@apso/cli 0.29.1 → 0.31.0

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;

package/dist/lib/import/pg-to-apsorc.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Database Import — conversion layer
+ *
+ * Turns an `IntrospectedSchema` (read from a live Postgres/Supabase database)
+ * into a `.apsorc`-shaped object. This is a pure function: same input always
+ * yields the same output and report, with no I/O — which keeps it exhaustively
+ * unit-testable.
+ *
+ * The reverse type map here is the inverse of `fieldTypeToColumnType`
+ * (src/lib/utils/field.ts). The FK-to-relationship logic mirrors how the
+ * platform derives FK column names in `getRelationshipIdField`
+ * (src/lib/utils/relationships/parse.ts) so imported relationships round-trip.
+ */
+import { ImportReport, IntrospectedColumn, IntrospectedSchema } from "./types";
+export interface ApsorcImportFieldOutput {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    unique?: boolean;
+    default?: unknown;
+    index?: boolean;
+    values?: string[];
+    length?: number;
+    precision?: number;
+    scale?: number;
+    primary?: boolean;
+}
+export interface ApsorcImportEntityOutput {
+    name: string;
+    primaryKeyType?: "serial" | "uuid" | "text";
+    created_at?: boolean;
+    updated_at?: boolean;
+    fields?: ApsorcImportFieldOutput[];
+    uniques?: Array<{
+        fields: string[];
+        name?: string;
+    }>;
+    indexes?: Array<{
+        fields: string[];
+        unique?: boolean;
+    }>;
+}
+export interface ApsorcImportRelationshipOutput {
+    from: string;
+    to: string;
+    type: "OneToMany" | "ManyToOne" | "ManyToMany" | "OneToOne";
+    to_name?: string;
+    nullable?: boolean;
+    bi_directional?: boolean;
+    cascadeDelete?: boolean;
+}
+export interface ApsorcImportOutput {
+    version: number;
+    rootFolder: string;
+    apiType: string;
+    entities: ApsorcImportEntityOutput[];
+    relationships: ApsorcImportRelationshipOutput[];
+}
+interface TypeResolution {
+    type: string;
+    /** True when the mapping loses information (arrays, unknown types). */
+    lossy?: "array" | "defaulted";
+}
+/**
+ * Resolve a column's `.apsorc` field type from its Postgres type. Postgres
+ * arrays (udt_name starting with "_") collapse to `array`; user enums become
+ * `enum`; unknown types fall back to `text`.
+ */
+export declare function pgTypeToApsorcType(col: IntrospectedColumn): TypeResolution;
+/**
+ * Translate a raw Postgres default expression into an `.apsorc` default value.
+ * Returns `{ drop: true }` when the default cannot be represented (function
+ * calls, sequence/uuid generators). Auto-timestamp and sequence defaults are
+ * dropped silently by callers that handle them structurally.
+ */
+export declare function parseDefault(raw: string | null, apsorcType: string): {
+    value?: unknown;
+    drop?: boolean;
+};
+/**
+ * Derive the relationship `to_name` so the platform regenerates a FK column
+ * matching the source column. Returns `undefined` when the default naming
+ * (`${camelCase(target)}Id`) already produces the source column. Sets
+ * `unmapped: true` when no name round-trips to the source column.
+ */
+export declare function deriveToName(sourceColumn: string, targetTable: string): {
+    toName?: string;
+    unmapped?: boolean;
+};
+/**
+ * Convert an introspected Postgres schema into a `.apsorc`-shaped object plus a
+ * report of everything that could not be represented losslessly.
+ */
+export declare function pgToApsorc(schema: IntrospectedSchema): {
+    apsorc: ApsorcImportOutput;
+    report: ImportReport;
+};
+/**
+ * Invariant guard: every emitted field type must be a recognized `.apsorc`
+ * column type, so code generation never silently falls back to varchar.
+ * Returns the list of any offending types (empty when valid).
+ */
+export declare function findUnknownEmittedTypes(output: ApsorcImportOutput): string[];
+export {};