@intentius/chant-lexicon-sql 0.124.18 → 0.124.21

package/src/postgres/live/kinds.e2e.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Composite and range types, aggregates, collations, casts and event
+ * triggers against a live server (#3911): applied as declared, they plan
+ * with no change and read back with no drift; a definition changed in the
+ * declaration is replaced (CREATE OR REPLACE AGGREGATE), dropped and created,
+ * or refused while something depends on it; an import writes each back as
+ * the declaration it came from, which plans with no change.
+ *
+ * The server: a throwaway one at the pin, skipped cleanly when Docker is not
+ * available. An event trigger is the database's and fires for every DDL in
+ * it, so this test does not run against a shared server
+ * (`CHANT_SQL_E2E_POSTGRES_URL`).
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { dockerAvailable, startTestPostgres, type TestPostgres } from "../testing/server";
+import { connectPostgres, type PostgresClient, type PostgresEndpoint } from "./client";
+import { readLiveSchema } from "./catalog";
+import { planPgAgainstServer } from "../plan/commands";
+import { observeResourcesDeep, liveProps } from "../plan/deep";
+import { postgresApply } from "../../op/activities/postgres-apply";
+import { objectsToIR } from "../import/ir";
+import { PostgresGenerator, postgresTemplates } from "../import/generator";
+import { declaredObjects } from "../apply/apply";
+
+const SCHEMA = "chant_e2e_3911";
+const enabled = await dockerAvailable();
+const dir = mkdtempSync(join(tmpdir(), "chant-pg-kinds-"));
+let server: TestPostgres | undefined;
+let endpoint: PostgresEndpoint;
+let admin: PostgresClient;
+
+beforeAll(async () => {
+  if (!enabled) return;
+  server = await startTestPostgres();
+  endpoint = server.endpoint();
+  admin = await connectPostgres(endpoint);
+}, 600_000);
+
+afterAll(async () => {
+  await admin?.end();
+  await server?.stop();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+interface Obj {
+  export: string;
+  type: string;
+  ddl: string;
+  dependsOn?: string[];
+}
+
+const MARKER = { stack: "e2e3911", env: "test" };
+const profile = () => ({
+  config: { ownership: MARKER, sql: { profiles: { e2e: { url: endpoint.url, password: { env: "PG_E2E_PASSWORD" }, schemas: [SCHEMA] } } } },
+  env: { PG_E2E_PASSWORD: endpoint.password ?? "" },
+});
+
+function writeBuild(file: string, objects: Obj[]): string {
+  const path = join(dir, file);
+  writeFileSync(path, JSON.stringify({ dialect: "postgres", postgresMajor: 18, objects: objects.map((o) => ({ dependsOn: [], ...o })) }));
+  return path;
+}
+
+const apply = (path: string, prune = false) => postgresApply({ buildPath: path, environment: "e2e", ...(prune ? { prune: true } : {}) }, undefined, { ...profile(), log: () => undefined });
+const plan = (path: string) => planPgAgainstServer("e2e", path, profile());
+
+const S = SCHEMA;
+interface Version {
+  /** The composite type's attributes. */
+  pair: string;
+  /** The aggregate's INITCOND. */
+  initcond: string;
+  /** The range's SUBTYPE_DIFF clause. */
+  diff: string;
+  /** The collation's locale. */
+  locale: string;
+  /** The cast's context. */
+  context: string;
+  /** The event trigger's tags. */
+  tags: string;
+}
+
+const objects = (v: Version): Obj[] => [
+  { export: "app", type: "Postgres::Schema", ddl: `CREATE SCHEMA ${S}` },
+  { export: "ci", type: "Postgres::Collation", dependsOn: ["app"], ddl: `CREATE COLLATION ${S}.ci (provider = icu, locale = '${v.locale}', deterministic = false);\nCOMMENT ON COLLATION ${S}.ci IS 'Case-insensitive'` },
+  { export: "pair", type: "Postgres::CompositeType", dependsOn: ["app"], ddl: `CREATE TYPE ${S}.pair AS (${v.pair});\nCOMMENT ON TYPE ${S}.pair IS 'Two values'` },
+  { export: "floatrange", type: "Postgres::RangeType", dependsOn: ["app"], ddl: `CREATE TYPE ${S}.floatrange AS RANGE (SUBTYPE = float8${v.diff})` },
+  { export: "people", type: "Postgres::Table", dependsOn: ["ci", "floatrange"], ddl: `CREATE TABLE ${S}.people (id int PRIMARY KEY, nick text COLLATE ${S}.ci, span ${S}.floatrange)` },
+  { export: "add2", type: "Postgres::Function", dependsOn: ["app"], ddl: `CREATE FUNCTION ${S}.add2(a integer, b integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$` },
+  {
+    export: "total",
+    type: "Postgres::Aggregate",
+    dependsOn: ["add2"],
+    ddl: `CREATE AGGREGATE ${S}.total(integer) (SFUNC = ${S}.add2, STYPE = int4, INITCOND = ${v.initcond}, PARALLEL = SAFE);\nCOMMENT ON AGGREGATE ${S}.total(int) IS 'A sum'`,
+  },
+  { export: "pairText", type: "Postgres::Function", dependsOn: ["pair"], ddl: `CREATE FUNCTION ${S}.pair_text(p ${S}.pair) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT p.a || ':' || p.b $$` },
+  { export: "pairCast", type: "Postgres::Cast", dependsOn: ["pair", "pairText"], ddl: `CREATE CAST (${S}.pair AS text) WITH FUNCTION ${S}.pair_text(${S}.pair)${v.context}` },
+  { export: "audit", type: "Postgres::Function", dependsOn: ["app"], ddl: `CREATE FUNCTION ${S}.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$` },
+  { export: "ddlAudit", type: "Postgres::EventTrigger", dependsOn: ["audit"], ddl: `CREATE EVENT TRIGGER ddl_audit_3911 ON ddl_command_end WHEN TAG IN (${v.tags}) EXECUTE FUNCTION ${S}.audit();\nCOMMENT ON EVENT TRIGGER ddl_audit_3911 IS 'Audits DDL'` },
+];
+
+const V1: Version = { pair: "a integer, b text COLLATE \"C\"", initcond: "0", diff: ", SUBTYPE_DIFF = float8mi", locale: "und-u-ks-level2", context: " AS ASSIGNMENT", tags: "'CREATE TABLE'" };
+// Each kind changed: the aggregate's INITCOND (OR REPLACE), the range's SUBTYPE_DIFF (a column uses the type: refused), the cast's context and the event trigger's tags (drop and create).
+const V2: Version = { ...V1, initcond: "'10'", diff: "", context: " AS IMPLICIT", tags: "'CREATE TABLE', 'ALTER TABLE'" };
+
+describe.skipIf(!enabled)("types, aggregates, collations, casts and event triggers on a live server", () => {
+  test("apply, plan, drift, change and import", async () => {
+    const v1 = writeBuild("v1.json", objects(V1));
+    const first = await apply(v1);
+    expect(first.failed).toEqual([]);
+    expect(first.applied.map((a) => [a.name, a.action])).toEqual([
+      [S, "created"],
+      [`${S}.ci`, "created"],
+      [`${S}.pair`, "created"],
+      [`${S}.floatrange`, "created"],
+      [`${S}.people`, "created"],
+      [`${S}.add2(integer,integer)`, "created"],
+      [`${S}.total(integer)`, "created"],
+      [`${S}.pair_text(${S}.pair)`, "created"],
+      [`(${S}.pair AS text)`, "created"],
+      [`${S}.audit()`, "created"],
+      ["ddl_audit_3911", "created"],
+    ]);
+    // Each works: the aggregate sums, the cast casts, the collation compares without case, the range has its multirange.
+    expect((await admin.query<{ t: number }>(`SELECT ${S}.total(x) AS t FROM generate_series(1, 4) x`))[0]!.t).toBe(10);
+    expect((await admin.query<{ t: string }>(`SELECT ROW(1, 'x')::${S}.pair::text AS t`))[0]!.t).toBe("1:x");
+    expect((await admin.query<{ eq: boolean }>(`SELECT 'Ab' = 'aB' COLLATE ${S}.ci AS eq`))[0]!.eq).toBe(true);
+    expect((await admin.query<{ m: string }>(`SELECT '{[1,2)}'::${S}.floatmultirange::text AS m`))[0]!.m).toBe("{[1,2)}");
+
+    // As declared: no change, and no drift.
+    expect((await plan(v1)).changes).toEqual([]);
+    const declared = declaredObjects(JSON.stringify({ dialect: "postgres", objects: objects(V1).map((o) => ({ dependsOn: [], ...o })) }));
+    const entities = new Map(declared.map((o) => [o.exportName, { entityType: o.type, props: o.props }]));
+    const deep = await observeResourcesDeep({ environment: "e2e", entityNames: [...entities.keys()], entities, ...profile() });
+    expect(deep.unobserved ?? {}).toEqual({});
+    const strip = (p: Record<string, unknown>) => Object.fromEntries(Object.entries(p).filter(([k]) => !["ddl", "source", "reads", "orReplace"].includes(k)));
+    for (const [name, e] of entities) expect(strip(deep.resources[name]!.properties), name).toEqual(strip(e.props));
+
+    // Changed by hand: drift, in the plan.
+    await admin.query(`CREATE OR REPLACE AGGREGATE ${S}.total(integer) (SFUNC = ${S}.add2, STYPE = int4, INITCOND = '5', PARALLEL = SAFE)`);
+    expect((await plan(v1)).changes.map((c) => [c.object, c.field, c.rule])).toEqual([[`total (${S}.total(integer))`, "definition", "SQLPG302"]]);
+
+    // Changed in the declaration: each with its rule; the range is used by a column, so its change is refused.
+    const v2 = writeBuild("v2.json", objects(V2));
+    const planned = await plan(v2);
+    expect(planned.changes.map((c) => [c.object, c.rule])).toEqual([
+      [`floatrange (${S}.floatrange)`, "SQLPG301"],
+      [`total (${S}.total(integer))`, "SQLPG302"],
+      [`pairCast ((${S}.pair AS text))`, "SQLPG300"],
+      ["ddlAudit (ddl_audit_3911)", "SQLPG300"],
+    ]);
+    expect(planned.refused.map((c) => c.object)).toEqual([`floatrange (${S}.floatrange)`]);
+    const v2Applied = writeBuild("v2-applied.json", objects({ ...V2, diff: V1.diff }));
+    const second = await apply(v2Applied);
+    expect(second.failed).toEqual([]);
+    expect(second.applied.filter((a) => a.action === "updated").map((a) => a.name)).toEqual([`${S}.total(integer)`, `(${S}.pair AS text)`, "ddl_audit_3911"]);
+    expect((await plan(v2Applied)).changes).toEqual([]);
+    expect((await admin.query<{ t: number }>(`SELECT ${S}.total(x) AS t FROM generate_series(1, 4) x`))[0]!.t).toBe(20);
+
+    // Import: the server's own printing, written back as declarations that parse and plan with no change.
+    const live = await readLiveSchema(admin, { schemas: [S] });
+    for (const o of live) liveProps(o);
+    const ir = objectsToIR(live.map((o) => ({ type: o.type, ...(o.schema ? { schema: o.schema } : {}), name: o.name, ddl: o.statement })));
+    const [file] = new PostgresGenerator().generate(ir);
+    expect(file!.content).toContain("export const ci = collation`");
+    expect(file!.content).toContain("export const pair = type`");
+    expect(file!.content).toContain("export const floatrange = type`");
+    expect(file!.content).toContain("export const total = aggregate`");
+    expect(file!.content).toContain("SFUNC = ${add2}");
+    expect(file!.content).toContain("cast`\n  CREATE CAST (${pair} AS text) WITH FUNCTION ${pairText}(${pair}) AS IMPLICIT");
+    expect(file!.content).toContain("export const ddlAudit3911 = eventTrigger`");
+    // The imported statements, in the generator's order, as a build: no change against the server they came from.
+    const items = ir.resources.map((r) => ({ exportName: r.logicalId, type: r.type, ...(r.properties.schema ? { schema: String(r.properties.schema) } : {}), name: String(r.properties.name), ddl: String(r.properties.ddl) }));
+    const { order } = postgresTemplates(items);
+    const imported = writeBuild("imported.json", order.map((it) => ({ export: it.exportName, type: it.type, ddl: it.ddl })));
+    expect((await plan(imported)).changes).toEqual([]);
+  }, 600_000);
+});

package/src/postgres/live/roundtrip.e2e.test.ts

@@ -2,9 +2,9 @@
  * The live round trip (#3279): a schema on one Postgres database is imported
  * as chant declarations, built, and applied to a second, empty database;
  * both catalogs then print the same statements for every object, exporting
- * the second gives back the same declarations, every declared object is
- * present, and the deep read of the applied database reports no drift from
- * the declarations.
+ * the second gives back the same declarations, a plan of the build against
+ * either database has no change, every declared object is present, and the
+ * deep read of the applied database reports no drift from the declarations.
  *
  * Needs Docker; skips cleanly without it. One throwaway `postgres` container
  * at the pin (18.6, by tag and digest), removed afterwards even on failure.
@@ -22,6 +22,7 @@ import { PostgresGenerator } from "../import/generator";
 import { readLiveSchema } from "./catalog";
 import { describeResources } from "./describe-resources";
 import { observeResourcesDeep } from "../plan/deep";
+import { planPgAgainstServer } from "../plan/commands";
 import { sqlPlugin } from "../../plugin";
 import { POSTGRES_DDL_FILE, sqlSerializer } from "../../serializer";
 
@@ -90,6 +91,11 @@ describe.skipIf(!enabled)("import, build, apply, and the catalog is unchanged",
     // The catalog is unchanged.
     expect(await catalog("target")).toEqual(await catalog("source"));
 
+    // A plan of the build against either database: no change (#3911).
+    const buildFile = join(projectDir, "schema.json");
+    writeFileSync(buildFile, out.primary);
+    for (const db of ["target", "source"]) expect((await planPgAgainstServer("rt", buildFile, profile(db))).changes, db).toEqual([]);
+
     // Exporting the applied database gives back the same declarations.
     const again = await exportResources({ environment: "rt", ...profile("target") });
     expect(new PostgresGenerator().generate(again)[0]!.content).toBe(file!.content);

package/src/postgres/live/undeclarable.e2e.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Import against a real Postgres server never leaves an object out without a
+ * word (#3911): a database holding a rewrite rule, an encoding conversion, an
+ * access method and a shell type beside a table fails the import, which
+ * names all four; with `skipUndeclarable` the rest is imported and the four
+ * are warnings. A composite type, an aggregate, a collation, a cast and an
+ * event trigger are declared kinds, so they are imported, not refused. What
+ * an extension brings (hstore's casts and operators) is the extension's, and
+ * is not refused.
+ *
+ * Needs Docker; skips cleanly without it. One throwaway `postgres` container
+ * at the pin, removed afterwards even on failure.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { dockerAvailable, startTestPostgres, type TestPostgres } from "../testing/server";
+import { exportResources } from "../import/live-export";
+import { UndeclarableObjectsError } from "../../core/undeclarable";
+
+const enabled = await dockerAvailable();
+let server: TestPostgres | undefined;
+
+const SEED = `
+CREATE EXTENSION hstore WITH SCHEMA public;
+CREATE SCHEMA app;
+CREATE TABLE app.users (id bigint PRIMARY KEY, name text);
+CREATE TYPE app.pair AS (a integer, b text);
+CREATE FUNCTION app.add2(integer, integer) RETURNS integer LANGUAGE sql AS $$ SELECT $1 + $2 $$;
+CREATE AGGREGATE app.total(integer) (sfunc = app.add2, stype = integer, initcond = '0');
+CREATE COLLATION app.ci (provider = icu, locale = 'und-u-ks-level2', deterministic = false);
+CREATE FUNCTION app.pair_text(app.pair) RETURNS text LANGUAGE sql AS $$ SELECT ($1).b $$;
+CREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair);
+CREATE FUNCTION app.on_ddl() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;
+CREATE EVENT TRIGGER audit_ddl ON ddl_command_end EXECUTE FUNCTION app.on_ddl();
+CREATE RULE users_notify AS ON INSERT TO app.users DO ALSO NOTIFY users;
+CREATE CONVERSION app.latin1_utf8 FOR 'LATIN1' TO 'UTF8' FROM iso8859_1_to_utf8;
+CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler;
+CREATE TYPE app.later;
+`;
+
+beforeAll(async () => {
+  if (!enabled) return;
+  server = await startTestPostgres();
+  const admin = await server.connect();
+  await admin.query("CREATE DATABASE source");
+  await admin.end();
+  const source = await server.connect("source");
+  await source.query(SEED);
+  await source.end();
+}, 600_000);
+
+afterAll(async () => {
+  await server?.stop();
+});
+
+const profile = () => ({
+  config: { sql: { profiles: { src: { url: server!.endpoint("source").url, password: { env: "PG_UD_PASSWORD" } } } } },
+  env: { PG_UD_PASSWORD: server!.endpoint("source").password },
+});
+
+const NAMED = ["rule app.users_notify ON users", "conversion app.latin1_utf8", "access method heap2", "base type app.later"];
+
+describe.skipIf(!enabled)("importing a database with objects chant cannot declare", () => {
+  test("fails, naming every one of them", async () => {
+    const err = await exportResources({ environment: "src", ...profile() }).then(
+      () => undefined,
+      (e: unknown) => e,
+    );
+    expect(err).toBeInstanceOf(UndeclarableObjectsError);
+    const objects = (err as UndeclarableObjectsError).objects.map((o) => `${o.kind} ${o.schema ? `${o.schema}.` : ""}${o.name}`);
+    expect([...objects].sort()).toEqual([...NAMED].sort());
+    for (const line of NAMED) expect((err as Error).message).toContain(`  - ${line}\n`);
+  }, 120_000);
+
+  test("with skipUndeclarable, imports the rest and lists them as warnings", async () => {
+    const ir = await exportResources({ environment: "src", skipUndeclarable: true, ...profile() });
+    expect(ir.resources.map((r) => r.properties.name)).toEqual(
+      expect.arrayContaining(["users", "hstore", "add2", "pair_text", "on_ddl", "pair", "total", "ci", "(app.pair AS text)", "audit_ddl"]),
+    );
+    const left = (ir.warnings ?? []).filter((w) => w.includes("is left out (--skip-undeclarable)"));
+    expect(left.map((w) => w.split(" is left out")[0]).sort()).toEqual([...NAMED].sort());
+  }, 120_000);
+});

package/src/postgres/live/undeclarable.ts

@@ -0,0 +1,141 @@
+/**
+ * The objects in a live Postgres database of the kinds no declaration holds
+ * (#3911), found so import can refuse them by name instead of leaving them
+ * out (`../../core/undeclarable.ts`).
+ *
+ * One catalog query per kind the coverage table marks refused
+ * (`../../coverage/postgres.json`), keyed by the row's `kind`. A kind whose
+ * row is flipped to declared is no longer asked about: its objects are then
+ * the catalog reader's (`./catalog.ts`) to read.
+ *
+ * Left out, as the reader leaves them out: the server's own schemas, objects
+ * an extension owns (`pg_depend.deptype = 'e'`; the extension is declared),
+ * the objects `initdb` makes, whose oids are below 16384
+ * (`FirstNormalObjectId`), and an object that is part of another
+ * (`deptype = 'i'`: the casts a range type makes for itself). An object in a
+ * schema is looked for in the schemas in scope; one that belongs to the whole
+ * database (a cast, an event trigger, a publication, a foreign data wrapper)
+ * is always looked for.
+ */
+
+import type { PostgresClient } from "./client";
+import { notExtensionOwned, scopeSql, type SchemaScope } from "./catalog";
+import { KIND_COVERAGE } from "../../coverage";
+import type { UndeclarableObject } from "../../core/undeclarable";
+
+/** `FirstNormalObjectId`: every oid below it is the server's own. */
+const FIRST_USER_OID = 16384;
+
+interface Probe {
+  /**
+   * A query returning `schema` (NULL for a database-wide object), `name`, and
+   * for a database-wide object the role that owns it (so a managed
+   * provider's own can be told apart); `scope` is the predicate on `n.nspname`.
+   */
+  sql(scope: string): string;
+}
+
+const C = 'COLLATE "C"';
+
+/** Not part of another object (`pg_depend.deptype = 'i'`): the multirange cast a range type makes for itself is the range type's. */
+const notInternal = (catalog: string, oid: string) =>
+  `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_catalog.${catalog}'::pg_catalog.regclass AND d.objid = ${oid} AND d.deptype = 'i')`;
+const ns = (alias: string, column: string) => `JOIN pg_catalog.pg_namespace ${alias} ON ${alias}.oid = ${column}`;
+const args = (oid: string) => `'(' || pg_catalog.replace(pg_catalog.oidvectortypes(${oid}), ', ', ',') || ')'`;
+
+/** A probe for objects of a catalog in a schema, the catalog aliased `x`; `name` is the name expression. */
+const inSchema = (catalog: string, nsColumn: string, name: string, where = "TRUE"): Probe => ({
+  sql: (scope) =>
+    `SELECT n.nspname AS schema, ${name} AS name, NULL::text AS owner FROM pg_catalog.${catalog} x ${ns("n", `x.${nsColumn}`)}
+     WHERE ${where} AND ${scope} AND x.oid >= ${FIRST_USER_OID} AND ${notExtensionOwned(catalog, "x.oid")} AND ${notInternal(catalog, "x.oid")}`,
+});
+
+/** A probe for objects that belong to the database, not a schema. */
+const databaseWide = (catalog: string, name: string, owner?: string): Probe => ({
+  sql: () =>
+    `SELECT NULL::text AS schema, ${name} AS name, ${owner ? `pg_catalog.pg_get_userbyid(x.${owner})` : "NULL::text"} AS owner FROM pg_catalog.${catalog} x
+     WHERE x.oid >= ${FIRST_USER_OID} AND ${notExtensionOwned(catalog, "x.oid")} AND ${notInternal(catalog, "x.oid")}`,
+});
+
+/** The pg_type rows of one `typtype`. */
+const type = (where: string) => inSchema("pg_type", "typnamespace", "x.typname", where);
+
+export const POSTGRES_PROBES: Readonly<Record<string, Probe>> = {
+  "access method": databaseWide("pg_am", "x.amname"),
+  aggregate: inSchema("pg_proc", "pronamespace", `x.proname || ${args("x.proargtypes")}`, "x.prokind = 'a'"),
+  "routine with a SQL-standard body": inSchema("pg_proc", "pronamespace", `x.proname || ${args("x.proargtypes")}`, "x.prokind IN ('f', 'p', 'w') AND x.prosqlbody IS NOT NULL"),
+  cast: databaseWide("pg_cast", "'(' || pg_catalog.format_type(x.castsource, NULL) || ' AS ' || pg_catalog.format_type(x.casttarget, NULL) || ')'"),
+  collation: inSchema("pg_collation", "collnamespace", "x.collname"),
+  conversion: inSchema("pg_conversion", "connamespace", "x.conname"),
+  "event trigger": databaseWide("pg_event_trigger", "x.evtname", "evtowner"),
+  "foreign data wrapper": databaseWide("pg_foreign_data_wrapper", "x.fdwname", "fdwowner"),
+  "foreign server": databaseWide("pg_foreign_server", "x.srvname", "srvowner"),
+  "user mapping": {
+    // pg_user_mapping is the superuser's to read; the view shows every mapping without its options.
+    sql: () =>
+      `SELECT NULL::text AS schema, 'for ' || x.usename || ' on server ' || x.srvname AS name, pg_catalog.pg_get_userbyid(s.srvowner) AS owner FROM pg_catalog.pg_user_mappings x
+       JOIN pg_catalog.pg_foreign_server s ON s.oid = x.srvid
+       WHERE ${notExtensionOwned("pg_foreign_server", "s.oid")}`,
+  },
+  "foreign table": inSchema("pg_class", "relnamespace", "x.relname", "x.relkind = 'f'"),
+  "procedural language": databaseWide("pg_language", "x.lanname", "lanowner"),
+  operator: inSchema("pg_operator", "oprnamespace", "x.oprname || '(' || pg_catalog.format_type(x.oprleft, NULL) || ',' || pg_catalog.format_type(x.oprright, NULL) || ')'"),
+  "operator class": inSchema("pg_opclass", "opcnamespace", "x.opcname || ' USING ' || (SELECT a.amname FROM pg_catalog.pg_am a WHERE a.oid = x.opcmethod)"),
+  // A family CREATE OPERATOR CLASS made for itself, named as its class, is the class's.
+  "operator family": inSchema(
+    "pg_opfamily",
+    "opfnamespace",
+    "x.opfname || ' USING ' || (SELECT a.amname FROM pg_catalog.pg_am a WHERE a.oid = x.opfmethod)",
+    "NOT EXISTS (SELECT 1 FROM pg_catalog.pg_opclass c WHERE c.opcfamily = x.oid AND c.opcname = x.opfname AND c.opcnamespace = x.opfnamespace)",
+  ),
+  publication: databaseWide("pg_publication", "x.pubname", "pubowner"),
+  subscription: {
+    sql: () =>
+      `SELECT NULL::text AS schema, x.subname AS name, pg_catalog.pg_get_userbyid(x.subowner) AS owner FROM pg_catalog.pg_subscription x
+       WHERE x.subdbid = (SELECT d.oid FROM pg_catalog.pg_database d WHERE d.datname = pg_catalog.current_database())`,
+  },
+  rule: {
+    sql: (scope) =>
+      `SELECT n.nspname AS schema, r.rulename || ' ON ' || c.relname AS name, NULL::text AS owner
+       FROM pg_catalog.pg_rewrite r JOIN pg_catalog.pg_class c ON c.oid = r.ev_class ${ns("n", "c.relnamespace")}
+       WHERE r.rulename <> '_RETURN' AND ${scope} AND ${notExtensionOwned("pg_class", "c.oid")}`,
+  },
+  "extended statistics": inSchema("pg_statistic_ext", "stxnamespace", "x.stxname"),
+  "text search configuration": inSchema("pg_ts_config", "cfgnamespace", "x.cfgname"),
+  "text search dictionary": inSchema("pg_ts_dict", "dictnamespace", "x.dictname"),
+  "text search parser": inSchema("pg_ts_parser", "prsnamespace", "x.prsname"),
+  "text search template": inSchema("pg_ts_template", "tmplnamespace", "x.tmplname"),
+  transform: databaseWide(
+    "pg_transform",
+    "'FOR ' || pg_catalog.format_type(x.trftype, NULL) || ' LANGUAGE ' || (SELECT l.lanname FROM pg_catalog.pg_language l WHERE l.oid = x.trflang)",
+  ),
+  "composite type": type("x.typtype = 'c' AND EXISTS (SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = x.typrelid AND c.relkind = 'c')"),
+  "range type": type("x.typtype = 'r'"),
+  // A base type, or a shell; not the array type the server makes beside every type.
+  "base type": type("x.typtype IN ('b', 'p') AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_type e WHERE e.typarray = x.oid)"),
+};
+
+/**
+ * Every object in scope of a kind the coverage table refuses, kind by kind
+ * in the table's order, each by schema then name. A kind the session may not
+ * read (a role without the privilege) is a problem in `unread`, not a pass.
+ */
+export async function readUndeclarable(client: PostgresClient, scope: SchemaScope = {}): Promise<{ objects: UndeclarableObject[]; unread: string[] }> {
+  const s = scopeSql("n.nspname", scope);
+  const objects: UndeclarableObject[] = [];
+  const unread: string[] = [];
+  for (const row of KIND_COVERAGE.postgres) {
+    if (row.status !== "refused") continue;
+    const probe = POSTGRES_PROBES[row.kind];
+    if (!probe) throw new Error(`no catalog query finds a Postgres ${row.kind} (src/postgres/live/undeclarable.ts)`);
+    // The comment names the kind, in the server's log and to a test's fake client.
+    const sql = `/* chant undeclarable: ${row.kind} */ SELECT q.schema, q.name, q.owner FROM (${probe.sql(s.sql)}) q ORDER BY q.schema ${C} NULLS FIRST, q.name ${C}`;
+    try {
+      const rows = await client.query<{ schema: string | null; name: string; owner: string | null }>(sql, sql.includes("$1") ? s.params : []);
+      for (const r of rows) objects.push({ kind: row.kind, ...(r.schema ? { schema: r.schema } : {}), name: r.name, ...(r.owner ? { owner: r.owner } : {}) });
+    } catch (err) {
+      unread.push(`${row.kind}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { objects, unread };
+}

package/src/postgres/parser.test.ts

@@ -164,7 +164,8 @@ describe("the other statements", () => {
     expect(s.options.map((o) => o.option)).toEqual(["AS", "INCREMENT", "NO MINVALUE", "MAXVALUE", "START", "CACHE", "NO CYCLE", "OWNED BY"]);
     expect(parse("CREATE DOMAIN d AS text CONSTRAINT c CHECK (VALUE <> '') NOT VALID")[0]!.statement).toBe("domain");
     expect(parse("CREATE TYPE mood AS ENUM ('sad', 'ok')")[0]!.statement).toBe("enum");
-    expect(at("CREATE TYPE mood AS (a int)")).toBe("(");
+    expect(parse("CREATE TYPE pair AS (a int)")[0]!.statement).toBe("composite");
+    expect(at("CREATE TYPE t (INPUT = t_in)")).toBe("(");
     expect(parse("CREATE SCHEMA IF NOT EXISTS app AUTHORIZATION owner")[0]!.statement).toBe("schema");
     expect(parse("CREATE EXTENSION IF NOT EXISTS citext WITH SCHEMA public VERSION '1.6' CASCADE")[0]!.statement).toBe("extension");
   });