@veloxts/orm 0.6.55 → 0.6.57

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @veloxts/orm
 
+## 0.6.57
+
+### Patch Changes
+
+- feat: add DI support to ecosystem packages and main packages
+- Updated dependencies
+  - @veloxts/core@0.6.57
+
+## 0.6.56
+
+### Patch Changes
+
+- fix(create): resolve TypeScript errors in RSC templates
+- Updated dependencies
+  - @veloxts/core@0.6.56
+
 ## 0.6.55
 
 ### Patch Changes

package/dist/index.d.ts

@@ -111,3 +111,22 @@ export {
  * ```
  */
 databasePlugin, } from './plugin.js';
+/**
+ * DI tokens and providers for @veloxts/orm
+ *
+ * Use these to integrate ORM services with the @veloxts/core DI container.
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { registerOrmProviders, DATABASE, DATABASE_CLIENT } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * const client = container.resolve(DATABASE_CLIENT);
+ * ```
+ */
+export { databaseProvider, registerOrmProviders, registerTenantProviders, tenantClientPoolProvider, tenantProvisionerProvider, tenantSchemaManagerProvider, } from './providers.js';
+export { DATABASE, DATABASE_CLIENT, DATABASE_CONFIG, PUBLIC_DATABASE_CLIENT, TENANT_CLIENT_POOL, TENANT_CLIENT_POOL_CONFIG, TENANT_MIDDLEWARE_CONFIG, TENANT_PROVISIONER, TENANT_PROVISIONER_CONFIG, TENANT_SCHEMA_MANAGER, TENANT_SCHEMA_MANAGER_CONFIG, } from './tokens.js';

package/dist/index.js

@@ -87,3 +87,35 @@ export {
  * ```
  */
 databasePlugin, } from './plugin.js';
+// ============================================================================
+// Dependency Injection
+// ============================================================================
+/**
+ * DI tokens and providers for @veloxts/orm
+ *
+ * Use these to integrate ORM services with the @veloxts/core DI container.
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { registerOrmProviders, DATABASE, DATABASE_CLIENT } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * const client = container.resolve(DATABASE_CLIENT);
+ * ```
+ */
+// Provider exports - factory functions for registering services
+export { databaseProvider, registerOrmProviders, registerTenantProviders, tenantClientPoolProvider, tenantProvisionerProvider, tenantSchemaManagerProvider, } from './providers.js';
+// Token exports - unique identifiers for DI resolution
+export { 
+// Core database tokens
+DATABASE, DATABASE_CLIENT, DATABASE_CONFIG, 
+// Public database token (multi-tenant)
+PUBLIC_DATABASE_CLIENT, 
+// Tenant service tokens
+TENANT_CLIENT_POOL, 
+// Tenant config tokens
+TENANT_CLIENT_POOL_CONFIG, TENANT_MIDDLEWARE_CONFIG, TENANT_PROVISIONER, TENANT_PROVISIONER_CONFIG, TENANT_SCHEMA_MANAGER, TENANT_SCHEMA_MANAGER_CONFIG, } from './tokens.js';

package/dist/plugin.d.ts

@@ -90,6 +90,19 @@ declare module '@veloxts/core' {
  *
  * @example
  * ```typescript
+ * // With DI container
+ * import { Container } from '@veloxts/core';
+ * import { databasePlugin, DATABASE } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * await app.use(databasePlugin({ client: prisma, container }));
+ *
+ * // Resolve from container
+ * const db = container.resolve(DATABASE);
+ * ```
+ *
+ * @example
+ * ```typescript
  * // Using ctx.db in procedures
  * import { defineProcedures, procedure } from '@veloxts/router';
  * import { z } from '@veloxts/validation';

package/dist/plugin.js

@@ -8,6 +8,8 @@
  */
 import { ConfigurationError, definePlugin } from '@veloxts/core';
 import { createDatabase } from './client.js';
+import { registerOrmProviders } from './providers.js';
+import { DATABASE } from './tokens.js';
 import { isDatabaseClient } from './types.js';
 // ============================================================================
 // Plugin Implementation
@@ -53,6 +55,19 @@ const DEFAULT_PLUGIN_NAME = '@veloxts/orm';
  *
  * @example
  * ```typescript
+ * // With DI container
+ * import { Container } from '@veloxts/core';
+ * import { databasePlugin, DATABASE } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * await app.use(databasePlugin({ client: prisma, container }));
+ *
+ * // Resolve from container
+ * const db = container.resolve(DATABASE);
+ * ```
+ *
+ * @example
+ * ```typescript
  * // Using ctx.db in procedures
  * import { defineProcedures, procedure } from '@veloxts/router';
  * import { z } from '@veloxts/validation';
@@ -89,6 +104,7 @@ export function databasePlugin(config) {
             'Ensure you are passing a valid Prisma client instance.');
     }
     const pluginName = config.name ?? DEFAULT_PLUGIN_NAME;
+    const { container } = config;
     // Plugin state - holds the database wrapper
     const state = {
         database: null,
@@ -97,8 +113,15 @@ export function databasePlugin(config) {
         name: pluginName,
         version: ORM_PLUGIN_VERSION,
         async register(server) {
-            // Create the database wrapper
-            state.database = createDatabase({ client: config.client });
+            if (container) {
+                // DI-enabled path: Register providers and resolve from container
+                registerOrmProviders(container, config);
+                state.database = container.resolve(DATABASE);
+            }
+            else {
+                // Legacy path: Direct instantiation (backward compatible)
+                state.database = createDatabase({ client: config.client });
+            }
             // Connect to the database
             await state.database.connect();
             // Add database client to request context via onRequest hook

package/dist/providers.d.ts

@@ -0,0 +1,157 @@
+/**
+ * DI Providers for @veloxts/orm
+ *
+ * Factory provider functions for registering ORM services with the DI container.
+ * These providers allow services to be managed by the container for testability and flexibility.
+ *
+ * @module orm/providers
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { registerOrmProviders, DATABASE, DATABASE_CLIENT } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * await db.connect();
+ * ```
+ */
+import { type Container, type FactoryProvider } from '@veloxts/core';
+import { type Database } from './client.js';
+import type { TenantClientPool, TenantClientPoolConfig, TenantProvisioner, TenantProvisionerConfig, TenantSchemaManager, TenantSchemaManagerConfig } from './tenant/types.js';
+import type { DatabaseClient, OrmPluginConfig } from './types.js';
+/**
+ * Creates a factory provider for the database wrapper
+ *
+ * Requires DATABASE_CLIENT to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({ provide: DATABASE_CLIENT, useValue: prisma });
+ * container.register(databaseProvider());
+ * const db = container.resolve(DATABASE);
+ * ```
+ */
+export declare function databaseProvider(): FactoryProvider<Database<DatabaseClient>>;
+/**
+ * Creates a factory provider for the tenant client pool
+ *
+ * Requires TENANT_CLIENT_POOL_CONFIG to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({
+ *   provide: TENANT_CLIENT_POOL_CONFIG,
+ *   useValue: {
+ *     baseDatabaseUrl: process.env.DATABASE_URL,
+ *     createClient: (schema) => new PrismaClient({ ... }),
+ *   }
+ * });
+ * container.register(tenantClientPoolProvider());
+ * const pool = container.resolve(TENANT_CLIENT_POOL);
+ * ```
+ */
+export declare function tenantClientPoolProvider(): FactoryProvider<TenantClientPool<DatabaseClient>>;
+/**
+ * Creates a factory provider for the tenant schema manager
+ *
+ * Requires TENANT_SCHEMA_MANAGER_CONFIG to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({
+ *   provide: TENANT_SCHEMA_MANAGER_CONFIG,
+ *   useValue: { databaseUrl: process.env.DATABASE_URL }
+ * });
+ * container.register(tenantSchemaManagerProvider());
+ * const schemaManager = container.resolve(TENANT_SCHEMA_MANAGER);
+ * ```
+ */
+export declare function tenantSchemaManagerProvider(): FactoryProvider<TenantSchemaManager>;
+/**
+ * Creates a factory provider for the tenant provisioner
+ *
+ * Requires TENANT_PROVISIONER_CONFIG to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({
+ *   provide: TENANT_PROVISIONER_CONFIG,
+ *   useValue: {
+ *     schemaManager: container.resolve(TENANT_SCHEMA_MANAGER),
+ *     publicClient: prisma,
+ *     clientPool: container.resolve(TENANT_CLIENT_POOL),
+ *   }
+ * });
+ * container.register(tenantProvisionerProvider());
+ * const provisioner = container.resolve(TENANT_PROVISIONER);
+ * ```
+ */
+export declare function tenantProvisionerProvider(): FactoryProvider<TenantProvisioner>;
+/**
+ * Registers core ORM providers with a container
+ *
+ * This registers the database client and wrapper for basic ORM usage.
+ * For multi-tenant scenarios, use `registerTenantProviders` as well.
+ *
+ * @param container - The DI container to register providers with
+ * @param config - ORM plugin configuration with Prisma client
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { registerOrmProviders, DATABASE, DATABASE_CLIENT } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * const client = container.resolve(DATABASE_CLIENT);
+ * ```
+ */
+export declare function registerOrmProviders(container: Container, config: OrmPluginConfig<DatabaseClient>): void;
+/**
+ * Registers tenant providers with a container
+ *
+ * Use this for multi-tenant scenarios after calling `registerOrmProviders`.
+ *
+ * @param container - The DI container to register providers with
+ * @param config - Tenant configuration options
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import {
+ *   registerOrmProviders,
+ *   registerTenantProviders,
+ *   TENANT_CLIENT_POOL,
+ *   TENANT_SCHEMA_MANAGER,
+ * } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ *
+ * // Register core ORM
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * // Register tenant providers
+ * registerTenantProviders(container, {
+ *   clientPool: {
+ *     baseDatabaseUrl: process.env.DATABASE_URL!,
+ *     createClient: (schema) => createPrismaClient(schema),
+ *   },
+ *   schemaManager: {
+ *     databaseUrl: process.env.DATABASE_URL!,
+ *   },
+ * });
+ *
+ * const pool = container.resolve(TENANT_CLIENT_POOL);
+ * const schemaManager = container.resolve(TENANT_SCHEMA_MANAGER);
+ * ```
+ */
+export declare function registerTenantProviders(container: Container, config: {
+    clientPool?: TenantClientPoolConfig<DatabaseClient>;
+    schemaManager?: TenantSchemaManagerConfig;
+    provisioner?: TenantProvisionerConfig<DatabaseClient>;
+}): void;

package/dist/providers.js

@@ -0,0 +1,230 @@
+/**
+ * DI Providers for @veloxts/orm
+ *
+ * Factory provider functions for registering ORM services with the DI container.
+ * These providers allow services to be managed by the container for testability and flexibility.
+ *
+ * @module orm/providers
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { registerOrmProviders, DATABASE, DATABASE_CLIENT } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * await db.connect();
+ * ```
+ */
+import { Scope } from '@veloxts/core';
+import { createDatabase } from './client.js';
+import { createTenantClientPool } from './tenant/client-pool.js';
+import { createTenantSchemaManager } from './tenant/schema/manager.js';
+import { createTenantProvisioner } from './tenant/schema/provisioner.js';
+import { DATABASE, DATABASE_CLIENT, DATABASE_CONFIG, TENANT_CLIENT_POOL, TENANT_CLIENT_POOL_CONFIG, TENANT_PROVISIONER, TENANT_PROVISIONER_CONFIG, TENANT_SCHEMA_MANAGER, TENANT_SCHEMA_MANAGER_CONFIG, } from './tokens.js';
+// ============================================================================
+// Core Database Providers
+// ============================================================================
+/**
+ * Creates a factory provider for the database wrapper
+ *
+ * Requires DATABASE_CLIENT to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({ provide: DATABASE_CLIENT, useValue: prisma });
+ * container.register(databaseProvider());
+ * const db = container.resolve(DATABASE);
+ * ```
+ */
+export function databaseProvider() {
+    return {
+        provide: DATABASE,
+        useFactory: (client) => createDatabase({ client }),
+        inject: [DATABASE_CLIENT],
+        scope: Scope.SINGLETON,
+    };
+}
+// ============================================================================
+// Tenant Providers
+// ============================================================================
+/**
+ * Creates a factory provider for the tenant client pool
+ *
+ * Requires TENANT_CLIENT_POOL_CONFIG to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({
+ *   provide: TENANT_CLIENT_POOL_CONFIG,
+ *   useValue: {
+ *     baseDatabaseUrl: process.env.DATABASE_URL,
+ *     createClient: (schema) => new PrismaClient({ ... }),
+ *   }
+ * });
+ * container.register(tenantClientPoolProvider());
+ * const pool = container.resolve(TENANT_CLIENT_POOL);
+ * ```
+ */
+export function tenantClientPoolProvider() {
+    return {
+        provide: TENANT_CLIENT_POOL,
+        useFactory: (config) => createTenantClientPool(config),
+        inject: [TENANT_CLIENT_POOL_CONFIG],
+        scope: Scope.SINGLETON,
+    };
+}
+/**
+ * Creates a factory provider for the tenant schema manager
+ *
+ * Requires TENANT_SCHEMA_MANAGER_CONFIG to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({
+ *   provide: TENANT_SCHEMA_MANAGER_CONFIG,
+ *   useValue: { databaseUrl: process.env.DATABASE_URL }
+ * });
+ * container.register(tenantSchemaManagerProvider());
+ * const schemaManager = container.resolve(TENANT_SCHEMA_MANAGER);
+ * ```
+ */
+export function tenantSchemaManagerProvider() {
+    return {
+        provide: TENANT_SCHEMA_MANAGER,
+        useFactory: (config) => createTenantSchemaManager(config),
+        inject: [TENANT_SCHEMA_MANAGER_CONFIG],
+        scope: Scope.SINGLETON,
+    };
+}
+/**
+ * Creates a factory provider for the tenant provisioner
+ *
+ * Requires TENANT_PROVISIONER_CONFIG to be registered in the container.
+ *
+ * @example
+ * ```typescript
+ * container.register({
+ *   provide: TENANT_PROVISIONER_CONFIG,
+ *   useValue: {
+ *     schemaManager: container.resolve(TENANT_SCHEMA_MANAGER),
+ *     publicClient: prisma,
+ *     clientPool: container.resolve(TENANT_CLIENT_POOL),
+ *   }
+ * });
+ * container.register(tenantProvisionerProvider());
+ * const provisioner = container.resolve(TENANT_PROVISIONER);
+ * ```
+ */
+export function tenantProvisionerProvider() {
+    return {
+        provide: TENANT_PROVISIONER,
+        useFactory: (config) => createTenantProvisioner(config),
+        inject: [TENANT_PROVISIONER_CONFIG],
+        scope: Scope.SINGLETON,
+    };
+}
+// ============================================================================
+// Bulk Registration Helpers
+// ============================================================================
+/**
+ * Registers core ORM providers with a container
+ *
+ * This registers the database client and wrapper for basic ORM usage.
+ * For multi-tenant scenarios, use `registerTenantProviders` as well.
+ *
+ * @param container - The DI container to register providers with
+ * @param config - ORM plugin configuration with Prisma client
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { registerOrmProviders, DATABASE, DATABASE_CLIENT } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * const client = container.resolve(DATABASE_CLIENT);
+ * ```
+ */
+export function registerOrmProviders(container, config) {
+    // Register config
+    container.register({
+        provide: DATABASE_CONFIG,
+        useValue: config,
+    });
+    // Register database client
+    container.register({
+        provide: DATABASE_CLIENT,
+        useValue: config.client,
+    });
+    // Register database wrapper provider
+    container.register(databaseProvider());
+}
+/**
+ * Registers tenant providers with a container
+ *
+ * Use this for multi-tenant scenarios after calling `registerOrmProviders`.
+ *
+ * @param container - The DI container to register providers with
+ * @param config - Tenant configuration options
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import {
+ *   registerOrmProviders,
+ *   registerTenantProviders,
+ *   TENANT_CLIENT_POOL,
+ *   TENANT_SCHEMA_MANAGER,
+ * } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ *
+ * // Register core ORM
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * // Register tenant providers
+ * registerTenantProviders(container, {
+ *   clientPool: {
+ *     baseDatabaseUrl: process.env.DATABASE_URL!,
+ *     createClient: (schema) => createPrismaClient(schema),
+ *   },
+ *   schemaManager: {
+ *     databaseUrl: process.env.DATABASE_URL!,
+ *   },
+ * });
+ *
+ * const pool = container.resolve(TENANT_CLIENT_POOL);
+ * const schemaManager = container.resolve(TENANT_SCHEMA_MANAGER);
+ * ```
+ */
+export function registerTenantProviders(container, config) {
+    // Register client pool if config provided
+    if (config.clientPool) {
+        container.register({
+            provide: TENANT_CLIENT_POOL_CONFIG,
+            useValue: config.clientPool,
+        });
+        container.register(tenantClientPoolProvider());
+    }
+    // Register schema manager if config provided
+    if (config.schemaManager) {
+        container.register({
+            provide: TENANT_SCHEMA_MANAGER_CONFIG,
+            useValue: config.schemaManager,
+        });
+        container.register(tenantSchemaManagerProvider());
+    }
+    // Register provisioner if config provided
+    if (config.provisioner) {
+        container.register({
+            provide: TENANT_PROVISIONER_CONFIG,
+            useValue: config.provisioner,
+        });
+        container.register(tenantProvisionerProvider());
+    }
+}

package/dist/tokens.d.ts

@@ -0,0 +1,130 @@
+/**
+ * DI Tokens for @veloxts/orm
+ *
+ * Symbol-based tokens for type-safe dependency injection.
+ * These tokens allow services to be registered, resolved, and mocked via the DI container.
+ *
+ * @module orm/tokens
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { DATABASE_CLIENT, DATABASE, registerOrmProviders } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * const client = container.resolve(DATABASE_CLIENT);
+ * ```
+ */
+import type { Database } from './client.js';
+import type { TenantClientPool, TenantClientPoolConfig, TenantMiddlewareConfig, TenantProvisioner, TenantProvisionerConfig, TenantSchemaManager, TenantSchemaManagerConfig } from './tenant/types.js';
+import type { DatabaseClient, OrmPluginConfig } from './types.js';
+/**
+ * Database client token (raw Prisma client)
+ *
+ * The underlying Prisma client instance used for database queries.
+ * This is the client passed to `databasePlugin({ client: ... })`.
+ *
+ * @example
+ * ```typescript
+ * const client = container.resolve(DATABASE_CLIENT);
+ * const users = await client.user.findMany();
+ * ```
+ */
+export declare const DATABASE_CLIENT: import("@veloxts/core").SymbolToken<DatabaseClient>;
+/**
+ * Database wrapper token (with lifecycle management)
+ *
+ * The Database wrapper provides connection state tracking and
+ * controlled connect/disconnect methods.
+ *
+ * @example
+ * ```typescript
+ * const db = container.resolve(DATABASE);
+ * await db.connect();
+ * console.log(db.isConnected); // true
+ * const users = await db.client.user.findMany();
+ * ```
+ */
+export declare const DATABASE: import("@veloxts/core").SymbolToken<Database<DatabaseClient>>;
+/**
+ * ORM plugin configuration token
+ *
+ * Contains the plugin configuration including the Prisma client.
+ */
+export declare const DATABASE_CONFIG: import("@veloxts/core").SymbolToken<OrmPluginConfig<DatabaseClient>>;
+/**
+ * Tenant client pool configuration token
+ *
+ * Configuration for creating tenant-scoped database clients.
+ */
+export declare const TENANT_CLIENT_POOL_CONFIG: import("@veloxts/core").SymbolToken<TenantClientPoolConfig<DatabaseClient>>;
+/**
+ * Tenant schema manager configuration token
+ *
+ * Configuration for PostgreSQL schema management operations.
+ */
+export declare const TENANT_SCHEMA_MANAGER_CONFIG: import("@veloxts/core").SymbolToken<TenantSchemaManagerConfig>;
+/**
+ * Tenant provisioner configuration token
+ *
+ * Configuration for tenant provisioning operations.
+ */
+export declare const TENANT_PROVISIONER_CONFIG: import("@veloxts/core").SymbolToken<TenantProvisionerConfig<DatabaseClient>>;
+/**
+ * Tenant middleware configuration token
+ *
+ * Configuration for tenant middleware including tenant loading and client pool.
+ */
+export declare const TENANT_MIDDLEWARE_CONFIG: import("@veloxts/core").SymbolToken<TenantMiddlewareConfig<DatabaseClient>>;
+/**
+ * Tenant client pool token
+ *
+ * Pool of tenant-scoped database clients for schema-per-tenant isolation.
+ *
+ * @example
+ * ```typescript
+ * const pool = container.resolve(TENANT_CLIENT_POOL);
+ * const client = await pool.getClient('tenant_acme_corp');
+ * ```
+ */
+export declare const TENANT_CLIENT_POOL: import("@veloxts/core").SymbolToken<TenantClientPool<DatabaseClient>>;
+/**
+ * Tenant schema manager token
+ *
+ * Manages PostgreSQL schemas for tenant isolation.
+ *
+ * @example
+ * ```typescript
+ * const schemaManager = container.resolve(TENANT_SCHEMA_MANAGER);
+ * await schemaManager.createSchema('acme-corp');
+ * ```
+ */
+export declare const TENANT_SCHEMA_MANAGER: import("@veloxts/core").SymbolToken<TenantSchemaManager>;
+/**
+ * Tenant provisioner token
+ *
+ * Handles full tenant lifecycle: creation, migration, and deprovisioning.
+ *
+ * @example
+ * ```typescript
+ * const provisioner = container.resolve(TENANT_PROVISIONER);
+ * const result = await provisioner.provision({ slug: 'acme-corp', name: 'Acme Corp' });
+ * ```
+ */
+export declare const TENANT_PROVISIONER: import("@veloxts/core").SymbolToken<TenantProvisioner>;
+/**
+ * Public database client token (shared schema)
+ *
+ * In multi-tenant scenarios, this token represents the public schema client
+ * used for shared data like tenant records, user lookups, etc.
+ *
+ * @example
+ * ```typescript
+ * const publicDb = container.resolve(PUBLIC_DATABASE_CLIENT);
+ * const tenant = await publicDb.tenant.findUnique({ where: { id } });
+ * ```
+ */
+export declare const PUBLIC_DATABASE_CLIENT: import("@veloxts/core").SymbolToken<DatabaseClient>;

package/dist/tokens.js

@@ -0,0 +1,140 @@
+/**
+ * DI Tokens for @veloxts/orm
+ *
+ * Symbol-based tokens for type-safe dependency injection.
+ * These tokens allow services to be registered, resolved, and mocked via the DI container.
+ *
+ * @module orm/tokens
+ *
+ * @example
+ * ```typescript
+ * import { Container } from '@veloxts/core';
+ * import { DATABASE_CLIENT, DATABASE, registerOrmProviders } from '@veloxts/orm';
+ *
+ * const container = new Container();
+ * registerOrmProviders(container, { client: prisma });
+ *
+ * const db = container.resolve(DATABASE);
+ * const client = container.resolve(DATABASE_CLIENT);
+ * ```
+ */
+import { token } from '@veloxts/core';
+// ============================================================================
+// Core Database Tokens
+// ============================================================================
+/**
+ * Database client token (raw Prisma client)
+ *
+ * The underlying Prisma client instance used for database queries.
+ * This is the client passed to `databasePlugin({ client: ... })`.
+ *
+ * @example
+ * ```typescript
+ * const client = container.resolve(DATABASE_CLIENT);
+ * const users = await client.user.findMany();
+ * ```
+ */
+export const DATABASE_CLIENT = token.symbol('DATABASE_CLIENT');
+/**
+ * Database wrapper token (with lifecycle management)
+ *
+ * The Database wrapper provides connection state tracking and
+ * controlled connect/disconnect methods.
+ *
+ * @example
+ * ```typescript
+ * const db = container.resolve(DATABASE);
+ * await db.connect();
+ * console.log(db.isConnected); // true
+ * const users = await db.client.user.findMany();
+ * ```
+ */
+export const DATABASE = token.symbol('DATABASE');
+/**
+ * ORM plugin configuration token
+ *
+ * Contains the plugin configuration including the Prisma client.
+ */
+export const DATABASE_CONFIG = token.symbol('DATABASE_CONFIG');
+// ============================================================================
+// Tenant Tokens - Configuration
+// ============================================================================
+/**
+ * Tenant client pool configuration token
+ *
+ * Configuration for creating tenant-scoped database clients.
+ */
+export const TENANT_CLIENT_POOL_CONFIG = token.symbol('TENANT_CLIENT_POOL_CONFIG');
+/**
+ * Tenant schema manager configuration token
+ *
+ * Configuration for PostgreSQL schema management operations.
+ */
+export const TENANT_SCHEMA_MANAGER_CONFIG = token.symbol('TENANT_SCHEMA_MANAGER_CONFIG');
+/**
+ * Tenant provisioner configuration token
+ *
+ * Configuration for tenant provisioning operations.
+ */
+export const TENANT_PROVISIONER_CONFIG = token.symbol('TENANT_PROVISIONER_CONFIG');
+/**
+ * Tenant middleware configuration token
+ *
+ * Configuration for tenant middleware including tenant loading and client pool.
+ */
+export const TENANT_MIDDLEWARE_CONFIG = token.symbol('TENANT_MIDDLEWARE_CONFIG');
+// ============================================================================
+// Tenant Tokens - Services
+// ============================================================================
+/**
+ * Tenant client pool token
+ *
+ * Pool of tenant-scoped database clients for schema-per-tenant isolation.
+ *
+ * @example
+ * ```typescript
+ * const pool = container.resolve(TENANT_CLIENT_POOL);
+ * const client = await pool.getClient('tenant_acme_corp');
+ * ```
+ */
+export const TENANT_CLIENT_POOL = token.symbol('TENANT_CLIENT_POOL');
+/**
+ * Tenant schema manager token
+ *
+ * Manages PostgreSQL schemas for tenant isolation.
+ *
+ * @example
+ * ```typescript
+ * const schemaManager = container.resolve(TENANT_SCHEMA_MANAGER);
+ * await schemaManager.createSchema('acme-corp');
+ * ```
+ */
+export const TENANT_SCHEMA_MANAGER = token.symbol('TENANT_SCHEMA_MANAGER');
+/**
+ * Tenant provisioner token
+ *
+ * Handles full tenant lifecycle: creation, migration, and deprovisioning.
+ *
+ * @example
+ * ```typescript
+ * const provisioner = container.resolve(TENANT_PROVISIONER);
+ * const result = await provisioner.provision({ slug: 'acme-corp', name: 'Acme Corp' });
+ * ```
+ */
+export const TENANT_PROVISIONER = token.symbol('TENANT_PROVISIONER');
+// ============================================================================
+// Public Database Token (for multi-tenant scenarios)
+// ============================================================================
+/**
+ * Public database client token (shared schema)
+ *
+ * In multi-tenant scenarios, this token represents the public schema client
+ * used for shared data like tenant records, user lookups, etc.
+ *
+ * @example
+ * ```typescript
+ * const publicDb = container.resolve(PUBLIC_DATABASE_CLIENT);
+ * const tenant = await publicDb.tenant.findUnique({ where: { id } });
+ * ```
+ */
+export const PUBLIC_DATABASE_CLIENT = token.symbol('PUBLIC_DATABASE_CLIENT');

package/dist/types.d.ts

@@ -91,6 +91,32 @@ export interface OrmPluginConfig<TClient extends DatabaseClient> {
      * @default '@veloxts/orm'
      */
     name?: string;
+    /**
+     * DI container for service registration and resolution (optional)
+     *
+     * When provided, ORM services are registered with the container and can be:
+     * - Resolved from the container directly
+     * - Mocked in tests by overriding registrations
+     * - Managed alongside other application services
+     *
+     * When not provided, services are created directly (legacy behavior).
+     *
+     * @example
+     * ```typescript
+     * import { Container } from '@veloxts/core';
+     * import { databasePlugin, DATABASE } from '@veloxts/orm';
+     *
+     * const container = new Container();
+     * app.register(databasePlugin({
+     *   client: prisma,
+     *   container,
+     * }));
+     *
+     * // Services now available from container
+     * const db = container.resolve(DATABASE);
+     * ```
+     */
+    container?: import('@veloxts/core').Container;
 }
 /**
  * Configuration options for the database wrapper

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/orm",
-  "version": "0.6.55",
+  "version": "0.6.57",
   "description": "Prisma wrapper with enhanced DX for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -19,7 +19,7 @@
     "fastify": "5.6.2",
     "pg": "8.16.0",
     "pg-format": "1.0.4",
-    "@veloxts/core": "0.6.55"
+    "@veloxts/core": "0.6.57"
   },
   "devDependencies": {
     "@types/pg": "8.15.4",