supaschema 0.1.0-rc.1

package/dist/sync.js

@@ -0,0 +1,86 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { checkMigrationSql } from "./check.js";
+import { diagnostic, hasErrors } from "./diagnostics.js";
+import { migrationsStatus, renderMigrationsStatus } from "./migrations-status.js";
+/**
+ * Auto-sync orchestration: supaschema gates, the Supabase CLI applies. Every
+ * pending migration must pass the static replay-safety check before any
+ * runner executes; ghost or out-of-order history refuses outright; and
+ * nothing touches a database unless `local`/`remote` was explicitly chosen —
+ * the default is a dry run that prints exactly what would execute. History
+ * stays runner-owned: supaschema never writes
+ * supabase_migrations.schema_migrations itself.
+ */
+export async function syncMigrations(options) {
+    const diagnostics = [];
+    const status = await migrationsStatus({
+        directory: options.directory,
+        ...(options.databaseUrl === undefined ? {} : { databaseUrl: options.databaseUrl }),
+    });
+    diagnostics.push(...status.diagnostics);
+    const lines = [renderMigrationsStatus(status.report).trimEnd()];
+    if (hasErrors(status.diagnostics)) {
+        lines.push("refusing to sync: resolve ghost or out-of-order history first");
+        return { applied: false, diagnostics, pending: status.report.pending, report: render(lines) };
+    }
+    if (status.report.pending.length === 0) {
+        lines.push("nothing to sync: disk and target history match");
+        return { applied: false, diagnostics, pending: [], report: render(lines) };
+    }
+    for (const file of status.report.pending) {
+        const sql = await readFile(join(options.directory, file), "utf8");
+        const checkDiagnostics = await checkMigrationSql(sql, {
+            ...(options.config === undefined ? {} : { config: options.config }),
+        });
+        const errors = checkDiagnostics.filter((item) => item.severity === "error");
+        diagnostics.push(...errors);
+        if (errors.length > 0) {
+            lines.push(`refusing to sync: ${file} fails the replay-safety check`);
+            return {
+                applied: false,
+                diagnostics,
+                pending: status.report.pending,
+                report: render(lines),
+            };
+        }
+        lines.push(`checked: ${file} (replay-safe)`);
+    }
+    const planned = [];
+    if (options.local === true) {
+        planned.push(["supabase", "migration", "up"]);
+    }
+    if (options.remote === true) {
+        planned.push(["supabase", "db", "push"]);
+    }
+    if (planned.length === 0) {
+        lines.push(`dry run: pass --local to apply ${status.report.pending.length} pending migration(s) via \`supabase migration up\`, --remote to push via \`supabase db push\``);
+        return { applied: false, diagnostics, pending: status.report.pending, report: render(lines) };
+    }
+    for (const [command, ...args] of planned) {
+        lines.push(`running: ${command} ${args.join(" ")}`);
+        const exitCode = await run(command ?? "", args);
+        if (exitCode !== 0) {
+            diagnostics.push(diagnostic("SUPA_SYNC_RUNNER_FAILED", "error", `\`${command} ${args.join(" ")}\` exited with code ${exitCode}`, { hint: "The migration runner owns apply/deploy; inspect its output above." }));
+            return {
+                applied: false,
+                diagnostics,
+                pending: status.report.pending,
+                report: render(lines),
+            };
+        }
+    }
+    return { applied: true, diagnostics, pending: status.report.pending, report: render(lines) };
+}
+function run(command, args) {
+    return new Promise((resolvePromise) => {
+        // Inherit stdio so the runner's own confirmation prompts reach the user.
+        const child = spawn(command, args, { stdio: "inherit" });
+        child.on("error", () => resolvePromise(127));
+        child.on("close", (code) => resolvePromise(code ?? 1));
+    });
+}
+function render(lines) {
+    return `${lines.join("\n")}\n`;
+}

package/dist/typegen-model.d.ts

@@ -0,0 +1,78 @@
+import type { SchemaModel } from "./core.js";
+export interface ColumnShape {
+    default?: unknown;
+    generated?: unknown;
+    identity?: string;
+    name: string;
+    notNull: boolean;
+    type: string;
+}
+export interface RelationshipShape {
+    columns: string[];
+    foreignKeyName: string;
+    isOneToOne: boolean;
+    referencedColumns: string[];
+    referencedRelation: string;
+    referencedSchema: string;
+}
+export interface FunctionShape {
+    args: {
+        name: string;
+        optional: boolean;
+        type: string;
+    }[];
+    name: string;
+    returns: {
+        setof: boolean;
+        type: string;
+    } | undefined;
+}
+export interface TableShape {
+    columns: ColumnShape[];
+    name: string;
+    primaryKey?: string[];
+    relationships: RelationshipShape[];
+    uniqueColumnSets: string[][];
+}
+export interface SchemaEntry {
+    composites: {
+        columns: ColumnShape[];
+        name: string;
+    }[];
+    enums: {
+        name: string;
+        values: string[];
+    }[];
+    functions: FunctionShape[];
+    tables: TableShape[];
+    views: {
+        columns: {
+            name: string;
+            type: string;
+        }[];
+        name: string;
+    }[];
+}
+export interface SchemaShapes {
+    domains: Map<string, string>;
+    enumsByBareName: Map<string, {
+        name: string;
+        schema: string;
+    }[]>;
+    enumsByQualifiedName: Map<string, {
+        name: string;
+        schema: string;
+    }>;
+    schemas: Map<string, SchemaEntry>;
+}
+export interface ResolvedColumnType {
+    arrayDepth: number;
+    enumRef?: {
+        name: string;
+        schema: string;
+    };
+    kind: "boolean" | "enum" | "json" | "number" | "string" | "unknown";
+}
+export declare function collectSchemaShapes(model: SchemaModel): Promise<SchemaShapes>;
+export declare function resolveColumnType(shapes: SchemaShapes, schemaName: string, sqlType: string): ResolvedColumnType;
+//# sourceMappingURL=typegen-model.d.ts.map

package/dist/typegen-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-model.d.ts","sourceRoot":"","sources":["../src/typegen-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAgB,MAAM,WAAW,CAAC;AAM3D,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;CACvD;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,iBAAiB,EAAE,CAAC;IACnC,gBAAgB,EAAE,MAAM,EAAE,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE;QAAE,OAAO,EAAE,WAAW,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACvD,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IAC5C,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,KAAK,EAAE;QAAE,OAAO,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACtE;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;IACjE,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;CACrE;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAwEnF;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,kBAAkB,CA8CpB"}

package/dist/typegen-model.js

@@ -0,0 +1,338 @@
+import { asRecord, readArray, readString, stringList, typeNameToSql } from "./sql/ast.js";
+import { parseSqlAst } from "./sql/parser.js";
+import { canonicalColumnType, canonicalTableShape } from "./sql/table-shape.js";
+import { collectViewColumns } from "./typegen-views.js";
+export async function collectSchemaShapes(model) {
+    const shapes = {
+        domains: new Map(),
+        enumsByBareName: new Map(),
+        enumsByQualifiedName: new Map(),
+        schemas: new Map(),
+    };
+    const schemaOf = (object) => schemaEntry(shapes, object.ref.schema ?? "public");
+    for (const object of model.objects) {
+        if (object.ref.kind === "enum") {
+            const schema = object.ref.schema ?? "public";
+            const entry = { name: object.ref.name, schema };
+            shapes.enumsByQualifiedName.set(`${schema}.${object.ref.name}`, entry);
+            const bare = shapes.enumsByBareName.get(object.ref.name) ?? [];
+            bare.push(entry);
+            shapes.enumsByBareName.set(object.ref.name, bare);
+            const values = Array.isArray(object.metadata.values)
+                ? object.metadata.values.map((value) => String(value))
+                : [];
+            schemaOf(object).enums.push({ name: object.ref.name, values });
+        }
+        else if (object.ref.kind === "domain") {
+            const base = await domainBaseType(object);
+            if (base !== undefined) {
+                shapes.domains.set(`${object.ref.schema ?? "public"}.${object.ref.name}`, base);
+            }
+        }
+    }
+    const tablesByKey = new Map();
+    for (const object of model.objects) {
+        if (object.ref.kind === "table" || object.ref.kind === "foreign-table") {
+            const columns = object.ref.kind === "table" ? tableColumns(object) : await foreignTableColumns(object);
+            const table = {
+                columns,
+                name: object.ref.name,
+                relationships: [],
+                uniqueColumnSets: [],
+            };
+            tablesByKey.set(`${object.ref.schema ?? "public"}.${object.ref.name}`, table);
+            schemaOf(object).tables.push(table);
+        }
+        else if (object.ref.kind === "function") {
+            const shape = await functionShape(object);
+            if (shape) {
+                schemaOf(object).functions.push(shape);
+            }
+        }
+    }
+    for (const object of model.objects) {
+        if (object.ref.kind === "constraint") {
+            await applyConstraint(object, tablesByKey);
+        }
+    }
+    resolveRelationshipTargets(tablesByKey);
+    for (const object of model.objects) {
+        if (object.ref.kind === "view" || object.ref.kind === "materialized-view") {
+            schemaOf(object).views.push({
+                columns: await collectViewColumns(object, tablesByKey),
+                name: object.ref.name,
+            });
+        }
+        else if (object.ref.kind === "type") {
+            schemaOf(object).composites.push({
+                columns: await compositeColumns(object),
+                name: object.ref.name,
+            });
+        }
+    }
+    return shapes;
+}
+export function resolveColumnType(shapes, schemaName, sqlType) {
+    let base = sqlType.trim();
+    let arrayDepth = 0;
+    while (base.endsWith("[]")) {
+        base = base.slice(0, -2).trim();
+        arrayDepth += 1;
+    }
+    const parenStart = base.indexOf("(");
+    if (parenStart !== -1) {
+        base = base.slice(0, parenStart).trim();
+    }
+    for (let hops = 0; hops < 8; hops += 1) {
+        const domainBase = shapes.domains.get(base.includes(".") ? base : `${schemaName}.${base}`) ??
+            shapes.domains.get(base);
+        if (domainBase === undefined) {
+            break;
+        }
+        base = domainBase;
+        const innerParen = base.indexOf("(");
+        if (innerParen !== -1) {
+            base = base.slice(0, innerParen).trim();
+        }
+        while (base.endsWith("[]")) {
+            base = base.slice(0, -2).trim();
+            arrayDepth += 1;
+        }
+    }
+    const lowered = base.toLowerCase();
+    if (numberTypes.has(lowered)) {
+        return { arrayDepth, kind: "number" };
+    }
+    if (stringTypes.has(lowered)) {
+        return { arrayDepth, kind: "string" };
+    }
+    if (lowered === "boolean" || lowered === "bool") {
+        return { arrayDepth, kind: "boolean" };
+    }
+    if (lowered === "json" || lowered === "jsonb") {
+        return { arrayDepth, kind: "json" };
+    }
+    const enumRef = resolveEnum(shapes, schemaName, base);
+    if (enumRef) {
+        return { arrayDepth, enumRef, kind: "enum" };
+    }
+    return { arrayDepth, kind: "unknown" };
+}
+function resolveEnum(shapes, schemaName, base) {
+    if (base.includes(".")) {
+        return shapes.enumsByQualifiedName.get(base);
+    }
+    const local = shapes.enumsByQualifiedName.get(`${schemaName}.${base}`);
+    if (local) {
+        return local;
+    }
+    const candidates = shapes.enumsByBareName.get(base);
+    return candidates && candidates.length === 1 ? candidates[0] : undefined;
+}
+function schemaEntry(shapes, name) {
+    let entry = shapes.schemas.get(name);
+    if (!entry) {
+        entry = { composites: [], enums: [], functions: [], tables: [], views: [] };
+        shapes.schemas.set(name, entry);
+    }
+    return entry;
+}
+function tableColumns(object) {
+    const shape = asRecord(object.metadata.canonicalShape);
+    return readArray(shape?.columns).flatMap((item) => {
+        const column = asRecord(item);
+        const name = readString(column?.name);
+        const type = readString(column?.type);
+        if (!(column && name && type)) {
+            return [];
+        }
+        return [
+            {
+                name,
+                notNull: column.notNull === true,
+                type,
+                ...(column.default !== undefined ? { default: column.default } : {}),
+                ...(column.generated !== undefined ? { generated: column.generated } : {}),
+                ...(typeof column.identity === "string" ? { identity: column.identity } : {}),
+            },
+        ];
+    });
+}
+async function foreignTableColumns(object) {
+    const parsed = await parseSqlAst(object.sql, object.file);
+    const statements = readArray(asRecord(parsed.ast)?.stmts);
+    const stmt = asRecord(asRecord(statements[0])?.stmt);
+    const base = asRecord(asRecord(stmt?.CreateForeignTableStmt)?.base);
+    if (!base) {
+        return [];
+    }
+    const shape = canonicalTableShape(base);
+    return readArray(shape.columns).flatMap((item) => {
+        const column = asRecord(item);
+        const name = readString(column?.name);
+        const type = readString(column?.type);
+        return column && name && type ? [{ name, notNull: column.notNull === true, type }] : [];
+    });
+}
+async function compositeColumns(object) {
+    const parsed = await parseSqlAst(object.sql, object.file);
+    const statements = readArray(asRecord(parsed.ast)?.stmts);
+    const composite = asRecord(asRecord(asRecord(statements[0])?.stmt)?.CompositeTypeStmt);
+    return readArray(composite?.coldeflist).flatMap((item) => {
+        const columnDef = asRecord(asRecord(item)?.ColumnDef);
+        const name = readString(columnDef?.colname);
+        if (!(columnDef && name)) {
+            return [];
+        }
+        return [{ name, notNull: false, type: canonicalColumnType(columnDef.typeName) }];
+    });
+}
+async function domainBaseType(object) {
+    const parsed = await parseSqlAst(object.sql, object.file);
+    const statements = readArray(asRecord(parsed.ast)?.stmts);
+    const domain = asRecord(asRecord(asRecord(statements[0])?.stmt)?.CreateDomainStmt);
+    return domain ? canonicalColumnType(domain.typeName) : undefined;
+}
+async function functionShape(object) {
+    const parsed = await parseSqlAst(object.sql, object.file);
+    const statements = readArray(asRecord(parsed.ast)?.stmts);
+    const fn = asRecord(asRecord(asRecord(statements[0])?.stmt)?.CreateFunctionStmt);
+    if (!fn) {
+        return undefined;
+    }
+    const args = [];
+    for (const item of readArray(fn.parameters)) {
+        const parameter = asRecord(asRecord(item)?.FunctionParameter);
+        if (!parameter) {
+            continue;
+        }
+        const mode = readString(parameter.mode) ?? "FUNC_PARAM_DEFAULT";
+        if (mode !== "FUNC_PARAM_DEFAULT" && mode !== "FUNC_PARAM_IN" && mode !== "FUNC_PARAM_INOUT") {
+            continue;
+        }
+        const name = readString(parameter.name);
+        if (!name) {
+            return undefined;
+        }
+        args.push({
+            name,
+            optional: parameter.defexpr !== undefined,
+            type: typeNameToSql(parameter.argType),
+        });
+    }
+    const returns = asRecord(object.metadata.returns);
+    return {
+        args,
+        name: object.ref.name,
+        returns: returns && typeof returns.type === "string"
+            ? { setof: returns.setof === true, type: returns.type }
+            : undefined,
+    };
+}
+async function applyConstraint(object, tablesByKey) {
+    const parsed = await parseSqlAst(object.sql, object.file);
+    const statements = readArray(asRecord(parsed.ast)?.stmts);
+    const alter = asRecord(asRecord(asRecord(statements[0])?.stmt)?.AlterTableStmt);
+    const schemaName = object.ref.schema ?? "public";
+    const table = tablesByKey.get(`${schemaName}.${object.ref.table ?? ""}`);
+    if (!table) {
+        return;
+    }
+    for (const command of readArray(alter?.cmds)) {
+        const constraint = asRecord(asRecord(asRecord(asRecord(command)?.AlterTableCmd)?.def)?.Constraint);
+        const contype = readString(constraint?.contype);
+        if (!constraint || !contype) {
+            continue;
+        }
+        if (contype === "CONSTR_PRIMARY") {
+            const keys = stringList(constraint.keys);
+            for (const column of table.columns) {
+                if (keys.includes(column.name)) {
+                    column.notNull = true;
+                }
+            }
+            table.primaryKey = keys;
+            table.uniqueColumnSets.push(keys);
+        }
+        else if (contype === "CONSTR_UNIQUE") {
+            table.uniqueColumnSets.push(stringList(constraint.keys));
+        }
+        else if (contype === "CONSTR_FOREIGN") {
+            const pkTable = asRecord(constraint.pktable);
+            if (!pkTable) {
+                continue;
+            }
+            table.relationships.push({
+                columns: stringList(constraint.fk_attrs),
+                foreignKeyName: readString(constraint.conname) ?? object.ref.name,
+                isOneToOne: false,
+                referencedColumns: stringList(constraint.pk_attrs),
+                referencedRelation: readString(pkTable.relname) ?? "",
+                referencedSchema: readString(pkTable.schemaname) ?? schemaName,
+            });
+        }
+    }
+}
+function resolveRelationshipTargets(tablesByKey) {
+    const primaryKeys = new Map();
+    for (const [key, table] of tablesByKey) {
+        if (table.primaryKey) {
+            primaryKeys.set(key, table.primaryKey);
+        }
+    }
+    for (const table of tablesByKey.values()) {
+        for (const relationship of table.relationships) {
+            if (relationship.referencedColumns.length === 0) {
+                const target = primaryKeys.get(`${relationship.referencedSchema}.${relationship.referencedRelation}`);
+                if (target) {
+                    relationship.referencedColumns = [...target];
+                }
+            }
+            relationship.isOneToOne = table.uniqueColumnSets.some((set) => set.length === relationship.columns.length &&
+                relationship.columns.every((column) => set.includes(column)));
+        }
+    }
+}
+const numberTypes = new Set([
+    "smallint",
+    "int2",
+    "integer",
+    "int",
+    "int4",
+    "bigint",
+    "int8",
+    "real",
+    "float4",
+    "double precision",
+    "float8",
+    "numeric",
+    "decimal",
+    "oid",
+]);
+const stringTypes = new Set([
+    "text",
+    "character varying",
+    "varchar",
+    "character",
+    "char",
+    '"char"',
+    "bpchar",
+    "uuid",
+    "citext",
+    "name",
+    "bytea",
+    "inet",
+    "cidr",
+    "macaddr",
+    "interval",
+    "date",
+    "time",
+    "timetz",
+    "time with time zone",
+    "time without time zone",
+    "timestamp",
+    "timestamptz",
+    "timestamp with time zone",
+    "timestamp without time zone",
+    "xml",
+]);

package/dist/typegen-views.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaObject } from "./core.js";
+import type { TableShape } from "./typegen-model.js";
+export declare function collectViewColumns(object: SchemaObject, tablesByKey: Map<string, TableShape>): Promise<{
+    name: string;
+    type: string;
+}[]>;
+//# sourceMappingURL=typegen-views.d.ts.map

package/dist/typegen-views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-views.d.ts","sourceRoot":"","sources":["../src/typegen-views.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG9C,OAAO,KAAK,EAAe,UAAU,EAAE,MAAM,oBAAoB,CAAC;AASlE,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EACpB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GACnC,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAiB3C"}

package/dist/typegen-views.js

@@ -0,0 +1,92 @@
+import { asRecord, readArray, readString, stringList } from "./sql/ast.js";
+import { parseSqlAst } from "./sql/parser.js";
+export async function collectViewColumns(object, tablesByKey) {
+    const aliasNames = Array.isArray(object.metadata.viewColumns)
+        ? object.metadata.viewColumns.map((value) => String(value))
+        : undefined;
+    const parsed = await parseSqlAst(object.sql, object.file);
+    const select = firstSelect(parsed.ast);
+    const fromInfo = soleFromTable(select, object.ref.schema ?? "public", tablesByKey);
+    const targets = readArray(select?.targetList).map((target) => parseTarget(target));
+    const expanded = expandTargets(targets, fromInfo);
+    if (aliasNames) {
+        return aliasNames.map((name, index) => ({
+            name,
+            type: aliasNames.length === expanded.length ? (expanded[index]?.type ?? "unknown") : "unknown",
+        }));
+    }
+    return expanded;
+}
+function expandTargets(targets, fromInfo) {
+    const output = [];
+    for (const target of targets) {
+        if (target.isStar) {
+            const coversFrom = fromInfo &&
+                (target.starQualifier === undefined || fromInfo.names.has(target.starQualifier));
+            if (coversFrom && fromInfo) {
+                for (const column of fromInfo.columns) {
+                    output.push({ name: column.name, type: column.type });
+                }
+            }
+            continue;
+        }
+        const name = target.alias ?? target.sourceColumn;
+        if (!name) {
+            continue;
+        }
+        const match = target.sourceColumn === undefined
+            ? undefined
+            : fromInfo?.columns.find((column) => column.name === target.sourceColumn);
+        output.push({ name, type: match?.type ?? "unknown" });
+    }
+    return output;
+}
+function parseTarget(target) {
+    const resTarget = asRecord(asRecord(target)?.ResTarget);
+    const columnRef = asRecord(asRecord(resTarget?.val)?.ColumnRef);
+    const fields = readArray(columnRef?.fields);
+    const lastField = fields.at(-1);
+    const isStar = asRecord(lastField)?.A_Star !== undefined;
+    const lastName = stringList(columnRef?.fields).at(-1);
+    const alias = readString(resTarget?.name);
+    if (isStar) {
+        return {
+            isStar: true,
+            ...(lastName !== undefined && fields.length > 1 ? { starQualifier: lastName } : {}),
+        };
+    }
+    return {
+        isStar: false,
+        ...(alias !== undefined ? { alias } : {}),
+        ...(lastName !== undefined ? { sourceColumn: lastName } : {}),
+    };
+}
+function firstSelect(ast) {
+    const statements = readArray(asRecord(ast)?.stmts);
+    const stmt = asRecord(asRecord(statements[0])?.stmt);
+    const view = asRecord(stmt?.ViewStmt);
+    const tableAs = asRecord(stmt?.CreateTableAsStmt);
+    return asRecord(asRecord(view?.query ?? tableAs?.query)?.SelectStmt);
+}
+function soleFromTable(select, defaultSchema, tablesByKey) {
+    const fromClause = readArray(select?.fromClause);
+    if (fromClause.length !== 1) {
+        return undefined;
+    }
+    const rangeVar = asRecord(asRecord(fromClause[0])?.RangeVar);
+    const relname = readString(rangeVar?.relname);
+    if (!(rangeVar && relname)) {
+        return undefined;
+    }
+    const schemaName = readString(rangeVar?.schemaname) ?? defaultSchema;
+    const table = tablesByKey.get(`${schemaName}.${relname}`);
+    if (!table) {
+        return undefined;
+    }
+    const aliasName = asRecord(rangeVar.alias)?.aliasname;
+    const names = new Set([relname]);
+    if (typeof aliasName === "string") {
+        names.add(aliasName);
+    }
+    return { columns: table.columns, names };
+}

package/dist/typegen-zod.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaModel } from "./core.js";
+export declare function generateZodSchemas(model: SchemaModel): Promise<string>;
+//# sourceMappingURL=typegen-zod.d.ts.map

package/dist/typegen-zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-zod.d.ts","sourceRoot":"","sources":["../src/typegen-zod.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAK7C,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CA6F5E"}