@rx-ted/packages-honest-plugins 1.0.1

package/db/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@rx-ted/packages-honest-plugins-db",
+  "version": "1.0.1",
+  "private": true,
+  "description": "Database plugin for @rx-ted/packages-honest",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "vitest": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./d1": {
+      "vitest": "./src/d1/index.ts",
+      "types": "./dist/d1/index.d.ts",
+      "default": "./dist/d1/index.js"
+    },
+    "./sqlite": {
+      "vitest": "./src/sqlite/index.ts",
+      "types": "./dist/sqlite/index.d.ts",
+      "default": "./dist/sqlite/index.js"
+    }
+  },
+  "sideEffects": [
+    "./dist/index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rx-ted/honest.git"
+  },
+  "author": "rx-ted",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@libsql/client": "^0.17.4",
+    "@rx-ted/packages-core": "workspace:^",
+    "drizzle-orm": "^0.45.2",
+    "mysql2": "^3.22.4",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@rx-ted/packages-honest": "workspace:^",
+    "hono": "^4.12.18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "vitest": "^4.1.7"
+  }
+}

package/db/src/constants.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from 'vitest';
+import { DB_GLOBAL_KEY } from './constants';
+
+describe('constants', () => {
+  it('exports DB_GLOBAL_KEY as "app:db"', () => {
+    expect(DB_GLOBAL_KEY).toBe('app:db');
+  });
+});

package/db/src/constants.ts

@@ -0,0 +1 @@
+export const DB_GLOBAL_KEY = 'app:db';

package/db/src/d1/index.ts

@@ -0,0 +1,13 @@
+export {
+  sqliteTable,
+  text,
+  integer,
+  real,
+  blob,
+  uniqueIndex,
+  index,
+  primaryKey,
+  foreignKey,
+} from 'drizzle-orm/sqlite-core';
+export type { AnyD1Database as D1DrizzleDatabase } from 'drizzle-orm/d1';
+export { D1Plugin } from './plugin';

package/db/src/d1/plugin.ts

@@ -0,0 +1,135 @@
+import type { Hono } from 'hono';
+import {
+  ENV_SYMBOL,
+  Platform,
+  type Env,
+  type ILogger,
+  resolveBinding,
+} from '@rx-ted/packages-core';
+import type { IPlugin, Application } from '@rx-ted/packages-honest';
+import { ComponentManager, resolvePluginLogger } from '@rx-ted/packages-honest';
+import { drizzle } from 'drizzle-orm/d1';
+import { DB_GLOBAL_KEY } from '../constants';
+import { assertRuntimeSupport, type AppRuntime } from '../resolve';
+
+export class D1Plugin implements IPlugin {
+  readonly name = `${DB_GLOBAL_KEY}:d1`;
+  readonly version = '0.0.1';
+  logger?: ILogger;
+  private db: any = null;
+
+  constructor(private options: { binding?: string; schema: Record<string, any> }) {}
+
+  async beforeModulesRegistered(app: Application, _hono: Hono): Promise<void> {
+    this.logger ??= resolvePluginLogger(this.name);
+
+    const appEnv = ComponentManager.getPlugin<Env>(ENV_SYMBOL);
+    assertRuntimeSupport(appEnv.platform as AppRuntime, 'd1');
+
+    const bindingName = this.resolveBindingName();
+    this.logger.info(`connecting... (binding: ${bindingName})`);
+
+    const binding = resolveBinding(bindingName);
+
+    if (binding) {
+      this.db = drizzle(binding, { schema: this.options.schema });
+      ComponentManager.registerPlugin(DB_GLOBAL_KEY, this.db);
+      return;
+    }
+
+    const resolveName = this.resolveBindingName.bind(this);
+    const opts = this.options;
+    const ensure = () => {
+      if (!this.db) {
+        const bn = resolveName();
+        const b = resolveBinding(bn);
+        if (b) {
+          this.db = drizzle(b, { schema: opts.schema });
+        }
+      }
+      return this.db;
+    };
+
+    ComponentManager.registerPlugin(
+      DB_GLOBAL_KEY,
+      new Proxy(
+        {},
+        {
+          get(_, prop) {
+            const instance = ensure();
+            if (!instance) {
+              throw new Error(`D1 binding "${resolveName()}" not found`);
+            }
+            const val = (instance as any)[prop];
+            return typeof val === 'function' ? val.bind(instance) : val;
+          },
+        },
+      ),
+    );
+  }
+
+  async afterModulesRegistered(_app: Application, _hono: Hono): Promise<void> {
+    if (!this.logger) return;
+
+    const bindingName = this.resolveBindingName();
+
+    try {
+      if (!this.db) {
+        const binding = resolveBinding(bindingName);
+        if (!binding) {
+          this.logger.warn(`health check skipped — binding "${bindingName}" not resolved`);
+          return;
+        }
+        this.db = drizzle(binding, { schema: this.options.schema });
+        ComponentManager.registerPlugin(DB_GLOBAL_KEY, this.db);
+        this.logger.info(`connected (binding: ${bindingName})`);
+      }
+
+      await healthCheck(this.db, bindingName);
+      this.logger.info(`health check passed (binding: ${bindingName})`);
+    } catch (error) {
+      this.logger.error(
+        { error: error instanceof Error ? error.message : String(error) },
+        `health check failed (binding: ${bindingName})`,
+      );
+    }
+  }
+
+  async close(): Promise<void> {
+    this.logger?.info(`shutting down (binding: ${this.resolveBindingName()})`);
+  }
+
+  private resolveBindingName(): string {
+    if (this.options.binding) return this.options.binding;
+    return findD1Binding() ?? 'DB';
+  }
+}
+
+function isD1Database(value: unknown): value is object {
+  return (
+    value !== null && typeof value === 'object' && typeof (value as any).prepare === 'function'
+  );
+}
+
+function findD1Binding(): string | null {
+  const sources: unknown[] = [globalThis, (globalThis as any).env, Platform.env()];
+  for (const source of sources) {
+    if (!source || typeof source !== 'object') continue;
+    for (const key of Object.keys(source as Record<string, unknown>)) {
+      if (isD1Database((source as any)[key])) return key;
+    }
+  }
+  return null;
+}
+
+async function healthCheck(db: any, bindingName: string): Promise<void> {
+  try {
+    await db.run('SELECT 1');
+  } catch (cause) {
+    throw new Error(
+      `D1 health check failed for binding "${bindingName}": the binding has no active database session. ` +
+        `Ensure the D1 database is bound correctly in your wrangler.toml and has been created (npx wrangler d1 create <name>).`,
+      { cause },
+    );
+  }
+}

package/db/src/db-service.ts

@@ -0,0 +1,14 @@
+import { Service, ComponentManager } from '@rx-ted/packages-honest';
+import type { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import { DB_GLOBAL_KEY } from './constants';
+
+@Service()
+class DbService {
+  constructor() {
+    return ComponentManager.getPlugin(DB_GLOBAL_KEY);
+  }
+}
+
+interface DbService extends BaseSQLiteDatabase<'async', any> {}
+
+export { DbService };

package/db/src/index.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import * as plugin from './index';
+
+describe('plugin barrel exports', () => {
+  it('exports DB_GLOBAL_KEY', () => {
+    expect(plugin.DB_GLOBAL_KEY).toBe('app:db');
+  });
+
+  it('exports DbService (class)', () => {
+    expect(plugin.DbService).toBeDefined();
+    expect(typeof plugin.DbService).toBe('function');
+  });
+
+  it('exports BaseRepository (class)', () => {
+    expect(plugin.BaseRepository).toBeDefined();
+    expect(typeof plugin.BaseRepository).toBe('function');
+  });
+
+  it('exports core Drizzle operators', () => {
+    expect(plugin.eq).toBeDefined();
+    expect(plugin.and).toBeDefined();
+    expect(plugin.or).toBeDefined();
+    expect(plugin.not).toBeDefined();
+    expect(plugin.sql).toBeDefined();
+    expect(plugin.asc).toBeDefined();
+    expect(plugin.desc).toBeDefined();
+    expect(plugin.count).toBeDefined();
+    expect(typeof plugin.eq).toBe('function');
+    expect(typeof plugin.and).toBe('function');
+  });
+
+  it('exports MysqlPlugin', () => {
+    expect(plugin.MysqlPlugin).toBeDefined();
+    expect(typeof plugin.MysqlPlugin).toBe('function');
+  });
+
+  it('exports mysql namespace', () => {
+    expect(plugin.mysql).toBeDefined();
+    expect(plugin.mysql.MysqlPlugin).toBeDefined();
+    expect(plugin.mysql.mysqlTable).toBeDefined();
+    expect(plugin.mysql.varchar).toBeDefined();
+    expect(plugin.mysql.int).toBeDefined();
+  });
+
+  it('exports MySQL column builders at top level', () => {
+    expect(plugin.mysqlTable).toBeDefined();
+    expect(plugin.varchar).toBeDefined();
+    expect(plugin.int).toBeDefined();
+    expect(plugin.bigint).toBeDefined();
+    expect(plugin.datetime).toBeDefined();
+    expect(plugin.boolean).toBeDefined();
+    expect(plugin.json).toBeDefined();
+  });
+
+  it('exports type-only namespaces (no runtime value)', () => {
+    // These are type-only namespaces (re-exports of .d.ts modules)
+    // They may not have runtime values depending on the Drizzle version
+    // Just verify the exports exist without throwing
+    expect(plugin).toHaveProperty('postgres');
+    expect(plugin).toHaveProperty('sqlite');
+    expect(plugin).toHaveProperty('d1');
+  });
+});

package/db/src/index.ts

@@ -0,0 +1,57 @@
+// Common exports
+export { DB_GLOBAL_KEY } from './constants';
+export { DBPlugin, assertRuntimeSupport } from './resolve';
+export type { AppRuntime, DbType } from './resolve';
+export { DbService } from './db-service';
+export { BaseRepository } from './repository';
+export type {
+  DatabaseClient,
+  PreparedStatement,
+  DatabaseConnection,
+  QueryResult,
+  DatabaseDriver,
+  QueryOptions,
+  PaginationResult,
+} from './types';
+
+// Common Drizzle operators
+export {
+  eq,
+  and,
+  or,
+  not,
+  inArray,
+  sql,
+  asc,
+  desc,
+  count,
+  like,
+  isNull,
+  isNotNull,
+} from 'drizzle-orm';
+
+// MySQL dialect (top-level for backward compatibility + namespaced)
+export * from './mysql';
+export * as mysql from './mysql';
+
+// PostgreSQL dialect (namespaced only)
+export * as postgres from './postgres';
+
+// SQLite dialect (namespaced only)
+export * as sqlite from './sqlite';
+
+// Cloudflare D1 dialect (namespaced only)
+export * as d1 from './d1';
+
+// Portable schema builder (table builder + compile dispatcher)
+export * from './schema-builder';
+
+// Zod bridge
+export {
+  zdb,
+  getZodDbMeta,
+  isZodObject,
+  toTableDefinition,
+  toColumnDefinition,
+} from './schema-builder/zod-bridge';
+export type { ZodDbMeta } from './schema-builder/zod-bridge';

package/db/src/mysql/client.ts

@@ -0,0 +1,112 @@
+import MySQL, {
+  type Pool,
+  type PoolConnection,
+  type PoolOptions,
+  type ResultSetHeader,
+  type RowDataPacket,
+} from 'mysql2/promise';
+import type { DatabaseClient, DatabaseConnection, PreparedStatement, QueryResult } from '../types';
+
+export function createMysqlPool(options: {
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  database: string;
+  ssl?: boolean | { rejectUnauthorized?: boolean; ca?: string; cert?: string; key?: string };
+  connectionLimit?: number;
+}): Pool {
+  const mysqlOptions: PoolOptions = {
+    host: options.host,
+    port: options.port,
+    user: options.user,
+    password: options.password,
+    database: options.database,
+    waitForConnections: true,
+    connectionLimit: options.connectionLimit ?? 10,
+    queueLimit: 0,
+  };
+  if (options.ssl) {
+    mysqlOptions.ssl = options.ssl === true ? { rejectUnauthorized: false } : options.ssl;
+  }
+  return MySQL.createPool(mysqlOptions);
+}
+
+export async function createMysqlClient(options: {
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  database: string;
+  ssl?: boolean | { rejectUnauthorized?: boolean; ca?: string; cert?: string; key?: string };
+}): Promise<DatabaseClient> {
+  const pool = createMysqlPool(options);
+  const connection = await pool.getConnection();
+  connection.release();
+  return new MysqlDatabaseClient(pool);
+}
+
+export class MysqlDatabaseClient implements DatabaseClient {
+  constructor(private pool: Pool) {}
+  prepare(sql: string): PreparedStatement {
+    return new MysqlPreparedStatement(this.pool, sql);
+  }
+  async getConnection(): Promise<DatabaseConnection> {
+    const conn = await this.pool.getConnection();
+    return new MysqlDatabaseConnection(conn);
+  }
+  async close(): Promise<void> {
+    await this.pool.end();
+  }
+}
+
+class MysqlPreparedStatement implements PreparedStatement {
+  constructor(
+    private client: Pool | PoolConnection,
+    private sql: string,
+  ) {}
+  async execute(params?: unknown[]): Promise<QueryResult> {
+    const connection =
+      'getConnection' in this.client ? await this.client.getConnection() : this.client;
+    try {
+      const [result] = await connection.execute<ResultSetHeader>(
+        this.sql,
+        params as (string | number | Buffer)[],
+      );
+      return {
+        affectedRows: result.affectedRows,
+        insertId: result.insertId ? Number(result.insertId) : undefined,
+      };
+    } finally {
+      connection.release();
+    }
+  }
+  release(): void {}
+}
+
+class MysqlDatabaseConnection implements DatabaseConnection {
+  constructor(private connection: PoolConnection) {}
+  prepare(sql: string): PreparedStatement {
+    return new MysqlPreparedStatement(this.connection, sql);
+  }
+  async query<T>(sql: string, params?: unknown[]): Promise<T[]> {
+    const [rows] = await this.connection.query<RowDataPacket[]>(
+      sql,
+      params as (string | number | Buffer)[],
+    );
+    return rows as T[];
+  }
+  async execute(sql: string, params?: unknown[]): Promise<QueryResult> {
+    const [result] = await this.connection.execute<ResultSetHeader>(
+      sql,
+      params as (string | number | Buffer)[],
+    );
+    return {
+      affectedRows: result.affectedRows,
+      insertId: result.insertId ? Number(result.insertId) : undefined,
+    };
+  }
+  release(): void {
+    this.connection.release();
+  }
+}

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

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('./client', () => ({
+  createMysqlClient: vi.fn(),
+  MysqlDatabaseClient: class {
+    constructor(public pool: any) {}
+    prepare = vi.fn();
+    getConnection = vi.fn();
+    close = vi.fn();
+  },
+}));
+
+import { createMysqlDriver } from './driver';
+import * as clientModule from './client';
+import type { DatabaseClient, DatabaseConnection, PreparedStatement } from '../types';
+
+function mockConnection(overrides?: Partial<DatabaseConnection>): DatabaseConnection {
+  return {
+    query: vi.fn(),
+    execute: vi.fn(),
+    prepare: vi.fn(),
+    release: vi.fn(),
+    ...overrides,
+  };
+}
+
+function makeClient(conn?: DatabaseConnection) {
+  const c = conn ?? mockConnection();
+  return {
+    getConnection: vi.fn().mockResolvedValue(c),
+    prepare: vi.fn(),
+    close: vi.fn(),
+  };
+}
+
+async function buildDriver(client?: DatabaseClient) {
+  const c = client ?? makeClient();
+  (clientModule.createMysqlClient as any).mockResolvedValue(c);
+  return createMysqlDriver({
+    host: 'localhost',
+    port: 3306,
+    user: 'root',
+    database: 'test',
+  });
+}
+
+describe('MysqlDriver', () => {
+  describe('query', () => {
+    it('returns rows from connection', async () => {
+      const conn = mockConnection();
+      (conn.query as any).mockResolvedValue([{ id: 1, name: 'Alice' }]);
+      const driver = await buildDriver(makeClient(conn));
+
+      const result = await driver.query('SELECT * FROM users');
+
+      expect(result).toEqual([{ id: 1, name: 'Alice' }]);
+      expect(conn.query).toHaveBeenCalledWith('SELECT * FROM users', undefined);
+      expect(conn.release).toHaveBeenCalled();
+    });
+  });
+
+  describe('execute', () => {
+    it('prepares, executes and releases statement', async () => {
+      const stmt: PreparedStatement = {
+        execute: vi.fn().mockResolvedValue({ affectedRows: 2, insertId: 10 }),
+        release: vi.fn(),
+      };
+      const conn = mockConnection();
+      (conn.prepare as any).mockReturnValue(stmt);
+      const driver = await buildDriver(makeClient(conn));
+
+      const result = await driver.execute('UPDATE users SET name = ?', ['Bob']);
+
+      expect(result).toEqual({ affectedRows: 2, insertId: 10 });
+      expect(conn.prepare).toHaveBeenCalledWith('UPDATE users SET name = ?');
+      expect(stmt.execute).toHaveBeenCalledWith(['Bob']);
+      expect(stmt.release).toHaveBeenCalled();
+      expect(conn.release).toHaveBeenCalled();
+    });
+  });
+
+  describe('transaction', () => {
+    it('commits on success', async () => {
+      const conn = mockConnection();
+      const driver = await buildDriver(makeClient(conn));
+
+      const result = await driver.transaction(async (tx) => {
+        await tx.query('SELECT 1');
+        return 'ok';
+      });
+
+      expect(result).toBe('ok');
+      expect(conn.query).toHaveBeenCalledWith('SET autocommit = 0');
+      expect(conn.query).toHaveBeenCalledWith('START TRANSACTION');
+      expect(conn.query).toHaveBeenCalledWith('COMMIT');
+      expect(conn.query).toHaveBeenCalledWith('SET autocommit = 1');
+      expect(conn.release).toHaveBeenCalled();
+    });
+
+    it('rolls back on error and rethrows', async () => {
+      const conn = mockConnection();
+      const driver = await buildDriver(makeClient(conn));
+
+      await expect(
+        driver.transaction(async () => {
+          throw new Error('db error');
+        }),
+      ).rejects.toThrow('db error');
+
+      expect(conn.query).toHaveBeenCalledWith('ROLLBACK');
+      expect(conn.query).toHaveBeenCalledWith('SET autocommit = 1');
+    });
+  });
+
+  describe('healthCheck', () => {
+    it('returns true when SELECT 1 succeeds', async () => {
+      const conn = mockConnection();
+      (conn.query as any).mockResolvedValue([[1]]);
+      const driver = await buildDriver(makeClient(conn));
+
+      const result = await driver.healthCheck();
+
+      expect(result).toBe(true);
+      expect(conn.query).toHaveBeenCalledWith('SELECT 1');
+    });
+
+    it('returns false on error', async () => {
+      const conn = mockConnection();
+      (conn.query as any).mockRejectedValue(new Error('connection failed'));
+      const driver = await buildDriver(makeClient(conn));
+
+      const result = await driver.healthCheck();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('close', () => {
+    it('closes the underlying client', async () => {
+      const client = makeClient();
+      const driver = await buildDriver(client);
+
+      await driver.close();
+
+      expect(client.close).toHaveBeenCalled();
+    });
+  });
+
+  describe('TransactionalMysqlDriver', () => {
+    it('delegates query inside transaction', async () => {
+      const conn = mockConnection();
+      (conn.query as any).mockResolvedValue([{ id: 1 }]);
+      const driver = await buildDriver(makeClient(conn));
+
+      const result = await driver.transaction(async (tx) => {
+        return tx.query('SELECT 1');
+      });
+
+      expect(result).toEqual([{ id: 1 }]);
+    });
+
+    it('throws on nested transaction call', async () => {
+      const conn = mockConnection();
+      const driver = await buildDriver(makeClient(conn));
+
+      await expect(
+        driver.transaction(async (tx) => {
+          return tx.transaction(async () => 'nested');
+        }),
+      ).rejects.toThrow('Nested transactions are not supported');
+    });
+
+    it('executes prepared statement inside transaction', async () => {
+      const stmt: PreparedStatement = {
+        execute: vi.fn().mockResolvedValue({ affectedRows: 1 }),
+        release: vi.fn(),
+      };
+      const conn = mockConnection();
+      (conn.prepare as any).mockReturnValue(stmt);
+      const driver = await buildDriver(makeClient(conn));
+
+      await driver.transaction(async (tx) => {
+        return tx.execute('UPDATE users SET x=1');
+      });
+
+      expect(stmt.execute).toHaveBeenCalled();
+      expect(stmt.release).toHaveBeenCalled();
+    });
+  });
+});