@iskra-bun/db-kit 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @iskra-bun/db-kit
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial public release.

package/README.md

@@ -0,0 +1,29 @@
+# @iskra-bun/db-kit
+
+Base de datos SQL de Iskra con [Drizzle ORM](https://orm.drizzle.team). Soporta PostgreSQL, MySQL, SQLite y LibSQL, e incluye CLI de migraciones.
+
+## Instalacion
+
+```bash
+bun add @iskra-bun/db-kit @iskra-bun/core
+```
+
+## Uso rapido
+
+```typescript
+import { App } from '@iskra-bun/core'
+import { DbDriver } from '@iskra-bun/db-kit'
+
+const app = new App({ name: 'mi-app' })
+app.register(new DbDriver({ dialect: 'sqlite', url: 'app.db' }))
+
+await app.start()
+```
+
+## Documentacion
+
+Guia completa: [docs/db-kit.md](../../docs/db-kit.md) · Migraciones: [docs/migraciones.md](../../docs/migraciones.md)
+
+## Licencia
+
+AGPL-3.0-or-later

package/dist/index.d.ts

@@ -0,0 +1,106 @@
+import { Driver, App, IskraError } from '@iskra-bun/core';
+import * as drizzle_kit from 'drizzle-kit';
+
+declare class DbDriver implements Driver {
+    name: string;
+    private client;
+    db: any;
+    private app;
+    init(app: App): Promise<void>;
+    start(): Promise<void>;
+    /**
+     * Ejecuta migraciones pendientes usando Drizzle Kit.
+     */
+    runMigrations(schemaPath: string, migrationsDir?: string): Promise<void>;
+    stop(): Promise<void>;
+}
+
+declare class ConnectionError extends IskraError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+declare class QueryError extends IskraError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+declare class MigrationError extends IskraError {
+    constructor(message: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+}
+
+interface MigrationConfig {
+    /** Dialecto de la base de datos */
+    dialect: 'postgresql' | 'mysql' | 'sqlite';
+    /** URL de conexión a la base de datos */
+    dbUrl: string;
+    /** Ruta al archivo de schema Drizzle (ej: './src/db/schema.ts') */
+    schemaPath: string;
+    /** Directorio donde se generan las migraciones (ej: './drizzle') */
+    migrationsDir: string;
+}
+/**
+ * Helper para ejecutar migraciones de Drizzle Kit.
+ * Usa `bunx drizzle-kit` como subproceso para generar y aplicar migraciones.
+ */
+declare class MigrationHelper {
+    private config;
+    private app?;
+    constructor(config: MigrationConfig, app?: App);
+    /**
+     * Genera archivos de migración basados en los cambios del schema.
+     */
+    generate(name?: string): Promise<void>;
+    /**
+     * Aplica las migraciones pendientes a la base de datos.
+     */
+    migrate(): Promise<void>;
+    /**
+     * Empuja el schema directamente a la base de datos (sin generar archivos de migración).
+     * Útil para desarrollo rápido.
+     */
+    push(): Promise<void>;
+    /**
+     * Elimina todas las tablas de la base de datos.
+     */
+    drop(): Promise<void>;
+    private exec;
+}
+/**
+ * Mapea el driver de Iskra al dialecto de Drizzle Kit.
+ */
+declare function mapDialect(driver: string): MigrationConfig['dialect'];
+
+interface DrizzleConfigOptions {
+    /** Dialecto: 'postgresql', 'mysql', 'sqlite' */
+    dialect: 'postgresql' | 'mysql' | 'sqlite';
+    /** URL de conexión a la base de datos */
+    dbUrl: string;
+    /** Ruta al archivo de schema (ej: './src/db/schema.ts') */
+    schemaPath: string;
+    /** Directorio de migraciones (ej: './drizzle') */
+    migrationsDir?: string;
+}
+/**
+ * Crea una configuración de drizzle-kit reutilizable.
+ *
+ * Uso en tu proyecto:
+ * ```ts
+ * // drizzle.config.ts
+ * import { createDrizzleConfig } from '@iskra-bun/db-kit';
+ *
+ * export default createDrizzleConfig({
+ *     dialect: 'sqlite',
+ *     dbUrl: process.env.DATABASE_URL || 'app.db',
+ *     schemaPath: './src/db/schema.ts',
+ * });
+ * ```
+ */
+declare function createDrizzleConfig(options: DrizzleConfigOptions): drizzle_kit.Config;
+
+export { ConnectionError, DbDriver, type DrizzleConfigOptions, type MigrationConfig, MigrationError, MigrationHelper, QueryError, createDrizzleConfig, mapDialect };

package/dist/index.js

@@ -0,0 +1,227 @@
+// src/driver.ts
+import { DriverError } from "@iskra-bun/core";
+import { drizzle } from "drizzle-orm/postgres-js";
+import { drizzle as drizzleMysql } from "drizzle-orm/mysql2";
+import postgres from "postgres";
+import mysql from "mysql2/promise";
+
+// src/errors.ts
+import { IskraError, ErrorCodes } from "@iskra-bun/core";
+var ConnectionError = class extends IskraError {
+  constructor(message, options) {
+    super(message, { code: ErrorCodes.CONNECTION_ERROR, ...options });
+    this.name = "ConnectionError";
+  }
+};
+var QueryError = class extends IskraError {
+  constructor(message, options) {
+    super(message, { code: ErrorCodes.QUERY_ERROR, ...options });
+    this.name = "QueryError";
+  }
+};
+var MigrationError = class extends IskraError {
+  constructor(message, options) {
+    super(message, { code: ErrorCodes.MIGRATION_ERROR, ...options });
+    this.name = "MigrationError";
+  }
+};
+
+// src/migrations.ts
+var MigrationHelper = class {
+  config;
+  app;
+  constructor(config, app) {
+    this.config = config;
+    this.app = app;
+  }
+  /**
+   * Genera archivos de migración basados en los cambios del schema.
+   */
+  async generate(name) {
+    const args = ["drizzle-kit", "generate"];
+    if (name) args.push("--name", name);
+    await this.exec(args, "generate");
+  }
+  /**
+   * Aplica las migraciones pendientes a la base de datos.
+   */
+  async migrate() {
+    await this.exec(["drizzle-kit", "migrate"], "migrate");
+  }
+  /**
+   * Empuja el schema directamente a la base de datos (sin generar archivos de migración).
+   * Útil para desarrollo rápido.
+   */
+  async push() {
+    await this.exec(["drizzle-kit", "push"], "push");
+  }
+  /**
+   * Elimina todas las tablas de la base de datos.
+   */
+  async drop() {
+    await this.exec(["drizzle-kit", "drop"], "drop");
+  }
+  async exec(args, operation) {
+    const env = {
+      ...process.env,
+      DATABASE_URL: this.config.dbUrl
+    };
+    this.app?.logger.info(`Running migration: ${operation}`);
+    try {
+      const proc = Bun.spawn(["bunx", ...args], {
+        cwd: process.cwd(),
+        env,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      if (stdout) this.app?.logger.info(stdout.trim());
+      if (exitCode !== 0) {
+        throw new MigrationError(`Migration ${operation} failed with exit code ${exitCode}`, {
+          context: { operation, exitCode, stderr: stderr.trim() }
+        });
+      }
+      this.app?.logger.info(`Migration ${operation} completed successfully`);
+    } catch (error) {
+      if (error instanceof MigrationError) throw error;
+      throw new MigrationError(`Migration ${operation} failed`, {
+        cause: error instanceof Error ? error : new Error(String(error)),
+        context: { operation }
+      });
+    }
+  }
+};
+function mapDialect(driver) {
+  switch (driver) {
+    case "postgres":
+      return "postgresql";
+    case "mysql":
+      return "mysql";
+    case "sqlite":
+    case "libsql":
+      return "sqlite";
+    default:
+      throw new MigrationError(`Cannot map driver "${driver}" to a Drizzle dialect`, {
+        context: { driver }
+      });
+  }
+}
+
+// src/driver.ts
+var DbDriver = class {
+  name = "db";
+  client;
+  db;
+  app;
+  async init(app) {
+    this.app = app;
+    app.context.set("db", this);
+  }
+  async start() {
+    if (!this.app) return;
+    const config = this.app.config.db;
+    if (!config) {
+      this.app.logger.warn("No DB configuration found. Skipping DB initialization.");
+      return;
+    }
+    this.app.logger.info(`Initializing DB driver: ${config.driver}`);
+    try {
+      switch (config.driver) {
+        case "postgres":
+          this.client = postgres(config.url);
+          this.db = drizzle(this.client);
+          break;
+        case "mysql":
+          this.client = await mysql.createConnection(config.url);
+          this.db = drizzleMysql(this.client);
+          break;
+        case "sqlite": {
+          const { Database } = await import("bun:sqlite");
+          const { drizzle: drizzleSqlite } = await import("drizzle-orm/bun-sqlite");
+          this.client = new Database(config.url);
+          this.db = drizzleSqlite(this.client);
+          break;
+        }
+        case "libsql": {
+          const { createClient } = await import("@libsql/client");
+          const { drizzle: drizzleLibsql } = await import("drizzle-orm/libsql");
+          this.client = createClient({ url: config.url, authToken: config.authToken });
+          this.db = drizzleLibsql(this.client);
+          break;
+        }
+        default:
+          throw new DriverError(`Unsupported DB driver: ${config.driver}`, {
+            code: "DRIVER_START_FAILED",
+            context: { driver: config.driver }
+          });
+      }
+      this.app.logger.info("DB connected successfully.");
+    } catch (error) {
+      if (error instanceof DriverError) throw error;
+      this.app.logger.error({ error }, "Failed to connect to DB");
+      throw new ConnectionError("Failed to connect to DB", {
+        cause: error instanceof Error ? error : new Error(String(error)),
+        context: { driver: config.driver, url: config.url }
+      });
+    }
+  }
+  /**
+   * Ejecuta migraciones pendientes usando Drizzle Kit.
+   */
+  async runMigrations(schemaPath, migrationsDir = "./drizzle") {
+    if (!this.app?.config.db) {
+      throw new DriverError("Cannot run migrations: no DB configuration found", {
+        code: "DRIVER_START_FAILED"
+      });
+    }
+    const config = this.app.config.db;
+    const helper = new MigrationHelper(
+      {
+        dialect: mapDialect(config.driver),
+        dbUrl: config.url,
+        schemaPath,
+        migrationsDir
+      },
+      this.app
+    );
+    await helper.migrate();
+  }
+  async stop() {
+    if (this.client) {
+      if (this.client.end) {
+        await this.client.end();
+      } else if (this.client.close) {
+        this.client.close();
+      }
+    }
+  }
+};
+
+// ../../node_modules/drizzle-kit/index.mjs
+function defineConfig(config) {
+  return config;
+}
+
+// src/drizzle.config.template.ts
+function createDrizzleConfig(options) {
+  return defineConfig({
+    dialect: options.dialect,
+    schema: options.schemaPath,
+    out: options.migrationsDir || "./drizzle",
+    dbCredentials: {
+      url: options.dbUrl
+    }
+  });
+}
+export {
+  ConnectionError,
+  DbDriver,
+  MigrationError,
+  MigrationHelper,
+  QueryError,
+  createDrizzleConfig,
+  mapDialect
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/driver.ts","../src/errors.ts","../src/migrations.ts","../../../node_modules/drizzle-kit/index.mjs","../src/drizzle.config.template.ts"],"sourcesContent":["import { type App, type Driver, type AppConfig, DriverError } from '@iskra-bun/core';\nimport { drizzle } from 'drizzle-orm/postgres-js';\nimport { drizzle as drizzleMysql } from 'drizzle-orm/mysql2';\nimport postgres from 'postgres';\nimport mysql from 'mysql2/promise';\nimport { ConnectionError } from './errors';\nimport { MigrationHelper, mapDialect } from './migrations';\n\nexport class DbDriver implements Driver {\n    name = 'db';\n    private client: any;\n    public db: any;\n\n    private app: App | undefined;\n\n    async init(app: App) {\n        this.app = app;\n        app.context.set('db', this);\n    }\n\n    async start() {\n        if (!this.app) return;\n        const config = this.app.config.db;\n        if (!config) {\n            this.app!.logger.warn('No DB configuration found. Skipping DB initialization.');\n            return;\n        }\n\n        this.app!.logger.info(`Initializing DB driver: ${config.driver}`);\n\n        try {\n            switch (config.driver) {\n                case 'postgres':\n                    this.client = postgres(config.url);\n                    this.db = drizzle(this.client);\n                    break;\n                case 'mysql':\n                    this.client = await mysql.createConnection(config.url);\n                    this.db = drizzleMysql(this.client);\n                    break;\n                case 'sqlite': {\n                    const { Database } = await import(\"bun:sqlite\");\n                    const { drizzle: drizzleSqlite } = await import(\"drizzle-orm/bun-sqlite\");\n                    this.client = new Database(config.url);\n                    this.db = drizzleSqlite(this.client);\n                    break;\n                }\n                case 'libsql': {\n                    const { createClient } = await import('@libsql/client');\n                    const { drizzle: drizzleLibsql } = await import('drizzle-orm/libsql');\n                    this.client = createClient({ url: config.url, authToken: config.authToken });\n                    this.db = drizzleLibsql(this.client);\n                    break;\n                }\n                default:\n                    throw new DriverError(`Unsupported DB driver: ${config.driver}`, {\n                        code: 'DRIVER_START_FAILED',\n                        context: { driver: config.driver },\n                    });\n            }\n            this.app!.logger.info('DB connected successfully.');\n        } catch (error) {\n            if (error instanceof DriverError) throw error;\n            this.app!.logger.error({ error }, 'Failed to connect to DB');\n            throw new ConnectionError('Failed to connect to DB', {\n                cause: error instanceof Error ? error : new Error(String(error)),\n                context: { driver: config.driver, url: config.url },\n            });\n        }\n    }\n\n    /**\n     * Ejecuta migraciones pendientes usando Drizzle Kit.\n     */\n    async runMigrations(schemaPath: string, migrationsDir: string = './drizzle'): Promise<void> {\n        if (!this.app?.config.db) {\n            throw new DriverError('Cannot run migrations: no DB configuration found', {\n                code: 'DRIVER_START_FAILED',\n            });\n        }\n\n        const config = this.app.config.db;\n        const helper = new MigrationHelper(\n            {\n                dialect: mapDialect(config.driver),\n                dbUrl: config.url,\n                schemaPath,\n                migrationsDir,\n            },\n            this.app,\n        );\n\n        await helper.migrate();\n    }\n\n    async stop() {\n        if (this.client) {\n            // Close connections based on client type\n            if (this.client.end) { // Postgres usage with postgres.js usually handles itself or has end. \n                // mysql2 has end()\n                await this.client.end();\n            } else if (this.client.close) { // bun:sqlite / libsql\n                this.client.close();\n            }\n            // postgres.js handles cleanup usually but explicit close might be needed depending on version/usage\n        }\n    }\n}\n","import { IskraError, ErrorCodes, type ErrorCode } from '@iskra-bun/core';\n\n// ─── Connection Error ────────────────────────────────────────────────────────\n\nexport class ConnectionError extends IskraError {\n    constructor(message: string, options?: { cause?: Error; context?: Record<string, unknown> }) {\n        super(message, { code: ErrorCodes.CONNECTION_ERROR, ...options });\n        this.name = 'ConnectionError';\n    }\n}\n\n// ─── Query Error ─────────────────────────────────────────────────────────────\n\nexport class QueryError extends IskraError {\n    constructor(message: string, options?: { cause?: Error; context?: Record<string, unknown> }) {\n        super(message, { code: ErrorCodes.QUERY_ERROR, ...options });\n        this.name = 'QueryError';\n    }\n}\n\n// ─── Migration Error ─────────────────────────────────────────────────────────\n\nexport class MigrationError extends IskraError {\n    constructor(message: string, options?: { cause?: Error; context?: Record<string, unknown> }) {\n        super(message, { code: ErrorCodes.MIGRATION_ERROR, ...options });\n        this.name = 'MigrationError';\n    }\n}\n","import { type App } from '@iskra-bun/core';\nimport { MigrationError } from './errors';\n\nexport interface MigrationConfig {\n    /** Dialecto de la base de datos */\n    dialect: 'postgresql' | 'mysql' | 'sqlite';\n    /** URL de conexión a la base de datos */\n    dbUrl: string;\n    /** Ruta al archivo de schema Drizzle (ej: './src/db/schema.ts') */\n    schemaPath: string;\n    /** Directorio donde se generan las migraciones (ej: './drizzle') */\n    migrationsDir: string;\n}\n\n/**\n * Helper para ejecutar migraciones de Drizzle Kit.\n * Usa `bunx drizzle-kit` como subproceso para generar y aplicar migraciones.\n */\nexport class MigrationHelper {\n    private config: MigrationConfig;\n    private app?: App;\n\n    constructor(config: MigrationConfig, app?: App) {\n        this.config = config;\n        this.app = app;\n    }\n\n    /**\n     * Genera archivos de migración basados en los cambios del schema.\n     */\n    async generate(name?: string): Promise<void> {\n        const args = ['drizzle-kit', 'generate'];\n        if (name) args.push('--name', name);\n        await this.exec(args, 'generate');\n    }\n\n    /**\n     * Aplica las migraciones pendientes a la base de datos.\n     */\n    async migrate(): Promise<void> {\n        await this.exec(['drizzle-kit', 'migrate'], 'migrate');\n    }\n\n    /**\n     * Empuja el schema directamente a la base de datos (sin generar archivos de migración).\n     * Útil para desarrollo rápido.\n     */\n    async push(): Promise<void> {\n        await this.exec(['drizzle-kit', 'push'], 'push');\n    }\n\n    /**\n     * Elimina todas las tablas de la base de datos.\n     */\n    async drop(): Promise<void> {\n        await this.exec(['drizzle-kit', 'drop'], 'drop');\n    }\n\n    private async exec(args: string[], operation: string): Promise<void> {\n        const env: Record<string, string> = {\n            ...process.env as Record<string, string>,\n            DATABASE_URL: this.config.dbUrl,\n        };\n\n        this.app?.logger.info(`Running migration: ${operation}`);\n\n        try {\n            const proc = Bun.spawn(['bunx', ...args], {\n                cwd: process.cwd(),\n                env,\n                stdout: 'pipe',\n                stderr: 'pipe',\n            });\n\n            const exitCode = await proc.exited;\n            const stdout = await new Response(proc.stdout).text();\n            const stderr = await new Response(proc.stderr).text();\n\n            if (stdout) this.app?.logger.info(stdout.trim());\n\n            if (exitCode !== 0) {\n                throw new MigrationError(`Migration ${operation} failed with exit code ${exitCode}`, {\n                    context: { operation, exitCode, stderr: stderr.trim() },\n                });\n            }\n\n            this.app?.logger.info(`Migration ${operation} completed successfully`);\n        } catch (error) {\n            if (error instanceof MigrationError) throw error;\n            throw new MigrationError(`Migration ${operation} failed`, {\n                cause: error instanceof Error ? error : new Error(String(error)),\n                context: { operation },\n            });\n        }\n    }\n}\n\n/**\n * Mapea el driver de Iskra al dialecto de Drizzle Kit.\n */\nexport function mapDialect(driver: string): MigrationConfig['dialect'] {\n    switch (driver) {\n        case 'postgres':\n            return 'postgresql';\n        case 'mysql':\n            return 'mysql';\n        case 'sqlite':\n        case 'libsql':\n            return 'sqlite';\n        default:\n            throw new MigrationError(`Cannot map driver \"${driver}\" to a Drizzle dialect`, {\n                context: { driver },\n            });\n    }\n}\n","// src/index.ts\nfunction defineConfig(config) {\n  return config;\n}\nexport {\n  defineConfig\n};\n","import { defineConfig } from 'drizzle-kit';\n\nexport interface DrizzleConfigOptions {\n    /** Dialecto: 'postgresql', 'mysql', 'sqlite' */\n    dialect: 'postgresql' | 'mysql' | 'sqlite';\n    /** URL de conexión a la base de datos */\n    dbUrl: string;\n    /** Ruta al archivo de schema (ej: './src/db/schema.ts') */\n    schemaPath: string;\n    /** Directorio de migraciones (ej: './drizzle') */\n    migrationsDir?: string;\n}\n\n/**\n * Crea una configuración de drizzle-kit reutilizable.\n *\n * Uso en tu proyecto:\n * ```ts\n * // drizzle.config.ts\n * import { createDrizzleConfig } from '@iskra-bun/db-kit';\n *\n * export default createDrizzleConfig({\n *     dialect: 'sqlite',\n *     dbUrl: process.env.DATABASE_URL || 'app.db',\n *     schemaPath: './src/db/schema.ts',\n * });\n * ```\n */\nexport function createDrizzleConfig(options: DrizzleConfigOptions) {\n    return defineConfig({\n        dialect: options.dialect,\n        schema: options.schemaPath,\n        out: options.migrationsDir || './drizzle',\n        dbCredentials: {\n            url: options.dbUrl,\n        },\n    });\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,62 @@
+{
+    "name": "@iskra-bun/db-kit",
+    "version": "0.1.0",
+    "description": "Base de datos SQL de Iskra con Drizzle ORM (PostgreSQL, MySQL, SQLite, LibSQL).",
+    "keywords": [
+        "iskra",
+        "bun",
+        "typescript",
+        "drizzle",
+        "sql",
+        "database",
+        "postgresql",
+        "mysql",
+        "sqlite"
+    ],
+    "author": "Joan Lascano",
+    "license": "AGPL-3.0-or-later",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/fearful/iskra.git",
+        "directory": "packages/db-kit"
+    },
+    "homepage": "https://github.com/fearful/iskra/tree/main/packages/db-kit#readme",
+    "bugs": "https://github.com/fearful/iskra/issues",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "bun": "./src/index.ts",
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "src",
+        "README.md",
+        "CHANGELOG.md"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "test": "bun test",
+        "build": "tsup --config ../../tsup.config.ts"
+    },
+    "dependencies": {
+        "@iskra-bun/core": "0.1.0",
+        "drizzle-orm": "^0.30.0",
+        "postgres": "^3.4.4",
+        "mysql2": "^3.9.2",
+        "@libsql/client": "^0.6.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.10.2",
+        "drizzle-kit": "^0.30.0"
+    }
+}

package/src/cli.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env bun
+/**
+ * CLI para migraciones de Iskra DB Kit.
+ *
+ * Uso:
+ *   bun run packages/db-kit/src/cli.ts generate [nombre]
+ *   bun run packages/db-kit/src/cli.ts migrate
+ *   bun run packages/db-kit/src/cli.ts push
+ *   bun run packages/db-kit/src/cli.ts drop
+ *
+ * Requiere un archivo drizzle.config.ts en el directorio actual.
+ */
+
+const [command, ...rest] = process.argv.slice(2);
+
+const validCommands = ['generate', 'migrate', 'push', 'drop'];
+
+if (!command || !validCommands.includes(command)) {
+    console.log(`
+Iskra DB Kit — CLI de Migraciones
+
+Uso:
+  bun run packages/db-kit/src/cli.ts <comando> [opciones]
+
+Comandos:
+  generate [nombre]  Genera archivos de migración a partir del schema
+  migrate            Aplica migraciones pendientes
+  push               Empuja el schema directo a la DB (sin migración)
+  drop               Elimina todas las tablas
+`);
+    process.exit(command ? 1 : 0);
+}
+
+const args = ['bunx', 'drizzle-kit', command, ...rest];
+
+console.log(`> ${args.join(' ')}`);
+
+const proc = Bun.spawn(args, {
+    cwd: process.cwd(),
+    stdout: 'inherit',
+    stderr: 'inherit',
+    env: process.env as Record<string, string>,
+});
+
+const exitCode = await proc.exited;
+process.exit(exitCode);
+
+export {};

package/src/driver.ts

@@ -0,0 +1,108 @@
+import { type App, type Driver, type AppConfig, DriverError } from '@iskra-bun/core';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { drizzle as drizzleMysql } from 'drizzle-orm/mysql2';
+import postgres from 'postgres';
+import mysql from 'mysql2/promise';
+import { ConnectionError } from './errors';
+import { MigrationHelper, mapDialect } from './migrations';
+
+export class DbDriver implements Driver {
+    name = 'db';
+    private client: any;
+    public db: any;
+
+    private app: App | undefined;
+
+    async init(app: App) {
+        this.app = app;
+        app.context.set('db', this);
+    }
+
+    async start() {
+        if (!this.app) return;
+        const config = this.app.config.db;
+        if (!config) {
+            this.app!.logger.warn('No DB configuration found. Skipping DB initialization.');
+            return;
+        }
+
+        this.app!.logger.info(`Initializing DB driver: ${config.driver}`);
+
+        try {
+            switch (config.driver) {
+                case 'postgres':
+                    this.client = postgres(config.url);
+                    this.db = drizzle(this.client);
+                    break;
+                case 'mysql':
+                    this.client = await mysql.createConnection(config.url);
+                    this.db = drizzleMysql(this.client);
+                    break;
+                case 'sqlite': {
+                    const { Database } = await import("bun:sqlite");
+                    const { drizzle: drizzleSqlite } = await import("drizzle-orm/bun-sqlite");
+                    this.client = new Database(config.url);
+                    this.db = drizzleSqlite(this.client);
+                    break;
+                }
+                case 'libsql': {
+                    const { createClient } = await import('@libsql/client');
+                    const { drizzle: drizzleLibsql } = await import('drizzle-orm/libsql');
+                    this.client = createClient({ url: config.url, authToken: config.authToken });
+                    this.db = drizzleLibsql(this.client);
+                    break;
+                }
+                default:
+                    throw new DriverError(`Unsupported DB driver: ${config.driver}`, {
+                        code: 'DRIVER_START_FAILED',
+                        context: { driver: config.driver },
+                    });
+            }
+            this.app!.logger.info('DB connected successfully.');
+        } catch (error) {
+            if (error instanceof DriverError) throw error;
+            this.app!.logger.error({ error }, 'Failed to connect to DB');
+            throw new ConnectionError('Failed to connect to DB', {
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { driver: config.driver, url: config.url },
+            });
+        }
+    }
+
+    /**
+     * Ejecuta migraciones pendientes usando Drizzle Kit.
+     */
+    async runMigrations(schemaPath: string, migrationsDir: string = './drizzle'): Promise<void> {
+        if (!this.app?.config.db) {
+            throw new DriverError('Cannot run migrations: no DB configuration found', {
+                code: 'DRIVER_START_FAILED',
+            });
+        }
+
+        const config = this.app.config.db;
+        const helper = new MigrationHelper(
+            {
+                dialect: mapDialect(config.driver),
+                dbUrl: config.url,
+                schemaPath,
+                migrationsDir,
+            },
+            this.app,
+        );
+
+        await helper.migrate();
+    }
+
+    async stop() {
+        if (this.client) {
+            // Close connections based on client type
+            if (this.client.end) { // Postgres usage with postgres.js usually handles itself or has end. 
+                // mysql2 has end()
+                await this.client.end();
+            } else if (this.client.close) { // bun:sqlite / libsql
+                this.client.close();
+            }
+            // postgres.js handles cleanup usually but explicit close might be needed depending on version/usage
+        }
+    }
+}

package/src/drizzle.config.template.ts

@@ -0,0 +1,38 @@
+import { defineConfig } from 'drizzle-kit';
+
+export interface DrizzleConfigOptions {
+    /** Dialecto: 'postgresql', 'mysql', 'sqlite' */
+    dialect: 'postgresql' | 'mysql' | 'sqlite';
+    /** URL de conexión a la base de datos */
+    dbUrl: string;
+    /** Ruta al archivo de schema (ej: './src/db/schema.ts') */
+    schemaPath: string;
+    /** Directorio de migraciones (ej: './drizzle') */
+    migrationsDir?: string;
+}
+
+/**
+ * Crea una configuración de drizzle-kit reutilizable.
+ *
+ * Uso en tu proyecto:
+ * ```ts
+ * // drizzle.config.ts
+ * import { createDrizzleConfig } from '@iskra-bun/db-kit';
+ *
+ * export default createDrizzleConfig({
+ *     dialect: 'sqlite',
+ *     dbUrl: process.env.DATABASE_URL || 'app.db',
+ *     schemaPath: './src/db/schema.ts',
+ * });
+ * ```
+ */
+export function createDrizzleConfig(options: DrizzleConfigOptions) {
+    return defineConfig({
+        dialect: options.dialect,
+        schema: options.schemaPath,
+        out: options.migrationsDir || './drizzle',
+        dbCredentials: {
+            url: options.dbUrl,
+        },
+    });
+}

package/src/errors.ts

@@ -0,0 +1,28 @@
+import { IskraError, ErrorCodes, type ErrorCode } from '@iskra-bun/core';
+
+// ─── Connection Error ────────────────────────────────────────────────────────
+
+export class ConnectionError extends IskraError {
+    constructor(message: string, options?: { cause?: Error; context?: Record<string, unknown> }) {
+        super(message, { code: ErrorCodes.CONNECTION_ERROR, ...options });
+        this.name = 'ConnectionError';
+    }
+}
+
+// ─── Query Error ─────────────────────────────────────────────────────────────
+
+export class QueryError extends IskraError {
+    constructor(message: string, options?: { cause?: Error; context?: Record<string, unknown> }) {
+        super(message, { code: ErrorCodes.QUERY_ERROR, ...options });
+        this.name = 'QueryError';
+    }
+}
+
+// ─── Migration Error ─────────────────────────────────────────────────────────
+
+export class MigrationError extends IskraError {
+    constructor(message: string, options?: { cause?: Error; context?: Record<string, unknown> }) {
+        super(message, { code: ErrorCodes.MIGRATION_ERROR, ...options });
+        this.name = 'MigrationError';
+    }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './driver';
+export * from './errors';
+export * from './migrations';
+export { createDrizzleConfig, type DrizzleConfigOptions } from './drizzle.config.template';

package/src/migrations.ts

@@ -0,0 +1,115 @@
+import { type App } from '@iskra-bun/core';
+import { MigrationError } from './errors';
+
+export interface MigrationConfig {
+    /** Dialecto de la base de datos */
+    dialect: 'postgresql' | 'mysql' | 'sqlite';
+    /** URL de conexión a la base de datos */
+    dbUrl: string;
+    /** Ruta al archivo de schema Drizzle (ej: './src/db/schema.ts') */
+    schemaPath: string;
+    /** Directorio donde se generan las migraciones (ej: './drizzle') */
+    migrationsDir: string;
+}
+
+/**
+ * Helper para ejecutar migraciones de Drizzle Kit.
+ * Usa `bunx drizzle-kit` como subproceso para generar y aplicar migraciones.
+ */
+export class MigrationHelper {
+    private config: MigrationConfig;
+    private app?: App;
+
+    constructor(config: MigrationConfig, app?: App) {
+        this.config = config;
+        this.app = app;
+    }
+
+    /**
+     * Genera archivos de migración basados en los cambios del schema.
+     */
+    async generate(name?: string): Promise<void> {
+        const args = ['drizzle-kit', 'generate'];
+        if (name) args.push('--name', name);
+        await this.exec(args, 'generate');
+    }
+
+    /**
+     * Aplica las migraciones pendientes a la base de datos.
+     */
+    async migrate(): Promise<void> {
+        await this.exec(['drizzle-kit', 'migrate'], 'migrate');
+    }
+
+    /**
+     * Empuja el schema directamente a la base de datos (sin generar archivos de migración).
+     * Útil para desarrollo rápido.
+     */
+    async push(): Promise<void> {
+        await this.exec(['drizzle-kit', 'push'], 'push');
+    }
+
+    /**
+     * Elimina todas las tablas de la base de datos.
+     */
+    async drop(): Promise<void> {
+        await this.exec(['drizzle-kit', 'drop'], 'drop');
+    }
+
+    private async exec(args: string[], operation: string): Promise<void> {
+        const env: Record<string, string> = {
+            ...process.env as Record<string, string>,
+            DATABASE_URL: this.config.dbUrl,
+        };
+
+        this.app?.logger.info(`Running migration: ${operation}`);
+
+        try {
+            const proc = Bun.spawn(['bunx', ...args], {
+                cwd: process.cwd(),
+                env,
+                stdout: 'pipe',
+                stderr: 'pipe',
+            });
+
+            const exitCode = await proc.exited;
+            const stdout = await new Response(proc.stdout).text();
+            const stderr = await new Response(proc.stderr).text();
+
+            if (stdout) this.app?.logger.info(stdout.trim());
+
+            if (exitCode !== 0) {
+                throw new MigrationError(`Migration ${operation} failed with exit code ${exitCode}`, {
+                    context: { operation, exitCode, stderr: stderr.trim() },
+                });
+            }
+
+            this.app?.logger.info(`Migration ${operation} completed successfully`);
+        } catch (error) {
+            if (error instanceof MigrationError) throw error;
+            throw new MigrationError(`Migration ${operation} failed`, {
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { operation },
+            });
+        }
+    }
+}
+
+/**
+ * Mapea el driver de Iskra al dialecto de Drizzle Kit.
+ */
+export function mapDialect(driver: string): MigrationConfig['dialect'] {
+    switch (driver) {
+        case 'postgres':
+            return 'postgresql';
+        case 'mysql':
+            return 'mysql';
+        case 'sqlite':
+        case 'libsql':
+            return 'sqlite';
+        default:
+            throw new MigrationError(`Cannot map driver "${driver}" to a Drizzle dialect`, {
+                context: { driver },
+            });
+    }
+}