@onebun/drizzle 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/drizzle",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Drizzle ORM module for OneBun framework - SQLite and PostgreSQL support",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -47,9 +47,9 @@
     "dev": "bun run --watch src/index.ts"
   },
   "dependencies": {
-    "@onebun/core": "^0.1.7",
-    "@onebun/envs": "^0.1.2",
-    "@onebun/logger": "^0.1.3",
+    "@onebun/core": "^0.1.11",
+    "@onebun/envs": "^0.1.4",
+    "@onebun/logger": "^0.1.5",
     "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/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;
 }
 
 /**