better-supabase 0.3.0 → 0.4.0

package/dist/cli/gen-D5cLCULx.js

@@ -0,0 +1,2 @@
+import { n as genCommand } from "./gen-Ccn_p90L.js";
+export { genCommand };

package/dist/cli/index.d.ts

@@ -0,0 +1,493 @@
+import { styleText } from "node:util";
+import { Catalog, CatalogCheck, CatalogColumn, CatalogColumnGrant, CatalogEnum, CatalogForeignKey, CatalogFunction, CatalogFunctionArg, CatalogGrant, CatalogIndex, CatalogPolicy, CatalogTable, CatalogTrigger, CatalogUnique, ExtrasFunction, ExtrasHook, ExtrasHookFunction, ExtrasTable, ForeignKeyAction, GeneratedFile, GeneratorMetadata, ResolvedConfig, Snapshot, SnapshotBucket, SnapshotExtras } from "better-supabase/config";
+import { Casing, Codec, FunctionMeta, RelationMeta, SchemaMeta, TableMeta } from "better-supabase";
+import { GeneratorMetadata as GeneratorMetadata$1, Queryable } from "@supabase/postgrest-typegen";
+//#region ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.d.mts
+//#region src/types.d.ts
+type ArgType = "boolean" | "string" | "enum" | "positional" | undefined;
+type _ArgDef<T extends ArgType, VT extends boolean | number | string> = {
+  type?: T;
+  description?: string;
+  valueHint?: string;
+  alias?: string | string[];
+  default?: VT;
+  required?: boolean;
+  options?: string[];
+};
+type BooleanArgDef = Omit<_ArgDef<"boolean", boolean>, "options"> & {
+  negativeDescription?: string;
+};
+type StringArgDef = Omit<_ArgDef<"string", string>, "options">;
+type EnumArgDef = _ArgDef<"enum", string>;
+type PositionalArgDef = Omit<_ArgDef<"positional", string>, "alias" | "options">;
+type ArgDef = BooleanArgDef | StringArgDef | PositionalArgDef | EnumArgDef;
+type ArgsDef = Record<string, ArgDef>;
+type ResolveParsedArgType<T extends ArgDef, VT> = T extends {
+  default?: any;
+  required?: boolean;
+} ? T["default"] extends NonNullable<VT> ? VT : T["required"] extends true ? VT : VT | undefined : VT | undefined;
+type ParsedPositionalArg<T extends ArgDef> = T extends {
+  type: "positional";
+} ? ResolveParsedArgType<T, string> : never;
+type ParsedStringArg<T extends ArgDef> = T extends {
+  type: "string";
+} ? ResolveParsedArgType<T, string> : never;
+type ParsedBooleanArg<T extends ArgDef> = T extends {
+  type: "boolean";
+} ? ResolveParsedArgType<T, boolean> : never;
+type ParsedEnumArg<T extends ArgDef> = T extends {
+  type: "enum";
+  options: infer U;
+} ? U extends Array<any> ? ResolveParsedArgType<T, U[number]> : never : never;
+type RawArgs = {
+  _: string[];
+};
+type ParsedArg<T extends ArgDef> = T["type"] extends "positional" ? ParsedPositionalArg<T> : T["type"] extends "boolean" ? ParsedBooleanArg<T> : T["type"] extends "string" ? ParsedStringArg<T> : T["type"] extends "enum" ? ParsedEnumArg<T> : never;
+type ParsedArgs$1<T extends ArgsDef = ArgsDef> = RawArgs & { [K in keyof T]: ParsedArg<T[K]>; } & { [K in keyof T as T[K] extends {
+  alias: string;
+} ? T[K]["alias"] : never]: ParsedArg<T[K]>; } & { [K in keyof T as T[K] extends {
+  alias: string[];
+} ? T[K]["alias"][number] : never]: ParsedArg<T[K]>; } & Record<string, string | number | boolean | string[]>;
+interface CommandMeta {
+  name?: string;
+  version?: string;
+  description?: string;
+  hidden?: boolean;
+  alias?: string | string[];
+}
+type SubCommandsDef = Record<string, Resolvable<CommandDef<any>>>;
+type CommandDef<T extends ArgsDef = ArgsDef> = {
+  meta?: Resolvable<CommandMeta>;
+  args?: Resolvable<T>;
+  default?: Resolvable<string>;
+  subCommands?: Resolvable<SubCommandsDef>;
+  plugins?: Resolvable<CittyPlugin>[];
+  setup?: (context: CommandContext$1<T>) => any | Promise<any>;
+  cleanup?: (context: CommandContext$1<T>) => any | Promise<any>;
+  run?: (context: CommandContext$1<T>) => any | Promise<any>;
+};
+type CommandContext$1<T extends ArgsDef = ArgsDef> = {
+  rawArgs: string[];
+  args: ParsedArgs$1<T>;
+  cmd: CommandDef<T>;
+  subCommand?: CommandDef<T>;
+  data?: any;
+};
+type CittyPlugin = {
+  name: string;
+  setup?(context: CommandContext$1<any>): void | Promise<void>;
+  cleanup?(context: CommandContext$1<any>): void | Promise<void>;
+};
+type Resolvable<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+//#endregion
+//#region src/cli/env.d.ts
+/** The environment variables the CLI reads, validated once per run. */
+interface CliEnv {
+  /** Postgres connection string for gen, introspect, doctor and seed. */
+  readonly DATABASE_URL?: string | undefined;
+  /** Personal access token for reading a hosted project. */
+  readonly SUPABASE_ACCESS_TOKEN?: string | undefined;
+  /** Management API base URL; defaults to https://api.supabase.com. */
+  readonly SUPABASE_API_URL?: string | undefined;
+  /** The Supabase CLI to run instead of `supabase` on the PATH. */
+  readonly SUPABASE_BIN?: string | undefined;
+  /** Home directory for `skills install --global`. */
+  readonly HOME?: string | undefined;
+  /** Set in CI; prompts never run there. */
+  readonly CI?: string | undefined;
+}
+//#endregion
+//#region src/cli/prompts.d.ts
+interface Choice<T extends string> {
+  readonly value: T;
+  readonly label: string;
+  readonly hint?: string;
+}
+/**
+ * Questions and progress for a person at a terminal. `run()` only gets one
+ * from the bin on a TTY outside CI; every method resolves `undefined` when the
+ * person cancels.
+ */
+interface Prompter {
+  readonly select: <T extends string>(message: string, choices: readonly Choice<T>[], initial: T) => Promise<T | undefined>;
+  readonly multiselect: <T extends string>(message: string, choices: readonly Choice<T>[], initial: readonly T[]) => Promise<T[] | undefined>;
+  readonly confirm: (message: string) => Promise<boolean | undefined>;
+  /** Shows `message` with a spinner until the returned function is called. */
+  readonly spinner: (message: string) => () => void;
+}
+//#endregion
+//#region src/cli/io.d.ts
+interface CliIo {
+  readonly stdout: (text: string) => void;
+  readonly stderr: (text: string) => void;
+  /** All of stdin, for the `--*-stdin` flags that keep secrets out of arguments. */
+  readonly stdin?: () => Promise<string>;
+  /** Color the output with ANSI escapes. Off unless set. */
+  readonly color?: boolean;
+  /**
+   * Prompts and spinners for a person at a terminal. `run()` drops them in
+   * CI and under `--json` or `--yes`, and without them commands never ask.
+   */
+  readonly prompts?: Prompter;
+}
+interface RunResult {
+  readonly code: number;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+interface CommandResult {
+  readonly code: number;
+  readonly output?: string;
+  readonly error?: string;
+  /** The JSON document `--json` prints instead of `output`. */
+  readonly data?: unknown;
+}
+//#endregion
+//#region src/cli/command.d.ts
+/** What `run()` hands every command next to its parsed arguments. */
+interface CliContext {
+  readonly cwd: string;
+  readonly config: ResolvedConfig;
+  /** `prompts` is unset in CI and under `--json` or `--yes`. */
+  readonly io: CliIo;
+  readonly env: CliEnv;
+  /** `--json`: return `data`, which `run()` prints as the one JSON document. */
+  readonly json: boolean;
+  readonly signal: AbortSignal | undefined;
+}
+/** Options every command accepts; `run()` reads them before the command starts. */
+declare const GLOBAL_ARGS: {
+  readonly cwd: {
+    readonly type: "string";
+    readonly description: "Project directory";
+    readonly valueHint: "dir";
+  };
+  readonly config: {
+    readonly type: "string";
+    readonly description: "Config file, relative to --cwd";
+    readonly valueHint: "file";
+  };
+  readonly json: {
+    readonly type: "boolean";
+    readonly description: "Print one JSON document on stdout; errors as Problem Details";
+  };
+  readonly yes: {
+    readonly type: "boolean";
+    readonly alias: "y";
+    readonly description: "Ask nothing; use the flags and the defaults";
+  };
+};
+type CliArgs<T extends ArgsDef> = ParsedArgs$1<T & typeof GLOBAL_ARGS>;
+interface CliCommandDef<T extends ArgsDef> {
+  readonly meta: CommandMeta & {
+    readonly name: string;
+  };
+  readonly args: T;
+  /** String options that take a list: comma-separated, repeated, or both. */
+  readonly lists?: readonly (keyof T & string)[];
+  readonly run: (args: CliArgs<T>, context: CliContext) => Promise<CommandResult>;
+}
+/** Any citty command, whatever its arguments. */
+type AnyCommand = Exclude<SubCommandsDef[string], Promise<unknown> | (() => unknown)>;
+/** A citty command that receives the `CliContext` and returns a `CommandResult`. */
+export declare function defineCliCommand<const T extends ArgsDef>(def: CliCommandDef<T>): AnyCommand;
+/** Splits a comma-separated option into its trimmed, non-empty parts. */
+export declare function list(value: string | undefined): string[];
+//#endregion
+//#region src/cli/legacy.d.ts
+type FlagValue = string | boolean | readonly string[];
+/** The arguments of a `(context) => CommandResult` command, parsed the 0.2 way. */
+interface ParsedArgs {
+  readonly command: string | undefined;
+  readonly rest: readonly string[];
+  readonly flags: Readonly<Record<string, FlagValue>>;
+}
+/** What a `(context) => CommandResult` command receives. */
+interface CommandContext {
+  readonly args: ParsedArgs;
+  readonly cwd: string;
+  readonly config: ResolvedConfig;
+  readonly io: CliIo;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly signal: AbortSignal | undefined;
+}
+/** The command shape before 0.3; `registerCommand` still accepts it, deprecated. */
+type Command = (context: CommandContext) => Promise<CommandResult>;
+//#endregion
+//#region src/cli/run.d.ts
+/** Registers a citty command; `defineCliCommand` gives it the `CliContext`. */
+export declare function registerCommand(name: string, command: AnyCommand): void;
+/** @deprecated Pass a citty `CommandDef` from `defineCliCommand` instead. */
+export declare function registerCommand(name: string, command: Command, help?: string): void;
+/** The usage text for the CLI, or for one command; plain unless `color` is set. */
+export declare function help(command?: string, color?: boolean): Promise<string>;
+interface RunOptions {
+  /** Directory `--cwd` is relative to. */
+  readonly cwd?: string;
+  /** Environment variables. Empty unless passed; the bin passes `process.env`. */
+  readonly env?: Readonly<Record<string, string | undefined>>;
+  readonly io?: CliIo;
+  readonly signal?: AbortSignal;
+}
+/** The names `run()` dispatches, registered commands included. */
+export declare function commandNames(): string[];
+/** Runs the CLI. Never exits the process; returns the exit code and output. */
+export declare function run(argv: readonly string[], options?: RunOptions): Promise<RunResult>;
+//#endregion
+//#region src/cli/errors.d.ts
+/** `1` for a failure, `2` for a usage error the caller can fix by changing the command. */
+type ExitCode = 1 | 2;
+type CliErrorCode = "usage" | "unknown_command" | "missing_value" | "config_not_found" | "config_invalid" | "env_invalid" | "failed" | "internal";
+/** Each code has a heading on this page, so `type` links to its explanation. */
+export declare const CLI_ERRORS_URL = "https://bettersupabase.com/docs/cli/errors";
+/** RFC 9457 Problem Details for a CLI error. `--json` prints it on stdout. */
+interface CliProblem {
+  readonly type: string;
+  readonly title: string;
+  readonly detail: string;
+  readonly code: CliErrorCode;
+  readonly exitCode: number;
+  /** The closest command, for `unknown_command`. */
+  readonly suggestion?: string;
+  /** The flag that supplies the value, for `missing_value`. */
+  readonly flag?: string;
+  /** One line per problem, for `config_invalid` and `env_invalid`. */
+  readonly issues?: readonly string[];
+}
+type CliProblemExtensions = Pick<CliProblem, "suggestion" | "flag" | "issues">;
+interface CliErrorOptions extends CliProblemExtensions {
+  readonly exitCode?: number;
+  readonly cause?: unknown;
+}
+/** An error the CLI reports as text, or as Problem Details under `--json`. */
+export declare class CliError extends Error {
+  override readonly name = "CliError";
+  readonly code: CliErrorCode;
+  readonly exitCode: number;
+  readonly problem: CliProblem;
+  constructor(code: CliErrorCode, message: string, options?: CliErrorOptions);
+}
+//#endregion
+//#region src/cli/style.d.ts
+type Format = Parameters<typeof styleText>[0];
+/** Styles text, or returns it unchanged when colors are off. */
+type Paint = (format: Format, text: string) => string;
+//#endregion
+//#region src/cli/db.d.ts
+/** The subset of `pg.Client` the CLI uses. */
+interface PgQueryable {
+  query<R = Record<string, unknown>>(text: string, values?: readonly unknown[]): Promise<{
+    rows: R[];
+  }>;
+}
+interface ConnectOptions {
+  /** Opens a pool of this many connections, for callers that query concurrently. */
+  readonly pool?: number;
+  /** Server-side limit for each statement, in milliseconds. */
+  readonly statementTimeout?: number;
+  /** Ends the connection when aborted, so Ctrl-C stops a running query. */
+  readonly signal?: AbortSignal;
+}
+/** A connection that queues its queries, or a pool that runs them concurrently. */
+interface PgConnection {
+  readonly client: PgQueryable;
+  readonly pooled?: boolean;
+  close: () => Promise<void>;
+  describe: string;
+}
+/** Opens a `pg` connection. `pg` is an optional peer, loaded on demand. */
+declare function connect(url: string, load?: () => Promise<unknown>, options?: ConnectOptions): Promise<PgConnection>;
+//#endregion
+//#region src/cli/introspect/source.d.ts
+/** A connection introspection can query, plus how to release it. */
+interface IntrospectionSource {
+  readonly queryable: Queryable;
+  readonly describe: string;
+  close(): Promise<void>;
+}
+/**
+ * A small `pg` pool, since introspection issues its queries concurrently. A
+ * `connect` that returns a single client gets its queries queued, because one
+ * `pg.Client` runs them one at a time.
+ */
+export declare function pgSource(url: string, open?: typeof connect, signal?: AbortSignal): Promise<IntrospectionSource>;
+interface ManagementSourceOptions {
+  readonly projectRef: string;
+  readonly accessToken: string;
+  /** Defaults to `https://api.supabase.com`. */
+  readonly apiUrl?: string;
+  readonly fetch?: typeof fetch;
+  /** Cancels in-flight queries (Ctrl-C). */
+  readonly signal?: AbortSignal;
+}
+/**
+ * Runs introspection SQL through the Supabase Management API as the
+ * read-only database user, so hosted projects need no database password.
+ */
+export declare function managementSource(options: ManagementSourceOptions): IntrospectionSource;
+//#endregion
+//#region src/cli/commands/snapshot.d.ts
+interface SnapshotSource {
+  readonly snapshotPath?: string;
+  readonly dbUrl?: string;
+  readonly projectRef?: string;
+  /** Ignore `source.snapshot` and read the database. */
+  readonly live?: boolean;
+  /** Ends the database connection or Management API request (Ctrl-C). */
+  readonly signal?: AbortSignal;
+  /** Reuses the snapshot cached for an unchanged catalog fingerprint. */
+  readonly cache?: boolean;
+}
+type Env = CliEnv;
+/**
+ * Loads a saved snapshot or introspects the database. With `shared`, it
+ * introspects over that source and leaves closing it to the caller, so later
+ * queries reuse the connection.
+ */
+export declare function loadSnapshot(config: ResolvedConfig, env: Env, source: SnapshotSource, open?: typeof connect, shared?: () => Promise<IntrospectionSource>): Promise<Snapshot>;
+/** Validates a parsed snapshot document. */
+export declare function parseSnapshot(data: unknown, label?: string): Promise<Snapshot>;
+export declare function serializeSnapshot(snapshot: Snapshot): string;
+//#endregion
+//#region src/cli/commands/gen.d.ts
+interface GenOptions extends SnapshotSource {
+  readonly config: ResolvedConfig;
+  readonly env: CliEnv;
+  readonly check: boolean;
+  /** Colors the `--check` diffs. */
+  readonly paint?: Paint;
+  /** Pre-loaded snapshot (tests, watch mode). */
+  readonly snapshot?: Snapshot;
+}
+/**
+ * Renders every generated file for a snapshot, without touching disk:
+ * `database.types.ts` (what `supabase gen types` prints), the main module,
+ * then each configured generator's files.
+ */
+export declare function renderFiles(config: ResolvedConfig, snapshot: Snapshot): Promise<GeneratedFile[]>;
+export declare function runGen(options: GenOptions): Promise<CommandResult>;
+//#endregion
+//#region src/cli/introspect/extras.d.ts
+/** A hook function to introspect: `[auth.hook.<hook>]` pointing at `schema.name`. */
+interface HookTarget {
+  readonly hook: string;
+  readonly schema: string;
+  readonly name: string;
+}
+//#endregion
+//#region src/cli/introspect/catalog.d.ts
+/** Joins the typegen metadata and the extras into one record per object. */
+export declare function toCatalog(snapshot: Snapshot): Catalog;
+//#endregion
+//#region src/cli/introspect/index.d.ts
+interface IntrospectOptions {
+  /** Auth hook functions to read too, in any schema (`[auth.hook.*]`). */
+  readonly hooks?: readonly HookTarget[];
+}
+/** Reads a v2 snapshot: typegen metadata plus the extras. */
+export declare function introspect(db: Queryable, schemas: readonly string[], options?: IntrospectOptions): Promise<Snapshot>;
+//#endregion
+//#region src/cli/introspect/from-catalog.d.ts
+/**
+ * Builds a snapshot from catalog records: the inverse of `toCatalog`. Tests
+ * and benchmarks describe schemas as tables and functions; this produces the
+ * typegen metadata and extras those records imply.
+ */
+export declare function fromCatalog(catalog: Catalog): Snapshot;
+//#endregion
+//#region src/cli/gen/model.d.ts
+interface ColumnModel {
+  readonly app: string;
+  readonly db: string;
+  readonly snapshot: CatalogColumn;
+  /** TypeScript type without `| null`. */
+  readonly tsType: string;
+  readonly nullable: boolean;
+  /** Optional on insert. */
+  readonly optional: boolean;
+  /** Not writable (generated always / identity always). */
+  readonly readonly: boolean;
+  readonly values: readonly string[] | undefined;
+  readonly json: boolean;
+  readonly codec: Codec | undefined;
+  /** Bucket id from `config.storagePaths`. */
+  readonly storage: string | undefined;
+  readonly insertable: boolean;
+  readonly updatable: boolean;
+}
+interface RelationModel {
+  readonly name: string;
+  readonly meta: RelationMeta;
+}
+interface TableModel {
+  readonly key: string;
+  readonly snapshot: CatalogTable;
+  readonly casing: Casing;
+  readonly columns: readonly ColumnModel[];
+  readonly relations: readonly RelationModel[];
+  readonly meta: TableMeta;
+}
+interface EnumModel {
+  readonly schema: string;
+  readonly name: string;
+  /** Constant name for the value array, e.g. `noteKindValues`. */
+  readonly constant: string;
+  readonly values: readonly string[];
+}
+interface FunctionModel {
+  readonly key: string;
+  readonly meta: FunctionMeta;
+  readonly args: readonly {
+    name: string;
+    tsType: string;
+    optional: boolean;
+  }[];
+  readonly returns: string;
+}
+interface JsonImport {
+  readonly name: string;
+  /** Path relative to the project root, without the `#Name` part. */
+  readonly from: string;
+}
+interface Model {
+  readonly tables: readonly TableModel[];
+  readonly enums: readonly EnumModel[];
+  readonly functions: readonly FunctionModel[];
+  readonly jsonImports: readonly JsonImport[];
+  readonly meta: SchemaMeta;
+  readonly config: ResolvedConfig;
+  readonly catalog: Catalog;
+  /** Typegen metadata restricted to the configured schemas. */
+  readonly introspection: GeneratorMetadata$1;
+}
+/** Builds the codegen model from a snapshot and config. */
+export declare function buildModel(snapshot: Snapshot, config: ResolvedConfig): Model;
+//#endregion
+//#region src/cli/gen/emit.d.ts
+export declare const GENERATED_HEADER = "// @generated by better-supabase gen. Do not edit; run `better-supabase gen` instead.";
+interface EmitOptions {
+  /** Import path from the generated module to `better-supabase`. */
+  readonly runtimeImport?: string;
+  /** Import path from the generated module to `database.types.ts`. */
+  readonly databaseTypesImport?: string;
+  /** Import path for each JSON type import, keyed by the configured path. */
+  readonly importPathFor: (from: string) => string;
+  /** Import path from the generated module to the metadata module (`emitMeta`). */
+  readonly metaImport?: string;
+}
+/** Renders the generated module. */
+export declare function emitModule(model: Model, options: EmitOptions): string;
+//#endregion
+//#region src/cli/config.d.ts
+/**
+ * Loads `better-supabase.config.*` with c12 and checks it against the config
+ * schema. c12 imports `.ts` natively (Node 24 strips the types), so no
+ * loader is needed; rc files, `package.json`, env overrides and `extends`
+ * are off so the one file is the whole config.
+ */
+export declare function loadConfig(cwd: string, explicit?: string): Promise<ResolvedConfig>;
+//#endregion
+//#region src/cli/version.d.ts
+export declare const VERSION = "0.4.0";
+//#endregion
+export type { Catalog, CatalogCheck, CatalogColumn, CatalogColumnGrant, CatalogEnum, CatalogForeignKey, CatalogFunction, CatalogFunctionArg, CatalogGrant, CatalogIndex, CatalogPolicy, CatalogTable, CatalogTrigger, CatalogUnique, CliArgs, CliCommandDef, CliContext, CliEnv, CliErrorCode, CliErrorOptions, CliIo, CliProblem, CliProblemExtensions, Command, CommandContext, CommandResult, ExitCode, ExtrasFunction, ExtrasHook, ExtrasHookFunction, ExtrasTable, ForeignKeyAction, GeneratorMetadata, IntrospectionSource, ManagementSourceOptions, ParsedArgs, Queryable, RunOptions, RunResult, Snapshot, SnapshotBucket, SnapshotExtras };

package/dist/cli/index.js

@@ -0,0 +1,184 @@
+import { a as list, r as defineCliCommand } from "./command-CK14fP91.js";
+import { n as CliError, t as CLI_ERRORS_URL } from "./errors-4v4DTtda.js";
+import { i as run, n as help, r as registerCommand, t as commandNames } from "./run-CP20LKk_.js";
+import { t as VERSION } from "./version-5mW_8sY1.js";
+import { a as loadConfig } from "./config-D9R0o1LH.js";
+import { b as emitModule, f as introspect, g as buildModel, i as runGen, k as toCatalog, l as parseSnapshot, m as pgSource, o as loadSnapshot, p as managementSource, r as renderFiles, u as serializeSnapshot, y as GENERATED_HEADER } from "./gen-Ccn_p90L.js";
+//#region src/cli/introspect/from-catalog.ts
+/**
+* Builds a snapshot from catalog records: the inverse of `toCatalog`. Tests
+* and benchmarks describe schemas as tables and functions; this produces the
+* typegen metadata and extras those records imply.
+*/
+function fromCatalog(catalog) {
+	const schemas = [.../* @__PURE__ */ new Set([...catalog.schemas, ...catalog.tables.map((table) => table.schema)])].sort();
+	const meta = {
+		version: 1,
+		schemas: schemas.map((name, index) => ({
+			id: 4e6 + index,
+			name,
+			owner: "postgres"
+		})),
+		tables: [],
+		foreignTables: [],
+		views: [],
+		materializedViews: [],
+		columns: [],
+		primaryKeys: [],
+		relationships: [],
+		functions: [],
+		types: []
+	};
+	const typeIds = /* @__PURE__ */ new Map();
+	const typeId = (schema, name) => {
+		const key = `${schema}.${name}`;
+		let id = typeIds.get(key);
+		if (id === void 0) {
+			id = 2e6 + typeIds.size;
+			typeIds.set(key, id);
+			meta.types.push({
+				id,
+				name,
+				schema,
+				format: name,
+				enums: [],
+				attributes: [],
+				comment: null,
+				type_relation_id: null
+			});
+		}
+		return id;
+	};
+	const enums = new Map(catalog.enums.map((entry) => [`${entry.schema}.${entry.name}`, entry]));
+	for (const entry of catalog.enums) {
+		const id = typeId(entry.schema, entry.name);
+		const type = meta.types.find((candidate) => candidate.id === id);
+		type.enums = [...entry.values];
+	}
+	const column = (table, id, entry, index) => ({
+		table_id: id,
+		schema: table.schema,
+		table: table.name,
+		id: `${id}.${index + 1}`,
+		ordinal_position: index + 1,
+		name: entry.name,
+		default_value: entry.default,
+		data_type: entry.isArray ? "ARRAY" : entry.isEnum ? "USER-DEFINED" : entry.udt,
+		format: entry.format,
+		type_schema: entry.typeSchema,
+		is_identity: entry.identity !== null,
+		identity_generation: entry.identity === "always" ? "ALWAYS" : entry.identity === "by default" ? "BY DEFAULT" : null,
+		is_generated: entry.generated,
+		is_nullable: entry.nullable,
+		is_updatable: entry.updatable,
+		is_unique: false,
+		enums: entry.isEnum ? [...enums.get(`${entry.typeSchema}.${entry.udt}`)?.values ?? []] : [],
+		check: null,
+		comment: entry.comment
+	});
+	catalog.tables.forEach((table, index) => {
+		const id = table.id || 1e6 + index;
+		if (table.kind === "table") meta.tables.push({
+			id,
+			schema: table.schema,
+			name: table.name,
+			rls_enabled: table.rls,
+			rls_forced: table.forceRls,
+			replica_identity: table.replicaIdentity ?? "DEFAULT",
+			bytes: 0,
+			size: "0 bytes",
+			live_rows_estimate: 0,
+			dead_rows_estimate: 0,
+			comment: table.comment
+		});
+		else meta.views.push({
+			id,
+			schema: table.schema,
+			name: table.name,
+			is_updatable: table.insertable || table.updatable,
+			is_insert_enabled: table.insertable,
+			is_update_enabled: table.updatable,
+			comment: table.comment
+		});
+		for (const [position, entry] of table.columns.entries()) meta.columns.push(column(table, id, entry, position));
+		for (const name of table.primaryKey) meta.primaryKeys.push({
+			schema: table.schema,
+			table_name: table.name,
+			name,
+			table_id: id
+		});
+		for (const fk of table.foreignKeys) meta.relationships.push({
+			foreign_key_name: fk.name,
+			schema: table.schema,
+			relation: table.name,
+			columns: [...fk.columns],
+			is_one_to_one: fk.oneToOne,
+			referenced_schema: fk.refSchema,
+			referenced_relation: fk.refTable,
+			referenced_columns: [...fk.refColumns]
+		});
+	});
+	const relationIds = new Map([...meta.tables, ...meta.views].map((entry) => [`${entry.schema}.${entry.name}`, entry.id]));
+	const argType = (schema, udt) => typeId(enums.has(`${schema}.${udt}`) ? schema : "pg_catalog", udt);
+	catalog.functions.forEach((fn, index) => {
+		const args = [...fn.args.map((arg) => ({
+			mode: "in",
+			name: arg.name,
+			type_id: argType(fn.schema, arg.isArray ? `_${arg.udt}` : arg.udt),
+			has_default: arg.hasDefault
+		})), ...(fn.returnsTable ?? []).map((entry) => ({
+			mode: "table",
+			name: entry.name,
+			type_id: argType(fn.schema, entry.udt),
+			has_default: false
+		}))];
+		meta.functions.push({
+			id: 3e6 + index,
+			schema: fn.schema,
+			name: fn.name,
+			language: fn.language,
+			definition: "",
+			complete_statement: "",
+			args,
+			argument_types: fn.signature,
+			identity_argument_types: fn.signature,
+			return_type_id: fn.returnsRelation ? typeId(fn.returnsRelation.split(".")[0], fn.returns) : argType(fn.schema, fn.returns),
+			return_type: fn.returns,
+			return_type_relation_id: fn.returnsRelation ? relationIds.get(fn.returnsRelation) ?? null : null,
+			is_set_returning_function: fn.returnsSet,
+			prorows: null,
+			behavior: fn.volatility.toUpperCase(),
+			security_definer: fn.securityDefiner,
+			config_params: fn.searchPath === null ? null : { search_path: fn.searchPath === "" ? "\"\"" : fn.searchPath }
+		});
+	});
+	return {
+		version: 2,
+		schemas,
+		generator: meta,
+		extras: {
+			tables: catalog.tables.map((table, index) => ({
+				id: table.id || 1e6 + index,
+				schema: table.schema,
+				name: table.name,
+				primaryKey: table.primaryKey,
+				uniques: table.uniques,
+				foreignKeys: table.foreignKeys.map((fk) => ({
+					name: fk.name,
+					onDelete: fk.onDelete,
+					onUpdate: fk.onUpdate
+				})),
+				checks: table.checks,
+				indexes: table.indexes,
+				policies: table.policies,
+				triggers: table.triggers,
+				grants: table.grants,
+				...table.columnGrants ? { columnGrants: table.columnGrants } : {}
+			})),
+			buckets: catalog.buckets,
+			realtime: catalog.realtime
+		}
+	};
+}
+//#endregion
+export { CLI_ERRORS_URL, CliError, GENERATED_HEADER, VERSION, buildModel, commandNames, defineCliCommand, emitModule, fromCatalog, help, introspect, list, loadConfig, loadSnapshot, managementSource, parseSnapshot, pgSource, registerCommand, renderFiles, run, runGen, serializeSnapshot, toCatalog };