@deterministic-code/datasources-mysql 0.1.0 → 0.1.2

package/dist/connection.js

@@ -0,0 +1,64 @@
+import { DatasourceError, IsolationLevel, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { createRequire } from "node:module";
+import { MysqlCommand } from "./command.js";
+import { mysql2Connect, } from "./i-mysql-engine.js";
+import { MysqlStatementRenderer } from "./MysqlStatementRenderer.js";
+import { MysqlTransaction } from "./transaction.js";
+const require = createRequire(import.meta.url);
+const isoSql = (isolation) => isolation === IsolationLevel.ReadUncommitted
+    ? "READ UNCOMMITTED"
+    : isolation === IsolationLevel.ReadCommitted
+        ? "READ COMMITTED"
+        : "REPEATABLE READ";
+export class MysqlConnection {
+    provider = "mysql";
+    url;
+    isOpen = false;
+    client;
+    connect;
+    static from = (options) => {
+        const url = options?.DATASOURCE_URL ?? "";
+        return new MysqlConnection({
+            url,
+            connect: mysql2Connect(require("mysql2/promise")),
+        });
+    };
+    constructor(options = {}) {
+        this.url = options.url ?? "";
+        this.connect = options.connect;
+    }
+    createCommand = () => new MysqlCommand(this, new StatementTextRenderer(t => new MysqlStatementRenderer(t)));
+    async open() {
+        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() {
+        await this.client?.end();
+        this.client = undefined;
+        this.isOpen = false;
+    }
+    [Symbol.asyncDispose] = () => this.close();
+    async startTransaction(isolation = IsolationLevel.Serializable) {
+        this.ensureOpen();
+        const client = this.require();
+        await client.query(`SET TRANSACTION ISOLATION LEVEL ${isoSql(isolation)}`);
+        await client.beginTransaction();
+        return new MysqlTransaction(this, isolation);
+    }
+    ensureOpen() {
+        if (!this.isOpen)
+            throw new DatasourceError("Connection is not open");
+    }
+    require() {
+        if (!this.client)
+            throw new DatasourceError("Connection is not open");
+        return this.client;
+    }
+}

package/dist/converters/BinaryConverter.d.ts

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

package/dist/converters/BinaryConverter.js

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

package/dist/converters/BoolConverter.d.ts

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

package/dist/converters/BoolConverter.js

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

package/dist/converters/DateTimeConverter.d.ts

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

package/dist/converters/DateTimeConverter.js

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

package/dist/converters/DecimalConverter.d.ts

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

package/dist/converters/DecimalConverter.js

@@ -0,0 +1,5 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export class DecimalConverter extends TypeConverter {
+    convert = (from) => from;
+    reverseConvert = (to) => typeof to === "number" ? String(to) : to;
+}

package/dist/converters/MysqlRowTypeConverters.d.ts

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

package/dist/converters/MysqlRowTypeConverters.js

@@ -0,0 +1,20 @@
+import { BinaryConverter } from "./BinaryConverter.js";
+import { BoolConverter } from "./BoolConverter.js";
+import { DateTimeConverter } from "./DateTimeConverter.js";
+import { DecimalConverter } from "./DecimalConverter.js";
+import { UuidConverter } from "./UuidConverter.js";
+export const MysqlRowTypeConverters = {
+    bool: new BoolConverter(),
+    datetime: new DateTimeConverter(),
+    uuid: new UuidConverter(),
+    decimal: new DecimalConverter(),
+    binary: new BinaryConverter(),
+};
+export const reverse = (value) => 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/dist/converters/UuidConverter.d.ts

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

package/dist/converters/UuidConverter.js

@@ -0,0 +1,5 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export class UuidConverter extends TypeConverter {
+    convert = (from) => from;
+    reverseConvert = (to) => to;
+}

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

@@ -0,0 +1,27 @@
+import type { Parameter } from "@deterministic-code/datasources";
+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/i-mysql-engine.js

@@ -0,0 +1,14 @@
+export const mysql2Connect = (mysql) => async (uri) => {
+    const client = (await mysql.createConnection({
+        uri,
+        namedPlaceholders: true,
+    }));
+    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/dist/index.d.ts

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

package/dist/index.js

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

package/dist/scalar.js

@@ -0,0 +1 @@
+export {};

package/dist/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@deterministic-code/datasources";
+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/dist/transaction.js

@@ -0,0 +1,15 @@
+import { IsolationLevel, } from "@deterministic-code/datasources";
+export class MysqlTransaction {
+    connection;
+    isolation;
+    constructor(connection, isolation = IsolationLevel.ReadCommitted) {
+        this.connection = connection;
+        this.isolation = isolation;
+    }
+    async commit() {
+        await this.connection.require().commit();
+    }
+    async abort() {
+        await this.connection.require().rollback();
+    }
+}

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "@deterministic-code/datasources-mysql",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.0",
+    "@deterministic-code/datasources": "^0.1.2",
     "mysql2": "^3.14.0"
   }
 }

package/src/MysqlBulkUpdateStatementTextRenderer.ts

@@ -1,10 +0,0 @@
-import { BulkUpdateStatementTextRenderer, type BulkUpdateStatement } from "@deterministic-code/datasources";
-
-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

@@ -1,12 +0,0 @@
-import { CreateTableStatementTextRenderer, type Column } from "@deterministic-code/datasources";
-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

@@ -1,54 +0,0 @@
-import {
-  DatasourceError,
-  StatementTextRenderer,
-  type Cell,
-  type DatasourceOptions,
-  type ICommand,
-  type IConnection,
-  type IDriver,
-  type Information,
-  type ITransaction,
-  type IsolationLevel,
-  type TypeConverter,
-} from "@deterministic-code/datasources";
-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.ts

@@ -1,34 +0,0 @@
-import {
-  BulkUpdateStatement,
-  CreateTableStatement,
-  SelectInsertedIdStatement,
-  SelectInsertedIdStatementTextRenderer,
-  StatementRenderer,
-  type StatementTextRenderer,
-} from "@deterministic-code/datasources";
-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

@@ -1,31 +0,0 @@
-import { parametersToRecord, type Cell, type Parameter } from "@deterministic-code/datasources";
-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

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

@@ -1,197 +0,0 @@
-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 "@deterministic-code/datasources";
-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

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