Chuyển tới nội dung chính

FF RESTaurent — Database Migration Playbook

Render PostgreSQL → Google Cloud SQL for PostgreSQL​

ghi chú

This database migration was successfully completed on July 25, 2026. For the historical record of how the migration was actually executed, please refer to the GCP Migration Timeline document. This playbook is preserved for historical context and as a reference for future migrations.


Table of Contents​

  1. Current Database Inventory
  2. Migration Strategy Decision
  3. Cloud SQL Instance Provisioning
  4. Pre-Migration Preparation
  5. Migration Execution
  6. Post-Migration Verification
  7. Cutover & Connection Switchover
  8. Rollback Procedure
  9. Ongoing Operations on Cloud SQL

1. Current Database Inventory​

1.1 Schema Overview​

The database is defined in apps/api/prisma/schema.prisma and managed exclusively through Prisma ORM.

CategoryCountDetails
Enums7ChefRole, SystemRole, PasswordResetStatus, EntryStatus, PaymentStatus, AdjustmentAllocation, RestaurantPlatform, CollectionSystemType
Models (Tables)20See model inventory below
Composite Indexes30+Performance indexes on all query-hot paths
Unique Constraints12+Including User.username, User.phone, User.systemRole, Cuisine.nameKey, etc.

1.2 Model Inventory​

ModelPrimary KeyNotable Constraints
Userid (CUID)username UNIQUE, phone UNIQUE (nullable), systemRole UNIQUE (singleton ROOT_ADMIN)
PasswordResetRequestid (CUID)activeKey UNIQUE, indexes on [status, createdAt], [userId, createdAt]
RootAdminTransferAuditid (CUID)—
RestaurantEntryid (CUID)Indexes on [diningAreaId], [status, createdAt, id], [createdById, createdAt, id]
Cuisineid (CUID)nameKey UNIQUE
RestaurantCuisine[restaurantId, cuisineId]Composite PK, index on [cuisineId]
DiningAreaid (CUID)normalizedKey UNIQUE
RestaurantPlatformLinkid (CUID)UNIQUE on [restaurantId, url], [restaurantId, sortOrder]
Billid (CUID)Indexes on [createdById, duplicateFingerprint, status], [status, createdAt, id], etc.
PaymentQrImageid (CUID)storagePath UNIQUE, index on [ownerId, status, createdAt, id]
BillParticipant[billId, memberId]Composite PK, indexes on [memberId, paymentStatus, billId]
Feedbackid (CUID)UNIQUE on [billId, userId], Decimal(3,1) ratings
ParticipantGroupid (CUID)UNIQUE on [ownerId, name]
ParticipantGroupMember[groupId, userId]Composite PK
Notificationid (CUID)Indexes on [userId, createdAt, id], [userId, readAt], [billId, userId, createdAt]
RoleAuditLogid (CUID)—
BillAuditLogid (CUID)Index on [billId, createdAt, id]
Collectionid (CUID)Indexes on [ownerId, createdAt], [isPublic, createdAt]
CollectionShare[collectionId, userId]Composite PK
CollectionRestaurant[collectionId, restaurantId]Composite PK

1.3 Prisma Migration History​

The project has 17 applied migrations under apps/api/prisma/migrations/:

#Migration NamePurpose
120260708000000_initInitial schema: User, Bill, BillParticipant, RestaurantEntry, Notification, RoleAuditLog, BillAuditLog
220260709000000_rename_cents_add_featuresRename monetary columns, add features
320260711000000_add_payment_urlAdd paymentUrl to Bill
420260715133000_root_admin_governanceSystemRole enum, RootAdminTransferAudit, singleton UNIQUE constraint
520260715170000_password_reset_requestsPasswordResetRequest model and related enums
620260715190000_add_structured_restaurant_addressStructured address fields on RestaurantEntry
720260715220000_enrich_restaurant_profilesBanner images, phone, avatarUrl on restaurants
820260715233000_add_cuisine_dining_area_catalogsCuisine, DiningArea, RestaurantCuisine models
920260715235500_add_shareable_collectionsCollection, CollectionShare, CollectionRestaurant models
1020260716003000_add_restaurant_feedbackFeedback model with Decimal ratings
1120260716010000_add_notification_groups_duplicate_protectionParticipantGroup, ParticipantGroupMember, duplicate fingerprint
1220260716020000_add_search_pagination_indexessearchText fields and pagination indexes
1320260716030000_add_final_query_indexesNotification and BillAuditLog performance indexes
1420260716171458_drop_indexesDrop redundant/superseded indexes
1520260717090000_add_adjustment_allocationAdjustmentAllocation enum on Bill
1620260719090000_add_media_and_payment_qrPaymentQrImage model, Supabase storage integration
1720260720000000_contract_phase2_normalized_restaurantsPhase 2 contract: drop legacy columns/tables

1.4 Seed & Backfill Scripts​

These scripts run as part of the container startup sequence in docker-compose.yml and apps/api/Dockerfile:

ScriptFileBehaviorProduction Safe?
Demo seedprisma/seed-if-empty.tsSeeds demo users/restaurants/bills if DB is empty. Throws in production.❌ Never
Cuisine catalog seedprisma/seed-popular-cuisines.tsIdempotent upsert of popular Vietnamese cuisines✅ Yes
Phone backfillprisma/backfill-user-phones.tsNormalizes existing phone numbers to canonical E.164. Validates before applying.✅ Yes
ROOT_ADMIN bootstrapprisma/bootstrap-root-admin.tsPromotes ROOT_ADMIN_USERNAME to ROOT_ADMIN if none exists. Race-condition safe (P2002 catch).✅ Yes
ROOT_ADMIN recoveryprisma/recover-root-admin.tsInteractive TTY script for emergency password reset. Not automated.🔧 Manual only

1.5 Verification Scripts​

ScriptFilePurpose
Index verificationprisma/verify-final-query-indexes.tsConfirms 4 critical query indexes exist and are used by EXPLAIN plans
Phase 2 contract verificationprisma/verify-phase2-contract.tsValidates normalized restaurants, cuisines, collections, and legacy column removal
Backup restore drillscripts/backup-restore-drill.shWeekly pg_dump + pg_restore round-trip with row-count validation

2. Migration Strategy Decision​

Approach: Full Logical Dump & Restore​

We use pg_dump / pg_restore (custom format) for the data transfer. This is the correct approach because:

  1. Render does not expose physical replication — logical replication or streaming replication is not available on Render's managed PostgreSQL.
  2. Dataset size is small — this is a team-internal bill-splitting app; the data volume is well within logical dump/restore performance limits.
  3. Prisma migration state must be preserved — the _prisma_migrations table must transfer intact so that prisma migrate deploy on Cloud SQL recognizes all 17 migrations as already applied.
  4. Existing tooling — the project already has a tested scripts/backup-restore-drill.sh that performs exactly this round-trip and validates row counts.

Migration Window​

WARNING: Downtime required. Because we cannot set up real-time replication between Render and Cloud SQL, there will be a write-freeze window during which:

  1. The Render API is stopped (or put in read-only mode).
  2. A final dump is taken.
  3. The dump is restored to Cloud SQL.
  4. The Cloud Run API is brought online pointing to Cloud SQL.

Estimated window: 15–30 minutes for a small dataset.


3. Cloud SQL Instance Provisioning​

3.1 Create the Instance​

# Set project context
gcloud config set project ff-restaurent-prod

# Create Cloud SQL instance
gcloud sql instances create ff-restaurent-db \
--database-version=POSTGRES_16 \
--tier=db-f1-micro \
--region=asia-east1 \
--storage-size=10GB \
--storage-auto-increase \
--backup-start-time=03:00 \
--availability-type=zonal \
--maintenance-window-day=SUN \
--maintenance-window-hour=4 \
--database-flags=log_min_duration_statement=1000 \
--deletion-protection

3.2 Create the Database and User​

# Create the application database
gcloud sql databases create ff_restaurent \
--instance=ff-restaurent-db \
--charset=UTF8

# Create the application user
gcloud sql users create ff \
--instance=ff-restaurent-db \
--password="$(openssl rand -base64 32)"

IMPORTANT: Record the generated password securely. This will be used in the DATABASE_URL stored in GCP Secret Manager.

3.3 Network & Connectivity​

Cloud Run connects to Cloud SQL via the Cloud SQL Auth Proxy sidecar (built into Cloud Run's --add-cloudsql-instances flag). This means:

  • No public IP required on Cloud SQL — use private IP or the Auth Proxy socket.
  • No VPC connector required for basic setups.
  • SSL is enforced transparently by the Auth Proxy.
# Get the Cloud SQL connection name (needed for Cloud Run)
gcloud sql instances describe ff-restaurent-db --format='value(connectionName)'
# Output: ff-restaurent-prod:asia-east1:ff-restaurent-db

The DATABASE_URL for Cloud Run with Auth Proxy uses Unix socket format:

postgresql://ff:<PASSWORD>@localhost/ff_restaurent?host=/cloudsql/ff-restaurent-prod:asia-east1:ff-restaurent-db&schema=public

Or, for direct connection (if public IP is enabled temporarily for the initial data import):

postgresql://ff:<PASSWORD>@<CLOUD_SQL_PUBLIC_IP>:5432/ff_restaurent?schema=public&sslmode=require

4. Pre-Migration Preparation​

4.1 Pre-Flight Checklist​

  • Cloud SQL instance is running and accessible.
  • Application user ff is created with the correct password.
  • Database ff_restaurent exists on the Cloud SQL instance.
  • pg_dump (v16+) and pg_restore (v16+) are installed on the operator machine.
  • Render database credentials are available (DATABASE_URL from Render dashboard).
  • GCP Secret Manager secrets are created (placeholder values OK at this stage).
  • Cloud Run API service is not yet deployed or is pointing to the old database.
  • A communication plan is sent to all team members about the maintenance window.

4.2 Take a Pre-Migration Backup on Render​

Before touching anything, capture a full backup and row counts from the current production database:

# Export environment
export RENDER_DB_URL="postgresql://<USER>:<PASS>@<RENDER_HOST>:5432/ff_restaurent"

# Full custom-format dump
pg_dump "$RENDER_DB_URL" \
--format=custom \
--no-owner \
--no-acl \
--verbose \
--file=ff_restaurent_pre_migration.dump

# Capture row counts for every table (for later verification)
psql "$RENDER_DB_URL" --no-align --tuples-only --quiet <<'SQL' > source_row_counts.txt
SELECT format(
'SELECT %L AS table_name, COUNT(*)::bigint AS row_count FROM %I.%I',
tablename, schemaname, tablename
)
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY tablename
\gexec
SQL

echo "=== Source row counts ==="
cat source_row_counts.txt

4.3 Validate Prisma Migration State on Render​

Confirm that all 17 migrations have been applied and none are rolled back:

psql "$RENDER_DB_URL" --set ON_ERROR_STOP=1 <<'SQL'
SELECT migration_name, finished_at, rolled_back_at
FROM "_prisma_migrations"
ORDER BY started_at;

SELECT COUNT(*) AS total_applied
FROM "_prisma_migrations"
WHERE finished_at IS NOT NULL AND rolled_back_at IS NULL;
SQL

CAUTION: Expected output: 17 applied migrations, all with finished_at IS NOT NULL and rolled_back_at IS NULL. If any migration is incomplete or rolled back, resolve this on Render before proceeding.

4.4 Run Existing Verification Scripts Against Render​

# From repository root, with DATABASE_URL pointing to Render
export DATABASE_URL="$RENDER_DB_URL"

# Verify indexes are present and used
npm run prisma:indexes:verify -w @ff-restaurent/api

# Verify Phase 2 contract
npm run prisma:phase2:contract:verify -w @ff-restaurent/api

Both scripts must pass cleanly. Their outputs serve as the baseline for post-migration comparison.


5. Migration Execution​

5.1 Enter Maintenance Window​

Step 1: Stop Render API writes.

Suspend or scale down the Render API service from the Render dashboard. This prevents any new writes during the dump.

Step 2: Take the final production dump.

# Final dump (during write-freeze)
pg_dump "$RENDER_DB_URL" \
--format=custom \
--no-owner \
--no-acl \
--verbose \
--file=ff_restaurent_final.dump

# Final row counts
psql "$RENDER_DB_URL" --no-align --tuples-only --quiet <<'SQL' > source_final_counts.txt
SELECT format(
'SELECT %L AS table_name, COUNT(*)::bigint AS row_count FROM %I.%I',
tablename, schemaname, tablename
)
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY tablename
\gexec
SQL

5.2 Import Into Cloud SQL​

Option A: Direct connection (temporary public IP)

# Enable public IP temporarily for import
gcloud sql instances patch ff-restaurent-db \
--assign-ip

export CLOUD_SQL_URL="postgresql://ff:<PASSWORD>@<CLOUD_SQL_IP>:5432/ff_restaurent?sslmode=require"

# Clean the target database
psql "$CLOUD_SQL_URL" --set ON_ERROR_STOP=1 <<'SQL'
DROP SCHEMA IF EXISTS public CASCADE;
CREATE SCHEMA public;
SQL

# Restore the dump
pg_restore \
--no-owner \
--no-acl \
--exit-on-error \
--verbose \
--dbname="$CLOUD_SQL_URL" \
ff_restaurent_final.dump

Option B: Cloud SQL Auth Proxy (no public IP)

# Start the Cloud SQL Auth Proxy in a separate terminal
cloud-sql-proxy ff-restaurent-prod:asia-east1:ff-restaurent-db \
--port=5433

# In the main terminal
export CLOUD_SQL_URL="postgresql://ff:<PASSWORD>@127.0.0.1:5433/ff_restaurent?schema=public"

psql "$CLOUD_SQL_URL" --set ON_ERROR_STOP=1 <<'SQL'
DROP SCHEMA IF EXISTS public CASCADE;
CREATE SCHEMA public;
SQL

pg_restore \
--no-owner \
--no-acl \
--exit-on-error \
--verbose \
--dbname="$CLOUD_SQL_URL" \
ff_restaurent_final.dump

Step 3: Disable public IP after import (if Option A was used).

gcloud sql instances patch ff-restaurent-db \
--no-assign-ip

6. Post-Migration Verification​

6.1 Row Count Comparison​

# Capture restored row counts
psql "$CLOUD_SQL_URL" --no-align --tuples-only --quiet <<'SQL' > restored_counts.txt
SELECT format(
'SELECT %L AS table_name, COUNT(*)::bigint AS row_count FROM %I.%I',
tablename, schemaname, tablename
)
FROM pg_tables
WHERE schemaname = 'public'
ORDER BY tablename
\gexec
SQL

# Compare
diff --unified source_final_counts.txt restored_counts.txt

CAUTION: The diff must be empty. Any row count discrepancy means data was lost during restore. Do not proceed until resolved.

6.2 Prisma Migration State​

psql "$CLOUD_SQL_URL" --set ON_ERROR_STOP=1 <<'SQL'
-- Must show 17 successfully applied migrations
SELECT migration_name, finished_at, rolled_back_at
FROM "_prisma_migrations"
ORDER BY started_at;

SELECT COUNT(*) AS total_applied
FROM "_prisma_migrations"
WHERE finished_at IS NOT NULL AND rolled_back_at IS NULL;
SQL

6.3 Run Verification Scripts Against Cloud SQL​

export DATABASE_URL="$CLOUD_SQL_URL"

# Index verification
npm run prisma:indexes:verify -w @ff-restaurent/api
# Expected: "FF-27 index coverage: 4/4"

# Phase 2 contract verification
npm run prisma:phase2:contract:verify -w @ff-restaurent/api
# Expected: "passed": true

6.4 Data Integrity Spot Checks​

psql "$CLOUD_SQL_URL" --set ON_ERROR_STOP=1 <<'SQL'
-- Exactly one ROOT_ADMIN exists
SELECT COUNT(*) AS root_admin_count FROM "User" WHERE "systemRole" = 'ROOT_ADMIN';

-- All restaurants have exactly one primary cuisine
SELECT r.id, r.name, COUNT(rc."cuisineId") AS primary_count
FROM "RestaurantEntry" r
LEFT JOIN "RestaurantCuisine" rc ON rc."restaurantId" = r.id AND rc."isPrimary" = true
GROUP BY r.id, r.name
HAVING COUNT(rc."cuisineId") <> 1;
-- Expected: 0 rows

-- All monetary values are non-negative integers
SELECT COUNT(*) AS negative_costs
FROM "Bill"
WHERE "baseCost" < 0 OR "vat" < 0 OR "shippingFee" < 0 OR "totalCost" < 0;
-- Expected: 0

-- No orphaned participants
SELECT bp."billId", bp."memberId"
FROM "BillParticipant" bp
LEFT JOIN "Bill" b ON b.id = bp."billId"
LEFT JOIN "User" u ON u.id = bp."memberId"
WHERE b.id IS NULL OR u.id IS NULL;
-- Expected: 0 rows

-- Exactly one global Recommended collection
SELECT COUNT(*) FROM "Collection" WHERE "systemType" = 'RECOMMENDED';
-- Expected: 1

-- Enum values are valid
SELECT DISTINCT "chefRole" FROM "User" WHERE "chefRole" IS NOT NULL;
-- Expected: only 'SOUS_CHEF', 'HEAD_CHEF'

SELECT DISTINCT "status" FROM "Bill";
-- Expected: only 'ACTIVE', 'ARCHIVED'
SQL

6.5 Full Verification Summary​

  • Row counts match between Render dump and Cloud SQL restore.
  • 17 Prisma migrations present, all with finished_at, no rolled_back_at.
  • Index verification passes (4/4).
  • Phase 2 contract verification passes.
  • Exactly 1 ROOT_ADMIN user exists.
  • All restaurants have exactly 1 primary cuisine.
  • No negative monetary values.
  • No orphaned bill participants.
  • Exactly 1 Recommended collection.
  • Enum values are within expected domains.

7. Cutover & Connection Switchover​

7.1 Update DATABASE_URL in GCP Secret Manager​

# Construct the Cloud Run Auth Proxy connection string
CLOUD_SQL_CONN="ff-restaurent-prod:asia-east1:ff-restaurent-db"
NEW_DB_URL="postgresql://ff:<PASSWORD>@localhost/ff_restaurent?host=/cloudsql/${CLOUD_SQL_CONN}&schema=public"

# Update the secret
echo -n "$NEW_DB_URL" | \
gcloud secrets versions add DATABASE_URL --data-file=-

7.2 Deploy Cloud Run API With Cloud SQL Connector​

gcloud run deploy ff-restaurent-api \
--image=asia-east1-docker.pkg.dev/ff-restaurent-prod/ff-restaurent/api:v1.1.0 \
--region=asia-east1 \
--platform=managed \
--port=4000 \
--add-cloudsql-instances=ff-restaurent-prod:asia-east1:ff-restaurent-db \
--set-secrets="DATABASE_URL=DATABASE_URL:latest,JWT_SECRET=JWT_SECRET:latest,REGISTRATION_INVITE_CODE=REGISTRATION_INVITE_CODE:latest,CORS_ORIGINS=CORS_ORIGINS:latest" \
--set-env-vars="NODE_ENV=production,ROOT_ADMIN_USERNAME=<USERNAME>,API_PORT=4000" \
--allow-unauthenticated

IMPORTANT: The --add-cloudsql-instances flag automatically mounts the Cloud SQL Auth Proxy as a sidecar. The DATABASE_URL must use the /cloudsql/CONNECTION_NAME socket path format shown above.

7.3 Run Idempotent Post-Deploy Scripts​

These are the same scripts that currently run at container startup. On Cloud Run, run them once as a Cloud Run Job or from a local terminal connected to Cloud SQL:

export DATABASE_URL="$NEW_DB_URL"

# 1. Apply any pending migrations (should be 0 if dump was clean)
npx prisma migrate deploy --schema apps/api/prisma/schema.prisma

# 2. Idempotent seeds and backfills
npm run prisma:cuisines:seed -w @ff-restaurent/api
npm run prisma:phones:backfill -w @ff-restaurent/api
npm run prisma:root:bootstrap -w @ff-restaurent/api

7.4 Smoke Test the Live API​

# Health check
curl -sf https://<CLOUD_RUN_API_URL>/health
# Expected: 200 OK

# Login test
curl -sf -X POST https://<CLOUD_RUN_API_URL>/api/auth/login \
-H 'Content-Type: application/json' \
-d '{"username":"<TEST_USER>","password":"<TEST_PASS>"}'
# Expected: 200 with JWT token

8. Rollback Procedure​

Scenario A: Pre-Cutover Rollback (Cloud Run not yet live)​

Simply discard the Cloud SQL data and keep Render running. No user impact.

# Restart Render API service from dashboard
# Delete Cloud SQL data if desired:
psql "$CLOUD_SQL_URL" --set ON_ERROR_STOP=1 -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"

Scenario B: Post-Cutover Rollback (Cloud Run is live, issues detected)​

# 1. Scale Cloud Run API to 0
gcloud run services update ff-restaurent-api --region=asia-east1 \
--max-instances=0

# 2. Restart Render API service from the Render dashboard

# 3. Update DNS back to Render endpoints

# 4. Verify Render API health
curl -sf https://<RENDER_API_URL>/health

WARNING: Any writes that occurred on Cloud SQL after cutover but before rollback will be lost unless manually reconciled. Minimize the rollback window.

Scenario C: Data Corruption on Cloud SQL​

# 1. Stop Cloud Run API
gcloud run services update ff-restaurent-api --region=asia-east1 --max-instances=0

# 2. Restore from the pre-migration dump or Cloud SQL automated backup
gcloud sql backups list --instance=ff-restaurent-db
gcloud sql backups restore <BACKUP_ID> --restore-instance=ff-restaurent-db

# 3. Re-verify with the verification suite
# 4. Redeploy Cloud Run API

9. Ongoing Operations on Cloud SQL​

9.1 Automated Backups​

Cloud SQL automated backups are configured at instance creation (--backup-start-time=03:00). Additionally:

  • Retention: Configure via gcloud sql instances patch --backup-retention-count=14.
  • Point-in-time recovery: Enable with gcloud sql instances patch --enable-point-in-time-recovery.

9.2 Adapt the Backup Restore Drill​

The existing backup-restore-drill.yml workflow uses DATABASE_URL to dump from production. After migration:

  1. Update the PRODUCTION_DATABASE_URL GitHub secret to the Cloud SQL connection string.
  2. Consider running the drill through the Cloud SQL Auth Proxy (add proxy setup step to the workflow).
  3. The drill script (scripts/backup-restore-drill.sh) needs no code changes — it is database-URL-agnostic.

9.3 Future Prisma Migrations on Cloud SQL​

IMPORTANT: Do not run migrations at container startup on Cloud Run. The current Dockerfile CMD (apps/api/Dockerfile line 24) runs npx prisma migrate deploy on boot. This is safe with a single container but dangerous when Cloud Run scales to multiple instances.

Recommended approach:

  1. Run prisma migrate deploy as a Cloud Run Job or a CI/CD pipeline step before deploying the new Cloud Run revision.
  2. Remove npx prisma migrate deploy from the Dockerfile CMD.
  3. The Dockerfile CMD should only run:
    CMD ["node", "dist/server.js"]

9.4 Monitoring & Alerts​

Set up Cloud SQL monitoring for:

MetricAlert ThresholdAction
CPU utilization> 80% sustained 5 minConsider upgrading tier
Memory utilization> 90% sustained 5 minConsider upgrading tier
Storage utilization> 80%Verify auto-increase is on
Connection count> 80% of maxCheck for connection leaks
Replication lag> 30s (if HA)Investigate Cloud SQL health
# View current metrics
gcloud sql instances describe ff-restaurent-db \
--format='table(settings.tier, settings.dataDiskSizeGb, state)'

9.5 Cost Optimization​

ScenarioRecommendation
Low traffic / developmentKeep db-f1-micro (~$9/month)
Growing trafficUpgrade to db-g1-small (~$26/month)
High availability neededAdd --availability-type=regional (doubles cost)
Automated backups storageFirst 7 backups free; each additional ~$0.08/GB/month

Appendix A: Quick Reference Commands​

# ---- Cloud SQL ----
# Connect interactively
gcloud sql connect ff-restaurent-db --user=ff --database=ff_restaurent

# List backups
gcloud sql backups list --instance=ff-restaurent-db

# Manual backup
gcloud sql backups create --instance=ff-restaurent-db --description="Pre-release backup"

# ---- Prisma ----
# Apply pending migrations (run BEFORE deploying new API revision)
DATABASE_URL="<CLOUD_SQL_URL>" npx prisma migrate deploy --schema apps/api/prisma/schema.prisma

# Check migration status
DATABASE_URL="<CLOUD_SQL_URL>" npx prisma migrate status --schema apps/api/prisma/schema.prisma

# ---- Verification ----
DATABASE_URL="<CLOUD_SQL_URL>" npm run prisma:indexes:verify -w @ff-restaurent/api
DATABASE_URL="<CLOUD_SQL_URL>" npm run prisma:phase2:contract:verify -w @ff-restaurent/api