@rebasepro/server-postgres 0.23.0 → 0.24.0

package/dist/introspect-db-queries-C_Q5VgQw.js

@@ -0,0 +1,317 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+//#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.generation_expression,
+        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
+export { readSchemaMetadata as i, isUsableFileName as n, quoteRelation as r, countRowsUpTo as t };
+
+//# sourceMappingURL=introspect-db-queries-C_Q5VgQw.js.map

package/dist/introspect-db-queries-C_Q5VgQw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspect-db-queries-C_Q5VgQw.js","names":[],"sources":["../src/schema/introspect-db-queries.ts"],"sourcesContent":["/**\n * The catalog queries introspection runs, and the shape they produce.\n *\n * These live apart from {@link ./introspect-db.ts} (the CLI entry point) on\n * purpose: the fixture-capture script and the live e2e read a database through\n * this module too, so what the tests see is what the CLI sees. A query that\n * only exists inside the CLI's `main()` can only be tested by running the CLI.\n *\n * No side effects beyond `SELECT`. Introspection reads a database it does not\n * own — it must never `ANALYZE`, create a temp table, or otherwise write.\n */\nimport type {\n    TableRow,\n    TableColumn,\n    EnumValue,\n    PrimaryKeyRow,\n    ForeignKeyRow,\n    UniqueConstraintRow,\n    CheckConstraintRow,\n    CommentRow,\n    SchemaMetadata\n} from \"./introspect-db-logic\";\n\n/** The subset of `pg.Client` this module needs, so tests can pass a fake. */\nexport interface QueryableClient {\n    query<R = Record<string, unknown>>(text: string, values?: unknown[]): Promise<{ rows: R[] }>;\n}\n\n/**\n * A Postgres identifier, quoted so that whatever is inside it stays inside it.\n *\n * Introspection reads table and schema names out of `pg_class` and puts them\n * straight back into SQL, and wrapping a name in double quotes is not the same\n * as escaping it: a table named `x\" ; DROP TABLE users; --` closes the quote\n * and then the statement. Postgres's own escape for a quote inside a quoted\n * identifier is to double it, which is what this does.\n *\n * \"The catalogue is trusted\" is true of your own database, and is exactly the\n * assumption this tool cannot make. Introspection exists to be pointed at\n * databases somebody else built, and it runs with the privileges of whoever\n * ran it — which is usually a superuser, because that is who has a connection\n * string to a database they are adopting.\n */\nexport function quoteIdentifier(name: string): string {\n    return `\"${name.replace(/\"/g, \"\\\"\\\"\")}\"`;\n}\n\n/** `\"schema\".\"table\"`, both halves quoted. */\nexport function quoteRelation(schema: string, table: string): string {\n    return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;\n}\n\n/**\n * Can this table's name be the name of the file describing it?\n *\n * Introspection writes `<collectionsDir>/<tableName>.ts`, and the table name\n * came from a database this tool did not create. Postgres will hold a table\n * called `../../../etc/cron.d/x`, and `path.join` resolves it — so without this\n * the generator writes a file wherever the name points, as whoever ran the\n * command.\n *\n * Deliberately narrow, and deliberately not a blocklist of `..` and `/`: the\n * question is \"is this a plain file name?\", and every answer that is not\n * obviously yes is a table better written by hand. NUL and the Windows\n * separator are in scope because a collections directory is checked out on\n * whatever machine the developer has.\n */\nexport function isUsableFileName(name: string): boolean {\n    if (name.length === 0 || name.length > 200) return false;\n    if (name === \".\" || name === \"..\") return false;\n    // Path separators (both platforms'), the Windows drive separator, and any\n    // control character — a NUL truncates the path at the OS boundary, so a\n    // name that reads as harmless in a log can be something else on disk.\n    // eslint-disable-next-line no-control-regex\n    if (/[/\\\\:\\u0000-\\u001f]/.test(name)) return false;\n    // A leading dot makes a hidden file, and a trailing one is invalid on\n    // Windows; neither is a table anyone means to generate.\n    return !name.startsWith(\".\") && !name.endsWith(\".\");\n}\n\n/**\n * Base tables, excluding partitions.\n *\n * `relispartition` is the reason this reads `pg_class` rather than\n * `information_schema.tables`, which reports every partition as a base table of\n * its own. Pagila partitions `payment` by month; introspected through\n * information_schema it yields `payment` plus 26 near-identical\n * `payment_p2022_*` collections, each with its own nav entry.\n *\n * `relkind = 'p'` (the partitioned parent) is included and `'r'` partitions are\n * dropped, which is the right way round: the parent is the queryable table.\n */\nexport const TABLES_QUERY = `\n    SELECT c.relname AS table_name,\n           c.relkind = 'p' AS is_partitioned\n    FROM pg_class c\n    JOIN pg_namespace n ON n.oid = c.relnamespace\n    WHERE n.nspname = $1\n      AND c.relkind IN ('r', 'p')\n      AND NOT c.relispartition\n      AND c.relname NOT LIKE 'drizzle_%'\n      AND c.relname NOT LIKE 'rebase_%'\n    ORDER BY c.relname\n`;\n\n/**\n * Columns, with the catalog facts that say a column is not the user's to edit.\n *\n * `is_generated`/`is_identity` are read for that reason: a generated column\n * rejects any write, so a form that offers it is offering a field that always\n * errors. `character_maximum_length` is the declared `varchar(n)` bound —\n * already enforced by the database, and free to surface as validation.\n */\nexport const COLUMNS_QUERY = `\n    SELECT\n        c.table_name,\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        c.is_nullable,\n        c.column_default,\n        c.ordinal_position,\n        c.is_generated,\n        c.generation_expression,\n        c.is_identity,\n        c.identity_generation,\n        c.character_maximum_length,\n        c.numeric_precision,\n        c.numeric_scale,\n        (SELECT a.atttypmod FROM pg_attribute a\n         JOIN pg_class pc ON a.attrelid = pc.oid\n         WHERE pc.relname = c.table_name\n           AND a.attname = c.column_name\n           AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod\n    FROM information_schema.columns c\n    WHERE c.table_schema = $1\n    ORDER BY c.table_name, c.ordinal_position\n`;\n\nexport const ENUMS_QUERY = `\n    SELECT t.typname AS enum_name,\n           e.enumlabel AS enum_value,\n           e.enumsortorder AS sort_order\n    FROM pg_type t\n    JOIN pg_enum e ON t.oid = e.enumtypid\n    JOIN pg_namespace n ON t.typnamespace = n.oid\n    WHERE n.nspname = $1\n    ORDER BY t.typname, e.enumsortorder\n`;\n\n/**\n * Primary key columns, in key order.\n *\n * `ORDER BY k.ord` matters for composite keys: the position of a column inside\n * the key is what tells a two-column PK made of two foreign keys apart from an\n * ordinary composite key, and `= ANY(i.indkey)` (the shape this replaced)\n * returns catalog order instead.\n */\nexport const PRIMARY_KEYS_QUERY = `\n    SELECT t.relname AS table_name,\n           a.attname AS column_name\n    FROM pg_index i\n    JOIN pg_class t ON t.oid = i.indrelid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord)\n    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum\n    WHERE i.indisprimary AND n.nspname = $1\n    ORDER BY t.relname, k.ord\n`;\n\n/**\n * Foreign keys, one row per referencing column, with the delete rule.\n *\n * Read from `pg_constraint` rather than through\n * `information_schema.constraint_column_usage`, which does not preserve the\n * pairing on a composite foreign key: it reports the cross product of the\n * constraint's columns, so a two-column FK comes back as four rows, two of them\n * pairing the wrong columns. `unnest(...) WITH ORDINALITY` on both sides joined\n * on the ordinal keeps each referencing column with the column it references.\n *\n * `confdeltype` is carried because `ON DELETE CASCADE` is the schema author\n * saying, in the database, that the child cannot outlive the parent — the one\n * unambiguous declaration of ownership a schema contains.\n *\n * Constraints declared on a *partition* are attributed to the partition root,\n * because that is the table this run generates a collection for. Pagila declares\n * `payment`'s three foreign keys on each monthly partition and none on the\n * parent, so reading `pg_constraint` at face value gives the `payment`\n * collection no relations at all. `pick = 1` then keeps one row per logical key,\n * preferring the root's own constraint when it has one, so a schema that\n * declares the key on the parent *and* inherits it onto 26 partitions does not\n * yield 27 copies of the same relation.\n */\nexport const FOREIGN_KEYS_QUERY = `\n    WITH fk AS (\n        SELECT con.oid,\n               con.conname,\n               con.conrelid,\n               con.confrelid,\n               con.conkey,\n               con.confkey,\n               con.confdeltype,\n               COALESCE(pg_partition_root(con.conrelid), con.conrelid) AS root_oid,\n               row_number() OVER (\n                   PARTITION BY COALESCE(pg_partition_root(con.conrelid), con.conrelid),\n                                con.confrelid, con.conkey, con.confkey\n                   ORDER BY (con.conrelid = COALESCE(pg_partition_root(con.conrelid), con.conrelid)) DESC,\n                            con.oid\n               ) AS pick\n        FROM pg_constraint con\n        JOIN pg_namespace n ON n.oid = con.connamespace\n        WHERE con.contype = 'f' AND n.nspname = $1\n    )\n    SELECT root.relname AS table_name,\n           sa.attname AS column_name,\n           tgt.relname AS foreign_table_name,\n           ta.attname AS foreign_column_name,\n           fk.conname AS constraint_name,\n           s.ord::int AS ordinal,\n           CASE fk.confdeltype\n               WHEN 'a' THEN 'NO ACTION'\n               WHEN 'r' THEN 'RESTRICT'\n               WHEN 'c' THEN 'CASCADE'\n               WHEN 'n' THEN 'SET NULL'\n               WHEN 'd' THEN 'SET DEFAULT'\n           END AS delete_rule\n    FROM fk\n    JOIN pg_class root ON root.oid = fk.root_oid\n    JOIN pg_class tgt ON tgt.oid = fk.confrelid\n    CROSS JOIN LATERAL unnest(fk.conkey) WITH ORDINALITY AS s(attnum, ord)\n    JOIN pg_attribute sa ON sa.attrelid = fk.conrelid AND sa.attnum = s.attnum\n    CROSS JOIN LATERAL unnest(fk.confkey) WITH ORDINALITY AS f(attnum, ord)\n    JOIN pg_attribute ta ON ta.attrelid = fk.confrelid AND ta.attnum = f.attnum\n    WHERE fk.pick = 1 AND s.ord = f.ord\n    ORDER BY root.relname, fk.conname, s.ord\n`;\n\n/**\n * Unique constraints and unique indexes, as ordered column lists.\n *\n * Indexes rather than constraints alone, because `CREATE UNIQUE INDEX` and\n * `ADD CONSTRAINT ... UNIQUE` produce the same guarantee and schemas use both.\n * Partial indexes (`indpred IS NOT NULL`) are excluded: they promise uniqueness\n * only over the rows matching their predicate, which is not the promise a\n * `validation: { unique: true }` field makes.\n */\nexport const UNIQUE_CONSTRAINTS_QUERY = `\n    SELECT t.relname AS table_name,\n           ic.relname AS constraint_name,\n           -- ::text, because the driver has no parser for an array of \\`name\\`\n           -- and hands back the raw \\`{a,b}\\` literal as a string. Every consumer\n           -- here indexes and compares it as an array, and a string of that\n           -- shape fails those silently rather than loudly.\n           array_agg(a.attname::text ORDER BY k.ord) AS column_names\n    FROM pg_index i\n    JOIN pg_class t ON t.oid = i.indrelid\n    JOIN pg_class ic ON ic.oid = i.indexrelid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord)\n    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum\n    WHERE i.indisunique\n      AND NOT i.indisprimary\n      AND i.indpred IS NULL\n      AND n.nspname = $1\n      AND NOT t.relispartition\n    GROUP BY t.relname, ic.relname\n    ORDER BY t.relname, ic.relname\n`;\n\n/**\n * CHECK constraints, as the source text Postgres reproduces them from.\n *\n * `pg_get_constraintdef` output is normalized by the server — the parser in\n * {@link ./introspect-db-constraints.ts} reads that normalized form, not\n * whatever the author typed.\n */\nexport const CHECK_CONSTRAINTS_QUERY = `\n    SELECT DISTINCT\n           root.relname AS table_name,\n           con.conname AS constraint_name,\n           pg_get_constraintdef(con.oid) AS definition\n    FROM pg_constraint con\n    JOIN pg_namespace n ON n.oid = con.connamespace\n    JOIN pg_class root ON root.oid = COALESCE(pg_partition_root(con.conrelid), con.conrelid)\n    WHERE con.contype = 'c'\n      AND n.nspname = $1\n    ORDER BY root.relname, con.conname\n`;\n\n/**\n * `COMMENT ON TABLE` / `COMMENT ON COLUMN`, which is documentation the author\n * already wrote and which nothing downstream has ever read.\n */\nexport const COMMENTS_QUERY = `\n    SELECT t.relname AS table_name,\n           a.attname AS column_name,\n           d.description AS comment\n    FROM pg_description d\n    JOIN pg_class t ON t.oid = d.objoid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.objsubid\n    WHERE n.nspname = $1\n      AND t.relkind IN ('r', 'p')\n      AND (d.objsubid = 0 OR a.attname IS NOT NULL)\n    ORDER BY t.relname, d.objsubid\n`;\n\n/**\n * Counts a table's rows, stopping once the answer can only be \"more than\n * `limit`\".\n *\n * Introspection asks this to tell a small reference table from a table that\n * merely looks like one (see `classifyTables`). `reltuples` would answer for\n * free but lies on a table that has never been analyzed — which is every table\n * in a database restored from a dump, i.e. exactly the case introspection meets\n * — and reports -1 there rather than an error, so the lie is silent.\n *\n * The subquery's LIMIT caps the work at `limit + 1` rows however large the\n * table is, so this stays cheap on a table with a billion rows.\n */\nexport async function countRowsUpTo(\n    client: QueryableClient,\n    schema: string,\n    table: string,\n    limit: number\n): Promise<number> {\n    const { rows } = await client.query<{ count: string }>(\n        `SELECT count(*)::text AS count FROM (SELECT 1 FROM ${quoteRelation(schema, table)} LIMIT ${limit + 1}) probe`\n    );\n    return Number(rows[0]?.count ?? 0);\n}\n\n/**\n * Reads everything the generator needs, in one pass.\n *\n * `rowCounts` is deliberately absent here: it costs a query per table and only\n * a handful of tables can possibly need it. The caller fills it in for the\n * candidates `lookupCandidates()` names.\n */\nexport async function readSchemaMetadata(\n    client: QueryableClient,\n    schema: string\n): Promise<SchemaMetadata> {\n    // Sequential, not `Promise.all`. A `pg.Client` is a single connection with\n    // one protocol stream: concurrent `query()` calls on one are queued and\n    // deprecated (removed in pg@9), so the parallel version buys nothing and\n    // warns while doing it.\n    const tables = await client.query<TableRow>(TABLES_QUERY, [schema]);\n    const columns = await client.query<TableColumn>(COLUMNS_QUERY, [schema]);\n    const enumValues = await client.query<EnumValue>(ENUMS_QUERY, [schema]);\n    const pks = await client.query<PrimaryKeyRow>(PRIMARY_KEYS_QUERY, [schema]);\n    const fks = await client.query<ForeignKeyRow>(FOREIGN_KEYS_QUERY, [schema]);\n    const uniques = await client.query<UniqueConstraintRow>(UNIQUE_CONSTRAINTS_QUERY, [schema]);\n    const checks = await client.query<CheckConstraintRow>(CHECK_CONSTRAINTS_QUERY, [schema]);\n    const comments = await client.query<CommentRow>(COMMENTS_QUERY, [schema]);\n\n    // A column list scoped to the schema still names tables this run excludes —\n    // views, partitions, the drizzle bookkeeping tables. Narrow every row set to\n    // the tables actually being introspected so downstream code never has to\n    // ask whether a table it found in `columns` really exists.\n    const known = new Set(tables.rows.map((t) => t.table_name));\n    const scoped = <T extends { table_name: string }>(rows: T[]) => rows.filter((r) => known.has(r.table_name));\n\n    return {\n        schema,\n        tables: tables.rows,\n        columns: scoped(columns.rows),\n        enumValues: enumValues.rows,\n        pks: scoped(pks.rows),\n        // A foreign key pointing *out* of the introspected set (into another\n        // schema, or at a view) cannot be turned into a relation: there is no\n        // collection on the other end to link to.\n        fks: scoped(fks.rows).filter((fk) => known.has(fk.foreign_table_name)),\n        uniques: scoped(uniques.rows),\n        checks: scoped(checks.rows),\n        comments: scoped(comments.rows),\n        rowCounts: {}\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA2CA,SAAgB,gBAAgB,MAAsB;CAClD,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,EAAE;AAC1C;;AAGA,SAAgB,cAAc,QAAgB,OAAuB;CACjE,OAAO,GAAG,gBAAgB,MAAM,EAAE,GAAG,gBAAgB,KAAK;AAC9D;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBAAiB,MAAuB;CACpD,IAAI,KAAK,WAAW,KAAK,KAAK,SAAS,KAAK,OAAO;CACnD,IAAI,SAAS,OAAO,SAAS,MAAM,OAAO;CAK1C,IAAI,sBAAsB,KAAK,IAAI,GAAG,OAAO;CAG7C,OAAO,CAAC,KAAK,WAAW,GAAG,KAAK,CAAC,KAAK,SAAS,GAAG;AACtD;;;;;;;;;;;;;AAcA,IAAa,eAAe;;;;;;;;;;;;;;;;;;;;AAqB5B,IAAa,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;AA0B7B,IAAa,cAAc;;;;;;;;;;;;;;;;;;AAmB3B,IAAa,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmClC,IAAa,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDlC,IAAa,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BxC,IAAa,0BAA0B;;;;;;;;;;;;;;;;AAiBvC,IAAa,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;AA2B9B,eAAsB,cAClB,QACA,QACA,OACA,OACe;CACf,MAAM,EAAE,SAAS,MAAM,OAAO,MAC1B,sDAAsD,cAAc,QAAQ,KAAK,EAAE,SAAS,QAAQ,EAAE,QAC1G;CACA,OAAO,OAAO,KAAK,EAAE,EAAE,SAAS,CAAC;AACrC;;;;;;;;AASA,eAAsB,mBAClB,QACA,QACuB;CAKvB,MAAM,SAAS,MAAM,OAAO,MAAgB,cAAc,CAAC,MAAM,CAAC;CAClE,MAAM,UAAU,MAAM,OAAO,MAAmB,eAAe,CAAC,MAAM,CAAC;CACvE,MAAM,aAAa,MAAM,OAAO,MAAiB,aAAa,CAAC,MAAM,CAAC;CACtE,MAAM,MAAM,MAAM,OAAO,MAAqB,oBAAoB,CAAC,MAAM,CAAC;CAC1E,MAAM,MAAM,MAAM,OAAO,MAAqB,oBAAoB,CAAC,MAAM,CAAC;CAC1E,MAAM,UAAU,MAAM,OAAO,MAA2B,0BAA0B,CAAC,MAAM,CAAC;CAC1F,MAAM,SAAS,MAAM,OAAO,MAA0B,yBAAyB,CAAC,MAAM,CAAC;CACvF,MAAM,WAAW,MAAM,OAAO,MAAkB,gBAAgB,CAAC,MAAM,CAAC;CAMxE,MAAM,QAAQ,IAAI,IAAI,OAAO,KAAK,KAAK,MAAM,EAAE,UAAU,CAAC;CAC1D,MAAM,UAA4C,SAAc,KAAK,QAAQ,MAAM,MAAM,IAAI,EAAE,UAAU,CAAC;CAE1G,OAAO;EACH;EACA,QAAQ,OAAO;EACf,SAAS,OAAO,QAAQ,IAAI;EAC5B,YAAY,WAAW;EACvB,KAAK,OAAO,IAAI,IAAI;EAIpB,KAAK,OAAO,IAAI,IAAI,CAAC,CAAC,QAAQ,OAAO,MAAM,IAAI,GAAG,kBAAkB,CAAC;EACrE,SAAS,OAAO,QAAQ,IAAI;EAC5B,QAAQ,OAAO,OAAO,IAAI;EAC1B,UAAU,OAAO,SAAS,IAAI;EAC9B,WAAW,CAAC;CAChB;AACJ"}