@deterministic-code/datasources 0.1.0 → 0.1.1

package/dist/statements/Where.d.ts

@@ -0,0 +1,16 @@
+import type { Parameter } from "../Parameter.js";
+import type { Cell } from "../converters/Cell.js";
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IExpression } from "./IExpression.js";
+import type { IWhere } from "./IWhere.js";
+import type { Comparison } from "./Cmp.js";
+export declare class Where implements IWhere {
+    readonly condition: IExpression;
+    constructor(condition: IExpression);
+    constructor(column: string, op: Comparison, value: Cell);
+    and(column: string, op: Comparison, value: Cell): Where;
+    or(column: string, op: Comparison, value: Cell): Where;
+    map(column: (name: string) => string, value: (name: string, cell: Cell) => Cell): Where;
+    accept: (visitor: IConditionVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/WhereText.d.ts

@@ -0,0 +1,8 @@
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { IWhere } from "./IWhere.js";
+export declare class WhereText implements IWhere {
+    private readonly text;
+    constructor(text: string);
+    get rawText(): string;
+    accept: (visitor: IConditionVisitor) => string;
+}

package/dist/statements/index.d.ts

@@ -0,0 +1,75 @@
+export type { IExpression } from "./IExpression.js";
+export type { IStatement } from "./IStatement.js";
+export type { IStatementVisitor } from "./IStatementVisitor.js";
+export type { ICondition } from "./ICondition.js";
+export type { IConditionVisitor } from "./IConditionVisitor.js";
+export type { IWhere } from "./IWhere.js";
+export type { ISelectStatement } from "./ISelectStatement.js";
+export type { IInsertStatement } from "./IInsertStatement.js";
+export type { IUpdateStatement } from "./IUpdateStatement.js";
+export type { IDeleteStatement } from "./IDeleteStatement.js";
+export type { IBulkInsertStatement } from "./IBulkInsertStatement.js";
+export type { IBulkUpdateStatement } from "./IBulkUpdateStatement.js";
+export type { IBulkDeleteStatement } from "./IBulkDeleteStatement.js";
+export type { ICreateTableStatement } from "./ICreateTableStatement.js";
+export type { ICreateIndexStatement } from "./ICreateIndexStatement.js";
+export type { IExecuteStoredProcedureStatement } from "./IExecuteStoredProcedureStatement.js";
+export type { IReturnStatement } from "./IReturnStatement.js";
+export type { Column } from "./Column.js";
+export type { ITableConstraint, TableConstraintKind } from "./ITableConstraint.js";
+export { Join } from "./Join.js";
+export type { JoinKind } from "./Join.js";
+export { Aggregate } from "./Aggregate.js";
+export type { SortDirection } from "./OrderBy.js";
+export { OrderBy } from "./OrderBy.js";
+export type { SelectStatementOptions } from "./SelectStatementOptions.js";
+export { Condition } from "./Condition.js";
+export { Operator } from "./Operator.js";
+export { eq, ne, gt, lt, ge, le } from "./Cmp.js";
+export type { Comparison } from "./Cmp.js";
+export { Identifier } from "./Identifier.js";
+export { Literal } from "./Literal.js";
+export { ArrayExpression } from "./ArrayExpression.js";
+export { Where } from "./Where.js";
+export { ExpressionEvaluator } from "./ExpressionEvaluator.js";
+export { StatementEvaluator } from "./StatementEvaluator.js";
+export { WhereText } from "./WhereText.js";
+export { SelectStatement } from "./SelectStatement.js";
+export { StatementParser } from "./StatementParser.js";
+export { StatementTextRenderer } from "./StatementTextRenderer.js";
+export { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
+export { StatementRenderer } from "./StatementRenderer.js";
+export { ExpressionRenderer } from "./ExpressionRenderer.js";
+export { ConditionRenderer } from "./ConditionRenderer.js";
+export { Native, n } from "./Native.js";
+export { Subquery } from "./Subquery.js";
+export { InsertStatement } from "./InsertStatement.js";
+export { UpdateStatement } from "./UpdateStatement.js";
+export { DeleteStatement } from "./DeleteStatement.js";
+export { BulkInsertStatement } from "./BulkInsertStatement.js";
+export { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+export { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+export { BulkInsertStatementTextRenderer } from "./BulkInsertStatementTextRenderer.js";
+export { BulkUpdateStatementTextRenderer } from "./BulkUpdateStatementTextRenderer.js";
+export { BulkDeleteStatementTextRenderer } from "./BulkDeleteStatementTextRenderer.js";
+export { CreateTableStatement } from "./CreateTableStatement.js";
+export { CreateTableStatementTextRenderer } from "./CreateTableStatementTextRenderer.js";
+export { CreateIndexStatement } from "./CreateIndexStatement.js";
+export { CreateIndexStatementTextRenderer } from "./CreateIndexStatementTextRenderer.js";
+export { SelectStatementTextRenderer } from "./SelectStatementTextRenderer.js";
+export { InsertStatementTextRenderer } from "./InsertStatementTextRenderer.js";
+export { UpdateStatementTextRenderer } from "./UpdateStatementTextRenderer.js";
+export { DeleteStatementTextRenderer } from "./DeleteStatementTextRenderer.js";
+export { ExecuteStoredProcedureStatementTextRenderer } from "./ExecuteStoredProcedureStatementTextRenderer.js";
+export { ReturnStatementTextRenderer } from "./ReturnStatementTextRenderer.js";
+export { SelectInsertedIdStatementTextRenderer } from "./SelectInsertedIdStatementTextRenderer.js";
+export { ColumnDefault } from "./ColumnDefault.js";
+export { NotNull } from "./NotNull.js";
+export { PrimaryKey } from "./PrimaryKey.js";
+export { ForeignKey, ReferentialAction } from "./ForeignKey.js";
+export type { ReferentialAction as ReferentialActionName } from "./ForeignKey.js";
+export { UniqueConstraint } from "./UniqueConstraint.js";
+export { CheckConstraint } from "./CheckConstraint.js";
+export { ExecuteStoredProcedureStatement } from "./ExecuteStoredProcedureStatement.js";
+export { SelectInsertedIdStatement } from "./SelectInsertedIdStatement.js";
+export { ReturnStatement } from "./ReturnStatement.js";

package/dist/stubs/StubCommand.d.ts

@@ -0,0 +1,15 @@
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { Cells } from "../converters/Cell.js";
+import type { IReader } from "../IReader.js";
+import type { Response } from "../Response.js";
+import type { Parameter } from "../Parameter.js";
+import { CommandMiddlewareHost } from "../CommandMiddlewareHost.js";
+import { Native } from "../statements/Native.js";
+export declare class StubCommand extends CommandMiddlewareHost implements ICommand {
+    readonly provider: string;
+    readonly connection: IConnection;
+    constructor(provider: string, connection: IConnection);
+    executeReaderNative: (text: Native, parameters?: Parameter[]) => Promise<IReader<Cells>>;
+    executeNative: (text: Native, parameters?: Parameter[]) => Promise<Response>;
+}

package/dist/stubs/StubConnection.d.ts

@@ -0,0 +1,13 @@
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { ITransaction } from "../ITransaction.js";
+export declare class StubConnection implements IConnection {
+    readonly provider: string;
+    isOpen: boolean;
+    constructor(provider: string);
+    createCommand: () => ICommand;
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction: () => Promise<ITransaction>;
+}

package/dist/stubs/StubDatasource.d.ts

@@ -0,0 +1,20 @@
+import type { Constructable } from "../converters/Constructable.js";
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { IDatasource } from "../IDatasource.js";
+import type { IReadonlyRepository } from "../IReadonlyRepository.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { RepositoryFactory } from "../RepositoryFactory.js";
+export declare class StubDatasource implements IDatasource {
+    readonly provider: string;
+    private connection?;
+    readonly repositories: RepositoryFactory;
+    constructor(provider: string);
+    private defaultConnection;
+    createConnection: () => Promise<IConnection>;
+    createCommand: (connection?: IConnection) => Promise<ICommand>;
+    createRepository<T>(type: Constructable<T>, connection?: IConnection): ICRUDRepository<T>;
+    createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+    createReadonlyRepository<T>(type: Constructable<T>, connection?: IConnection): IReadonlyRepository<T>;
+    createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+}

package/dist/stubs/StubReader.d.ts

@@ -0,0 +1,11 @@
+import type { IReader } from "../IReader.js";
+export declare class StubReader<T = unknown> implements IReader<T> {
+    readonly provider: string;
+    current: T | undefined;
+    constructor(provider: string);
+    next(): Promise<boolean>;
+    read(): AsyncIterable<T>;
+    nextResult(): Promise<boolean>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}

package/dist/stubs/StubRepository.d.ts

@@ -0,0 +1,22 @@
+import type { Scalar } from "../builders/Scalar.js";
+import type { Cells } from "../converters/Cell.js";
+import type { Constructable } from "../converters/Constructable.js";
+import type { IConnection } from "../IConnection.js";
+import type { Parameter } from "../Parameter.js";
+import type { IExecuteStoredProcedureStatement } from "../statements/IExecuteStoredProcedureStatement.js";
+import type { ISelectStatement } from "../statements/ISelectStatement.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { ReadonlyRepository } from "../ReadonlyRepository.js";
+import type { ReadonlyRepositoryMappingOptions } from "../ReadonlyRepositoryMappingOptions.js";
+import type { Response } from "../Response.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class StubRepository<T = unknown> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+    readonly provider: string;
+    readonly ids: readonly string[];
+    constructor(provider: string, _connection: IConnection, type?: Constructable<T>);
+    read(_query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement, _parameters?: Parameter[], _options?: ReadonlyRepositoryMappingOptions<T>): AsyncIterable<T>;
+    create: (_item: T) => Promise<T>;
+    update: (_item: T, _byWhere?: IWhere) => Promise<Response>;
+    delete: (_item: T, _byWhere?: IWhere) => Promise<Response>;
+    readSingleById: (_id: Scalar | Cells) => Promise<T | undefined>;
+}

package/dist/stubs/StubTransaction.d.ts

@@ -0,0 +1,10 @@
+import type { IConnection } from "../IConnection.js";
+import type { ITransaction } from "../ITransaction.js";
+export declare class StubTransaction implements ITransaction {
+    readonly provider: string;
+    readonly connection: IConnection;
+    readonly isolation: "readCommitted";
+    constructor(provider: string, connection: IConnection);
+    commit: () => Promise<void>;
+    abort: () => Promise<void>;
+}

package/dist/stubs/createStubDatasource.d.ts

@@ -0,0 +1,2 @@
+import { StubDatasource } from "./StubDatasource.js";
+export declare const createStubDatasource: (provider: string) => StubDatasource;

package/dist/stubs/index.d.ts

@@ -0,0 +1,7 @@
+export { createStubDatasource } from "./createStubDatasource.js";
+export { StubCommand } from "./StubCommand.js";
+export { StubConnection } from "./StubConnection.js";
+export { StubDatasource } from "./StubDatasource.js";
+export { StubReader } from "./StubReader.js";
+export { StubRepository } from "./StubRepository.js";
+export { StubTransaction } from "./StubTransaction.js";

package/dist/stubs/notImplemented.d.ts

@@ -0,0 +1 @@
+export declare const notImplemented: (provider: string) => never;

package/package.json

@@ -1,18 +1,26 @@
 {
   "name": "@deterministic-code/datasources",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./mocks": "./src/mocks/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./mocks": {
+      "types": "./dist/mocks/index.d.ts",
+      "import": "./src/mocks/index.ts",
+      "default": "./src/mocks/index.ts"
+    }
   },
   "files": [
+    "dist",
     "src"
   ],
   "publishConfig": {
     "access": "public"
-  },
-  "license": "MIT"
+  }
 }

package/src/ArrayReader.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { ArrayReader } from "./index.ts";
+
+describe("ArrayReader", () => {
+  it("walks an array including the empty case", async () => {
+    const empty = new ArrayReader([]);
+    expect(empty.current).toBeUndefined();
+    expect(await empty.next()).toBe(false);
+    expect(empty.current).toBeUndefined();
+
+    const reader = new ArrayReader([{ id: 1 }, { id: 2 }]);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 1 });
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 2 });
+    expect(await reader.next()).toBe(false);
+    expect(reader.current).toBeUndefined();
+    expect(await reader.nextResult()).toBe(false);
+    expect(await Array.fromAsync(new ArrayReader(["a", "b"]).read())).toEqual(["a", "b"]);
+    await reader.dispose();
+    await reader[Symbol.asyncDispose]();
+  });
+});

package/src/BulkCRUDRepository.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from "vitest";
+import { MemoryDriver } from "@datasources/memory";
+import { collectAsync } from "./collectAsync.ts";
+import { BulkCRUDRepository } from "./BulkCRUDRepository.ts";
+import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
+import { DatasourceError } from "./DatasourceError.ts";
+import type { IConnection } from "./IConnection.ts";
+
+class Parent {
+  id = 0;
+  label = "";
+  children: Child[] = [];
+}
+
+class Child {
+  id = 0;
+  parent_id = 0;
+  label = "";
+}
+
+const setup = async (): Promise<IConnection> => {
+  const connection = new MemoryDriver().connection();
+  await connection.open();
+  return connection;
+};
+
+const relate = (parentsRepo: BulkCRUDRepository<Parent>, childrenRepo: BulkCRUDRepository<Child>) => {
+  parentsRepo.addEnriched({ destinationProperty: "children", sourceProperty: "id", relatedKey: "parent_id", type: "list" }, childrenRepo);
+  return parentsRepo;
+};
+
+describe("BulkCRUDRepository", () => {
+  it("creates parents and children", async () => {
+    const connection = await setup();
+    const parentsRepo = new BulkCRUDRepository(Parent, connection);
+    const childrenRepo = new BulkCRUDRepository(Child, connection);
+    const ids = await relate(parentsRepo, childrenRepo).createBulk([
+      Object.assign(new Parent(), { children: [Object.assign(new Child(), { label: "a" })] }),
+      Object.assign(new Parent(), {
+        children: [Object.assign(new Child(), { label: "b" }), Object.assign(new Child(), { label: "c" })],
+      }),
+    ]);
+    const parents = await collectAsync(parentsRepo.read());
+    const children = await collectAsync(childrenRepo.read());
+    expect(parents).toHaveLength(2);
+    expect(parents.every((parent) => parent.id > 0)).toBe(true);
+    expect(children).toHaveLength(3);
+    expect(ids.map((row) => row.id).sort()).toEqual(parents.map((parent) => parent.id).sort());
+  });
+
+  it("createBulk writes each parent", async () => {
+    const parentsRepo = new BulkCRUDRepository(Parent, await setup());
+    const ids = await parentsRepo.createBulk([
+      Object.assign(new Parent(), { label: "a" }),
+      Object.assign(new Parent(), { label: "b" }),
+    ]);
+    const parents = await collectAsync(parentsRepo.read());
+    expect(parents).toHaveLength(2);
+    expect(ids.map((row) => row.id).sort()).toEqual(parents.map((parent) => parent.id).sort());
+  });
+
+  it("createBulk returns composite ids", async () => {
+    class Coded {
+      code = "";
+      code_extra = "";
+      label = "";
+    }
+    const codesRepo = new BulkCRUDRepository<Coded>(await setup(), {
+      type: Coded,
+      ids: ["code", "code_extra"],
+    });
+    const ids = await codesRepo.createBulk([
+      Object.assign(new Coded(), { code: "a", code_extra: "ab", label: "one" }),
+      Object.assign(new Coded(), { code: "b", code_extra: "ba", label: "two" }),
+    ]);
+    expect(ids).toEqual([
+      Object.assign(new Coded(), { code: "a", code_extra: "ab", label: "one" }),
+      Object.assign(new Coded(), { code: "b", code_extra: "ba", label: "two" }),
+    ]);
+  });
+
+  it("keeps the first write when a later bulk update throws", async () => {
+    const parentsRepo = new BulkCRUDRepository(Parent, await setup());
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "a" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "b" }));
+    expect(second.id).toBeGreaterThan(0);
+    let seen = 0;
+    parentsRepo.addMiddleware({
+      beforeCommand() {
+        seen += 1;
+        if (seen === 2) throw new DatasourceError("stop");
+      },
+      afterCommand() {},
+    });
+    await expect(parentsRepo.updateBulk([
+      Object.assign(new Parent(), { id: first.id, label: "changed" }),
+      Object.assign(new Parent(), { id: first.id, label: "later" }),
+    ])).rejects.toThrow(/stop/);
+    const stored = await collectAsync(parentsRepo.read());
+    expect(stored.find((parent) => parent.id === first.id)?.label).toBe("changed");
+  });
+
+  it("rolls back a bulk update when useTransaction is on", async () => {
+    const parentsRepo = new BulkCRUDRepository<Parent>(await setup(), {
+      type: Parent,
+      write: new DefaultWriteEnrichmentStrategy(undefined, undefined, undefined, true),
+    });
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "a" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "b" }));
+    expect(second.id).toBeGreaterThan(0);
+    let seen = 0;
+    parentsRepo.addMiddleware({
+      beforeCommand() {
+        seen += 1;
+        if (seen === 2) throw new DatasourceError("stop");
+      },
+      afterCommand() {},
+    });
+    await expect(parentsRepo.updateBulk([
+      Object.assign(new Parent(), { id: first.id, label: "changed" }),
+      Object.assign(new Parent(), { id: first.id, label: "later" }),
+    ])).rejects.toThrow(/stop/);
+    const stored = await collectAsync(parentsRepo.read());
+    expect(stored.find((parent) => parent.id === first.id)?.label).toBe("a");
+  });
+
+  it("update replace-syncs each parent", async () => {
+    const connection = await setup();
+    const parentsRepo = new BulkCRUDRepository(Parent, connection);
+    const childrenRepo = new BulkCRUDRepository(Child, connection);
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "one" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "two" }));
+    expect(second.id).toBeGreaterThan(0);
+    const kept = await childrenRepo.create(Object.assign(new Child(), { parent_id: first.id, label: "a" }));
+    expect(kept.id).toBeGreaterThan(0);
+    const dropped = await childrenRepo.create(Object.assign(new Child(), { parent_id: second.id, label: "b" }));
+    expect(dropped.id).toBeGreaterThan(0);
+    const response = await relate(parentsRepo, childrenRepo).updateBulk([
+      Object.assign(new Parent(), {
+        id: first.id,
+        label: "one",
+        children: [Object.assign(new Child(), { id: kept.id, label: "aa" })],
+      }),
+      Object.assign(new Parent(), {
+        id: second.id,
+        label: "two",
+        children: [Object.assign(new Child(), { label: "c" })],
+      }),
+    ]);
+    expect(response.rowsAffected).toBe(2);
+    const children = await collectAsync(childrenRepo.read());
+    expect(children).toHaveLength(2);
+    expect(children.find((child) => child.parent_id === first.id)?.label).toBe("aa");
+    expect(children.find((child) => child.parent_id === second.id)?.label).toBe("c");
+    expect(children.some((child) => child.label === "b")).toBe(false);
+  });
+
+  it("delete cascades each parent", async () => {
+    const connection = await setup();
+    const parentsRepo = new BulkCRUDRepository(Parent, connection);
+    const childrenRepo = new BulkCRUDRepository(Child, connection);
+    const first = await parentsRepo.create(Object.assign(new Parent(), { label: "one" }));
+    expect(first.id).toBeGreaterThan(0);
+    const second = await parentsRepo.create(Object.assign(new Parent(), { label: "two" }));
+    expect(second.id).toBeGreaterThan(0);
+    const firstChild = await childrenRepo.create(Object.assign(new Child(), { parent_id: first.id, label: "a" }));
+    expect(firstChild.id).toBeGreaterThan(0);
+    const secondChild = await childrenRepo.create(Object.assign(new Child(), { parent_id: second.id, label: "b" }));
+    expect(secondChild.id).toBeGreaterThan(0);
+    const kept = await childrenRepo.create(Object.assign(new Child(), { label: "keep" }));
+    expect(kept.id).toBeGreaterThan(0);
+    const response = await relate(parentsRepo, childrenRepo).deleteBulk([
+      Object.assign(new Parent(), { id: first.id }),
+      Object.assign(new Parent(), { id: second.id }),
+    ]);
+    expect(response.rowsAffected).toBe(2);
+    expect(await collectAsync(parentsRepo.read())).toEqual([]);
+    expect((await collectAsync(childrenRepo.read())).map((child) => child.label)).toEqual(["keep"]);
+  });
+});