@onebun/drizzle 0.1.4 → 0.1.6

package/bin/drizzle-kit.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+/**
+ * CLI wrapper for drizzle-kit
+ *
+ * This wrapper ensures that the correct version of drizzle-kit is used
+ * (the one installed with \@onebun/drizzle) instead of a potentially
+ * different version that bunx might download from npm.
+ *
+ * Usage:
+ *   bunx onebun-drizzle generate
+ *   bunx onebun-drizzle push
+ *   bunx onebun-drizzle studio
+ */
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+import { spawn } from 'bun';
+
+// Find drizzle-kit binary - resolve the package path without executing it
+const drizzleKitModulePath = import.meta.resolve('drizzle-kit');
+const drizzleKitDir = dirname(fileURLToPath(drizzleKitModulePath));
+const drizzleKitBin = join(drizzleKitDir, 'bin.cjs');
+
+// Pass all arguments to drizzle-kit
+const args = Bun.argv.slice(2);
+
+const proc = spawn(['bun', drizzleKitBin, ...args], {
+  stdout: 'inherit',
+  stderr: 'inherit',
+  stdin: 'inherit',
+});
+
+const exitCode = await proc.exited;
+process.exit(exitCode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/drizzle",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Drizzle ORM module for OneBun framework - SQLite and PostgreSQL support",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -27,20 +27,29 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "bin": {
+    "onebun-drizzle": "./bin/drizzle-kit.ts"
+  },
   "files": [
     "src",
+    "bin",
     "README.md"
   ],
   "main": "src/index.ts",
   "module": "src/index.ts",
   "types": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./pg": "./src/pg.ts",
+    "./sqlite": "./src/sqlite.ts"
+  },
   "scripts": {
     "dev": "bun run --watch src/index.ts"
   },
   "dependencies": {
-    "@onebun/core": "^0.1.6",
-    "@onebun/envs": "^0.1.2",
-    "@onebun/logger": "^0.1.3",
+    "@onebun/core": "^0.1.9",
+    "@onebun/envs": "^0.1.3",
+    "@onebun/logger": "^0.1.4",
     "drizzle-orm": "^0.44.7",
     "drizzle-kit": "^0.31.6",
     "drizzle-arktype": "^0.1.3",

package/src/drizzle.module.ts

@@ -1,6 +1,10 @@
 import type { DrizzleModuleOptions } from './types';
 
-import { Module } from '@onebun/core';
+import {
+  Global,
+  Module,
+  removeFromGlobalModules,
+} from '@onebun/core';
 
 
 import { DrizzleService } from './drizzle.service';
@@ -15,6 +19,9 @@ const DRIZZLE_MODULE_OPTIONS = Symbol('DRIZZLE_MODULE_OPTIONS');
  * Uses Bun.SQL for PostgreSQL (built-in Bun adapter) and bun:sqlite for SQLite.
  * No external database drivers required - uses native Bun capabilities.
  * 
+ * By default, DrizzleModule is global - DrizzleService is available in all modules
+ * without explicit import. Use `isGlobal: false` to disable this behavior.
+ * 
  * Configuration is loaded from environment variables by default,
  * but can be overridden with module options.
  * 
@@ -26,7 +33,7 @@ const DRIZZLE_MODULE_OPTIONS = Symbol('DRIZZLE_MODULE_OPTIONS');
  * - DB_AUTO_MIGRATE: Whether to run migrations on startup (default: false)
  * - DB_LOG_QUERIES: Whether to log SQL queries (default: false)
  * 
- * @example Basic usage with environment variables
+ * @example Basic usage with environment variables (global by default)
  * ```typescript
  * import { Module } from '@onebun/core';
  * import { DrizzleModule } from '@onebun/drizzle';
@@ -36,6 +43,13 @@ const DRIZZLE_MODULE_OPTIONS = Symbol('DRIZZLE_MODULE_OPTIONS');
  *   controllers: [MyController],
  * })
  * export class AppModule {}
+ * 
+ * // DrizzleService is automatically available in all submodules
+ * @Module({
+ *   controllers: [UserController],
+ *   providers: [UserService], // UserService can inject DrizzleService
+ * })
+ * export class UserModule {}
  * ```
  * 
  * @example With module options (overrides environment variables)
@@ -61,6 +75,22 @@ const DRIZZLE_MODULE_OPTIONS = Symbol('DRIZZLE_MODULE_OPTIONS');
  * export class AppModule {}
  * ```
  * 
+ * @example Non-global mode (for multi-database scenarios)
+ * ```typescript
+ * // Each import creates a new DrizzleService instance
+ * DrizzleModule.forRoot({
+ *   connection: { ... },
+ *   isGlobal: false,
+ * })
+ * 
+ * // Submodules must explicitly import DrizzleModule.forFeature()
+ * @Module({
+ *   imports: [DrizzleModule.forFeature()],
+ *   providers: [UserService],
+ * })
+ * export class UserModule {}
+ * ```
+ * 
  * Then inject DrizzleService in your controller:
  * ```typescript
  * import { Controller, Get } from '@onebun/core';
@@ -79,6 +109,7 @@ const DRIZZLE_MODULE_OPTIONS = Symbol('DRIZZLE_MODULE_OPTIONS');
  * }
  * ```
  */
+@Global()
 @Module({
   providers: [DrizzleService],
   exports: [DrizzleService],
@@ -88,27 +119,84 @@ export class DrizzleModule {
    * Configure drizzle module with custom options
    * Options will override environment variables
    * 
+   * By default, isGlobal is true - DrizzleService is available in all modules.
+   * Set isGlobal: false for multi-database scenarios where each import
+   * should create a new DrizzleService instance.
+   * 
    * @param options - Drizzle module configuration options
    * @returns Module class with configuration
    * 
-   * @example
+   * @example Global mode (default)
    * ```typescript
    * DrizzleModule.forRoot({
    *   connection: {
    *     type: DatabaseType.SQLITE,
-   *     options: {
-   *       url: './data.db',
-   *     },
+   *     options: { url: './data.db' },
    *   },
    *   autoMigrate: true,
    * })
    * ```
+   * 
+   * @example Non-global mode (for multiple databases)
+   * ```typescript
+   * DrizzleModule.forRoot({
+   *   connection: {
+   *     type: DatabaseType.POSTGRESQL,
+   *     options: { ... },
+   *   },
+   *   isGlobal: false, // Each import creates new instance
+   * })
+   * ```
    */
   static forRoot(options: DrizzleModuleOptions): typeof DrizzleModule {
     // Store options in a static property that DrizzleService can access
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (DrizzleModule as any)[DRIZZLE_MODULE_OPTIONS] = options;
 
+    // If isGlobal is explicitly set to false, remove from global modules registry
+    // This allows creating separate DrizzleService instances for multi-DB scenarios
+    if (options.isGlobal === false) {
+      removeFromGlobalModules(DrizzleModule);
+    }
+
+    return DrizzleModule;
+  }
+
+  /**
+   * Import DrizzleModule into a feature module
+   * 
+   * Use this method when DrizzleModule is not global (isGlobal: false)
+   * and you need to explicitly import DrizzleService in a submodule.
+   * 
+   * When DrizzleModule is global (default), you don't need to use forFeature() -
+   * DrizzleService is automatically available in all modules.
+   * 
+   * @returns Module class that exports DrizzleService
+   * 
+   * @example
+   * ```typescript
+   * // In root module: non-global DrizzleModule
+   * @Module({
+   *   imports: [
+   *     DrizzleModule.forRoot({
+   *       connection: { ... },
+   *       isGlobal: false,
+   *     }),
+   *   ],
+   * })
+   * export class AppModule {}
+   * 
+   * // In feature module: explicitly import DrizzleService
+   * @Module({
+   *   imports: [DrizzleModule.forFeature()],
+   *   providers: [UserService],
+   * })
+   * export class UserModule {}
+   * ```
+   */
+  static forFeature(): typeof DrizzleModule {
+    // Simply return the module class - it already exports DrizzleService
+    // The module system will handle service instance resolution
     return DrizzleModule;
   }
 

package/src/drizzle.service.ts

@@ -183,8 +183,8 @@ export class DrizzleService<TDbType extends DatabaseTypeLiteral = DatabaseTypeLi
   private sqliteClient: Database | null = null;
   private postgresClient: SQL | null = null;
 
-  constructor(...args: unknown[]) {
-    super(...args);
+  constructor() {
+    super();
     // Only start auto-initialization if there's configuration to use
     // Check synchronously to avoid unnecessary async work
     if (this.shouldAutoInitialize()) {

package/src/index.ts

@@ -49,3 +49,77 @@ export { generateMigrations, pushSchema } from './migrations';
 
 // Validation utilities
 export * from './validation';
+
+// ============================================================================
+// Re-exports from drizzle-orm (common utilities for all dialects)
+// ============================================================================
+
+// Query operators - comparison
+export {
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  between,
+  notBetween,
+} from 'drizzle-orm';
+
+// Query operators - logical
+export {
+  and,
+  or,
+  not,
+} from 'drizzle-orm';
+
+// Query operators - pattern matching
+export {
+  like,
+  ilike,
+  notLike,
+  notIlike,
+} from 'drizzle-orm';
+
+// Query operators - array
+export {
+  inArray,
+  notInArray,
+} from 'drizzle-orm';
+
+// Query operators - null
+export {
+  isNull,
+  isNotNull,
+} from 'drizzle-orm';
+
+// SQL template and raw
+export {
+  sql,
+} from 'drizzle-orm';
+
+// Aggregates
+export {
+  count,
+  sum,
+  avg,
+  min,
+  max,
+} from 'drizzle-orm';
+
+// Ordering
+export {
+  asc,
+  desc,
+} from 'drizzle-orm';
+
+// Relations
+export {
+  relations,
+} from 'drizzle-orm';
+
+// ============================================================================
+// Re-exports from drizzle-kit (config helper)
+// ============================================================================
+
+export { defineConfig } from 'drizzle-kit';

package/src/pg.ts

@@ -0,0 +1,67 @@
+/**
+ * PostgreSQL schema builders re-exported from drizzle-orm/pg-core
+ *
+ * Usage:
+ * ```typescript
+ * import { pgTable, text, integer, timestamp, uuid } from '@onebun/drizzle/pg';
+ * ```
+ */
+
+// Table and schema builders
+export {
+  pgTable,
+  pgSchema,
+  pgEnum,
+  pgView,
+  pgMaterializedView,
+  pgSequence,
+} from 'drizzle-orm/pg-core';
+
+// Column types
+export {
+  bigint,
+  bigserial,
+  boolean,
+  char,
+  cidr,
+  customType,
+  date,
+  doublePrecision,
+  inet,
+  integer,
+  interval,
+  json,
+  jsonb,
+  line,
+  macaddr,
+  macaddr8,
+  numeric,
+  point,
+  real,
+  serial,
+  smallint,
+  smallserial,
+  text,
+  time,
+  timestamp,
+  uuid,
+  varchar,
+} from 'drizzle-orm/pg-core';
+
+// Constraints and indexes
+export {
+  check,
+  foreignKey,
+  index,
+  primaryKey,
+  unique,
+  uniqueIndex,
+} from 'drizzle-orm/pg-core';
+
+// Types for type inference
+export type {
+  PgTable,
+  PgColumn,
+  PgEnum,
+  PgTableWithColumns,
+} from 'drizzle-orm/pg-core';

package/src/sqlite.ts

@@ -0,0 +1,41 @@
+/**
+ * SQLite schema builders re-exported from drizzle-orm/sqlite-core
+ *
+ * Usage:
+ * ```typescript
+ * import { sqliteTable, text, integer, real, blob } from '@onebun/drizzle/sqlite';
+ * ```
+ */
+
+// Table and view builders
+export {
+  sqliteTable,
+  sqliteView,
+} from 'drizzle-orm/sqlite-core';
+
+// Column types
+export {
+  blob,
+  customType,
+  integer,
+  numeric,
+  real,
+  text,
+} from 'drizzle-orm/sqlite-core';
+
+// Constraints and indexes
+export {
+  check,
+  foreignKey,
+  index,
+  primaryKey,
+  unique,
+  uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+
+// Types for type inference
+export type {
+  SQLiteTable,
+  SQLiteColumn,
+  SQLiteTableWithColumns,
+} from 'drizzle-orm/sqlite-core';

package/src/types.ts

@@ -134,6 +134,14 @@ export interface DrizzleModuleOptions {
    * Default: false
    */
   logQueries?: boolean;
+  
+  /**
+   * Whether to register module as global
+   * When true, DrizzleService is available in all modules without explicit import.
+   * When false, each import creates a new instance (useful for multi-database scenarios).
+   * Default: true
+   */
+  isGlobal?: boolean;
 }
 
 /**