@rx-ted/packages-honest-plugins 1.0.1

package/cache/src/resolve.ts

@@ -0,0 +1,140 @@
+import { ENV_SYMBOL, type Env, Platform, resolveBinding } from '@rx-ted/packages-core';
+export { resolveBinding };
+import { ComponentManager, resolvePluginLogger } from '@rx-ted/packages-honest';
+import type { Application, IPlugin } from '@rx-ted/packages-honest';
+import { createCloudflareKvDriver } from './cloudflare/driver';
+import type { KvNamespace } from './cloudflare/driver';
+import { createRedisDriver } from './redis/driver';
+import type { RedisClientOptions } from './redis/driver';
+import { createLocalCacheDriver } from './local/driver';
+import type { CacheDriver } from './types';
+import { CACHE_GLOBAL_KEY } from './cache-service';
+
+export interface CachePluginOptions {
+  driver?: 'redis' | 'kv' | 'local';
+  redis?: RedisClientOptions;
+  kvBinding?: string;
+}
+
+export function findKvBinding(env?: Env): string {
+  const sources: Record<string, unknown>[] = [
+    globalThis as Record<string, unknown>,
+    ((globalThis as any).env ?? {}) as Record<string, unknown>,
+    Platform.env(),
+  ];
+  for (const source of sources) {
+    for (const key of Object.keys(source)) {
+      const val = source[key];
+      if (val && typeof val === 'object' && 'get' in val && 'put' in val && 'delete' in val) {
+        const { get, put, delete: del } = val as any;
+        if (typeof get === 'function' && typeof put === 'function' && typeof del === 'function') {
+          return key;
+        }
+      }
+    }
+  }
+  return '';
+}
+
+function resolveRedisConfig(
+  options: CachePluginOptions | undefined,
+  env?: Env,
+): RedisClientOptions | null {
+  if (options?.redis) return options.redis;
+  if (env?.has('REDIS_URL')) return { url: env.get('REDIS_URL')! };
+  if (env?.has('REDIS_HOST')) {
+    return {
+      host: env.get('REDIS_HOST'),
+      port: env.get('REDIS_PORT', 'number'),
+      username: env.get('REDIS_USERNAME'),
+      password: env.get('REDIS_PASSWORD'),
+      db: env.get('REDIS_DB', 'number'),
+    };
+  }
+  return null;
+}
+
+export class CachePlugin implements IPlugin {
+  readonly name = 'cache-plugin';
+  readonly version = '1.0.0';
+  logger?: import('@rx-ted/packages-core').ILogger;
+
+  private driver: CacheDriver | null = null;
+
+  constructor(private options?: CachePluginOptions) {}
+
+  getClient(): CacheDriver {
+    if (!this.driver) {
+      throw new Error('Cache not initialized. Ensure beforeModulesRegistered has run.');
+    }
+    return this.driver;
+  }
+
+  async beforeModulesRegistered(app: Application): Promise<void> {
+    this.logger ??= resolvePluginLogger(this.name);
+    this.logger.info('Cache: initializing...');
+
+    const appEnv = ComponentManager.hasPlugin(ENV_SYMBOL)
+      ? ComponentManager.getPlugin<Env>(ENV_SYMBOL)
+      : undefined;
+
+    const explicit = this.options?.driver;
+    const platform = appEnv?.platform ?? 'node';
+
+    if (explicit === 'kv' || (!explicit && platform === 'cloudflare')) {
+      this.driver = this.initCloudflare(appEnv);
+    } else if (
+      explicit === 'redis' ||
+      (!explicit && (platform === 'node' || platform === 'bun' || platform === 'deno'))
+    ) {
+      this.driver = await this.initNode(appEnv);
+    } else {
+      this.driver = createLocalCacheDriver();
+    }
+
+    app.getContext().set('honest:cache', this.driver);
+    ComponentManager.registerPlugin(CACHE_GLOBAL_KEY, this.driver);
+    this.logger.info('Cache: ready');
+  }
+
+  private initCloudflare(env?: Env): CacheDriver {
+    const bindingName = this.options?.kvBinding || findKvBinding(env);
+    if (bindingName) {
+      const ns = resolveBinding(bindingName, env) as KvNamespace | undefined;
+      if (ns) {
+        this.logger?.info('Cache: using Cloudflare KV');
+        return createCloudflareKvDriver(ns);
+      }
+    }
+    throw new Error(
+      `Cache: Cloudflare KV binding not found. Configure a KV namespace binding named "${bindingName || '<name>'}" in your wrangler.toml.`,
+    );
+  }
+
+  private async initNode(env?: Env): Promise<CacheDriver> {
+    const redisConfig = resolveRedisConfig(this.options, env);
+    if (redisConfig) {
+      try {
+        const driver = await createRedisDriver(redisConfig);
+        const ok = await driver.healthCheck();
+        if (ok) {
+          this.logger?.info('Cache: using Redis');
+          return driver;
+        }
+        this.logger?.warn('Cache: Redis health check failed, falling back to local');
+      } catch (err) {
+        this.logger?.warn(
+          { error: err instanceof Error ? err.message : String(err) },
+          'Cache: Redis connection failed, falling back to local',
+        );
+      }
+    }
+    this.logger?.info('Cache: using local in-memory cache');
+    return createLocalCacheDriver();
+  }
+
+  async close(): Promise<void> {
+    await this.driver?.close();
+    this.driver = null;
+  }
+}

package/cache/src/types.ts

@@ -0,0 +1,14 @@
+export interface CacheDriver {
+  get<T = unknown>(key: string): Promise<T | null>;
+  set(key: string, value: unknown, ttl?: number): Promise<boolean>;
+  delete(key: string): Promise<boolean>;
+  exists(key: string): Promise<boolean>;
+  mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+  mset(items: Array<{ key: string; value: unknown; ttl?: number }>): Promise<boolean>;
+  deleteByPattern(pattern: string): Promise<number>;
+  incr(key: string): Promise<number>;
+  decr(key: string): Promise<number>;
+  expire(key: string, ttl: number): Promise<boolean>;
+  close(): Promise<void>;
+  healthCheck(): Promise<boolean>;
+}

package/cache/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": true,
+    "sourceMap": false,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "types": ["node"],
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"]
+}

package/cache/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+import { getWorkspaceAliases } from '../../../vitest.workspace-aliases';
+
+export default defineConfig({
+  resolve: {
+    alias: getWorkspaceAliases(),
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    exclude: ['node_modules'],
+  },
+});

package/db/.turbo/turbo-build.log

@@ -0,0 +1 @@
+$ tsc -p tsconfig.json

package/db/.turbo/turbo-test.log

@@ -0,0 +1,21 @@
+$ vitest run
+
+ RUN  v4.1.8 /Users/ben/projects/app/packages/honest-plugins/db
+
+ ✓ src/schema-builder/column-builder.test.ts (6 tests) 3ms
+ ✓ src/schema-builder/types.test.ts (7 tests) 2ms
+ ✓ src/schema-builder/table-builder.test.ts (5 tests) 2ms
+ ✓ src/mysql/driver.test.ts (10 tests) 7ms
+ ✓ src/mysql/plugin.test.ts (16 tests) 11ms
+ ✓ src/constants.test.ts (1 test) 3ms
+ ✓ src/repository.test.ts (14 tests) 5ms
+ ✓ src/schema-builder/compile-d1.test.ts (4 tests) 2ms
+ ✓ src/schema-builder/compile-mysql.test.ts (4 tests) 2ms
+ ✓ src/schema-builder/index.test.ts (4 tests) 3ms
+ ✓ src/index.test.ts (8 tests) 2ms
+
+ Test Files  11 passed (11)
+      Tests  79 passed (79)
+   Start at  14:17:12
+   Duration  1.08s (transform 793ms, setup 0ms, import 2.48s, tests 42ms, environment 1ms)
+

package/db/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @rx-ted/packages-honest-plugins-db
+
+## 1.0.1
+
+### Patch Changes
+
+- 11bbae7: Remove defunct packages (web-admin, auth, http-client, search) and introduce barrel packages for consolidated exports. Migrate all internal imports from scoped plugin names (`@rx-ted/packages-honest-plugins-db`) to path-based barrel imports (`@rx-ted/packages-honest-plugins/db`). Reset all package versions to 1.0.0 with consolidated changelogs. Clean up obsolete documentation across the monorepo.
+- Updated dependencies [11bbae7]
+  - @rx-ted/packages-core@1.0.1
+  - @rx-ted/packages-honest@1.0.1
+
+## 1.0.0
+
+Initial consolidated release.
+
+### Features
+
+- Database plugin for @rx-ted/packages-honest
+- Schema-builder with Zod integration (`zdb()` helper)
+- D1 (SQLite) schema compiler with proper JSON mode
+- MySQL schema compiler
+- `compileSchema` dispatcher for multi-dialect support
+- Lazy Proxy D1 binding resolution for wrangler dev compatibility
+- `SqlitePlugin` using better-sqlite3 (WAL mode, foreign keys)
+- Normalize SQLite insert results (`{changes,lastInsertRowid}` → `{affectedRows,insertId}`)
+- Shared `resolveBinding` utility from core

package/db/README.md

@@ -0,0 +1,99 @@
+# @rx-ted/packages-honest-plugins-db
+
+Database plugin for [@rx-ted/packages-honest](https://github.com/rx-ted/honest). Supports MySQL, SQLite, Cloudflare D1, and PostgreSQL via Drizzle ORM.
+
+## Features
+
+- **Multi-dialect**: MySQL, SQLite, Cloudflare D1, PostgreSQL
+- **Drizzle ORM**: type-safe SQL with schema-first approach
+- **Runtime-agnostic**: works on Node.js, Bun, Deno, and Cloudflare Workers
+- **Portable schema builder**: define schemas once, compile to any dialect
+- **Zod bridge**: `zdb()` for Zod-to-Drizzle schema conversion
+
+## Installation
+
+```bash
+pnpm add @rx-ted/packages-honest-plugins-db
+```
+
+Peer dependencies: `@rx-ted/packages-honest`, `hono`
+
+## Usage
+
+### Register as a plugin
+
+```ts
+import { DBPlugin } from '@rx-ted/packages-honest-plugins/db';
+
+const plugin = new DBPlugin({
+  // dialect is auto-detected from DB env var
+});
+
+const { hono } = await Application.create(AppModule, {
+  plugins: [plugin],
+});
+```
+
+### Subpath exports
+
+```ts
+import { DBPlugin } from '@rx-ted/packages-honest-plugins/db'       // auto-detect dialect
+import { DBPlugin } from '@rx-ted/packages-honest-plugins/db/d1'    // Cloudflare D1
+import { DBPlugin } from '@rx-ted/packages-honest-plugins/db/sqlite' // SQLite
+```
+
+### Access the database
+
+```ts
+import { ComponentManager } from '@rx-ted/packages-honest';
+import { DbService } from '@rx-ted/packages-honest-plugins/db';
+
+const db = ComponentManager.getPlugin<DbService>('db');
+// Use db.client for Drizzle ORM operations
+```
+
+### Schema builder
+
+```ts
+import { compileSchema, table, column } from '@rx-ted/packages-honest-plugins/db';
+
+const schema = table('users', {
+  id: column.uuid().primaryKey(),
+  name: column.text().notNull(),
+});
+
+// Compiles to dialect-specific DDL based on runtime platform
+const ddl = compileSchema(schema);
+```
+
+### Zod bridge
+
+```ts
+import { zdb, toTableDefinition } from '@rx-ted/packages-honest-plugins/db';
+import { z } from 'zod';
+
+const userSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1),
+});
+
+const meta = getZodDbMeta(userSchema, 'users');
+const tableDef = toTableDefinition(meta);
+```
+
+## Supported Dialects
+
+| Dialect | Env var | Package |
+|---------|---------|---------|
+| MySQL | `DB=mysql` | `mysql2` |
+| SQLite | `DB=sqlite` | `better-sqlite3` |
+| Cloudflare D1 | `DB=d1` | `@libsql/client` |
+| PostgreSQL | `DB=postgres` | `postgres` |
+
+## Scripts
+
+| Script | Description |
+|--------|-------------|
+| `pnpm test` | Run tests |
+| `pnpm build` | Build |
+| `pnpm typecheck` | Type check |

package/db/dist/constants.d.ts

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

package/db/dist/constants.js

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

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

@@ -0,0 +1,3 @@
+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/dist/d1/index.js

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

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

@@ -0,0 +1,18 @@
+import type { Hono } from 'hono';
+import { type ILogger } from '@rx-ted/packages-core';
+import type { IPlugin, Application } from '@rx-ted/packages-honest';
+export declare class D1Plugin implements IPlugin {
+    private options;
+    readonly name = "app:db:d1";
+    readonly version = "0.0.1";
+    logger?: ILogger;
+    private db;
+    constructor(options: {
+        binding?: string;
+        schema: Record<string, any>;
+    });
+    beforeModulesRegistered(app: Application, _hono: Hono): Promise<void>;
+    afterModulesRegistered(_app: Application, _hono: Hono): Promise<void>;
+    close(): Promise<void>;
+    private resolveBindingName;
+}

package/db/dist/d1/plugin.js

@@ -0,0 +1,104 @@
+import { ENV_SYMBOL, Platform, resolveBinding, } from '@rx-ted/packages-core';
+import { ComponentManager, resolvePluginLogger } from '@rx-ted/packages-honest';
+import { drizzle } from 'drizzle-orm/d1';
+import { DB_GLOBAL_KEY } from '../constants';
+import { assertRuntimeSupport } from '../resolve';
+export class D1Plugin {
+    options;
+    name = `${DB_GLOBAL_KEY}:d1`;
+    version = '0.0.1';
+    logger;
+    db = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async beforeModulesRegistered(app, _hono) {
+        this.logger ??= resolvePluginLogger(this.name);
+        const appEnv = ComponentManager.getPlugin(ENV_SYMBOL);
+        assertRuntimeSupport(appEnv.platform, '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[prop];
+                return typeof val === 'function' ? val.bind(instance) : val;
+            },
+        }));
+    }
+    async afterModulesRegistered(_app, _hono) {
+        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() {
+        this.logger?.info(`shutting down (binding: ${this.resolveBindingName()})`);
+    }
+    resolveBindingName() {
+        if (this.options.binding)
+            return this.options.binding;
+        return findD1Binding() ?? 'DB';
+    }
+}
+function isD1Database(value) {
+    return (value !== null && typeof value === 'object' && typeof value.prepare === 'function');
+}
+function findD1Binding() {
+    const sources = [globalThis, globalThis.env, Platform.env()];
+    for (const source of sources) {
+        if (!source || typeof source !== 'object')
+            continue;
+        for (const key of Object.keys(source)) {
+            if (isD1Database(source[key]))
+                return key;
+        }
+    }
+    return null;
+}
+async function healthCheck(db, bindingName) {
+    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/dist/db-service.d.ts

@@ -0,0 +1,7 @@
+import type { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+declare class DbService {
+    constructor();
+}
+interface DbService extends BaseSQLiteDatabase<'async', any> {
+}
+export { DbService };

package/db/dist/db-service.js

@@ -0,0 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Service, ComponentManager } from '@rx-ted/packages-honest';
+import { DB_GLOBAL_KEY } from './constants';
+let DbService = class DbService {
+    constructor() {
+        return ComponentManager.getPlugin(DB_GLOBAL_KEY);
+    }
+};
+DbService = __decorate([
+    Service(),
+    __metadata("design:paramtypes", [])
+], DbService);
+export { DbService };

package/db/dist/index.d.ts

@@ -0,0 +1,15 @@
+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';
+export { eq, and, or, not, inArray, sql, asc, desc, count, like, isNull, isNotNull, } from 'drizzle-orm';
+export * from './mysql';
+export * as mysql from './mysql';
+export * as postgres from './postgres';
+export * as sqlite from './sqlite';
+export * as d1 from './d1';
+export * from './schema-builder';
+export { zdb, getZodDbMeta, isZodObject, toTableDefinition, toColumnDefinition, } from './schema-builder/zod-bridge';
+export type { ZodDbMeta } from './schema-builder/zod-bridge';

package/db/dist/index.js

@@ -0,0 +1,20 @@
+// Common exports
+export { DB_GLOBAL_KEY } from './constants';
+export { DBPlugin, assertRuntimeSupport } from './resolve';
+export { DbService } from './db-service';
+export { BaseRepository } from './repository';
+// 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';

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

@@ -0,0 +1,36 @@
+import { type Pool } from 'mysql2/promise';
+import type { DatabaseClient, DatabaseConnection, PreparedStatement } from '../types';
+export declare 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;
+export declare 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>;
+export declare class MysqlDatabaseClient implements DatabaseClient {
+    private pool;
+    constructor(pool: Pool);
+    prepare(sql: string): PreparedStatement;
+    getConnection(): Promise<DatabaseConnection>;
+    close(): Promise<void>;
+}

package/db/dist/mysql/client.js

@@ -0,0 +1,84 @@
+import MySQL, {} from 'mysql2/promise';
+export function createMysqlPool(options) {
+    const mysqlOptions = {
+        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) {
+    const pool = createMysqlPool(options);
+    const connection = await pool.getConnection();
+    connection.release();
+    return new MysqlDatabaseClient(pool);
+}
+export class MysqlDatabaseClient {
+    pool;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    prepare(sql) {
+        return new MysqlPreparedStatement(this.pool, sql);
+    }
+    async getConnection() {
+        const conn = await this.pool.getConnection();
+        return new MysqlDatabaseConnection(conn);
+    }
+    async close() {
+        await this.pool.end();
+    }
+}
+class MysqlPreparedStatement {
+    client;
+    sql;
+    constructor(client, sql) {
+        this.client = client;
+        this.sql = sql;
+    }
+    async execute(params) {
+        const connection = 'getConnection' in this.client ? await this.client.getConnection() : this.client;
+        try {
+            const [result] = await connection.execute(this.sql, params);
+            return {
+                affectedRows: result.affectedRows,
+                insertId: result.insertId ? Number(result.insertId) : undefined,
+            };
+        }
+        finally {
+            connection.release();
+        }
+    }
+    release() { }
+}
+class MysqlDatabaseConnection {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    prepare(sql) {
+        return new MysqlPreparedStatement(this.connection, sql);
+    }
+    async query(sql, params) {
+        const [rows] = await this.connection.query(sql, params);
+        return rows;
+    }
+    async execute(sql, params) {
+        const [result] = await this.connection.execute(sql, params);
+        return {
+            affectedRows: result.affectedRows,
+            insertId: result.insertId ? Number(result.insertId) : undefined,
+        };
+    }
+    release() {
+        this.connection.release();
+    }
+}