@gencow/core 0.1.23 → 0.1.25

package/src/__tests__/rls-crud-basic.test.ts

@@ -65,25 +65,13 @@ describe("fixtures/basic + PGlite + CRUD + RLS", () => {
     db = env.db;
     seededTaskRows = env.taskRows;
     listDef = env.defs.list;
-    listHandler = env.defs.list!.handler as (
-      ctx: unknown,
-      args: unknown
-    ) => Promise<TaskListResult>;
-    getHandler = env.defs.get!.handler as (
-      ctx: unknown,
-      args: unknown
-    ) => Promise<TaskRow | null>;
-    createHandler = env.defs.create!.handler as (
-      ctx: unknown,
-      args: unknown
-    ) => Promise<TaskRow>;
-    updateHandler = env.defs.update!.handler as (
-      ctx: unknown,
-      args: unknown
-    ) => Promise<TaskRow | undefined>;
+    listHandler = env.defs.list!.handler as (ctx: unknown, args: unknown) => Promise<TaskListResult>;
+    getHandler = env.defs.get!.handler as (ctx: unknown, args: unknown) => Promise<TaskRow | null>;
+    createHandler = env.defs.create!.handler as (ctx: unknown, args: unknown) => Promise<TaskRow>;
+    updateHandler = env.defs.update!.handler as (ctx: unknown, args: unknown) => Promise<TaskRow | undefined>;
     removeHandler = env.defs.remove!.handler as (
       ctx: unknown,
-      args: unknown
+      args: unknown,
     ) => Promise<{ success: boolean }>;
   });
 
@@ -102,109 +90,81 @@ describe("fixtures/basic + PGlite + CRUD + RLS", () => {
       tenantId: "tenant_fixture",
       vars: { "app.note": "ok" },
     });
-    const otherUserRows = await scoped
-      .select()
-      .from(tasks)
-      .where(eq(tasks.userId, fixtureUsers[1].id));
+    const otherUserRows = await scoped.select().from(tasks).where(eq(tasks.userId, fixtureUsers[1].id));
     expect(otherUserRows.length).toBe(0);
 
-    const ownRows = await scoped
-      .select()
-      .from(tasks)
-      .where(eq(tasks.userId, user0Identity.id));
-    expect(ownRows.length).toBe(
-      seededTaskRows.filter((r) => r.userId === user0Identity.id).length
-    );
+    const ownRows = await scoped.select().from(tasks).where(eq(tasks.userId, user0Identity.id));
+    expect(ownRows.length).toBe(seededTaskRows.filter((r) => r.userId === user0Identity.id).length);
   });
 
   it("tasks.list returns only the current user (us_000) rows per RLS and total matches", async () => {
     expect(listDef).toBeDefined();
 
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (ctx) => {
-        const listResult = await listHandler(ctx, {});
-
-        const expected = seededTaskRows.filter(
-          (r) => r.userId === fixtureUsers[0].id
-        );
-
-        expect(listResult).toHaveProperty("data");
-        expect(listResult).toHaveProperty("total");
-        expect(listResult.total).toBe(expected.length);
-
-        const rows = listResult.data;
-
-        const byId = new Map(rows.map((r) => [r.id, r]));
-        expect(byId.size).toBe(expected.length);
-
-        for (const seeded of expected) {
-          const row = byId.get(seeded.id);
-          expect(row).toBeDefined();
-          expect(row!.id).toBe(seeded.id);
-          expect(row!.userId).toBe(seeded.userId);
-          expect(row!.done).toBe(seeded.done);
-          expect(row!.title).toBe(seeded.title);
-        }
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (ctx) => {
+      const listResult = await listHandler(ctx, {});
+
+      const expected = seededTaskRows.filter((r) => r.userId === fixtureUsers[0].id);
+
+      expect(listResult).toHaveProperty("data");
+      expect(listResult).toHaveProperty("total");
+      expect(listResult.total).toBe(expected.length);
+
+      const rows = listResult.data;
+
+      const byId = new Map(rows.map((r) => [r.id, r]));
+      expect(byId.size).toBe(expected.length);
+
+      for (const seeded of expected) {
+        const row = byId.get(seeded.id);
+        expect(row).toBeDefined();
+        expect(row!.id).toBe(seeded.id);
+        expect(row!.userId).toBe(seeded.userId);
+        expect(row!.done).toBe(seeded.done);
+        expect(row!.title).toBe(seeded.title);
       }
-    );
+    });
   });
 
   it("search parameter applies to title/description ilike search", async () => {
     expect(listDef).toBeDefined();
 
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (ctx) => {
-        const sharedSubstring = "Project Alpha";
-        const expectedForUser0 = seededTaskRows.filter(
-          (r) =>
-            r.userId === user0Identity.id &&
-            r.title.toLowerCase().includes(sharedSubstring.toLowerCase())
-        );
-        expect(expectedForUser0.length).toBe(2);
-
-        const result = await listHandler(ctx, { search: sharedSubstring });
-        const rows = result.data;
-        expect(rows.length).toBe(expectedForUser0.length);
-
-        const byId = new Map(rows.map((r) => [r.id, r]));
-        for (const seeded of expectedForUser0) {
-          expect(byId.get(seeded.id)?.title).toBe(seeded.title);
-        }
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (ctx) => {
+      const sharedSubstring = "Project Alpha";
+      const expectedForUser0 = seededTaskRows.filter(
+        (r) => r.userId === user0Identity.id && r.title.toLowerCase().includes(sharedSubstring.toLowerCase()),
+      );
+      expect(expectedForUser0.length).toBe(2);
+
+      const result = await listHandler(ctx, { search: sharedSubstring });
+      const rows = result.data;
+      expect(rows.length).toBe(expectedForUser0.length);
+
+      const byId = new Map(rows.map((r) => [r.id, r]));
+      for (const seeded of expectedForUser0) {
+        expect(byId.get(seeded.id)?.title).toBe(seeded.title);
       }
-    );
+    });
   });
 
   it("tasks.get succeeds when current user reads own task", async () => {
     const ownTaskId = "tk-003";
 
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (ctx) => {
-        const task = await getHandler(ctx, { id: ownTaskId });
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (ctx) => {
+      const task = await getHandler(ctx, { id: ownTaskId });
 
-        expect(task).toBeDefined();
-        expect(task?.id).toBe(ownTaskId);
-        expect(task?.userId).toBe(user0Identity.id);
-      }
-    );
+      expect(task).toBeDefined();
+      expect(task?.id).toBe(ownTaskId);
+      expect(task?.userId).toBe(user0Identity.id);
+    });
   });
 
   it("tasks.get fails when current user tries to read another user's task", async () => {
     const user1TaskId = "tk-001";
 
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (ctx) => {
-        const task = await getHandler(ctx, { id: user1TaskId });
-        expect(task).toBeNull();
-      }
-    );
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (ctx) => {
+      const task = await getHandler(ctx, { id: user1TaskId });
+      expect(task).toBeNull();
+    });
   });
 
   it("tasks.update succeeds when updating a task owned by current user", async () => {
@@ -212,179 +172,146 @@ describe("fixtures/basic + PGlite + CRUD + RLS", () => {
     const updatedTitle = "Project Alpha — updated by owner";
     const updatedDone = true;
 
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (ctx) => {
-        const before = await getHandler(ctx, {
-          id: ownTaskId,
-        });
-        expect(before?.title).not.toBe(updatedTitle);
-        expect(before?.done).not.toBe(updatedDone);
-
-        const updated = await updateHandler(ctx, {
-          id: ownTaskId,
-          title: updatedTitle,
-          done: updatedDone,
-        });
-
-        expect(updated).toBeDefined();
-        expect(updated?.id).toBe(ownTaskId);
-        expect(updated?.userId).toBe(user0Identity.id);
-        expect(updated?.title).toBe(updatedTitle);
-        expect(updated?.done).toBe(updatedDone);
-
-        const fetched = await getHandler(ctx, {
-          id: ownTaskId,
-        });
-        expect(fetched?.id).toBe(ownTaskId);
-        expect(fetched?.title).toBe(updatedTitle);
-        expect(fetched?.done).toBe(updatedDone);
-      }
-    );
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (ctx) => {
+      const before = await getHandler(ctx, {
+        id: ownTaskId,
+      });
+      expect(before?.title).not.toBe(updatedTitle);
+      expect(before?.done).not.toBe(updatedDone);
+
+      const updated = await updateHandler(ctx, {
+        id: ownTaskId,
+        title: updatedTitle,
+        done: updatedDone,
+      });
+
+      expect(updated).toBeDefined();
+      expect(updated?.id).toBe(ownTaskId);
+      expect(updated?.userId).toBe(user0Identity.id);
+      expect(updated?.title).toBe(updatedTitle);
+      expect(updated?.done).toBe(updatedDone);
+
+      const fetched = await getHandler(ctx, {
+        id: ownTaskId,
+      });
+      expect(fetched?.id).toBe(ownTaskId);
+      expect(fetched?.title).toBe(updatedTitle);
+      expect(fetched?.done).toBe(updatedDone);
+    });
   });
 
   it("tasks.create succeeds when creating a task with current userId", async () => {
     const ownTaskId = "tk-own-create";
     const ownTaskTitle = "Project Delta — created by owner";
 
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (user0Ctx) => {
-        const created = await createHandler(user0Ctx, {
-          id: ownTaskId,
-          userId: user0Identity.id,
-          title: ownTaskTitle,
-          done: false,
-        });
-
-        expect(created).toBeDefined();
-        expect(created.id).toBe(ownTaskId);
-        expect(created.userId).toBe(user0Identity.id);
-        expect(created.title).toBe(ownTaskTitle);
-        expect(created.done).toBe(false);
-
-        const fetched = await getHandler(user0Ctx, {
-          id: ownTaskId,
-        });
-        expect(fetched).toBeDefined();
-        expect(fetched?.id).toBe(ownTaskId);
-        expect(fetched?.userId).toBe(user0Identity.id);
-      }
-    );
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (user0Ctx) => {
+      const created = await createHandler(user0Ctx, {
+        id: ownTaskId,
+        userId: user0Identity.id,
+        title: ownTaskTitle,
+        done: false,
+      });
+
+      expect(created).toBeDefined();
+      expect(created.id).toBe(ownTaskId);
+      expect(created.userId).toBe(user0Identity.id);
+      expect(created.title).toBe(ownTaskTitle);
+      expect(created.done).toBe(false);
+
+      const fetched = await getHandler(user0Ctx, {
+        id: ownTaskId,
+      });
+      expect(fetched).toBeDefined();
+      expect(fetched?.id).toBe(ownTaskId);
+      expect(fetched?.userId).toBe(user0Identity.id);
+    });
   });
 
   it("tasks.create fails when current user tries to create with another userId", async () => {
     const unauthorizedTaskId = "tk-other-user-create";
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (user0Ctx) => {
-        let thrown: unknown;
-        try {
-          await createHandler(user0Ctx, {
-            id: unauthorizedTaskId,
-            userId: user1Identity.id,
-            title: "Unauthorized create attempt",
-            done: false,
-          });
-        } catch (e) {
-          thrown = e;
-        }
-        expect(thrown).toBeInstanceOf(Error);
-
-        const user1Ctx = makeTestGencowCtxWithRls(
-          user0Ctx.unsafeDb as any,
-          user1Identity
-        );
-        const after = await getHandler(user1Ctx, { id: unauthorizedTaskId });
-        expect(after).toBeNull();
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (user0Ctx) => {
+      let thrown: unknown;
+      try {
+        await createHandler(user0Ctx, {
+          id: unauthorizedTaskId,
+          userId: user1Identity.id,
+          title: "Unauthorized create attempt",
+          done: false,
+        });
+      } catch (e) {
+        thrown = e;
       }
-    );
+      expect(thrown).toBeInstanceOf(Error);
+
+      const user1Ctx = makeTestGencowCtxWithRls(user0Ctx.unsafeDb as any, user1Identity);
+      const after = await getHandler(user1Ctx, { id: unauthorizedTaskId });
+      expect(after).toBeNull();
+    });
   });
 
   it("tasks.update fails when current user tries to update user1 task", async () => {
     const user1TaskId = "tk-001";
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (user0Ctx) => {
-        const user1Ctx = makeTestGencowCtxWithRls(
-          user0Ctx.unsafeDb as any,
-          user1Identity
-        );
-
-        const before = await getHandler(user1Ctx, {
-          id: user1TaskId,
-        });
-        expect(before).toBeDefined();
-        const beforeTitle = before?.title;
-        const beforeDone = before?.done ?? false;
-
-        const unauthorizedUpdate = await updateHandler(user0Ctx, {
-          id: user1TaskId,
-          title: "Unauthorized update attempt",
-          done: !beforeDone,
-        });
-
-        expect(unauthorizedUpdate).toBeUndefined();
-
-        const after = await getHandler(user1Ctx, {
-          id: user1TaskId,
-        });
-        expect(after).toBeDefined();
-        expect(after?.title).toBe(beforeTitle);
-        expect(after?.done).toBe(beforeDone);
-      }
-    );
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (user0Ctx) => {
+      const user1Ctx = makeTestGencowCtxWithRls(user0Ctx.unsafeDb as any, user1Identity);
+
+      const before = await getHandler(user1Ctx, {
+        id: user1TaskId,
+      });
+      expect(before).toBeDefined();
+      const beforeTitle = before?.title;
+      const beforeDone = before?.done ?? false;
+
+      const unauthorizedUpdate = await updateHandler(user0Ctx, {
+        id: user1TaskId,
+        title: "Unauthorized update attempt",
+        done: !beforeDone,
+      });
+
+      expect(unauthorizedUpdate).toBeUndefined();
+
+      const after = await getHandler(user1Ctx, {
+        id: user1TaskId,
+      });
+      expect(after).toBeDefined();
+      expect(after?.title).toBe(beforeTitle);
+      expect(after?.done).toBe(beforeDone);
+    });
   });
 
   it("tasks.remove succeeds when deleting a task owned by current user", async () => {
     const ownTaskId = "tk-002";
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (user0Ctx) => {
-        const before = await getHandler(user0Ctx, { id: ownTaskId });
-        expect(before).toBeDefined();
-
-        const removeResult = await removeHandler(user0Ctx, {
-          id: ownTaskId,
-        });
-        expect(removeResult.success).toBe(true);
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (user0Ctx) => {
+      const before = await getHandler(user0Ctx, { id: ownTaskId });
+      expect(before).toBeDefined();
 
-        const after = await getHandler(user0Ctx, { id: ownTaskId });
-        expect(after).toBeNull();
-      }
-    );
+      const removeResult = await removeHandler(user0Ctx, {
+        id: ownTaskId,
+      });
+      expect(removeResult.success).toBe(true);
+
+      const after = await getHandler(user0Ctx, { id: ownTaskId });
+      expect(after).toBeNull();
+    });
   });
 
   it("tasks.remove cannot delete a task owned by another user", async () => {
     const user1TaskId = "tk-004";
-    await runWithRollbackTestGencowCtxWithRls(
-      db,
-      user0Identity,
-      async (user0Ctx) => {
-        const user1Ctx = makeTestGencowCtxWithRls(
-          user0Ctx.unsafeDb as any,
-          user1Identity
-        );
-
-        const before = await getHandler(user1Ctx, { id: user1TaskId });
-        expect(before).toBeDefined();
-
-        const removeResult = await removeHandler(user0Ctx, {
-          id: user1TaskId,
-        });
-        expect(removeResult.success).toBe(true);
-
-        const after = await getHandler(user1Ctx, {
-          id: user1TaskId,
-        });
-        expect(after).toBeDefined();
-        expect(after?.id).toBe(user1TaskId);
-      }
-    );
+    await runWithRollbackTestGencowCtxWithRls(db, user0Identity, async (user0Ctx) => {
+      const user1Ctx = makeTestGencowCtxWithRls(user0Ctx.unsafeDb as any, user1Identity);
+
+      const before = await getHandler(user1Ctx, { id: user1TaskId });
+      expect(before).toBeDefined();
+
+      const removeResult = await removeHandler(user0Ctx, {
+        id: user1TaskId,
+      });
+      expect(removeResult.success).toBe(true);
+
+      const after = await getHandler(user1Ctx, {
+        id: user1TaskId,
+      });
+      expect(after).toBeDefined();
+      expect(after?.id).toBe(user1TaskId);
+    });
   });
 });