@deterministic-code/datasources 0.1.0 → 0.1.1

package/src/mocks/MockDatasource.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import {
+  MockCommand,
+  MockConnection,
+  MockDatasource,
+  MockRepository,
+  Native,
+  untyped,
+} from "../index.ts";
+
+describe("MockDatasource", () => {
+  it("builds commands and repositories from a mock datasource", async () => {
+    const ds = new MockDatasource();
+    expect(ds.provider).toBe("mock");
+    expect(await ds.createConnection()).toBe(ds.connection);
+    const mockCommand = await ds.createCommand();
+    expect(mockCommand).toBeInstanceOf(MockCommand);
+    await mockCommand.executeNative(new Native(""));
+    await mockCommand.executeReaderNative(new Native(""));
+    const provided = new MockConnection();
+    expect((await ds.createCommand(provided)).connection).toBe(provided);
+    expect(ds.createRepository(untyped(), provided)).toBeInstanceOf(MockRepository);
+    expect(ds.createRepository(untyped())).toBeInstanceOf(MockRepository);
+
+    await ds.connection.close();
+    ds.command = new MockCommand(ds.connection);
+    ds.repository = new MockRepository(ds.connection);
+    expect(await ds.createCommand()).toBe(ds.command);
+    await expect(ds.createCommand()).rejects.toThrow("Connection is already open");
+    expect(ds.createRepository(untyped())).toBe(ds.repository);
+    expect(ds.createReadonlyRepository(untyped())).toBe(ds.repository);
+
+    const named = new MockDatasource("custom");
+    expect(named.provider).toBe("custom");
+    const customRepo = new MockRepository(named.connection);
+    named.repositories.register("Item", "items", () => customRepo, () => customRepo);
+    expect(named.createRepository("items")).toBe(customRepo);
+    expect(named.createReadonlyRepository("Item")).toBe(customRepo);
+  });
+});

package/src/mocks/MockReader.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { MockReader } from "../index.ts";
+
+describe("MockReader", () => {
+  it("walks mock reader rows and errors", async () => {
+    const reader = new MockReader(["x"]);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toBe("x");
+    expect(await reader.next()).toBe(false);
+    expect(await reader.nextResult()).toBe(false);
+    expect(await Array.fromAsync(new MockReader(["x"]).read())).toEqual(["x"]);
+    await reader.dispose();
+    await reader[Symbol.asyncDispose]();
+    reader.nextError = new Error("next");
+    await expect(reader.next()).rejects.toThrow("next");
+  });
+});

package/src/mocks/MockRepository.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { collectAsync, MockConnection, MockSelectStatement, MockRepository, MockWhere } from "../index.ts";
+
+describe("MockRepository", () => {
+  it("records repository CRUD and errors", async () => {
+    const repo = new MockRepository<{ id: number }>(new MockConnection());
+    expect(await repo.readSingle()).toBeUndefined();
+    repo.items = [{ id: 1 }, { id: 2 }];
+    expect(await repo.readSingle(new MockSelectStatement("id=1"))).toEqual({ id: 1 });
+    expect(await collectAsync(repo.read())).toEqual([{ id: 1 }, { id: 2 }]);
+    expect(await collectAsync(repo.read(new MockSelectStatement("all")))).toHaveLength(2);
+    expect(await repo.readSingle(new MockWhere("id=1"))).toEqual({ id: 1 });
+    expect(await collectAsync(repo.read(new MockWhere("all")))).toHaveLength(2);
+    expect(await repo.readSingleById(1)).toEqual({ id: 1 });
+    expect(await repo.create({ id: 3 })).toEqual({ id: 3 });
+    expect(
+      (await repo.update({ id: 3 }, new MockWhere("id=3"))).rowsAffected,
+    ).toBe(1);
+    expect((await repo.delete({ id: 3 })).rowsAffected).toBe(1);
+
+    repo.readSingleError = new Error("gs");
+    await expect(repo.readSingle()).rejects.toThrow("gs");
+    repo.readError = new Error("g");
+    await expect(collectAsync(repo.read())).rejects.toThrow("g");
+    repo.addError = new Error("ad");
+    await expect(repo.create({ id: 0 })).rejects.toThrow("ad");
+    repo.updateError = new Error("up");
+    await expect(repo.update({ id: 0 })).rejects.toThrow("up");
+    repo.deleteError = new Error("del");
+    await expect(repo.delete({ id: 0 })).rejects.toThrow("del");
+  });
+});

package/src/mocks/MockSelectStatement.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DefaultStatementTextRenderer, MockSelectStatement } from "../index.ts";
+
+describe("MockSelectStatement", () => {
+  it("tracks accept calls", () => {
+    const query = new MockSelectStatement("q");
+    expect(query.accept({ visit: () => "" })).toBe("q");
+    expect(query.acceptCalls).toBe(1);
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe("q");
+  });
+});

package/src/mocks/MockTransaction.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { MockConnection, MockTransaction } from "../index.ts";
+
+describe("MockTransaction", () => {
+  it("records transaction commit and abort", async () => {
+    const connection = new MockConnection();
+    const txn = new MockTransaction(connection);
+    await txn.commit();
+    expect(txn.committed).toBe(true);
+    await txn.abort();
+    expect(txn.aborted).toBe(true);
+    txn.commitError = new Error("c");
+    await expect(txn.commit()).rejects.toThrow("c");
+    txn.abortError = new Error("a");
+    await expect(txn.abort()).rejects.toThrow("a");
+  });
+});

package/src/mocks/MockWhere.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DefaultStatementTextRenderer, MockWhere } from "../index.ts";
+
+describe("MockWhere", () => {
+  it("tracks accept calls", () => {
+    const where = new MockWhere("w");
+    expect(where.accept({ visit: () => "" })).toBe("w");
+    expect(where.acceptCalls).toBe(1);
+    expect(DefaultStatementTextRenderer.instance.render(where)).toBe("w");
+  });
+});

package/src/parametersToRecord.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { parametersToRecord } from "./index.ts";
+
+describe("parametersToRecord", () => {
+  it("returns an empty record when parameters are omitted", () => {
+    expect(parametersToRecord()).toEqual({});
+    expect(parametersToRecord(null)).toEqual({});
+    expect(parametersToRecord(undefined)).toEqual({});
+  });
+
+  it("maps names to values", () => {
+    expect(
+      parametersToRecord([
+        { name: "id", value: 1 },
+        { name: "label", value: "a" },
+      ]),
+    ).toEqual({ id: 1, label: "a" });
+  });
+});

package/src/public-surface.test.ts

@@ -0,0 +1,23 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const providers = join(dirname(fileURLToPath(import.meta.url)), "../../providers");
+
+describe("provider public surface", () => {
+  it("exports only the provider", () => {
+    const names = readdirSync(providers, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name !== "node_modules")
+      .map((entry) => entry.name);
+    expect(names.length).toBeGreaterThanOrEqual(11);
+    for (const name of names) {
+      const source = readFileSync(join(providers, name, "src/index.ts"), "utf8");
+      const match = source.match(
+        /^export \{ ([A-Za-z0-9]+) \} from "\.\/\1\.ts";\n$/,
+      );
+      expect(match, name).not.toBeNull();
+      expect(match?.[1]?.endsWith("Driver"), name).toBe(true);
+    }
+  });
+});

package/src/readWithWhereClauseAndCustomFlatToNestedObjectMappingOptions.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { MemoryDriver } from "@datasources/memory";
+import { collectAsync } from "./collectAsync.ts";
+import { CRUDRepository } from "./CRUDRepository.ts";
+import { NestedToObjectEnrichmentStrategy } from "./NestedToObjectEnrichmentStrategy.ts";
+import { ChangeCasingMapper } from "./mappers/ChangeCasingMapper.ts";
+import { DictionaryMapper } from "./mappers/DictionaryMapper.ts";
+import type { IMapper } from "./mappers/IMapper.ts";
+import { TransformMapper } from "./mappers/TransformMapper.ts";
+import type { IConnection } from "./IConnection.ts";
+import type { Scalar } from "./builders/Scalar.ts";
+import { MockCommand } from "./mocks/mock-command.ts";
+import { MockConnection } from "./mocks/mock-connection.ts";
+import { MockReader } from "./mocks/mock-reader.ts";
+import { Join, Operator, SelectStatement, Where } from "./statements/index.ts";
+
+describe("readWithWhereClauseAndCustomFlatToNestedObjectMappingOptions", () => {
+  it("read with where clause and custom flat to nested object mapping options", async () => {
+    class UserType {
+      Id = 0;
+      Name = "";
+    }
+
+    class Parent {
+      Id = 0;
+      Type = new UserType();
+      TypeName = "";
+      Children: Child[] = [];
+    }
+
+    class Child {
+      Id = 0;
+      ParentId = 0;
+      Label = "";
+    }
+
+    type Seed = Record<string, Scalar>;
+
+    const snake = new ChangeCasingMapper("pascalCase", "snakeCase");
+    const references = new DictionaryMapper<string>([["Type", "type_id"]]);
+    const columns: IMapper<string, string> = new TransformMapper(
+      (name) => {
+        const mapped = references.map(name);
+        return mapped !== name ? mapped : snake.map(name);
+      },
+      (name) => {
+        const from = references.reverseMap(name);
+        return from !== name ? from : snake.reverseMap(name);
+      },
+    );
+
+    const joinEntity = new DictionaryMapper([
+      ["Parent", "parent"],
+      ["Child", "child"],
+    ]);
+
+    const setup = async (): Promise<IConnection> => {
+      const connection = new MemoryDriver().connection();
+      await connection.open();
+      return connection;
+    };
+
+    const typesRepo = (connection: IConnection) =>
+      new CRUDRepository(connection, { type: UserType, ids: ["Id"], propertyMappings: columns });
+
+    const parentsRepo = (connection: IConnection) =>
+      new CRUDRepository(connection, { type: Parent, ids: ["Id"], propertyMappings: columns });
+
+    const connection = await setup();
+    const types = typesRepo(connection);
+    const type = await types.create(Object.assign(new UserType(), { Name: "person" }));
+    const parents = parentsRepo(connection);
+    parents.addEnriched(
+      { destinationProperty: "TypeName", sourceProperty: "Type", relatedKey: "Id", relatedProperty: "Name" },
+      types,
+    );
+    await parents.create(Object.assign(new Parent(), { Type: Object.assign(new UserType(), { Id: type.Id }) }));
+    const enriched = await parents.readSingle();
+
+    const row1: Seed = { Id: 1, TypeName: "person", ChildId: 10, Label: "a" };
+    const row2: Seed = { Id: 1, TypeName: "person", ChildId: 11, Label: "b" };
+    const mockConnection = new MockConnection({ provider: "memory" });
+    const command = new MockCommand(mockConnection);
+    mockConnection.command = command;
+    const joinParents = parentsRepo(mockConnection);
+    joinParents.addEnriched(
+      { destinationProperty: "TypeName", sourceProperty: "Type", relatedKey: "Id", relatedProperty: "Name" },
+      types,
+    );
+    joinParents.addEnriched(
+      { destinationProperty: "Children", sourceProperty: "Id", relatedKey: "ParentId", type: "list" },
+      joinParents,
+      new NestedToObjectEnrichmentStrategy<Parent>({
+        key: "Id",
+        fields: {
+          Id: "Id",
+          TypeName: "TypeName",
+          Children: {
+            key: "ChildId",
+            fields: { Id: "ChildId", Label: "Label" },
+          },
+        },
+      }),
+    );
+    const join = new SelectStatement({
+      table: "Parent",
+      fields: [
+        "Parent.Id AS Id",
+        "Parent.TypeName AS TypeName",
+        "Child.Id AS ChildId",
+        "Child.Label AS Label",
+      ],
+      joins: [Join.left("Child", "Parent.Id", "Child.ParentId")],
+      where: new Where(new Operator.Equals("Parent.Id", 1)),
+    });
+    command.reader = new MockReader([row1, row2]);
+    const items = await collectAsync(
+      joinParents.read(join, undefined, { entityMapper: joinEntity }),
+    );
+    expect(enriched?.TypeName).toBe("person");
+    expect(items).toHaveLength(1);
+    expect(items[0]?.Id).toBe(1);
+    expect(items[0]?.TypeName).toBe("person");
+    expect(items[0]?.Children.map((child) => child.Label)).toEqual(["a", "b"]);
+  });
+});

package/src/readerToAsyncIterable.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { ArrayReader, collectAsync, readerToAsyncIterable, type IReader } from "./index.ts";
+
+describe("readerToAsyncIterable", () => {
+  it("converts a reader to an async iterable", async () => {
+    const items = await collectAsync(
+      readerToAsyncIterable(new ArrayReader(["a", "b"])),
+    );
+    expect(items).toEqual(["a", "b"]);
+    expect(await collectAsync(readerToAsyncIterable(new ArrayReader([])))).toEqual(
+      [],
+    );
+  });
+
+  it("skips a defined-next row whose current is undefined", async () => {
+    const reader: IReader<string> = {
+      current: undefined,
+      read() {
+        return readerToAsyncIterable(this);
+      },
+      async nextResult() {
+        return false;
+      },
+      async dispose() {},
+      async [Symbol.asyncDispose]() {
+        await this.dispose();
+      },
+      async next() {
+        if (this.current === undefined && (this as { once?: boolean }).once) {
+          return false;
+        }
+        (this as { once?: boolean }).once = true;
+        this.current = undefined;
+        return true;
+      },
+    };
+    expect(await collectAsync(readerToAsyncIterable(reader))).toEqual([]);
+  });
+});