@rebasepro/server-postgres 0.21.2-canary.g1ea48be → 0.23.0

package/dist/schema/atlas-argv.d.ts

@@ -54,5 +54,20 @@ export interface AtlasInvocation {
  * instead, with `stripCarvedOutStatements`.
  */
 export declare function acceptsExcludeFlag(domain: string, args: string[]): boolean;
+/**
+ * Does this Atlas invocation plan against the scratch database (`--dev-url`)?
+ *
+ * `schema apply` and `migrate diff` do; `migrate apply`, `hash` and `status`
+ * never read it, so `db migrate` has no reason to create one.
+ */
+export declare function takesDevUrl(domain: string, args: string[]): boolean;
 /** Assemble the full argv, connection flags and all. */
 export declare function buildAtlasArgs(invocation: AtlasInvocation): string[];
+/**
+ * `atlas migrate apply`'s own arguments for `rebase db migrate`.
+ *
+ * `positionals` are what is left of the user's line once every flag the
+ * driver knows has been consumed — at most the optional amount Atlas takes. A
+ * flag reaching here is a flag Atlas rejects before doing any work.
+ */
+export declare function migrateApplyArgs(positionals: string[], baseline: string | undefined): string[];

package/dist/schema/column-plan-helpers.d.ts

@@ -44,12 +44,31 @@ export declare const resolveColumnName: (propName: string, prop?: Property | nul
  * config was written. Refused here instead, where the collection has a name.
  */
 export declare const assertSinglePrimaryKey: (collection: CollectionConfig) => void;
-export declare const getPrimaryKeyProp: (collection: CollectionConfig) => {
+/**
+ * A collection's primary key, by both of its names.
+ *
+ * `name` is the property key — what the generated Drizzle table is keyed by,
+ * so it is what a relation's `references` names. `column` is the SQL
+ * identifier, so it is what a foreign key's `REFERENCES` names. They differ
+ * whenever the key is camelCase or carries a `columnName` (`authorId` is
+ * `author_id`, and every table `rebase schema introspect` adopts is spelled
+ * that way), and a constraint written with the key named a column that does
+ * not exist: `db push` could not build its desired state, and boot failed the
+ * constraint on every start.
+ */
+export interface PrimaryKey {
+    /** Property key: the Drizzle object key and the JSON field. */
     name: string;
-    type: "string" | "number";
-    isUuid: boolean;
-};
+    /** SQL column. */
+    column: string;
+    /** The declaring property; absent for the implicit `id TEXT` of a collection that declares none. */
+    prop?: Property;
+}
+export declare const getPrimaryKeyProp: (collection: CollectionConfig) => PrimaryKey;
+/** The primary key's property key. What a Drizzle relation's `references` names. */
 export declare const getPrimaryKeyName: (collection: CollectionConfig) => string;
+/** The primary key's column. What a foreign key's `REFERENCES` names. */
+export declare const getPrimaryKeyColumn: (collection: CollectionConfig) => string;
 export declare const isIdProperty: (propName: string, prop: Property, collection: CollectionConfig) => boolean;
 /**
  * The labels an `enum` declares, in order, whichever form it was written in.

package/dist/schema/destructive-sql.d.ts

@@ -9,6 +9,13 @@
  * here, and refuse to auto-approve anything destructive without an explicit
  * opt-in.
  *
+ * A type change is the one destructive plan that names no DROP. `ALTER COLUMN
+ * "price" TYPE integer` rounds every 19.99 to 20, and `TYPE date` throws away
+ * every timestamp's time of day, in a statement that reads like a routine
+ * alter. So a type change is gated too, unless it is a widening every value
+ * survives unchanged — which needs the column's current type, read from the
+ * catalogue by the caller.
+ *
  * Everything in this file is side-effect free so it can be unit-tested
  * without Atlas or a database.
  */
@@ -24,13 +31,57 @@ export interface DestructiveStatement {
     statement: string;
     /** Which destructive operation it was flagged for, e.g. "DROP COLUMN". */
     kind: string;
+    /**
+     * What in the statement loses data, when the kind alone does not say:
+     * for `ALTER COLUMN TYPE`, each lossy column with its old and new type.
+     */
+    detail?: string;
+}
+/** A column as the database has it now, with its type as `format_type` spells it. */
+export interface ExistingColumnType {
+    schema: string;
+    table: string;
+    column: string;
+    /** e.g. `character varying(255)`, `numeric(10,2)`, `timestamp with time zone`. */
+    type: string;
 }
+/**
+ * Every column of every ordinary table outside the system schemas, with its
+ * type. What {@link detectDestructiveStatements} compares a planned type
+ * change against; `format_type` because it carries the modifier (`(255)`,
+ * `(10,2)`) that decides whether a change widens or narrows.
+ */
+export declare const COLUMN_TYPES_SQL = "\n    SELECT n.nspname AS \"schema\",\n           c.relname AS \"table\",\n           a.attname AS \"column\",\n           format_type(a.atttypid, a.atttypmod) AS \"type\"\n    FROM pg_attribute a\n    JOIN pg_class c     ON c.oid = a.attrelid\n    JOIN pg_namespace n ON n.oid = c.relnamespace\n    WHERE c.relkind IN ('r', 'p')\n      AND a.attnum > 0\n      AND NOT a.attisdropped\n      AND n.nspname NOT IN ('pg_catalog', 'information_schema')\n      AND n.nspname NOT LIKE 'pg\\_%'\n";
 /**
  * Scan an Atlas plan (the SQL printed by `schema apply --dry-run`) and return
  * the statements that would destroy data. An empty array means the plan is
  * safe to auto-approve.
+ *
+ * `columnTypes` is what the database holds now. A type change to a column it
+ * does not list is flagged: not knowing what a column is means not knowing
+ * whether the change keeps its values.
+ */
+export declare function detectDestructiveStatements(planSql: string, columnTypes?: readonly ExistingColumnType[]): DestructiveStatement[];
+/**
+ * Is `ALTER COLUMN … TYPE to` a widening, one that keeps every value exactly
+ * as it was?
+ *
+ * Deliberately short. Everything not listed needs a confirmation, including
+ * changes that are usually harmless: `timestamp` → `timestamptz` reads each
+ * value in the session's time zone, `json` → `jsonb` drops duplicate keys,
+ * `real` → `double precision` prints 0.1 as 0.100000001490116, and `integer` →
+ * `text` keeps the digits but changes what the column is.
+ *
+ *  - the same type, with a modifier at least as wide (`varchar(100)` →
+ *    `varchar(255)`, `numeric(10,2)` → `numeric(12,2)` or unbounded,
+ *    `timestamptz(3)` → `timestamptz`);
+ *  - `smallint` → `integer` → `bigint`, and any of them to a `numeric` with
+ *    room for all their digits;
+ *  - `varchar(n)` → `text`, and `text` → an unbounded `varchar`.
+ *
+ * Arrays follow their element type, and never gain or lose a dimension.
  */
-export declare function detectDestructiveStatements(planSql: string): DestructiveStatement[];
+export declare function isLosslessTypeChange(from: string, to: string): boolean;
 export type PushDecision = "apply" | "confirm" | "refuse";
 /**
  * Decide how `db push` should proceed given the plan's destructiveness and

package/dist/schema/doctor-cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { i as diagnoseDbError } from "../cli-errors-Dka89exj.js";
+import { i as diagnoseDbError } from "../cli-errors-B8qHg02P.js";
 import { o as validatePolicyPgRoles, s as warnOnAnonymousGrants } from "../rls-enforcement-C6Xk0lA6.js";
 import { t as chalk } from "../source-Br7L7GOI.js";
-import { n as loadCollections, r as runDoctor } from "../doctor-Gzzd8wTq.js";
-import { n as formatPolicyDrift, r as hasDrift, t as checkPolicyDrift } from "../policy-drift-B0GDRh7_.js";
+import { n as loadCollections, r as runDoctor } from "../doctor-Cb2thZ8s.js";
+import { n as formatPolicyDrift, r as hasDrift, t as checkPolicyDrift } from "../policy-drift-DljYdrpW.js";
 import path from "path";
 //#region src/schema/doctor-policy-checks.ts
 /**

package/dist/schema/generate-drizzle-schema.js

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { t as main } from "../generate-drizzle-schema-D2MDdJt-.js";
+import { t as main } from "../generate-drizzle-schema-yzY_BLhr.js";
 //#region src/schema/bin/generate-drizzle-schema.ts
 /**
 * The built entry point for `generate-drizzle-schema`.

package/dist/schema/generate-postgres-ddl.js

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as generatePostgresVectorDdl, i as generatePostgresTriggersDdl, n as generatePostgresPoliciesDdl, r as generatePostgresSearchDdl, t as generatePostgresDdl } from "../generate-postgres-ddl-logic-CR2xcS7e.js";
+import { a as generatePostgresVectorDdl, i as generatePostgresTriggersDdl, n as generatePostgresPoliciesDdl, r as generatePostgresSearchDdl, t as generatePostgresDdl } from "../generate-postgres-ddl-logic-Bt2d2mRH.js";
 import { n as outError, t as out } from "../cli-output-CNdMql-L.js";
 import { loadCollectionsFromDirectory } from "@rebasepro/server";
 import { declaredDatabaseExtensions } from "@rebasepro/types";

package/dist/schema/introspect-db.js

@@ -1,9 +1,9 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
 import { a as __toESM, t as require___vite_browser_external } from "../__vite-browser-external-BnuHet1e.js";
+import { _ as isUsableFileName, a as generateCollectionFile, f as classifyTables, g as countRowsUpTo, i as buildTablesMap, l as mergeIndexContent, o as generateIndexContent, p as lookupCandidates, r as buildEnumMap, u as safeHostFromUrl, v as quoteRelation, y as readSchemaMetadata } from "../introspect-db-logic-WMuAfxvw.js";
 import { n as outError, r as outWarn, t as out } from "../cli-output-CNdMql-L.js";
 import { t as chalk } from "../source-Br7L7GOI.js";
-import { a as generateCollectionFile, f as classifyTables, i as buildTablesMap, l as mergeIndexContent, o as generateIndexContent, p as lookupCandidates, r as buildEnumMap, u as safeHostFromUrl } from "../introspect-db-logic-C6LQdTxj.js";
 import { t as require_arg } from "../arg-Dni7MzLB.js";
 import pg from "pg";
 import fs from "fs";
@@ -77,317 +77,6 @@ function detectCollectionBuilder(outDir) {
 	return "annotation";
 }
 //#endregion
-//#region src/schema/introspect-db-queries.ts
-/**
-* A Postgres identifier, quoted so that whatever is inside it stays inside it.
-*
-* Introspection reads table and schema names out of `pg_class` and puts them
-* straight back into SQL, and wrapping a name in double quotes is not the same
-* as escaping it: a table named `x" ; DROP TABLE users; --` closes the quote
-* and then the statement. Postgres's own escape for a quote inside a quoted
-* identifier is to double it, which is what this does.
-*
-* "The catalogue is trusted" is true of your own database, and is exactly the
-* assumption this tool cannot make. Introspection exists to be pointed at
-* databases somebody else built, and it runs with the privileges of whoever
-* ran it — which is usually a superuser, because that is who has a connection
-* string to a database they are adopting.
-*/
-function quoteIdentifier(name) {
-	return `"${name.replace(/"/g, "\"\"")}"`;
-}
-/** `"schema"."table"`, both halves quoted. */
-function quoteRelation(schema, table) {
-	return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
-}
-/**
-* Can this table's name be the name of the file describing it?
-*
-* Introspection writes `<collectionsDir>/<tableName>.ts`, and the table name
-* came from a database this tool did not create. Postgres will hold a table
-* called `../../../etc/cron.d/x`, and `path.join` resolves it — so without this
-* the generator writes a file wherever the name points, as whoever ran the
-* command.
-*
-* Deliberately narrow, and deliberately not a blocklist of `..` and `/`: the
-* question is "is this a plain file name?", and every answer that is not
-* obviously yes is a table better written by hand. NUL and the Windows
-* separator are in scope because a collections directory is checked out on
-* whatever machine the developer has.
-*/
-function isUsableFileName(name) {
-	if (name.length === 0 || name.length > 200) return false;
-	if (name === "." || name === "..") return false;
-	if (/[/\\:\u0000-\u001f]/.test(name)) return false;
-	return !name.startsWith(".") && !name.endsWith(".");
-}
-/**
-* Base tables, excluding partitions.
-*
-* `relispartition` is the reason this reads `pg_class` rather than
-* `information_schema.tables`, which reports every partition as a base table of
-* its own. Pagila partitions `payment` by month; introspected through
-* information_schema it yields `payment` plus 26 near-identical
-* `payment_p2022_*` collections, each with its own nav entry.
-*
-* `relkind = 'p'` (the partitioned parent) is included and `'r'` partitions are
-* dropped, which is the right way round: the parent is the queryable table.
-*/
-var TABLES_QUERY = `
-    SELECT c.relname AS table_name,
-           c.relkind = 'p' AS is_partitioned
-    FROM pg_class c
-    JOIN pg_namespace n ON n.oid = c.relnamespace
-    WHERE n.nspname = $1
-      AND c.relkind IN ('r', 'p')
-      AND NOT c.relispartition
-      AND c.relname NOT LIKE 'drizzle_%'
-      AND c.relname NOT LIKE 'rebase_%'
-    ORDER BY c.relname
-`;
-/**
-* Columns, with the catalog facts that say a column is not the user's to edit.
-*
-* `is_generated`/`is_identity` are read for that reason: a generated column
-* rejects any write, so a form that offers it is offering a field that always
-* errors. `character_maximum_length` is the declared `varchar(n)` bound —
-* already enforced by the database, and free to surface as validation.
-*/
-var COLUMNS_QUERY = `
-    SELECT
-        c.table_name,
-        c.column_name,
-        c.data_type,
-        c.udt_name,
-        c.is_nullable,
-        c.column_default,
-        c.ordinal_position,
-        c.is_generated,
-        c.is_identity,
-        c.identity_generation,
-        c.character_maximum_length,
-        c.numeric_precision,
-        c.numeric_scale,
-        (SELECT a.atttypmod FROM pg_attribute a
-         JOIN pg_class pc ON a.attrelid = pc.oid
-         WHERE pc.relname = c.table_name
-           AND a.attname = c.column_name
-           AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod
-    FROM information_schema.columns c
-    WHERE c.table_schema = $1
-    ORDER BY c.table_name, c.ordinal_position
-`;
-var ENUMS_QUERY = `
-    SELECT t.typname AS enum_name,
-           e.enumlabel AS enum_value,
-           e.enumsortorder AS sort_order
-    FROM pg_type t
-    JOIN pg_enum e ON t.oid = e.enumtypid
-    JOIN pg_namespace n ON t.typnamespace = n.oid
-    WHERE n.nspname = $1
-    ORDER BY t.typname, e.enumsortorder
-`;
-/**
-* Primary key columns, in key order.
-*
-* `ORDER BY k.ord` matters for composite keys: the position of a column inside
-* the key is what tells a two-column PK made of two foreign keys apart from an
-* ordinary composite key, and `= ANY(i.indkey)` (the shape this replaced)
-* returns catalog order instead.
-*/
-var PRIMARY_KEYS_QUERY = `
-    SELECT t.relname AS table_name,
-           a.attname AS column_name
-    FROM pg_index i
-    JOIN pg_class t ON t.oid = i.indrelid
-    JOIN pg_namespace n ON n.oid = t.relnamespace
-    CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord)
-    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum
-    WHERE i.indisprimary AND n.nspname = $1
-    ORDER BY t.relname, k.ord
-`;
-/**
-* Foreign keys, one row per referencing column, with the delete rule.
-*
-* Read from `pg_constraint` rather than through
-* `information_schema.constraint_column_usage`, which does not preserve the
-* pairing on a composite foreign key: it reports the cross product of the
-* constraint's columns, so a two-column FK comes back as four rows, two of them
-* pairing the wrong columns. `unnest(...) WITH ORDINALITY` on both sides joined
-* on the ordinal keeps each referencing column with the column it references.
-*
-* `confdeltype` is carried because `ON DELETE CASCADE` is the schema author
-* saying, in the database, that the child cannot outlive the parent — the one
-* unambiguous declaration of ownership a schema contains.
-*
-* Constraints declared on a *partition* are attributed to the partition root,
-* because that is the table this run generates a collection for. Pagila declares
-* `payment`'s three foreign keys on each monthly partition and none on the
-* parent, so reading `pg_constraint` at face value gives the `payment`
-* collection no relations at all. `pick = 1` then keeps one row per logical key,
-* preferring the root's own constraint when it has one, so a schema that
-* declares the key on the parent *and* inherits it onto 26 partitions does not
-* yield 27 copies of the same relation.
-*/
-var FOREIGN_KEYS_QUERY = `
-    WITH fk AS (
-        SELECT con.oid,
-               con.conname,
-               con.conrelid,
-               con.confrelid,
-               con.conkey,
-               con.confkey,
-               con.confdeltype,
-               COALESCE(pg_partition_root(con.conrelid), con.conrelid) AS root_oid,
-               row_number() OVER (
-                   PARTITION BY COALESCE(pg_partition_root(con.conrelid), con.conrelid),
-                                con.confrelid, con.conkey, con.confkey
-                   ORDER BY (con.conrelid = COALESCE(pg_partition_root(con.conrelid), con.conrelid)) DESC,
-                            con.oid
-               ) AS pick
-        FROM pg_constraint con
-        JOIN pg_namespace n ON n.oid = con.connamespace
-        WHERE con.contype = 'f' AND n.nspname = $1
-    )
-    SELECT root.relname AS table_name,
-           sa.attname AS column_name,
-           tgt.relname AS foreign_table_name,
-           ta.attname AS foreign_column_name,
-           fk.conname AS constraint_name,
-           s.ord::int AS ordinal,
-           CASE fk.confdeltype
-               WHEN 'a' THEN 'NO ACTION'
-               WHEN 'r' THEN 'RESTRICT'
-               WHEN 'c' THEN 'CASCADE'
-               WHEN 'n' THEN 'SET NULL'
-               WHEN 'd' THEN 'SET DEFAULT'
-           END AS delete_rule
-    FROM fk
-    JOIN pg_class root ON root.oid = fk.root_oid
-    JOIN pg_class tgt ON tgt.oid = fk.confrelid
-    CROSS JOIN LATERAL unnest(fk.conkey) WITH ORDINALITY AS s(attnum, ord)
-    JOIN pg_attribute sa ON sa.attrelid = fk.conrelid AND sa.attnum = s.attnum
-    CROSS JOIN LATERAL unnest(fk.confkey) WITH ORDINALITY AS f(attnum, ord)
-    JOIN pg_attribute ta ON ta.attrelid = fk.confrelid AND ta.attnum = f.attnum
-    WHERE fk.pick = 1 AND s.ord = f.ord
-    ORDER BY root.relname, fk.conname, s.ord
-`;
-/**
-* Unique constraints and unique indexes, as ordered column lists.
-*
-* Indexes rather than constraints alone, because `CREATE UNIQUE INDEX` and
-* `ADD CONSTRAINT ... UNIQUE` produce the same guarantee and schemas use both.
-* Partial indexes (`indpred IS NOT NULL`) are excluded: they promise uniqueness
-* only over the rows matching their predicate, which is not the promise a
-* `validation: { unique: true }` field makes.
-*/
-var UNIQUE_CONSTRAINTS_QUERY = `
-    SELECT t.relname AS table_name,
-           ic.relname AS constraint_name,
-           -- ::text, because the driver has no parser for an array of \`name\`
-           -- and hands back the raw \`{a,b}\` literal as a string. Every consumer
-           -- here indexes and compares it as an array, and a string of that
-           -- shape fails those silently rather than loudly.
-           array_agg(a.attname::text ORDER BY k.ord) AS column_names
-    FROM pg_index i
-    JOIN pg_class t ON t.oid = i.indrelid
-    JOIN pg_class ic ON ic.oid = i.indexrelid
-    JOIN pg_namespace n ON n.oid = t.relnamespace
-    CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord)
-    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum
-    WHERE i.indisunique
-      AND NOT i.indisprimary
-      AND i.indpred IS NULL
-      AND n.nspname = $1
-      AND NOT t.relispartition
-    GROUP BY t.relname, ic.relname
-    ORDER BY t.relname, ic.relname
-`;
-/**
-* CHECK constraints, as the source text Postgres reproduces them from.
-*
-* `pg_get_constraintdef` output is normalized by the server — the parser in
-* {@link ./introspect-db-constraints.ts} reads that normalized form, not
-* whatever the author typed.
-*/
-var CHECK_CONSTRAINTS_QUERY = `
-    SELECT DISTINCT
-           root.relname AS table_name,
-           con.conname AS constraint_name,
-           pg_get_constraintdef(con.oid) AS definition
-    FROM pg_constraint con
-    JOIN pg_namespace n ON n.oid = con.connamespace
-    JOIN pg_class root ON root.oid = COALESCE(pg_partition_root(con.conrelid), con.conrelid)
-    WHERE con.contype = 'c'
-      AND n.nspname = $1
-    ORDER BY root.relname, con.conname
-`;
-/**
-* `COMMENT ON TABLE` / `COMMENT ON COLUMN`, which is documentation the author
-* already wrote and which nothing downstream has ever read.
-*/
-var COMMENTS_QUERY = `
-    SELECT t.relname AS table_name,
-           a.attname AS column_name,
-           d.description AS comment
-    FROM pg_description d
-    JOIN pg_class t ON t.oid = d.objoid
-    JOIN pg_namespace n ON n.oid = t.relnamespace
-    LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.objsubid
-    WHERE n.nspname = $1
-      AND t.relkind IN ('r', 'p')
-      AND (d.objsubid = 0 OR a.attname IS NOT NULL)
-    ORDER BY t.relname, d.objsubid
-`;
-/**
-* Counts a table's rows, stopping once the answer can only be "more than
-* `limit`".
-*
-* Introspection asks this to tell a small reference table from a table that
-* merely looks like one (see `classifyTables`). `reltuples` would answer for
-* free but lies on a table that has never been analyzed — which is every table
-* in a database restored from a dump, i.e. exactly the case introspection meets
-* — and reports -1 there rather than an error, so the lie is silent.
-*
-* The subquery's LIMIT caps the work at `limit + 1` rows however large the
-* table is, so this stays cheap on a table with a billion rows.
-*/
-async function countRowsUpTo(client, schema, table, limit) {
-	const { rows } = await client.query(`SELECT count(*)::text AS count FROM (SELECT 1 FROM ${quoteRelation(schema, table)} LIMIT ${limit + 1}) probe`);
-	return Number(rows[0]?.count ?? 0);
-}
-/**
-* Reads everything the generator needs, in one pass.
-*
-* `rowCounts` is deliberately absent here: it costs a query per table and only
-* a handful of tables can possibly need it. The caller fills it in for the
-* candidates `lookupCandidates()` names.
-*/
-async function readSchemaMetadata(client, schema) {
-	const tables = await client.query(TABLES_QUERY, [schema]);
-	const columns = await client.query(COLUMNS_QUERY, [schema]);
-	const enumValues = await client.query(ENUMS_QUERY, [schema]);
-	const pks = await client.query(PRIMARY_KEYS_QUERY, [schema]);
-	const fks = await client.query(FOREIGN_KEYS_QUERY, [schema]);
-	const uniques = await client.query(UNIQUE_CONSTRAINTS_QUERY, [schema]);
-	const checks = await client.query(CHECK_CONSTRAINTS_QUERY, [schema]);
-	const comments = await client.query(COMMENTS_QUERY, [schema]);
-	const known = new Set(tables.rows.map((t) => t.table_name));
-	const scoped = (rows) => rows.filter((r) => known.has(r.table_name));
-	return {
-		schema,
-		tables: tables.rows,
-		columns: scoped(columns.rows),
-		enumValues: enumValues.rows,
-		pks: scoped(pks.rows),
-		fks: scoped(fks.rows).filter((fk) => known.has(fk.foreign_table_name)),
-		uniques: scoped(uniques.rows),
-		checks: scoped(checks.rows),
-		comments: scoped(comments.rows),
-		rowCounts: {}
-	};
-}
-//#endregion
 //#region src/schema/introspect-db-constraints.ts
 /** The length functions whose argument is the column being constrained. */
 var LENGTH_FUNCTIONS = /* @__PURE__ */ new Set([