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

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

@@ -1,10 +1,11 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import type { ColumnProps } from "../../base.model.ts";
 import { Index } from "../index.model.ts";
 import { CreateIndex } from "./index.create.ts";
 
 describe("index", () => {
-  test("create", () => {
+  test("create", async () => {
     const index = new Index({
       schema: "public",
       table_name: "test_table",
@@ -59,6 +60,8 @@ describe("index", () => {
 
     const change = new CreateIndex({ index, indexableObject: { columns } });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE INDEX test_index ON public.test_table (id)",
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Index } from "../index.model.ts";
 import { DropIndex } from "./index.drop.ts";
 
 describe("index", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const index = new Index({
       schema: "public",
       table_name: "test_table",
@@ -39,6 +40,8 @@ describe("index", () => {
       index,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP INDEX public.test_index");
   });
 });

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

@@ -1,10 +1,11 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Language, type LanguageProps } from "../language.model.ts";
 import { AlterLanguageChangeOwner } from "./language.alter.ts";
 
 describe.concurrent("language", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: Omit<LanguageProps, "owner"> = {
         name: "plpgsql",
         is_trusted: true,
@@ -25,6 +26,8 @@ describe.concurrent("language", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER LANGUAGE plpgsql OWNER TO new_owner",
       );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Language } from "../language.model.ts";
 import { CreateLanguage } from "./language.create.ts";
 
 describe("language", () => {
-  test("create", () => {
+  test("create", async () => {
     const language = new Language({
       name: "plpgsql",
       is_trusted: true,
@@ -20,6 +21,8 @@ describe("language", () => {
       language,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE TRUSTED LANGUAGE plpgsql HANDLER plpgsql_call_handler INLINE plpgsql_inline_handler VALIDATOR plpgsql_validator",
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Language } from "../language.model.ts";
 import { DropLanguage } from "./language.drop.ts";
 
 describe("language", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const language = new Language({
       name: "plpgsql",
       is_trusted: true,
@@ -20,6 +21,8 @@ describe("language", () => {
       language,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP LANGUAGE plpgsql");
   });
 });

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

@@ -1,7 +1,17 @@
 import { describe, expect, test } from "bun:test";
+import type { ObjectDiffContext } from "../diff-context.ts";
 import { AlterLanguageChangeOwner } from "./changes/language.alter.ts";
+import {
+  CreateCommentOnLanguage,
+  DropCommentOnLanguage,
+} from "./changes/language.comment.ts";
 import { CreateLanguage } from "./changes/language.create.ts";
 import { DropLanguage } from "./changes/language.drop.ts";
+import {
+  GrantLanguagePrivileges,
+  RevokeGrantOptionLanguagePrivileges,
+  RevokeLanguagePrivileges,
+} from "./changes/language.privilege.ts";
 import { diffLanguages } from "./language.diff.ts";
 import { Language, type LanguageProps } from "./language.model.ts";
 
@@ -17,13 +27,24 @@ const base: LanguageProps = {
   privileges: [],
 };
 
+const makeLanguage = (override: Partial<LanguageProps> = {}) =>
+  new Language({
+    ...base,
+    ...override,
+    privileges: override.privileges ?? [...base.privileges],
+  });
+
+const ctx: Pick<ObjectDiffContext, "version"> = {
+  version: 170000,
+};
+
 describe.concurrent("language.diff", () => {
   test("create and drop", () => {
     const l = new Language(base);
-    const created = diffLanguages({ version: 170000 }, {}, { [l.stableId]: l });
+    const created = diffLanguages(ctx, {}, { [l.stableId]: l });
     expect(created[0]).toBeInstanceOf(CreateLanguage);
 
-    const dropped = diffLanguages({ version: 170000 }, { [l.stableId]: l }, {});
+    const dropped = diffLanguages(ctx, { [l.stableId]: l }, {});
     expect(dropped[0]).toBeInstanceOf(DropLanguage);
   });
 
@@ -31,7 +52,7 @@ describe.concurrent("language.diff", () => {
     const main = new Language(base);
     const branch = new Language({ ...base, owner: "o2" });
     const changes = diffLanguages(
-      { version: 170000 },
+      ctx,
       { [main.stableId]: main },
       { [branch.stableId]: branch },
     );
@@ -42,7 +63,7 @@ describe.concurrent("language.diff", () => {
     const main = new Language(base);
     const branch = new Language({ ...base, call_handler: "handler()" });
     const changes = diffLanguages(
-      { version: 170000 },
+      ctx,
       { [main.stableId]: main },
       { [branch.stableId]: branch },
     );
@@ -50,4 +71,65 @@ describe.concurrent("language.diff", () => {
     expect(changes[0]).toBeInstanceOf(DropLanguage);
     expect(changes[1]).toBeInstanceOf(CreateLanguage);
   });
+
+  test("create with comment emits create comment change", () => {
+    const l = makeLanguage({ comment: "my language" });
+    const changes = diffLanguages(ctx, {}, { [l.stableId]: l });
+    expect(changes[0]).toBeInstanceOf(CreateLanguage);
+    expect(changes.some((c) => c instanceof CreateCommentOnLanguage)).toBe(
+      true,
+    );
+  });
+
+  test("comment changes emit create/drop comment statements", () => {
+    const main = makeLanguage();
+    const withComment = makeLanguage({ comment: "lang comment" });
+
+    const addComment = diffLanguages(
+      ctx,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment[0]).toBeInstanceOf(CreateCommentOnLanguage);
+
+    const dropComment = diffLanguages(
+      ctx,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment[0]).toBeInstanceOf(DropCommentOnLanguage);
+  });
+
+  test("privilege diffs emit grant, revoke, and revoke grant option statements", () => {
+    const main = makeLanguage({
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: false },
+        { grantee: "role_with_option", privilege: "USAGE", grantable: true },
+        { grantee: "role_removed", privilege: "USAGE", grantable: false },
+      ],
+    });
+    const branch = makeLanguage({
+      privileges: [
+        { grantee: "role_usage", privilege: "USAGE", grantable: true },
+        { grantee: "role_with_option", privilege: "USAGE", grantable: false },
+        { grantee: "role_new", privilege: "USAGE", grantable: false },
+      ],
+    });
+
+    const changes = diffLanguages(
+      ctx,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+
+    expect(changes.some((c) => c instanceof GrantLanguagePrivileges)).toBe(
+      true,
+    );
+    expect(changes.some((c) => c instanceof RevokeLanguagePrivileges)).toBe(
+      true,
+    );
+    expect(
+      changes.some((c) => c instanceof RevokeGrantOptionLanguagePrivileges),
+    ).toBe(true);
+  });
 });

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

@@ -2,10 +2,10 @@ import type { Change } from "../../change.types.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 { hasNonAlterableChanges } from "../utils.ts";
 import { AlterLanguageChangeOwner } from "./changes/language.alter.ts";
 import {
@@ -30,7 +30,7 @@ import type { Language } from "./language.model.ts";
  * @returns A list of changes to apply to main to make it match branch.
  */
 export function diffLanguages(
-  ctx: { version: number; mainRoles?: Record<string, Role> },
+  ctx: Pick<ObjectDiffContext, "version">,
   main: Record<string, Language>,
   branch: Record<string, Language>,
 ): Change[] {
@@ -121,54 +121,22 @@ export function diffLanguages(
         mainPrivilegesFiltered,
         branchPrivilegesFiltered,
         branchLanguage.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 GrantLanguagePrivileges({
-                language: branchLanguage,
-                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 RevokeLanguagePrivileges({
-                language: mainLanguage,
-                grantee,
-                privileges: list,
-                version: ctx.version,
-              }),
-            );
-          }
-        }
-
-        // Generate revoke grant option changes
-        if (result.revokeGrantOption.length > 0) {
-          changes.push(
-            new RevokeGrantOptionLanguagePrivileges({
-              language: mainLanguage,
-              grantee,
-              privilegeNames: result.revokeGrantOption,
-              version: ctx.version,
-            }),
-          );
-        }
-      }
+      changes.push(
+        ...(emitObjectPrivilegeChanges(
+          privilegeResults,
+          branchLanguage,
+          mainLanguage,
+          "language",
+          {
+            Grant: GrantLanguagePrivileges,
+            Revoke: RevokeLanguagePrivileges,
+            RevokeGrantOption: RevokeGrantOptionLanguagePrivileges,
+          },
+          ctx.version,
+        ) as Change[]),
+      );
     }
   }
 

package/src/core/objects/materialized-view/changes/materialized-view.alter.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import {
   MaterializedView,
   type MaterializedViewProps,
@@ -10,7 +11,7 @@ import {
 
 describe.concurrent("materialized-view", () => {
   describe("alter", () => {
-    test("change owner", () => {
+    test("change owner", async () => {
       const props: Omit<MaterializedViewProps, "owner"> = {
         schema: "public",
         name: "test_mv",
@@ -40,12 +41,14 @@ describe.concurrent("materialized-view", () => {
         owner: "new_owner",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER MATERIALIZED VIEW public.test_mv OWNER TO new_owner",
       );
     });
 
-    test("set storage params", () => {
+    test("set storage params", async () => {
       const props: Omit<MaterializedViewProps, "options"> = {
         schema: "public",
         name: "test_mv",
@@ -76,12 +79,14 @@ describe.concurrent("materialized-view", () => {
         keysToReset: [],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         "ALTER MATERIALIZED VIEW public.test_mv SET (fillfactor=90)",
       );
     });
 
-    test("reset and set storage params", () => {
+    test("reset and set storage params", async () => {
       const props: Omit<MaterializedViewProps, "options"> = {
         schema: "public",
         name: "test_mv",
@@ -112,6 +117,8 @@ describe.concurrent("materialized-view", () => {
         keysToReset: ["autovacuum_enabled"],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
         [
           "ALTER MATERIALIZED VIEW public.test_mv RESET (autovacuum_enabled)",

package/src/core/objects/materialized-view/changes/materialized-view.create.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { MaterializedView } from "../materialized-view.model.ts";
 import { CreateMaterializedView } from "./materialized-view.create.ts";
 
 describe("materialized-view", () => {
-  test("create minimal", () => {
+  test("create minimal", async () => {
     const mv = new MaterializedView({
       schema: "public",
       name: "test_mv",
@@ -28,12 +29,14 @@ describe("materialized-view", () => {
 
     const change = new CreateMaterializedView({ materializedView: mv });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE MATERIALIZED VIEW public.test_mv AS SELECT * FROM test_table WITH NO DATA",
     );
   });
 
-  test("create with all options", () => {
+  test("create with all options", async () => {
     const mv = new MaterializedView({
       schema: "public",
       name: "test_mv",
@@ -57,6 +60,8 @@ describe("materialized-view", () => {
 
     const change = new CreateMaterializedView({ materializedView: mv });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE MATERIALIZED VIEW public.test_mv WITH (fillfactor=90, autovacuum_enabled=false) AS SELECT * FROM test_table WITH DATA",
     );

package/src/core/objects/materialized-view/changes/materialized-view.drop.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { MaterializedView } from "../materialized-view.model.ts";
 import { DropMaterializedView } from "./materialized-view.drop.ts";
 
 describe("materialized-view", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const materializedView = new MaterializedView({
       schema: "public",
       name: "test_mv",
@@ -29,6 +30,8 @@ describe("materialized-view", () => {
       materializedView,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP MATERIALIZED VIEW public.test_mv");
   });
 });

package/src/core/objects/materialized-view/materialized-view.diff.test.ts

@@ -4,8 +4,19 @@ import {
   AlterMaterializedViewChangeOwner,
   AlterMaterializedViewSetStorageParams,
 } from "./changes/materialized-view.alter.ts";
+import {
+  CreateCommentOnMaterializedView,
+  CreateCommentOnMaterializedViewColumn,
+  DropCommentOnMaterializedView,
+  DropCommentOnMaterializedViewColumn,
+} from "./changes/materialized-view.comment.ts";
 import { CreateMaterializedView } from "./changes/materialized-view.create.ts";
 import { DropMaterializedView } from "./changes/materialized-view.drop.ts";
+import {
+  GrantMaterializedViewPrivileges,
+  RevokeGrantOptionMaterializedViewPrivileges,
+  RevokeMaterializedViewPrivileges,
+} from "./changes/materialized-view.privilege.ts";
 import { diffMaterializedViews } from "./materialized-view.diff.ts";
 import {
   MaterializedView,
@@ -33,6 +44,33 @@ const base: MaterializedViewProps = {
   privileges: [],
 };
 
+const baseColumn = {
+  name: "id",
+  position: 1,
+  data_type: "integer",
+  data_type_str: "integer",
+  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: null,
+  comment: null,
+};
+
+const makeMaterializedView = (override: Partial<MaterializedViewProps> = {}) =>
+  new MaterializedView({
+    ...base,
+    ...override,
+    privileges: override.privileges ?? [...base.privileges],
+    columns: override.columns ?? [...base.columns],
+  });
+
 const testContext = {
   version: 170000,
   currentUser: "postgres",
@@ -99,4 +137,128 @@ describe.concurrent("materialized-view.diff", () => {
       changes.some((c) => c instanceof AlterMaterializedViewSetStorageParams),
     ).toBe(true);
   });
+
+  test("create with comment and column comments", () => {
+    const mv = makeMaterializedView({
+      comment: "my matview",
+      columns: [
+        { ...baseColumn, comment: "id column" },
+        { ...baseColumn, name: "val", position: 2, comment: null },
+      ],
+    });
+    const changes = diffMaterializedViews(
+      testContext,
+      {},
+      { [mv.stableId]: mv },
+    );
+    expect(changes[0]).toBeInstanceOf(CreateMaterializedView);
+    expect(
+      changes.some((c) => c instanceof CreateCommentOnMaterializedView),
+    ).toBe(true);
+    expect(
+      changes.some((c) => c instanceof CreateCommentOnMaterializedViewColumn),
+    ).toBe(true);
+  });
+
+  test("create with privileges emits grant changes", () => {
+    const mv = makeMaterializedView({
+      privileges: [
+        { grantee: "role_select", privilege: "SELECT", grantable: false },
+      ],
+    });
+    const changes = diffMaterializedViews(
+      testContext,
+      {},
+      { [mv.stableId]: mv },
+    );
+    expect(changes[0]).toBeInstanceOf(CreateMaterializedView);
+    expect(
+      changes.some((c) => c instanceof GrantMaterializedViewPrivileges),
+    ).toBe(true);
+  });
+
+  test("comment changes emit create/drop comment statements", () => {
+    const main = makeMaterializedView();
+    const withComment = makeMaterializedView({ comment: "matview comment" });
+
+    const addComment = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [withComment.stableId]: withComment },
+    );
+    expect(addComment[0]).toBeInstanceOf(CreateCommentOnMaterializedView);
+
+    const dropComment = diffMaterializedViews(
+      testContext,
+      { [withComment.stableId]: withComment },
+      { [main.stableId]: main },
+    );
+    expect(dropComment[0]).toBeInstanceOf(DropCommentOnMaterializedView);
+  });
+
+  test("column comment changes emit create/drop column comment statements", () => {
+    const main = makeMaterializedView({
+      columns: [{ ...baseColumn, comment: null }],
+    });
+    const withColComment = makeMaterializedView({
+      columns: [{ ...baseColumn, comment: "id column" }],
+    });
+
+    const addColComment = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [withColComment.stableId]: withColComment },
+    );
+    expect(
+      addColComment.some(
+        (c) => c instanceof CreateCommentOnMaterializedViewColumn,
+      ),
+    ).toBe(true);
+
+    const dropColComment = diffMaterializedViews(
+      testContext,
+      { [withColComment.stableId]: withColComment },
+      { [main.stableId]: main },
+    );
+    expect(
+      dropColComment.some(
+        (c) => c instanceof DropCommentOnMaterializedViewColumn,
+      ),
+    ).toBe(true);
+  });
+
+  test("privilege diffs emit grant, revoke, and revoke grant option statements", () => {
+    const main = makeMaterializedView({
+      privileges: [
+        { grantee: "role_select", privilege: "SELECT", grantable: false },
+        { grantee: "role_with_option", privilege: "SELECT", grantable: true },
+        { grantee: "role_removed", privilege: "SELECT", grantable: false },
+      ],
+    });
+    const branch = makeMaterializedView({
+      privileges: [
+        { grantee: "role_select", privilege: "SELECT", grantable: true },
+        { grantee: "role_with_option", privilege: "SELECT", grantable: false },
+        { grantee: "role_new", privilege: "SELECT", grantable: false },
+      ],
+    });
+
+    const changes = diffMaterializedViews(
+      testContext,
+      { [main.stableId]: main },
+      { [branch.stableId]: branch },
+    );
+
+    expect(
+      changes.some((c) => c instanceof GrantMaterializedViewPrivileges),
+    ).toBe(true);
+    expect(
+      changes.some((c) => c instanceof RevokeMaterializedViewPrivileges),
+    ).toBe(true);
+    expect(
+      changes.some(
+        (c) => c instanceof RevokeGrantOptionMaterializedViewPrivileges,
+      ),
+    ).toBe(true);
+  });
 });