@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/CRUDRepositoryBuilder.ts

@@ -1,53 +0,0 @@
-import type { IConnection } from "./IConnection.ts";
-import { defaultId, fieldNamesOf, createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-import { CRUDRepository } from "./CRUDRepository.ts";
-import { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.ts";
-import type { BuiltRepository } from "./BuiltRepository.ts";
-import type { Constructable } from "./converters/Constructable.ts";
-import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.ts";
-import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
-import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
-
-const isCrud = <T>(options: ReadonlyRepositoryMappingOptions<T>): options is CRUDRepositoryOptions<T> =>
-  "ids" in options || "write" in options;
-
-const withIds = <T>(options: CRUDRepositoryOptions<T>): CRUDRepositoryOptions<T> =>
-  "ids" in options
-    ? options
-    : {
-        ...options,
-        ids: options.type ? defaultId(fieldNamesOf(options.type)) : ["id"],
-      };
-
-export const repositoryParts = <T>(
-  typeOrConnection: Constructable<T> | IConnection,
-  connectionOrOptions?: IConnection | CRUDRepositoryOptions<T>,
-): { built: BuiltRepository<T>; statements: CRUDRepositoryStatements } => {
-  const builder = new CRUDRepositoryBuilder<T>();
-  const built =
-    typeof typeOrConnection === "function"
-      ? builder.parts(
-          connectionOrOptions as IConnection,
-          createCRUDRepositoryOptions(typeOrConnection),
-        )
-      : builder.parts(typeOrConnection, withIds(connectionOrOptions as CRUDRepositoryOptions<T>));
-  return { built, statements: builder.crudStatements! };
-};
-
-export class CRUDRepositoryBuilder<T = object> extends ReadonlyRepositoryBuilder<T> {
-  crudStatements?: CRUDRepositoryStatements;
-
-  protected override ids = (options: ReadonlyRepositoryMappingOptions<T>): string[] =>
-    isCrud(options)
-      ? (options.ids ?? (options.type ? defaultId(fieldNamesOf(options.type)) : ["id"]))
-      : [];
-
-  protected override statements = (table: string, columns: string[]): ReadonlyRepositoryStatements => {
-    this.crudStatements = new CRUDRepositoryStatements(table, columns, this.entityMapper, this.propertyMapper);
-    return new ReadonlyRepositoryStatements(table, columns);
-  };
-
-  build = (connection: IConnection, options: CRUDRepositoryOptions<T>): CRUDRepository<T> =>
-    new CRUDRepository(connection, options);
-}

package/src/CRUDRepositoryOptions.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DefaultStatementTextRenderer, Operator, UpdateStatement, Where } from "./statements/index.ts";
-import { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.ts";
-import { CRUDRepository } from "./CRUDRepository.ts";
-import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.ts";
-import { CRUDRepositoryBuilder } from "./CRUDRepositoryBuilder.ts";
-import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.ts";
-import { MockConnection } from "./mocks/mock-connection.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-
-describe("CRUDRepositoryOptions", () => {
-  it("defaults are identity", () => {
-    const read: CRUDRepositoryOptions = {
-      ids: ["id"],
-      entity: "users",
-      readProperties: ["id"],
-    };
-    const built = new CRUDRepositoryBuilder().parts(new MockConnection(), read);
-    expect(DefaultStatementTextRenderer.instance.render(built.statements.select())).toBe("SELECT id FROM users");
-    expect(built.propertyMappings.map("x")).toBe("x");
-    expect(built.propertyMappings.reverseMap("x")).toBe("x");
-    const withId: CRUDRepositoryOptions = { ids: ["id"] };
-    expect(new CRUDRepositoryBuilder().parts(new MockConnection(), withId).ids).toEqual(["id"]);
-    const fromType: CRUDRepositoryOptions<{ id: number }> = {
-      type: class {
-        id = 0;
-      },
-      ids: ["id"],
-    };
-    expect(new CRUDRepositoryBuilder<{ id: number }>().parts(new MockConnection(), fromType).ids).toEqual(["id"]);
-    expect(new ReadonlyRepositoryBuilder().parts(new MockConnection(), {}).ids).toEqual([]);
-    expect(new CRUDRepositoryBuilder().parts(new MockConnection(), { entity: "users" }).ids).toEqual([]);
-    expect(
-      new CRUDRepositoryBuilder().parts(new MockConnection(), {
-        write: new DefaultWriteEnrichmentStrategy(),
-      }).ids,
-    ).toEqual(["id"]);
-    class Named {
-      id = 0;
-    }
-    expect(
-      new CRUDRepositoryBuilder<Named>().parts(new MockConnection(), {
-        type: Named,
-        write: new DefaultWriteEnrichmentStrategy<Named>(),
-      }).ids,
-    ).toEqual(["id"]);
-    expect(
-      new CRUDRepositoryBuilder().build(new MockConnection(), { ids: ["id"], entity: "users" }),
-    ).toBeInstanceOf(CRUDRepository);
-  });
-
-  it("uses the mapped table and columns", () => {
-    const statements = new CRUDRepositoryStatements("users", ["id", "name"]);
-    expect(DefaultStatementTextRenderer.instance.render(statements.select())).toBe("SELECT id, name FROM users");
-    expect(DefaultStatementTextRenderer.instance.render(statements.insert([{ name: "id", value: 1 }]))).toBe(
-      "INSERT INTO users (id) VALUES ($id)",
-    );
-    expect(DefaultStatementTextRenderer.instance.render(statements.update([{ name: "name", value: "a" }]))).toBe(
-      "UPDATE users SET name = $name",
-    );
-    expect(
-      DefaultStatementTextRenderer.instance.render(statements.update([{ name: "name", value: "a" }], new Where(new Operator.Equals("id", 1)))),
-    ).toBe("UPDATE users SET name = $name WHERE id = $id");
-    expect(DefaultStatementTextRenderer.instance.render(statements.delete(new Where(new Operator.Equals("id", 1))))).toBe(
-      "DELETE FROM users WHERE id = $id",
-    );
-    expect(UpdateStatement.parameterList([{ name: "name", value: "a" }])).toEqual([
-      { name: "name", value: "a" },
-    ]);
-    expect(DefaultStatementTextRenderer.instance.render(statements.delete())).toBe("DELETE FROM users");
-    const inserted = statements.selectInsertedId("id");
-    expect(inserted.table).toBe("users");
-    expect(inserted.column).toBe("id");
-    expect(() => DefaultStatementTextRenderer.instance.render(inserted)).toThrow("provider must implement SelectInsertIdStatement");
-  });
-});

package/src/CRUDRepositoryOptions.ts

@@ -1,8 +0,0 @@
-import type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.ts";
-import type { Cells } from "./converters/Cell.ts";
-import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.ts";
-
-export type CRUDRepositoryOptions<T = Cells> = ReadonlyRepositoryMappingOptions<T> & {
-  ids?: string[];
-  write?: IWriteEnrichmentStrategy<T>;
-};

package/src/CRUDRepositoryStatements.ts

@@ -1,43 +0,0 @@
-import type { Cell } from "./converters/Cell.ts";
-import type { Field } from "./builders/Field.ts";
-import type { IMapper } from "./mappers/IMapper.ts";
-import { IdentityMapper } from "./mappers/IdentityMapper.ts";
-import { StatementMappers } from "./StatementMappers.ts";
-import { DeleteStatement } from "./statements/DeleteStatement.ts";
-import { InsertStatement } from "./statements/InsertStatement.ts";
-import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.ts";
-import { UpdateStatement } from "./statements/UpdateStatement.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.ts";
-
-const same = (_name: string, value: Cell): Cell => value;
-
-export class CRUDRepositoryStatements extends ReadonlyRepositoryStatements {
-  private readonly mappings: StatementMappers;
-
-  constructor(
-    table: string,
-    columns: readonly string[],
-    entityMappers: IMapper<string, string> = new IdentityMapper(),
-    propertyMappers: IMapper<string, string> = new IdentityMapper(),
-  ) {
-    super(table, columns);
-    this.mappings = new StatementMappers(entityMappers, propertyMappers);
-  }
-
-  insert = (fields: Field[]): InsertStatement =>
-    this.mappings.apply(new InsertStatement(this.table, fields), same) as InsertStatement;
-
-  update = (
-    fields: Field[],
-    where?: IWhere,
-    cell: (name: string, value: Cell) => Cell = same,
-  ): UpdateStatement =>
-    this.mappings.apply(new UpdateStatement(this.table, fields, where), cell) as UpdateStatement;
-
-  delete = (where?: IWhere, cell: (name: string, value: Cell) => Cell = same): DeleteStatement =>
-    this.mappings.apply(new DeleteStatement(this.table, where), cell) as DeleteStatement;
-
-  selectInsertedId = (column: string): SelectInsertedIdStatement =>
-    this.mappings.apply(new SelectInsertedIdStatement(this.table, column), same) as SelectInsertedIdStatement;
-}

package/src/CascadeDeleteEnrichmentStrategy.ts

@@ -1,51 +0,0 @@
-import { DatasourceError } from "./DatasourceError.ts";
-import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.ts";
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { Scalar } from "./builders/Scalar.ts";
-import { Operator, Where } from "./statements/index.ts";
-
-type Props = Record<string, Scalar | object>;
-
-const get = <TItem>(item: TItem, name: string): Scalar | object | undefined =>
-  (item as never as Props)[name];
-
-const present = (value: Scalar | object | undefined): value is Scalar =>
-  value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
-
-const linkWhere = (
-  association: NonNullable<Enrichment["association"]>,
-  parentKey: Scalar,
-  relatedKey: Scalar,
-): Where =>
-  new Where(
-    new Operator.And(
-      new Operator.Equals(association.parent, parentKey),
-      new Operator.Equals(association.related, relatedKey),
-    ),
-  );
-
-export class CascadeDeleteEnrichmentStrategy<T> extends DeleteEnrichmentStrategy<T> {
-  async deleteChildren<TChild extends object>(
-    writer: ICRUDRepository<TChild>,
-    enrichment: Enrichment,
-    parent: T,
-    deleteNested: (rows: TChild[]) => Promise<void>,
-  ): Promise<void> {
-    const existing = await DeleteEnrichmentStrategy.load(writer, enrichment, parent);
-    await deleteNested(existing);
-    for (const row of existing) await writer.delete(row, DeleteEnrichmentStrategy.childrenWhere(writer, enrichment, parent));
-  }
-
-  async deleteLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void> {
-    const association = enrichment.association;
-    if (!association) throw new DatasourceError("Missing association");
-    const key = get(parent, enrichment.sourceProperty);
-    if (!present(key)) return;
-    for (const row of await DeleteEnrichmentStrategy.loadLinks(writer, association.parent, key)) {
-      const id = get(row, association.related);
-      if (!present(id)) continue;
-      await writer.delete(row, linkWhere(association, key, id));
-    }
-  }
-}

package/src/CascadeDeleteUpdateEnrichmentStrategy.ts

@@ -1,28 +0,0 @@
-import { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-import { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.ts";
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.ts";
-
-export class CascadeDeleteUpdateEnrichmentStrategy<T> extends UpdateEnrichmentStrategy<T> {
-  private readonly create = new DefaultCreateEnrichmentStrategy<T>();
-
-  async updateChildren<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void> {
-    for (const row of await DeleteEnrichmentStrategy.load(writer, enrichment, parent))
-      await writer.delete(row, DeleteEnrichmentStrategy.childrenWhere(writer, enrichment, parent));
-    await this.create.createChildren(writer, enrichment, parent);
-  }
-
-  async updateLinked<TChild extends object>(writer: ICRUDRepository<TChild>, enrichment: Enrichment, parent: T): Promise<void> {
-    const association = enrichment.association;
-    if (!association) throw new DatasourceError("Missing association");
-    const parentKey = this.requiredKey(parent, enrichment);
-    for (const row of await DeleteEnrichmentStrategy.loadLinks(writer, association.parent, parentKey)) {
-      const id = this.getCell(row, association.related);
-      if (!this.presentCell(id)) continue;
-      await writer.delete(row, this.linkWhere(association, parentKey, id));
-    }
-    await this.create.createLinked(writer, enrichment, parent);
-  }
-}

package/src/Command.test.ts

@@ -1,105 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  MockCommand,
-  Native,
-  MockConnection,
-  MockReader,
-  MetaDataRowTypeConverter,
-  TransformMapper,
-} from "./index.ts";
-
-class NameValue {
-  name = "";
-  value = "";
-}
-
-class Contact {
-  name = "";
-}
-
-class User {
-  id = 0;
-  username = "";
-  email = "";
-  contact_name1 = "";
-  contact_name2 = "";
-  contacts: Contact[] = [];
-}
-
-const userContactsMapper = () =>
-  new TransformMapper<User, User>(
-    (row) => {
-      row.contacts = [
-        Object.assign(new Contact(), { name: row.contact_name1 }),
-        Object.assign(new Contact(), { name: row.contact_name2 }),
-      ];
-      return row;
-    },
-    (user) => {
-      user.contact_name1 = user.contacts[0]?.name ?? "";
-      user.contact_name2 = user.contacts[1]?.name ?? "";
-      return user;
-    },
-  );
-
-describe("Command", () => {
-  it("executeReader returns NameValue objects", async () => {
-    const command = new MockCommand(new MockConnection());
-    command.reader = new MockReader([{ name: "theme", value: "dark" }]);
-    const reader = await command.executeReader("SELECT name, value FROM settings");
-    const converter = new MetaDataRowTypeConverter<NameValue>();
-    const items: NameValue[] = [];
-    while (await reader.next()) {
-      items.push(converter.convert(reader.current!, NameValue));
-    }
-    expect(items[0]?.name).toBe("theme");
-    expect(items[0]?.value).toBe("dark");
-  });
-
-  it("execute insert update and delete", async () => {
-    const command = new MockCommand(new MockConnection());
-    await command.executeNative(new Native("insert"), [
-      { name: "id", value: 1 },
-      { name: "name", value: "a" },
-    ]);
-    await command.executeNative(new Native("update"), [
-      { name: "id", value: 1 },
-      { name: "name", value: "A" },
-    ]);
-    await command.executeNative(new Native("delete"), [{ name: "id", value: 1 }]);
-    expect(command.executeCalls.map((call) => call.text)).toEqual([
-      "insert",
-      "update",
-      "delete",
-    ]);
-    expect(command.executeCalls[0]?.parameters?.map((parameter) => parameter.name)).toEqual([
-      "id",
-      "name",
-    ]);
-  });
-
-  it("executeReader maps flat contacts", async () => {
-    const command = new MockCommand(new MockConnection());
-    command.reader = new MockReader([
-      {
-        id: 1,
-        username: "bobby",
-        email: "bob@asdf.com",
-        contact_name1: "bob",
-        contact_name2: "roberta",
-      },
-    ]);
-    const reader = await command.executeReader(
-      "SELECT contact_name1, contact_name2, email, id, username FROM users",
-    );
-    const converter = new MetaDataRowTypeConverter<User>();
-    const mapper = userContactsMapper();
-    let user: User | undefined;
-    while (await reader.next()) {
-      user = mapper.map(converter.convert(reader.current!, User));
-    }
-    expect(user?.username).toBe("bobby");
-    expect(user?.email).toBe("bob@asdf.com");
-    expect(user?.contacts.map((contact) => contact.name)).toEqual(["bob", "roberta"]);
-  });
-});

package/src/CommandMiddlewareHost.test.ts

@@ -1,98 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CommandMiddlewareHost } from "./index.ts";
-
-describe("CommandMiddlewareHost", () => {
-  it("base execute methods require a driver", () => {
-    const host = new CommandMiddlewareHost();
-    expect(() => host.execute("SELECT id FROM users")).toThrow("executeNative");
-    expect(() => host.execute("  ")).toThrow("empty command");
-    expect(() => host.executeReader("SELECT id FROM users")).toThrow("executeReaderNative");
-    expect(() => host.executeReader("")).toThrow("empty command");
-  });
-
-  it("rewrites the text and runs afterCommand", async () => {
-    const host = new CommandMiddlewareHost();
-    const seen: string[] = [];
-    let used = "";
-    host.addMiddleware({
-      beforeCommand: (text) => {
-        seen.push(`before:${text}`);
-        return { text: "SELECT 2" };
-      },
-      afterCommand: (text, _params, results, elapsedMs) => {
-        seen.push(`after:${text}:${results.length}:${elapsedMs >= 0}`);
-      },
-    });
-    const result = await host.run("SELECT 1", undefined, async (text) => {
-      used = text;
-      seen.push("op");
-      return { value: 7, rows: [{ id: 1 }] };
-    });
-    expect(result).toBe(7);
-    expect(used).toBe("SELECT 2");
-    expect(seen[0]).toBe("before:SELECT 1");
-    expect(seen[1]).toBe("op");
-    expect(seen[2]?.startsWith("after:SELECT 2:1:true")).toBe(true);
-  });
-
-  it("runs with no middleware", async () => {
-    const host = new CommandMiddlewareHost();
-    expect(await host.run("", undefined, async () => ({ value: "ok", rows: [] }))).toBe(
-      "ok",
-    );
-  });
-
-  it("skips the command when beforeCommand throws", async () => {
-    const host = new CommandMiddlewareHost();
-    let ran = false;
-    host.addMiddleware({
-      beforeCommand: () => {
-        throw new Error("blocked");
-      },
-      afterCommand: () => {
-        ran = true;
-      },
-    });
-    await expect(
-      host.run("select", undefined, async () => {
-        ran = true;
-        return { value: 1, rows: [] };
-      }),
-    ).rejects.toThrow("blocked");
-    expect(ran).toBe(false);
-  });
-
-  it("runs afterCommand with error when the command fails", async () => {
-    const host = new CommandMiddlewareHost();
-    let captured: Error | undefined;
-    host.addMiddleware({
-      beforeCommand: () => undefined,
-      afterCommand: (_q, _p, _r, _e, error) => {
-        captured = error;
-      },
-    });
-    await expect(
-      host.run("select", undefined, async () => {
-        throw new Error("fail-op");
-      }),
-    ).rejects.toThrow("fail-op");
-    expect(captured?.message).toBe("fail-op");
-  });
-
-  it("wraps a non-Error throw for afterCommand", async () => {
-    const host = new CommandMiddlewareHost();
-    let captured: Error | undefined;
-    host.addMiddleware({
-      beforeCommand: () => undefined,
-      afterCommand: (_q, _p, _r, _e, error) => {
-        captured = error;
-      },
-    });
-    await expect(
-      host.run("select", undefined, async () => {
-        throw "string-fail";
-      }),
-    ).rejects.toBe("string-fail");
-    expect(captured?.message).toBe("string-fail");
-  });
-});

package/src/CommandMiddlewareHost.ts

@@ -1,113 +0,0 @@
-import type { ICommandMiddleware } from "./ICommandMiddleware.ts";
-import type { IReader } from "./IReader.ts";
-import type { Parameter } from "./Parameter.ts";
-import type { Response } from "./Response.ts";
-import type { Row } from "./Row.ts";
-import type { Cell, Cells } from "./converters/Cell.ts";
-import type { IStatement } from "./statements/IStatement.ts";
-import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.ts";
-import { Native } from "./statements/Native.ts";
-import { StatementParser } from "./statements/StatementParser.ts";
-
-const asError = (error: unknown): Error =>
-  error instanceof Error ? error : new Error(String(error));
-
-type ExecuteBody = { result: Cell; rowsAffected: number };
-
-const resultOf = (value: Cell | object | null): Cell =>
-  value instanceof Date ||
-  value instanceof Uint8Array ||
-  value === null ||
-  typeof value === "string" ||
-  typeof value === "number" ||
-  typeof value === "boolean" ||
-  typeof value === "bigint"
-    ? value
-    : String(value);
-
-const isResponse = (value: object): value is ExecuteBody =>
-  "rowsAffected" in value && typeof (value as ExecuteBody).rowsAffected === "number";
-
-const logged = <T>(value: T, rows: readonly Row[]): readonly Row[] =>
-  rows.length > 0 || value === null || typeof value !== "object" || !isResponse(value)
-    ? rows
-    : [{ result: resultOf(value.result), rowsAffected: value.rowsAffected }];
-
-export class CommandMiddlewareHost {
-  private readonly middlewares: ICommandMiddleware[] = [];
-
-  addMiddleware(middleware: ICommandMiddleware): this {
-    this.middlewares.push(middleware);
-    return this;
-  }
-
-  execute(text: string, parameters?: Parameter[]): Promise<Response> {
-    if (!text.trim()) throw new Error("empty command");
-    return this.executeStatement(StatementParser.parse(text), parameters);
-  }
-
-  executeReader(text: string, parameters?: Parameter[]): Promise<IReader<Cells>> {
-    if (!text.trim()) throw new Error("empty command");
-    return this.executeReaderStatement(StatementParser.parse(text), parameters);
-  }
-
-  executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
-    return this.executeNative(
-      new Native(DefaultStatementTextRenderer.instance.render(statement)),
-      parameters,
-    );
-  }
-
-  executeReaderStatement(
-    statement: IStatement,
-    parameters?: Parameter[],
-  ): Promise<IReader<Cells>> {
-    return this.executeReaderNative(
-      new Native(DefaultStatementTextRenderer.instance.render(statement)),
-      parameters,
-    );
-  }
-
-  executeNative(_text: Native, _parameters?: Parameter[]): Promise<Response> {
-    throw new Error("executeNative");
-  }
-
-  executeReaderNative(_text: Native, _parameters?: Parameter[]): Promise<IReader<Cells>> {
-    throw new Error("executeReaderNative");
-  }
-
-  async run<T>(
-    text: string,
-    params: Parameter[] | undefined,
-    fn: (
-      text: string,
-      params?: Parameter[],
-    ) => Promise<{ value: T; rows: readonly Row[] }>,
-  ): Promise<T> {
-    let q = text.trim();
-    let p = params;
-    for (const middleware of this.middlewares) {
-      const rewritten = await middleware.beforeCommand(q, p);
-      if (rewritten) {
-        q = rewritten.text;
-        p = rewritten.params as Parameter[] | undefined;
-      }
-    }
-
-    const start = performance.now();
-    try {
-      const { value, rows } = await fn(q, p);
-      const elapsedMs = performance.now() - start;
-      for (const middleware of this.middlewares) {
-        await middleware.afterCommand(q, p, logged(value, rows), elapsedMs);
-      }
-      return value;
-    } catch (error) {
-      const elapsedMs = performance.now() - start;
-      for (const middleware of this.middlewares) {
-        await middleware.afterCommand(q, p, [], elapsedMs, asError(error));
-      }
-      throw error;
-    }
-  }
-}

package/src/Connection.test.ts

@@ -1,34 +0,0 @@
-import { afterAll, afterEach, beforeEach, describe, expect, it } from "vitest";
-import { Datasource, DatasourceFactory, MockDriver } from "./index.ts";
-
-const envKeys = [
-  "INSTALLED_PROVIDERS",
-  "DATASOURCE_URL",
-  "PROVIDER",
-] as const;
-const savedEnv = Object.fromEntries(envKeys.map((key) => [key, process.env[key]]));
-
-beforeEach(() => {
-  for (const key of envKeys) delete process.env[key];
-  DatasourceFactory.register("sqlite", new MockDriver());
-  process.env.PROVIDER = "sqlite";
-});
-
-afterEach(() => DatasourceFactory.reset());
-
-afterAll(() => {
-  for (const key of envKeys) {
-    if (savedEnv[key] === undefined) delete process.env[key];
-    else process.env[key] = savedEnv[key];
-  }
-});
-
-describe("Connection", () => {
-  it("create from default", async () => {
-    const ds = Datasource.default;
-    const connection = await ds.createConnection();
-    await connection.open();
-    await connection.close();
-    expect(connection.isOpen).toBe(false);
-  });
-});