@intentius/chant-lexicon-sql 0.114.1 → 0.116.0

package/src/op/effect-receipts.e2e.test.ts

@@ -0,0 +1,277 @@
+/**
+ * A project that uses only the sql lexicon runs an Op of `effect()` batches
+ * with `chant run`, and its receipts are kept on the environment's server
+ * (#3657), end to end on both dialects.
+ *
+ * For each dialect, a project in a temporary directory declares an Op of
+ * three batches. Each batch is an `effect()` whose steps run SQL with
+ * `sqlExec`: the batch records itself in a log table. The second batch fails
+ * while a stop table holds a row. The first `chant run --env admin` runs the
+ * first batch, fails on the second, and leaves one receipt. With the stop
+ * row deleted, the second run skips the first batch (the log holds it once),
+ * runs the other two, and leaves three receipts, in
+ * `chant_receipts.receipts` under `chant_e2e_3657/admin/`. A third run runs
+ * nothing.
+ *
+ * The test's own objects are in the database (ClickHouse) or schema
+ * (Postgres) `chant_e2e_3657`; its receipts are the rows of
+ * `chant_receipts.receipts` whose address starts `chant_e2e_3657/`, deleted
+ * afterwards.
+ *
+ * The servers: `CHANT_SQL_RECEIPTS_CLICKHOUSE_URL` and
+ * `CHANT_SQL_RECEIPTS_POSTGRES_URL` (a `postgres://user@host:port/db` URL, with
+ * `CHANT_SQL_RECEIPTS_POSTGRES_PASSWORD`) name running ones, such as the
+ * servers `chant emulator up --lexicon sql` starts. Without them, each dialect
+ * starts a throwaway server at the same pin, and skips cleanly when Docker is
+ * not available.
+ */
+
+import { execFile } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { dockerAvailable, startScratchServer, type ScratchServer } from "../clickhouse/container";
+import { clickhouseQuery, type ClickHouseEndpoint } from "../clickhouse/http";
+import { clickhouseImage } from "../spec/pin";
+import { startTestPostgres, type TestPostgres } from "../postgres/testing/server";
+import { connectPostgres, type PostgresClient, type PostgresEndpoint } from "../postgres/live/client";
+
+const exec = promisify(execFile);
+
+const REPO = join(import.meta.dirname, "../../../..");
+const BIN = join(REPO, "node_modules/.bin");
+const NAME = "chant_e2e_3657";
+const OP = "fill-batches";
+const ENV = "admin";
+const PREFIX = `${NAME}/${ENV}/`;
+
+const givenClickHouse = process.env.CHANT_SQL_RECEIPTS_CLICKHOUSE_URL;
+const givenPostgres = process.env.CHANT_SQL_RECEIPTS_POSTGRES_URL;
+const docker = givenClickHouse && givenPostgres ? false : await dockerAvailable();
+
+interface Run {
+  code: number;
+  output: string;
+}
+
+const strip = (s: string) => s.replace(/\u001b\[[0-9;]*m/g, "");
+
+/** A project directory chant can run in: the repository's `node_modules` linked in, and a git repository. */
+async function project(files: Record<string, string>, env: Record<string, string>) {
+  const dir = mkdtempSync(join(tmpdir(), "chant-sql-receipts-"));
+  symlinkSync(join(REPO, "node_modules"), join(dir, "node_modules"), "dir");
+  for (const [path, text] of Object.entries({
+    "package.json": JSON.stringify({ name: "sql-receipts-e2e", private: true, type: "module" }),
+    ".gitignore": "node_modules\ndist\n.chant\n",
+    ...files,
+  })) {
+    mkdirSync(join(dir, path, ".."), { recursive: true });
+    writeFileSync(join(dir, path), text);
+  }
+  const git = (...args: string[]) => exec("git", ["-c", "user.email=e2e@chant.invalid", "-c", "user.name=e2e", ...args], { cwd: dir });
+  await git("init", "-q");
+  await git("add", "-A");
+  await git("commit", "-qm", "the op");
+  const chant = async (...args: string[]): Promise<Run> => {
+    try {
+      const r = await exec(join(BIN, "chant"), args, {
+        cwd: dir,
+        env: { ...process.env, ...env, PATH: `${BIN}:${process.env.PATH ?? ""}` },
+        maxBuffer: 16 * 1024 * 1024,
+      });
+      return { code: 0, output: strip(`${r.stdout}${r.stderr}`) };
+    } catch (err) {
+      const e = err as { code?: number; stdout?: string; stderr?: string };
+      return { code: typeof e.code === "number" ? e.code : 1, output: strip(`${e.stdout ?? ""}${e.stderr ?? ""}`) };
+    }
+  };
+  return { dir, chant };
+}
+
+const config = (sql: Record<string, unknown>) => `import type { ChantConfig } from "@intentius/chant";
+import "@intentius/chant-lexicon-sql";
+
+export default {
+  lexicons: ["sql"],
+  ownership: { stack: "${NAME}", env: "${ENV}" },
+  sql: ${JSON.stringify(sql, null, 2)},
+} satisfies ChantConfig;
+`;
+
+/** The Op: three batches; each runs `stop` (which fails while the stop table holds a row) and then `record`. */
+const opFile = (stop: string, record: (batch: string) => string) => `import { EffectReceipt } from "@intentius/chant";
+import { Op, activity, effect, phase } from "@intentius/chant/op";
+
+const batch = (b: string, steps: ReturnType<typeof activity>[]) =>
+  effect(EffectReceipt(\`fill-\${b}\`, { effect: \`fill/\${b}\`, flavor: "existence" }), steps);
+const record = (b: string) => activity("sqlExec", { sql: ${JSON.stringify(record("__B__"))}.replace("__B__", b) }, "atMostOnce");
+
+const op = Op({
+  name: "${OP}",
+  overview: "three batches, each with its receipt",
+  phases: [
+    phase("Fill", [
+      batch("b1", [record("b1")]),
+      batch("b2", [activity("sqlExec", { sql: ${JSON.stringify(stop)} }, "atMostOnce"), record("b2")]),
+      batch("b3", [record("b3")]),
+    ]),
+  ],
+});
+export default op;
+`;
+
+/**
+ * The shared scenario. `log` reads the batches the log table holds, in
+ * order; `receipts` the receipt addresses under the test's prefix; `unstop`
+ * deletes the stop row.
+ */
+async function failThenResume(p: Awaited<ReturnType<typeof project>>, io: { log: () => Promise<string[]>; receipts: () => Promise<string[]>; unstop: () => Promise<void> }) {
+  const first = await p.chant("run", OP, "--env", ENV);
+  expect(first.code, first.output).not.toBe(0);
+  expect(await io.log()).toEqual(["b1"]);
+  expect(await io.receipts()).toEqual([`${PREFIX}fill/b1`]);
+
+  await io.unstop();
+  const second = await p.chant("run", OP, "--env", ENV);
+  expect(second.code, second.output).toBe(0);
+  // b1 ran once: the second run read its receipt and skipped it.
+  expect(await io.log()).toEqual(["b1", "b2", "b3"]);
+  expect(await io.receipts()).toEqual([`${PREFIX}fill/b1`, `${PREFIX}fill/b2`, `${PREFIX}fill/b3`]);
+
+  const third = await p.chant("run", OP, "--env", ENV);
+  expect(third.code, third.output).toBe(0);
+  expect(await io.log()).toEqual(["b1", "b2", "b3"]);
+}
+
+// ── ClickHouse ──────────────────────────────────────────────────────────────
+
+describe.skipIf(!givenClickHouse && !docker)("effect() batches on ClickHouse keep their receipts in chant_receipts.receipts (#3657)", () => {
+  let server: ScratchServer | undefined;
+  let admin: ClickHouseEndpoint;
+  let p: Awaited<ReturnType<typeof project>>;
+  const q = <T = Record<string, unknown>>(sql: string) => clickhouseQuery<T>(admin, sql);
+  const forget = async () => {
+    const [t] = await q<{ n: string }>("SELECT count() AS n FROM system.tables WHERE database = 'chant_receipts' AND name = 'receipts'");
+    if (Number(t?.n ?? 0) > 0) await clickhouseQuery(admin, `ALTER TABLE chant_receipts.receipts DELETE WHERE startsWith(address, '${NAME}/')`, { settings: { mutations_sync: "1" } });
+  };
+
+  beforeAll(async () => {
+    if (givenClickHouse) admin = { url: givenClickHouse };
+    else {
+      server = await startScratchServer(clickhouseImage(), { namePrefix: "chant-sql-receipts" });
+      admin = server.endpoint;
+    }
+    await q(`DROP DATABASE IF EXISTS ${NAME} SYNC`);
+    await forget();
+    await q(`CREATE DATABASE ${NAME}`);
+    await q(`CREATE TABLE ${NAME}.log (batch String, at DateTime64(3) DEFAULT now64(3)) ENGINE = MergeTree ORDER BY at`);
+    await q(`CREATE TABLE ${NAME}.stop (x UInt8) ENGINE = MergeTree ORDER BY x`);
+    await q(`INSERT INTO ${NAME}.stop VALUES (1)`);
+    p = await project(
+      {
+        "chant.config.ts": config({ dialect: "clickhouse", profiles: { [ENV]: { url: admin.url, databases: [NAME] } } }),
+        "ops/fill.op.ts": opFile(`SELECT throwIf(count() > 0, 'stopped') FROM ${NAME}.stop`, (b) => `INSERT INTO ${NAME}.log (batch) VALUES ('${b}')`),
+      },
+      {},
+    );
+  }, 600_000);
+
+  afterAll(async () => {
+    if (admin) {
+      await q(`DROP DATABASE IF EXISTS ${NAME} SYNC`).catch(() => undefined);
+      await forget().catch(() => undefined);
+    }
+    await server?.stop();
+    if (p) rmSync(p.dir, { recursive: true, force: true });
+  });
+
+  test("a failed run keeps the finished batch's receipt; the rerun skips it", async () => {
+    await failThenResume(p, {
+      log: async () => (await q<{ batch: string }>(`SELECT batch FROM ${NAME}.log ORDER BY at, batch`)).map((r) => r.batch),
+      receipts: async () =>
+        (await q<{ address: string }>(`SELECT DISTINCT address FROM chant_receipts.receipts WHERE startsWith(address, '${NAME}/') ORDER BY address`)).map((r) => r.address),
+      unstop: async () => {
+        await q(`TRUNCATE TABLE ${NAME}.stop`);
+      },
+    });
+    // The receipts database is chant's: its comment carries the receipts key.
+    const [db] = await q<{ comment: string }>("SELECT comment FROM system.databases WHERE name = 'chant_receipts'");
+    expect(db?.comment).toContain("receipts=effects");
+  }, 600_000);
+});
+
+// ── Postgres ────────────────────────────────────────────────────────────────
+
+describe.skipIf(!givenPostgres && !docker)("effect() batches on Postgres keep their receipts in chant_receipts.receipts (#3657)", () => {
+  let server: TestPostgres | undefined;
+  let endpoint: PostgresEndpoint;
+  let admin: PostgresClient;
+  let p: Awaited<ReturnType<typeof project>>;
+  /** Whether chant_receipts was there before the test: the test drops it afterwards only when it made it. */
+  let hadReceiptsSchema = true;
+  const q = <T = Record<string, unknown>>(sql: string) => admin.query<T>(sql);
+  const forget = async () => {
+    const [t] = await q<{ present: boolean }>("SELECT pg_catalog.to_regclass('chant_receipts.receipts') IS NOT NULL AS present");
+    if (t?.present) await q(`DELETE FROM chant_receipts.receipts WHERE starts_with(address, '${NAME}/')`);
+  };
+
+  beforeAll(async () => {
+    if (givenPostgres) endpoint = { url: givenPostgres, password: process.env.CHANT_SQL_RECEIPTS_POSTGRES_PASSWORD };
+    else {
+      server = await startTestPostgres();
+      endpoint = server.endpoint();
+    }
+    admin = await connectPostgres(endpoint);
+    const [s] = await q<{ n: number }>("SELECT count(*)::int AS n FROM pg_catalog.pg_namespace WHERE nspname = 'chant_receipts'");
+    hadReceiptsSchema = (s?.n ?? 0) > 0;
+    await q(`DROP SCHEMA IF EXISTS ${NAME} CASCADE`);
+    await forget();
+    await q(`CREATE SCHEMA ${NAME}`);
+    await q(`CREATE TABLE ${NAME}.log (id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, batch text NOT NULL)`);
+    await q(`CREATE TABLE ${NAME}.stop (x int)`);
+    await q(`INSERT INTO ${NAME}.stop VALUES (1)`);
+    p = await project(
+      {
+        "chant.config.ts": config({
+          dialect: "postgres",
+          profiles: { [ENV]: { url: endpoint.url, password: { env: "ADMIN_PASSWORD" }, schemas: [NAME] } },
+        }),
+        "ops/fill.op.ts": opFile(
+          `DO $$ BEGIN IF EXISTS (SELECT 1 FROM ${NAME}.stop) THEN RAISE EXCEPTION 'stopped'; END IF; END $$`,
+          (b) => `INSERT INTO ${NAME}.log (batch) VALUES ('${b}')`,
+        ),
+      },
+      { ADMIN_PASSWORD: endpoint.password ?? "" },
+    );
+  }, 600_000);
+
+  afterAll(async () => {
+    if (admin) {
+      await q(`DROP SCHEMA IF EXISTS ${NAME} CASCADE`).catch(() => undefined);
+      await forget().catch(() => undefined);
+      if (!hadReceiptsSchema) await q("DROP SCHEMA IF EXISTS chant_receipts CASCADE").catch(() => undefined);
+      await admin.end();
+    }
+    await server?.stop();
+    if (p) rmSync(p.dir, { recursive: true, force: true });
+  });
+
+  test("a failed run keeps the finished batch's receipt; the rerun skips it", async () => {
+    await failThenResume(p, {
+      log: async () => (await q<{ batch: string }>(`SELECT batch FROM ${NAME}.log ORDER BY id`)).map((r) => r.batch),
+      receipts: async () =>
+        (await q<{ address: string }>(`SELECT address FROM chant_receipts.receipts WHERE starts_with(address, '${NAME}/') ORDER BY address`)).map((r) => r.address),
+      unstop: async () => {
+        await q(`DELETE FROM ${NAME}.stop`);
+      },
+    });
+    // The schema and the table are chant's: their comments carry the receipts key.
+    const [c] = await q<{ schema: string; tbl: string }>(
+      "SELECT pg_catalog.obj_description('chant_receipts'::regnamespace, 'pg_namespace') AS schema, pg_catalog.obj_description('chant_receipts.receipts'::regclass, 'pg_class') AS tbl",
+    );
+    expect(c?.schema).toContain("receipts=effects");
+    expect(c?.tbl).toContain("receipts=effects");
+  }, 600_000);
+});

package/src/plugin.ts

@@ -103,6 +103,9 @@ export const sqlPlugin: LexiconPlugin = {
       { name: "type", isTag: true, description: "A Postgres CREATE TYPE ... AS ENUM, parsed into an enum entity" },
       { name: "domain", isTag: true, description: "A Postgres CREATE DOMAIN, parsed into a domain entity" },
       { name: "extension", isTag: true, description: "A Postgres CREATE EXTENSION, parsed into an extension entity" },
+      { name: "func", isTag: true, description: "A Postgres CREATE FUNCTION, parsed into a function entity with its body kept verbatim" },
+      { name: "procedure", isTag: true, description: "A Postgres CREATE PROCEDURE, parsed into a procedure entity with its body kept verbatim" },
+      { name: "trigger", isTag: true, description: "A Postgres CREATE TRIGGER, parsed into a trigger entity on its table" },
       {
         name: "literal",
         isTag: false,

package/src/postgres/apply/apply.ts

@@ -138,9 +138,17 @@ export class PostgresApplyError extends SqlApplyError<PostgresApplyOutcome> {
   }
 }
 
-/** The name an apply result gives an object: `schema.name`, or a schema's or extension's own name. */
-export const refName = (o: { kind: CanonicalKind; schema?: string; name: string }): string =>
-  o.kind === "schema" || o.kind === "extension" || o.schema === undefined ? o.name : `${o.schema}.${o.name}`;
+/**
+ * The name an apply result gives an object: `schema.name`, or a schema's or
+ * extension's own name; a routine's with its parameter types
+ * (`app.touch()`), a trigger's with its table (`touch ON app.users`).
+ */
+export const refName = (o: { kind: CanonicalKind; schema?: string; name: string; signature?: string }): string =>
+  o.kind === "trigger"
+    ? `${o.name}${o.signature ?? ""}`
+    : o.kind === "schema" || o.kind === "extension" || o.schema === undefined
+      ? o.name
+      : `${o.schema}.${o.name}${o.kind === "function" || o.kind === "procedure" ? (o.signature ?? "") : ""}`;
 
 /**
  * The objects a Postgres `chant build` output declares, in creation order,
@@ -434,7 +442,7 @@ export async function applyPostgres(
 }
 
 /** The address a live object is keyed by in the diff. */
-function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?: string; name: string } {
+function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?: string; name: string; signature?: string } {
   const kind = (
     {
       "Postgres::Schema": "schema",
@@ -446,9 +454,17 @@ function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?:
       "Postgres::Enum": "enum",
       "Postgres::Domain": "domain",
       "Postgres::Extension": "extension",
+      "Postgres::Function": "function",
+      "Postgres::Procedure": "procedure",
+      "Postgres::Trigger": "trigger",
     } as const
   )[o.type];
-  return { kind, ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" ? { schema: o.schema } : {}), name: o.name };
+  return {
+    kind,
+    ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" ? { schema: o.schema } : {}),
+    name: o.name,
+    ...(o.signature !== undefined ? { signature: o.signature } : {}),
+  };
 }
 
 /** The comments the extensions' control files set, by extension name. */

package/src/postgres/apply/statements.ts

@@ -80,9 +80,17 @@ export const pgString = (value: string): string => `'${value.replace(/'/g, "''")
 /** `schema.name`, each part quoted where Postgres needs it. */
 export const pgQualified = (schema: string | undefined, name: string): string => (schema ? `${quoteIdent(schema)}.${quoteIdent(name)}` : quoteIdent(name));
 
-/** An object's name in a statement. A schema and an extension have no schema. */
-export const objectIdent = (o: { kind: CanonicalKind; schema?: string; name: string }): string =>
-  o.kind === "schema" || o.kind === "extension" ? quoteIdent(o.name) : pgQualified(o.schema, o.name);
+/**
+ * An object's name in a statement. A schema and an extension have no schema;
+ * a routine is named with its parameter types (`app.f(integer,text)`), a
+ * trigger with its table (`touch ON app.users`).
+ */
+export const objectIdent = (o: { kind: CanonicalKind; schema?: string; name: string; signature?: string }): string =>
+  o.kind === "schema" || o.kind === "extension"
+    ? quoteIdent(o.name)
+    : o.kind === "trigger"
+      ? `${quoteIdent(o.name)}${o.signature ?? ""}`
+      : `${pgQualified(o.schema, o.name)}${o.signature ?? ""}`;
 
 /** The words a statement names the object's kind with. */
 export const KIND_WORDS: Readonly<Record<CanonicalKind, string>> = {
@@ -95,6 +103,9 @@ export const KIND_WORDS: Readonly<Record<CanonicalKind, string>> = {
   enum: "TYPE",
   domain: "DOMAIN",
   extension: "EXTENSION",
+  function: "FUNCTION",
+  procedure: "PROCEDURE",
+  trigger: "TRIGGER",
 };
 
 /** The canonical kind of an entity type. */
@@ -168,7 +179,8 @@ export function createSteps(
   splitStatements(obj.ddl).forEach((s, i) => {
     if (i > 0 && isOwnComment(s, obj.canonical.kind)) return;
     let sql = s.text;
-    if (i === 0 && opts.orReplace && obj.canonical.kind === "view" && !/\bOR\s+REPLACE\b/i.test(sql)) sql = sql.replace(/\bCREATE\s+/i, "CREATE OR REPLACE ");
+    const replaceable = obj.canonical.kind === "view" || obj.canonical.kind === "function" || obj.canonical.kind === "procedure" || (obj.canonical.kind === "trigger" && obj.canonical.fields.constraint !== true);
+    if (i === 0 && opts.orReplace && replaceable && !/^\s*CREATE\s+OR\s+REPLACE\b/i.test(sql)) sql = sql.replace(/\bCREATE\s+/i, "CREATE OR REPLACE ");
     const concurrently = i === 0 && obj.canonical.kind === "index" && obj.props.concurrently === true;
     out.push({ ...step(sql, cls, opts.rule, !concurrently), ...(concurrently ? { buildsIndex: objectIdent(obj.canonical) } : {}) });
   });
@@ -177,10 +189,10 @@ export function createSteps(
 }
 
 /** The `DROP` for an object a prune removes. Never `CASCADE`: what something else still uses is kept. */
-export function dropStatement(kind: CanonicalKind, schema: string | undefined, name: string): PgStep {
-  const what = objectIdent({ kind, ...(schema !== undefined ? { schema } : {}), name });
+export function dropStatement(kind: CanonicalKind, schema: string | undefined, name: string, signature?: string): PgStep {
+  const what = objectIdent({ kind, ...(schema !== undefined ? { schema } : {}), name, ...(signature !== undefined ? { signature } : {}) });
   if (kind === "index") return step(`DROP INDEX CONCURRENTLY ${what}`, "concurrently", "SQLPG242", false);
-  return step(`DROP ${KIND_WORDS[kind]} ${what}`, "drop", "SQLPG270");
+  return step(`DROP ${KIND_WORDS[kind]} ${what}`, "drop", kind === "trigger" ? "SQLPG285" : "SQLPG270");
 }
 
 // ── Columns ────────────────────────────────────────────────────────────
@@ -403,7 +415,7 @@ export const isRefused = (c: PgChange): boolean => c.class === "expand";
 export const isDestructive = (c: PgChange): boolean => c.rule === "SQLPG204";
 
 /** Changes that replace the object: drop it and create it again from its declaration. */
-export const isRecreate = (c: PgChange): boolean => c.rule === "SQLPG252" || c.rule === "SQLPG243";
+export const isRecreate = (c: PgChange): boolean => c.rule === "SQLPG252" || c.rule === "SQLPG243" || c.rule === "SQLPG281";
 
 /**
  * The statements for an object that exists on the server, change by change.
@@ -538,8 +550,15 @@ export function alterSteps(
         steps.push(step(`ALTER INDEX ${objectIdent(live)} RENAME TO ${quoteIdent(d.name)}`, c.class, c.rule));
         break;
       case "SQLPG250":
+      case "SQLPG280":
         steps.push(...createSteps(obj, opts.marker, { orReplace: true, cls: c.class, rule: c.rule }).slice(0, 1));
         break;
+      case "SQLPG284":
+        if (d.fields.constraint === true || live.fields.constraint === true || d.signature !== live.signature) {
+          steps.push(step(`DROP TRIGGER ${objectIdent(live)}`, c.class, c.rule));
+          steps.push(...createSteps(obj, opts.marker, { cls: c.class, rule: c.rule }));
+        } else steps.push(...createSteps(obj, opts.marker, { orReplace: true, cls: c.class, rule: c.rule }).slice(0, 1));
+        break;
       case "SQLPG260": {
         const before = (live.fields.labels as string[] | undefined) ?? [];
         const after = (d.fields.labels as string[] | undefined) ?? [];
@@ -631,6 +650,8 @@ export interface PgDropStatement {
   kind: CanonicalKind;
   schema?: string;
   name: string;
+  /** A routine's parameter types, a trigger's table. */
+  signature?: string;
   step: PgStep;
 }
 
@@ -663,7 +684,21 @@ export interface PgStatementPlan {
 }
 
 /** Drop order: what reads from a table before the table, types after the tables using them, a schema last. */
-const DROP_ORDER: Record<CanonicalKind, number> = { materializedView: 0, view: 1, index: 2, table: 3, sequence: 4, domain: 5, enum: 6, extension: 7, schema: 8 };
+const DROP_ORDER: Record<CanonicalKind, number> = {
+  trigger: 0,
+  materializedView: 1,
+  view: 2,
+  index: 3,
+  table: 4,
+  sequence: 5,
+  // A routine after what calls it (a view, a trigger, a default), before the types its parameters use.
+  function: 6,
+  procedure: 6,
+  domain: 7,
+  enum: 8,
+  extension: 9,
+  schema: 10,
+};
 
 /**
  * The statements that take the current schema to the declared one, from the
@@ -735,11 +770,18 @@ export function planPgStatements(input: PgStatementPlanInput): PgStatementPlan {
 
   const drops: PgDropStatement[] = [];
   for (const c of input.changes) {
-    if (!((c.rule === "SQLPG270" || c.rule === "SQLPG242") && c.after === undefined)) continue;
+    if (!((c.rule === "SQLPG270" || c.rule === "SQLPG242" || c.rule === "SQLPG285") && c.after === undefined)) continue;
     const o = currentByKey.get(c.object);
     if (!o || o.foreign) continue;
     const schema = o.kind === "schema" || o.kind === "extension" ? undefined : o.schema;
-    drops.push({ key: c.object, kind: o.kind, ...(schema !== undefined ? { schema } : {}), name: o.name, step: dropStatement(o.kind, schema, o.name) });
+    drops.push({
+      key: c.object,
+      kind: o.kind,
+      ...(schema !== undefined ? { schema } : {}),
+      name: o.name,
+      ...(o.signature !== undefined ? { signature: o.signature } : {}),
+      step: dropStatement(o.kind, schema, o.name, o.signature),
+    });
   }
   drops.sort((a, b) => DROP_ORDER[a.kind] - DROP_ORDER[b.kind]);
   return { objects, drops };