@apso/cli 0.30.0 → 0.32.0

package/dist/lib/import/copy-data.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Database Import — data copy (phase 2)
+ *
+ * Plans and executes a row copy from a source Postgres/Supabase database into a
+ * target database that was rebuilt from the imported schema (phase 1). The
+ * planning logic is pure and fully unit-testable; the actual reads/writes go
+ * through the injectable `SourceReader` / `TargetWriter` interfaces so the
+ * executor can be tested with fakes (mirroring phase 1's `Introspector`).
+ *
+ * Mapping rules mirror phase 1 exactly:
+ *  - target table name  = snakeCase(entity name) = snakeCase(source table name)
+ *  - single-column FK   = renamed to the platform's camelCase `<ref>Id`
+ *  - every other column = copied under its original name
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targetColumnsFromSchema = exports.executeCopy = exports.buildInsertSql = exports.coerceValue = exports.planCopy = exports.topoSortTables = exports.buildColumnMapping = exports.targetTableName = void 0;
+const casing_1 = require("../utils/casing");
+const relationships_1 = require("../utils/relationships");
+const pg_to_apsorc_1 = require("./pg-to-apsorc");
+const INTEGER_PK_UDTS = new Set(["int2", "int4", "int8"]);
+/** The target table name the generator produces for a given source table. */
+function targetTableName(sourceTable) {
+    return (0, casing_1.snakeCase)(sourceTable);
+}
+exports.targetTableName = targetTableName;
+/** Map every source column to its target column name (FK rename or identity). */
+function buildColumnMapping(table) {
+    const fkRefByColumn = new Map();
+    for (const fk of table.foreignKeys) {
+        if (fk.columns.length === 1) {
+            fkRefByColumn.set(fk.columns[0], fk.referencedTable);
+        }
+    }
+    return [...table.columns]
+        .sort((a, b) => a.ordinal - b.ordinal)
+        .map((col) => {
+        const refTable = fkRefByColumn.get(col.name);
+        if (refTable) {
+            const { toName } = (0, pg_to_apsorc_1.deriveToName)(col.name, refTable);
+            const targetColumn = (0, relationships_1.getRelationshipIdField)({
+                name: refTable,
+                type: "ManyToOne",
+                referenceName: toName,
+            });
+            return { sourceColumn: col.name, targetColumn };
+        }
+        return { sourceColumn: col.name, targetColumn: col.name };
+    });
+}
+exports.buildColumnMapping = buildColumnMapping;
+/**
+ * Order tables so each is copied after the tables it references via FK
+ * (parents before children). Self-references are ignored; tables in a cycle are
+ * reported and appended best-effort at the end.
+ */
+function topoSortTables(tables) {
+    const names = new Set(tables.map((t) => t.name));
+    const deps = new Map();
+    for (const t of tables) {
+        const d = new Set();
+        for (const fk of t.foreignKeys) {
+            if (fk.referencedTable !== t.name && names.has(fk.referencedTable)) {
+                d.add(fk.referencedTable);
+            }
+        }
+        deps.set(t.name, d);
+    }
+    const order = [];
+    const visited = new Set();
+    let progress = true;
+    while (order.length < tables.length && progress) {
+        progress = false;
+        for (const t of tables) {
+            if (visited.has(t.name))
+                continue;
+            if ([...deps.get(t.name)].every((x) => visited.has(x))) {
+                order.push(t.name);
+                visited.add(t.name);
+                progress = true;
+            }
+        }
+    }
+    const cyclic = tables
+        .filter((t) => !visited.has(t.name))
+        .map((t) => t.name);
+    for (const c of cyclic)
+        order.push(c); // best-effort append
+    return { order, cyclic };
+}
+exports.topoSortTables = topoSortTables;
+/**
+ * Build a full copy plan from the source schema and the set of columns that
+ * actually exist in each target table. Source columns whose mapped target
+ * column is missing are dropped (and reported); source tables with no target
+ * table are skipped entirely.
+ */
+function planCopy(source, targetColumnsByTable, tableFilter) {
+    var _a;
+    const filter = tableFilter && tableFilter.length > 0 ? new Set(tableFilter) : null;
+    const consideredTables = source.tables.filter((t) => !filter || filter.has(t.name));
+    const { order, cyclic } = topoSortTables(consideredTables);
+    const byName = new Map(consideredTables.map((t) => [t.name, t]));
+    const tables = [];
+    const skippedColumns = [];
+    const missingTargetTables = [];
+    for (const sourceTable of order) {
+        const table = byName.get(sourceTable);
+        const targetTable = targetTableName(sourceTable);
+        const targetColumns = targetColumnsByTable.get(targetTable);
+        if (!targetColumns) {
+            missingTargetTables.push(sourceTable);
+            continue;
+        }
+        const mapping = buildColumnMapping(table);
+        const keptSource = [];
+        const keptTarget = [];
+        for (const m of mapping) {
+            if (targetColumns.has(m.targetColumn)) {
+                keptSource.push(m.sourceColumn);
+                keptTarget.push(m.targetColumn);
+            }
+            else {
+                skippedColumns.push({
+                    table: sourceTable,
+                    column: m.sourceColumn,
+                    reason: `target column "${m.targetColumn}" not found in ${targetTable}`,
+                });
+            }
+        }
+        // Determine ordering + serial PK handling from a single-column PK.
+        let orderBy = null;
+        let serialPkColumn = null;
+        if (table.primaryKey.length === 1) {
+            const pkCol = table.primaryKey[0];
+            orderBy = pkCol;
+            const pk = table.columns.find((c) => c.name === pkCol);
+            const targetPk = (_a = mapping.find((m) => m.sourceColumn === pkCol)) === null || _a === void 0 ? void 0 : _a.targetColumn;
+            if (pk && targetPk && INTEGER_PK_UDTS.has(pk.udtName)) {
+                serialPkColumn = targetPk;
+            }
+        }
+        tables.push({
+            sourceTable,
+            targetTable,
+            sourceColumns: keptSource,
+            targetColumns: keptTarget,
+            orderBy,
+            serialPkColumn,
+        });
+    }
+    return { tables, skippedColumns, missingTargetTables, cyclicTables: cyclic };
+}
+exports.planCopy = planCopy;
+/** Coerce a value read from pg into something safe to bind on insert. */
+function coerceValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Date)
+        return value;
+    if (Buffer.isBuffer(value))
+        return value;
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return value;
+}
+exports.coerceValue = coerceValue;
+/** Build a parameterized multi-row INSERT statement for a batch. */
+function buildInsertSql(table, columns, rows, schema) {
+    const tableRef = schema ? `"${schema}"."${table}"` : `"${table}"`;
+    const colList = columns.map((c) => `"${c}"`).join(", ");
+    const values = [];
+    const tuples = rows.map((row) => {
+        const placeholders = row.map((val) => {
+            values.push(coerceValue(val));
+            return `$${values.length}`;
+        });
+        return `(${placeholders.join(", ")})`;
+    });
+    return {
+        text: `INSERT INTO ${tableRef} (${colList}) VALUES ${tuples.join(", ")}`,
+        values,
+    };
+}
+exports.buildInsertSql = buildInsertSql;
+/**
+ * Execute a copy plan. Insert-only: if any target table already has rows the
+ * run aborts before writing anything. The whole copy runs in one transaction
+ * on the target, so a failure rolls everything back.
+ */
+async function executeCopy(plan, source, target, options = {}) {
+    var _a, _b;
+    const batchSize = (_a = options.batchSize) !== null && _a !== void 0 ? _a : 500;
+    const dryRun = (_b = options.dryRun) !== null && _b !== void 0 ? _b : false;
+    // Pre-flight: detect non-empty target tables.
+    const blockedTables = [];
+    for (const t of plan.tables) {
+        // eslint-disable-next-line no-await-in-loop
+        const count = await target.rowCount(t.targetTable);
+        if (count > 0)
+            blockedTables.push(t.targetTable);
+    }
+    const perTable = [];
+    if (dryRun) {
+        for (const t of plan.tables) {
+            // eslint-disable-next-line no-await-in-loop
+            const rows = await source.totalRows(t.sourceTable);
+            perTable.push({ table: t.targetTable, rows });
+        }
+        return {
+            dryRun: true,
+            perTable,
+            skippedColumns: plan.skippedColumns,
+            missingTargetTables: plan.missingTargetTables,
+            cyclicTables: plan.cyclicTables,
+            blockedTables,
+        };
+    }
+    if (blockedTables.length > 0) {
+        throw new Error(`Aborting: target table(s) already contain rows: ${blockedTables.join(", ")}. Use a fresh target or clear these tables first.`);
+    }
+    await target.begin();
+    try {
+        for (const t of plan.tables) {
+            let offset = 0;
+            let copied = 0;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                // eslint-disable-next-line no-await-in-loop
+                const rows = await source.readBatch(t.sourceTable, t.sourceColumns, t.orderBy, offset, batchSize);
+                if (rows.length === 0)
+                    break;
+                // eslint-disable-next-line no-await-in-loop
+                await target.insertBatch(t.targetTable, t.targetColumns, rows);
+                copied += rows.length;
+                offset += rows.length;
+                if (rows.length < batchSize)
+                    break;
+            }
+            if (t.serialPkColumn && copied > 0) {
+                // eslint-disable-next-line no-await-in-loop
+                await target.resetSequence(t.targetTable, t.serialPkColumn);
+            }
+            perTable.push({ table: t.targetTable, rows: copied });
+        }
+        await target.commit();
+    }
+    catch (error) {
+        await target.rollback();
+        throw error;
+    }
+    return {
+        dryRun: false,
+        perTable,
+        skippedColumns: plan.skippedColumns,
+        missingTargetTables: plan.missingTargetTables,
+        cyclicTables: plan.cyclicTables,
+        blockedTables,
+    };
+}
+exports.executeCopy = executeCopy;
+/** Build the target column lookup used by planCopy from an introspected target. */
+function targetColumnsFromSchema(target) {
+    return new Map(target.tables.map((t) => [t.name, new Set(t.columns.map((c) => c.name))]));
+}
+exports.targetColumnsFromSchema = targetColumnsFromSchema;

package/dist/lib/import/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export { pgToApsorc, findUnknownEmittedTypes } from "./pg-to-apsorc";
+export type { ApsorcImportOutput, ApsorcImportEntityOutput, ApsorcImportFieldOutput, ApsorcImportRelationshipOutput, } from "./pg-to-apsorc";
+export { PgIntrospector, redactConnectionString, buildSchema, SYSTEM_SCHEMAS } from "./introspect";
+export { planCopy, executeCopy, buildColumnMapping, topoSortTables, targetTableName, targetColumnsFromSchema, buildInsertSql, coerceValue, } from "./copy-data";
+export type { CopyPlan, CopyResult, TableCopyPlan, ColumnMapping, SourceReader, TargetWriter, ExecuteOptions, } from "./copy-data";
+export { PgSourceReader, PgTargetWriter } from "./pg-data";

package/dist/lib/import/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgTargetWriter = exports.PgSourceReader = exports.coerceValue = exports.buildInsertSql = exports.targetColumnsFromSchema = exports.targetTableName = exports.topoSortTables = exports.buildColumnMapping = exports.executeCopy = exports.planCopy = exports.SYSTEM_SCHEMAS = exports.buildSchema = exports.redactConnectionString = exports.PgIntrospector = exports.findUnknownEmittedTypes = exports.pgToApsorc = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+var pg_to_apsorc_1 = require("./pg-to-apsorc");
+Object.defineProperty(exports, "pgToApsorc", { enumerable: true, get: function () { return pg_to_apsorc_1.pgToApsorc; } });
+Object.defineProperty(exports, "findUnknownEmittedTypes", { enumerable: true, get: function () { return pg_to_apsorc_1.findUnknownEmittedTypes; } });
+var introspect_1 = require("./introspect");
+Object.defineProperty(exports, "PgIntrospector", { enumerable: true, get: function () { return introspect_1.PgIntrospector; } });
+Object.defineProperty(exports, "redactConnectionString", { enumerable: true, get: function () { return introspect_1.redactConnectionString; } });
+Object.defineProperty(exports, "buildSchema", { enumerable: true, get: function () { return introspect_1.buildSchema; } });
+Object.defineProperty(exports, "SYSTEM_SCHEMAS", { enumerable: true, get: function () { return introspect_1.SYSTEM_SCHEMAS; } });
+var copy_data_1 = require("./copy-data");
+Object.defineProperty(exports, "planCopy", { enumerable: true, get: function () { return copy_data_1.planCopy; } });
+Object.defineProperty(exports, "executeCopy", { enumerable: true, get: function () { return copy_data_1.executeCopy; } });
+Object.defineProperty(exports, "buildColumnMapping", { enumerable: true, get: function () { return copy_data_1.buildColumnMapping; } });
+Object.defineProperty(exports, "topoSortTables", { enumerable: true, get: function () { return copy_data_1.topoSortTables; } });
+Object.defineProperty(exports, "targetTableName", { enumerable: true, get: function () { return copy_data_1.targetTableName; } });
+Object.defineProperty(exports, "targetColumnsFromSchema", { enumerable: true, get: function () { return copy_data_1.targetColumnsFromSchema; } });
+Object.defineProperty(exports, "buildInsertSql", { enumerable: true, get: function () { return copy_data_1.buildInsertSql; } });
+Object.defineProperty(exports, "coerceValue", { enumerable: true, get: function () { return copy_data_1.coerceValue; } });
+var pg_data_1 = require("./pg-data");
+Object.defineProperty(exports, "PgSourceReader", { enumerable: true, get: function () { return pg_data_1.PgSourceReader; } });
+Object.defineProperty(exports, "PgTargetWriter", { enumerable: true, get: function () { return pg_data_1.PgTargetWriter; } });

package/dist/lib/import/introspect.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Database Import — introspection layer
+ *
+ * Reads the schema of a live Postgres/Supabase database. This layer is
+ * deliberately thin and side-effect-light: it only issues read-only SELECTs
+ * against information_schema/pg_catalog and returns an `IntrospectedSchema`.
+ * All interpretation lives in the conversion layer (pg-to-apsorc.ts).
+ *
+ * `pg` is loaded lazily so importing this module (e.g. from the command) does
+ * not pull the driver until an actual connection is made.
+ */
+import { IntrospectedSchema, Introspector } from "./types";
+/** Supabase- and Postgres-managed schemas we never import from. */
+export declare const SYSTEM_SCHEMAS: Set<string>;
+/** Strip credentials from a connection string for safe display in errors. */
+export declare function redactConnectionString(input: string): string;
+/**
+ * Reads schema metadata from a Postgres database via a connection string.
+ * SSL is enabled by default (Supabase requires it).
+ */
+export declare class PgIntrospector implements Introspector {
+    private readonly connectionString;
+    constructor(connectionString: string);
+    private connect;
+    introspect(schema: string): Promise<IntrospectedSchema>;
+}
+interface RawRows {
+    tableRows: any[];
+    columnRows: any[];
+    pkRows: any[];
+    fkRows: any[];
+    uniqueRows: any[];
+    indexRows: any[];
+    enumRows: any[];
+    schemaRows: any[];
+}
+/**
+ * Assemble raw query rows into an IntrospectedSchema. Exported (separate from
+ * the DB connection) so it can be unit-tested with fixture rows.
+ */
+export declare function buildSchema(schema: string, raw: RawRows): IntrospectedSchema;
+export {};

package/dist/lib/import/introspect.js

@@ -0,0 +1,327 @@
+"use strict";
+/**
+ * Database Import — introspection layer
+ *
+ * Reads the schema of a live Postgres/Supabase database. This layer is
+ * deliberately thin and side-effect-light: it only issues read-only SELECTs
+ * against information_schema/pg_catalog and returns an `IntrospectedSchema`.
+ * All interpretation lives in the conversion layer (pg-to-apsorc.ts).
+ *
+ * `pg` is loaded lazily so importing this module (e.g. from the command) does
+ * not pull the driver until an actual connection is made.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSchema = exports.PgIntrospector = exports.redactConnectionString = exports.SYSTEM_SCHEMAS = void 0;
+/** Supabase- and Postgres-managed schemas we never import from. */
+exports.SYSTEM_SCHEMAS = new Set([
+    "auth",
+    "storage",
+    "realtime",
+    "_realtime",
+    "vault",
+    "extensions",
+    "graphql",
+    "graphql_public",
+    "pgsodium",
+    "pgsodium_masks",
+    "pgbouncer",
+    "cron",
+    "net",
+    "supabase_functions",
+    "supabase_migrations",
+    "_analytics",
+    "information_schema",
+    "pg_catalog",
+    "pg_toast",
+]);
+const CONFDELTYPE_TO_ACTION = {
+    a: "NO ACTION",
+    r: "RESTRICT",
+    c: "CASCADE",
+    n: "SET NULL",
+    d: "SET DEFAULT",
+};
+/** Strip credentials from a connection string for safe display in errors. */
+function redactConnectionString(input) {
+    return input.replace(/(\/\/[^/:@]+:)[^@]*(@)/, "$1****$2");
+}
+exports.redactConnectionString = redactConnectionString;
+/**
+ * Reads schema metadata from a Postgres database via a connection string.
+ * SSL is enabled by default (Supabase requires it).
+ */
+class PgIntrospector {
+    constructor(connectionString) {
+        this.connectionString = connectionString;
+    }
+    async connect() {
+        var _a, _b;
+        // Lazy import keeps `pg` out of the module graph until we actually connect.
+        const pg = await Promise.resolve().then(() => __importStar(require("pg")));
+        const Client = (_a = pg.Client) !== null && _a !== void 0 ? _a : (_b = pg.default) === null || _b === void 0 ? void 0 : _b.Client;
+        const client = new Client({
+            connectionString: this.connectionString,
+            ssl: { rejectUnauthorized: false },
+        });
+        await client.connect();
+        return client;
+    }
+    async introspect(schema) {
+        let client;
+        try {
+            client = await this.connect();
+            const [tableRows, columnRows, pkRows, fkRows, uniqueRows, indexRows, enumRows, schemaRows,] = [
+                await client.query(TABLES_SQL, [schema]),
+                await client.query(COLUMNS_SQL, [schema]),
+                await client.query(PRIMARY_KEYS_SQL, [schema]),
+                await client.query(FOREIGN_KEYS_SQL, [schema]),
+                await client.query(UNIQUE_SQL, [schema]),
+                await client.query(INDEXES_SQL, [schema]),
+                await client.query(ENUMS_SQL, [schema]),
+                await client.query(SCHEMAS_SQL),
+            ];
+            return buildSchema(schema, {
+                tableRows: tableRows.rows,
+                columnRows: columnRows.rows,
+                pkRows: pkRows.rows,
+                fkRows: fkRows.rows,
+                uniqueRows: uniqueRows.rows,
+                indexRows: indexRows.rows,
+                enumRows: enumRows.rows,
+                schemaRows: schemaRows.rows,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to introspect database: ${redactConnectionString(message)}`);
+        }
+        finally {
+            if (client)
+                await client.end();
+        }
+    }
+}
+exports.PgIntrospector = PgIntrospector;
+const TABLES_SQL = `
+  SELECT table_name, table_type
+  FROM information_schema.tables
+  WHERE table_schema = $1 AND table_type IN ('BASE TABLE', 'VIEW')
+  ORDER BY table_name`;
+const COLUMNS_SQL = `
+  SELECT table_name, column_name, udt_name, data_type, is_nullable,
+         column_default, character_maximum_length, numeric_precision,
+         numeric_scale, ordinal_position
+  FROM information_schema.columns
+  WHERE table_schema = $1
+  ORDER BY table_name, ordinal_position`;
+const PRIMARY_KEYS_SQL = `
+  SELECT cl.relname AS table_name, att.attname AS column_name, ord.n AS key_index
+  FROM pg_constraint con
+  JOIN pg_class cl ON cl.oid = con.conrelid
+  JOIN pg_namespace ns ON ns.oid = cl.relnamespace
+  JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS ord(attnum, n) ON true
+  JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = ord.attnum
+  WHERE con.contype = 'p' AND ns.nspname = $1
+  ORDER BY cl.relname, ord.n`;
+const FOREIGN_KEYS_SQL = `
+  SELECT con.conname, cl.relname AS table_name, att.attname AS column_name,
+         clf.relname AS referenced_table, attf.attname AS referenced_column,
+         con.confdeltype, ord.n AS key_index
+  FROM pg_constraint con
+  JOIN pg_class cl ON cl.oid = con.conrelid
+  JOIN pg_namespace ns ON ns.oid = cl.relnamespace
+  JOIN pg_class clf ON clf.oid = con.confrelid
+  JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS ord(attnum, n) ON true
+  JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = ord.attnum
+  JOIN pg_attribute attf ON attf.attrelid = con.confrelid AND attf.attnum = con.confkey[ord.n]
+  WHERE con.contype = 'f' AND ns.nspname = $1
+  ORDER BY con.conname, ord.n`;
+const UNIQUE_SQL = `
+  SELECT con.conname, cl.relname AS table_name, att.attname AS column_name, ord.n AS key_index
+  FROM pg_constraint con
+  JOIN pg_class cl ON cl.oid = con.conrelid
+  JOIN pg_namespace ns ON ns.oid = cl.relnamespace
+  JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS ord(attnum, n) ON true
+  JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = ord.attnum
+  WHERE con.contype = 'u' AND ns.nspname = $1
+  ORDER BY con.conname, ord.n`;
+const INDEXES_SQL = `
+  SELECT tc.relname AS table_name, ic.relname AS index_name,
+         a.attname AS column_name, ix.indisunique, k.n AS ord
+  FROM pg_index ix
+  JOIN pg_class ic ON ic.oid = ix.indexrelid
+  JOIN pg_class tc ON tc.oid = ix.indrelid
+  JOIN pg_namespace ns ON ns.oid = tc.relnamespace
+  JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n) ON true
+  JOIN pg_attribute a ON a.attrelid = tc.oid AND a.attnum = k.attnum
+  WHERE ns.nspname = $1 AND ix.indisprimary = false
+  ORDER BY tc.relname, ic.relname, k.n`;
+const ENUMS_SQL = `
+  SELECT t.typname AS enum_name, e.enumlabel AS label
+  FROM pg_type t
+  JOIN pg_enum e ON e.enumtypid = t.oid
+  JOIN pg_namespace n ON n.oid = t.typnamespace
+  WHERE n.nspname = $1
+  ORDER BY t.typname, e.enumsortorder`;
+const SCHEMAS_SQL = `SELECT schema_name FROM information_schema.schemata`;
+/**
+ * Assemble raw query rows into an IntrospectedSchema. Exported (separate from
+ * the DB connection) so it can be unit-tested with fixture rows.
+ */
+function buildSchema(schema, raw) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    // Enums
+    const enumMap = new Map();
+    for (const row of raw.enumRows) {
+        const list = (_a = enumMap.get(row.enum_name)) !== null && _a !== void 0 ? _a : [];
+        list.push(row.label);
+        enumMap.set(row.enum_name, list);
+    }
+    const enums = [...enumMap.entries()].map(([name, labels]) => ({ name, labels }));
+    // Tables / views
+    const baseTables = raw.tableRows
+        .filter((r) => r.table_type === "BASE TABLE")
+        .map((r) => r.table_name);
+    const views = raw.tableRows
+        .filter((r) => r.table_type === "VIEW")
+        .map((r) => r.table_name);
+    // Columns grouped by table
+    const columnsByTable = new Map();
+    for (const row of raw.columnRows) {
+        const isEnum = row.data_type === "USER-DEFINED" && enumMap.has(row.udt_name);
+        const col = {
+            name: row.column_name,
+            udtName: row.udt_name,
+            dataType: row.data_type,
+            nullable: row.is_nullable === "YES",
+            default: (_b = row.column_default) !== null && _b !== void 0 ? _b : null,
+            charMaxLength: (_c = row.character_maximum_length) !== null && _c !== void 0 ? _c : null,
+            numericPrecision: (_d = row.numeric_precision) !== null && _d !== void 0 ? _d : null,
+            numericScale: (_e = row.numeric_scale) !== null && _e !== void 0 ? _e : null,
+            ordinal: row.ordinal_position,
+            isEnum,
+            enumTypeName: isEnum ? row.udt_name : undefined,
+        };
+        const list = (_f = columnsByTable.get(row.table_name)) !== null && _f !== void 0 ? _f : [];
+        list.push(col);
+        columnsByTable.set(row.table_name, list);
+    }
+    // Primary keys
+    const pkByTable = new Map();
+    for (const row of raw.pkRows) {
+        const list = (_g = pkByTable.get(row.table_name)) !== null && _g !== void 0 ? _g : [];
+        list.push(row.column_name);
+        pkByTable.set(row.table_name, list);
+    }
+    // Foreign keys (grouped by constraint name to handle composite keys)
+    const fkByConstraint = new Map();
+    for (const row of raw.fkRows) {
+        const existing = fkByConstraint.get(row.conname);
+        if (existing) {
+            existing.columns.push(row.column_name);
+            existing.refColumns.push(row.referenced_column);
+        }
+        else {
+            fkByConstraint.set(row.conname, {
+                table: row.table_name,
+                columns: [row.column_name],
+                refTable: row.referenced_table,
+                refColumns: [row.referenced_column],
+                confdeltype: row.confdeltype,
+            });
+        }
+    }
+    const fksByTable = new Map();
+    for (const fk of fkByConstraint.values()) {
+        const list = (_h = fksByTable.get(fk.table)) !== null && _h !== void 0 ? _h : [];
+        list.push({
+            columns: fk.columns,
+            referencedTable: fk.refTable,
+            referencedColumns: fk.refColumns,
+            onDelete: (_j = CONFDELTYPE_TO_ACTION[fk.confdeltype]) !== null && _j !== void 0 ? _j : "NO ACTION",
+        });
+        fksByTable.set(fk.table, list);
+    }
+    // Unique constraints (grouped by constraint name)
+    const uniqueByConstraint = new Map();
+    for (const row of raw.uniqueRows) {
+        const existing = uniqueByConstraint.get(row.conname);
+        if (existing)
+            existing.columns.push(row.column_name);
+        else
+            uniqueByConstraint.set(row.conname, {
+                table: row.table_name,
+                columns: [row.column_name],
+            });
+    }
+    const uniquesByTable = new Map();
+    for (const [name, uc] of uniqueByConstraint.entries()) {
+        const list = (_k = uniquesByTable.get(uc.table)) !== null && _k !== void 0 ? _k : [];
+        list.push({ name, columns: uc.columns });
+        uniquesByTable.set(uc.table, list);
+    }
+    // Indexes (grouped by index name)
+    const indexByName = new Map();
+    for (const row of raw.indexRows) {
+        const existing = indexByName.get(row.index_name);
+        if (existing)
+            existing.columns.push(row.column_name);
+        else
+            indexByName.set(row.index_name, {
+                table: row.table_name,
+                columns: [row.column_name],
+                unique: row.indisunique,
+            });
+    }
+    const indexesByTable = new Map();
+    for (const [name, idx] of indexByName.entries()) {
+        const list = (_l = indexesByTable.get(idx.table)) !== null && _l !== void 0 ? _l : [];
+        list.push({ name, columns: idx.columns, unique: idx.unique });
+        indexesByTable.set(idx.table, list);
+    }
+    const tables = baseTables.map((name) => {
+        var _a, _b, _c, _d, _e;
+        return ({
+            name,
+            columns: (_a = columnsByTable.get(name)) !== null && _a !== void 0 ? _a : [],
+            primaryKey: (_b = pkByTable.get(name)) !== null && _b !== void 0 ? _b : [],
+            foreignKeys: (_c = fksByTable.get(name)) !== null && _c !== void 0 ? _c : [],
+            uniqueConstraints: (_d = uniquesByTable.get(name)) !== null && _d !== void 0 ? _d : [],
+            indexes: (_e = indexesByTable.get(name)) !== null && _e !== void 0 ? _e : [],
+        });
+    });
+    const systemSchemas = raw.schemaRows
+        .map((r) => r.schema_name)
+        .filter((s) => exports.SYSTEM_SCHEMAS.has(s) && s !== schema)
+        .sort();
+    return {
+        schema,
+        tables,
+        enums,
+        skipped: { views, systemSchemas },
+    };
+}
+exports.buildSchema = buildSchema;