supaschema 0.1.0-rc.1

package/dist/typegen-zod.js

@@ -0,0 +1,149 @@
+import { quoteKey } from "./typegen.js";
+import { collectSchemaShapes, resolveColumnType } from "./typegen-model.js";
+export async function generateZodSchemas(model) {
+    const shapes = await collectSchemaShapes(model);
+    const sortedSchemas = [...shapes.schemas.entries()].sort(([left], [right]) => left.localeCompare(right));
+    const enumIdents = buildEnumIdentifiers(sortedSchemas);
+    const lines = [
+        'import { z } from "zod";',
+        "",
+        "export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[];",
+        "",
+        "export const jsonSchema: z.ZodType<Json> = z.lazy(() =>",
+        "  z.union([",
+        "    z.string(),",
+        "    z.number(),",
+        "    z.boolean(),",
+        "    z.null(),",
+        "    z.record(z.string(), z.union([jsonSchema, z.undefined()])),",
+        "    z.array(jsonSchema),",
+        "  ]),",
+        ");",
+        "",
+    ];
+    for (const [schemaName, entry] of sortedSchemas) {
+        for (const item of [...entry.enums].sort((a, b) => a.name.localeCompare(b.name))) {
+            const ident = enumIdents.get(`${schemaName}.${item.name}`);
+            if (ident && item.values.length > 0) {
+                lines.push(`const ${ident} = z.enum([${item.values.map((value) => JSON.stringify(value)).join(", ")}]);`);
+            }
+        }
+    }
+    lines.push("");
+    lines.push("export const schemas = {");
+    for (const [schemaName, entry] of sortedSchemas) {
+        const zodFor = (sqlType) => zodExpr(shapes, schemaName, enumIdents, sqlType);
+        lines.push(`  ${quoteKey(schemaName)}: {`);
+        lines.push("    Enums: {");
+        for (const item of [...entry.enums].sort((a, b) => a.name.localeCompare(b.name))) {
+            const ident = enumIdents.get(`${schemaName}.${item.name}`);
+            if (ident && item.values.length > 0) {
+                lines.push(`      ${quoteKey(item.name)}: ${ident},`);
+            }
+        }
+        lines.push("    },");
+        lines.push("    Tables: {");
+        for (const table of [...entry.tables].sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`      ${quoteKey(table.name)}: {`);
+            lines.push("        Row: z.object({");
+            for (const column of table.columns) {
+                const base = zodFor(column.type);
+                lines.push(`          ${quoteKey(column.name)}: ${column.notNull ? base : `${base}.nullable()`},`);
+            }
+            lines.push("        }),");
+            lines.push("        Insert: z.object({");
+            for (const column of table.columns) {
+                const field = zodInsertField(column, zodFor);
+                if (field) {
+                    lines.push(`          ${field}`);
+                }
+            }
+            lines.push("        }),");
+            lines.push("        Update: z.object({");
+            for (const column of table.columns) {
+                if (column.generated !== undefined || column.identity === "a") {
+                    continue;
+                }
+                const base = zodFor(column.type);
+                const value = column.notNull ? base : `${base}.nullable()`;
+                lines.push(`          ${quoteKey(column.name)}: ${value}.optional(),`);
+            }
+            lines.push("        }),");
+            lines.push("      },");
+        }
+        lines.push("    },");
+        lines.push("    Views: {");
+        for (const view of [...entry.views].sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`      ${quoteKey(view.name)}: {`);
+            lines.push("        Row: z.object({");
+            for (const column of view.columns) {
+                lines.push(`          ${quoteKey(column.name)}: ${zodFor(column.type)}.nullable(),`);
+            }
+            lines.push("        }),");
+            lines.push("      },");
+        }
+        lines.push("    },");
+        lines.push("  },");
+    }
+    lines.push("} as const;");
+    return `${lines.join("\n")}\n`;
+}
+function buildEnumIdentifiers(schemas) {
+    const idents = new Map();
+    const used = new Set();
+    for (const [schemaName, entry] of schemas) {
+        for (const item of entry.enums) {
+            let ident = `${sanitizeIdent(schemaName)}_${sanitizeIdent(item.name)}`;
+            let suffix = 1;
+            while (used.has(ident)) {
+                suffix += 1;
+                ident = `${sanitizeIdent(schemaName)}_${sanitizeIdent(item.name)}_${suffix}`;
+            }
+            used.add(ident);
+            idents.set(`${schemaName}.${item.name}`, ident);
+        }
+    }
+    return idents;
+}
+function sanitizeIdent(value) {
+    let result = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index] ?? "";
+        const isWord = (char >= "a" && char <= "z") ||
+            (char >= "A" && char <= "Z") ||
+            (char >= "0" && char <= "9") ||
+            char === "_";
+        result += isWord ? char : "_";
+    }
+    const first = result[0] ?? "";
+    return first >= "0" && first <= "9" ? `_${result}` : result;
+}
+function zodExpr(shapes, schemaName, enumIdents, sqlType) {
+    const resolved = resolveColumnType(shapes, schemaName, sqlType);
+    let mapped;
+    if (resolved.kind === "enum" && resolved.enumRef) {
+        mapped = enumIdents.get(`${resolved.enumRef.schema}.${resolved.enumRef.name}`) ?? "z.unknown()";
+    }
+    else if (resolved.kind === "json") {
+        mapped = "jsonSchema";
+    }
+    else if (resolved.kind === "unknown") {
+        mapped = "z.unknown()";
+    }
+    else {
+        mapped = `z.${resolved.kind}()`;
+    }
+    for (let depth = 0; depth < resolved.arrayDepth; depth += 1) {
+        mapped = `z.array(${mapped})`;
+    }
+    return mapped;
+}
+function zodInsertField(column, zodFor) {
+    if (column.generated !== undefined || column.identity === "a") {
+        return undefined;
+    }
+    const base = zodFor(column.type);
+    const value = column.notNull ? base : `${base}.nullable()`;
+    const optional = !column.notNull || column.default !== undefined || column.identity !== undefined;
+    return `${quoteKey(column.name)}: ${optional ? `${value}.optional()` : value},`;
+}

package/dist/typegen.d.ts

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

package/dist/typegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen.d.ts","sourceRoot":"","sources":["../src/typegen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAS7C,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAyE/E;AA0FD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAe7C"}

package/dist/typegen.js

@@ -0,0 +1,184 @@
+import { collectSchemaShapes, resolveColumnType } from "./typegen-model.js";
+export async function generateDatabaseTypes(model) {
+    const shapes = await collectSchemaShapes(model);
+    const lines = [
+        "export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[];",
+        "",
+        "export type Database = {",
+    ];
+    const sortedSchemas = [...shapes.schemas.entries()].sort(([left], [right]) => left.localeCompare(right));
+    for (const [schemaName, entry] of sortedSchemas) {
+        const typeOf = (sqlType) => tsType(shapes, schemaName, sqlType);
+        lines.push(`  ${quoteKey(schemaName)}: {`);
+        lines.push("    Tables: {");
+        for (const table of [...entry.tables].sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`      ${quoteKey(table.name)}: {`);
+            lines.push("        Row: {");
+            for (const column of table.columns) {
+                const base = typeOf(column.type);
+                lines.push(`          ${quoteKey(column.name)}: ${column.notNull ? base : `${base} | null`};`);
+            }
+            lines.push("        };");
+            lines.push("        Insert: {");
+            for (const column of table.columns) {
+                lines.push(`          ${insertField(column, typeOf)}`);
+            }
+            lines.push("        };");
+            lines.push("        Update: {");
+            for (const column of table.columns) {
+                lines.push(`          ${updateField(column, typeOf)}`);
+            }
+            lines.push("        };");
+            lines.push(`        Relationships: ${renderRelationships(table.relationships)};`);
+            lines.push("      };");
+        }
+        lines.push("    };");
+        lines.push("    Views: {");
+        for (const view of [...entry.views].sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`      ${quoteKey(view.name)}: {`);
+            lines.push("        Row: {");
+            for (const column of view.columns) {
+                lines.push(`          ${quoteKey(column.name)}: ${typeOf(column.type)} | null;`);
+            }
+            lines.push("        };");
+            lines.push("      };");
+        }
+        lines.push("    };");
+        lines.push("    Enums: {");
+        for (const item of [...entry.enums].sort((a, b) => a.name.localeCompare(b.name))) {
+            const union = item.values.map((value) => JSON.stringify(value)).join(" | ");
+            lines.push(`      ${quoteKey(item.name)}: ${union.length > 0 ? union : "never"};`);
+        }
+        lines.push("    };");
+        lines.push("    CompositeTypes: {");
+        for (const composite of [...entry.composites].sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`      ${quoteKey(composite.name)}: {`);
+            for (const column of composite.columns) {
+                lines.push(`        ${quoteKey(column.name)}: ${typeOf(column.type)} | null;`);
+            }
+            lines.push("      };");
+        }
+        lines.push("    };");
+        lines.push(...functionsBlock(entry.functions, typeOf));
+        lines.push("  };");
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push(...helperBlock());
+    lines.push("");
+    lines.push(...constantsBlock(sortedSchemas));
+    return `${lines.join("\n")}\n`;
+}
+function tsType(shapes, schemaName, sqlType) {
+    const resolved = resolveColumnType(shapes, schemaName, sqlType);
+    let mapped;
+    if (resolved.kind === "enum" && resolved.enumRef) {
+        mapped = `Database["${resolved.enumRef.schema}"]["Enums"]["${resolved.enumRef.name}"]`;
+    }
+    else if (resolved.kind === "json") {
+        mapped = "Json";
+    }
+    else if (resolved.kind === "unknown") {
+        mapped = "unknown";
+    }
+    else {
+        mapped = resolved.kind;
+    }
+    return mapped + "[]".repeat(resolved.arrayDepth);
+}
+function insertField(column, typeOf) {
+    if (column.generated !== undefined || column.identity === "a") {
+        return `${quoteKey(column.name)}?: never;`;
+    }
+    const base = typeOf(column.type);
+    const type = column.notNull ? base : `${base} | null`;
+    const optional = !column.notNull || column.default !== undefined || column.identity !== undefined;
+    return `${quoteKey(column.name)}${optional ? "?" : ""}: ${type};`;
+}
+function updateField(column, typeOf) {
+    if (column.generated !== undefined || column.identity === "a") {
+        return `${quoteKey(column.name)}?: never;`;
+    }
+    const base = typeOf(column.type);
+    return `${quoteKey(column.name)}?: ${column.notNull ? base : `${base} | null`};`;
+}
+function functionsBlock(functions, typeOf) {
+    const grouped = new Map();
+    for (const fn of functions) {
+        const overloads = grouped.get(fn.name) ?? [];
+        overloads.push(fn);
+        grouped.set(fn.name, overloads);
+    }
+    if (grouped.size === 0) {
+        return ["    Functions: { [_ in never]: never };"];
+    }
+    const lines = ["    Functions: {"];
+    for (const [name, overloads] of [...grouped.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const argVariants = sortedUnique(overloads.map((fn) => renderFunctionArgs(fn, typeOf)));
+        const returnVariants = sortedUnique(overloads.map((fn) => renderFunctionReturns(fn, typeOf)));
+        lines.push(`      ${quoteKey(name)}: { Args: ${argVariants.join(" | ")}; Returns: ${returnVariants.join(" | ")} };`);
+    }
+    lines.push("    };");
+    return lines;
+}
+function renderFunctionArgs(fn, typeOf) {
+    const args = fn.args
+        .map((arg) => `${quoteKey(arg.name)}${arg.optional ? "?" : ""}: ${typeOf(arg.type)}`)
+        .join("; ");
+    return args.length > 0 ? `{ ${args} }` : "Record<PropertyKey, never>";
+}
+function renderFunctionReturns(fn, typeOf) {
+    const base = fn.returns ? typeOf(fn.returns.type) : "unknown";
+    return fn.returns?.setof ? `${base}[]` : base;
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function renderRelationships(relationships) {
+    if (relationships.length === 0) {
+        return "[]";
+    }
+    const items = relationships.map((item) => `{ foreignKeyName: ${JSON.stringify(item.foreignKeyName)}; columns: ${tupleType(item.columns)}; isOneToOne: ${item.isOneToOne}; referencedRelation: ${JSON.stringify(item.referencedRelation)}; referencedColumns: ${tupleType(item.referencedColumns)} }`);
+    return `[${items.join(", ")}]`;
+}
+function tupleType(values) {
+    return `[${values.map((value) => JSON.stringify(value)).join(", ")}]`;
+}
+export function quoteKey(name) {
+    let simple = name.length > 0;
+    for (let index = 0; index < name.length; index += 1) {
+        const char = name[index] ?? "";
+        const isWord = (char >= "a" && char <= "z") ||
+            (char >= "A" && char <= "Z") ||
+            char === "_" ||
+            (index > 0 && char >= "0" && char <= "9");
+        if (!isWord) {
+            simple = false;
+            break;
+        }
+    }
+    return simple ? name : JSON.stringify(name);
+}
+function helperBlock() {
+    return [
+        'export type Tables<S extends keyof Database, T extends keyof Database[S]["Tables"]> = Database[S]["Tables"][T] extends { Row: infer R } ? R : never;',
+        'export type TablesInsert<S extends keyof Database, T extends keyof Database[S]["Tables"]> = Database[S]["Tables"][T] extends { Insert: infer I } ? I : never;',
+        'export type TablesUpdate<S extends keyof Database, T extends keyof Database[S]["Tables"]> = Database[S]["Tables"][T] extends { Update: infer U } ? U : never;',
+        'export type Views<S extends keyof Database, V extends keyof Database[S]["Views"]> = Database[S]["Views"][V] extends { Row: infer R } ? R : never;',
+        'export type Enums<S extends keyof Database, E extends keyof Database[S]["Enums"]> = Database[S]["Enums"][E];',
+    ];
+}
+function constantsBlock(schemas) {
+    const lines = ["export const Constants = {"];
+    for (const [schemaName, entry] of schemas) {
+        lines.push(`  ${quoteKey(schemaName)}: {`);
+        lines.push("    Enums: {");
+        for (const item of [...entry.enums].sort((a, b) => a.name.localeCompare(b.name))) {
+            lines.push(`      ${quoteKey(item.name)}: [${item.values.map((value) => JSON.stringify(value)).join(", ")}],`);
+        }
+        lines.push("    },");
+        lines.push("  },");
+    }
+    lines.push("} as const;");
+    return lines;
+}

package/dist/validators.d.ts

@@ -0,0 +1,3 @@
+import type { CheckOptions, Diagnostic } from "./core.js";
+export declare function runConfiguredValidators(sql: string, options?: CheckOptions): Promise<Diagnostic[]>;
+//# sourceMappingURL=validators.d.ts.map

package/dist/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../src/validators.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAgB1D,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,UAAU,EAAE,CAAC,CA6BvB"}

package/dist/validators.js

@@ -0,0 +1,104 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { resolveConfig } from "./config.js";
+import { diagnostic } from "./diagnostics.js";
+const execFileAsync = promisify(execFile);
+export async function runConfiguredValidators(sql, options = {}) {
+    const config = resolveConfig(options.config);
+    const externalValidators = config.validators.filter((validator) => validator !== "internal-parser");
+    if (externalValidators.length === 0) {
+        return [];
+    }
+    const diagnostics = [];
+    const tempRoot = await mkdtemp(join(tmpdir(), "supaschema-"));
+    const tempFile = join(tempRoot, "migration.sql");
+    try {
+        await writeFile(tempFile, sql);
+        for (const validator of externalValidators) {
+            const spec = validatorSpec(validator);
+            if (!spec) {
+                diagnostics.push(diagnostic("SUPA_VALIDATOR_UNKNOWN", "error", `unknown validator "${validator}"`, {
+                    hint: "Supported validators: internal-parser, squawk, squawk-cli, pgls, postgres-language-server, sqlfluff, pg-formatter.",
+                }));
+                continue;
+            }
+            diagnostics.push(...(await runValidator(validator, spec, tempFile, options.cwd)));
+        }
+    }
+    finally {
+        await rm(tempRoot, { force: true, recursive: true }).catch(() => undefined);
+    }
+    return diagnostics;
+}
+function validatorSpec(name) {
+    switch (name) {
+        case "squawk":
+        case "squawk-cli":
+            return { args: [], command: "squawk" };
+        case "pgls":
+        case "@postgres-language-server/cli":
+        case "postgres-language-server":
+            return {
+                args: [
+                    "check",
+                    "--disable-db",
+                    "--reporter=summary",
+                    "--max-diagnostics=none",
+                    "--no-errors-on-unmatched",
+                ],
+                command: "postgres-language-server",
+            };
+        case "sqlfluff":
+            return { args: ["lint", "--dialect", "postgres"], command: "sqlfluff" };
+        case "pg-formatter":
+        case "pgformatter":
+            return { args: ["--check"], command: "pg-formatter" };
+        default:
+            return undefined;
+    }
+}
+async function runValidator(name, spec, path, cwd = process.cwd()) {
+    try {
+        await execFileAsync(spec.command, [...spec.args, path], {
+            cwd,
+            maxBuffer: 1024 * 1024 * 10,
+            timeout: 30_000,
+        });
+        return [];
+    }
+    catch (error) {
+        if (isMissingExecutable(error)) {
+            return [
+                diagnostic("SUPA_VALIDATOR_UNAVAILABLE", "error", `validator "${name}" is not available`, {
+                    hint: `Install the validator or remove "${name}" from validators.`,
+                }),
+            ];
+        }
+        return [
+            diagnostic("SUPA_VALIDATOR_FAILED", "error", `validator "${name}" reported diagnostics`, {
+                hint: commandOutput(error),
+            }),
+        ];
+    }
+}
+function isMissingExecutable(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function commandOutput(error) {
+    if (!error || typeof error !== "object") {
+        return String(error);
+    }
+    const output = [readStringProperty(error, "stdout"), readStringProperty(error, "stderr")]
+        .filter((value) => value.length > 0)
+        .join("\n")
+        .trim();
+    return output.length > 0 ? output.slice(0, 2000) : String(error);
+}
+function readStringProperty(value, property) {
+    const record = value;
+    const output = record[property];
+    return typeof output === "string" ? output : "";
+}

package/dist/verify-environment.d.ts

@@ -0,0 +1,5 @@
+import type { Client } from "pg";
+import type { Diagnostic } from "./core.js";
+export declare function preflightCapability(admin: Client): Promise<Diagnostic | undefined>;
+export declare const supabaseEnvironmentStubSql = "\nCREATE SCHEMA IF NOT EXISTS auth;\nCREATE TABLE IF NOT EXISTS auth.users (\n  instance_id uuid,\n  id uuid PRIMARY KEY,\n  aud varchar(255),\n  role varchar(255),\n  email varchar(255),\n  encrypted_password varchar(255),\n  email_confirmed_at timestamptz,\n  invited_at timestamptz,\n  confirmation_token varchar(255),\n  confirmation_sent_at timestamptz,\n  recovery_token varchar(255),\n  recovery_sent_at timestamptz,\n  email_change_token_new varchar(255),\n  email_change varchar(255),\n  email_change_sent_at timestamptz,\n  last_sign_in_at timestamptz,\n  raw_app_meta_data jsonb,\n  raw_user_meta_data jsonb,\n  is_super_admin boolean,\n  created_at timestamptz DEFAULT now(),\n  updated_at timestamptz,\n  phone text,\n  phone_confirmed_at timestamptz,\n  phone_change text,\n  phone_change_token varchar(255),\n  phone_change_sent_at timestamptz,\n  confirmed_at timestamptz,\n  email_change_token_current varchar(255),\n  email_change_confirm_status smallint,\n  banned_until timestamptz,\n  reauthentication_token varchar(255),\n  reauthentication_sent_at timestamptz,\n  is_sso_user boolean DEFAULT false,\n  deleted_at timestamptz,\n  is_anonymous boolean DEFAULT false\n);\nCREATE OR REPLACE FUNCTION auth.uid() RETURNS uuid LANGUAGE sql STABLE AS $$\n  SELECT nullif(current_setting('request.jwt.claim.sub', true), '')::uuid\n$$;\nCREATE OR REPLACE FUNCTION auth.role() RETURNS text LANGUAGE sql STABLE AS $$\n  SELECT coalesce(nullif(current_setting('request.jwt.claim.role', true), ''), 'anon')\n$$;\nCREATE OR REPLACE FUNCTION auth.jwt() RETURNS jsonb LANGUAGE sql STABLE AS $$\n  SELECT coalesce(nullif(current_setting('request.jwt.claims', true), ''), '{}')::jsonb\n$$;\nCREATE OR REPLACE FUNCTION auth.email() RETURNS text LANGUAGE sql STABLE AS $$\n  SELECT nullif(current_setting('request.jwt.claim.email', true), '')\n$$;\nCREATE SCHEMA IF NOT EXISTS cron;\nCREATE TABLE IF NOT EXISTS cron.job (\n  jobid bigint PRIMARY KEY,\n  schedule text,\n  command text,\n  nodename text,\n  nodeport integer,\n  database text,\n  username text,\n  active boolean DEFAULT true,\n  jobname text\n);\nCREATE TABLE IF NOT EXISTS cron.job_run_details (\n  jobid bigint,\n  runid bigint PRIMARY KEY,\n  job_pid integer,\n  database text,\n  username text,\n  command text,\n  status text,\n  return_message text,\n  start_time timestamptz,\n  end_time timestamptz\n);\n";
+//# sourceMappingURL=verify-environment.d.ts.map

package/dist/verify-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-environment.d.ts","sourceRoot":"","sources":["../src/verify-environment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AACjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG5C,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAexF;AAQD,eAAO,MAAM,0BAA0B,k1EA2EtC,CAAC"}

package/dist/verify-environment.js

@@ -0,0 +1,92 @@
+import { diagnostic } from "./diagnostics.js";
+export async function preflightCapability(admin) {
+    const result = await admin.query("SELECT (rolcreatedb OR rolsuper) AS can_create FROM pg_catalog.pg_roles WHERE rolname = current_user");
+    if (result.rows[0]?.can_create === true) {
+        return undefined;
+    }
+    return diagnostic("SUPA_VERIFY_ROLE_CAPABILITY", "error", "the verification role cannot CREATE DATABASE", {
+        hint: "Use a role with CREATEDB. On a local Supabase stack, `postgres` lacks superuser for many extensions too — prefer `supabase_admin` (postgresql://supabase_admin:postgres@127.0.0.1:<db.port>/postgres).",
+    });
+}
+// The stub mirrors the stable GoTrue auth.users column set so that RLS
+// policies, foreign keys, and views referencing auth.users columns
+// (role, email, phone, raw_app_meta_data, ...) resolve during verify
+// instead of failing with a false-negative undefined-column error. auth
+// is a managed schema, so user trees only reference it; a wider stub is
+// pure reference-resolution benefit and is subtracted from reconvergence.
+export const supabaseEnvironmentStubSql = `
+CREATE SCHEMA IF NOT EXISTS auth;
+CREATE TABLE IF NOT EXISTS auth.users (
+  instance_id uuid,
+  id uuid PRIMARY KEY,
+  aud varchar(255),
+  role varchar(255),
+  email varchar(255),
+  encrypted_password varchar(255),
+  email_confirmed_at timestamptz,
+  invited_at timestamptz,
+  confirmation_token varchar(255),
+  confirmation_sent_at timestamptz,
+  recovery_token varchar(255),
+  recovery_sent_at timestamptz,
+  email_change_token_new varchar(255),
+  email_change varchar(255),
+  email_change_sent_at timestamptz,
+  last_sign_in_at timestamptz,
+  raw_app_meta_data jsonb,
+  raw_user_meta_data jsonb,
+  is_super_admin boolean,
+  created_at timestamptz DEFAULT now(),
+  updated_at timestamptz,
+  phone text,
+  phone_confirmed_at timestamptz,
+  phone_change text,
+  phone_change_token varchar(255),
+  phone_change_sent_at timestamptz,
+  confirmed_at timestamptz,
+  email_change_token_current varchar(255),
+  email_change_confirm_status smallint,
+  banned_until timestamptz,
+  reauthentication_token varchar(255),
+  reauthentication_sent_at timestamptz,
+  is_sso_user boolean DEFAULT false,
+  deleted_at timestamptz,
+  is_anonymous boolean DEFAULT false
+);
+CREATE OR REPLACE FUNCTION auth.uid() RETURNS uuid LANGUAGE sql STABLE AS $$
+  SELECT nullif(current_setting('request.jwt.claim.sub', true), '')::uuid
+$$;
+CREATE OR REPLACE FUNCTION auth.role() RETURNS text LANGUAGE sql STABLE AS $$
+  SELECT coalesce(nullif(current_setting('request.jwt.claim.role', true), ''), 'anon')
+$$;
+CREATE OR REPLACE FUNCTION auth.jwt() RETURNS jsonb LANGUAGE sql STABLE AS $$
+  SELECT coalesce(nullif(current_setting('request.jwt.claims', true), ''), '{}')::jsonb
+$$;
+CREATE OR REPLACE FUNCTION auth.email() RETURNS text LANGUAGE sql STABLE AS $$
+  SELECT nullif(current_setting('request.jwt.claim.email', true), '')
+$$;
+CREATE SCHEMA IF NOT EXISTS cron;
+CREATE TABLE IF NOT EXISTS cron.job (
+  jobid bigint PRIMARY KEY,
+  schedule text,
+  command text,
+  nodename text,
+  nodeport integer,
+  database text,
+  username text,
+  active boolean DEFAULT true,
+  jobname text
+);
+CREATE TABLE IF NOT EXISTS cron.job_run_details (
+  jobid bigint,
+  runid bigint PRIMARY KEY,
+  job_pid integer,
+  database text,
+  username text,
+  command text,
+  status text,
+  return_message text,
+  start_time timestamptz,
+  end_time timestamptz
+);
+`;

package/dist/verify.d.ts

@@ -0,0 +1,3 @@
+import type { Diagnostic, VerifyMigrationOptions } from "./core.js";
+export declare function verifyMigration(options: VerifyMigrationOptions): Promise<Diagnostic[]>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../src/verify.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAA+B,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAkBjG,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CA8K5F"}