@supabase/pg-delta 1.0.0-alpha.10 → 1.0.0-alpha.11

package/src/core/integrations/filter/dsl.test.ts

@@ -6,15 +6,21 @@ const tableCreate = {
   objectType: "table",
   operation: "create",
   scope: "object",
-  table: { schema: "public", name: "t" },
+  table: {
+    schema: "public",
+    name: "t",
+    owner: "postgres",
+    is_partition: false,
+  },
   requires: ["schema:public"],
+  creates: ["table:public.t"],
 } as unknown as Change;
 
 const viewAlter = {
   objectType: "view",
   operation: "alter",
   scope: "comment",
-  view: { schema: "private", name: "v" },
+  view: { schema: "private", name: "v", owner: "admin" },
   requires: ["schema:private", "type:auth.users"],
 } as unknown as Change;
 
@@ -26,14 +32,23 @@ const roleDrop = {
   requires: [],
 } as unknown as Change;
 
+const membershipChange = {
+  objectType: "role",
+  operation: "create",
+  scope: "membership",
+  member: "app_user",
+  role: { name: "admin_group" },
+  requires: [],
+} as unknown as Change;
+
 describe("evaluatePattern", () => {
-  describe("core properties", () => {
-    test("type match", () => {
-      expect(evaluatePattern({ type: "table" }, tableCreate)).toBe(true);
+  describe("bare key matching (top-level properties)", () => {
+    test("objectType match", () => {
+      expect(evaluatePattern({ objectType: "table" }, tableCreate)).toBe(true);
     });
 
-    test("type mismatch", () => {
-      expect(evaluatePattern({ type: "view" }, tableCreate)).toBe(false);
+    test("objectType mismatch", () => {
+      expect(evaluatePattern({ objectType: "view" }, tableCreate)).toBe(false);
     });
 
     test("operation match", () => {
@@ -52,12 +67,18 @@ describe("evaluatePattern", () => {
       expect(evaluatePattern({ scope: "comment" }, tableCreate)).toBe(false);
     });
 
-    test("multiple core properties AND together", () => {
+    test("multiple bare keys AND together", () => {
       expect(
-        evaluatePattern({ type: "table", operation: "create" }, tableCreate),
+        evaluatePattern(
+          { objectType: "table", operation: "create" },
+          tableCreate,
+        ),
       ).toBe(true);
       expect(
-        evaluatePattern({ type: "table", operation: "drop" }, tableCreate),
+        evaluatePattern(
+          { objectType: "table", operation: "drop" },
+          tableCreate,
+        ),
       ).toBe(false);
     });
 
@@ -67,124 +88,257 @@ describe("evaluatePattern", () => {
     });
   });
 
-  describe("composition patterns", () => {
-    test("not negates a pattern", () => {
-      expect(evaluatePattern({ not: { type: "table" } }, tableCreate)).toBe(
+  describe("path key matching (model sub-object properties)", () => {
+    test("exact path match", () => {
+      expect(evaluatePattern({ "table/schema": "public" }, tableCreate)).toBe(
+        true,
+      );
+      expect(evaluatePattern({ "table/schema": "private" }, tableCreate)).toBe(
         false,
       );
-      expect(evaluatePattern({ not: { type: "view" } }, tableCreate)).toBe(
+    });
+
+    test("path with array value checks inclusion", () => {
+      expect(
+        evaluatePattern({ "table/schema": ["public", "private"] }, tableCreate),
+      ).toBe(true);
+      expect(
+        evaluatePattern({ "table/schema": ["private", "auth"] }, tableCreate),
+      ).toBe(false);
+    });
+
+    test("path not found returns false", () => {
+      expect(evaluatePattern({ "table/schema": "public" }, roleDrop)).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("wildcard pattern matching", () => {
+    test("*/schema matches any objectType's schema", () => {
+      expect(evaluatePattern({ "*/schema": "public" }, tableCreate)).toBe(true);
+      expect(evaluatePattern({ "*/schema": "private" }, viewAlter)).toBe(true);
+      expect(evaluatePattern({ "*/schema": "public" }, viewAlter)).toBe(false);
+    });
+
+    test("*/owner matches across object types", () => {
+      expect(evaluatePattern({ "*/owner": "postgres" }, tableCreate)).toBe(
         true,
       );
+      expect(evaluatePattern({ "*/owner": "admin" }, viewAlter)).toBe(true);
     });
 
-    test("and requires all to match", () => {
+    test("*/schema does not match objectTypes without schema", () => {
+      expect(evaluatePattern({ "*/schema": "anything" }, roleDrop)).toBe(false);
+    });
+
+    test("*/name matches role/name", () => {
+      expect(evaluatePattern({ "*/name": "admin" }, roleDrop)).toBe(true);
+    });
+
+    test("wildcard with array value", () => {
       expect(
-        evaluatePattern(
-          { and: [{ type: "table" }, { operation: "create" }] },
-          tableCreate,
-        ),
+        evaluatePattern({ "*/schema": ["public", "private"] }, tableCreate),
       ).toBe(true);
+    });
+  });
+
+  describe("boolean matching", () => {
+    test("matches boolean value", () => {
       expect(
-        evaluatePattern(
-          { and: [{ type: "table" }, { operation: "drop" }] },
-          tableCreate,
-        ),
-      ).toBe(false);
+        evaluatePattern({ "table/is_partition": false }, tableCreate),
+      ).toBe(true);
+      expect(evaluatePattern({ "table/is_partition": true }, tableCreate)).toBe(
+        false,
+      );
     });
+  });
 
-    test("or requires any to match", () => {
+  describe("regex matching", () => {
+    test("regex on string value", () => {
       expect(
         evaluatePattern(
-          { or: [{ type: "table" }, { type: "view" }] },
+          { "table/name": { op: "regex", value: "^t" } },
           tableCreate,
         ),
       ).toBe(true);
       expect(
         evaluatePattern(
-          { or: [{ type: "role" }, { type: "view" }] },
+          { "table/name": { op: "regex", value: "^z" } },
           tableCreate,
         ),
       ).toBe(false);
     });
 
-    test("nested composition", () => {
+    test("regex with array of patterns", () => {
       expect(
         evaluatePattern(
-          { not: { or: [{ type: "role" }, { type: "view" }] } },
+          { "table/name": { op: "regex", value: ["^z", "^t"] } },
           tableCreate,
         ),
       ).toBe(true);
     });
-  });
 
-  describe("requiresMatching", () => {
-    test("prefix match on requires array", () => {
+    test("regex on array value (requires)", () => {
       expect(
-        evaluatePattern({ requiresMatching: ["schema:public"] }, tableCreate),
+        evaluatePattern(
+          { requires: { op: "regex", value: "^schema:" } },
+          tableCreate,
+        ),
       ).toBe(true);
       expect(
-        evaluatePattern({ requiresMatching: ["schema:"] }, tableCreate),
+        evaluatePattern(
+          { requires: { op: "regex", value: "^type:auth\\." } },
+          viewAlter,
+        ),
       ).toBe(true);
-    });
-
-    test("no match when prefix absent", () => {
       expect(
-        evaluatePattern({ requiresMatching: ["type:auth."] }, tableCreate),
+        evaluatePattern(
+          { requires: { op: "regex", value: "^type:auth\\." } },
+          tableCreate,
+        ),
       ).toBe(false);
     });
+  });
+
+  describe("array value matching (requires/creates)", () => {
+    test("string match against array checks any element", () => {
+      expect(evaluatePattern({ requires: "schema:public" }, tableCreate)).toBe(
+        true,
+      );
+      expect(evaluatePattern({ requires: "schema:private" }, tableCreate)).toBe(
+        false,
+      );
+    });
 
-    test("matches when any prefix matches any requires entry", () => {
+    test("array match against array checks intersection", () => {
       expect(
-        evaluatePattern({ requiresMatching: ["type:auth."] }, viewAlter),
+        evaluatePattern(
+          { requires: ["schema:public", "schema:other"] },
+          tableCreate,
+        ),
       ).toBe(true);
     });
 
-    test("no match when requires is empty", () => {
-      expect(evaluatePattern({ requiresMatching: ["schema:"] }, roleDrop)).toBe(
+    test("no match on empty requires", () => {
+      expect(evaluatePattern({ requires: "schema:public" }, roleDrop)).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("member/grantee matching", () => {
+    test("member match", () => {
+      expect(evaluatePattern({ member: "app_user" }, membershipChange)).toBe(
+        true,
+      );
+      expect(evaluatePattern({ member: "other_user" }, membershipChange)).toBe(
         false,
       );
     });
+
+    test("member not present returns false", () => {
+      expect(evaluatePattern({ member: "app_user" }, tableCreate)).toBe(false);
+    });
   });
 
-  describe("extracted properties", () => {
-    test("schema as string exact match", () => {
-      expect(evaluatePattern({ schema: "public" }, tableCreate)).toBe(true);
-      expect(evaluatePattern({ schema: "private" }, tableCreate)).toBe(false);
+  describe("composition patterns", () => {
+    test("not negates a pattern", () => {
+      expect(
+        evaluatePattern({ not: { objectType: "table" } }, tableCreate),
+      ).toBe(false);
+      expect(
+        evaluatePattern({ not: { objectType: "view" } }, tableCreate),
+      ).toBe(true);
     });
 
-    test("schema as array checks inclusion", () => {
+    test("and requires all to match", () => {
       expect(
-        evaluatePattern({ schema: ["public", "private"] }, tableCreate),
+        evaluatePattern(
+          { and: [{ objectType: "table" }, { operation: "create" }] },
+          tableCreate,
+        ),
       ).toBe(true);
       expect(
-        evaluatePattern({ schema: ["private", "auth"] }, tableCreate),
+        evaluatePattern(
+          { and: [{ objectType: "table" }, { operation: "drop" }] },
+          tableCreate,
+        ),
       ).toBe(false);
     });
 
-    test("null extracted value returns false", () => {
-      expect(evaluatePattern({ schema: "public" }, roleDrop)).toBe(false);
+    test("or requires any to match", () => {
+      expect(
+        evaluatePattern(
+          { or: [{ objectType: "table" }, { objectType: "view" }] },
+          tableCreate,
+        ),
+      ).toBe(true);
+      expect(
+        evaluatePattern(
+          { or: [{ objectType: "role" }, { objectType: "view" }] },
+          tableCreate,
+        ),
+      ).toBe(false);
+    });
+
+    test("nested composition", () => {
+      expect(
+        evaluatePattern(
+          { not: { or: [{ objectType: "role" }, { objectType: "view" }] } },
+          tableCreate,
+        ),
+      ).toBe(true);
+    });
+
+    test("composition with wildcard patterns", () => {
+      expect(
+        evaluatePattern(
+          { not: { "*/schema": ["auth", "extensions"] } },
+          tableCreate,
+        ),
+      ).toBe(true);
     });
+  });
 
-    test("unknown property key is ignored", () => {
-      const pattern = { unknownKey: "value" } as Record<string, unknown>;
+  describe("combined path + bare keys", () => {
+    test("objectType and path key AND together", () => {
       expect(
         evaluatePattern(
-          pattern as Parameters<typeof evaluatePattern>[0],
+          { objectType: "table", "table/is_partition": false },
           tableCreate,
         ),
       ).toBe(true);
+      expect(
+        evaluatePattern(
+          { objectType: "table", "table/is_partition": true },
+          tableCreate,
+        ),
+      ).toBe(false);
     });
+  });
 
-    test("cascade property is ignored and does not affect match", () => {
+  describe("cascade property", () => {
+    test("cascade is ignored and does not affect match", () => {
       expect(
-        evaluatePattern({ type: "table", cascade: true }, tableCreate),
+        evaluatePattern(
+          { objectType: "table", cascade: true } as Parameters<
+            typeof evaluatePattern
+          >[0],
+          tableCreate,
+        ),
       ).toBe(true);
       expect(
-        evaluatePattern({ type: "table", cascade: false }, tableCreate),
+        evaluatePattern(
+          { objectType: "table", cascade: false } as Parameters<
+            typeof evaluatePattern
+          >[0],
+          tableCreate,
+        ),
       ).toBe(true);
       expect(
         evaluatePattern(
-          { not: { schema: "auth" }, cascade: true },
+          { not: { "*/schema": "auth" }, cascade: true },
           tableCreate,
         ),
       ).toBe(true);
@@ -194,7 +348,7 @@ describe("evaluatePattern", () => {
 
 describe("compileFilterDSL", () => {
   test("returns a function that evaluates the pattern", () => {
-    const filter = compileFilterDSL({ type: "table" });
+    const filter = compileFilterDSL({ objectType: "table" });
     expect(typeof filter).toBe("function");
     expect(filter(tableCreate)).toBe(true);
     expect(filter(roleDrop)).toBe(false);
@@ -202,10 +356,95 @@ describe("compileFilterDSL", () => {
 
   test("works with composition patterns", () => {
     const filter = compileFilterDSL({
-      or: [{ type: "table" }, { type: "role" }],
+      or: [{ objectType: "table" }, { objectType: "role" }],
     });
     expect(filter(tableCreate)).toBe(true);
     expect(filter(roleDrop)).toBe(true);
     expect(filter(viewAlter)).toBe(false);
   });
+
+  test("works with wildcard-based patterns", () => {
+    const filter = compileFilterDSL({
+      "*/schema": "public",
+    });
+    expect(filter(tableCreate)).toBe(true);
+    expect(filter(viewAlter)).toBe(false);
+  });
+
+  test("throws on invalid regex pattern", () => {
+    expect(() =>
+      compileFilterDSL({
+        "table/name": { op: "regex", value: "[invalid" },
+      }),
+    ).toThrow(/Invalid regex pattern "\[invalid" in filter DSL/);
+  });
+
+  test("throws on invalid regex in array of patterns", () => {
+    expect(() =>
+      compileFilterDSL({
+        "table/name": { op: "regex", value: ["^valid$", "(unclosed"] },
+      }),
+    ).toThrow(/Invalid regex pattern "\(unclosed" in filter DSL/);
+  });
+
+  test("throws on invalid regex nested in composition", () => {
+    expect(() =>
+      compileFilterDSL({
+        or: [
+          { objectType: "table" },
+          { "table/name": { op: "regex", value: "**bad" } },
+        ],
+      }),
+    ).toThrow(/Invalid regex pattern "\*\*bad" in filter DSL/);
+  });
+});
+
+describe("glob pattern features", () => {
+  const tableCreate = {
+    objectType: "table",
+    operation: "create",
+    scope: "object",
+    table: {
+      schema: "public",
+      name: "t",
+      owner: "postgres",
+      is_partition: false,
+    },
+    requires: ["schema:public"],
+    creates: ["table:public.t"],
+  } as unknown as Change;
+
+  const viewAlter = {
+    objectType: "view",
+    operation: "alter",
+    scope: "comment",
+    view: { schema: "private", name: "v", owner: "admin" },
+    requires: ["schema:private", "type:auth.users"],
+  } as unknown as Change;
+
+  const roleDrop = {
+    objectType: "role",
+    operation: "drop",
+    scope: "object",
+    role: { name: "admin" },
+    requires: [],
+  } as unknown as Change;
+
+  test("brace expansion in path pattern keys", () => {
+    const filter = compileFilterDSL({ "{table,view}/schema": "public" });
+    expect(filter(tableCreate)).toBe(true);
+    expect(filter(viewAlter)).toBe(false); // private, not public
+    expect(filter(roleDrop)).toBe(false); // no matching key
+  });
+
+  test("partial wildcard in field names", () => {
+    const filter = compileFilterDSL({ "table/is_*": false });
+    expect(filter(tableCreate)).toBe(true); // is_partition = false
+  });
+
+  test("extglob negation in pattern keys", () => {
+    const filter = compileFilterDSL({ "!(role)/schema": "public" });
+    expect(filter(tableCreate)).toBe(true); // table/schema = public
+    expect(filter(roleDrop)).toBe(false); // role excluded by negation
+  });
 });