@deterministic-code/datasources-mysql 0.0.0-stage → 0.1.1

package/src/connection.ts

@@ -0,0 +1,91 @@
+import {
+  DatasourceError,
+  IsolationLevel,
+  StatementTextRenderer,
+  type DatasourceOptions,
+  type ICommand,
+  type IConnection,
+  type IsolationLevelName,
+  type ITransaction,
+} from "@datasources/core";
+import { createRequire } from "node:module";
+import { MysqlCommand } from "./command.ts";
+import type { MysqlConnectionOptions } from "./connection-options.ts";
+import {
+  mysql2Connect,
+  type IMysqlClient,
+  type Mysql2Module,
+  type MysqlCreateConnection,
+} from "./i-mysql-engine.ts";
+import { MysqlStatementRenderer } from "./MysqlStatementRenderer.ts";
+import { MysqlTransaction } from "./transaction.ts";
+
+const require = createRequire(import.meta.url);
+
+const isoSql = (isolation: IsolationLevelName): string =>
+  isolation === IsolationLevel.ReadUncommitted
+    ? "READ UNCOMMITTED"
+    : isolation === IsolationLevel.ReadCommitted
+      ? "READ COMMITTED"
+      : "REPEATABLE READ";
+
+export class MysqlConnection implements IConnection {
+  readonly provider = "mysql";
+  url: string;
+  isOpen = false;
+  private client?: IMysqlClient;
+  private readonly connect?: MysqlCreateConnection;
+
+  static from = (options?: DatasourceOptions): MysqlConnection => {
+    const url = options?.DATASOURCE_URL ?? "";
+    return new MysqlConnection({
+      url,
+      connect: mysql2Connect(require("mysql2/promise") as Mysql2Module),
+    });
+  };
+
+  constructor(options: MysqlConnectionOptions = {}) {
+    this.url = options.url ?? "";
+    this.connect = options.connect;
+  }
+
+  createCommand = (): ICommand =>
+    new MysqlCommand(this, new StatementTextRenderer(t => new MysqlStatementRenderer(t)));
+
+  async open(): Promise<void> {
+    if (this.isOpen) throw new DatasourceError("Connection is already open");
+    if (!this.client) {
+      if (!this.connect) throw new DatasourceError("MySQL engine is required");
+      this.client = await this.connect(this.url);
+    }
+    await this.client.query("SET SESSION sql_mode = CONCAT(@@sql_mode, ',ANSI_QUOTES')");
+    this.isOpen = true;
+  }
+
+  async close(): Promise<void> {
+    await this.client?.end();
+    this.client = undefined;
+    this.isOpen = false;
+  }
+
+  [Symbol.asyncDispose] = (): Promise<void> => this.close();
+
+  async startTransaction(
+    isolation: IsolationLevelName = IsolationLevel.ReadCommitted,
+  ): Promise<ITransaction> {
+    this.ensureOpen();
+    const client = this.require();
+    await client.query(`SET TRANSACTION ISOLATION LEVEL ${isoSql(isolation)}`);
+    await client.beginTransaction();
+    return new MysqlTransaction(this, isolation);
+  }
+
+  ensureOpen(): void {
+    if (!this.isOpen) throw new DatasourceError("Connection is not open");
+  }
+
+  require(): IMysqlClient {
+    if (!this.client) throw new DatasourceError("Connection is not open");
+    return this.client;
+  }
+}

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

@@ -0,0 +1,9 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+
+const bytes = (value: Cell): Cell =>
+  typeof value === "string" ? Uint8Array.from(Buffer.from(value, "base64")) : value;
+
+export class BinaryConverter extends TypeConverter<Cell, Cell> {
+  convert = (from: Cell): Cell => bytes(from);
+  reverseConvert = (to: Cell): Cell => bytes(to);
+}

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

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

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

@@ -0,0 +1,15 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+
+const stamp = (date: Date): string =>
+  date.toISOString().replace("T", " ").replace("Z", "");
+
+export class DateTimeConverter extends TypeConverter<Cell, Cell> {
+  convert = (from: Cell): Cell =>
+    typeof from === "string" ? new Date(from) : from;
+  reverseConvert = (to: Cell): Cell =>
+    to instanceof Date
+      ? stamp(to)
+      : typeof to === "string" && /^\d{4}-\d{2}-\d{2}T/.test(to)
+        ? stamp(new Date(to))
+        : to;
+}

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

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

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

@@ -0,0 +1,25 @@
+import { type Cell, type TypeConverter } from "@datasources/core";
+import { BinaryConverter } from "./BinaryConverter.ts";
+import { BoolConverter } from "./BoolConverter.ts";
+import { DateTimeConverter } from "./DateTimeConverter.ts";
+import { DecimalConverter } from "./DecimalConverter.ts";
+import { UuidConverter } from "./UuidConverter.ts";
+
+export const MysqlRowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = {
+  bool: new BoolConverter(),
+  datetime: new DateTimeConverter(),
+  uuid: new UuidConverter(),
+  decimal: new DecimalConverter(),
+  binary: new BinaryConverter(),
+};
+
+export const reverse = (value: Cell): Cell =>
+  typeof value === "boolean"
+    ? MysqlRowTypeConverters.bool.reverseConvert(value)
+    : value instanceof Date
+      || (typeof value === "string" && /^\d{4}-\d{2}-\d{2}T/.test(value))
+      ? MysqlRowTypeConverters.datetime.reverseConvert(value)
+      : value instanceof Uint8Array
+        ? MysqlRowTypeConverters.binary.reverseConvert(value)
+        : value;
+

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

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

package/src/i-mysql-engine.ts

@@ -0,0 +1,58 @@
+import type { Parameter } from "@datasources/core";
+import type { Cells, Scalar } from "./scalar.ts";
+
+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>;
+}
+
+interface MysqlCoreQuery {
+  stream(): AsyncIterable<Cells>;
+}
+
+interface Mysql2PromiseConnection extends IMysqlClient {
+  connection: {
+    query(sql: string, params?: Record<string, Scalar>): MysqlCoreQuery;
+  };
+}
+
+export type MysqlCreateConnection = (url: string) => Promise<IMysqlClient>;
+
+export type Mysql2Module = {
+  createConnection: (
+    options: { uri: string; namedPlaceholders: boolean },
+  ) => Promise<IMysqlClient>;
+};
+
+export const mysql2Connect = (mysql: Mysql2Module): MysqlCreateConnection => async (uri: string) => {
+  const client = (await mysql.createConnection({
+    uri,
+    namedPlaceholders: true,
+  })) as Mysql2PromiseConnection;
+  return {
+    query: (sql, params) => client.query(sql, params),
+    queryRows: (sql, params) => client.connection.query(sql, params).stream(),
+    beginTransaction: () => client.beginTransaction(),
+    commit: () => client.commit(),
+    rollback: () => client.rollback(),
+    end: () => client.end(),
+  };
+};

package/src/index.ts

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

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/scalar.ts

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