@apso/cli 0.30.0 → 0.31.0

package/dist/commands/import/supabase.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import BaseCommand from "../../lib/base-command";
+import { ApsorcImportOutput, ImportReport, Introspector } from "../../lib/import";
+/**
+ * Resolve the Postgres connection string from an explicit flag or, failing
+ * that, the SUPABASE_DB_URL / DATABASE_URL environment variables. Returns
+ * undefined if none is set (the command then prompts interactively).
+ */
+export declare function resolveConnectionString(flagValue: string | undefined, env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Run the full introspect -> convert -> validate pipeline against any
+ * Introspector. Throws if the generated relationships fail to parse. Pure of
+ * file/console I/O so it can be unit-tested with a fake Introspector.
+ */
+export declare function importFromIntrospector(introspector: Introspector, schema: string): Promise<{
+    apsorc: ApsorcImportOutput;
+    report: ImportReport;
+    unknownTypes: string[];
+}>;
+/** Render the import report as a human-readable summary (contains no secrets). */
+export declare function formatReport(report: ImportReport): string;
+/**
+ * Write the generated .apsorc to disk, backing up any existing file first.
+ * Returns the backup path if one was made.
+ */
+export declare function writeApsorcFile(apsorc: ApsorcImportOutput, outPath: string): {
+    backupPath?: string;
+};
+export default class ImportSupabase extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "connection-string": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        schema: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        out: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        "dry-run": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    /** Overridable for testing. */
+    protected makeIntrospector(connectionString: string): Introspector;
+    run(): Promise<void>;
+}

package/dist/commands/import/supabase.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeApsorcFile = exports.formatReport = exports.importFromIntrospector = exports.resolveConnectionString = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const base_command_1 = tslib_1.__importDefault(require("../../lib/base-command"));
+const config_1 = require("../../lib/config");
+const apsorc_parser_1 = require("../../lib/apsorc-parser");
+const relationships_1 = require("../../lib/utils/relationships");
+const import_1 = require("../../lib/import");
+/**
+ * Resolve the Postgres connection string from an explicit flag or, failing
+ * that, the SUPABASE_DB_URL / DATABASE_URL environment variables. Returns
+ * undefined if none is set (the command then prompts interactively).
+ */
+function resolveConnectionString(flagValue, env = process.env) {
+    return flagValue || env.SUPABASE_DB_URL || env.DATABASE_URL || undefined;
+}
+exports.resolveConnectionString = resolveConnectionString;
+/**
+ * Run the full introspect -> convert -> validate pipeline against any
+ * Introspector. Throws if the generated relationships fail to parse. Pure of
+ * file/console I/O so it can be unit-tested with a fake Introspector.
+ */
+async function importFromIntrospector(introspector, schema) {
+    const introspected = await introspector.introspect(schema);
+    const { apsorc, report } = (0, import_1.pgToApsorc)(introspected);
+    // Validate by running the generated relationships through the real parser.
+    (0, relationships_1.parseRelationships)(apsorc.relationships);
+    return {
+        apsorc,
+        report,
+        unknownTypes: (0, import_1.findUnknownEmittedTypes)(apsorc),
+    };
+}
+exports.importFromIntrospector = importFromIntrospector;
+/** Render the import report as a human-readable summary (contains no secrets). */
+function formatReport(report) {
+    const lines = [];
+    lines.push(`Imported ${report.tablesImported.length} table(s) and ${report.relationships} relationship(s).`);
+    if (report.tablesImported.length > 0) {
+        lines.push(`  Tables: ${report.tablesImported.join(", ")}`);
+    }
+    if (report.viewsSkipped.length > 0) {
+        lines.push(`  Skipped views: ${report.viewsSkipped.join(", ")}`);
+    }
+    if (report.systemSchemasSkipped.length > 0) {
+        lines.push(`  Skipped system schemas: ${report.systemSchemasSkipped.join(", ")}`);
+    }
+    const w = report.warnings;
+    const review = [];
+    if (w.compositePks.length > 0)
+        review.push(`  - Composite primary keys (review): ${w.compositePks.join(", ")}`);
+    if (w.nonStandardPks.length > 0)
+        review.push(`  - Non-"id" primary keys (kept as fields): ${w.nonStandardPks.join(", ")}`);
+    if (w.noPrimaryKey.length > 0)
+        review.push(`  - Tables with no primary key: ${w.noPrimaryKey.join(", ")}`);
+    if (w.compositeFks.length > 0)
+        review.push(`  - Composite foreign keys (kept as columns, no relationship): ${w.compositeFks.join(", ")}`);
+    if (w.fkColumnNameUnmapped.length > 0)
+        review.push(`  - Foreign keys whose generated column may differ: ${w.fkColumnNameUnmapped.join(", ")}`);
+    if (w.joinTablesDetected.length > 0)
+        review.push(`  - Join tables (could be modeled as ManyToMany): ${w.joinTablesDetected.join(", ")}`);
+    if (w.arraysLossy.length > 0)
+        review.push(`  - Array columns reduced to text: ${w.arraysLossy.join(", ")}`);
+    if (w.typesDefaulted.length > 0)
+        review.push(`  - Unknown types defaulted to text: ${w.typesDefaulted
+            .map((t) => `${t.column} (${t.udt})`)
+            .join(", ")}`);
+    if (w.defaultsDropped.length > 0)
+        review.push(`  - Column defaults dropped: ${w.defaultsDropped.join(", ")}`);
+    if (review.length > 0) {
+        lines.push("", "Review the following (not fully represented):", ...review);
+    }
+    return lines.join("\n");
+}
+exports.formatReport = formatReport;
+/**
+ * Write the generated .apsorc to disk, backing up any existing file first.
+ * Returns the backup path if one was made.
+ */
+function writeApsorcFile(apsorc, outPath) {
+    let backupPath;
+    if (fs.existsSync(outPath)) {
+        backupPath = (0, config_1.createBackup)(outPath);
+    }
+    fs.writeFileSync(outPath, JSON.stringify(apsorc, null, 2), "utf-8");
+    return { backupPath };
+}
+exports.writeApsorcFile = writeApsorcFile;
+class ImportSupabase extends base_command_1.default {
+    /** Overridable for testing. */
+    makeIntrospector(connectionString) {
+        return new import_1.PgIntrospector(connectionString);
+    }
+    async run() {
+        var _a, _b;
+        const { flags } = await this.parse(ImportSupabase);
+        let connectionString = resolveConnectionString(flags["connection-string"]);
+        if (!connectionString) {
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: "password",
+                    name: "connectionString",
+                    mask: "*",
+                    message: "Supabase Postgres connection string:",
+                    validate: (input) => input.trim().length > 0 || "A connection string is required",
+                },
+            ]);
+            connectionString = answer.connectionString.trim();
+        }
+        try {
+            this.log("Connecting and introspecting schema (read-only)...");
+            const introspector = this.makeIntrospector(connectionString);
+            const { apsorc, report, unknownTypes } = await importFromIntrospector(introspector, flags.schema);
+            this.log("");
+            this.log(formatReport(report));
+            if (unknownTypes.length > 0) {
+                this.warn(`Some column types were not recognized and defaulted to text: ${[
+                    ...new Set(unknownTypes),
+                ].join(", ")}`);
+            }
+            if (report.tablesImported.length === 0) {
+                this.warn(`No base tables found in schema "${flags.schema}". Nothing to write.`);
+                return;
+            }
+            if (flags["dry-run"]) {
+                this.log("");
+                this.log("Dry run — no file written.");
+                return;
+            }
+            const outPath = (_b = (_a = flags.out) !== null && _a !== void 0 ? _a : (0, apsorc_parser_1.findConfigPath)()) !== null && _b !== void 0 ? _b : path.join(process.cwd(), ".apsorc");
+            if (fs.existsSync(outPath) && !flags.yes) {
+                const { confirm } = await inquirer_1.default.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirm",
+                        message: `Overwrite ${outPath} with the imported schema?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    this.log("Import cancelled.");
+                    return;
+                }
+            }
+            const { backupPath } = writeApsorcFile(apsorc, outPath);
+            if (backupPath)
+                this.log(`Backup created: ${backupPath}`);
+            this.log(`Schema written to ${outPath}`);
+            this.log("");
+            this.log("Next steps:");
+            this.log("  - Review the .apsorc, especially any items flagged above");
+            this.log("  - Run 'apso migrate' to validate the schema locally");
+            this.log("  - Run 'apso generate' to scaffold code");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            // Defense-in-depth: never surface the connection string in an error.
+            this.error((0, import_1.redactConnectionString)(message.split(connectionString).join("****")));
+        }
+    }
+}
+ImportSupabase.description = "Introspect an existing Supabase (Postgres) database and generate a local .apsorc schema. Read-only: it never writes to the source database.";
+ImportSupabase.examples = [
+    `$ apso import supabase`,
+    `$ apso import supabase -c "postgresql://postgres:[pw]@db.[ref].supabase.co:5432/postgres"`,
+    `$ SUPABASE_DB_URL="postgresql://..." apso import supabase --dry-run`,
+];
+ImportSupabase.flags = {
+    "connection-string": core_1.Flags.string({
+        char: "c",
+        description: "Postgres connection string. Falls back to SUPABASE_DB_URL or DATABASE_URL, then prompts.",
+    }),
+    schema: core_1.Flags.string({
+        description: "Database schema to import",
+        default: "public",
+    }),
+    out: core_1.Flags.string({
+        char: "o",
+        description: "Path to write the .apsorc (default: existing .apsorc or ./.apsorc)",
+    }),
+    "dry-run": core_1.Flags.boolean({
+        description: "Introspect and print a summary without writing any file",
+        default: false,
+    }),
+    yes: core_1.Flags.boolean({
+        char: "y",
+        description: "Skip the overwrite confirmation prompt",
+        default: false,
+    }),
+};
+exports.default = ImportSupabase;

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

@@ -0,0 +1,4 @@
+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";

package/dist/lib/import/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });

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;