@rx-ted/packages-honest-plugins 1.0.1

package/db/dist/mysql/driver.d.ts

@@ -0,0 +1,18 @@
+import type { Pool } from 'mysql2/promise';
+import type { Logger } from '@rx-ted/packages-core';
+import type { DatabaseDriver } from '../types';
+export declare 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>;

package/db/dist/mysql/driver.js

@@ -0,0 +1,107 @@
+import { createMysqlClient, MysqlDatabaseClient } from './client';
+export async function createMysqlDriver(options) {
+    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 {
+    client;
+    logger;
+    constructor(client, logger) {
+        this.client = client;
+        this.logger = logger;
+    }
+    async query(sql, params) {
+        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(sql, params);
+        conn.release();
+        if (this.logger)
+            this.logger.debug({ rows: result.length }, 'MySQL: result');
+        return result;
+    }
+    async execute(sql, params) {
+        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(fn) {
+        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() {
+        await this.client.close();
+        if (this.logger)
+            this.logger.info('MySQL: closed');
+    }
+    async healthCheck() {
+        try {
+            const conn = await this.client.getConnection();
+            await conn.query('SELECT 1');
+            conn.release();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+class TransactionalMysqlDriver {
+    connection;
+    constructor(connection, _logger) {
+        this.connection = connection;
+    }
+    async query(sql, params) {
+        return this.connection.query(sql, params);
+    }
+    async execute(sql, params) {
+        const stmt = this.connection.prepare(sql);
+        const result = await stmt.execute(params);
+        stmt.release();
+        return result;
+    }
+    async transaction(_fn) {
+        throw new Error('Nested transactions are not supported');
+    }
+    async close() { }
+    async healthCheck() {
+        return true;
+    }
+}

package/db/dist/mysql/index.d.ts

@@ -0,0 +1,11 @@
+export { MysqlPlugin, DRIZZLE_GLOBAL_KEY, DB_CONTEXT_KEY, DRIZZLE_CONTEXT_KEY, MYSQL_CONTEXT_KEY, POOL_CONTEXT_KEY, } from './plugin';
+export type { MysqlPluginOptions } from './plugin';
+export { DB_GLOBAL_KEY } from '../constants';
+export { createMysqlDriver } from './driver';
+export { createMysqlPool, createMysqlClient, MysqlDatabaseClient } from './client';
+export type { MysqlClientOptions } from './types';
+export type { DatabaseOptions, SslOptions, DriverOptions, DatabaseDriverOptions, } from './types';
+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/dist/mysql/index.js

@@ -0,0 +1,11 @@
+// Plugin
+export { MysqlPlugin, DRIZZLE_GLOBAL_KEY, DB_CONTEXT_KEY, DRIZZLE_CONTEXT_KEY, MYSQL_CONTEXT_KEY, POOL_CONTEXT_KEY, } from './plugin';
+// Global key
+export { DB_GLOBAL_KEY } from '../constants';
+// Raw driver
+export { createMysqlDriver } from './driver';
+export { createMysqlPool, createMysqlClient, MysqlDatabaseClient } from './client';
+// ── 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 { drizzle } from 'drizzle-orm/mysql2';
+export * as drizzleORM from 'drizzle-orm';

package/db/dist/mysql/plugin.d.ts

@@ -0,0 +1,51 @@
+import type { Hono } from 'hono';
+import type mysql from 'mysql2/promise';
+import { type ILogger } from '@rx-ted/packages-core';
+import type { Application, IPlugin } from '@rx-ted/packages-honest';
+import type { DatabaseDriver } from '../types';
+export declare const DB_CONTEXT_KEY = "context:db";
+export declare const POOL_CONTEXT_KEY = "honest:mysql:pool";
+export declare const DRIZZLE_GLOBAL_KEY = "app:db";
+export declare const DRIZZLE_CONTEXT_KEY = "context:db";
+export declare 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 declare class MysqlPlugin implements IPlugin {
+    static readonly globalKey = "app:db";
+    readonly name = "mysql-plugin";
+    readonly version = "1.0.0";
+    logger?: ILogger;
+    private driver;
+    private drizzleInstance;
+    private pool;
+    private readonly options;
+    private readonly contextKey;
+    constructor(options: MysqlPluginOptions);
+    getClient(): DatabaseDriver;
+    getDrizzle(): any;
+    getPool(): mysql.Pool;
+    beforeModulesRegistered(app: Application, _hono: Hono): Promise<void>;
+    afterModulesRegistered(_app: Application, _hono: Hono): Promise<void>;
+    close(): Promise<void>;
+}

package/db/dist/mysql/plugin.js

@@ -0,0 +1,94 @@
+import { drizzle } from 'drizzle-orm/mysql2';
+import { ENV_SYMBOL } from '@rx-ted/packages-core';
+import { ComponentManager, resolvePluginLogger } from '@rx-ted/packages-honest';
+import { createMysqlPool } from './client';
+import { createMysqlDriver } from './driver';
+import { DB_GLOBAL_KEY } from '../constants';
+import { assertRuntimeSupport } 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 class MysqlPlugin {
+    static globalKey = DB_GLOBAL_KEY;
+    name = 'mysql-plugin';
+    version = '1.0.0';
+    logger;
+    driver = null;
+    drizzleInstance = null;
+    pool = null;
+    options;
+    contextKey;
+    constructor(options) {
+        this.options = options;
+        this.contextKey = options.contextKey ?? MYSQL_CONTEXT_KEY;
+    }
+    getClient() {
+        if (!this.driver)
+            throw new Error('MySQL driver not initialized');
+        return this.driver;
+    }
+    getDrizzle() {
+        if (!this.drizzleInstance)
+            throw new Error('Drizzle not initialized');
+        return this.drizzleInstance;
+    }
+    getPool() {
+        if (!this.pool)
+            throw new Error('MySQL pool not initialized');
+        return this.pool;
+    }
+    async beforeModulesRegistered(app, _hono) {
+        this.logger ??= resolvePluginLogger(this.name);
+        const env = ComponentManager.getPlugin(ENV_SYMBOL);
+        assertRuntimeSupport(env.platform, '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,
+        });
+        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, params) => this.options.logger(query),
+                    }
+                    : this.options.logger,
+        });
+        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, _hono) {
+        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() {
+        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/dist/mysql/types.d.ts

@@ -0,0 +1,38 @@
+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/dist/mysql/types.js

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

package/db/dist/postgres/index.d.ts

@@ -0,0 +1,2 @@
+export { pgTable, text, integer, boolean, timestamp, pgEnum, uniqueIndex, index, primaryKey, foreignKey, } from 'drizzle-orm/pg-core';
+export type { PgDatabase } from 'drizzle-orm/pg-core';

package/db/dist/postgres/index.js

@@ -0,0 +1,3 @@
+// 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';

package/db/dist/repository.d.ts

@@ -0,0 +1,14 @@
+import { type Table } from 'drizzle-orm';
+import type { QueryOptions, PaginationResult } from './types';
+export declare class BaseRepository<TTable extends Table> {
+    protected db: any;
+    protected table: TTable;
+    constructor(db: any, table: TTable);
+    findById(id: string): Promise<any | null>;
+    findMany(options?: QueryOptions): Promise<any[]>;
+    findWithPagination(options?: QueryOptions): Promise<PaginationResult<any>>;
+    create(data: any): Promise<any>;
+    update(id: string, data: any): Promise<any | null>;
+    delete(id: string): Promise<boolean>;
+    count(where?: Record<string, any>): Promise<number>;
+}

package/db/dist/repository.js

@@ -0,0 +1,79 @@
+import { eq, and } from 'drizzle-orm';
+import { sql } from 'drizzle-orm';
+export class BaseRepository {
+    db;
+    table;
+    constructor(db, table) {
+        this.db = db;
+        this.table = table;
+    }
+    async findById(id) {
+        const [result] = await this.db
+            .select()
+            .from(this.table)
+            .where(eq(this.table.id, id))
+            .limit(1);
+        return result ?? null;
+    }
+    async findMany(options) {
+        let query = this.db.select().from(this.table);
+        if (options?.where) {
+            const conditions = Object.entries(options.where).map(([key, value]) => eq(this.table[key], value));
+            query = query.where(and(...conditions));
+        }
+        if (options?.orderBy) {
+            for (const [key, dir] of Object.entries(options.orderBy)) {
+                query = query.orderBy(dir === 'desc'
+                    ? sql `${this.table[key]} desc`
+                    : sql `${this.table[key]} asc`);
+            }
+        }
+        if (options?.pagination) {
+            const { page, pageSize } = options.pagination;
+            query = query.limit(pageSize).offset((page - 1) * pageSize);
+        }
+        return query;
+    }
+    async findWithPagination(options) {
+        const page = options?.pagination?.page ?? 1;
+        const pageSize = options?.pagination?.pageSize ?? 10;
+        const data = await this.findMany(options);
+        const total = await this.count(options?.where);
+        return {
+            data,
+            total,
+            page,
+            pageSize,
+            totalPages: Math.ceil(total / pageSize),
+        };
+    }
+    async create(data) {
+        const raw = await this.db.insert(this.table).values(data);
+        const r = Array.isArray(raw) ? raw[0] : raw;
+        return {
+            insertId: Number(r.insertId ?? r.lastInsertRowid ?? r.meta?.last_row_id),
+            affectedRows: Number(r.affectedRows ?? r.rowsAffected ?? r.meta?.changes ?? 0),
+        };
+    }
+    async update(id, data) {
+        const raw = await this.db
+            .update(this.table)
+            .set(data)
+            .where(eq(this.table.id, id));
+        const r = Array.isArray(raw) ? raw[0] : raw;
+        return r ?? null;
+    }
+    async delete(id) {
+        const result = await this.db.delete(this.table).where(eq(this.table.id, id));
+        return result.affectedRows > 0;
+    }
+    async count(where) {
+        let query = this.db.select({ count: sql `count(*)` }).from(this.table);
+        if (where) {
+            const conditions = Object.entries(where).map(([key, value]) => eq(this.table[key], value));
+            query = query.where(and(...conditions));
+        }
+        const [result] = await query;
+        return Number(result?.count ?? 0);
+    }
+}

package/db/dist/resolve.d.ts

@@ -0,0 +1,6 @@
+import type { IPlugin } from '@rx-ted/packages-honest';
+export type AppRuntime = 'node' | 'bun' | 'deno' | 'cloudflare' | 'vercel-edge';
+export type DbType = 'd1' | 'sqlite' | 'mysql';
+export declare function assertRuntimeSupport(runtime: AppRuntime, dbType: DbType): void;
+export declare function DBPlugin(schema: Record<string, any>): Promise<IPlugin>;
+export declare function DBPlugin(plugin: IPlugin): Promise<IPlugin>;

package/db/dist/resolve.js

@@ -0,0 +1,81 @@
+import { ENV_SYMBOL, Env } from '@rx-ted/packages-core';
+import { ComponentManager } from '@rx-ted/packages-honest';
+const RUNTIME_DB_MAP = {
+    cloudflare: ['d1'],
+    node: ['sqlite', 'mysql'],
+    bun: ['sqlite', 'mysql'],
+    deno: ['sqlite', 'mysql'],
+    'vercel-edge': [],
+};
+const PLUGIN_DB_TYPE = {
+    D1Plugin: 'd1',
+    SqlitePlugin: 'sqlite',
+    MysqlPlugin: 'mysql',
+};
+function getAppEnv() {
+    if (ComponentManager.hasPlugin(ENV_SYMBOL)) {
+        return ComponentManager.getPlugin(ENV_SYMBOL);
+    }
+    return new Env(process.env, {});
+}
+export function assertRuntimeSupport(runtime, dbType) {
+    if (!(runtime in RUNTIME_DB_MAP)) {
+        throw new Error(`[db] Unsupported runtime "${runtime}". ` +
+            `Supported: ${Object.keys(RUNTIME_DB_MAP).join(', ')}. ` +
+            `Contact the developer to add support for this runtime.`);
+    }
+    const allowed = RUNTIME_DB_MAP[runtime];
+    if (!allowed.includes(dbType)) {
+        throw new Error(`[db] Database "${dbType}" is not supported on runtime "${runtime}". ` +
+            `Allowed databases for "${runtime}": ${allowed.join(', ')}. ` +
+            `Change the DB env var or switch to a different runtime.`);
+    }
+}
+function dbTypeFromPlugin(plugin) {
+    const name = plugin.constructor?.name;
+    const dbType = name ? PLUGIN_DB_TYPE[name] : undefined;
+    if (!dbType) {
+        throw new Error(`[db] Unknown plugin "${name}". ` +
+            `Supported plugins: ${Object.keys(PLUGIN_DB_TYPE).join(', ')}.`);
+    }
+    return dbType;
+}
+export async function DBPlugin(arg) {
+    const appEnv = getAppEnv();
+    // Explicit mode: user passed a pre-created plugin
+    if (arg && typeof arg === 'object' && 'name' in arg && 'version' in arg) {
+        const dbType = dbTypeFromPlugin(arg);
+        assertRuntimeSupport(appEnv.platform, dbType);
+        return arg;
+    }
+    // Auto-detect mode: arg is schema
+    const runtime = appEnv.platform;
+    const dbRaw = appEnv.get('DB');
+    const db = (typeof dbRaw === 'string' ? dbRaw : undefined) ??
+        RUNTIME_DB_MAP[runtime]?.[0] ??
+        'sqlite';
+    assertRuntimeSupport(runtime, db);
+    if (db === 'd1') {
+        const { D1Plugin } = await import('./d1/plugin');
+        return new D1Plugin({ schema: arg });
+    }
+    if (db === 'sqlite') {
+        const { SqlitePlugin } = await import('./sqlite/plugin');
+        return new SqlitePlugin({
+            dbPath: appEnv.var('DB_PATH', 'data/app.db'),
+            schema: arg,
+        });
+    }
+    const { MysqlPlugin } = await import('./mysql/plugin');
+    return new MysqlPlugin({
+        connection: {
+            host: appEnv.get('DB_HOST', 'string'),
+            port: appEnv.get('DB_PORT', 'number'),
+            user: appEnv.get('DB_USER', 'string'),
+            password: appEnv.get('DB_PASSWORD') ?? '',
+            database: appEnv.get('DB_DATABASE', 'string'),
+        },
+        schema: arg,
+        logger: true,
+    });
+}

package/db/dist/schema-builder/column-builder.d.ts

@@ -0,0 +1,26 @@
+import type { ColumnDefinition, ReferenceDef } from './types';
+type ColumnType = 'varchar' | 'char' | 'text' | 'bigint' | 'integer' | 'boolean' | 'timestamp' | 'date' | 'enum' | 'json' | 'decimal';
+interface ColumnOpts {
+    length?: number;
+    values?: string[];
+    precision?: number;
+    scale?: number;
+}
+export declare class ColumnBuilder {
+    private def;
+    private customDbName?;
+    __tableName?: string;
+    __columnName?: string;
+    constructor(type: ColumnType, opts?: ColumnOpts);
+    dbName(name: string): this;
+    primaryKey(): this;
+    autoIncrement(): this;
+    notNull(): this;
+    unique(): this;
+    default(value: unknown): this;
+    references(fn: () => ColumnBuilder, opts?: {
+        onDelete?: ReferenceDef['onDelete'];
+    }): this;
+    build(name: string): ColumnDefinition;
+}
+export {};

package/db/dist/schema-builder/column-builder.js

@@ -0,0 +1,53 @@
+export class ColumnBuilder {
+    def;
+    customDbName;
+    __tableName;
+    __columnName;
+    constructor(type, opts) {
+        this.def = { type };
+        if (opts?.length !== undefined)
+            this.def.length = opts.length;
+        if (opts?.values !== undefined)
+            this.def.values = opts.values;
+        if (opts?.precision !== undefined)
+            this.def.precision = opts.precision;
+        if (opts?.scale !== undefined)
+            this.def.scale = opts.scale;
+    }
+    dbName(name) {
+        this.customDbName = name;
+        return this;
+    }
+    primaryKey() {
+        this.def.primaryKey = true;
+        return this;
+    }
+    autoIncrement() {
+        this.def.autoIncrement = true;
+        return this;
+    }
+    notNull() {
+        this.def.notNull = true;
+        return this;
+    }
+    unique() {
+        this.def.unique = true;
+        return this;
+    }
+    default(value) {
+        this.def.default = value;
+        return this;
+    }
+    references(fn, opts) {
+        const target = fn();
+        const tbl = target.__tableName ?? target.table?.[Symbol.for('drizzle:Name')];
+        const col = target.__columnName ?? target.name;
+        if (!tbl || !col)
+            throw new Error('references() target not fully initialized (missing table/column name)');
+        this.def.references = { table: tbl, column: col, onDelete: opts?.onDelete };
+        return this;
+    }
+    build(name) {
+        return { name: this.customDbName ?? name, ...this.def };
+    }
+}

package/db/dist/schema-builder/compile-d1.d.ts

@@ -0,0 +1,5 @@
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { SchemaDefinition } from './types';
+export declare function compileD1<T extends SchemaDefinition>(schema: T): {
+    [K in keyof T]: SQLiteTable;
+};