@deterministic-code/datasources-mysql 0.0.0-stage → 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,6 +1,25 @@
 {
   "name": "@deterministic-code/datasources-mysql",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "mysql2": "^3.14.0",
+    "@deterministic-code/datasources": "^0.1.1"
+  }
+}

package/src/MysqlBulkUpdateStatementTextRenderer.ts

@@ -0,0 +1,10 @@
+import { BulkUpdateStatementTextRenderer, type BulkUpdateStatement } from "@datasources/core";
+
+export class MysqlBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
+  override render = (statement: BulkUpdateStatement): string => {
+    const assigns = statement.set
+      .map((column) => `${statement.table}.${column} = data.${column}`)
+      .join(", ");
+    return `UPDATE ${statement.table} JOIN ${this.source(statement)} ON ${this.on(statement)} SET ${assigns}`;
+  };
+}

package/src/MysqlCreateTableStatementRenderer.ts

@@ -0,0 +1,12 @@
+import { CreateTableStatementTextRenderer, type Column } from "@datasources/core";
+import { columnTypes } from "./columnTypes.ts";
+
+export class MysqlCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+  protected typeName(column: Column): string {
+    return columnTypes[column.type] ?? column.type;
+  }
+
+  protected identity(column: Column): string {
+    return column.identity ? " AUTO_INCREMENT" : "";
+  }
+}

package/src/MysqlDriver.ts

@@ -0,0 +1,54 @@
+import {
+  DatasourceError,
+  StatementTextRenderer,
+  type Cell,
+  type DatasourceOptions,
+  type ICommand,
+  type IConnection,
+  type IDriver,
+  type Information,
+  type ITransaction,
+  type IsolationLevel,
+  type TypeConverter,
+} from "@datasources/core";
+import { MysqlConnection } from "./connection.ts";
+import { MysqlCommand } from "./command.ts";
+import { MysqlTransaction } from "./transaction.ts";
+import { MysqlRowTypeConverters } from "./converters/MysqlRowTypeConverters.ts";
+import { MysqlStatementRenderer } from "./MysqlStatementRenderer.ts";
+import { columnTypes } from "./columnTypes.ts";
+
+export { columnTypes };
+
+const statements = new StatementTextRenderer(t => new MysqlStatementRenderer(t));
+
+export class MysqlDriver implements IDriver {
+  readonly statementRenderer = statements;
+  readonly information: Information = {
+    descriptions: [
+      "MySQL / MariaDB server driver.",
+      "Full connection, command, transaction, and repository support.",
+    ],
+    overrides: [
+      "Overrides SelectInsertedIdStatement to SELECT LAST_INSERT_ID() AS {column}",
+      "Overrides CreateTableStatement identity to AUTO_INCREMENT",
+      "Overrides CreateTableStatement type mapping (int→INT, uuid→CHAR(36), string/datetime→TEXT, bool→TINYINT, decimal→DECIMAL(18,4), float→DOUBLE, binary→BLOB)",
+    ],
+    changeLogs: [],
+  };
+  rowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = MysqlRowTypeConverters;
+  columnType = (name: string): string =>
+    columnTypes[name] ??
+    (() => {
+      throw new DatasourceError(`Unknown mysql type "${name}"`);
+    })();
+  connection = (options?: DatasourceOptions): IConnection =>
+    MysqlConnection.from(options);
+  command = (connection: IConnection): ICommand =>
+    new MysqlCommand(connection as MysqlConnection, statements);
+  transaction = (
+    connection: IConnection,
+    isolation: IsolationLevel = "readCommitted",
+  ): ITransaction =>
+    new MysqlTransaction(connection as MysqlConnection, isolation);
+}

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

@@ -0,0 +1,34 @@
+import {
+  BulkUpdateStatement,
+  CreateTableStatement,
+  SelectInsertedIdStatement,
+  SelectInsertedIdStatementTextRenderer,
+  StatementRenderer,
+  type StatementTextRenderer,
+} from "@datasources/core";
+import { MysqlBulkUpdateStatementTextRenderer } from "./MysqlBulkUpdateStatementTextRenderer.ts";
+import { MysqlCreateTableStatementRenderer } from "./MysqlCreateTableStatementRenderer.ts";
+
+class MysqlSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
+  override render(statement: SelectInsertedIdStatement): string {
+    return `SELECT LAST_INSERT_ID() AS ${statement.column}`;
+  }
+}
+
+export class MysqlStatementRenderer extends StatementRenderer {
+  constructor(text: StatementTextRenderer) {
+    super(text);
+  }
+
+  protected override visitSelectInsertedId(inserted: SelectInsertedIdStatement): string {
+    return new MysqlSelectInsertedIdStatementTextRenderer().render(inserted);
+  }
+
+  protected override visitCreateTable(create: CreateTableStatement): string {
+    return new MysqlCreateTableStatementRenderer().render(create);
+  }
+
+  protected override visitBulkUpdate(update: BulkUpdateStatement): string {
+    return new MysqlBulkUpdateStatementTextRenderer().render(update);
+  }
+}

package/src/bind.ts

@@ -0,0 +1,31 @@
+import { parametersToRecord, type Cell, type Parameter } from "@datasources/core";
+import { reverse } from "./converters/MysqlRowTypeConverters.ts";
+import type { Scalar } from "./scalar.ts";
+
+const NAME = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
+const TOKEN = /\$[A-Za-z_][A-Za-z0-9_]*|'[^']*'|"[^"]*"|`[^`]*`|\b[A-Za-z_][A-Za-z0-9_]*\b/g;
+
+export const withoutReturning = (sql: string): string =>
+  sql.replace(/\s+RETURNING\b[^;]*$/i, "");
+
+const quoteReserved = (sql: string): string =>
+  sql.replace(TOKEN, (token, offset: number) => {
+    const skip = token.startsWith("$") || token.startsWith("'") || token.startsWith("\"") || token.startsWith("`");
+    const reserved = !skip && token.toLowerCase() === "key"
+      && !/\b(?:PRIMARY|FOREIGN|UNIQUE)\s+$/i.test(sql.slice(0, offset));
+    const mixed = !skip && /[A-Z]/.test(token) && /[a-z]/.test(token);
+    return reserved || mixed ? `\`${token}\`` : token;
+  });
+
+export const toMysql = (sql: string): string =>
+  quoteReserved(withoutReturning(sql)).replace(NAME, (_match, name: string) => `:${name}`);
+
+export const bindParameters = (
+  parameters?: Parameter[] | null,
+): Record<string, Scalar> => {
+  const record = parametersToRecord(parameters);
+  const bound: Record<string, Scalar> = {};
+  for (const [name, value] of Object.entries(record))
+    bound[name] = reverse(value as Cell) as Scalar;
+  return bound;
+};

package/src/columnTypes.ts

@@ -0,0 +1,10 @@
+export const columnTypes: Record<string, string> = {
+  int: "INT",
+  uuid: "CHAR(36)",
+  string: "TEXT",
+  datetime: "TEXT",
+  bool: "TINYINT",
+  decimal: "DECIMAL(18,4)",
+  float: "DOUBLE",
+  binary: "BLOB",
+};

package/src/command.ts

@@ -0,0 +1,197 @@
+import {
+  ArrayReader,
+  CommandMiddlewareHost,
+  FirstResultReader,
+  DatasourceError,
+  ExecuteStoredProcedureStatement,
+  Native,
+  ParameterDirection,
+  ReturnStatement,
+  SelectStatement,
+  StatementTextRenderer,
+  Response,
+  splitStatements,
+  statementParameters,
+  statementReader,
+  StreamingReader,
+  type Cells,
+  type ICommand,
+  type IReader,
+  type IStatement,
+  type Parameter,
+} from "@datasources/core";
+import { bindParameters, toMysql } from "./bind.ts";
+import type { MysqlConnection } from "./connection.ts";
+import type { MysqlExecuteResult } from "./i-mysql-engine.ts";
+import type { Scalar } from "./scalar.ts";
+import { MysqlStatementRenderer } from "./MysqlStatementRenderer.ts";
+
+const outputs = (parameters?: Parameter[]) =>
+  parameters?.filter(
+    (parameter) =>
+      parameter.direction && parameter.direction !== ParameterDirection.Input,
+  ) ?? [];
+
+export class MysqlCommand extends CommandMiddlewareHost implements ICommand {
+  private readonly statements: StatementTextRenderer;
+
+  constructor(readonly connection: MysqlConnection, statements?: StatementTextRenderer) {
+    super();
+    this.statements = statements ?? new StatementTextRenderer(t => new MysqlStatementRenderer(t));
+  }
+
+  async executeReaderNative(
+    text: Native,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> {
+    return this.run(text.text, parameters, async (query, params) => {
+      if (!query.trim()) return { value: new ArrayReader([]), rows: [] };
+      this.connection.ensureOpen();
+      const statements = splitStatements(query);
+      if (statements.length === 0) return { value: new ArrayReader([]), rows: [] };
+      const bound = bindParameters(params);
+      if (statements.some((sql) => /^\s*call\b/i.test(sql))) {
+        const sets: Cells[][] = [];
+        for (const sql of statements) sets.push(...(await this.callResults(sql, bound)));
+        return FirstResultReader.capture(resultSetsReader(sets));
+      }
+      return FirstResultReader.capture(statementReader(statements, (sql) => this.query(sql, bound)));
+    });
+  }
+
+  async executeReaderStatement(
+    statement: IStatement,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> {
+    return this.executeReaderNative(new Native(this.statements.render(statement)), parameters);
+  }
+
+  async executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
+    if (statement instanceof SelectStatement || statement instanceof ReturnStatement)
+      return this.firstCell(statement, parameters);
+    if (statement instanceof ExecuteStoredProcedureStatement && statement.name && outputs(parameters).length)
+      return this.executeProcedure(this.statements.render(statement), parameters);
+    return this.executeNative(new Native(this.statements.render(statement)), parameters);
+  }
+
+  private async firstCell(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
+    const reader = await this.executeReaderStatement(statement, parameters);
+    try {
+      if (!(await reader.next())) return new Response(null, 0, parameters);
+      const row = reader.current;
+      /* v8 ignore next */
+      if (!row) throw new DatasourceError("Reader current must be a row");
+      const values = Object.values(row);
+      return new Response(values.length === 0 ? null : values[0], 1, parameters);
+    } finally {
+      await reader.dispose();
+    }
+  }
+
+  async executeNative(text: Native, parameters?: Parameter[]): Promise<Response> {
+    return this.run(text.text, parameters, async (query, params) => {
+      if (!query.trim()) return { value: new Response(undefined, 0, params), rows: [] };
+      this.connection.ensureOpen();
+      const named = bindParameters(params);
+      let rowsAffected = 0;
+      let parameters = params;
+      let result: MysqlExecuteResult["result"];
+      for (const part of splitStatements(query)) {
+        const names = new Set(statementParameters(part));
+        const used = Object.fromEntries(
+          Object.entries(named).filter(([name]) => names.has(name.replace(/^[$:@]/, ""))),
+        );
+        const executed = await this.runSql(part, used, params);
+        rowsAffected += executed.rowsAffected;
+        parameters = executed.parameters ?? params;
+        result = executed.result;
+      }
+      return {
+        value: new Response(result, rowsAffected, parameters),
+        rows: [],
+      };
+    });
+  }
+
+  private async executeProcedure(sql: string, parameters?: Parameter[]): Promise<Response> {
+    return this.run(sql, parameters, async (query, params) => {
+      this.connection.ensureOpen();
+      const outs = outputs(params);
+      const client = this.connection.require();
+      for (const parameter of params!) {
+        if (
+          !parameter.direction ||
+          parameter.direction === ParameterDirection.Input ||
+          parameter.direction === ParameterDirection.InputOutput
+        )
+          await client.query(`SET @${parameter.name} = :${parameter.name}`, {
+            [parameter.name]: parameter.value ?? null,
+          });
+      }
+      await client.query(toMysql(query).replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, "@$1"));
+      const [rows] = await client.query(
+        `SELECT ${outs.map((parameter) => `@${parameter.name} AS \`${parameter.name}\``).join(", ")}`,
+      );
+      const row = Array.isArray(rows) ? (rows[0] as Cells | undefined) : undefined;
+      return {
+        value: new Response(
+          undefined,
+          0,
+          params?.map((parameter) =>
+            row && parameter.direction && parameter.direction !== ParameterDirection.Input
+              ? { ...parameter, value: cellValue(row[parameter.name]) }
+              : parameter,
+          ),
+        ),
+        rows: [],
+      };
+    });
+  }
+
+  private async runSql(
+    sql: string,
+    params?: Record<string, Scalar>,
+    parameters?: Parameter[],
+  ): Promise<MysqlExecuteResult> {
+    const [result] = await this.connection.require().query(toMysql(sql), params);
+    return Array.isArray(result)
+      ? { rowsAffected: result.length, parameters }
+      : { rowsAffected: result.affectedRows ?? 0, result: null, parameters };
+  }
+
+  private query(sql: string, params?: Record<string, Scalar>): AsyncIterable<Cells> {
+    return this.connection.require().queryRows(toMysql(sql), params);
+  }
+
+  private async callResults(sql: string, params?: Record<string, Scalar>): Promise<Cells[][]> {
+    const [result] = await this.connection.require().query(toMysql(sql), params);
+    if (!Array.isArray(result)) return [[]];
+    return result.filter((item): item is Cells[] => Array.isArray(item));
+  }
+}
+
+const cellValue = (cell: Scalar | object | undefined): Scalar => {
+  if (cell === null || cell === undefined) return null;
+  if (typeof cell === "string" || typeof cell === "number" || typeof cell === "boolean" || typeof cell === "bigint")
+    return cell;
+  if (cell instanceof Uint8Array) return new TextDecoder().decode(cell);
+  return JSON.stringify(cell);
+};
+
+const resultSetsReader = (sets: Cells[][]): StreamingReader => {
+  let set = 0;
+  let row = 0;
+  return new StreamingReader(
+    async () => {
+      const current = sets[set]?.[row];
+      if (current === undefined) return undefined;
+      row += 1;
+      return current;
+    },
+    async () => {
+      set += 1;
+      row = 0;
+      return set < sets.length;
+    },
+  );
+};

package/src/connection-options.ts

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