@holo-js/db-mysql 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+import { PoolOptions } from 'mysql2/promise';
+
+interface DriverQueryResult<TRow extends Record<string, unknown> = Record<string, unknown>> {
+    rows: TRow[];
+    rowCount: number;
+}
+interface DriverExecutionResult {
+    affectedRows?: number;
+    lastInsertId?: number | string;
+}
+interface DriverAdapter {
+    initialize(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    runWithTransactionScope?<T>(callback: () => Promise<T>): Promise<T>;
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    createSavepoint?(name: string): Promise<void>;
+    rollbackToSavepoint?(name: string): Promise<void>;
+    releaseSavepoint?(name: string): Promise<void>;
+}
+interface MySQLQueryableLike {
+    query(sql: string, bindings?: readonly unknown[]): Promise<readonly [unknown, unknown]>;
+}
+interface MySQLClientLike extends MySQLQueryableLike {
+    release?(): void;
+    end?(): Promise<void>;
+}
+interface MySQLPoolLike extends MySQLQueryableLike {
+    getConnection(): Promise<MySQLClientLike>;
+    end(): Promise<void>;
+}
+interface MySQLAdapterOptions {
+    uri?: string;
+    config?: PoolOptions;
+    client?: MySQLClientLike;
+    pool?: MySQLPoolLike;
+    createPool?: (config: PoolOptions) => MySQLPoolLike;
+}
+declare class MySQLAdapter implements DriverAdapter {
+    private pool?;
+    private readonly directClient?;
+    private readonly createPoolInstance?;
+    private readonly config;
+    private connected;
+    private transactionClient?;
+    private leasedTransactionClient;
+    private readonly transactionScope;
+    constructor(options?: MySQLAdapterOptions);
+    initialize(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
+    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    createSavepoint(name: string): Promise<void>;
+    rollbackToSavepoint(name: string): Promise<void>;
+    releaseSavepoint(name: string): Promise<void>;
+    private getQueryable;
+    private leaseTransactionClient;
+    private requireTransactionClient;
+    private releaseTransactionClient;
+    private releaseScopedTransaction;
+    private normalizeSavepointName;
+}
+declare function createMySQLAdapter(options?: MySQLAdapterOptions): MySQLAdapter;
+
+export { type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, MySQLAdapter, type MySQLAdapterOptions, type MySQLClientLike, type MySQLPoolLike, type MySQLQueryableLike, createMySQLAdapter };

package/dist/index.mjs

@@ -0,0 +1,224 @@
+// src/index.ts
+import { AsyncLocalStorage } from "async_hooks";
+import mysql from "mysql2/promise";
+var TransactionError = class extends Error {
+};
+function toMutableBindings(bindings = []) {
+  return [...bindings];
+}
+function wrapMySQLClient(client) {
+  const rawClient = client;
+  return {
+    async query(sql, bindings = []) {
+      return rawClient.query(sql, toMutableBindings(bindings));
+    },
+    release: rawClient.release?.bind(rawClient),
+    end: rawClient.end?.bind(rawClient)
+  };
+}
+function wrapMySQLPool(pool) {
+  const rawPool = pool;
+  return {
+    async query(sql, bindings = []) {
+      return rawPool.query(sql, toMutableBindings(bindings));
+    },
+    async getConnection() {
+      return wrapMySQLClient(await rawPool.getConnection());
+    },
+    end: rawPool.end.bind(rawPool)
+  };
+}
+var MySQLAdapter = class {
+  pool;
+  directClient;
+  createPoolInstance;
+  config;
+  connected;
+  transactionClient;
+  leasedTransactionClient = false;
+  transactionScope = new AsyncLocalStorage();
+  constructor(options = {}) {
+    this.directClient = options.client ? wrapMySQLClient(options.client) : void 0;
+    this.pool = options.pool ? wrapMySQLPool(options.pool) : void 0;
+    this.createPoolInstance = options.createPool ?? (options.client || options.pool ? void 0 : (config) => wrapMySQLPool(mysql.createPool(config)));
+    this.config = options.config ?? (options.uri ? { uri: options.uri } : {});
+    this.connected = !!(options.client || options.pool);
+  }
+  async initialize() {
+    if (this.connected) {
+      return;
+    }
+    if (this.createPoolInstance) {
+      this.pool = this.createPoolInstance(this.config);
+    }
+    this.connected = true;
+  }
+  async disconnect() {
+    if (!this.connected) {
+      return;
+    }
+    if (this.transactionClient && this.leasedTransactionClient) {
+      this.transactionClient.release?.();
+      this.transactionClient = void 0;
+      this.leasedTransactionClient = false;
+    }
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = void 0;
+    } else if (this.directClient?.end) {
+      await this.directClient.end();
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async runWithTransactionScope(callback) {
+    const active = this.transactionScope.getStore();
+    if (active) {
+      return callback();
+    }
+    await this.initialize();
+    if (this.directClient) {
+      return this.transactionScope.run({
+        client: this.directClient,
+        leased: false,
+        released: false
+      }, callback);
+    }
+    if (!this.pool) {
+      throw new TransactionError("MySQL adapter is not initialized with a pool or client.");
+    }
+    const state = {
+      client: await this.pool.getConnection(),
+      leased: true,
+      released: false
+    };
+    return this.transactionScope.run(state, async () => {
+      try {
+        return await callback();
+      } finally {
+        this.releaseScopedTransaction(state);
+      }
+    });
+  }
+  async query(sql, bindings = []) {
+    const queryable = await this.getQueryable();
+    const [rows] = await queryable.query(sql, bindings);
+    const normalized = rows;
+    return {
+      rows: Array.isArray(normalized) ? [...normalized] : [],
+      rowCount: Array.isArray(normalized) ? normalized.length : 0
+    };
+  }
+  async introspect(sql, bindings = []) {
+    return this.query(sql, bindings);
+  }
+  async execute(sql, bindings = []) {
+    const queryable = await this.getQueryable();
+    const [result] = await queryable.query(sql, bindings);
+    const execution = result;
+    return {
+      affectedRows: typeof execution.affectedRows === "number" ? execution.affectedRows : 0,
+      lastInsertId: execution.insertId
+    };
+  }
+  async beginTransaction() {
+    const client = await this.leaseTransactionClient();
+    await client.query("START TRANSACTION");
+  }
+  async commit() {
+    const client = this.requireTransactionClient();
+    await client.query("COMMIT");
+    this.releaseTransactionClient();
+  }
+  async rollback() {
+    const client = this.requireTransactionClient();
+    await client.query("ROLLBACK");
+    this.releaseTransactionClient();
+  }
+  async createSavepoint(name) {
+    await this.requireTransactionClient().query(`SAVEPOINT ${this.normalizeSavepointName(name)}`);
+  }
+  async rollbackToSavepoint(name) {
+    await this.requireTransactionClient().query(`ROLLBACK TO SAVEPOINT ${this.normalizeSavepointName(name)}`);
+  }
+  async releaseSavepoint(name) {
+    await this.requireTransactionClient().query(`RELEASE SAVEPOINT ${this.normalizeSavepointName(name)}`);
+  }
+  async getQueryable() {
+    const scoped = this.transactionScope.getStore();
+    if (scoped) {
+      return scoped.client;
+    }
+    if (this.transactionClient) {
+      return this.transactionClient;
+    }
+    await this.initialize();
+    if (this.directClient) {
+      return this.directClient;
+    }
+    if (!this.pool) {
+      throw new TransactionError("MySQL adapter is not initialized with a pool or client.");
+    }
+    return this.pool;
+  }
+  async leaseTransactionClient() {
+    const scoped = this.transactionScope.getStore();
+    if (scoped) {
+      return scoped.client;
+    }
+    if (this.transactionClient) {
+      return this.transactionClient;
+    }
+    await this.initialize();
+    if (this.directClient) {
+      this.transactionClient = this.directClient;
+      this.leasedTransactionClient = false;
+      return this.transactionClient;
+    }
+    if (!this.pool) {
+      throw new TransactionError("MySQL adapter is not initialized with a pool or client.");
+    }
+    this.transactionClient = await this.pool.getConnection();
+    this.leasedTransactionClient = true;
+    return this.transactionClient;
+  }
+  requireTransactionClient() {
+    const scoped = this.transactionScope.getStore();
+    if (scoped) {
+      return scoped.client;
+    }
+    if (!this.transactionClient) {
+      throw new TransactionError("No active MySQL transaction client is available.");
+    }
+    return this.transactionClient;
+  }
+  releaseTransactionClient() {
+    if (this.transactionClient && this.leasedTransactionClient) {
+      this.transactionClient.release?.();
+    }
+    this.transactionClient = void 0;
+    this.leasedTransactionClient = false;
+  }
+  releaseScopedTransaction(state) {
+    if (!state.leased || state.released) {
+      return;
+    }
+    state.client.release?.();
+    state.released = true;
+  }
+  normalizeSavepointName(name) {
+    if (!/^[A-Z_]\w*$/i.test(name)) {
+      throw new TransactionError(`Invalid savepoint name "${name}".`);
+    }
+    return name;
+  }
+};
+function createMySQLAdapter(options = {}) {
+  return new MySQLAdapter(options);
+}
+export {
+  MySQLAdapter,
+  createMySQLAdapter
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@holo-js/db-mysql",
+  "version": "0.1.3",
+  "description": "Holo-JS Framework - MySQL database adapter",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "stub": "tsup --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run"
+  },
+  "peerDependencies": {
+    "@holo-js/db": "^0.1.3"
+  },
+  "dependencies": {
+    "mysql2": "^3.17.1"
+  },
+  "devDependencies": {
+    "@holo-js/db": "workspace:*",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}