@supabase/pg-delta 1.0.0-alpha.17 → 1.0.0-alpha.19

package/src/core/objects/procedure/procedure.diff.ts

@@ -49,8 +49,7 @@ export function diffProcedures(
 
   const changes: ProcedureChange[] = [];
 
-  for (const procedureId of created) {
-    const proc = branch[procedureId];
+  const appendCreateProcedureChanges = (proc: Procedure) => {
     changes.push(new CreateProcedure({ procedure: proc }));
 
     // OWNER: If the procedure should be owned by someone other than the current user,
@@ -112,6 +111,10 @@ export function diffProcedures(
         ctx.version,
       ) as ProcedureChange[]),
     );
+  };
+
+  for (const procedureId of created) {
+    appendCreateProcedureChanges(branch[procedureId]);
   }
 
   for (const procedureId of dropped) {
@@ -122,22 +125,18 @@ export function diffProcedures(
     const mainProcedure = main[procedureId];
     const branchProcedure = branch[procedureId];
 
-    // Check if non-alterable properties have changed
-    // These require dropping and recreating the procedure
-    const NON_ALTERABLE_FIELDS: Array<keyof Procedure> = [
+    // Fields that are part of the function's identity/signature. PostgreSQL
+    // rejects `CREATE OR REPLACE FUNCTION` for any of these changes with
+    // errors such as:
+    //   - cannot change return type of existing function
+    //   - cannot change name of input parameter "..."
+    //   - cannot change whether a procedure has output parameters
+    //   - cannot remove parameter defaults from existing function
+    // These require `DROP FUNCTION` followed by `CREATE FUNCTION`.
+    const SIGNATURE_BREAKING_FIELDS: Array<keyof Procedure> = [
       "kind",
       "return_type",
       "return_type_schema",
-      "language",
-      // The following properties are alterable in SQL, but our generator may choose
-      // to replace on changes not covered by explicit ALTER actions. Keep them out here
-      // to allow ALTER for those we implement below.
-      // security_definer,
-      // volatility,
-      // parallel_safety,
-      // is_strict,
-      // leakproof,
-      // Returns-set is part of the signature and not alterable
       "returns_set",
       "argument_count",
       "argument_default_count",
@@ -146,26 +145,45 @@ export function diffProcedures(
       "all_argument_types",
       "argument_modes",
       "argument_defaults",
+    ];
+    // Fields where `CREATE OR REPLACE` is sufficient - body replacement only.
+    // Other fields (security_definer, volatility, parallel_safety, is_strict,
+    // leakproof, config) are alterable via dedicated ALTER actions below.
+    const OR_REPLACEABLE_NON_ALTERABLE_FIELDS: Array<keyof Procedure> = [
+      "language",
       "source_code",
       "binary_path",
       "sql_body",
-      // config is alterable via SET/RESET
     ];
-    const nonAlterablePropsChanged = hasNonAlterableChanges(
+    const signatureChanged = hasNonAlterableChanges(
       mainProcedure,
       branchProcedure,
-      NON_ALTERABLE_FIELDS,
+      SIGNATURE_BREAKING_FIELDS,
       {
         argument_names: deepEqual,
         argument_types: deepEqual,
         all_argument_types: deepEqual,
         argument_modes: deepEqual,
-        config: deepEqual,
       },
     );
+    const nonAlterablePropsChanged =
+      signatureChanged ||
+      hasNonAlterableChanges(
+        mainProcedure,
+        branchProcedure,
+        OR_REPLACEABLE_NON_ALTERABLE_FIELDS,
+      );
 
-    if (nonAlterablePropsChanged) {
-      // Replace the entire procedure
+    if (signatureChanged) {
+      // PostgreSQL cannot change an existing function's signature via
+      // `CREATE OR REPLACE`. Drop the old signature, then recreate.
+      // `expandReplaceDependencies` will cascade the replacement to dependent
+      // objects (views, triggers, column defaults) via pg_depend edges.
+      changes.push(new DropProcedure({ procedure: mainProcedure }));
+      appendCreateProcedureChanges(branchProcedure);
+    } else if (nonAlterablePropsChanged) {
+      // Body-only non-alterable change - `CREATE OR REPLACE` preserves the
+      // function OID and keeps dependent objects attached.
       changes.push(
         new CreateProcedure({ procedure: branchProcedure, orReplace: true }),
       );

package/src/core/objects/rls-policy/changes/rls-policy.alter.test.ts

@@ -23,6 +23,8 @@ describe.concurrent("rls-policy", () => {
         with_check_expression: null,
         owner: "owner",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const policy = new RlsPolicy({
         ...props,
@@ -52,6 +54,8 @@ describe.concurrent("rls-policy", () => {
         with_check_expression: null,
         owner: "owner",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const policy = new RlsPolicy({
         ...props,
@@ -81,6 +85,8 @@ describe.concurrent("rls-policy", () => {
         with_check_expression: null,
         owner: "owner",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const main = new RlsPolicy({
         ...props,
@@ -120,6 +126,8 @@ describe.concurrent("rls-policy", () => {
         with_check_expression: null,
         owner: "owner",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const main = new RlsPolicy({
         ...props,
@@ -159,6 +167,8 @@ describe.concurrent("rls-policy", () => {
         with_check_expression: null,
         owner: "test",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const policy = new RlsPolicy({
         ...props,
@@ -188,6 +198,8 @@ describe.concurrent("rls-policy", () => {
         with_check_expression: null,
         owner: "test",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const policy = new RlsPolicy({
         ...props,
@@ -217,6 +229,8 @@ describe.concurrent("rls-policy", () => {
         using_expression: "expr",
         owner: "test",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const policy = new RlsPolicy({
         ...props,
@@ -246,6 +260,8 @@ describe.concurrent("rls-policy", () => {
         using_expression: "expr",
         owner: "test",
         comment: null,
+        referenced_relations: [],
+        referenced_procedures: [],
       };
       const policy = new RlsPolicy({
         ...props,

package/src/core/objects/rls-policy/changes/rls-policy.create.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
+import { stableId } from "../../utils.ts";
 import { RlsPolicy } from "../rls-policy.model.ts";
 import { CreateRlsPolicy } from "./rls-policy.create.ts";
 
@@ -16,6 +17,8 @@ describe("rls-policy", () => {
       with_check_expression: null,
       owner: "test",
       comment: null,
+      referenced_relations: [],
+      referenced_procedures: [],
     });
 
     const change = new CreateRlsPolicy({
@@ -41,6 +44,8 @@ describe("rls-policy", () => {
       with_check_expression: null,
       owner: "test",
       comment: null,
+      referenced_relations: [],
+      referenced_procedures: [],
     });
 
     const change = new CreateRlsPolicy({
@@ -66,6 +71,8 @@ describe("rls-policy", () => {
       with_check_expression: "expr2",
       owner: "test",
       comment: null,
+      referenced_relations: [],
+      referenced_procedures: [],
     });
 
     const change = new CreateRlsPolicy({
@@ -78,4 +85,125 @@ describe("rls-policy", () => {
       "CREATE POLICY test_policy_all ON public.test_table AS RESTRICTIVE FOR UPDATE TO role1, role2 USING (expr1) WITH CHECK (expr2)",
     );
   });
+
+  test("requires referenced relations reported by pg_depend", () => {
+    const policy = new RlsPolicy({
+      schema: "app",
+      name: "cross_relation_policy",
+      table_name: "accounts",
+      command: "r",
+      permissive: true,
+      roles: ["public"],
+      using_expression:
+        "(EXISTS (SELECT 1 FROM app.users) AND EXISTS (SELECT 1 FROM app.active_accounts))",
+      with_check_expression:
+        "(id IN (SELECT account_id FROM app.memberships WHERE active))",
+      owner: "test",
+      comment: null,
+      referenced_relations: [
+        { kind: "table", schema: "app", name: "users" },
+        { kind: "table", schema: "app", name: "memberships" },
+        { kind: "view", schema: "app", name: "active_accounts" },
+        { kind: "materialized_view", schema: "app", name: "account_stats" },
+        { kind: "foreign_table", schema: "app", name: "remote_profiles" },
+      ],
+      referenced_procedures: [],
+    });
+
+    const change = new CreateRlsPolicy({ policy });
+
+    expect(change.requires).toContain(stableId.table("app", "users"));
+    expect(change.requires).toContain(stableId.table("app", "memberships"));
+    expect(change.requires).toContain(stableId.view("app", "active_accounts"));
+    expect(change.requires).toContain(
+      stableId.materializedView("app", "account_stats"),
+    );
+    expect(change.requires).toContain(
+      stableId.foreignTable("app", "remote_profiles"),
+    );
+  });
+
+  test("requires referenced procedures reported by pg_depend", () => {
+    const policy = new RlsPolicy({
+      schema: "app",
+      name: "function_guarded_policy",
+      table_name: "accounts",
+      command: "r",
+      permissive: true,
+      roles: ["public"],
+      using_expression: "public.is_admin()",
+      with_check_expression: null,
+      owner: "test",
+      comment: null,
+      referenced_relations: [],
+      referenced_procedures: [
+        { schema: "public", name: "is_admin", argument_types: [] },
+        {
+          schema: "public",
+          name: "has_role",
+          argument_types: ["text", "integer"],
+        },
+      ],
+    });
+
+    const change = new CreateRlsPolicy({ policy });
+
+    expect(change.requires).toContain(stableId.procedure("public", "is_admin"));
+    expect(change.requires).toContain(
+      stableId.procedure("public", "has_role", "text,integer"),
+    );
+  });
+
+  test("does not require additional objects when referenced lists are empty", () => {
+    const policy = new RlsPolicy({
+      schema: "app",
+      name: "simple_policy",
+      table_name: "accounts",
+      command: "*",
+      permissive: true,
+      roles: [],
+      using_expression: null,
+      with_check_expression: null,
+      owner: "test",
+      comment: null,
+      referenced_relations: [],
+      referenced_procedures: [],
+    });
+
+    const change = new CreateRlsPolicy({ policy });
+
+    expect(change.requires).toEqual([
+      stableId.schema("app"),
+      stableId.table("app", "accounts"),
+      stableId.role("test"),
+    ]);
+  });
+
+  // Sequences referenced via nextval() are a known gap. pg_depend only
+  // records the sequence edge when the argument is written as a regclass
+  // literal (e.g. `nextval('app.seq'::regclass)`); bare string literals
+  // produce no pg_depend row. Tracked in
+  // https://github.com/supabase/pg-toolbelt/issues/220.
+  test.skip("requires referenced sequences (follow-up)", () => {
+    const policy = new RlsPolicy({
+      schema: "app",
+      name: "sequence_policy",
+      table_name: "accounts",
+      command: "r",
+      permissive: true,
+      roles: ["public"],
+      using_expression: "id < nextval('app.next_id'::regclass)",
+      with_check_expression: null,
+      owner: "test",
+      comment: null,
+      referenced_relations: [],
+      referenced_procedures: [],
+    });
+
+    const change = new CreateRlsPolicy({ policy });
+
+    // Expected once the gap is closed:
+    //   expect(change.requires).toContain(stableId.sequence("app", "next_id"));
+    expect(change.requires.length).toBeGreaterThan(0);
+  });
 });

package/src/core/objects/rls-policy/changes/rls-policy.create.ts

@@ -45,6 +45,33 @@ export class CreateRlsPolicy extends CreateRlsPolicyChange {
     // Owner dependency
     dependencies.add(stableId.role(this.policy.owner));
 
+    // Relations and functions referenced inside USING / WITH CHECK
+    // expressions must exist before the policy is created. These come from
+    // pg_depend (populated by PostgreSQL's recordDependencyOnExpr at policy
+    // creation), not from re-parsing the expression text.
+    for (const ref of this.policy.referenced_relations) {
+      switch (ref.kind) {
+        case "table":
+          dependencies.add(stableId.table(ref.schema, ref.name));
+          break;
+        case "view":
+          dependencies.add(stableId.view(ref.schema, ref.name));
+          break;
+        case "materialized_view":
+          dependencies.add(stableId.materializedView(ref.schema, ref.name));
+          break;
+        case "foreign_table":
+          dependencies.add(stableId.foreignTable(ref.schema, ref.name));
+          break;
+      }
+    }
+
+    for (const ref of this.policy.referenced_procedures) {
+      dependencies.add(
+        stableId.procedure(ref.schema, ref.name, ref.argument_types.join(",")),
+      );
+    }
+
     return Array.from(dependencies);
   }
 

package/src/core/objects/rls-policy/changes/rls-policy.drop.test.ts

@@ -16,6 +16,8 @@ describe("rls-policy", () => {
       with_check_expression: null,
       owner: "test",
       comment: null,
+      referenced_relations: [],
+      referenced_procedures: [],
     });
 
     const change = new DropRlsPolicy({

package/src/core/objects/rls-policy/rls-policy.diff.test.ts

@@ -20,6 +20,8 @@ const base: RlsPolicyProps = {
   with_check_expression: null,
   owner: "o1",
   comment: null,
+  referenced_relations: [],
+  referenced_procedures: [],
 };
 
 describe.concurrent("rls-policy.diff", () => {

package/src/core/objects/rls-policy/rls-policy.model.ts

@@ -11,6 +11,33 @@ const RlsPolicyCommandSchema = z.enum([
   "*", // ALL commands
 ]);
 
+const RlsPolicyReferencedRelationKindSchema = z.enum([
+  "table",
+  "view",
+  "materialized_view",
+  "foreign_table",
+]);
+
+const rlsPolicyReferencedRelationSchema = z.object({
+  kind: RlsPolicyReferencedRelationKindSchema,
+  schema: z.string(),
+  name: z.string(),
+});
+
+export type RlsPolicyReferencedRelation = z.infer<
+  typeof rlsPolicyReferencedRelationSchema
+>;
+
+const rlsPolicyReferencedProcedureSchema = z.object({
+  schema: z.string(),
+  name: z.string(),
+  argument_types: z.array(z.string()),
+});
+
+export type RlsPolicyReferencedProcedure = z.infer<
+  typeof rlsPolicyReferencedProcedureSchema
+>;
+
 const rlsPolicyPropsSchema = z.object({
   schema: z.string(),
   name: z.string(),
@@ -22,6 +49,8 @@ const rlsPolicyPropsSchema = z.object({
   with_check_expression: z.string().nullable(),
   owner: z.string(),
   comment: z.string().nullable(),
+  referenced_relations: z.array(rlsPolicyReferencedRelationSchema),
+  referenced_procedures: z.array(rlsPolicyReferencedProcedureSchema),
 });
 
 export type RlsPolicyProps = z.infer<typeof rlsPolicyPropsSchema>;
@@ -37,6 +66,23 @@ export class RlsPolicy extends BasePgModel {
   public readonly with_check_expression: RlsPolicyProps["with_check_expression"];
   public readonly owner: RlsPolicyProps["owner"];
   public readonly comment: RlsPolicyProps["comment"];
+  /**
+   * Tables / views / materialized views / foreign tables that
+   * `using_expression` / `with_check_expression` reference, sourced from
+   * `pg_depend` (`recordDependencyOnExpr` at policy creation). Drives
+   * ordering dependencies in `CreateRlsPolicy.requires`. Intentionally
+   * excluded from `dataFields` — it's derived from the expression text
+   * and changes lockstep with it.
+   */
+  public readonly referenced_relations: RlsPolicyProps["referenced_relations"];
+  /**
+   * Functions / procedures that `using_expression` / `with_check_expression`
+   * reference, sourced from `pg_depend` (refclassid = `pg_proc`). The
+   * argument-type signature comes straight from `pg_proc.proargtypes` via
+   * `format_type`, so it matches the signature the procedure extractor
+   * embeds in `stableId.procedure(...)`. Not part of `dataFields`.
+   */
+  public readonly referenced_procedures: RlsPolicyProps["referenced_procedures"];
 
   constructor(props: RlsPolicyProps) {
     super();
@@ -54,6 +100,10 @@ export class RlsPolicy extends BasePgModel {
     this.with_check_expression = props.with_check_expression;
     this.owner = props.owner;
     this.comment = props.comment;
+
+    // Derived metadata (not part of equality)
+    this.referenced_relations = props.referenced_relations;
+    this.referenced_procedures = props.referenced_procedures;
   }
 
   get stableId(): `rlsPolicy:${string}` {
@@ -101,6 +151,59 @@ extension_table_oids as (
     d.refclassid = 'pg_extension'::regclass
     and d.classid = 'pg_class'::regclass
     and d.deptype = 'e'
+),
+policy_relation_deps as (
+  -- Relations referenced inside polqual / polwithcheck. PostgreSQL records
+  -- these via recordDependencyOnExpr(..., DEPENDENCY_NORMAL = 'n') at
+  -- CREATE POLICY time, so pg_depend is authoritative and we don't need to
+  -- re-parse the expression text. Covers regular tables, partitioned
+  -- tables, views, materialized views, and foreign tables — any relation
+  -- kind the policy can reference in a subquery.
+  select distinct
+    d.objid                 as policy_oid,
+    case ref_c.relkind
+      when 'r' then 'table'
+      when 'p' then 'table'
+      when 'v' then 'view'
+      when 'm' then 'materialized_view'
+      when 'f' then 'foreign_table'
+    end                     as ref_kind,
+    ref_ns.nspname          as ref_schema,
+    ref_c.relname           as ref_name
+  from
+    pg_depend d
+    join pg_policy p on p.oid = d.objid
+    join pg_class ref_c on ref_c.oid = d.refobjid
+    join pg_namespace ref_ns on ref_ns.oid = ref_c.relnamespace
+  where
+    d.classid = 'pg_policy'::regclass
+    and d.refclassid = 'pg_class'::regclass
+    and d.deptype = 'n'
+    and ref_c.relkind in ('r', 'p', 'v', 'm', 'f')
+    and d.refobjid <> p.polrelid
+),
+policy_procedure_deps as (
+  -- Functions / procedures referenced inside polqual / polwithcheck. Same
+  -- pg_depend mechanism as above, just refclassid = pg_proc. proargtypes
+  -- formatted via format_type(oid, null) matches the signature produced by
+  -- the procedure extractor (see procedure.model.ts), so stableId.procedure
+  -- on both sides of the diff lines up exactly.
+  select distinct
+    d.objid            as policy_oid,
+    ref_ns.nspname     as ref_schema,
+    ref_p.proname      as ref_name,
+    array(
+      select format_type(oid, null)
+      from unnest(ref_p.proargtypes) as oid
+    )                  as ref_argument_types
+  from
+    pg_depend d
+    join pg_proc ref_p on ref_p.oid = d.refobjid
+    join pg_namespace ref_ns on ref_ns.oid = ref_p.pronamespace
+  where
+    d.classid = 'pg_policy'::regclass
+    and d.refclassid = 'pg_proc'::regclass
+    and d.deptype = 'n'
 )
 select
   tc.relnamespace::regnamespace::text as schema,
@@ -120,7 +223,37 @@ select
   pg_get_expr(p.polqual, p.polrelid) as using_expression,
   pg_get_expr(p.polwithcheck, p.polrelid) as with_check_expression,
   tc.relowner::regrole::text as owner,
-  obj_description(p.oid, 'pg_policy') as comment
+  obj_description(p.oid, 'pg_policy') as comment,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'kind', prd.ref_kind,
+          'schema', prd.ref_schema,
+          'name', prd.ref_name
+        )
+        order by prd.ref_schema, prd.ref_name
+      )
+      from policy_relation_deps prd
+      where prd.policy_oid = p.oid
+    ),
+    '[]'
+  ) as referenced_relations,
+  coalesce(
+    (
+      select json_agg(
+        json_build_object(
+          'schema', ppd.ref_schema,
+          'name', ppd.ref_name,
+          'argument_types', ppd.ref_argument_types
+        )
+        order by ppd.ref_schema, ppd.ref_name, ppd.ref_argument_types
+      )
+      from policy_procedure_deps ppd
+      where ppd.policy_oid = p.oid
+    ),
+    '[]'
+  ) as referenced_procedures
 from
   pg_catalog.pg_policy p
   inner join pg_catalog.pg_class tc on tc.oid = p.polrelid

package/src/core/objects/table/changes/table.alter.test.ts

@@ -766,6 +766,7 @@ describe.concurrent("table", () => {
         validated: true,
         is_local: true,
         no_inherit: false,
+        is_temporal: false,
         is_partition_clone: false,
         parent_constraint_schema: null,
         parent_constraint_name: null,