@rx-ted/packages-honest-plugins 1.0.1

package/db/src/mysql/driver.ts

@@ -0,0 +1,116 @@
+import type { Pool } from 'mysql2/promise';
+import type { Logger } from '@rx-ted/packages-core';
+import type { DatabaseClient, DatabaseConnection, DatabaseDriver, QueryResult } from '../types';
+import { createMysqlClient, MysqlDatabaseClient } from './client';
+
+export async function createMysqlDriver(options: {
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  database: string;
+  ssl?: boolean | { rejectUnauthorized?: boolean; ca?: string; cert?: string; key?: string };
+  logger?: Logger;
+  pool?: Pool;
+}): Promise<DatabaseDriver> {
+  const logger = options.logger;
+  if (logger)
+    logger.debug(
+      { host: options.host, port: options.port, database: options.database },
+      'MySQL: connecting',
+    );
+  const client = options.pool
+    ? new MysqlDatabaseClient(options.pool)
+    : await createMysqlClient(options);
+  if (logger) logger.info('MySQL: connected');
+  return new MysqlDriver(client, logger);
+}
+
+class MysqlDriver implements DatabaseDriver {
+  constructor(
+    private client: DatabaseClient,
+    private logger?: Logger,
+  ) {}
+  async query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]> {
+    if (this.logger) this.logger.debug({ sql: sql.substring(0, 100), params }, 'MySQL: query');
+    const conn = await this.client.getConnection();
+    const result = await conn.query<T>(sql, params);
+    conn.release();
+    if (this.logger) this.logger.debug({ rows: result.length }, 'MySQL: result');
+    return result;
+  }
+  async execute(sql: string, params?: unknown[]): Promise<QueryResult> {
+    if (this.logger) this.logger.debug({ sql: sql.substring(0, 100), params }, 'MySQL: execute');
+    const conn = await this.client.getConnection();
+    const stmt = conn.prepare(sql);
+    const result = await stmt.execute(params);
+    stmt.release();
+    conn.release();
+    if (this.logger)
+      this.logger.debug(
+        { affectedRows: result.affectedRows, insertId: result.insertId },
+        'MySQL: executed',
+      );
+    return {
+      affectedRows: result.affectedRows,
+      insertId: result.insertId ? Number(result.insertId) : undefined,
+    };
+  }
+  async transaction<T>(fn: (driver: DatabaseDriver) => Promise<T>): Promise<T> {
+    const conn = await this.client.getConnection();
+    await conn.query('SET autocommit = 0');
+    await conn.query('START TRANSACTION');
+    const txDriver = new TransactionalMysqlDriver(conn, this.logger);
+    try {
+      const result = await fn(txDriver);
+      await conn.query('COMMIT');
+      await conn.query('SET autocommit = 1');
+      if (this.logger) this.logger.debug('MySQL: transaction committed');
+      return result;
+    } catch (error) {
+      await conn.query('ROLLBACK');
+      await conn.query('SET autocommit = 1');
+      if (this.logger) this.logger.error({ error }, 'MySQL: transaction rolled back');
+      throw error;
+    } finally {
+      conn.release();
+    }
+  }
+  async close(): Promise<void> {
+    await this.client.close();
+    if (this.logger) this.logger.info('MySQL: closed');
+  }
+  async healthCheck(): Promise<boolean> {
+    try {
+      const conn = await this.client.getConnection();
+      await conn.query('SELECT 1');
+      conn.release();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+class TransactionalMysqlDriver implements DatabaseDriver {
+  constructor(
+    private connection: DatabaseConnection,
+    _logger?: Logger,
+  ) {}
+  async query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]> {
+    return this.connection.query<T>(sql, params);
+  }
+  async execute(sql: string, params?: unknown[]): Promise<QueryResult> {
+    const stmt = this.connection.prepare(sql);
+    const result = await stmt.execute(params);
+    stmt.release();
+    return result;
+  }
+  async transaction<T>(_fn: (driver: DatabaseDriver) => Promise<T>): Promise<T> {
+    throw new Error('Nested transactions are not supported');
+  }
+  async close(): Promise<void> {}
+  async healthCheck(): Promise<boolean> {
+    return true;
+  }
+}

package/db/src/mysql/index.ts

@@ -0,0 +1,51 @@
+// Plugin
+export {
+  MysqlPlugin,
+  DRIZZLE_GLOBAL_KEY,
+  DB_CONTEXT_KEY,
+  DRIZZLE_CONTEXT_KEY,
+  MYSQL_CONTEXT_KEY,
+  POOL_CONTEXT_KEY,
+} from './plugin';
+export type { MysqlPluginOptions } from './plugin';
+
+// Global key
+export { DB_GLOBAL_KEY } from '../constants';
+
+// Raw driver
+export { createMysqlDriver } from './driver';
+export { createMysqlPool, createMysqlClient, MysqlDatabaseClient } from './client';
+export type { MysqlClientOptions } from './types';
+
+// MySQL-specific types
+export type {
+  DatabaseOptions,
+  SslOptions,
+  DriverOptions,
+  DatabaseDriverOptions,
+} from './types';
+
+// ── Drizzle ORM re-exports ──
+export {
+  mysqlTable,
+  varchar,
+  int,
+  bigint,
+  char,
+  text,
+  longtext,
+  date,
+  datetime,
+  timestamp,
+  boolean,
+  json,
+  mysqlEnum,
+  uniqueIndex,
+  index,
+  primaryKey,
+  foreignKey,
+} from 'drizzle-orm/mysql-core';
+
+export type { MySql2Database } from 'drizzle-orm/mysql2';
+export { drizzle } from 'drizzle-orm/mysql2';
+export * as drizzleORM from 'drizzle-orm';

package/db/src/mysql/plugin.test.ts

@@ -0,0 +1,228 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MysqlPlugin } from './plugin';
+import type { Application } from '@rx-ted/packages-honest';
+
+vi.mock('@rx-ted/packages-honest', () => ({
+  ComponentManager: {
+    registerPlugin: vi.fn(),
+    getPlugin: vi.fn().mockReturnValue({ platform: 'node' }),
+    hasPlugin: vi.fn(),
+  },
+  resolvePluginLogger: vi.fn().mockReturnValue({
+    child: vi.fn().mockReturnThis(),
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  }),
+  LOGGER_SYMBOL: Symbol('logger'),
+}));
+
+vi.mock('./client', () => ({
+  createMysqlPool: vi.fn().mockReturnValue({ end: vi.fn() }),
+  createMysqlClient: vi.fn(),
+  MysqlDatabaseClient: class {
+    constructor(public pool: any) {}
+    prepare = vi.fn();
+    getConnection = vi.fn();
+    close = vi.fn();
+  },
+}));
+
+vi.mock('./driver', () => ({
+  createMysqlDriver: vi.fn().mockResolvedValue({
+    query: vi.fn(),
+    execute: vi.fn(),
+    transaction: vi.fn(),
+    close: vi.fn(),
+    healthCheck: vi.fn().mockResolvedValue(true),
+  }),
+}));
+
+vi.mock('drizzle-orm/mysql2', () => ({
+  drizzle: vi.fn().mockReturnValue({ _: 'drizzle-instance' }),
+}));
+
+import { ComponentManager } from '@rx-ted/packages-honest';
+import { createMysqlPool } from './client';
+import { createMysqlDriver } from './driver';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { DB_GLOBAL_KEY } from '../constants';
+
+function createMockApp(): Application {
+  const ctx = new Map<string, any>();
+  return {
+    getContext: vi.fn().mockReturnValue({
+      set: vi.fn((key: string, value: any) => {
+        ctx.set(key, value);
+      }),
+      get: vi.fn((key: string) => ctx.get(key)),
+    }),
+  } as unknown as Application;
+}
+
+describe('MysqlPlugin', () => {
+  let plugin: MysqlPlugin;
+  let mockApp: Application;
+
+  const defaultOptions = {
+    connection: {
+      host: 'localhost',
+      port: 3306,
+      user: 'root',
+      password: 'secret',
+      database: 'test',
+    },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    plugin = new MysqlPlugin(defaultOptions);
+    mockApp = createMockApp();
+  });
+
+  describe('construction', () => {
+    it('sets name and version', () => {
+      expect(plugin.name).toBe('mysql-plugin');
+      expect(plugin.version).toBe('1.0.0');
+    });
+
+    it('has static globalKey', () => {
+      expect(MysqlPlugin.globalKey).toBe(DB_GLOBAL_KEY);
+    });
+
+    it('implements IPlugin', () => {
+      expect(typeof plugin.beforeModulesRegistered).toBe('function');
+      expect(typeof plugin.afterModulesRegistered).toBe('function');
+      expect(typeof plugin.close).toBe('function');
+    });
+  });
+
+  describe('beforeModulesRegistered', () => {
+    it('creates pool, driver, and drizzle instance', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      expect(createMysqlPool).toHaveBeenCalledWith({
+        host: 'localhost',
+        port: 3306,
+        user: 'root',
+        password: 'secret',
+        database: 'test',
+      });
+      expect(createMysqlDriver).toHaveBeenCalled();
+      expect(drizzle).toHaveBeenCalled();
+    });
+
+    it('registers the drizzle instance in ComponentManager', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      expect(ComponentManager.registerPlugin).toHaveBeenCalledWith(
+        DB_GLOBAL_KEY,
+        expect.objectContaining({ _: 'drizzle-instance' }),
+      );
+    });
+
+    it('stores pool, driver and drizzle in app context', async () => {
+      const ctx = { set: vi.fn() };
+      (mockApp.getContext as any).mockReturnValue(ctx);
+
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      expect(ctx.set).toHaveBeenCalledWith('honest:mysql:pool', expect.any(Object));
+      expect(ctx.set).toHaveBeenCalledWith('honest:mysql', expect.any(Object));
+      expect(ctx.set).toHaveBeenCalledWith('context:db', expect.any(Object));
+    });
+
+    it('uses custom contextKey if provided', async () => {
+      const ctx = { set: vi.fn() };
+      (mockApp.getContext as any).mockReturnValue(ctx);
+      plugin = new MysqlPlugin({
+        ...defaultOptions,
+        contextKey: 'custom:ctx',
+      });
+
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      expect(ctx.set).toHaveBeenCalledWith('custom:ctx', expect.any(Object));
+    });
+  });
+
+  describe('afterModulesRegistered', () => {
+    it('runs health check', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+      const healthCheck = vi.fn().mockResolvedValue(true);
+
+      (createMysqlDriver as any).mockResolvedValue({
+        query: vi.fn(),
+        execute: vi.fn(),
+        transaction: vi.fn(),
+        close: vi.fn(),
+        healthCheck,
+      });
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      await plugin.afterModulesRegistered(mockApp, {} as any);
+
+      expect(healthCheck).toHaveBeenCalled();
+    });
+  });
+
+  describe('getters', () => {
+    it('getClient returns driver after init', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      expect(plugin.getClient()).toBeDefined();
+    });
+
+    it('getClient throws before init', () => {
+      expect(() => plugin.getClient()).toThrow('MySQL driver not initialized');
+    });
+
+    it('getDrizzle returns instance after init', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      expect(plugin.getDrizzle()).toBeDefined();
+    });
+
+    it('getDrizzle throws before init', () => {
+      expect(() => plugin.getDrizzle()).toThrow('Drizzle not initialized');
+    });
+
+    it('getPool returns pool after init', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      expect(plugin.getPool()).toBeDefined();
+    });
+
+    it('getPool throws before init', () => {
+      expect(() => plugin.getPool()).toThrow('MySQL pool not initialized');
+    });
+  });
+
+  describe('close', () => {
+    it('calls close on driver and pool end', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      const driverClose = vi.fn().mockResolvedValue(undefined);
+      (createMysqlDriver as any).mockResolvedValue({
+        query: vi.fn(),
+        execute: vi.fn(),
+        transaction: vi.fn(),
+        close: driverClose,
+        healthCheck: vi.fn().mockResolvedValue(true),
+      });
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+
+      await plugin.close();
+
+      expect(driverClose).toHaveBeenCalled();
+    });
+
+    it('resets internal references after close', async () => {
+      await plugin.beforeModulesRegistered(mockApp, {} as any);
+      await plugin.close();
+
+      expect(() => plugin.getClient()).toThrow('MySQL driver not initialized');
+    });
+  });
+});

package/db/src/mysql/plugin.ts

@@ -0,0 +1,128 @@
+import type { Hono } from 'hono';
+import type mysql from 'mysql2/promise';
+import { drizzle } from 'drizzle-orm/mysql2';
+import { ENV_SYMBOL, type Env, type ILogger } from '@rx-ted/packages-core';
+import { ComponentManager, resolvePluginLogger } from '@rx-ted/packages-honest';
+import type { Application, IPlugin } from '@rx-ted/packages-honest';
+import { createMysqlPool } from './client';
+import { createMysqlDriver } from './driver';
+import type { DatabaseDriver } from '../types';
+import { DB_GLOBAL_KEY } from '../constants';
+import { assertRuntimeSupport, type AppRuntime } from '../resolve';
+
+export const DB_CONTEXT_KEY = 'context:db';
+export const POOL_CONTEXT_KEY = 'honest:mysql:pool';
+
+// Backward-compat aliases
+export const DRIZZLE_GLOBAL_KEY = DB_GLOBAL_KEY;
+export const DRIZZLE_CONTEXT_KEY = DB_CONTEXT_KEY;
+export const MYSQL_CONTEXT_KEY = 'honest:mysql';
+
+export interface MysqlPluginOptions {
+  connection: {
+    host: string;
+    port: number;
+    user: string;
+    password?: string;
+    database: string;
+    ssl?: boolean | { rejectUnauthorized?: boolean; ca?: string; cert?: string; key?: string };
+    connectionLimit?: number;
+  };
+  contextKey?: string;
+  schema?: Record<string, unknown>;
+  logger?: boolean | ((log: string) => void);
+  plugins?: Array<{ name: string; install: (db: any) => void }>;
+}
+
+export class MysqlPlugin implements IPlugin {
+  static readonly globalKey = DB_GLOBAL_KEY;
+  readonly name = 'mysql-plugin';
+  readonly version = '1.0.0';
+  logger?: ILogger;
+  private driver: DatabaseDriver | null = null;
+  private drizzleInstance: any = null;
+  private pool: mysql.Pool | null = null;
+  private readonly options: MysqlPluginOptions;
+  private readonly contextKey: string;
+
+  constructor(options: MysqlPluginOptions) {
+    this.options = options;
+    this.contextKey = options.contextKey ?? MYSQL_CONTEXT_KEY;
+  }
+
+  getClient(): DatabaseDriver {
+    if (!this.driver) throw new Error('MySQL driver not initialized');
+    return this.driver;
+  }
+
+  getDrizzle(): any {
+    if (!this.drizzleInstance) throw new Error('Drizzle not initialized');
+    return this.drizzleInstance;
+  }
+
+  getPool(): mysql.Pool {
+    if (!this.pool) throw new Error('MySQL pool not initialized');
+    return this.pool;
+  }
+
+  async beforeModulesRegistered(app: Application, _hono: Hono): Promise<void> {
+    this.logger ??= resolvePluginLogger(this.name);
+
+    const env = ComponentManager.getPlugin<Env>(ENV_SYMBOL);
+    assertRuntimeSupport(env.platform as AppRuntime, 'mysql');
+
+    this.logger.info(
+      {
+        host: this.options.connection.host,
+        database: this.options.connection.database,
+      },
+      'MySQL: initializing',
+    );
+
+    this.pool = createMysqlPool({ ...this.options.connection });
+    this.driver = await createMysqlDriver({
+      ...this.options.connection,
+      pool: this.pool,
+      logger: this.logger as any,
+    });
+
+    const { schema } = this.options;
+    this.drizzleInstance = drizzle(this.pool, {
+      schema,
+      mode: 'default',
+      logger:
+        this.options.logger === true
+          ? true
+          : typeof this.options.logger === 'function'
+            ? {
+                logQuery: (query: string, params: unknown[]) =>
+                  (this.options.logger as Function)(query),
+              }
+            : this.options.logger,
+    } as any);
+
+    ComponentManager.registerPlugin(DB_GLOBAL_KEY, this.drizzleInstance);
+    app.getContext().set(POOL_CONTEXT_KEY, this.pool);
+    app.getContext().set(this.contextKey, this.driver);
+    app.getContext().set(DB_CONTEXT_KEY, this.drizzleInstance);
+  }
+
+  async afterModulesRegistered(_app: Application, _hono: Hono): Promise<void> {
+    if (!this.logger) return;
+    const healthy = await this.driver?.healthCheck();
+    if (healthy) {
+      this.logger.info('MySQL: health check passed');
+    } else {
+      this.logger.error('MySQL: health check failed');
+    }
+  }
+
+  async close(): Promise<void> {
+    this.logger?.info('MySQL: shutting down');
+    await this.driver?.close();
+    if (this.pool) await this.pool.end();
+    this.driver = null;
+    this.drizzleInstance = null;
+    this.pool = null;
+  }
+}

package/db/src/mysql/types.ts

@@ -0,0 +1,32 @@
+import type { Logger } from '@rx-ted/packages-core';
+
+export interface DatabaseOptions {
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  database: string;
+  ssl?: boolean | { rejectUnauthorized?: boolean; ca?: string; cert?: string; key?: string };
+}
+
+export interface SslOptions {
+  rejectUnauthorized?: boolean;
+  ca?: string;
+  cert?: string;
+  key?: string;
+}
+
+export interface DriverOptions {
+  logger?: Logger;
+}
+
+export interface DatabaseDriverOptions extends DatabaseOptions, DriverOptions {}
+
+export interface MysqlClientOptions {
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  database: string;
+  ssl?: boolean | { rejectUnauthorized?: boolean; ca?: string; cert?: string; key?: string };
+}

package/db/src/postgres/index.ts

@@ -0,0 +1,15 @@
+// PostgreSQL dialect — placeholder
+// Re-export Drizzle pg-core types for consumers to use in schema definitions
+export {
+  pgTable,
+  text,
+  integer,
+  boolean,
+  timestamp,
+  pgEnum,
+  uniqueIndex,
+  index,
+  primaryKey,
+  foreignKey,
+} from 'drizzle-orm/pg-core';
+export type { PgDatabase } from 'drizzle-orm/pg-core';