@deterministic-code/datasources-mysql 0.1.0 → 0.1.1

package/dist/MysqlBulkUpdateStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import { BulkUpdateStatementTextRenderer, type BulkUpdateStatement } from "@datasources/core";
+export declare class MysqlBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
+    render: (statement: BulkUpdateStatement) => string;
+}

package/dist/MysqlCreateTableStatementRenderer.d.ts

@@ -0,0 +1,5 @@
+import { CreateTableStatementTextRenderer, type Column } from "@datasources/core";
+export declare class MysqlCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    protected typeName(column: Column): string;
+    protected identity(column: Column): string;
+}

package/dist/MysqlDriver.d.ts

@@ -0,0 +1,12 @@
+import { StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@datasources/core";
+import { columnTypes } from "./columnTypes.js";
+export { columnTypes };
+export declare class MysqlDriver implements IDriver {
+    readonly statementRenderer: StatementTextRenderer;
+    readonly information: Information;
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/MysqlStatementRenderer.d.ts

@@ -0,0 +1,7 @@
+import { BulkUpdateStatement, CreateTableStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@datasources/core";
+export declare class MysqlStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
+    protected visitCreateTable(create: CreateTableStatement): string;
+    protected visitBulkUpdate(update: BulkUpdateStatement): string;
+}

package/dist/bind.d.ts

@@ -0,0 +1,5 @@
+import { type Parameter } from "@datasources/core";
+import type { Scalar } from "./scalar.js";
+export declare const withoutReturning: (sql: string) => string;
+export declare const toMysql: (sql: string) => string;
+export declare const bindParameters: (parameters?: Parameter[] | null) => Record<string, Scalar>;

package/dist/columnTypes.d.ts

@@ -0,0 +1 @@
+export declare const columnTypes: Record<string, string>;

package/dist/command.d.ts

@@ -0,0 +1,16 @@
+import { CommandMiddlewareHost, Native, StatementTextRenderer, Response, type Cells, type ICommand, type IReader, type IStatement, type Parameter } from "@datasources/core";
+import type { MysqlConnection } from "./connection.js";
+export declare class MysqlCommand extends CommandMiddlewareHost implements ICommand {
+    readonly connection: MysqlConnection;
+    private readonly statements;
+    constructor(connection: MysqlConnection, statements?: StatementTextRenderer);
+    executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeReaderStatement(statement: IStatement, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
+    private firstCell;
+    executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
+    private executeProcedure;
+    private runSql;
+    private query;
+    private callResults;
+}

package/dist/connection-options.d.ts

@@ -0,0 +1,5 @@
+import type { MysqlCreateConnection } from "./i-mysql-engine.js";
+export interface MysqlConnectionOptions {
+    url?: string;
+    connect?: MysqlCreateConnection;
+}

package/dist/connection.d.ts

@@ -0,0 +1,19 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@datasources/core";
+import type { MysqlConnectionOptions } from "./connection-options.js";
+import { type IMysqlClient } from "./i-mysql-engine.js";
+export declare class MysqlConnection implements IConnection {
+    readonly provider = "mysql";
+    url: string;
+    isOpen: boolean;
+    private client?;
+    private readonly connect?;
+    static from: (options?: DatasourceOptions) => MysqlConnection;
+    constructor(options?: MysqlConnectionOptions);
+    createCommand: () => ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction(isolation?: IsolationLevelName): Promise<ITransaction>;
+    ensureOpen(): void;
+    require(): IMysqlClient;
+}

package/dist/converters/BinaryConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class BinaryConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/BoolConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class BoolConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/DateTimeConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class DateTimeConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/DecimalConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class DecimalConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/converters/MysqlRowTypeConverters.d.ts

@@ -0,0 +1,3 @@
+import { type Cell, type TypeConverter } from "@datasources/core";
+export declare const MysqlRowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+export declare const reverse: (value: Cell) => Cell;

package/dist/converters/UuidConverter.d.ts

@@ -0,0 +1,5 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+export declare class UuidConverter extends TypeConverter<Cell, Cell> {
+    convert: (from: Cell) => Cell;
+    reverseConvert: (to: Cell) => Cell;
+}

package/dist/i-mysql-engine.d.ts

@@ -0,0 +1,27 @@
+import type { Parameter } from "@datasources/core";
+import type { Cells, Scalar } from "./scalar.js";
+export interface MysqlExecuteResult {
+    rowsAffected: number;
+    result?: Scalar;
+    parameters?: Parameter[];
+}
+export interface MysqlQueryHeader {
+    affectedRows?: number;
+    insertId?: Scalar;
+}
+export interface IMysqlClient {
+    query(sql: string, params?: Record<string, Scalar>): Promise<[MysqlQueryHeader | Cells[]]>;
+    queryRows(sql: string, params?: Record<string, Scalar>): AsyncIterable<Cells>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    end(): Promise<void>;
+}
+export type MysqlCreateConnection = (url: string) => Promise<IMysqlClient>;
+export type Mysql2Module = {
+    createConnection: (options: {
+        uri: string;
+        namedPlaceholders: boolean;
+    }) => Promise<IMysqlClient>;
+};
+export declare const mysql2Connect: (mysql: Mysql2Module) => MysqlCreateConnection;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { MysqlDriver } from "./MysqlDriver.js";

package/dist/scalar.d.ts

@@ -0,0 +1,2 @@
+export type Scalar = string | number | boolean | bigint | null;
+export type Cells = Record<string, Scalar>;

package/dist/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@datasources/core";
+import type { MysqlConnection } from "./connection.js";
+export declare class MysqlTransaction implements ITransaction {
+    readonly connection: MysqlConnection;
+    readonly isolation: IsolationLevelName;
+    constructor(connection: MysqlConnection, isolation?: IsolationLevelName);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

package/package.json

@@ -1,21 +1,25 @@
 {
   "name": "@deterministic-code/datasources-mysql",
-  "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"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
   },
   "files": [
+    "dist",
     "src"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.0",
-    "mysql2": "^3.14.0"
+    "mysql2": "^3.14.0",
+    "@deterministic-code/datasources": "^0.1.1"
   }
 }

package/src/MysqlBulkUpdateStatementTextRenderer.ts

@@ -1,4 +1,4 @@
-import { BulkUpdateStatementTextRenderer, type BulkUpdateStatement } from "@deterministic-code/datasources";
+import { BulkUpdateStatementTextRenderer, type BulkUpdateStatement } from "@datasources/core";
 
 export class MysqlBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
   override render = (statement: BulkUpdateStatement): string => {

package/src/MysqlCreateTableStatementRenderer.ts

@@ -1,4 +1,4 @@
-import { CreateTableStatementTextRenderer, type Column } from "@deterministic-code/datasources";
+import { CreateTableStatementTextRenderer, type Column } from "@datasources/core";
 import { columnTypes } from "./columnTypes.ts";
 
 export class MysqlCreateTableStatementRenderer extends CreateTableStatementTextRenderer {

package/src/MysqlDriver.ts

@@ -10,7 +10,7 @@ import {
   type ITransaction,
   type IsolationLevel,
   type TypeConverter,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { MysqlConnection } from "./connection.ts";
 import { MysqlCommand } from "./command.ts";
 import { MysqlTransaction } from "./transaction.ts";

package/src/MysqlStatementRenderer.test.ts

@@ -0,0 +1,64 @@
+import {
+  BulkUpdateStatement,
+  ColumnDefault,
+  CreateTableStatement,
+  DefaultStatementTextRenderer,
+  ForeignKey,
+  SelectInsertedIdStatement,
+  NotNull,
+  PrimaryKey,
+  ReferentialAction,
+  SelectStatement,
+  StatementTextRenderer,
+} from "@datasources/core";
+import { describe, expect, it } from "vitest";
+import { MysqlCreateTableStatementRenderer } from "./MysqlCreateTableStatementRenderer.ts";
+import { MysqlStatementRenderer } from "./MysqlStatementRenderer.ts";
+
+describe("MysqlStatementRenderer", () => {
+  const renderer = new StatementTextRenderer(t => new MysqlStatementRenderer(t));
+
+  it("renders inserted id and create table", () => {
+    expect(renderer.render(new SelectInsertedIdStatement("users", "id"))).toBe(
+      "SELECT LAST_INSERT_ID() AS id",
+    );
+
+    const create = new CreateTableStatement(
+      "orders",
+      [
+        { name: "id", type: "INTEGER", default: new ColumnDefault("0", "df_id"), notNull: new NotNull("nn_id") },
+        { name: "user_id", type: "INTEGER" },
+      ],
+      [
+        new PrimaryKey("pk_orders", ["id"]),
+        new ForeignKey("fk_orders_user", ["user_id"], "users", ["id"], ReferentialAction.Cascade),
+      ],
+    );
+    expect(renderer.render(create)).toBe(new MysqlCreateTableStatementRenderer().render(create));
+    expect(renderer.render(new SelectStatement({ table: "users", fields: ["id"] }))).toBe(
+      "SELECT id FROM users",
+    );
+  });
+
+  it("renders type default and identity", () => {
+    const create = new CreateTableStatement("users", [
+      { name: "id", type: "int", default: new ColumnDefault("0"), notNull: new NotNull(), identity: true },
+    ]);
+    expect(renderer.render(create)).toBe(
+      "CREATE TABLE users (id INT AUTO_INCREMENT DEFAULT 0 NOT NULL)",
+    );
+    expect(DefaultStatementTextRenderer.instance.render(create)).toBe(
+      "CREATE TABLE users (id int DEFAULT 0 NOT NULL)",
+    );
+  });
+
+  it("renders bulk update as join", () => {
+    const update = new BulkUpdateStatement("parents", ["label"], ["id"], [
+      { fields: [{ name: "label", value: "a" }], ids: [{ name: "id", value: 1 }] },
+      { fields: [{ name: "label", value: "b" }], ids: [{ name: "id", value: 2 }] },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE parents JOIN (SELECT $label__0 AS label, $id__0 AS id UNION ALL SELECT $label__1 AS label, $id__1 AS id) AS data ON parents.id = data.id SET parents.label = data.label",
+    );
+  });
+});

package/src/MysqlStatementRenderer.ts

@@ -5,7 +5,7 @@ import {
   SelectInsertedIdStatementTextRenderer,
   StatementRenderer,
   type StatementTextRenderer,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { MysqlBulkUpdateStatementTextRenderer } from "./MysqlBulkUpdateStatementTextRenderer.ts";
 import { MysqlCreateTableStatementRenderer } from "./MysqlCreateTableStatementRenderer.ts";
 

package/src/bind.ts

@@ -1,4 +1,4 @@
-import { parametersToRecord, type Cell, type Parameter } from "@deterministic-code/datasources";
+import { parametersToRecord, type Cell, type Parameter } from "@datasources/core";
 import { reverse } from "./converters/MysqlRowTypeConverters.ts";
 import type { Scalar } from "./scalar.ts";
 

package/src/command.ts

@@ -19,7 +19,7 @@ import {
   type IReader,
   type IStatement,
   type Parameter,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { bindParameters, toMysql } from "./bind.ts";
 import type { MysqlConnection } from "./connection.ts";
 import type { MysqlExecuteResult } from "./i-mysql-engine.ts";

package/src/connection.ts

@@ -7,7 +7,7 @@ import {
   type IConnection,
   type IsolationLevelName,
   type ITransaction,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { createRequire } from "node:module";
 import { MysqlCommand } from "./command.ts";
 import type { MysqlConnectionOptions } from "./connection-options.ts";

package/src/converters/BinaryConverter.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { BinaryConverter } from "./BinaryConverter.ts";
+
+describe("BinaryConverter", () => {
+  it("maps binary", () => {
+    const converter = new BinaryConverter();
+    const raw = new Uint8Array([1, 2, 3, 4]);
+    expect(converter.convert(raw)).toBe(raw);
+    expect(converter.reverseConvert(raw)).toBe(raw);
+    expect(converter.reverseConvert("AQIDBA==")).toEqual(raw);
+  });
+});

package/src/converters/BinaryConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 const bytes = (value: Cell): Cell =>
   typeof value === "string" ? Uint8Array.from(Buffer.from(value, "base64")) : value;

package/src/converters/BoolConverter.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { BoolConverter } from "./BoolConverter.ts";
+
+describe("BoolConverter", () => {
+  it("maps bool", () => {
+    const converter = new BoolConverter();
+    expect(converter.convert(1)).toBe(true);
+    expect(converter.convert(0)).toBe(false);
+    expect(converter.convert("x")).toBe("x");
+    expect(converter.reverseConvert(true)).toBe(1);
+    expect(converter.reverseConvert(false)).toBe(0);
+    expect(converter.reverseConvert("x")).toBe("x");
+  });
+});

package/src/converters/BoolConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 export class BoolConverter extends TypeConverter<Cell, Cell> {
   convert = (from: Cell): Cell => (typeof from === "number" ? from !== 0 : from);

package/src/converters/DateTimeConverter.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { DateTimeConverter } from "./DateTimeConverter.ts";
+
+describe("DateTimeConverter", () => {
+  it("maps datetime", () => {
+    const converter = new DateTimeConverter();
+    const date = new Date("2020-01-02T03:04:05.000Z");
+    expect(converter.convert("2020-01-02T03:04:05.000Z")).toEqual(date);
+    expect(converter.convert(date)).toBe(date);
+    expect(converter.reverseConvert(date)).toBe("2020-01-02 03:04:05.000");
+    expect(converter.reverseConvert("2020-01-02T03:04:05.000Z")).toBe("2020-01-02 03:04:05.000");
+    expect(converter.reverseConvert("x")).toBe("x");
+  });
+});

package/src/converters/DateTimeConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 const stamp = (date: Date): string =>
   date.toISOString().replace("T", " ").replace("Z", "");

package/src/converters/DecimalConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DecimalConverter } from "./DecimalConverter.ts";
+
+describe("DecimalConverter", () => {
+  it("maps decimal", () => {
+    const converter = new DecimalConverter();
+    expect(converter.convert("10.5")).toBe("10.5");
+    expect(converter.reverseConvert(10.5)).toBe("10.5");
+    expect(converter.reverseConvert("10.5")).toBe("10.5");
+  });
+});

package/src/converters/DecimalConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 export class DecimalConverter extends TypeConverter<Cell, Cell> {
   convert = (from: Cell): Cell => from;

package/src/converters/MysqlRowTypeConverters.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { MysqlDriver } from "../MysqlDriver.ts";
+import { reverse, MysqlRowTypeConverters } from "./MysqlRowTypeConverters.ts";
+
+describe("MysqlRowTypeConverters", () => {
+  it("registers default types", () => {
+    expect(Object.keys(new MysqlDriver().rowTypeConverters)).toEqual(Object.keys(MysqlRowTypeConverters));
+  });
+
+  it("reverses booleans, dates, and bytes", () => {
+    const when = new Date("2024-01-02T00:00:00.000Z");
+    expect(reverse(true)).toBe(1);
+    expect(reverse(false)).toBe(0);
+    expect(reverse(when)).toBe(when.toISOString().replace("T", " ").replace("Z", ""));
+    expect(reverse(new Uint8Array([1, 2]))).toEqual(new Uint8Array([1, 2]));
+    expect(reverse("a")).toBe("a");
+    expect(reverse("2024-01-02T00:00:00Z")).toBe("2024-01-02 00:00:00.000");
+  });
+});

package/src/converters/MysqlRowTypeConverters.ts

@@ -1,4 +1,4 @@
-import { type Cell, type TypeConverter } from "@deterministic-code/datasources";
+import { type Cell, type TypeConverter } from "@datasources/core";
 import { BinaryConverter } from "./BinaryConverter.ts";
 import { BoolConverter } from "./BoolConverter.ts";
 import { DateTimeConverter } from "./DateTimeConverter.ts";

package/src/converters/UuidConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { UuidConverter } from "./UuidConverter.ts";
+
+describe("UuidConverter", () => {
+  it("maps uuid", () => {
+    const converter = new UuidConverter();
+    const id = "550e8400-e29b-41d4-a716-446655440000";
+    expect(converter.convert(id)).toBe(id);
+    expect(converter.reverseConvert(id)).toBe(id);
+  });
+});

package/src/converters/UuidConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 export class UuidConverter extends TypeConverter<Cell, Cell> {
   convert = (from: Cell): Cell => from;

package/src/i-mysql-engine.ts

@@ -1,4 +1,4 @@
-import type { Parameter } from "@deterministic-code/datasources";
+import type { Parameter } from "@datasources/core";
 import type { Cells, Scalar } from "./scalar.ts";
 
 export interface MysqlExecuteResult {

package/src/mysql.test.ts

@@ -0,0 +1,342 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("mysql2/promise", () => ({
+  createConnection: async () => ({
+    query: async () => [{}],
+    beginTransaction: async () => {},
+    commit: async () => {},
+    rollback: async () => {},
+    end: async () => {},
+  }),
+}));
+
+import { Datasource, DatasourceFactory, DatasourceError, IsolationLevel, CRUDRepository, ReadonlyRepository, untyped, Native, ParameterDirection, columnType, RowTypeConverter, CreateTableStatement, ExecuteStoredProcedureStatement, ReturnStatement, SelectStatement, type IDriver } from "@datasources/core";
+import { bindParameters, toMysql } from "./bind.ts";
+import { MysqlCommand } from "./command.ts";
+import { MysqlConnection } from "./connection.ts";
+import { MysqlRowTypeConverters } from "./converters/MysqlRowTypeConverters.ts";
+import { mysql2Connect, type IMysqlClient, type MysqlQueryHeader } from "./i-mysql-engine.ts";
+import { MysqlDriver } from "./MysqlDriver.ts";
+import { MysqlTransaction } from "./transaction.ts";
+import type { Cells, Scalar } from "./scalar.ts";
+
+class FakeClient implements IMysqlClient {
+  queries: Array<{ sql: string; params?: Record<string, Scalar> }> = [];
+  begins = 0;
+  commits = 0;
+  rollbacks = 0;
+  ended = false;
+  header: MysqlQueryHeader = { affectedRows: 2, insertId: 5 };
+  rows: Cells[] = [{ id: 1 }];
+  arrayResult = false;
+  /** Multi-result-set payload for CALL (array of row arrays). */
+  callSets?: Cells[][];
+
+  async query(sql: string, params?: Record<string, Scalar>) {
+    this.queries.push({ sql, params });
+    if (this.callSets !== undefined)
+      return [this.callSets] as [MysqlQueryHeader | Cells[]];
+    return [this.arrayResult ? this.rows : this.header] as [
+      MysqlQueryHeader | Cells[],
+    ];
+  }
+  async *queryRows(sql: string, params?: Record<string, Scalar>): AsyncGenerator<Cells> {
+    this.queries.push({ sql, params });
+    if (!this.arrayResult) return;
+    for (const row of this.rows) yield row;
+  }
+  async beginTransaction(): Promise<void> {
+    this.begins += 1;
+  }
+  async commit(): Promise<void> {
+    this.commits += 1;
+  }
+  async rollback(): Promise<void> {
+    this.rollbacks += 1;
+  }
+  async end(): Promise<void> {
+    this.ended = true;
+  }
+}
+
+const opened = async (url = "mysql://localhost/app", client = new FakeClient()) => {
+  const connection = new MysqlConnection({ url, connect: async () => client });
+  await connection.open();
+  return { connection, client, command: new MysqlCommand(connection) };
+};
+
+afterEach(() => {
+  DatasourceFactory.reset();
+  DatasourceFactory.register("mysql", new MysqlDriver());
+});
+
+describe("bindParameters", () => {
+  it("binds and rewrites parameters", () => {
+    expect(bindParameters()).toEqual({});
+    expect(bindParameters(null)).toEqual({});
+    expect(bindParameters([{ name: "id", value: 1 }])).toEqual({ id: 1 });
+    expect(toMysql("SELECT * FROM t WHERE id = $id")).toBe(
+      "SELECT * FROM t WHERE id = :id",
+    );
+    expect(toMysql("INSERT INTO t (id) VALUES ($id) RETURNING id")).toBe(
+      "INSERT INTO t (id) VALUES (:id)",
+    );
+    expect(toMysql("INSERT INTO contact_settings (contact_id, key, value) VALUES ($contact_id, $key, $value)"))
+      .toBe("INSERT INTO contact_settings (contact_id, `key`, value) VALUES (:contact_id, :key, :value)");
+    expect(toMysql("CREATE TABLE t (id INT PRIMARY KEY)")).toBe("CREATE TABLE t (id INT PRIMARY KEY)");
+    expect(toMysql("CREATE TABLE t (id INT AUTO_INCREMENT, CONSTRAINT `pk` PRIMARY KEY (`id`))"))
+      .toBe("CREATE TABLE t (id INT AUTO_INCREMENT, CONSTRAINT `pk` PRIMARY KEY (`id`))");
+    expect(toMysql("INSERT INTO OldContactsTbl (CntID) VALUES ($CntID)"))
+      .toBe("INSERT INTO `OldContactsTbl` (`CntID`) VALUES (:CntID)");
+  });
+});
+
+describe("MysqlConnection", () => {
+  it("opens, runs SQL, transacts, and closes", async () => {
+    const { connection, client, command } = await opened("mysql://db/app");
+    expect(await command.execute("INSERT INTO items (id) VALUES ($id)", [{ name: "id", value: 1 }]))
+      .toMatchObject({ rowsAffected: 2, result: null });
+    expect(await command.executeStatement(new CreateTableStatement("users", [{ name: "id", type: "INTEGER" }])))
+      .toMatchObject({ rowsAffected: 2 });
+    expect(client.queries.at(-1)?.sql).toBe("CREATE TABLE users (id INTEGER)");
+    client.arrayResult = true;
+    expect(await (await command.executeReaderNative(new Native("SELECT 1"))).next()).toBe(true);
+    expect(await command.executeNative(new Native("   "))).toEqual({ result: undefined, rowsAffected: 0, parameters: undefined });
+    client.arrayResult = true;
+    const reader = await command.executeReader("SELECT * FROM items");
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 1 });
+    expect(await (await command.executeReaderNative(new Native(""))).next()).toBe(false);
+    client.arrayResult = false;
+    await connection.startTransaction();
+    await connection.startTransaction(IsolationLevel.ReadUncommitted);
+    await connection.startTransaction(IsolationLevel.ReadCommitted);
+    await connection.startTransaction(IsolationLevel.RepeatableRead);
+    await new MysqlTransaction(connection).commit();
+    await new MysqlTransaction(connection).abort();
+    expect(client.begins).toBe(4);
+    expect(client.commits).toBe(1);
+    expect(client.rollbacks).toBe(1);
+    expect(client.queries.map((q) => q.sql)).toEqual([
+      "SET SESSION sql_mode = CONCAT(@@sql_mode, ',ANSI_QUOTES')",
+      "INSERT INTO items (id) VALUES (:id)",
+      "CREATE TABLE users (id INTEGER)",
+      "SELECT 1",
+      "SELECT * FROM items",
+      "SET TRANSACTION ISOLATION LEVEL READ COMMITTED",
+      "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED",
+      "SET TRANSACTION ISOLATION LEVEL READ COMMITTED",
+      "SET TRANSACTION ISOLATION LEVEL REPEATABLE READ",
+    ]);
+    await connection.close();
+    expect(client.ended).toBe(true);
+    expect(() => connection.require()).toThrow("not open");
+    await expect(command.executeNative(new Native("x"))).rejects.toThrow("not open");
+  });
+
+  it("connects through mysql2 and treats array results as row counts", async () => {
+    const connect = mysql2Connect({
+      createConnection: async () => new FakeClient(),
+    });
+    const named = new MysqlConnection({ url: "mysql://db/app", connect });
+    await named.open();
+    await named.close();
+
+    const { command, client, connection } = await opened("x");
+    client.arrayResult = true;
+    expect(await command.executeNative(new Native("SELECT 1"))).toMatchObject({ rowsAffected: 1, result: undefined });
+    client.arrayResult = false;
+    client.header = {};
+    expect(await command.executeNative(new Native("UPDATE items"))).toMatchObject({ rowsAffected: 0 });
+    await connection.close();
+    await connection.close();
+  });
+
+  it("opens, reopens, transacts, and closes", async () => {
+    const { connection, client } = await opened("mysql://db/app");
+    await expect(connection.open()).rejects.toThrow("Connection is already open");
+    expect(connection.createCommand()).toBeInstanceOf(MysqlCommand);
+    expect(connection.isOpen).toBe(true);
+    const txn = await connection.startTransaction();
+    await txn.commit();
+    const txn2 = await connection.startTransaction(IsolationLevel.ReadUncommitted);
+    expect(txn2.isolation).toBe(IsolationLevel.ReadUncommitted);
+    await txn2.abort();
+    expect(txn.isolation).toBe("readCommitted");
+    await connection.close();
+    expect(client.ended).toBe(true);
+    expect(() => connection.ensureOpen()).toThrow(DatasourceError);
+    await expect(connection.startTransaction()).rejects.toThrow(DatasourceError);
+  });
+
+  it("defaults url and requires a client to open", async () => {
+    const connection = new MysqlConnection();
+    expect(connection.url).toBe("");
+    await expect(connection.open()).rejects.toThrow(DatasourceError);
+  });
+});
+
+describe("MysqlCommand", () => {
+  it("executes SQL through the client", async () => {
+    const { command, client } = await opened();
+    client.arrayResult = true;
+    expect(await command.execute("DELETE FROM items", [{ name: "id", value: 1 }]))
+      .toEqual({ result: undefined, rowsAffected: 1, parameters: [{ name: "id", value: 1 }] });
+    expect(await command.executeNative(new Native(""))).toEqual({ result: undefined, rowsAffected: 0, parameters: undefined });
+    const reader = await command.executeReader("SELECT * FROM items");
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 1 });
+    const empty = await command.executeReaderNative(new Native(""));
+    expect(await empty.next()).toBe(false);
+    expect(await (await command.executeReaderNative(new Native(";"))).next()).toBe(false);
+    client.rows = [{ add_one: 5 }];
+    const n = { name: "n", value: 4 };
+    expect(await command.executeStatement(new ReturnStatement("add_one", [n]), [n]))
+      .toEqual({ result: 5, rowsAffected: 1, parameters: [n] });
+    client.rows = [];
+    expect(await command.executeNative(new Native("SELECT 1"))).toEqual({
+      result: undefined,
+      rowsAffected: 0,
+      parameters: undefined,
+    });
+    client.rows = [{ result: 5 }];
+    const start = { name: "start_n", value: 4 };
+    const out = { name: "result", direction: ParameterDirection.Output };
+    expect(
+      await command.executeStatement(new ExecuteStoredProcedureStatement("bump", [start, out]), [start, out]),
+    ).toMatchObject({
+      parameters: [start, { name: "result", direction: ParameterDirection.Output, value: 5 }],
+    });
+    const inout = { name: "n", value: 4, direction: ParameterDirection.InputOutput };
+    client.rows = [{ n: 5 }];
+    expect(await command.executeStatement(new ExecuteStoredProcedureStatement("bump", [inout]), [inout])).toMatchObject({
+      parameters: [{ name: "n", value: 5, direction: ParameterDirection.InputOutput }],
+    });
+    expect(
+      await command.executeStatement(new ExecuteStoredProcedureStatement("bump", [
+        { name: "start_n" },
+        { name: "result", direction: ParameterDirection.Output },
+      ]), [
+        { name: "start_n" },
+        { name: "result", direction: ParameterDirection.Output },
+      ]),
+    ).toMatchObject({ rowsAffected: 0 });
+    client.arrayResult = true;
+    client.rows = [];
+    expect(await command.executeStatement(new SelectStatement({ table: "dual", fields: ["1"] }))).toMatchObject({
+      result: null,
+      rowsAffected: 0,
+    });
+    client.rows = [{}];
+    expect(await command.executeStatement(new SelectStatement({ table: "dual", fields: ["1"] }))).toMatchObject({ result: null });
+    expect(await command.executeStatement(new ExecuteStoredProcedureStatement("bump", []))).toMatchObject({
+      result: undefined,
+    });
+    client.arrayResult = false;
+    expect(await (await command.executeReaderNative(new Native("SELECT 1"))).next()).toBe(false);
+    expect(
+      await command.executeStatement(new ExecuteStoredProcedureStatement("bump", [
+        { name: "result", direction: ParameterDirection.Output },
+      ]), [
+        { name: "result", direction: ParameterDirection.Output },
+      ]),
+    ).toMatchObject({ rowsAffected: 0 });
+  });
+
+  it("reads CALL result sets through the reader", async () => {
+    const { command, client } = await opened();
+    client.callSets = [[{ id: 1 }, { id: 2 }], [{ id: 3 }]];
+    const reader = await command.executeReaderNative(new Native("CALL two_ids()"));
+    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(await reader.nextResult()).toBe(true);
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 3 });
+    expect(await reader.next()).toBe(false);
+    expect(await reader.nextResult()).toBe(false);
+
+    client.callSets = undefined;
+    client.arrayResult = false;
+    const empty = await command.executeReaderNative(new Native("CALL noop()"));
+    expect(await empty.next()).toBe(false);
+    expect(await empty.nextResult()).toBe(false);
+  });
+});
+
+describe("Mysql datasource", () => {
+  it("registers and constructs children", async () => {
+    expect(
+      await new Datasource("mysql", new MysqlDriver()).createConnection(),
+    ).toBeInstanceOf(MysqlConnection);
+    const of = (): IDriver => ({
+      connection: () => new MysqlConnection({ connect: async () => new FakeClient() }),
+      command: (c) => c.createCommand(),
+      transaction: (c, isolation = "readCommitted") =>
+        new MysqlTransaction(c as MysqlConnection, isolation),
+      rowTypeConverters: MysqlRowTypeConverters,
+      columnType,
+    });
+    const ds = new Datasource("mysql", of());
+    expect(ds.provider).toBe("mysql");
+    const connection = await ds.createConnection();
+    await (connection as MysqlConnection).open();
+    const command = await ds.createCommand(connection);
+    expect(command).toBeInstanceOf(MysqlCommand);
+    expect(command.connection).toBe(connection);
+    await command.execute("DELETE FROM items");
+    await command.executeReaderNative(new Native("SELECT 1"));
+    await expect(ds.createCommand()).rejects.toThrow("Connection is already open");
+    const repo = ds.createRepository(untyped(), connection);
+    expect(ds.createReadonlyRepository(untyped(), connection).constructor).toBe(ReadonlyRepository);
+    expect(repo).toBeInstanceOf(CRUDRepository);
+    expect(new Datasource("mysql", of()).createRepository(untyped())).toBeInstanceOf(CRUDRepository);
+    expect(Datasource.create({ PROVIDER: "mysql" }).provider).toBe("mysql");
+    expect(MysqlConnection.from({ DATASOURCE_URL: "mysql://db/app" }).url).toBe("mysql://db/app");
+    expect(MysqlConnection.from({ DATASOURCE_URL: "mysql://db/app" }).url).toBe("mysql://db/app");
+    expect(MysqlConnection.from().url).toBe("");
+    const provider = new MysqlDriver();
+    expect(provider.columnType("int")).toBe("INT");
+    expect(provider.columnType("uuid")).toBe("CHAR(36)");
+    expect(provider.columnType("string")).toBe("TEXT");
+    expect(provider.columnType("datetime")).toBe("TEXT");
+    expect(provider.columnType("bool")).toBe("TINYINT");
+    expect(provider.columnType("decimal")).toBe("DECIMAL(18,4)");
+    expect(provider.columnType("float")).toBe("DOUBLE");
+    expect(provider.columnType("binary")).toBe("BLOB");
+    expect(() => provider.columnType("xml")).toThrow('Unknown mysql type "xml"');
+    expect(provider.command(connection)).toBeInstanceOf(MysqlCommand);
+    expect(provider.transaction(connection as MysqlConnection).isolation).toBe("readCommitted");
+  });
+
+  it("maps property targets", () => {
+    const provider = new MysqlDriver();
+    const created = "2020-01-02T03:04:05.000Z";
+    const converter = RowTypeConverter.from(provider.rowTypeConverters, {
+      Key: "uuid",
+      Active: "bool",
+      Login: "string",
+      Created: "datetime",
+    });
+    const row = converter.convert({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: 1,
+      Login: "ada",
+      Created: created,
+    });
+    expect(row).toEqual({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: true,
+      Login: "ada",
+      Created: new Date(created),
+    });
+    expect(converter.reverseConvert(row)).toEqual({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: 1,
+      Login: "ada",
+      Created: "2020-01-02 03:04:05.000",
+    });
+  });
+});

package/src/transaction.ts

@@ -2,7 +2,7 @@ import {
   IsolationLevel,
   type ITransaction,
   type IsolationLevelName,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import type { MysqlConnection } from "./connection.ts";
 
 export class MysqlTransaction implements ITransaction {