@supabase/pg-delta 1.0.0-alpha.4 → 1.0.0-alpha.6

package/src/core/objects/sequence/sequence.model.ts

@@ -148,7 +148,7 @@ select
         )
         order by x.grantee, x.privilege_type
       )
-      from lateral aclexplode(c.relacl) as x(grantor, grantee, privilege_type, is_grantable)
+      from lateral aclexplode(COALESCE(c.relacl, acldefault('S', c.relowner))) as x(grantor, grantee, privilege_type, is_grantable)
     ), '[]'
   ) as privileges,
   c.relowner::regrole::text as owner

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { stableId } from "../../utils.ts";
 import { Subscription } from "../subscription.model.ts";
 import {
@@ -44,18 +45,20 @@ const makeSubscription = (override: Partial<SubscriptionProps> = {}) =>
   });
 
 describe("subscription.alter", () => {
-  test("set connection serializes conninfo literal", () => {
+  test("set connection serializes conninfo literal", async () => {
     const subscription = makeSubscription({
       conninfo: "dbname=postgres host=replica",
     });
     const change = new AlterSubscriptionSetConnection({ subscription });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "ALTER SUBSCRIPTION sub_base CONNECTION 'dbname=postgres host=replica'",
     );
   });
 
-  test("set publication preserves ordering and refresh hint when disabled", () => {
+  test("set publication preserves ordering and refresh hint when disabled", async () => {
     const enabledSubscription = makeSubscription({
       publications: ["pub_a", "pub_b"],
       enabled: true,
@@ -64,6 +67,8 @@ describe("subscription.alter", () => {
       subscription: enabledSubscription,
     });
 
+    await assertValidSql(enabledChange.serialize());
+
     expect(enabledChange.serialize()).toBe(
       "ALTER SUBSCRIPTION sub_base SET PUBLICATION pub_a, pub_b",
     );
@@ -76,12 +81,14 @@ describe("subscription.alter", () => {
       subscription: disabledSubscription,
     });
 
+    await assertValidSql(disabledChange.serialize());
+
     expect(disabledChange.serialize()).toBe(
       "ALTER SUBSCRIPTION sub_base SET PUBLICATION pub_a, pub_b WITH (refresh = false)",
     );
   });
 
-  test("toggle enablement serializes ENABLE and DISABLE statements", () => {
+  test("toggle enablement serializes ENABLE and DISABLE statements", async () => {
     const subscription = makeSubscription();
 
     expect(new AlterSubscriptionEnable({ subscription }).serialize()).toBe(
@@ -92,7 +99,7 @@ describe("subscription.alter", () => {
     );
   });
 
-  test("set options delegates to option formatter", () => {
+  test("set options delegates to option formatter", async () => {
     const subscription = makeSubscription({
       slot_name: "custom_slot",
       slot_is_none: false,
@@ -104,12 +111,14 @@ describe("subscription.alter", () => {
       options: ["slot_name", "disable_on_error", "origin"],
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "ALTER SUBSCRIPTION sub_base SET (slot_name = 'custom_slot', disable_on_error = true, origin = 'none')",
     );
   });
 
-  test("set owner tracks role dependency", () => {
+  test("set owner tracks role dependency", async () => {
     const subscription = makeSubscription();
     const change = new AlterSubscriptionSetOwner({
       subscription,
@@ -117,6 +126,7 @@ describe("subscription.alter", () => {
     });
 
     expect(change.requires).toEqual([stableId.role("new_owner")]);
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       "ALTER SUBSCRIPTION sub_base OWNER TO new_owner",
     );

package/src/core/objects/subscription/changes/subscription.comment.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { stableId } from "../../utils.ts";
 import { Subscription } from "../subscription.model.ts";
 import {
@@ -40,7 +41,7 @@ const makeSubscription = (override: Partial<SubscriptionProps> = {}) =>
   });
 
 describe("subscription.comment", () => {
-  test("create comment serializes and declares dependencies", () => {
+  test("create comment serializes and declares dependencies", async () => {
     const subscription = makeSubscription({
       comment: "subscription's metadata",
     });
@@ -48,12 +49,13 @@ describe("subscription.comment", () => {
 
     expect(change.creates).toEqual([stableId.comment(subscription.stableId)]);
     expect(change.requires).toEqual([subscription.stableId]);
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       "COMMENT ON SUBSCRIPTION sub_base IS 'subscription''s metadata'",
     );
   });
 
-  test("drop comment serializes and tracks drops", () => {
+  test("drop comment serializes and tracks drops", async () => {
     const subscription = makeSubscription({ comment: "not used" });
     const change = new DropCommentOnSubscription({ subscription });
 
@@ -62,6 +64,7 @@ describe("subscription.comment", () => {
       stableId.comment(subscription.stableId),
       subscription.stableId,
     ]);
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe("COMMENT ON SUBSCRIPTION sub_base IS NULL");
   });
 });

package/src/core/objects/subscription/changes/subscription.create.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { stableId } from "../../utils.ts";
 import { Subscription } from "../subscription.model.ts";
 import { CreateSubscription } from "./subscription.create.ts";
@@ -37,18 +38,19 @@ const makeSubscription = (override: Partial<SubscriptionProps> = {}) =>
   });
 
 describe("subscription.create", () => {
-  test("serialize minimal subscription", () => {
+  test("serialize minimal subscription", async () => {
     const subscription = makeSubscription();
     const change = new CreateSubscription({ subscription });
 
     expect(change.creates).toEqual([subscription.stableId]);
     expect(change.requires).toEqual([stableId.role(subscription.owner)]);
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       "CREATE SUBSCRIPTION sub_base CONNECTION 'host=example dbname=postgres' PUBLICATION pub_base",
     );
   });
 
-  test("serialize subscription with extended options", () => {
+  test("serialize subscription with extended options", async () => {
     const subscription = makeSubscription({
       enabled: false,
       binary: true,
@@ -70,6 +72,7 @@ describe("subscription.create", () => {
     const change = new CreateSubscription({ subscription });
 
     expect(change.requires).toEqual([stableId.role(subscription.owner)]);
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       "CREATE SUBSCRIPTION sub_base CONNECTION 'dbname=postgres application_name=sub_base' PUBLICATION pub_a, pub_b WITH (enabled = false, slot_name = 'custom_slot', binary = true, streaming = 'parallel', synchronous_commit = 'local', two_phase = true, disable_on_error = true, password_required = false, run_as_owner = true, origin = 'none', failover = true, create_slot = false, connect = false)",
     );

package/src/core/objects/subscription/changes/subscription.drop.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Subscription } from "../subscription.model.ts";
 import { DropSubscription } from "./subscription.drop.ts";
 
@@ -36,11 +37,12 @@ const makeSubscription = (override: Partial<SubscriptionProps> = {}) =>
   });
 
 describe("subscription.drop", () => {
-  test("serialize drop subscription", () => {
+  test("serialize drop subscription", async () => {
     const subscription = makeSubscription();
     const change = new DropSubscription({ subscription });
 
     expect(change.drops).toEqual([subscription.stableId]);
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe("DROP SUBSCRIPTION sub_base");
   });
 });

package/src/core/objects/subscription/subscription.diff.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import {
   AlterSubscriptionDisable,
   AlterSubscriptionEnable,
@@ -16,6 +17,10 @@ import { DropSubscription } from "./changes/subscription.drop.ts";
 import { diffSubscriptions } from "./subscription.diff.ts";
 import { Subscription, type SubscriptionProps } from "./subscription.model.ts";
 
+const ctx: Pick<ObjectDiffContext, "currentUser"> = {
+  currentUser: "postgres",
+};
+
 const baseProps: SubscriptionProps = {
   name: "mysub",
   raw_name: "mysub",
@@ -42,7 +47,7 @@ describe.concurrent("subscription.diff", () => {
   test("create and drop subscription", () => {
     const subscription = new Subscription(baseProps);
     const created = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       {},
       { [subscription.stableId]: subscription },
     );
@@ -51,7 +56,7 @@ describe.concurrent("subscription.diff", () => {
     );
 
     const dropped = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [subscription.stableId]: subscription },
       {},
     );
@@ -68,7 +73,7 @@ describe.concurrent("subscription.diff", () => {
       conninfo: "host=replica port=5433 dbname=postgres",
     });
     const changes = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [mainSubscription.stableId]: mainSubscription },
       { [branchSubscription.stableId]: branchSubscription },
     );
@@ -87,7 +92,7 @@ describe.concurrent("subscription.diff", () => {
       publications: ["pub_a", "pub_b"],
     });
     const changes = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [mainSubscription.stableId]: mainSubscription },
       { [branchSubscription.stableId]: branchSubscription },
     );
@@ -105,7 +110,7 @@ describe.concurrent("subscription.diff", () => {
       enabled: false,
     });
     const disableChanges = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [mainSubscription.stableId]: mainSubscription },
       { [branchDisabled.stableId]: branchDisabled },
     );
@@ -116,7 +121,7 @@ describe.concurrent("subscription.diff", () => {
     ).toBe(true);
 
     const enableChanges = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [branchDisabled.stableId]: branchDisabled },
       { [mainSubscription.stableId]: mainSubscription },
     );
@@ -141,7 +146,7 @@ describe.concurrent("subscription.diff", () => {
       slot_is_none: false,
     });
     const changes = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [mainSubscription.stableId]: mainSubscription },
       { [branchSubscription.stableId]: branchSubscription },
     );
@@ -163,7 +168,7 @@ describe.concurrent("subscription.diff", () => {
       replication_slot_created: false,
     });
     const changes = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [mainSubscription.stableId]: mainSubscription },
       { [branchSubscription.stableId]: branchSubscription },
     );
@@ -184,7 +189,7 @@ describe.concurrent("subscription.diff", () => {
       comment: "replication subscription",
     });
     const changes = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [mainSubscription.stableId]: mainSubscription },
       { [branchSubscription.stableId]: branchSubscription },
     );
@@ -200,7 +205,7 @@ describe.concurrent("subscription.diff", () => {
       comment: null,
     });
     const dropCommentChanges = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [branchSubscription.stableId]: branchSubscription },
       { [removeCommentSubscription.stableId]: removeCommentSubscription },
     );
@@ -218,7 +223,7 @@ describe.concurrent("subscription.diff", () => {
       two_phase: true,
     });
     const changes = diffSubscriptions(
-      { currentUser: "postgres" },
+      ctx,
       { [mainSubscription.stableId]: mainSubscription },
       { [branchSubscription.stableId]: branchSubscription },
     );

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

@@ -1,4 +1,5 @@
 import { diffObjects } from "../base.diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import { hasNonAlterableChanges } from "../utils.ts";
 import {
   AlterSubscriptionDisable,
@@ -35,7 +36,7 @@ const SETTABLE_OPTIONS: SubscriptionSettableOption[] = [
 ];
 
 export function diffSubscriptions(
-  ctx: { currentUser: string },
+  ctx: Pick<ObjectDiffContext, "currentUser">,
   main: Record<string, Subscription>,
   branch: Record<string, Subscription>,
 ): SubscriptionChange[] {

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import type { ColumnProps } from "../../base.model.ts";
 import { Table, type TableProps } from "../table.model.ts";
 import {
@@ -28,7 +29,7 @@ import {
 
 describe.concurrent("table", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: Omit<TableProps, "owner"> = {
         schema: "public",
         name: "test_table",
@@ -57,12 +58,14 @@ describe.concurrent("table", () => {
 
       const change = new AlterTableChangeOwner({ table, owner: "new_owner" });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table OWNER TO new_owner",
       );
     });
 
-    test("set unlogged", () => {
+    test("set unlogged", async () => {
       const props: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -86,12 +89,13 @@ describe.concurrent("table", () => {
       const table = new Table({ ...props, owner: "o1", options: null });
 
       const change = new AlterTableSetUnlogged({ table });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table SET UNLOGGED",
       );
     });
 
-    test("set logged", () => {
+    test("set logged", async () => {
       const props: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -115,12 +119,13 @@ describe.concurrent("table", () => {
       const table = new Table({ ...props, owner: "o1", options: null });
 
       const change = new AlterTableSetLogged({ table });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table SET LOGGED",
       );
     });
 
-    test("enable/disable row level security", () => {
+    test("enable/disable row level security", async () => {
       const base: Omit<TableProps, "owner" | "options" | "row_security"> = {
         schema: "public",
         name: "test_table",
@@ -148,6 +153,7 @@ describe.concurrent("table", () => {
           row_security: false,
         }),
       });
+      await assertValidSql(enable.serialize());
       expect(enable.serialize()).toBe(
         "ALTER TABLE public.test_table ENABLE ROW LEVEL SECURITY",
       );
@@ -159,12 +165,13 @@ describe.concurrent("table", () => {
           row_security: true,
         }),
       });
+      await assertValidSql(disable.serialize());
       expect(disable.serialize()).toBe(
         "ALTER TABLE public.test_table DISABLE ROW LEVEL SECURITY",
       );
     });
 
-    test("force/no force row level security", () => {
+    test("force/no force row level security", async () => {
       const base: Omit<TableProps, "owner" | "options" | "force_row_security"> =
         {
           schema: "public",
@@ -193,6 +200,7 @@ describe.concurrent("table", () => {
           force_row_security: false,
         }),
       });
+      await assertValidSql(force.serialize());
       expect(force.serialize()).toBe(
         "ALTER TABLE public.test_table FORCE ROW LEVEL SECURITY",
       );
@@ -204,12 +212,13 @@ describe.concurrent("table", () => {
           force_row_security: true,
         }),
       });
+      await assertValidSql(noforce.serialize());
       expect(noforce.serialize()).toBe(
         "ALTER TABLE public.test_table NO FORCE ROW LEVEL SECURITY",
       );
     });
 
-    test("set storage params", () => {
+    test("set storage params", async () => {
       const base: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -234,12 +243,13 @@ describe.concurrent("table", () => {
         table: new Table({ ...base, owner: "o1", options: null }),
         options: ["fillfactor=90"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table SET (fillfactor=90)",
       );
     });
 
-    test("reset storage params", () => {
+    test("reset storage params", async () => {
       const base: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -269,12 +279,13 @@ describe.concurrent("table", () => {
         table,
         params: ["fillfactor", "autovacuum_enabled"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table RESET (fillfactor, autovacuum_enabled)",
       );
     });
 
-    test("replica identity default/nothing/full", () => {
+    test("replica identity default/nothing/full", async () => {
       const baseProps: Omit<
         TableProps,
         "owner" | "options" | "replica_identity"
@@ -329,7 +340,7 @@ describe.concurrent("table", () => {
       ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY FULL");
     });
 
-    test("replica identity DEFAULT and INDEX fallback", () => {
+    test("replica identity DEFAULT and INDEX fallback", async () => {
       const baseProps: Omit<
         TableProps,
         "owner" | "options" | "replica_identity"
@@ -385,7 +396,7 @@ describe.concurrent("table", () => {
       ).toBe("ALTER TABLE public.test_table REPLICA IDENTITY DEFAULT");
     });
 
-    test("columns add/drop/alter", () => {
+    test("columns add/drop/alter", async () => {
       const tableProps: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -440,6 +451,7 @@ describe.concurrent("table", () => {
         table: withCols,
         column: colInt,
       });
+      await assertValidSql(changeAdd.serialize());
       expect(changeAdd.serialize()).toBe(
         "ALTER TABLE public.test_table ADD COLUMN a integer",
       );
@@ -454,6 +466,7 @@ describe.concurrent("table", () => {
         table: dropFrom,
         column: colText,
       });
+      await assertValidSql(changeDrop.serialize());
       expect(changeDrop.serialize()).toBe(
         "ALTER TABLE public.test_table DROP COLUMN b",
       );
@@ -462,6 +475,7 @@ describe.concurrent("table", () => {
         table: withCols,
         column: colText,
       });
+      await assertValidSql(changeType.serialize());
       expect(changeType.serialize()).toBe(
         "ALTER TABLE public.test_table ALTER COLUMN b TYPE text",
       );
@@ -470,6 +484,7 @@ describe.concurrent("table", () => {
         table: withCols,
         column: { ...colInt, default: "0" },
       });
+      await assertValidSql(changeSetDefault.serialize());
       expect(changeSetDefault.serialize()).toBe(
         "ALTER TABLE public.test_table ALTER COLUMN a SET DEFAULT 0",
       );
@@ -478,6 +493,7 @@ describe.concurrent("table", () => {
         table: withCols,
         column: { ...colInt, default: null },
       });
+      await assertValidSql(changeDropDefault.serialize());
       expect(changeDropDefault.serialize()).toBe(
         "ALTER TABLE public.test_table ALTER COLUMN a DROP DEFAULT",
       );
@@ -486,6 +502,7 @@ describe.concurrent("table", () => {
         table: withCols,
         column: { ...colInt, not_null: true },
       });
+      await assertValidSql(changeSetNotNull.serialize());
       expect(changeSetNotNull.serialize()).toBe(
         "ALTER TABLE public.test_table ALTER COLUMN a SET NOT NULL",
       );
@@ -494,12 +511,13 @@ describe.concurrent("table", () => {
         table: withCols,
         column: { ...colInt, not_null: false },
       });
+      await assertValidSql(changeDropNotNull.serialize());
       expect(changeDropNotNull.serialize()).toBe(
         "ALTER TABLE public.test_table ALTER COLUMN a DROP NOT NULL",
       );
     });
 
-    test("add column with collation, default and not null", () => {
+    test("add column with collation, default and not null", async () => {
       const tableProps: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -540,12 +558,13 @@ describe.concurrent("table", () => {
         comment: null,
       };
       const change = new AlterTableAddColumn({ table: withCols, column: col });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table ADD COLUMN a integer COLLATE mycoll DEFAULT 0 NOT NULL",
       );
     });
 
-    test("alter column type with collation", () => {
+    test("alter column type with collation", async () => {
       const tableProps: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -589,12 +608,13 @@ describe.concurrent("table", () => {
         table: withCols,
         column: col,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table ALTER COLUMN b TYPE text COLLATE mycoll",
       );
     });
 
-    test("set default NULL fallback", () => {
+    test("set default NULL fallback", async () => {
       const tableProps: Omit<TableProps, "owner" | "options"> = {
         schema: "public",
         name: "test_table",
@@ -638,12 +658,13 @@ describe.concurrent("table", () => {
         table: withCols,
         column: col,
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER TABLE public.test_table ALTER COLUMN a SET DEFAULT NULL",
       );
     });
 
-    test("constraints add/drop/validate and flavors", () => {
+    test("constraints add/drop/validate and flavors", async () => {
       const t = new Table({
         schema: "public",
         name: "test_table",
@@ -736,7 +757,7 @@ describe.concurrent("table", () => {
       ).toBe("ALTER TABLE public.test_table VALIDATE CONSTRAINT pk_t");
     });
 
-    test("attach/detach partition", () => {
+    test("attach/detach partition", async () => {
       const table = new Table({
         schema: "public",
         name: "events",
@@ -807,6 +828,7 @@ describe.concurrent("table", () => {
         table,
         partition: part2025,
       });
+      await assertValidSql(attach.serialize());
       expect(attach.serialize()).toBe(
         "ALTER TABLE public.events ATTACH PARTITION public.events_2025 FOR VALUES FROM ('2025-01-01 00:00:00') TO ('2026-01-01 00:00:00')",
       );
@@ -815,6 +837,7 @@ describe.concurrent("table", () => {
         table,
         partition: part2025,
       });
+      await assertValidSql(detach.serialize());
       expect(detach.serialize()).toBe(
         "ALTER TABLE public.events DETACH PARTITION public.events_2025",
       );

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Table, type TableProps } from "../table.model.ts";
 import { CreateTable } from "./table.create.ts";
 
@@ -26,13 +27,14 @@ const base: TableProps = {
 };
 
 describe.concurrent("table.create", () => {
-  test("minimal create with no columns", () => {
+  test("minimal create with no columns", async () => {
     const t = new Table(base);
     const change = new CreateTable({ table: t });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe("CREATE TABLE public.t ()");
   });
 
-  test("TEMPORARY with columns, inherits and options", () => {
+  test("TEMPORARY with columns, inherits and options", async () => {
     const t = new Table({
       ...base,
       persistence: "t",
@@ -134,17 +136,53 @@ describe.concurrent("table.create", () => {
     });
 
     const change = new CreateTable({ table: t });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       'CREATE TEMPORARY TABLE public.t (c1 integer DEFAULT 0 NOT NULL, c2 text COLLATE "en_US", c3 integer GENERATED ALWAYS AS IDENTITY, c4 text GENERATED ALWAYS AS (lower((name))) STORED, c5 integer GENERATED BY DEFAULT AS IDENTITY) INHERITS (public.parent) WITH (fillfactor=90, autovacuum_enabled=true)',
     );
   });
 
-  test("UNLOGGED minimal create (no columns)", () => {
+  test("UNLOGGED minimal create (no columns)", async () => {
     const t = new Table({
       ...base,
       persistence: "u",
     });
     const change = new CreateTable({ table: t });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe("CREATE UNLOGGED TABLE public.t ()");
   });
+
+  test("requires does NOT include procedure stableIds from DEFAULT expressions (handled by pg_depend catalog constraints)", async () => {
+    // Function dependencies in DEFAULT expressions are resolved through pg_depend
+    // in the sort pipeline, which provides exact argument types and covers all
+    // expression contexts. The CreateTable change itself does not need to list them.
+    const t = new Table({
+      ...base,
+      columns: [
+        {
+          name: "auth_role",
+          position: 1,
+          data_type: "text",
+          data_type_str: "text",
+          is_custom_type: false,
+          custom_type_type: null,
+          custom_type_category: null,
+          custom_type_schema: null,
+          custom_type_name: null,
+          not_null: false,
+          is_identity: false,
+          is_identity_always: false,
+          is_generated: false,
+          collation: null,
+          default: "auth.role()",
+          comment: null,
+        },
+      ],
+    });
+    const change = new CreateTable({ table: t });
+    const procedureRequires = change.requires.filter((r) =>
+      r.startsWith("procedure:"),
+    );
+    expect(procedureRequires).toEqual([]);
+  });
 });