@deterministic-code/datasources-mysql 0.1.0 → 0.1.2

package/dist/MysqlAlterTableStatementRenderer.d.ts

@@ -0,0 +1,6 @@
+import { AlterTableStatementTextRenderer, type AlterAction, type Column } from "@deterministic-code/datasources";
+export declare class MysqlAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    protected typeName(column: Column): string;
+    protected identity(column: Column): string;
+    protected actionSql(action: AlterAction): string;
+}

package/dist/MysqlAlterTableStatementRenderer.js

@@ -0,0 +1,13 @@
+import { AlterTableStatementTextRenderer, } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+export class MysqlAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    typeName(column) {
+        return columnTypes[column.type] ?? column.type;
+    }
+    identity(column) {
+        return column.identity ? " AUTO_INCREMENT" : "";
+    }
+    actionSql(action) {
+        return action.kind === "alterColumn" ? `MODIFY COLUMN ${this.column(action.column)}` : super.actionSql(action);
+    }
+}

package/dist/MysqlBulkUpdateStatementTextRenderer.d.ts

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

package/dist/MysqlBulkUpdateStatementTextRenderer.js

@@ -0,0 +1,9 @@
+import { BulkUpdateStatementTextRenderer } from "@deterministic-code/datasources";
+export class MysqlBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
+    render = (statement) => {
+        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/dist/MysqlCreateRoutineStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { CreateRoutineStatementTextRenderer, type CreateRoutineStatement } from "@datasources/core";
+export declare class MysqlCreateRoutineStatementRenderer extends CreateRoutineStatementTextRenderer {
+    render(statement: CreateRoutineStatement): string;
+}

package/dist/MysqlCreateTableStatementRenderer.d.ts

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

package/dist/MysqlCreateTableStatementRenderer.js

@@ -0,0 +1,10 @@
+import { CreateTableStatementTextRenderer } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+export class MysqlCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    typeName(column) {
+        return columnTypes[column.type] ?? column.type;
+    }
+    identity(column) {
+        return column.identity ? " AUTO_INCREMENT" : "";
+    }
+}

package/dist/MysqlCreateTriggerStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { CreateTriggerStatementTextRenderer, type CreateTriggerStatement } from "@deterministic-code/datasources";
+export declare class MysqlCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
+    render(statement: CreateTriggerStatement): string;
+}

package/dist/MysqlCreateTriggerStatementRenderer.js

@@ -0,0 +1,7 @@
+import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+export class MysqlCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
+    render(statement) {
+        return `CREATE TRIGGER ${statement.name} BEFORE UPDATE ON ${statement.table}
+FOR EACH ROW SET NEW.${statement.updatedColumn} = ${statement.utcNow}`;
+    }
+}

package/dist/MysqlDriver.d.ts

@@ -0,0 +1,16 @@
+import { DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@deterministic-code/datasources";
+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>>;
+    readonly quoteLeft = "`";
+    readonly quoteRight = "`";
+    readonly typeConverter: DeterministicTypeConverter;
+    readonly defaultValueConverter: DefaultValueConverter;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/MysqlDriver.js

@@ -0,0 +1,76 @@
+import { DatasourceError, DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { MysqlConnection } from "./connection.js";
+import { MysqlCommand } from "./command.js";
+import { MysqlTransaction } from "./transaction.js";
+import { MysqlRowTypeConverters } from "./converters/MysqlRowTypeConverters.js";
+import { MysqlStatementRenderer } from "./MysqlStatementRenderer.js";
+import { columnTypes } from "./columnTypes.js";
+export { columnTypes };
+const statements = new StatementTextRenderer(t => new MysqlStatementRenderer(t));
+export class MysqlDriver {
+    statementRenderer = statements;
+    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)",
+            "Overrides CreateCreateStoredProcedureStatement to PROCEDURE Create{Plural}",
+            "Overrides CreateReadStoredProcedureStatement to PROCEDURE Read{Plural}By{Properties}",
+            "Overrides CreateUpdateStoredProcedureStatement to PROCEDURE Update{Plural}By{Properties}",
+            "Overrides CreateDeleteStoredProcedureStatement to PROCEDURE Delete{Plural}By{Properties}",
+            "Overrides CreateBulkCreateStoredProcedureStatement to PROCEDURE BulkCreate{Plural}",
+            "Overrides CreateBulkUpdateStoredProcedureStatement to PROCEDURE BulkUpdate{Plural}",
+            "Overrides CreateBulkDeleteStoredProcedureStatement to PROCEDURE BulkDelete{Plural}",
+        ],
+        changeLogs: [],
+    };
+    rowTypeConverters = MysqlRowTypeConverters;
+    quoteLeft = "`";
+    quoteRight = "`";
+    typeConverter = new DeterministicTypeConverter({
+        string: "TEXT",
+        character: "CHAR(1)",
+        number: "INT",
+        integer: "INT",
+        unsignedinteger: "INT UNSIGNED",
+        smallinteger: "SMALLINT",
+        unsignedsmallinteger: "SMALLINT UNSIGNED",
+        biginteger: "BIGINT",
+        unsignedbiginteger: "BIGINT UNSIGNED",
+        float: "DOUBLE",
+        decimal: "DECIMAL(10, 2)",
+        boolean: "TINYINT(1)",
+        datetime: "DATETIME(3)",
+        binary: "BLOB",
+        uuid: "CHAR(36)",
+        reference: "INT",
+    }, {
+        dialectName: "mysql",
+        stringUnlimited: "TEXT",
+        stringSized: (n) => (n <= 16383 ? `VARCHAR(${n})` : "LONGTEXT"),
+        character: "CHAR",
+        decimal: { kind: "optional", type: "DECIMAL", fallback: "DECIMAL(10, 2)" },
+        binaryUnlimited: "BLOB",
+        binarySized: (n) => (n <= 65535 ? `VARBINARY(${n})` : "LONGBLOB"),
+    });
+    defaultValueConverter = new DefaultValueConverter({
+        newId: () => `(UUID())`,
+        now: () => `(NOW(3))`,
+        utcNow: () => `(UTC_TIMESTAMP(3))`,
+        booleanOn: "1",
+        booleanOff: "0",
+        hex: (arg) => `X'${arg}'`,
+        hexReverse: /^X'(.*)'$/,
+    });
+    columnType = (name) => columnTypes[name] ??
+        (() => {
+            throw new DatasourceError(`Unknown mysql type "${name}"`);
+        })();
+    connection = (options) => MysqlConnection.from(options);
+    command = (connection) => new MysqlCommand(connection, statements);
+    transaction = (connection, isolation = "readCommitted") => new MysqlTransaction(connection, isolation);
+}

package/dist/MysqlDropIndexStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { DropIndexStatementTextRenderer, type DropIndexStatement } from "@deterministic-code/datasources";
+export declare class MysqlDropIndexStatementRenderer extends DropIndexStatementTextRenderer {
+    render(statement: DropIndexStatement): string;
+}

package/dist/MysqlDropIndexStatementRenderer.js

@@ -0,0 +1,6 @@
+import { DropIndexStatementTextRenderer } from "@deterministic-code/datasources";
+export class MysqlDropIndexStatementRenderer extends DropIndexStatementTextRenderer {
+    render(statement) {
+        return `DROP INDEX ${statement.name} ON ${statement.table}`;
+    }
+}

package/dist/MysqlDropRoutineStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { DropRoutineStatementTextRenderer, type DropRoutineStatement } from "@deterministic-code/datasources";
+export declare class MysqlDropRoutineStatementRenderer extends DropRoutineStatementTextRenderer {
+    render(statement: DropRoutineStatement): string;
+}

package/dist/MysqlDropRoutineStatementRenderer.js

@@ -0,0 +1,6 @@
+import { DropRoutineStatementTextRenderer } from "@deterministic-code/datasources";
+export class MysqlDropRoutineStatementRenderer extends DropRoutineStatementTextRenderer {
+    render(statement) {
+        return `DROP PROCEDURE IF EXISTS ${statement.name}`;
+    }
+}

package/dist/MysqlStatementRenderer.d.ts

@@ -0,0 +1,18 @@
+import { AlterTableStatement, BulkUpdateStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropIndexStatement, DropRoutineStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
+export declare class MysqlStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
+    protected visitCreateTable(create: CreateTableStatement): string;
+    protected visitAlterTable(alter: AlterTableStatement): string;
+    protected visitDropIndex(index: DropIndexStatement): string;
+    protected visitBulkUpdate(update: BulkUpdateStatement): string;
+    protected visitCreateTrigger(trigger: CreateTriggerStatement): string;
+    protected visitDropRoutine(routine: DropRoutineStatement): string;
+    protected visitCreateCreateStoredProcedureStatement(statement: CreateCreateStoredProcedureStatement): string;
+    protected visitCreateReadStoredProcedureStatement(statement: CreateReadStoredProcedureStatement): string;
+    protected visitCreateUpdateStoredProcedureStatement(statement: CreateUpdateStoredProcedureStatement): string;
+    protected visitCreateDeleteStoredProcedureStatement(statement: CreateDeleteStoredProcedureStatement): string;
+    protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;
+    protected visitCreateBulkUpdateStoredProcedureStatement(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    protected visitCreateBulkDeleteStoredProcedureStatement(statement: CreateBulkDeleteStoredProcedureStatement): string;
+}

package/dist/MysqlStatementRenderer.js

@@ -0,0 +1,60 @@
+import { SelectInsertedIdStatementTextRenderer, StatementRenderer, } from "@deterministic-code/datasources";
+import { MysqlAlterTableStatementRenderer } from "./MysqlAlterTableStatementRenderer.js";
+import { MysqlBulkUpdateStatementTextRenderer } from "./MysqlBulkUpdateStatementTextRenderer.js";
+import { MysqlCreateTableStatementRenderer } from "./MysqlCreateTableStatementRenderer.js";
+import { MysqlCreateTriggerStatementRenderer } from "./MysqlCreateTriggerStatementRenderer.js";
+import { MysqlDropIndexStatementRenderer } from "./MysqlDropIndexStatementRenderer.js";
+import { MysqlDropRoutineStatementRenderer } from "./MysqlDropRoutineStatementRenderer.js";
+import { MysqlStoredProcedureStatementRenderer } from "./MysqlStoredProcedureStatementRenderer.js";
+class MysqlSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
+    render(statement) {
+        return `SELECT LAST_INSERT_ID() AS ${statement.column}`;
+    }
+}
+export class MysqlStatementRenderer extends StatementRenderer {
+    constructor(text) {
+        super(text);
+    }
+    visitSelectInsertedId(inserted) {
+        return new MysqlSelectInsertedIdStatementTextRenderer().render(inserted);
+    }
+    visitCreateTable(create) {
+        return new MysqlCreateTableStatementRenderer().render(create);
+    }
+    visitAlterTable(alter) {
+        return new MysqlAlterTableStatementRenderer().renderAlter(alter);
+    }
+    visitDropIndex(index) {
+        return new MysqlDropIndexStatementRenderer().render(index);
+    }
+    visitBulkUpdate(update) {
+        return new MysqlBulkUpdateStatementTextRenderer().render(update);
+    }
+    visitCreateTrigger(trigger) {
+        return new MysqlCreateTriggerStatementRenderer().render(trigger);
+    }
+    visitDropRoutine(routine) {
+        return new MysqlDropRoutineStatementRenderer().render(routine);
+    }
+    visitCreateCreateStoredProcedureStatement(statement) {
+        return new MysqlStoredProcedureStatementRenderer().renderCreate(statement);
+    }
+    visitCreateReadStoredProcedureStatement(statement) {
+        return new MysqlStoredProcedureStatementRenderer().renderRead(statement);
+    }
+    visitCreateUpdateStoredProcedureStatement(statement) {
+        return new MysqlStoredProcedureStatementRenderer().renderUpdate(statement);
+    }
+    visitCreateDeleteStoredProcedureStatement(statement) {
+        return new MysqlStoredProcedureStatementRenderer().renderDelete(statement);
+    }
+    visitCreateBulkCreateStoredProcedureStatement(statement) {
+        return new MysqlStoredProcedureStatementRenderer().renderBulkCreate(statement);
+    }
+    visitCreateBulkUpdateStoredProcedureStatement(statement) {
+        return new MysqlStoredProcedureStatementRenderer().renderBulkUpdate(statement);
+    }
+    visitCreateBulkDeleteStoredProcedureStatement(statement) {
+        return new MysqlStoredProcedureStatementRenderer().renderBulkDelete(statement);
+    }
+}

package/dist/MysqlStoredProcedureStatementRenderer.d.ts

@@ -0,0 +1,10 @@
+import type { CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateUpdateStoredProcedureStatement } from "@deterministic-code/datasources";
+export declare class MysqlStoredProcedureStatementRenderer {
+    renderCreate(statement: CreateCreateStoredProcedureStatement): string;
+    renderRead(statement: CreateReadStoredProcedureStatement): string;
+    renderUpdate(statement: CreateUpdateStoredProcedureStatement): string;
+    renderDelete(statement: CreateDeleteStoredProcedureStatement): string;
+    renderBulkCreate(statement: CreateBulkCreateStoredProcedureStatement): string;
+    renderBulkUpdate(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    renderBulkDelete(statement: CreateBulkDeleteStoredProcedureStatement): string;
+}

package/dist/MysqlStoredProcedureStatementRenderer.js

@@ -0,0 +1,101 @@
+const params = (list) => list.map((p) => `  IN ${p.name} ${p.type}`).join(",\n");
+const where = (columns) => columns.map((c) => `t.${c} = ${c}`).join(" AND ");
+const jsonColumns = (columns) => columns.map((c) => `${c.name} ${c.type} PATH '$.${c.name}'`).join(", ");
+const procedure = (name, signature, body) => `DROP PROCEDURE IF EXISTS ${name};
+GO
+CREATE PROCEDURE ${name}(${signature})
+BEGIN
+${body}
+END;
+GO`;
+export class MysqlStoredProcedureStatementRenderer {
+    renderCreate(statement) {
+        const generated = statement.generatedKey;
+        const insertCols = generated ? statement.columns : statement.parameters.map((p) => p.name);
+        const vals = generated
+            ? statement.columns.map((c) => (c === statement.key ? "new_id" : c))
+            : statement.parameters.map((p) => p.name);
+        const body = generated
+            ? `  DECLARE new_id VARCHAR(36);
+  SET new_id = UUID();
+  INSERT INTO ${statement.table} (${insertCols.join(", ")})
+  VALUES (${vals.join(", ")});
+  SELECT new_id AS ${statement.key};`
+            : `  INSERT INTO ${statement.table} (${insertCols.join(", ")})
+  VALUES (${vals.join(", ")});
+  SELECT LAST_INSERT_ID() AS ${statement.key};`;
+        return procedure(statement.name, `\n${params(statement.parameters)}\n`, body);
+    }
+    renderRead(statement) {
+        const aliased = statement.columns.map((c) => `t.${c}`).join(", ");
+        if (statement.byProperties.length === 0) {
+            return procedure(statement.name, "", `  SELECT ${aliased} FROM ${statement.table} t ORDER BY t.${statement.key};`);
+        }
+        const signature = statement.byProperties
+            .map((c) => {
+            const type = statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType;
+            return `IN ${c} ${type}`;
+        })
+            .join(", ");
+        return procedure(statement.name, signature, `  SELECT ${aliased} FROM ${statement.table} t WHERE ${where(statement.byProperties)};`);
+    }
+    renderUpdate(statement) {
+        const sets = statement.writable.map((c) => `    t.${c}     = ${c}`);
+        if (statement.auditUpdated !== undefined) {
+            const auditParam = statement.parameters.find((p) => p.name.includes("new_updated"));
+            if (auditParam)
+                sets.push(`    t.${statement.auditUpdated} = ${auditParam.name}`);
+        }
+        const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
+        return procedure(statement.name, `\n${params(statement.parameters)}\n`, `  UPDATE ${statement.table} t
+  SET
+${sets.join(",\n")}
+  WHERE ${where(by)};
+  SELECT ROW_COUNT() AS affected;`);
+    }
+    renderDelete(statement) {
+        const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
+        const signature = by
+            .map((c) => {
+            const type = statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType;
+            return `IN ${c} ${type}`;
+        })
+            .join(", ");
+        return procedure(statement.name, signature, `  DELETE t FROM ${statement.table} t WHERE ${where(by)};
+  SELECT ROW_COUNT() AS affected;`);
+    }
+    renderBulkCreate(statement) {
+        const cols = statement.columns.map((c) => c.name).join(", ");
+        return procedure(statement.name, `IN ${statement.payload.name} ${statement.payload.type}, OUT ids JSON`, `  INSERT INTO ${statement.table} (${cols})
+  SELECT ${cols}
+  FROM JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (
+    ${jsonColumns(statement.columns)}
+  )) AS payload_rows;
+  GET DIAGNOSTICS @n = ROW_COUNT;
+  SET @first = LAST_INSERT_ID();
+  SET ids = JSON_ARRAY();
+  SET @i = 0;
+  WHILE @i < @n DO
+    SET ids = JSON_ARRAY_APPEND(ids, '$', @first + @i);
+    SET @i = @i + 1;
+  END WHILE;`);
+    }
+    renderBulkUpdate(statement) {
+        const sets = statement.columns
+            .filter((c) => c.name !== statement.key)
+            .map((c) => `c.${c.name} = payload_rows.${c.name}`)
+            .join(", ");
+        return procedure(statement.name, `IN ${statement.payload.name} ${statement.payload.type}`, `  UPDATE ${statement.table} c
+  JOIN JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (
+    ${jsonColumns(statement.columns)}
+  )) AS payload_rows ON c.${statement.key} = payload_rows.${statement.key}
+  SET ${sets};`);
+    }
+    renderBulkDelete(statement) {
+        const key = statement.columns.find((c) => c.name === statement.key) ?? {
+            name: statement.key,
+            type: statement.keyType,
+        };
+        return procedure(statement.name, `IN ${statement.payload.name} ${statement.payload.type}`, `  DELETE c FROM ${statement.table} c JOIN JSON_TABLE(${statement.payload.name}, '$[*]' COLUMNS (${key.name} ${key.type} PATH '$.${key.name}')) AS payload_rows ON c.${statement.key} = payload_rows.${statement.key};`);
+    }
+}

package/dist/bind.d.ts

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

@@ -0,0 +1,20 @@
+import { parametersToRecord } from "@deterministic-code/datasources";
+import { reverse } from "./converters/MysqlRowTypeConverters.js";
+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) => sql.replace(/\s+RETURNING\b[^;]*$/i, "");
+const quoteReserved = (sql) => sql.replace(TOKEN, (token, offset) => {
+    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) => quoteReserved(withoutReturning(sql)).replace(NAME, (_match, name) => `:${name}`);
+export const bindParameters = (parameters) => {
+    const record = parametersToRecord(parameters);
+    const bound = {};
+    for (const [name, value] of Object.entries(record))
+        bound[name] = reverse(value);
+    return bound;
+};

package/dist/columnTypes.d.ts

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

package/dist/columnTypes.js

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

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 "@deterministic-code/datasources";
+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/command.js

@@ -0,0 +1,143 @@
+import { ArrayReader, CommandMiddlewareHost, FirstResultReader, DatasourceError, ExecuteStoredProcedureStatement, Native, ParameterDirection, ReturnStatement, SelectStatement, StatementTextRenderer, Response, splitStatements, statementParameters, statementReader, StreamingReader, } from "@deterministic-code/datasources";
+import { bindParameters, toMysql } from "./bind.js";
+import { MysqlStatementRenderer } from "./MysqlStatementRenderer.js";
+const outputs = (parameters) => parameters?.filter((parameter) => parameter.direction && parameter.direction !== ParameterDirection.Input) ?? [];
+export class MysqlCommand extends CommandMiddlewareHost {
+    connection;
+    statements;
+    constructor(connection, statements) {
+        super();
+        this.connection = connection;
+        this.statements = statements ?? new StatementTextRenderer(t => new MysqlStatementRenderer(t));
+    }
+    async executeReaderNative(text, parameters) {
+        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 = [];
+                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, parameters) {
+        return this.executeReaderNative(new Native(this.statements.render(statement)), parameters);
+    }
+    async executeStatement(statement, parameters) {
+        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);
+    }
+    async firstCell(statement, parameters) {
+        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, parameters) {
+        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;
+            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: [],
+            };
+        });
+    }
+    async executeProcedure(sql, parameters) {
+        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] : 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: [],
+            };
+        });
+    }
+    async runSql(sql, params, parameters) {
+        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 };
+    }
+    query(sql, params) {
+        return this.connection.require().queryRows(toMysql(sql), params);
+    }
+    async callResults(sql, params) {
+        const [result] = await this.connection.require().query(toMysql(sql), params);
+        if (!Array.isArray(result))
+            return [[]];
+        return result.filter((item) => Array.isArray(item));
+    }
+}
+const cellValue = (cell) => {
+    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) => {
+    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/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-options.js

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

package/dist/connection.d.ts

@@ -0,0 +1,19 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@deterministic-code/datasources";
+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;
+}