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

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { diffRlsPolicies } from "../rls-policy.diff.ts";
 import { RlsPolicy, type RlsPolicyProps } from "../rls-policy.model.ts";
 import {
@@ -11,7 +12,7 @@ import { DropRlsPolicy } from "./rls-policy.drop.ts";
 
 describe.concurrent("rls-policy", () => {
   describe("alter", () => {
-    test("change roles", () => {
+    test("change roles", async () => {
       const props: Omit<RlsPolicyProps, "roles"> = {
         schema: "public",
         name: "test_policy",
@@ -33,12 +34,14 @@ describe.concurrent("rls-policy", () => {
         roles: ["role1", "role2"],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
-        "ALTER POLICY public.test_policy ON public.test_table TO role1, role2",
+        "ALTER POLICY test_policy ON public.test_table TO role1, role2",
       );
     });
 
-    test("change roles to PUBLIC (default)", () => {
+    test("change roles to PUBLIC (default)", async () => {
       const props: Omit<RlsPolicyProps, "roles"> = {
         schema: "public",
         name: "test_policy",
@@ -60,12 +63,14 @@ describe.concurrent("rls-policy", () => {
         roles: ["public"],
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
-        "ALTER POLICY public.test_policy ON public.test_table TO PUBLIC",
+        "ALTER POLICY test_policy ON public.test_table TO PUBLIC",
       );
     });
 
-    test("drop + create rls policy when command changes", () => {
+    test("drop + create rls policy when command changes", async () => {
       const props: Omit<RlsPolicyProps, "command"> = {
         schema: "public",
         name: "test_policy",
@@ -94,15 +99,17 @@ describe.concurrent("rls-policy", () => {
       expect(changes).toHaveLength(2);
       expect(changes[0]).toBeInstanceOf(DropRlsPolicy);
       expect(changes[1]).toBeInstanceOf(CreateRlsPolicy);
+      await assertValidSql(changes[0].serialize());
       expect(changes[0].serialize()).toBe(
         "DROP POLICY test_policy ON public.test_table",
       );
+      await assertValidSql(changes[1].serialize());
       expect(changes[1].serialize()).toBe(
         "CREATE POLICY test_policy ON public.test_table FOR UPDATE USING (user_id = current_user_id())",
       );
     });
 
-    test("drop + create rls policy when permissive changes", () => {
+    test("drop + create rls policy when permissive changes", async () => {
       const props: Omit<RlsPolicyProps, "permissive"> = {
         schema: "public",
         name: "test_policy",
@@ -131,15 +138,17 @@ describe.concurrent("rls-policy", () => {
       expect(changes).toHaveLength(2);
       expect(changes[0]).toBeInstanceOf(DropRlsPolicy);
       expect(changes[1]).toBeInstanceOf(CreateRlsPolicy);
+      await assertValidSql(changes[0].serialize());
       expect(changes[0].serialize()).toBe(
         "DROP POLICY test_policy ON public.test_table",
       );
+      await assertValidSql(changes[1].serialize());
       expect(changes[1].serialize()).toBe(
         "CREATE POLICY test_policy ON public.test_table AS RESTRICTIVE FOR SELECT USING (user_id = current_user_id())",
       );
     });
 
-    test("alter using expression", () => {
+    test("alter using expression", async () => {
       const props: Omit<RlsPolicyProps, "using_expression"> = {
         schema: "public",
         name: "test_policy",
@@ -161,12 +170,14 @@ describe.concurrent("rls-policy", () => {
         usingExpression: "new_expr",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
-        "ALTER POLICY public.test_policy ON public.test_table USING (new_expr)",
+        "ALTER POLICY test_policy ON public.test_table USING (new_expr)",
       );
     });
 
-    test("clear using expression -> USING (true)", () => {
+    test("clear using expression -> USING (true)", async () => {
       const props: Omit<RlsPolicyProps, "using_expression"> = {
         schema: "public",
         name: "test_policy",
@@ -188,12 +199,14 @@ describe.concurrent("rls-policy", () => {
         usingExpression: null,
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
-        "ALTER POLICY public.test_policy ON public.test_table USING (true)",
+        "ALTER POLICY test_policy ON public.test_table USING (true)",
       );
     });
 
-    test("alter with check expression", () => {
+    test("alter with check expression", async () => {
       const props: Omit<RlsPolicyProps, "with_check_expression"> = {
         schema: "public",
         name: "test_policy",
@@ -215,12 +228,14 @@ describe.concurrent("rls-policy", () => {
         withCheckExpression: "new_check",
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
-        "ALTER POLICY public.test_policy ON public.test_table WITH CHECK (new_check)",
+        "ALTER POLICY test_policy ON public.test_table WITH CHECK (new_check)",
       );
     });
 
-    test("clear with check expression -> WITH CHECK (true)", () => {
+    test("clear with check expression -> WITH CHECK (true)", async () => {
       const props: Omit<RlsPolicyProps, "with_check_expression"> = {
         schema: "public",
         name: "test_policy",
@@ -242,8 +257,10 @@ describe.concurrent("rls-policy", () => {
         withCheckExpression: null,
       });
 
+      await assertValidSql(change.serialize());
+
       expect(change.serialize()).toBe(
-        "ALTER POLICY public.test_policy ON public.test_table WITH CHECK (true)",
+        "ALTER POLICY test_policy ON public.test_table WITH CHECK (true)",
       );
     });
   });

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

@@ -47,7 +47,7 @@ export class AlterRlsPolicySetRoles extends AlterRlsPolicyChange {
 
     return [
       "ALTER POLICY",
-      `${this.policy.schema}.${this.policy.name}`,
+      this.policy.name,
       "ON",
       `${this.policy.schema}.${this.policy.table_name}`,
       "TO",
@@ -78,7 +78,7 @@ export class AlterRlsPolicySetUsingExpression extends AlterRlsPolicyChange {
     const expr = this.usingExpression ?? "true";
     return [
       "ALTER POLICY",
-      `${this.policy.schema}.${this.policy.name}`,
+      this.policy.name,
       "ON",
       `${this.policy.schema}.${this.policy.table_name}`,
       "USING",
@@ -112,7 +112,7 @@ export class AlterRlsPolicySetWithCheckExpression extends AlterRlsPolicyChange {
     const expr = this.withCheckExpression ?? "true";
     return [
       "ALTER POLICY",
-      `${this.policy.schema}.${this.policy.name}`,
+      this.policy.name,
       "ON",
       `${this.policy.schema}.${this.policy.table_name}`,
       "WITH CHECK",

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { RlsPolicy } from "../rls-policy.model.ts";
 import { CreateRlsPolicy } from "./rls-policy.create.ts";
 
 describe("rls-policy", () => {
-  test("create minimal", () => {
+  test("create minimal", async () => {
     const policy = new RlsPolicy({
       schema: "public",
       name: "test_policy_min",
@@ -21,12 +22,14 @@ describe("rls-policy", () => {
       policy,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE POLICY test_policy_min ON public.test_table",
     );
   });
 
-  test("create", () => {
+  test("create", async () => {
     const policy = new RlsPolicy({
       schema: "public",
       name: "test_policy",
@@ -44,12 +47,14 @@ describe("rls-policy", () => {
       policy,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE POLICY test_policy ON public.test_table FOR SELECT USING (user_id = current_user_id())",
     );
   });
 
-  test("create with all options", () => {
+  test("create with all options", async () => {
     const policy = new RlsPolicy({
       schema: "public",
       name: "test_policy_all",
@@ -67,6 +72,8 @@ describe("rls-policy", () => {
       policy,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "CREATE POLICY test_policy_all ON public.test_table AS RESTRICTIVE FOR UPDATE TO role1, role2 USING (expr1) WITH CHECK (expr2)",
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { RlsPolicy } from "../rls-policy.model.ts";
 import { DropRlsPolicy } from "./rls-policy.drop.ts";
 
 describe("rls-policy", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const policy = new RlsPolicy({
       schema: "public",
       name: "test_policy",
@@ -21,6 +22,8 @@ describe("rls-policy", () => {
       policy,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe(
       "DROP POLICY test_policy ON public.test_table",
     );

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

@@ -1,10 +1,11 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Role, type RoleProps } from "../role.model.ts";
 import { AlterRoleSetOptions } from "./role.alter.ts";
 
 describe.concurrent("role", () => {
   describe("alter", () => {
-    test("alter SUPERUSER", () => {
+    test("alter SUPERUSER", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -21,10 +22,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["SUPERUSER"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH SUPERUSER");
     });
 
-    test("alter NOSUPERUSER", () => {
+    test("alter NOSUPERUSER", async () => {
       const role = new Role({
         name: "r",
         is_superuser: true,
@@ -44,10 +46,11 @@ describe.concurrent("role", () => {
         role,
         options: ["NOSUPERUSER"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH NOSUPERUSER");
     });
 
-    test("alter NOCREATEDB", () => {
+    test("alter NOCREATEDB", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -64,10 +67,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["NOCREATEDB"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH NOCREATEDB");
     });
 
-    test("alter NOCREATEROLE", () => {
+    test("alter NOCREATEROLE", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -87,10 +91,11 @@ describe.concurrent("role", () => {
         role,
         options: ["NOCREATEROLE"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH NOCREATEROLE");
     });
 
-    test("alter INHERIT", () => {
+    test("alter INHERIT", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -107,10 +112,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["INHERIT"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH INHERIT");
     });
 
-    test("alter LOGIN", () => {
+    test("alter LOGIN", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -127,10 +133,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["LOGIN"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH LOGIN");
     });
 
-    test("alter NOREPLICATION", () => {
+    test("alter NOREPLICATION", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -150,10 +157,11 @@ describe.concurrent("role", () => {
         role,
         options: ["NOREPLICATION"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH NOREPLICATION");
     });
 
-    test("alter NOBYPASSRLS", () => {
+    test("alter NOBYPASSRLS", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -173,10 +181,11 @@ describe.concurrent("role", () => {
         role,
         options: ["NOBYPASSRLS"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH NOBYPASSRLS");
     });
 
-    test("alter CREATEROLE", () => {
+    test("alter CREATEROLE", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -193,10 +202,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["CREATEROLE"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH CREATEROLE");
     });
 
-    test("alter NOINHERIT", () => {
+    test("alter NOINHERIT", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -213,10 +223,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["NOINHERIT"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH NOINHERIT");
     });
 
-    test("alter NOLOGIN", () => {
+    test("alter NOLOGIN", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -233,10 +244,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["NOLOGIN"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH NOLOGIN");
     });
 
-    test("alter REPLICATION", () => {
+    test("alter REPLICATION", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -256,10 +268,11 @@ describe.concurrent("role", () => {
         role,
         options: ["REPLICATION"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH REPLICATION");
     });
 
-    test("alter BYPASSRLS", () => {
+    test("alter BYPASSRLS", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -276,10 +289,11 @@ describe.concurrent("role", () => {
         default_privileges: [],
       });
       const change = new AlterRoleSetOptions({ role, options: ["BYPASSRLS"] });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe("ALTER ROLE r WITH BYPASSRLS");
     });
 
-    test("alter multiple options ordering", () => {
+    test("alter multiple options ordering", async () => {
       const role = new Role({
         name: "r",
         is_superuser: false,
@@ -308,11 +322,12 @@ describe.concurrent("role", () => {
           "CONNECTION LIMIT 10",
         ],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER ROLE r WITH SUPERUSER CREATEDB CREATEROLE NOINHERIT LOGIN REPLICATION BYPASSRLS CONNECTION LIMIT 10",
       );
     });
-    test("alter flags and connection limit", () => {
+    test("alter flags and connection limit", async () => {
       const props: Omit<
         RoleProps,
         "can_create_databases" | "connection_limit"
@@ -338,6 +353,7 @@ describe.concurrent("role", () => {
         role,
         options: ["CREATEDB", "CONNECTION LIMIT 3"],
       });
+      await assertValidSql(change.serialize());
       expect(change.serialize()).toBe(
         "ALTER ROLE r WITH CREATEDB CONNECTION LIMIT 3",
       );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Role } from "../role.model.ts";
 import { CreateRole } from "./role.create.ts";
 
 describe("role", () => {
-  test("create minimal (omit defaults)", () => {
+  test("create minimal (omit defaults)", async () => {
     const role = new Role({
       name: "test_role",
       is_superuser: false,
@@ -24,10 +25,12 @@ describe("role", () => {
       role,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("CREATE ROLE test_role WITH LOGIN");
   });
 
-  test("create with all options (non-defaults only)", () => {
+  test("create with all options (non-defaults only)", async () => {
     const role = new Role({
       name: "r_all",
       is_superuser: true,
@@ -45,6 +48,7 @@ describe("role", () => {
     });
 
     const change = new CreateRole({ role });
+    await assertValidSql(change.serialize());
     expect(change.serialize()).toBe(
       "CREATE ROLE r_all WITH SUPERUSER CREATEDB CREATEROLE NOINHERIT LOGIN REPLICATION BYPASSRLS CONNECTION LIMIT 5",
     );

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

@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { assertValidSql } from "../../../test-utils/assert-valid-sql.ts";
 import { Role } from "../role.model.ts";
 import { DropRole } from "./role.drop.ts";
 
 describe("role", () => {
-  test("drop", () => {
+  test("drop", async () => {
     const role = new Role({
       name: "test_role",
       is_superuser: false,
@@ -24,6 +25,8 @@ describe("role", () => {
       role,
     });
 
+    await assertValidSql(change.serialize());
+
     expect(change.serialize()).toBe("DROP ROLE test_role");
   });
 });