@deterministic-code/datasources-mysql 0.1.1 → 0.1.2

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 "@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

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

package/src/connection.ts

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

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

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

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

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

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

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

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

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