@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/src/CRUDRepositoryBuilder.ts

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,113 @@
+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

@@ -0,0 +1,34 @@
+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);
+  });
+});