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

package/src/core/objects/domain/changes/domain.create.ts

@@ -1,4 +1,8 @@
-import { isUserDefinedTypeSchema, stableId } from "../../utils.ts";
+import {
+  isUserDefinedTypeSchema,
+  parseTypeString,
+  stableId,
+} from "../../utils.ts";
 import type { Domain } from "../domain.model.ts";
 import { CreateDomainChange } from "./domain.base.ts";
 
@@ -75,7 +79,9 @@ export class CreateDomain extends CreateDomainChange {
 
     // Base type (use formatted string for type+typmod and add schema if needed)
     let baseType = this.domain.base_type_str as string;
+    const alreadyQualified = parseTypeString(baseType);
     if (
+      !alreadyQualified &&
       this.domain.base_type_schema &&
       this.domain.base_type_schema !== "pg_catalog"
     ) {

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Domain } from "../domain.model.ts";
 import { DropDomain } from "./domain.drop.ts";
 
 describe("domain", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const domain = new Domain({
       schema: "public",
       name: "test_domain",
@@ -25,6 +26,8 @@ describe("domain", () => {
       domain,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP DOMAIN public.test_domain");
   });
 });

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

@@ -1,11 +1,10 @@
-import type { DefaultPrivilegeState } from "../base.default-privileges.ts";
 import { diffObjects } from "../base.diff.ts";
 import {
   diffPrivileges,
+  emitObjectPrivilegeChanges,
   filterPublicBuiltInDefaults,
-  groupPrivilegesByGrantable,
 } from "../base.privilege-diff.ts";
-import type { Role } from "../role/role.model.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import {
   AlterDomainAddConstraint,
   AlterDomainChangeOwner,
@@ -39,12 +38,10 @@ import type { Domain } from "./domain.model.ts";
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffDomains(
-  ctx: {
-    version: number;
-    currentUser: string;
-    defaultPrivilegeState: DefaultPrivilegeState;
-    mainRoles: Record<string, Role>;
-  },
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
   main: Record<string, Domain>,
   branch: Record<string, Domain>,
 ): DomainChange[] {
@@ -99,6 +96,10 @@ export function diffDomains(
       "domain",
       newDomain.schema ?? "",
     );
+    const creatorFilteredDefaults =
+      newDomain.owner !== ctx.currentUser
+        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+        : effectiveDefaults;
     // Filter out PUBLIC's built-in default USAGE privilege (PostgreSQL grants it automatically)
     // Reference: https://www.postgresql.org/docs/17/ddl-priv.html Table 5.2
     // This prevents generating unnecessary "GRANT USAGE TO PUBLIC" statements
@@ -109,57 +110,25 @@ export function diffDomains(
     // Filter out owner privileges - owner always has ALL privileges implicitly
     // and shouldn't be compared. Use the domain owner as the reference.
     const privilegeResults = diffPrivileges(
-      effectiveDefaults,
+      filterPublicBuiltInDefaults("domain", creatorFilteredDefaults),
       desiredPrivileges,
       newDomain.owner,
-      ctx.mainRoles,
     );
 
-    // Generate grant changes
-    for (const [grantee, result] of privilegeResults) {
-      if (result.grants.length > 0) {
-        const grantGroups = groupPrivilegesByGrantable(result.grants);
-        for (const [grantable, list] of grantGroups) {
-          void grantable;
-          changes.push(
-            new GrantDomainPrivileges({
-              domain: newDomain,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke changes
-      if (result.revokes.length > 0) {
-        const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-        for (const [grantable, list] of revokeGroups) {
-          void grantable;
-          changes.push(
-            new RevokeDomainPrivileges({
-              domain: newDomain,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke grant option changes
-      if (result.revokeGrantOption.length > 0) {
-        changes.push(
-          new RevokeGrantOptionDomainPrivileges({
-            domain: newDomain,
-            grantee,
-            privilegeNames: result.revokeGrantOption,
-            version: ctx.version,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        newDomain,
+        newDomain,
+        "domain",
+        {
+          Grant: GrantDomainPrivileges,
+          Revoke: RevokeDomainPrivileges,
+          RevokeGrantOption: RevokeGrantOptionDomainPrivileges,
+        },
+        ctx.version,
+      ) as DomainChange[]),
+    );
   }
 
   for (const domainId of dropped) {
@@ -304,54 +273,22 @@ export function diffDomains(
       mainPrivilegesFiltered,
       branchPrivilegesFiltered,
       branchDomain.owner,
-      ctx.mainRoles,
     );
 
-    for (const [grantee, result] of privilegeResults) {
-      // Generate grant changes
-      if (result.grants.length > 0) {
-        const grantGroups = groupPrivilegesByGrantable(result.grants);
-        for (const [grantable, list] of grantGroups) {
-          void grantable;
-          changes.push(
-            new GrantDomainPrivileges({
-              domain: branchDomain,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke changes
-      if (result.revokes.length > 0) {
-        const revokeGroups = groupPrivilegesByGrantable(result.revokes);
-        for (const [grantable, list] of revokeGroups) {
-          void grantable;
-          changes.push(
-            new RevokeDomainPrivileges({
-              domain: mainDomain,
-              grantee,
-              privileges: list,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
-
-      // Generate revoke grant option changes
-      if (result.revokeGrantOption.length > 0) {
-        changes.push(
-          new RevokeGrantOptionDomainPrivileges({
-            domain: mainDomain,
-            grantee,
-            privilegeNames: result.revokeGrantOption,
-            version: ctx.version,
-          }),
-        );
-      }
-    }
+    changes.push(
+      ...(emitObjectPrivilegeChanges(
+        privilegeResults,
+        branchDomain,
+        mainDomain,
+        "domain",
+        {
+          Grant: GrantDomainPrivileges,
+          Revoke: RevokeDomainPrivileges,
+          RevokeGrantOption: RevokeGrantOptionDomainPrivileges,
+        },
+        ctx.version,
+      ) as DomainChange[]),
+    );
   }
 
   return changes;

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

@@ -168,7 +168,7 @@ export async function extractDomains(pool: Pool): Promise<Domain[]> {
               )
               order by x.grantee, x.privilege_type
             )
-            from lateral aclexplode(t.typacl) as x(grantor, grantee, privilege_type, is_grantable)
+            from lateral aclexplode(COALESCE(t.typacl, acldefault('T', t.typowner))) as x(grantor, grantee, privilege_type, is_grantable)
           ), '[]'
         ) as privileges
       from

package/src/core/objects/event-trigger/changes/event-trigger.alter.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { EventTrigger } from "../event-trigger.model.ts";
 import {
   AlterEventTriggerChangeOwner,
@@ -17,32 +18,38 @@ describe("event trigger alter change", () => {
     comment: null,
   });
 
-  test("serialize owner change", () => {
+  test("serialize owner change", async () => {
     const change = new AlterEventTriggerChangeOwner({
       eventTrigger: baseEventTrigger,
       owner: "new_owner",
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "ALTER EVENT TRIGGER ddl_logger OWNER TO new_owner",
     );
   });
 
-  test("serialize disable", () => {
+  test("serialize disable", async () => {
     const change = new AlterEventTriggerSetEnabled({
       eventTrigger: baseEventTrigger,
       enabled: "D",
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("ALTER EVENT TRIGGER ddl_logger DISABLE");
   });
 
-  test("serialize enable always", () => {
+  test("serialize enable always", async () => {
     const change = new AlterEventTriggerSetEnabled({
       eventTrigger: baseEventTrigger,
       enabled: "A",
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "ALTER EVENT TRIGGER ddl_logger ENABLE ALWAYS",
     );

package/src/core/objects/event-trigger/changes/event-trigger.create.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { EventTrigger } from "../event-trigger.model.ts";
 import { CreateEventTrigger } from "./event-trigger.create.ts";
 
 describe("event trigger create change", () => {
-  test("serialize create event trigger", () => {
+  test("serialize create event trigger", async () => {
     const eventTrigger = new EventTrigger({
       name: "ddl_logger",
       event: "ddl_command_start",
@@ -17,6 +18,8 @@ describe("event trigger create change", () => {
 
     const change = new CreateEventTrigger({ eventTrigger });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE EVENT TRIGGER ddl_logger ON ddl_command_start WHEN TAG IN ('CREATE TABLE', 'ALTER TABLE') EXECUTE FUNCTION public.log_ddl()",
     );

package/src/core/objects/event-trigger/changes/event-trigger.drop.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { EventTrigger } from "../event-trigger.model.ts";
 import { DropEventTrigger } from "./event-trigger.drop.ts";
 
 describe("event trigger drop change", () => {
-  test("serialize drop event trigger", () => {
+  test("serialize drop event trigger", async () => {
     const eventTrigger = new EventTrigger({
       name: "ddl_logger",
       event: "ddl_command_start",
@@ -17,6 +18,8 @@ describe("event trigger drop change", () => {
 
     const change = new DropEventTrigger({ eventTrigger });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP EVENT TRIGGER ddl_logger");
   });
 });

package/src/core/objects/event-trigger/event-trigger.diff.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import {
   AlterEventTriggerChangeOwner,
   AlterEventTriggerSetEnabled,
@@ -12,6 +13,10 @@ import { DropEventTrigger } from "./changes/event-trigger.drop.ts";
 import { diffEventTriggers } from "./event-trigger.diff.ts";
 import { EventTrigger, type EventTriggerProps } from "./event-trigger.model.ts";
 
+const ctx: Pick<ObjectDiffContext, "currentUser"> = {
+  currentUser: "postgres",
+};
+
 const base: EventTriggerProps = {
   name: "ddl_logger",
   event: "ddl_command_start",
@@ -28,7 +33,7 @@ describe.concurrent("event-trigger.diff", () => {
     const eventTrigger = new EventTrigger(base);
 
     const created = diffEventTriggers(
-      { currentUser: "postgres" },
+      ctx,
       {},
       { [eventTrigger.stableId]: eventTrigger },
     );
@@ -36,7 +41,7 @@ describe.concurrent("event-trigger.diff", () => {
     expect(created[0]).toBeInstanceOf(CreateEventTrigger);
 
     const dropped = diffEventTriggers(
-      { currentUser: "postgres" },
+      ctx,
       { [eventTrigger.stableId]: eventTrigger },
       {},
     );
@@ -52,7 +57,7 @@ describe.concurrent("event-trigger.diff", () => {
     });
 
     const changes = diffEventTriggers(
-      { currentUser: "postgres" },
+      ctx,
       { [mainEventTrigger.stableId]: mainEventTrigger },
       { [branchEventTrigger.stableId]: branchEventTrigger },
     );
@@ -70,7 +75,7 @@ describe.concurrent("event-trigger.diff", () => {
     });
 
     const changes = diffEventTriggers(
-      { currentUser: "postgres" },
+      ctx,
       { [mainEventTrigger.stableId]: mainEventTrigger },
       { [branchEventTrigger.stableId]: branchEventTrigger },
     );
@@ -87,7 +92,7 @@ describe.concurrent("event-trigger.diff", () => {
     });
 
     const changes = diffEventTriggers(
-      { currentUser: "postgres" },
+      ctx,
       { [mainEventTrigger.stableId]: mainEventTrigger },
       { [branchEventTrigger.stableId]: branchEventTrigger },
     );
@@ -108,7 +113,7 @@ describe.concurrent("event-trigger.diff", () => {
     });
 
     const createCommentChanges = diffEventTriggers(
-      { currentUser: "postgres" },
+      ctx,
       { [mainEventTrigger.stableId]: mainEventTrigger },
       { [branchWithComment.stableId]: branchWithComment },
     );
@@ -116,7 +121,7 @@ describe.concurrent("event-trigger.diff", () => {
     expect(createCommentChanges[0]).toBeInstanceOf(CreateCommentOnEventTrigger);
 
     const dropCommentChanges = diffEventTriggers(
-      { currentUser: "postgres" },
+      ctx,
       { [branchWithComment.stableId]: branchWithComment },
       { [branchWithoutComment.stableId]: branchWithoutComment },
     );

package/src/core/objects/event-trigger/event-trigger.diff.ts

@@ -1,4 +1,5 @@
 import { diffObjects } from "../base.diff.ts";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import { deepEqual, hasNonAlterableChanges } from "../utils.ts";
 import {
   AlterEventTriggerChangeOwner,
@@ -22,7 +23,7 @@ import type { EventTrigger } from "./event-trigger.model.ts";
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffEventTriggers(
-  ctx: { currentUser: string },
+  ctx: Pick<ObjectDiffContext, "currentUser">,
   main: Record<string, EventTrigger>,
   branch: Record<string, EventTrigger>,
 ): EventTriggerChange[] {

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Extension, type ExtensionProps } from "../extension.model.ts";
 import {
   AlterExtensionSetSchema,
@@ -7,7 +8,7 @@ import {
 
 describe.concurrent("extension", () => {
   describe("alter", () => {
-    test("update version", () => {
+    test("update version", async () => {
       const props: Omit<ExtensionProps, "version"> = {
         name: "test_extension",
         schema: "public",
@@ -26,12 +27,14 @@ describe.concurrent("extension", () => {
         version: "2.0",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER EXTENSION test_extension UPDATE TO '2.0'",
       );
     });
 
-    test("set schema", () => {
+    test("set schema", async () => {
       const props: Omit<ExtensionProps, "schema"> = {
         name: "test_extension",
         relocatable: true,
@@ -50,6 +53,8 @@ describe.concurrent("extension", () => {
         schema: "extensions",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER EXTENSION test_extension SET SCHEMA extensions",
       );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Extension } from "../extension.model.ts";
 import { CreateExtension } from "./extension.create.ts";
 
 describe("extension", () => {
-  test("create", () => {
+  test("create", async () => {
     const extension = new Extension({
       name: "test_extension",
       schema: "public",
@@ -18,6 +19,8 @@ describe("extension", () => {
       extension,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       `CREATE EXTENSION test_extension WITH SCHEMA public`,
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Extension } from "../extension.model.ts";
 import { DropExtension } from "./extension.drop.ts";
 
 describe("extension", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const extension = new Extension({
       name: "test_extension",
       schema: "public",
@@ -18,6 +19,8 @@ describe("extension", () => {
       extension,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP EXTENSION test_extension");
   });
 });

package/src/core/objects/extension/extension.model.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test";
+import type { Pool } from "pg";
+import { Extension, extractExtensions } from "./extension.model.ts";
+
+describe("Extension", () => {
+  test("stableId returns extension:<name>", () => {
+    const ext = new Extension({
+      name: "plpgsql",
+      schema: "pg_catalog",
+      relocatable: false,
+      version: "1.0",
+      owner: "postgres",
+      comment: null,
+      members: [],
+    });
+    expect(ext.stableId).toBe("extension:plpgsql");
+  });
+
+  test("identityFields returns name", () => {
+    const ext = new Extension({
+      name: "vector",
+      schema: "extensions",
+      relocatable: true,
+      version: "0.7.0",
+      owner: "postgres",
+      comment: "vector type",
+      members: ["type:extensions.vector"],
+    });
+    expect(ext.identityFields).toEqual({ name: "vector" });
+  });
+
+  test("dataFields returns schema, relocatable, version, owner, comment", () => {
+    const ext = new Extension({
+      name: "pgcrypto",
+      schema: "public",
+      relocatable: false,
+      version: "1.3",
+      owner: "postgres",
+      comment: "cryptographic functions",
+      members: ["procedure:public.gen_random_uuid()"],
+    });
+    expect(ext.dataFields).toEqual({
+      schema: "public",
+      relocatable: false,
+      version: "1.3",
+      owner: "postgres",
+      comment: "cryptographic functions",
+    });
+  });
+});
+
+describe("extractExtensions", () => {
+  test("returns empty array when pool returns no rows", async () => {
+    const pool = {
+      query: async () => ({ rows: [] }),
+    } as unknown as Pool;
+    const result = await extractExtensions(pool);
+    expect(result).toEqual([]);
+  });
+
+  test("returns Extension instances for valid rows", async () => {
+    const pool = {
+      query: async () => ({
+        rows: [
+          {
+            name: "plpgsql",
+            schema: "pg_catalog",
+            relocatable: false,
+            version: "1.0",
+            owner: "postgres",
+            comment: null,
+            members: [],
+          },
+          {
+            name: "vector",
+            schema: "extensions",
+            relocatable: true,
+            version: "0.7.0",
+            owner: "postgres",
+            comment: null,
+            members: ["type:extensions.vector", "table:extensions.vector"],
+          },
+        ],
+      }),
+    } as unknown as Pool;
+    const result = await extractExtensions(pool);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBeInstanceOf(Extension);
+    expect(result[0].name).toBe("plpgsql");
+    expect(result[0].stableId).toBe("extension:plpgsql");
+    expect(result[0].members).toEqual([]);
+    expect(result[1].name).toBe("vector");
+    expect(result[1].members).toEqual([
+      "type:extensions.vector",
+      "table:extensions.vector",
+    ]);
+  });
+});