@fragno-dev/db 0.2.1 → 0.3.0

package/src/adapters/in-memory/in-memory-adapter.ts

@@ -0,0 +1,277 @@
+import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+import {
+  fragnoDatabaseAdapterNameFakeSymbol,
+  fragnoDatabaseAdapterVersionFakeSymbol,
+  type DatabaseAdapter,
+  type DatabaseContextStorage,
+} from "../adapters";
+import type { AnySchema, AnyTable, FragnoId } from "../../schema/create";
+import type { SimpleQueryInterface, TableToUpdateValues } from "../../query/simple-query-interface";
+import {
+  resolveInMemoryAdapterOptions,
+  type InMemoryAdapterOptions,
+  type ResolvedInMemoryAdapterOptions,
+} from "./options";
+import { createInMemoryStore, ensureNamespaceStore } from "./store";
+import {
+  createInMemoryUowCompiler,
+  createInMemoryUowExecutor,
+  InMemoryUowDecoder,
+} from "./in-memory-uow";
+import { UnitOfWork, type UnitOfWorkConfig } from "../../query/unit-of-work/unit-of-work";
+import type { CursorResult } from "../../query/cursor";
+import {
+  createNamingResolver,
+  suffixNamingStrategy,
+  type SqlNamingStrategy,
+} from "../../naming/sql-naming";
+
+class UpdateManySpecialBuilder<TTable extends AnyTable> {
+  #indexName?: string;
+  #condition?: unknown;
+  #setValues?: TableToUpdateValues<TTable>;
+
+  whereIndex(indexName: string, condition?: unknown): this {
+    this.#indexName = indexName;
+    this.#condition = condition;
+    return this;
+  }
+
+  set(values: TableToUpdateValues<TTable>): this {
+    this.#setValues = values;
+    return this;
+  }
+
+  getConfig() {
+    return {
+      indexName: this.#indexName,
+      condition: this.#condition,
+      setValues: this.#setValues,
+    };
+  }
+}
+
+const hasIdField = (record: unknown): record is { id: string | FragnoId } =>
+  record !== null && typeof record === "object" && "id" in record;
+
+export type InMemoryUowConfig = UnitOfWorkConfig;
+
+export class InMemoryAdapter implements DatabaseAdapter<InMemoryUowConfig> {
+  readonly options: ResolvedInMemoryAdapterOptions;
+  readonly namingStrategy: SqlNamingStrategy;
+
+  #contextStorage: RequestContextStorage<DatabaseContextStorage>;
+  #store = createInMemoryStore();
+  #schemaNamespaceMap = new WeakMap<AnySchema, string | null>();
+  #schemaByNamespace = new Map<string, { schema: AnySchema; namespace: string | null }>();
+
+  constructor(options: InMemoryAdapterOptions = {}) {
+    this.options = resolveInMemoryAdapterOptions(options);
+    this.namingStrategy = options.namingStrategy ?? suffixNamingStrategy;
+    this.#contextStorage = new RequestContextStorage();
+  }
+
+  get [fragnoDatabaseAdapterNameFakeSymbol](): string {
+    return "in-memory";
+  }
+
+  get [fragnoDatabaseAdapterVersionFakeSymbol](): number {
+    return 0;
+  }
+
+  get contextStorage(): RequestContextStorage<DatabaseContextStorage> {
+    return this.#contextStorage;
+  }
+
+  async getSchemaVersion(_namespace: string): Promise<string | undefined> {
+    return undefined;
+  }
+
+  async isConnectionHealthy(): Promise<boolean> {
+    return true;
+  }
+
+  async close(): Promise<void> {
+    return;
+  }
+
+  async reset(): Promise<void> {
+    this.#store.namespaces.clear();
+    for (const [namespaceKey, { schema, namespace }] of this.#schemaByNamespace) {
+      const resolver = createNamingResolver(schema, namespace, this.namingStrategy);
+      ensureNamespaceStore(this.#store, namespaceKey, schema, resolver);
+    }
+  }
+
+  createQueryEngine<T extends AnySchema>(
+    schema: T,
+    namespace: string | null,
+  ): SimpleQueryInterface<T, InMemoryUowConfig> {
+    this.#schemaNamespaceMap.set(schema, namespace);
+    const namespaceKey = namespace ?? schema.name;
+    this.#schemaByNamespace.set(namespaceKey, { schema, namespace });
+    const resolverFactory = (schemaForResolver: AnySchema, namespaceForResolver: string | null) =>
+      createNamingResolver(schemaForResolver, namespaceForResolver, this.namingStrategy);
+    const resolver = resolverFactory(schema, namespace);
+    ensureNamespaceStore(this.#store, namespaceKey, schema, resolver);
+
+    const compiler = createInMemoryUowCompiler();
+    const executor = createInMemoryUowExecutor(this.#store, this.options, resolverFactory);
+    const decoder = new InMemoryUowDecoder(resolverFactory);
+
+    const createUow = (opts?: { name?: string; config?: UnitOfWorkConfig }) =>
+      new UnitOfWork(
+        compiler,
+        executor,
+        decoder,
+        opts?.name,
+        opts?.config,
+        this.#schemaNamespaceMap,
+      ).forSchema(schema);
+
+    const queryEngine = {
+      now: async () => this.options.clock.now(),
+      async find(tableName, builderFn) {
+        const uow = createUow();
+        uow.find(tableName, builderFn);
+        const [result]: unknown[][] = await uow.executeRetrieve();
+        return result ?? [];
+      },
+
+      async findWithCursor(tableName, builderFn) {
+        const uow = createUow().findWithCursor(tableName, builderFn);
+        const [result] = await uow.executeRetrieve();
+        return result as CursorResult<unknown>;
+      },
+
+      async findFirst(tableName, builderFn) {
+        const uow = createUow();
+        if (builderFn) {
+          uow.find(tableName, (b) => {
+            builderFn(b);
+            return b.pageSize(1);
+          });
+        } else {
+          uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
+        }
+        const [result]: unknown[][] = await uow.executeRetrieve();
+        return result?.[0] ?? null;
+      },
+
+      async create(tableName, values) {
+        const uow = createUow();
+        uow.create(tableName, values);
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to create record");
+        }
+
+        const createdId = uow.getCreatedIds()[0];
+        if (!createdId) {
+          throw new Error("Failed to get created ID");
+        }
+        return createdId;
+      },
+
+      async createMany(tableName, valuesArray) {
+        const uow = createUow();
+        for (const values of valuesArray) {
+          uow.create(tableName, values);
+        }
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to create records");
+        }
+        return uow.getCreatedIds();
+      },
+
+      async update(tableName, id, builderFn) {
+        const uow = createUow();
+        uow.update(tableName, id, builderFn);
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to update record (version conflict or record not found)");
+        }
+      },
+
+      async updateMany(tableName, builderFn) {
+        const table = schema.tables[tableName];
+        if (!table) {
+          throw new Error(`Table ${tableName} not found in schema`);
+        }
+
+        const specialBuilder = new UpdateManySpecialBuilder<typeof table>();
+        builderFn(specialBuilder);
+        const { indexName, condition, setValues } = specialBuilder.getConfig();
+
+        if (!indexName) {
+          throw new Error("whereIndex() must be called in updateMany");
+        }
+        if (!setValues) {
+          throw new Error("set() must be called in updateMany");
+        }
+
+        const findUow = createUow();
+        findUow.find(tableName, (b) => {
+          if (condition !== undefined && condition !== null) {
+            return b.whereIndex(indexName as never, condition as never);
+          }
+          return b.whereIndex(indexName as never);
+        });
+        const [records]: unknown[][] = await findUow.executeRetrieve();
+
+        if (!records || records.length === 0) {
+          return;
+        }
+
+        const updateUow = createUow();
+        for (const record of records) {
+          if (!hasIdField(record)) {
+            throw new Error("Record missing id field");
+          }
+          updateUow.update(tableName, record.id, (b) => b.set(setValues).check());
+        }
+        const { success } = await updateUow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to update records (version conflict)");
+        }
+      },
+
+      async delete(tableName, id, builderFn) {
+        const uow = createUow();
+        uow.delete(tableName, id, builderFn);
+        const { success } = await uow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to delete record (version conflict or record not found)");
+        }
+      },
+
+      async deleteMany(tableName, builderFn) {
+        const findUow = createUow();
+        findUow.find(tableName, builderFn);
+        const [records]: unknown[][] = await findUow.executeRetrieve();
+
+        if (!records || records.length === 0) {
+          return;
+        }
+
+        const deleteUow = createUow();
+        for (const record of records) {
+          if (!hasIdField(record)) {
+            throw new Error("Record missing id field");
+          }
+          deleteUow.delete(tableName, record.id);
+        }
+        const { success } = await deleteUow.executeMutations();
+        if (!success) {
+          throw new Error("Failed to delete records (version conflict)");
+        }
+      },
+
+      createUnitOfWork(name, config) {
+        return createUow({ name, config });
+      },
+    } as SimpleQueryInterface<T, InMemoryUowConfig>;
+    return queryEngine;
+  }
+}

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

@@ -0,0 +1,296 @@
+import { describe, expect, it } from "vitest";
+import type { AnySchema } from "../../schema/create";
+import { column, idColumn, schema, FragnoId, referenceColumn } from "../../schema/create";
+import { UnitOfWork } from "../../query/unit-of-work/unit-of-work";
+import { createInMemoryStore } from "./store";
+import {
+  createInMemoryUowCompiler,
+  createInMemoryUowExecutor,
+  InMemoryUowDecoder,
+} from "./in-memory-uow";
+import { resolveInMemoryAdapterOptions, type InMemoryAdapterOptions } from "./options";
+
+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 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("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,100 @@
+import { describe, expect, it } from "vitest";
+import { column, idColumn, referenceColumn, schema, type AnySchema } from "../../schema/create";
+import { UnitOfWork, type RetrievalOperation } from "../../query/unit-of-work/unit-of-work";
+import { createInMemoryStore } from "./store";
+import {
+  createInMemoryUowCompiler,
+  createInMemoryUowExecutor,
+  InMemoryUowDecoder,
+} from "./in-memory-uow";
+import { resolveInMemoryAdapterOptions } from "./options";
+import type { CompiledJoin } from "../../query/orm/orm";
+
+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()),
+    )
+    .addReference("author", {
+      type: "one",
+      from: { table: "posts", column: "authorId" },
+      to: { table: "users", column: "id" },
+    }),
+);
+
+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,
+  };
+};
+
+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".',
+    );
+  });
+});