fix(db): retire file size bridge before forced schema push

Author: Sg312

.github/workflows/test-build.yml

@@ -83,6 +83,12 @@ jobs:
       - name: Install dependencies
         run: bun install --frozen-lockfile --ignore-scripts
 
+      - name: Verify direct schema push compatibility
+        working-directory: packages/db
+        env:
+          DB_PUSH_TEST_DATABASE_URL: postgresql://postgres:postgres@127.0.0.1:5432/postgres
+        run: bunx vitest run scripts/push.postgres.test.ts
+
       - name: Provision a fresh database through the supported command
         working-directory: packages/db
         run: |

packages/db/scripts/prepare-push.ts

@@ -0,0 +1,40 @@
+import { createLogger } from '@sim/logger'
+import postgres, { type Sql } from 'postgres'
+
+/**
+ * Direct schema push does not run versioned SQL migrations. Retire the known
+ * size compatibility bridge atomically with its column, preserving canonical
+ * bigint values and backfilling legacy-only rows before Drizzle inspects them.
+ * Only the explicitly forced push path invokes this preparation; ordinary
+ * migrations continue to use the guarded release cutover in migration 0348.
+ */
+export async function prepareForcedPush(sql: Sql): Promise<void> {
+  await sql.begin(async (tx) => {
+    await tx`SET LOCAL lock_timeout = '5s'`
+    const columns = await tx<{ attname: string }[]>`
+      SELECT attname FROM pg_attribute
+      WHERE attrelid = to_regclass('public.workspace_files')
+        AND attname IN ('size', 'size_bytes') AND NOT attisdropped
+    `
+    if (!columns.some((column) => column.attname === 'size')) return
+
+    await tx`LOCK TABLE public.workspace_files IN ACCESS EXCLUSIVE MODE`
+    await tx`ALTER TABLE public.workspace_files ADD COLUMN IF NOT EXISTS size_bytes bigint`
+    await tx`UPDATE public.workspace_files SET size_bytes = size WHERE size_bytes IS NULL`
+    await tx`DROP TRIGGER IF EXISTS workspace_files_sync_size_columns ON public.workspace_files`
+    await tx`DROP FUNCTION IF EXISTS public.sync_workspace_file_size_columns()`
+    await tx`ALTER TABLE public.workspace_files DROP COLUMN size`
+  })
+}
+
+if (import.meta.main) {
+  const url = process.env.DATABASE_URL
+  if (!url) throw new Error('Missing DATABASE_URL')
+  const sql = postgres(url, { max: 1, connect_timeout: 10 })
+  try {
+    await prepareForcedPush(sql)
+    createLogger('DatabasePush').info('Forced push compatibility preparation completed')
+  } finally {
+    await sql.end()
+  }
+}

packages/db/scripts/push.postgres.test.ts

@@ -1,7 +1,8 @@
 import { spawnSync } from 'node:child_process'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { prepareForcedPush } from '@sim/db/scripts/prepare-push'
 import { generateId } from '@sim/utils/id'
 import postgres, { type Sql } from 'postgres'
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
@@ -54,7 +55,7 @@ describe.skipIf(!databaseUrl)('patched Drizzle push against PostgreSQL', () => {
   async function schema(source: string) {
     await writeFile(
       join(directory, 'schema.ts'),
-      `import { pgTable, pgSchema, pgEnum, text, integer, boolean, check } from ${JSON.stringify(import.meta.resolve('drizzle-orm/pg-core'))}
+      `import { pgTable, pgSchema, pgEnum, text, integer, bigint, boolean, check } from ${JSON.stringify(import.meta.resolve('drizzle-orm/pg-core'))}
 import { sql } from ${JSON.stringify(import.meta.resolve('drizzle-orm'))}
 ${source}`
     )
@@ -90,6 +91,58 @@ ${source}`
 })`)
   }
 
+  it('retires the legacy size bridge without losing bigint or unbackfilled values', async () => {
+    await sql`CREATE TABLE workspace_files (id text PRIMARY KEY, size integer NOT NULL, size_bytes bigint)`
+    await sql`INSERT INTO workspace_files VALUES ('legacy', 123, NULL), ('large', 2147483647, 5000000000)`
+    await sql.unsafe(
+      await readFile(
+        new URL('../migrations/0308_workspace_file_size_cutover.sql', import.meta.url),
+        'utf8'
+      )
+    )
+    await prepareForcedPush(sql)
+    await prepareForcedPush(sql)
+    await schema(`export const files = pgTable('workspace_files', {
+      id: text('id').primaryKey(), sizeBytes: bigint('size_bytes', { mode: 'number' }),
+    })`)
+    const result = push()
+    expect(result.status, result.stdout + result.stderr).toBe(0)
+    expect(await sql`SELECT id, size_bytes::text FROM workspace_files ORDER BY id`).toEqual([
+      { id: 'large', size_bytes: '5000000000' },
+      { id: 'legacy', size_bytes: '123' },
+    ])
+    expect(
+      await sql`SELECT to_regprocedure('sync_workspace_file_size_columns()') AS bridge`
+    ).toEqual([{ bridge: null }])
+  }, 30_000)
+
+  it('rolls back preparation instead of cascading unknown dependencies', async () => {
+    await sql`CREATE TABLE workspace_files (id text PRIMARY KEY, size integer NOT NULL, size_bytes bigint)`
+    await sql`INSERT INTO workspace_files VALUES ('legacy', 123, NULL)`
+    await sql.unsafe(
+      await readFile(
+        new URL('../migrations/0308_workspace_file_size_cutover.sql', import.meta.url),
+        'utf8'
+      )
+    )
+    await sql`CREATE VIEW retained_sizes AS SELECT size FROM workspace_files`
+    await expect(prepareForcedPush(sql)).rejects.toThrow('depend')
+    expect(await sql`SELECT size, size_bytes FROM workspace_files`).toEqual([
+      { size: 123, size_bytes: null },
+    ])
+    expect(
+      await sql`SELECT tgname FROM pg_trigger WHERE tgrelid = 'workspace_files'::regclass AND NOT tgisinternal`
+    ).toEqual([{ tgname: 'workspace_files_sync_size_columns' }])
+  })
+
+  it('prepares both fresh databases and legacy schemas without the new column', async () => {
+    await prepareForcedPush(sql)
+    await sql`CREATE TABLE workspace_files (id text PRIMARY KEY, size integer NOT NULL)`
+    await sql`INSERT INTO workspace_files VALUES ('legacy', 456)`
+    await prepareForcedPush(sql)
+    expect(await sql`SELECT * FROM workspace_files`).toEqual([{ id: 'legacy', size_bytes: '456' }])
+  })
+
   it('initializes a fresh database', async () => {
     await schema(`export const records = pgTable('records', {
   id: text('id').primaryKey(), enabled: boolean('enabled').notNull().default(false),

packages/db/scripts/push.test.ts

@@ -38,18 +38,26 @@ describe('db:push policy and process boundaries', () => {
   it('sets create/drop only on the Drizzle child and forwards force independently', async () => {
     vi.stubEnv('SIM_DB_PUSH_RENAME_MODE', undefined)
     expect(await runPush(['--force'])).toBe(0)
-    expect(spawn).toHaveBeenCalledTimes(4)
-    expect(spawn.mock.calls[0][0]).toEqual([
+    expect(spawn).toHaveBeenCalledTimes(5)
+    expect(spawn.mock.calls[0][0]).toContain('./scripts/prepare-push.ts')
+    expect(spawn.mock.calls[1][0]).toEqual([
       'bunx',
       '--no-install',
       'drizzle-kit',
       'push',
       '--config=./drizzle.config.ts',
       '--force',
     ])
-    expect(spawn.mock.calls[0][1].env?.SIM_DB_PUSH_RENAME_MODE).toBe('create')
+    expect(spawn.mock.calls[1][1].env?.SIM_DB_PUSH_RENAME_MODE).toBe('create')
     expect(process.env.SIM_DB_PUSH_RENAME_MODE).toBeUndefined()
-    for (const [, options] of spawn.mock.calls.slice(1)) expect(options.env).toBeUndefined()
+    for (const [, options] of [spawn.mock.calls[0], ...spawn.mock.calls.slice(2)])
+      expect(options.env).toBeUndefined()
+  })
+
+  it('does not start Drizzle when compatibility preparation fails', async () => {
+    spawn.mockReturnValueOnce({ exited: Promise.resolve(44) })
+    expect(await runPush(['--force'])).toBe(44)
+    expect(spawn).toHaveBeenCalledTimes(1)
   })
 
   it('does not implicitly approve data loss', async () => {
@@ -58,9 +66,10 @@ describe('db:push policy and process boundaries', () => {
   })
 
   it('stops reconciliation when Drizzle fails', async () => {
+    spawn.mockReturnValueOnce({ exited: Promise.resolve(0) })
     spawn.mockReturnValueOnce({ exited: Promise.resolve(42) })
     expect(await runPush(['--force'])).toBe(42)
-    expect(spawn).toHaveBeenCalledTimes(1)
+    expect(spawn).toHaveBeenCalledTimes(2)
   })
 
   it('stops after the first failed reconciliation', async () => {

packages/db/scripts/push.ts

@@ -26,6 +26,16 @@ export async function runPush(args: string[]): Promise<number> {
     return 1
   }
 
+  if (!help && args.includes('--force')) {
+    const preparation = Bun.spawn(['bun', '--env-file=.env', 'run', './scripts/prepare-push.ts'], {
+      stdin: 'inherit',
+      stdout: 'inherit',
+      stderr: 'inherit',
+    })
+    const preparationExit = await preparation.exited
+    if (preparationExit !== 0) return preparationExit
+  }
+
   const pushArgs = args.filter((arg) => arg !== '--interactive-renames')
   const child = Bun.spawn(
     ['bunx', '--no-install', 'drizzle-kit', 'push', '--config=./drizzle.config.ts', ...pushArgs],