@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/in-memory/in-memory-uow.mutations.test.ts

@@ -0,0 +1,344 @@
+import { describe, expect, it } from "vitest";
+
+import { UnitOfWork } from "../../query/unit-of-work/unit-of-work";
+import type { AnySchema } from "../../schema/create";
+import { column, idColumn, schema, FragnoId, referenceColumn } from "../../schema/create";
+import {
+  createInMemoryUowCompiler,
+  createInMemoryUowExecutor,
+  InMemoryUowDecoder,
+} from "./in-memory-uow";
+import { resolveInMemoryAdapterOptions, type InMemoryAdapterOptions } from "./options";
+import { createInMemoryStore } from "./store";
+
+const testSchema = schema("test", (s) =>
+  s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),
+);
+
+const fkSchema = schema("fk", (s) =>
+  s
+    .addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string")))
+    .addTable("posts", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("title", column("string"))
+        .addColumn("authorId", referenceColumn()),
+    )
+    .addReference("author", {
+      type: "one",
+      from: { table: "posts", column: "authorId" },
+      to: { table: "users", column: "id" },
+    }),
+);
+
+const joinOnlySchema = schema("join-only", (s) =>
+  s
+    .addTable("users", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("email", column("string"))
+        .createIndex("users_email_idx", ["email"], { unique: true }),
+    )
+    .addTable("invitations", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("email", column("string"))
+        .createIndex("invitations_email_idx", ["email"]),
+    )
+    .addReference("invitedUser", {
+      type: "one",
+      from: { table: "invitations", column: "email" },
+      to: { table: "users", column: "email" },
+      foreignKey: false,
+    }),
+);
+
+const createTestUowFactory = () => {
+  const store = createInMemoryStore();
+  const options = resolveInMemoryAdapterOptions({ idSeed: "seed" });
+  const compiler = createInMemoryUowCompiler();
+  const executor = createInMemoryUowExecutor(store, options);
+  const decoder = new InMemoryUowDecoder();
+
+  return () => new UnitOfWork(compiler, executor, decoder).forSchema(testSchema);
+};
+
+const createFkUowFactory = () => {
+  const store = createInMemoryStore();
+  const options = resolveInMemoryAdapterOptions({ idSeed: "seed" });
+  const compiler = createInMemoryUowCompiler();
+  const executor = createInMemoryUowExecutor(store, options);
+  const decoder = new InMemoryUowDecoder();
+
+  return () => new UnitOfWork(compiler, executor, decoder).forSchema(fkSchema);
+};
+
+const createUowFactoryWithOptions = <TSchema extends AnySchema>(
+  testSchemaToUse: TSchema,
+  optionsOverrides: InMemoryAdapterOptions = {},
+) => {
+  const store = createInMemoryStore();
+  const options = resolveInMemoryAdapterOptions({ idSeed: "seed", ...optionsOverrides });
+  const compiler = createInMemoryUowCompiler();
+  const executor = createInMemoryUowExecutor(store, options);
+  const decoder = new InMemoryUowDecoder();
+
+  return {
+    createUow: () => new UnitOfWork(compiler, executor, decoder).forSchema(testSchemaToUse),
+    options,
+    store,
+  };
+};
+
+describe("in-memory uow mutations", () => {
+  it("updates rows with version checks and increments version", async () => {
+    const createUow = createTestUowFactory();
+
+    const createMutation = createUow();
+    createMutation.create("users", { id: "user-1", name: "Jane" });
+    const createResult = await createMutation.executeMutations();
+    expect(createResult.success).toBe(true);
+
+    const createdId = createMutation.getCreatedIds()[0]!;
+    expect(createdId.version).toBe(0);
+
+    const updateMutation = createUow();
+    updateMutation.update("users", createdId, (b) => b.set({ name: "June" }).check());
+    const updateResult = await updateMutation.executeMutations();
+    expect(updateResult.success).toBe(true);
+
+    const findAfterUpdate = createUow();
+    findAfterUpdate.find("users", (b) => b.whereIndex("primary"));
+    const rows = (await findAfterUpdate.executeRetrieve()) as unknown[];
+    const updatedUser = (rows[0] as { id: FragnoId; name: string }[])[0];
+
+    expect(updatedUser?.name).toBe("June");
+    expect(updatedUser?.id).toBeInstanceOf(FragnoId);
+    expect(updatedUser?.id.version).toBe(1);
+
+    const staleUpdate = createUow();
+    staleUpdate.update("users", createdId, (b) => b.set({ name: "Nope" }).check());
+    const staleResult = await staleUpdate.executeMutations();
+    expect(staleResult.success).toBe(false);
+
+    const findAfterStale = createUow();
+    findAfterStale.find("users", (b) => b.whereIndex("primary"));
+    const staleRows = (await findAfterStale.executeRetrieve()) as unknown[];
+    const staleUser = (staleRows[0] as { id: FragnoId; name: string }[])[0];
+
+    expect(staleUser?.name).toBe("June");
+    expect(staleUser?.id.version).toBe(1);
+  });
+
+  it("checks and deletes rows with version enforcement", async () => {
+    const createUow = createTestUowFactory();
+
+    const createMutation = createUow();
+    createMutation.create("users", { id: "user-2", name: "Ari" });
+    const createResult = await createMutation.executeMutations();
+    expect(createResult.success).toBe(true);
+
+    const createdId = createMutation.getCreatedIds()[0]!;
+
+    const checkMutation = createUow();
+    checkMutation.check("users", createdId);
+    const checkResult = await checkMutation.executeMutations();
+    expect(checkResult.success).toBe(true);
+
+    const wrongVersionId = new FragnoId({
+      externalId: createdId.externalId,
+      internalId: createdId.internalId,
+      version: createdId.version + 1,
+    });
+
+    const badCheck = createUow();
+    badCheck.check("users", wrongVersionId);
+    const badCheckResult = await badCheck.executeMutations();
+    expect(badCheckResult.success).toBe(false);
+
+    const badDelete = createUow();
+    badDelete.delete("users", wrongVersionId, (b) => b.check());
+    const badDeleteResult = await badDelete.executeMutations();
+    expect(badDeleteResult.success).toBe(false);
+
+    const findBeforeDelete = createUow();
+    findBeforeDelete.find("users", (b) => b.whereIndex("primary"));
+    const beforeDeleteRows = (await findBeforeDelete.executeRetrieve()) as unknown[];
+    expect(beforeDeleteRows[0]).toHaveLength(1);
+
+    const deleteMutation = createUow();
+    deleteMutation.delete("users", createdId, (b) => b.check());
+    const deleteResult = await deleteMutation.executeMutations();
+    expect(deleteResult.success).toBe(true);
+
+    const findAfterDelete = createUow();
+    findAfterDelete.find("users", (b) => b.whereIndex("primary"));
+    const afterDeleteRows = (await findAfterDelete.executeRetrieve()) as unknown[];
+    expect(afterDeleteRows[0]).toHaveLength(0);
+  });
+
+  it("enforces foreign keys on create and update", async () => {
+    const createUow = createFkUowFactory();
+
+    const createUser = createUow();
+    createUser.create("users", { id: "user-1", name: "Ada" });
+    const createUserResult = await createUser.executeMutations();
+    expect(createUserResult.success).toBe(true);
+
+    const userId = createUser.getCreatedIds()[0]!;
+
+    const createPost = createUow();
+    createPost.create("posts", {
+      id: "post-1",
+      title: "Hello",
+      authorId: userId,
+    });
+    const createPostResult = await createPost.executeMutations();
+    expect(createPostResult.success).toBe(true);
+
+    const badCreate = createUow();
+    badCreate.create("posts", {
+      id: "post-2",
+      title: "Nope",
+      authorId: "missing-user",
+    });
+    await expect(badCreate.executeMutations()).rejects.toThrow("Foreign key constraint violation");
+
+    const postId = createPost.getCreatedIds()[0]!;
+    const badUpdate = createUow();
+    badUpdate.update("posts", postId, (b) => b.set({ authorId: "missing-user" }));
+    await expect(badUpdate.executeMutations()).rejects.toThrow("Foreign key constraint violation");
+  });
+
+  it("enforces foreign keys on delete", async () => {
+    const createUow = createFkUowFactory();
+
+    const createUser = createUow();
+    createUser.create("users", { id: "user-2", name: "Sam" });
+    const createUserResult = await createUser.executeMutations();
+    expect(createUserResult.success).toBe(true);
+
+    const userId = createUser.getCreatedIds()[0]!;
+
+    const createPost = createUow();
+    createPost.create("posts", {
+      id: "post-3",
+      title: "Dependent",
+      authorId: userId,
+    });
+    const createPostResult = await createPost.executeMutations();
+    expect(createPostResult.success).toBe(true);
+
+    const deleteUser = createUow();
+    deleteUser.delete("users", userId, (b) => b.check());
+    await expect(deleteUser.executeMutations()).rejects.toThrow("Foreign key constraint violation");
+  });
+
+  it("does not enforce join-only relations as foreign keys", async () => {
+    const { createUow } = createUowFactoryWithOptions(joinOnlySchema);
+
+    const createInvitation = createUow();
+    createInvitation.create("invitations", { id: "invite-1", email: "missing@example.com" });
+    const createInvitationResult = await createInvitation.executeMutations();
+    expect(createInvitationResult.success).toBe(true);
+
+    const createUser = createUow();
+    createUser.create("users", { id: "user-1", email: "user@example.com" });
+    const createUserResult = await createUser.executeMutations();
+    expect(createUserResult.success).toBe(true);
+
+    const userId = createUser.getCreatedIds()[0]!;
+    const createInvitation2 = createUow();
+    createInvitation2.create("invitations", { id: "invite-2", email: "user@example.com" });
+    const createInvitation2Result = await createInvitation2.executeMutations();
+    expect(createInvitation2Result.success).toBe(true);
+
+    const deleteUser = createUow();
+    deleteUser.delete("users", userId, (b) => b.check());
+    const deleteUserResult = await deleteUser.executeMutations();
+    expect(deleteUserResult.success).toBe(true);
+  });
+
+  it("uses custom internal id generators when provided", async () => {
+    let current = 9n;
+    const internalIdGenerator = () => {
+      current += 1n;
+      return current;
+    };
+    const { createUow } = createUowFactoryWithOptions(testSchema, { internalIdGenerator });
+
+    const firstCreate = createUow();
+    firstCreate.create("users", { id: "user-1", name: "Ari" });
+    const firstResult = await firstCreate.executeMutations();
+    expect(firstResult.success).toBe(true);
+
+    const secondCreate = createUow();
+    secondCreate.create("users", { id: "user-2", name: "Bea" });
+    const secondResult = await secondCreate.executeMutations();
+    expect(secondResult.success).toBe(true);
+
+    const [firstId, secondId] = [firstCreate.getCreatedIds()[0]!, secondCreate.getCreatedIds()[0]!];
+
+    expect(firstId.internalId).toBe(10n);
+    expect(secondId.internalId).toBe(11n);
+  });
+
+  it("skips foreign key and unique constraints when enforceConstraints is false", async () => {
+    const { createUow } = createUowFactoryWithOptions(testSchema, {
+      enforceConstraints: false,
+    });
+    const { createUow: createFkUow } = createUowFactoryWithOptions(fkSchema, {
+      enforceConstraints: false,
+    });
+
+    const createUser = createUow();
+    createUser.create("users", { id: "dup-id", name: "First" });
+    const firstResult = await createUser.executeMutations();
+    expect(firstResult.success).toBe(true);
+
+    const createUserDup = createUow();
+    createUserDup.create("users", { id: "dup-id", name: "Second" });
+    const secondResult = await createUserDup.executeMutations();
+    expect(secondResult.success).toBe(true);
+
+    const findDupes = createUow();
+    findDupes.find("users", (b) => b.whereIndex("primary"));
+    const dupeRows = (await findDupes.executeRetrieve()) as unknown[];
+    expect(dupeRows[0]).toHaveLength(2);
+
+    const createPost = createFkUow();
+    createPost.create("posts", {
+      id: "post-1",
+      title: "No author",
+      authorId: "missing-user",
+    });
+    const createPostResult = await createPost.executeMutations();
+    expect(createPostResult.success).toBe(true);
+
+    const createdPostId = createPost.getCreatedIds()[0]!;
+    const updatePost = createFkUow();
+    updatePost.update("posts", createdPostId, (b) => b.set({ authorId: "still-missing" }));
+    const updatePostResult = await updatePost.executeMutations();
+    expect(updatePostResult.success).toBe(true);
+
+    const createUserForDelete = createFkUow();
+    createUserForDelete.create("users", { id: "user-3", name: "Sam" });
+    const createUserForDeleteResult = await createUserForDelete.executeMutations();
+    expect(createUserForDeleteResult.success).toBe(true);
+
+    const userId = createUserForDelete.getCreatedIds()[0]!;
+    const createPostForDelete = createFkUow();
+    createPostForDelete.create("posts", {
+      id: "post-2",
+      title: "Dependent",
+      authorId: userId,
+    });
+    const createPostForDeleteResult = await createPostForDelete.executeMutations();
+    expect(createPostForDeleteResult.success).toBe(true);
+
+    const deleteUser = createFkUow();
+    deleteUser.delete("users", userId, (b) => b.check());
+    const deleteResult = await deleteUser.executeMutations();
+    expect(deleteResult.success).toBe(true);
+  });
+});

package/src/adapters/in-memory/in-memory-uow.retrieval.test.ts

@@ -0,0 +1,255 @@
+import { describe, expect, it } from "vitest";
+
+import type { CompiledJoin } from "../../query/orm/orm";
+import { UnitOfWork, type RetrievalOperation } from "../../query/unit-of-work/unit-of-work";
+import {
+  column,
+  ExplicitRelationInit,
+  idColumn,
+  referenceColumn,
+  schema,
+  type AnySchema,
+} from "../../schema/create";
+import {
+  createInMemoryUowCompiler,
+  createInMemoryUowExecutor,
+  InMemoryUowDecoder,
+} from "./in-memory-uow";
+import { resolveInMemoryAdapterOptions } from "./options";
+import { createInMemoryStore } from "./store";
+
+const joinSchema = schema("join", (s) =>
+  s
+    .addTable("users", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("name", column("string"))
+        .addColumn("email", column("string"))
+        .createIndex("idx_users_name", ["name"]),
+    )
+    .addTable("posts", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("title", column("string"))
+        .addColumn("authorId", referenceColumn()),
+    )
+    .addTable("memberships", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("userId", referenceColumn())
+        .createIndex("idx_memberships_user", ["userId"]),
+    )
+    .addReference("author", {
+      type: "one",
+      from: { table: "posts", column: "authorId" },
+      to: { table: "users", column: "id" },
+    })
+    .addReference("membershipUser", {
+      type: "one",
+      from: { table: "memberships", column: "userId" },
+      to: { table: "users", column: "id" },
+    })
+    .addReference("memberships", {
+      type: "many",
+      from: { table: "users", column: "id" },
+      to: { table: "memberships", column: "userId" },
+      foreignKey: false,
+    }),
+);
+
+const externalJoinSchema = schema("external-join", (s) =>
+  s
+    .addTable("left", (t) => t.addColumn("id", idColumn()).addColumn("label", column("string")))
+    .addTable("right", (t) => t.addColumn("id", idColumn()).addColumn("label", column("string"))),
+);
+
+const createHarness = () => {
+  const store = createInMemoryStore();
+  const options = resolveInMemoryAdapterOptions({ idSeed: "seed" });
+  const compiler = createInMemoryUowCompiler();
+  const executor = createInMemoryUowExecutor(store, options);
+  const decoder = new InMemoryUowDecoder();
+
+  return {
+    createUow: () => new UnitOfWork(compiler, executor, decoder).forSchema(joinSchema),
+    executor,
+  };
+};
+
+const createExternalJoinHarness = () => {
+  const store = createInMemoryStore();
+  const options = resolveInMemoryAdapterOptions({ idSeed: "seed" });
+  const compiler = createInMemoryUowCompiler();
+  const executor = createInMemoryUowExecutor(store, options);
+  const decoder = new InMemoryUowDecoder();
+
+  return {
+    createUow: () => new UnitOfWork(compiler, executor, decoder).forSchema(externalJoinSchema),
+  };
+};
+
+describe("in-memory uow retrieval", () => {
+  it("throws when joins use orderBy instead of orderByIndex", async () => {
+    const { createUow, executor } = createHarness();
+
+    const createData = createUow();
+    createData.create("users", {
+      id: "user-1",
+      name: "Ada",
+      email: "ada@example.com",
+    });
+    createData.create("posts", {
+      id: "post-1",
+      title: "Hello",
+      authorId: "user-1",
+    });
+    await createData.executeMutations();
+
+    const relation = joinSchema.tables.posts.relations.author;
+    const join: CompiledJoin = {
+      relation,
+      options: {
+        select: true,
+        where: undefined,
+        orderBy: [[joinSchema.tables.users.columns.email, "asc"]],
+        join: undefined,
+        limit: undefined,
+      },
+    };
+
+    const op = {
+      type: "find",
+      schema: joinSchema,
+      table: joinSchema.tables.posts,
+      indexName: "_primary",
+      options: {
+        useIndex: "_primary",
+        select: true,
+        where: undefined,
+        orderByIndex: undefined,
+        after: undefined,
+        before: undefined,
+        pageSize: undefined,
+        joins: [join],
+      },
+    } satisfies RetrievalOperation<typeof joinSchema>;
+
+    const opForExecutor = op as unknown as RetrievalOperation<AnySchema>;
+
+    await expect(executor.executeRetrievalPhase([opForExecutor])).rejects.toThrow(
+      'In-memory adapter only supports orderByIndex; received orderBy on table "users".',
+    );
+  });
+
+  it("joins join-only relations using left-side id coercion", async () => {
+    const { createUow } = createHarness();
+
+    const createData = createUow();
+    createData.create("users", {
+      id: "user-1",
+      name: "Ada",
+      email: "ada@example.com",
+    });
+    createData.create("memberships", {
+      id: "membership-1",
+      userId: "user-1",
+    });
+    await createData.executeMutations();
+
+    const query = createUow();
+    query.find("users", (b) =>
+      b
+        .whereIndex("primary", (eb) => eb("id", "=", "user-1"))
+        .join((jb) => jb.memberships((mb) => mb.select(["id"]))),
+    );
+
+    const [users] = (await query.executeRetrieve()) as Array<
+      Array<{ memberships?: { id: { externalId: string } } }>
+    >;
+
+    expect(users).toHaveLength(1);
+    expect(users[0].memberships).toMatchObject({
+      id: expect.objectContaining({ externalId: "membership-1" }),
+    });
+  });
+
+  it("joins external-id relations without coercing both sides to internal ids", async () => {
+    const { createUow } = createExternalJoinHarness();
+
+    const relationInit = new ExplicitRelationInit(
+      "one",
+      externalJoinSchema.tables.right,
+      externalJoinSchema.tables.left,
+      { foreignKey: false },
+    );
+    relationInit.on.push(["id", "id"]);
+    const relation = relationInit.init("rightMatch");
+    externalJoinSchema.tables.left.relations["rightMatch"] = relation;
+
+    const createData = createUow();
+    createData.create("left", {
+      id: "left-1",
+      label: "Left One",
+    });
+    createData.create("left", {
+      id: "shared-id",
+      label: "Left Shared",
+    });
+    createData.create("right", {
+      id: "shared-id",
+      label: "Right Shared",
+    });
+    await createData.executeMutations();
+
+    const query = createUow();
+    query.find("left", (b) =>
+      b
+        .whereIndex("primary", (eb) => eb("id", "=", "shared-id"))
+        .join((jb) => jb["rightMatch"]((rb) => rb.select(["id", "label"]))),
+    );
+
+    const [rows] = (await query.executeRetrieve()) as Array<
+      Array<{ rightMatch?: { id: { externalId: string }; label: string } }>
+    >;
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0].rightMatch).toMatchObject({
+      id: expect.objectContaining({ externalId: "shared-id" }),
+      label: "Right Shared",
+    });
+  });
+
+  it("applies page size after filtering primary-index lookups", async () => {
+    const { createUow } = createHarness();
+
+    const createData = createUow();
+    createData.create("users", {
+      id: "user-1",
+      name: "Ada",
+      email: "ada@example.com",
+    });
+    createData.create("users", {
+      id: "user-2",
+      name: "Grace",
+      email: "grace@example.com",
+    });
+    await createData.executeMutations();
+
+    const query = createUow();
+    query.findFirst("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", "user-2")));
+
+    const [[user]] = (await query.executeRetrieve()) as Array<
+      [
+        {
+          id: { externalId: string };
+          name: string;
+        } | null,
+      ]
+    >;
+
+    expect(user).toMatchObject({
+      id: expect.objectContaining({ externalId: "user-2" }),
+      name: "Grace",
+    });
+  });
+});