@mountsqli/mysql 0.1.0

package/dist/chunk-CO3DMWOJ.js

@@ -0,0 +1,260 @@
+// src/mysql-core/dialect.ts
+import { Dialect, SQL } from "@mountsqli/core";
+var MysqlDialect = class extends Dialect {
+  dialect = "mysql";
+  escapeName(name) {
+    return `\`${name}\``;
+  }
+  escapeParam(index) {
+    return `?`;
+  }
+  buildSelectQuery(config) {
+    const parts = ["SELECT"];
+    if (config.distinct) parts.push("DISTINCT");
+    if (config.columns.length > 0) {
+      const colSqls = config.columns.map((col) => {
+        const tableName2 = col._.tableName || config.table?.[/* @__PURE__ */ Symbol.for("name")];
+        if (tableName2) {
+          return `${this.escapeName(tableName2)}.${this.escapeName(col.name)}`;
+        }
+        return this.escapeName(col.name);
+      });
+      parts.push(colSqls.join(", "));
+    } else {
+      parts.push("*");
+    }
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    parts.push(`FROM ${this.escapeName(tableName)}`);
+    if (config.joins) {
+      for (const join of config.joins) {
+        const joinTableName = join.table?.[/* @__PURE__ */ Symbol.for("name")];
+        const joinType = join.type.toUpperCase();
+        const onSql = join.on.toQuery(this.getBuildQueryConfig()).sql;
+        parts.push(`${joinType} JOIN ${this.escapeName(joinTableName)} ON ${onSql}`);
+      }
+    }
+    if (config.where) {
+      parts.push(`WHERE ${config.where.toQuery(this.getBuildQueryConfig()).sql}`);
+    }
+    if (config.groupBy && config.groupBy.length > 0) {
+      parts.push(`GROUP BY ${config.groupBy.map((g) => g.toQuery(this.getBuildQueryConfig()).sql).join(", ")}`);
+    }
+    if (config.having) {
+      parts.push(`HAVING ${config.having.toQuery(this.getBuildQueryConfig()).sql}`);
+    }
+    if (config.orderBy && config.orderBy.length > 0) {
+      parts.push(`ORDER BY ${config.orderBy.map((o) => o.toQuery(this.getBuildQueryConfig()).sql).join(", ")}`);
+    }
+    if (config.limit !== void 0) parts.push(`LIMIT ${config.limit}`);
+    if (config.offset !== void 0) parts.push(`OFFSET ${config.offset}`);
+    return new SQL([parts.join(" ")]);
+  }
+  buildInsertQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const columns = Object.keys(config.values[0] ?? {});
+    const escapedCols = columns.map((c) => this.escapeName(c));
+    const placeholders = columns.map(() => "?");
+    let sql = `INSERT INTO ${this.escapeName(tableName)} (${escapedCols.join(", ")}) VALUES (${placeholders.join(", ")})`;
+    if (config.onConflict) {
+      sql += ` ${config.onConflict.toQuery(this.getBuildQueryConfig()).sql}`;
+    }
+    const params = [];
+    for (const row of config.values) {
+      for (const col of columns) {
+        params.push(row[col]);
+      }
+    }
+    return new SQL([sql]);
+  }
+  buildUpdateQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const setClauses = Object.keys(config.set).map((k) => `${this.escapeName(k)} = ?`);
+    let sql = `UPDATE ${this.escapeName(tableName)} SET ${setClauses.join(", ")}`;
+    if (config.where) {
+      sql += ` WHERE ${config.where.toQuery(this.getBuildQueryConfig()).sql}`;
+    }
+    return new SQL([sql]);
+  }
+  buildDeleteQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    let sql = `DELETE FROM ${this.escapeName(tableName)}`;
+    if (config.where) {
+      sql += ` WHERE ${config.where.toQuery(this.getBuildQueryConfig()).sql}`;
+    }
+    return new SQL([sql]);
+  }
+  buildCreateTable(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const ifNotExists = config.ifNotExists ? " IF NOT EXISTS" : "";
+    const columns = config.table.getSQLColumns();
+    const colDefs = Object.values(columns).map(
+      (col) => `  ${this.escapeName(col.name)} ${col.sqlType}`
+    );
+    const pkCols = [];
+    for (const [, col] of Object.entries(config.table.columns)) {
+      if (col.isPrimaryKey) pkCols.push(this.escapeName(col.name));
+    }
+    if (pkCols.length > 0) colDefs.push(`  PRIMARY KEY (${pkCols.join(", ")})`);
+    return new SQL([`CREATE TABLE${ifNotExists} ${this.escapeName(tableName)} (
+${colDefs.join(",\n")}
+)`]);
+  }
+  buildDropTable(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const ifExists = config.ifExists ? " IF EXISTS" : "";
+    return new SQL([`DROP TABLE${ifExists} ${this.escapeName(tableName)}`]);
+  }
+  buildCreateIndex(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const unique = config.unique ? "UNIQUE " : "";
+    const colNames = config.columns.map((c) => this.escapeName(c.name)).join(", ");
+    return new SQL([`CREATE ${unique}INDEX ${this.escapeName(config.name)} ON ${this.escapeName(tableName)} (${colNames})`]);
+  }
+};
+
+// src/mysql-core/session.ts
+import { Session } from "@mountsqli/core";
+var MysqlPreparedQuery = class {
+  _query;
+  _pool;
+  constructor(pool, query) {
+    this._query = query;
+    this._pool = pool;
+  }
+  async execute() {
+    return this._pool.execute(this._query.sql, this._query.params);
+  }
+  async all() {
+    const [rows] = await this._pool.execute(this._query.sql, this._query.params);
+    return rows;
+  }
+  async values() {
+    const [rows] = await this._pool.execute(this._query.sql, this._query.params);
+    return rows.map((row) => Object.values(row));
+  }
+  getQuery() {
+    return this._query;
+  }
+};
+var MysqlTransaction = class _MysqlTransaction extends Session {
+  _conn;
+  constructor(conn, logger) {
+    super(logger);
+    this._conn = conn;
+    this.inTransaction = true;
+  }
+  async execute(query) {
+    const [rows] = await this._conn.execute(query.sql, query.params);
+    return rows;
+  }
+  prepare(query) {
+    return new MysqlPreparedQuery({ execute: this._conn.execute.bind(this._conn) }, query);
+  }
+  async transaction(fn) {
+    await this._conn.beginTransaction();
+    const tx = new _MysqlTransaction(this._conn, this.logger);
+    try {
+      const result = await fn(tx);
+      await this._conn.commit();
+      return result;
+    } catch (err) {
+      await this._conn.rollback();
+      throw err;
+    }
+  }
+  async rollback() {
+    await this._conn.rollback();
+    throw new Error("Transaction rolled back");
+  }
+  async commit() {
+    await this._conn.commit();
+  }
+  async setTransactionIsolation(level) {
+    await this._conn.execute(`SET TRANSACTION ISOLATION LEVEL ${level.toUpperCase()}`);
+  }
+  async dispose() {
+    this._conn.release();
+  }
+};
+var MysqlSession = class extends Session {
+  _pool;
+  constructor(pool, logger) {
+    super(logger);
+    this._pool = pool;
+  }
+  async execute(query) {
+    const [rows] = await this._pool.execute(query.sql, query.params);
+    return rows;
+  }
+  prepare(query) {
+    return new MysqlPreparedQuery(this._pool, query);
+  }
+  async transaction(fn, config) {
+    const conn = await this._pool.getConnection();
+    try {
+      if (config?.isolationLevel) {
+        await conn.execute(`SET TRANSACTION ISOLATION LEVEL ${config.isolationLevel.toUpperCase()}`);
+      }
+      await conn.beginTransaction();
+      this.inTransaction = true;
+      const tx = new MysqlTransaction(conn, this.logger);
+      const result = await fn(tx);
+      await conn.commit();
+      return result;
+    } catch (err) {
+      await conn.rollback();
+      throw err;
+    } finally {
+      conn.release();
+    }
+  }
+  async dispose() {
+    await this._pool.end();
+  }
+};
+
+// src/drivers/mysql2/driver.ts
+import { createLogger } from "@mountsqli/core";
+var Mysql2Driver = class {
+  dialect = "mysql";
+  _config;
+  _pool = null;
+  _logger;
+  constructor(config) {
+    this._config = config;
+    this._logger = typeof config.logger === "boolean" ? createLogger({ enabled: config.logger }) : config.logger ?? createLogger({ enabled: false });
+  }
+  createSession() {
+    if (!this._pool) throw new Error("Not connected");
+    return new MysqlSession(this._pool, this._logger);
+  }
+  async connect() {
+    const mysql = await import("mysql2/promise");
+    if (typeof this._config.connection === "string") {
+      this._pool = await mysql.createPool(this._config.connection);
+    } else {
+      this._pool = await mysql.createPool(this._config.connection);
+    }
+  }
+  async disconnect() {
+    if (this._pool) {
+      await this._pool.end();
+      this._pool = null;
+    }
+  }
+  async ping() {
+    try {
+      await this._pool?.execute("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+export {
+  MysqlDialect,
+  MysqlTransaction,
+  MysqlSession,
+  Mysql2Driver
+};

package/dist/driver-BNL3tH8k.d.ts

@@ -0,0 +1,61 @@
+import { Session, Logger, QueryWithTypings, PreparedQuery, TransactionConfig, Driver } from '@mountsqli/core';
+
+/**
+ * MySQL session — wraps mysql2 connection/pool.
+ */
+
+interface MysqlPool {
+    execute(sql: string, params?: any[]): Promise<[any[], any]>;
+    query(sql: string, params?: any[]): Promise<[any[], any]>;
+    getConnection(): Promise<MysqlConnection>;
+    end(): Promise<void>;
+}
+interface MysqlConnection {
+    execute(sql: string, params?: any[]): Promise<[any[], any]>;
+    query(sql: string, params?: any[]): Promise<[any[], any]>;
+    release(): void;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+declare class MysqlTransaction extends Session {
+    private _conn;
+    constructor(conn: MysqlConnection, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    rollback(): Promise<never>;
+    commit(): Promise<void>;
+    setTransactionIsolation(level: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare class MysqlSession extends Session {
+    private _pool;
+    constructor(pool: MysqlPool, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>, config?: TransactionConfig): Promise<T>;
+    dispose(): Promise<void>;
+}
+
+/**
+ * mysql2 driver.
+ */
+
+interface Mysql2DriverConfig {
+    connection: string | Record<string, any>;
+    logger?: Logger | boolean;
+}
+declare class Mysql2Driver implements Driver {
+    readonly dialect: "mysql";
+    private _config;
+    private _pool;
+    private _logger;
+    constructor(config: Mysql2DriverConfig);
+    createSession(): MysqlSession;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ping(): Promise<boolean>;
+}
+
+export { type Mysql2DriverConfig as M, Mysql2Driver as a, MysqlSession as b, MysqlTransaction as c };

package/dist/drivers/mysql2/index.d.ts

@@ -0,0 +1,11 @@
+import { DatabaseConfig, Database } from '@mountsqli/core';
+import { M as Mysql2DriverConfig } from '../../driver-BNL3tH8k.js';
+export { a as Mysql2Driver } from '../../driver-BNL3tH8k.js';
+
+/**
+ * mysql2 driver entry point.
+ */
+
+declare function mountsqli(connectionOrConfig: string | Mysql2DriverConfig, options?: DatabaseConfig): Database;
+
+export { Mysql2DriverConfig, mountsqli };

package/dist/drivers/mysql2/index.js

@@ -0,0 +1,19 @@
+import {
+  Mysql2Driver,
+  MysqlDialect
+} from "../../chunk-CO3DMWOJ.js";
+
+// src/drivers/mysql2/index.ts
+import { Database, createLogger } from "@mountsqli/core";
+function mountsqli(connectionOrConfig, options) {
+  const logger = typeof options?.logger === "boolean" ? createLogger({ enabled: options.logger }) : options?.logger ?? createLogger({ enabled: false });
+  const driverConfig = typeof connectionOrConfig === "string" ? { connection: connectionOrConfig, logger } : { ...connectionOrConfig, logger };
+  const driver = new Mysql2Driver(driverConfig);
+  const dialect = new MysqlDialect();
+  const session = driver.createSession();
+  return new Database(session, dialect, { ...options, logger });
+}
+export {
+  Mysql2Driver,
+  mountsqli
+};

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { Table, TableConfig, Column, Dialect, AnyColumn, SQL } from '@mountsqli/core';
+export { a as Mysql2Driver, b as MysqlSession, c as MysqlTransaction } from './driver-BNL3tH8k.js';
+
+/**
+ * MySQL table factory.
+ */
+
+declare class MysqlTable extends Table<TableConfig & {
+    dialect: 'mysql';
+}> {
+}
+type MysqlTableColumns = Record<string, Column>;
+declare function mysqlTable<TColumns extends MysqlTableColumns>(name: string, columns: TColumns, config?: {
+    schema?: string;
+}): MysqlTable & {
+    columns: TColumns;
+};
+
+/**
+ * MySQL dialect — SQL generation for MySQL.
+ */
+
+declare class MysqlDialect extends Dialect {
+    readonly dialect: "mysql";
+    escapeName(name: string): string;
+    escapeParam(index: number): string;
+    buildSelectQuery(config: {
+        table: Table;
+        columns: AnyColumn[];
+        where?: SQL;
+        orderBy?: SQL[];
+        groupBy?: SQL[];
+        having?: SQL;
+        limit?: number;
+        offset?: number;
+        joins?: Array<{
+            table: Table;
+            on: SQL;
+            type: 'inner' | 'left' | 'right' | 'full';
+        }>;
+        distinct?: boolean;
+    }): SQL;
+    buildInsertQuery(config: {
+        table: Table;
+        values: Record<string, unknown>[];
+        onConflict?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildUpdateQuery(config: {
+        table: Table;
+        set: Record<string, unknown>;
+        where?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildDeleteQuery(config: {
+        table: Table;
+        where?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildCreateTable(config: {
+        table: Table;
+        ifNotExists?: boolean;
+    }): SQL;
+    buildDropTable(config: {
+        table: Table;
+        ifExists?: boolean;
+    }): SQL;
+    buildCreateIndex(config: {
+        name: string;
+        table: Table;
+        columns: AnyColumn[];
+        unique?: boolean;
+        concurrently?: boolean;
+    }): SQL;
+}
+
+export { MysqlDialect, MysqlTable, type MysqlTableColumns, mysqlTable };

package/dist/index.js

@@ -0,0 +1,28 @@
+import {
+  Mysql2Driver,
+  MysqlDialect,
+  MysqlSession,
+  MysqlTransaction
+} from "./chunk-CO3DMWOJ.js";
+
+// src/mysql-core/table.ts
+import { Table } from "@mountsqli/core";
+var MysqlTable = class extends Table {
+};
+function mysqlTable(name, columns, config) {
+  const table = new MysqlTable(name, config?.schema, name);
+  for (const [key, col] of Object.entries(columns)) {
+    table.columns[key] = col;
+    col.tableName = name;
+  }
+  const result = table;
+  result.columns = columns;
+  return result;
+}
+export {
+  Mysql2Driver,
+  MysqlDialect,
+  MysqlSession,
+  MysqlTransaction,
+  mysqlTable
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mountsqli/mysql",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./mysql2": {
+      "import": "./dist/drivers/mysql2/index.js",
+      "types": "./dist/drivers/mysql2/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist", "LICENSE", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts src/drivers/mysql2/index.ts --format esm --dts --clean",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@mountsqli/core": "workspace:*",
+    "@mountsqli/shared": "workspace:*"
+  },
+  "peerDependencies": {
+    "mysql2": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mysql2": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "tsup": "^8.0.0",
+    "vitest": "^3.0.0"
+  }
+}