redefined-designs/backend/tests/integration/schemaMirror.integration.test.ts

import { readFileSync } from 'fs';
import path from 'path';
import { pool } from '../../src/db';
import { closeDb } from './setup/testDb';

afterAll(async () => {
  await pool.end();
  await closeDb();
});

const SCHEMA = readFileSync(
  path.join(__dirname, '..', '..', 'src', 'db-kysely', 'schema.ts'),
  'utf8'
);

/**
 * Every table name the generated mirror declares.
 *
 * Read from the `DB` interface, which is the one place kysely-codegen lists
 * them all, mapping the database's own snake_case name to the interface for
 * that table. Parsing the file as text rather than importing it is deliberate
 * and unchanged from the Drizzle version: these are TypeScript types, erased at
 * run time, so there is nothing to import and inspect.
 */
function mirroredTables(): string[] {
  const block = /export interface DB \{([^}]*)\}/.exec(SCHEMA)?.[1] ?? '';
  return [...block.matchAll(/^\s*([a-z0-9_]+):/gm)].map((m) => m[1]!).sort();
}

async function liveTables(): Promise<string[]> {
  const { rows } = await pool.query<{ table_name: string }>(
    `SELECT table_name FROM information_schema.tables
     WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
       AND table_name <> 'pgmigrations'
     ORDER BY table_name`
  );
  return rows.map((r) => r.table_name);
}

/**
 * The guard for #217.
 *
 * `src/db-kysely/schema.ts` is generated by `npm run db:types` and is a
 * read-only mirror of the real schema, which `backend/migrations` owns. Nothing
 * makes anyone regenerate after writing a migration, and that is not
 * hypothetical: the mirror sat missing `item_drafts` and `upload_links` from
 * the moment #222 landed until #217, because it had been copied into src/ by
 * hand and nobody had reason to look at it.
 *
 * A stale mirror is worse than no mirror. Row types are inferred from it, so a
 * converted query would type-check against a schema the database does not have
 * and fail at run time with a column that does not exist — the exact class of
 * drift the adoption was meant to close.
 *
 * The generator changed in #305 and this test did not, because the drift it
 * guards is a property of generating a mirror at all rather than of any
 * library.
 */
describe('the generated schema mirror', () => {
  it('declares every table the migrations create', async () => {
    const live = await liveTables();
    const mirrored = mirroredTables();

    const missing = live.filter((name) => !mirrored.includes(name));
    expect(missing).toEqual([]);
  });

  it('declares no table the database does not have', async () => {
    const live = await liveTables();
    const mirrored = mirroredTables();

    const extra = mirrored.filter((name) => !live.includes(name));
    expect(extra).toEqual([]);
  });

  // pgmigrations is node-pg-migrate's bookkeeping, excluded by
  // --exclude-pattern in the db:types script. A regeneration without that flag
  // would quietly put it back.
  it('excludes node-pg-migrate bookkeeping', () => {
    expect(mirroredTables()).not.toContain('pgmigrations');
  });

  // Columns, not just tables: a migration that adds a column to a table the
  // mirror already knows about is the likelier drift, and the one a table-level
  // check would wave through.
  //
  // One exact match, where the Drizzle version needed two and called itself
  // "deliberately loose" for it. kysely-codegen emits the database's own name
  // as a bare interface key, so `  column_name:` at the start of a line is the
  // whole of the naming rule and there is nothing to re-implement.
  it('declares every column of every table it mirrors', async () => {
    const { rows } = await pool.query<{ table_name: string; column_name: string }>(
      `SELECT table_name, column_name FROM information_schema.columns
       WHERE table_schema = 'public' AND table_name <> 'pgmigrations'
       ORDER BY table_name, column_name`
    );

    const declared = new Set(
      [...SCHEMA.matchAll(/^\s{2}([a-z0-9_]+):/gm)].map((m) => m[1]!)
    );
    const missing = rows
      .filter((row) => !declared.has(row.column_name))
      .map((row) => `${row.table_name}.${row.column_name}`);

    expect(missing).toEqual([]);
  });
});