@veloxts/orm 0.2.0 → 0.3.0

package/dist/client.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Database client wrapper for Prisma
+ *
+ * Provides lifecycle management and connection state tracking
+ * for Prisma clients in a type-safe manner.
+ *
+ * @module client
+ */
+import type { ConnectionStatus, DatabaseClient, DatabaseWrapperConfig } from './types.js';
+/**
+ * Wrapped database client with connection lifecycle management
+ *
+ * @template TClient - Type of the underlying Prisma client
+ */
+export interface Database<TClient extends DatabaseClient> {
+    /**
+     * The underlying Prisma client instance
+     *
+     * Use this for all database queries. The client is always available,
+     * but queries will fail if not connected.
+     *
+     * @example
+     * ```typescript
+     * const db = createDatabase({ client: prisma });
+     * await db.connect();
+     *
+     * const users = await db.client.user.findMany();
+     * ```
+     */
+    readonly client: TClient;
+    /**
+     * Current connection status
+     */
+    readonly status: ConnectionStatus;
+    /**
+     * Whether the database is connected
+     *
+     * Convenience getter equivalent to `status.isConnected`
+     */
+    readonly isConnected: boolean;
+    /**
+     * Establishes connection to the database
+     *
+     * @throws {VeloxError} If already connected or connection fails
+     *
+     * @example
+     * ```typescript
+     * const db = createDatabase({ client: prisma });
+     * await db.connect();
+     * console.log(db.isConnected); // true
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects from the database
+     *
+     * @throws {VeloxError} If not connected or disconnection fails
+     *
+     * @example
+     * ```typescript
+     * await db.disconnect();
+     * console.log(db.isConnected); // false
+     * ```
+     */
+    disconnect(): Promise<void>;
+}
+/**
+ * Creates a database wrapper with connection lifecycle management
+ *
+ * This wrapper provides:
+ * - Connection state tracking
+ * - Controlled connect/disconnect methods
+ * - Type-safe access to the underlying client
+ *
+ * The client is NOT automatically connected - call `connect()` explicitly
+ * or use `createDatabasePlugin` for automatic lifecycle management.
+ *
+ * @template TClient - Type of the Prisma client
+ * @param config - Database configuration with client instance
+ * @returns Database wrapper with lifecycle management
+ *
+ * @throws {VeloxError} If config is invalid or client doesn't implement DatabaseClient
+ *
+ * @example
+ * ```typescript
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabase } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const db = createDatabase({ client: prisma });
+ *
+ * // Manual connection management
+ * await db.connect();
+ * const users = await db.client.user.findMany();
+ * await db.disconnect();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check connection status
+ * const db = createDatabase({ client: prisma });
+ *
+ * console.log(db.isConnected); // false
+ * console.log(db.status.state); // 'disconnected'
+ *
+ * await db.connect();
+ *
+ * console.log(db.isConnected); // true
+ * console.log(db.status.state); // 'connected'
+ * console.log(db.status.connectedAt); // Date
+ * ```
+ */
+export declare function createDatabase<TClient extends DatabaseClient>(config: DatabaseWrapperConfig<TClient>): Database<TClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAEV,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAOpB;;;;GAIG;AACH,MAAM,WAAW,QAAQ,CAAC,OAAO,SAAS,cAAc;IACtD;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAElC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAE9B;;;;;;;;;;;OAWG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAS,cAAc,EAC3D,MAAM,EAAE,qBAAqB,CAAC,OAAO,CAAC,GACrC,QAAQ,CAAC,OAAO,CAAC,CAgInB"}

package/dist/client.js

@@ -0,0 +1,156 @@
+/**
+ * Database client wrapper for Prisma
+ *
+ * Provides lifecycle management and connection state tracking
+ * for Prisma clients in a type-safe manner.
+ *
+ * @module client
+ */
+import { ConfigurationError, VeloxError } from '@veloxts/core';
+import { isDatabaseClient } from './types.js';
+/**
+ * Creates a database wrapper with connection lifecycle management
+ *
+ * This wrapper provides:
+ * - Connection state tracking
+ * - Controlled connect/disconnect methods
+ * - Type-safe access to the underlying client
+ *
+ * The client is NOT automatically connected - call `connect()` explicitly
+ * or use `createDatabasePlugin` for automatic lifecycle management.
+ *
+ * @template TClient - Type of the Prisma client
+ * @param config - Database configuration with client instance
+ * @returns Database wrapper with lifecycle management
+ *
+ * @throws {VeloxError} If config is invalid or client doesn't implement DatabaseClient
+ *
+ * @example
+ * ```typescript
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabase } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const db = createDatabase({ client: prisma });
+ *
+ * // Manual connection management
+ * await db.connect();
+ * const users = await db.client.user.findMany();
+ * await db.disconnect();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check connection status
+ * const db = createDatabase({ client: prisma });
+ *
+ * console.log(db.isConnected); // false
+ * console.log(db.status.state); // 'disconnected'
+ *
+ * await db.connect();
+ *
+ * console.log(db.isConnected); // true
+ * console.log(db.status.state); // 'connected'
+ * console.log(db.status.connectedAt); // Date
+ * ```
+ */
+export function createDatabase(config) {
+    // Validate configuration
+    if (!config || typeof config !== 'object') {
+        throw new ConfigurationError('Database configuration is required');
+    }
+    if (!config.client) {
+        throw new ConfigurationError('Database client is required in configuration');
+    }
+    // Validate that the client implements DatabaseClient interface
+    if (!isDatabaseClient(config.client)) {
+        throw new ConfigurationError('Database client must implement $connect and $disconnect methods');
+    }
+    // Internal state
+    const state = {
+        connectionState: 'disconnected',
+        connectedAt: undefined,
+    };
+    // PERFORMANCE: Cached status object to avoid creating new objects on each access
+    // Updated only when connection state changes
+    let cachedStatus = buildStatusObject();
+    /**
+     * Builds a new status object from current state
+     * @internal
+     */
+    function buildStatusObject() {
+        return {
+            state: state.connectionState,
+            isConnected: state.connectionState === 'connected',
+            connectedAt: state.connectedAt,
+        };
+    }
+    /**
+     * Updates the cached status object when state changes
+     * @internal
+     */
+    function updateCachedStatus() {
+        cachedStatus = buildStatusObject();
+    }
+    // Connection method
+    async function connect() {
+        if (state.connectionState === 'connected') {
+            throw new VeloxError('Database is already connected', 500, 'DATABASE_ALREADY_CONNECTED');
+        }
+        if (state.connectionState === 'connecting') {
+            throw new VeloxError('Database connection is already in progress', 500, 'DATABASE_CONNECTION_IN_PROGRESS');
+        }
+        state.connectionState = 'connecting';
+        updateCachedStatus();
+        try {
+            await config.client.$connect();
+            state.connectionState = 'connected';
+            state.connectedAt = new Date();
+            updateCachedStatus();
+        }
+        catch (error) {
+            state.connectionState = 'disconnected';
+            updateCachedStatus();
+            throw new VeloxError(`Failed to connect to database: ${error instanceof Error ? error.message : String(error)}`, 500, 'DATABASE_CONNECTION_ERROR');
+        }
+    }
+    // Disconnection method
+    async function disconnect() {
+        if (state.connectionState === 'disconnected') {
+            throw new VeloxError('Database is not connected', 500, 'DATABASE_NOT_CONNECTED');
+        }
+        if (state.connectionState === 'disconnecting') {
+            throw new VeloxError('Database disconnection is already in progress', 500, 'DATABASE_DISCONNECTION_IN_PROGRESS');
+        }
+        state.connectionState = 'disconnecting';
+        updateCachedStatus();
+        try {
+            await config.client.$disconnect();
+            state.connectionState = 'disconnected';
+            state.connectedAt = undefined;
+            updateCachedStatus();
+        }
+        catch (error) {
+            // Even if disconnect fails, mark as disconnected
+            state.connectionState = 'disconnected';
+            state.connectedAt = undefined;
+            updateCachedStatus();
+            throw new VeloxError(`Failed to disconnect from database: ${error instanceof Error ? error.message : String(error)}`, 500, 'DATABASE_DISCONNECTION_ERROR');
+        }
+    }
+    // Return the database wrapper object with proper getters for reactive properties
+    // PERFORMANCE: status getter returns cached object instead of creating new one
+    const database = {
+        client: config.client,
+        connect,
+        disconnect,
+        get status() {
+            return cachedStatus;
+        },
+        get isConnected() {
+            return state.connectionState === 'connected';
+        },
+    };
+    return database;
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @veloxts/orm - Laravel-inspired Prisma wrapper for VeloxTS framework
+ *
+ * Provides type-safe database integration with:
+ * - Context-based database access (`ctx.db.user.findUnique(...)`)
+ * - VeloxApp plugin integration with automatic lifecycle management
+ * - Connection state tracking and error handling
+ *
+ * @example
+ * ```typescript
+ * // Setup
+ * import { createVeloxApp } from '@veloxts/core';
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabasePlugin } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const app = await createVeloxApp({ port: 3210 });
+ *
+ * await app.use(createDatabasePlugin({ client: prisma }));
+ * await app.start();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using ctx.db in procedure handlers
+ * getUser: procedure()
+ *   .input(z.object({ id: z.string().uuid() }))
+ *   .query(async ({ input, ctx }) => {
+ *     return ctx.db.user.findUnique({ where: { id: input.id } });
+ *   })
+ * ```
+ *
+ * @module @veloxts/orm
+ */
+/**
+ * Package version
+ */
+export declare const ORM_VERSION: "0.1.0";
+export type { 
+/**
+ * Connection state enum values
+ */
+ConnectionState, 
+/**
+ * Connection status information
+ */
+ConnectionStatus, 
+/**
+ * Base interface for Prisma clients
+ */
+DatabaseClient, 
+/**
+ * Configuration for database wrapper
+ */
+DatabaseWrapperConfig, 
+/**
+ * Infer client type from config
+ */
+InferClientType, 
+/**
+ * Infer database client type
+ */
+InferDatabaseClient, 
+/**
+ * Plugin configuration options
+ */
+OrmPluginConfig, } from './types.js';
+export { isDatabaseClient } from './types.js';
+export type { 
+/**
+ * Database wrapper interface with lifecycle management
+ */
+Database, } from './client.js';
+export { 
+/**
+ * Create a database wrapper with connection lifecycle management
+ *
+ * Use this for manual connection management. For automatic lifecycle
+ * management with VeloxApp, use `createDatabasePlugin` instead.
+ *
+ * @example
+ * ```typescript
+ * const db = createDatabase({ client: new PrismaClient() });
+ * await db.connect();
+ *
+ * const users = await db.client.user.findMany();
+ *
+ * await db.disconnect();
+ * ```
+ */
+createDatabase, } from './client.js';
+export { 
+/**
+ * Create a database plugin for VeloxApp integration
+ *
+ * This is the recommended way to integrate Prisma with VeloxTS.
+ * The plugin automatically:
+ * - Connects to the database when the app starts
+ * - Disconnects during graceful shutdown
+ * - Adds `ctx.db` to procedure handlers
+ *
+ * @example
+ * ```typescript
+ * import { createVeloxApp } from '@veloxts/core';
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabasePlugin } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const app = await createVeloxApp({ port: 3210 });
+ *
+ * await app.use(createDatabasePlugin({ client: prisma }));
+ * await app.start();
+ * ```
+ */
+createDatabasePlugin, } from './plugin.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAMH;;GAEG;AACH,eAAO,MAAM,WAAW,EAAG,OAAgB,CAAC;AAM5C,YAAY;AACV;;GAEG;AACH,eAAe;AACf;;GAEG;AACH,gBAAgB;AAChB;;GAEG;AACH,cAAc;AACd;;GAEG;AACH,qBAAqB;AACrB;;GAEG;AACH,eAAe;AACf;;GAEG;AACH,mBAAmB;AACnB;;GAEG;AACH,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAM9C,YAAY;AACV;;GAEG;AACH,QAAQ,GACT,MAAM,aAAa,CAAC;AACrB,OAAO;AACL;;;;;;;;;;;;;;;GAeG;AACH,cAAc,GACf,MAAM,aAAa,CAAC;AAMrB,OAAO;AACL;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oBAAoB,GACrB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,88 @@
+/**
+ * @veloxts/orm - Laravel-inspired Prisma wrapper for VeloxTS framework
+ *
+ * Provides type-safe database integration with:
+ * - Context-based database access (`ctx.db.user.findUnique(...)`)
+ * - VeloxApp plugin integration with automatic lifecycle management
+ * - Connection state tracking and error handling
+ *
+ * @example
+ * ```typescript
+ * // Setup
+ * import { createVeloxApp } from '@veloxts/core';
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabasePlugin } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const app = await createVeloxApp({ port: 3210 });
+ *
+ * await app.use(createDatabasePlugin({ client: prisma }));
+ * await app.start();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using ctx.db in procedure handlers
+ * getUser: procedure()
+ *   .input(z.object({ id: z.string().uuid() }))
+ *   .query(async ({ input, ctx }) => {
+ *     return ctx.db.user.findUnique({ where: { id: input.id } });
+ *   })
+ * ```
+ *
+ * @module @veloxts/orm
+ */
+// ============================================================================
+// Version
+// ============================================================================
+/**
+ * Package version
+ */
+export const ORM_VERSION = '0.1.0';
+export { isDatabaseClient } from './types.js';
+export { 
+/**
+ * Create a database wrapper with connection lifecycle management
+ *
+ * Use this for manual connection management. For automatic lifecycle
+ * management with VeloxApp, use `createDatabasePlugin` instead.
+ *
+ * @example
+ * ```typescript
+ * const db = createDatabase({ client: new PrismaClient() });
+ * await db.connect();
+ *
+ * const users = await db.client.user.findMany();
+ *
+ * await db.disconnect();
+ * ```
+ */
+createDatabase, } from './client.js';
+// ============================================================================
+// Plugin
+// ============================================================================
+export { 
+/**
+ * Create a database plugin for VeloxApp integration
+ *
+ * This is the recommended way to integrate Prisma with VeloxTS.
+ * The plugin automatically:
+ * - Connects to the database when the app starts
+ * - Disconnects during graceful shutdown
+ * - Adds `ctx.db` to procedure handlers
+ *
+ * @example
+ * ```typescript
+ * import { createVeloxApp } from '@veloxts/core';
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabasePlugin } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const app = await createVeloxApp({ port: 3210 });
+ *
+ * await app.use(createDatabasePlugin({ client: prisma }));
+ * await app.start();
+ * ```
+ */
+createDatabasePlugin, } from './plugin.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,+EAA+E;AAC/E,UAAU;AACV,+EAA+E;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,OAAgB,CAAC;AAoC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAY9C,OAAO;AACL;;;;;;;;;;;;;;;GAeG;AACH,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,+EAA+E;AAC/E,SAAS;AACT,+EAA+E;AAE/E,OAAO;AACL;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oBAAoB,GACrB,MAAM,aAAa,CAAC"}

package/dist/plugin.d.ts

@@ -0,0 +1,117 @@
+/**
+ * VeloxApp plugin for database integration
+ *
+ * Provides automatic database lifecycle management via the VeloxTS plugin system.
+ * Connects on app start, disconnects on app shutdown.
+ *
+ * @module plugin
+ */
+import type { DatabaseClient, OrmPluginConfig } from './types.js';
+/**
+ * Extend BaseContext to include the database client
+ *
+ * After registering the database plugin, `ctx.db` will be available
+ * in all procedure handlers with full type information.
+ *
+ * @example
+ * ```typescript
+ * // In your app setup
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabasePlugin } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * await app.use(createDatabasePlugin({ client: prisma }));
+ *
+ * // In your procedure handlers
+ * getUser: procedure()
+ *   .input(z.object({ id: z.string() }))
+ *   .query(async ({ input, ctx }) => {
+ *     // ctx.db is typed as your PrismaClient
+ *     return ctx.db.user.findUnique({ where: { id: input.id } });
+ *   })
+ * ```
+ *
+ * To get full type inference for your specific Prisma schema,
+ * add this to your app's declaration file:
+ *
+ * @example
+ * ```typescript
+ * // In your app's types.d.ts or similar
+ * import type { PrismaClient } from '@prisma/client';
+ *
+ * declare module '@veloxts/core' {
+ *   interface BaseContext {
+ *     db: PrismaClient;
+ *   }
+ * }
+ * ```
+ */
+declare module '@veloxts/core' {
+    interface BaseContext {
+        /**
+         * Database client for executing queries
+         *
+         * This property is added by the @veloxts/orm plugin.
+         * The actual type depends on your Prisma schema.
+         */
+        db: DatabaseClient;
+    }
+}
+/**
+ * Creates a database plugin for VeloxApp integration
+ *
+ * This plugin:
+ * - Wraps your Prisma client with connection management
+ * - Automatically connects when the app starts
+ * - Automatically disconnects during graceful shutdown
+ * - Adds `db` to the request context for use in procedure handlers
+ *
+ * @template TClient - Type of the Prisma client
+ * @param config - Plugin configuration with Prisma client
+ * @returns A VeloxPlugin that can be registered with `app.use()`
+ *
+ * @throws {ConfigurationError} If config is invalid or client is missing
+ *
+ * @example
+ * ```typescript
+ * import { createVeloxApp } from '@veloxts/core';
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabasePlugin } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const app = await createVeloxApp({ port: 3210 });
+ *
+ * // Register the database plugin
+ * await app.use(createDatabasePlugin({ client: prisma }));
+ *
+ * // Start the app (database connects automatically)
+ * await app.start();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using ctx.db in procedures
+ * import { defineProcedures, procedure } from '@veloxts/router';
+ * import { z } from '@veloxts/validation';
+ *
+ * export const userProcedures = defineProcedures('users', {
+ *   getUser: procedure()
+ *     .input(z.object({ id: z.string().uuid() }))
+ *     .query(async ({ input, ctx }) => {
+ *       // ctx.db is your Prisma client
+ *       const user = await ctx.db.user.findUnique({
+ *         where: { id: input.id }
+ *       });
+ *       return user;
+ *     }),
+ *
+ *   createUser: procedure()
+ *     .input(z.object({ name: z.string(), email: z.string().email() }))
+ *     .mutation(async ({ input, ctx }) => {
+ *       return ctx.db.user.create({ data: input });
+ *     }),
+ * });
+ * ```
+ */
+export declare function createDatabasePlugin<TClient extends DatabaseClient>(config: OrmPluginConfig<TClient>): import("@veloxts/core").VeloxPlugin<import("fastify").FastifyPluginOptions>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAOlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,QAAQ,eAAe,CAAC;IAC7B,UAAU,WAAW;QACnB;;;;;WAKG;QACH,EAAE,EAAE,cAAc,CAAC;KACpB;CACF;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,cAAc,EACjE,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,+EA2EjC"}

package/dist/plugin.js

@@ -0,0 +1,138 @@
+/**
+ * VeloxApp plugin for database integration
+ *
+ * Provides automatic database lifecycle management via the VeloxTS plugin system.
+ * Connects on app start, disconnects on app shutdown.
+ *
+ * @module plugin
+ */
+import { ConfigurationError, definePlugin } from '@veloxts/core';
+import { createDatabase } from './client.js';
+import { isDatabaseClient } from './types.js';
+// ============================================================================
+// Plugin Implementation
+// ============================================================================
+/**
+ * Version of the ORM plugin
+ */
+const ORM_PLUGIN_VERSION = '0.1.0';
+/**
+ * Default plugin name
+ */
+const DEFAULT_PLUGIN_NAME = '@veloxts/orm';
+/**
+ * Creates a database plugin for VeloxApp integration
+ *
+ * This plugin:
+ * - Wraps your Prisma client with connection management
+ * - Automatically connects when the app starts
+ * - Automatically disconnects during graceful shutdown
+ * - Adds `db` to the request context for use in procedure handlers
+ *
+ * @template TClient - Type of the Prisma client
+ * @param config - Plugin configuration with Prisma client
+ * @returns A VeloxPlugin that can be registered with `app.use()`
+ *
+ * @throws {ConfigurationError} If config is invalid or client is missing
+ *
+ * @example
+ * ```typescript
+ * import { createVeloxApp } from '@veloxts/core';
+ * import { PrismaClient } from '@prisma/client';
+ * import { createDatabasePlugin } from '@veloxts/orm';
+ *
+ * const prisma = new PrismaClient();
+ * const app = await createVeloxApp({ port: 3210 });
+ *
+ * // Register the database plugin
+ * await app.use(createDatabasePlugin({ client: prisma }));
+ *
+ * // Start the app (database connects automatically)
+ * await app.start();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using ctx.db in procedures
+ * import { defineProcedures, procedure } from '@veloxts/router';
+ * import { z } from '@veloxts/validation';
+ *
+ * export const userProcedures = defineProcedures('users', {
+ *   getUser: procedure()
+ *     .input(z.object({ id: z.string().uuid() }))
+ *     .query(async ({ input, ctx }) => {
+ *       // ctx.db is your Prisma client
+ *       const user = await ctx.db.user.findUnique({
+ *         where: { id: input.id }
+ *       });
+ *       return user;
+ *     }),
+ *
+ *   createUser: procedure()
+ *     .input(z.object({ name: z.string(), email: z.string().email() }))
+ *     .mutation(async ({ input, ctx }) => {
+ *       return ctx.db.user.create({ data: input });
+ *     }),
+ * });
+ * ```
+ */
+export function createDatabasePlugin(config) {
+    // Validate configuration at plugin creation time
+    if (!config || typeof config !== 'object') {
+        throw new ConfigurationError('Database plugin configuration is required');
+    }
+    if (!config.client) {
+        throw new ConfigurationError('Database client is required. Provide a Prisma client instance in config.client');
+    }
+    if (!isDatabaseClient(config.client)) {
+        throw new ConfigurationError('Database client must implement $connect and $disconnect methods. ' +
+            'Ensure you are passing a valid Prisma client instance.');
+    }
+    const pluginName = config.name ?? DEFAULT_PLUGIN_NAME;
+    // Plugin state - holds the database wrapper
+    const state = {
+        database: null,
+    };
+    return definePlugin({
+        name: pluginName,
+        version: ORM_PLUGIN_VERSION,
+        async register(server) {
+            // Create the database wrapper
+            state.database = createDatabase({ client: config.client });
+            // Connect to the database
+            await state.database.connect();
+            // Add database client to request context via onRequest hook
+            server.addHook('onRequest', async (request) => {
+                // The context should be created by @veloxts/core's onRequest hook
+                // which runs before this hook (due to plugin registration order)
+                if (request.context) {
+                    // Extend the context with the database client using Object.defineProperty
+                    // for proper property definition without type assertion side effects
+                    Object.defineProperty(request.context, 'db', {
+                        value: config.client,
+                        writable: false,
+                        enumerable: true,
+                        configurable: true, // Allow redefinition for testing
+                    });
+                }
+            });
+            // Register shutdown hook using Fastify's onClose hook
+            // This ensures the database disconnects during graceful shutdown
+            server.addHook('onClose', async () => {
+                if (state.database?.isConnected) {
+                    try {
+                        await state.database.disconnect();
+                        server.log.info('Database disconnected successfully during shutdown');
+                    }
+                    catch (error) {
+                        // Log error but don't rethrow - allow graceful shutdown to continue
+                        server.log.error({ err: error instanceof Error ? error : new Error(String(error)) }, 'Failed to disconnect database during shutdown');
+                    }
+                }
+            });
+            // Log successful registration
+            server.log.info(`Database plugin "${pluginName}" registered successfully`);
+        },
+    });
+}
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Type definitions for @veloxts/orm
+ *
+ * Provides type-safe abstractions for Prisma client integration
+ * without requiring direct Prisma dependency.
+ *
+ * @module types
+ */
+/**
+ * Extend the VeloxErrorCodeRegistry to include ORM-specific error codes
+ *
+ * This enables type-safe error handling for database-related errors
+ */
+declare module '@veloxts/core' {
+    interface VeloxErrorCodeRegistry {
+        orm: 'DATABASE_CONNECTION_ERROR' | 'DATABASE_DISCONNECTION_ERROR' | 'DATABASE_NOT_CONNECTED' | 'DATABASE_ALREADY_CONNECTED' | 'DATABASE_CONNECTION_IN_PROGRESS' | 'DATABASE_DISCONNECTION_IN_PROGRESS';
+    }
+}
+/**
+ * Minimal interface that any Prisma client must satisfy
+ *
+ * This interface allows the ORM package to work with any Prisma client
+ * without requiring @prisma/client as a direct dependency.
+ *
+ * @example
+ * ```typescript
+ * import { PrismaClient } from '@prisma/client';
+ *
+ * // PrismaClient satisfies DatabaseClient
+ * const prisma: DatabaseClient = new PrismaClient();
+ * ```
+ */
+export interface DatabaseClient {
+    /**
+     * Establishes connection to the database
+     *
+     * Called automatically when using createDatabasePlugin,
+     * or can be called manually with createDatabase.
+     */
+    $connect: () => Promise<void>;
+    /**
+     * Disconnects from the database
+     *
+     * Called automatically during app shutdown when using createDatabasePlugin,
+     * or can be called manually with createDatabase.
+     */
+    $disconnect: () => Promise<void>;
+}
+/**
+ * Type guard to check if an object is a valid DatabaseClient
+ *
+ * Uses property checks to ensure the object has the required methods
+ * without using type assertions.
+ *
+ * @param value - Value to check
+ * @returns true if value satisfies DatabaseClient interface
+ *
+ * @example
+ * ```typescript
+ * if (isDatabaseClient(unknownValue)) {
+ *   await unknownValue.$connect();
+ * }
+ * ```
+ */
+export declare function isDatabaseClient(value: unknown): value is DatabaseClient;
+/**
+ * Configuration options for the database plugin
+ *
+ * @template TClient - Type of the Prisma client
+ */
+export interface OrmPluginConfig<TClient extends DatabaseClient> {
+    /**
+     * The Prisma client instance to use
+     *
+     * Must be an already-instantiated PrismaClient. Connection will be
+     * managed by the plugin (connect on start, disconnect on shutdown).
+     *
+     * @example
+     * ```typescript
+     * const prisma = new PrismaClient();
+     * const plugin = createDatabasePlugin({ client: prisma });
+     * ```
+     */
+    client: TClient;
+    /**
+     * Custom name for the plugin registration
+     *
+     * Defaults to '@veloxts/orm'. Useful when registering multiple database
+     * connections with different names.
+     *
+     * @default '@veloxts/orm'
+     */
+    name?: string;
+}
+/**
+ * Configuration options for the database wrapper
+ */
+export interface DatabaseWrapperConfig<TClient extends DatabaseClient> {
+    /**
+     * The Prisma client instance to wrap
+     */
+    client: TClient;
+}
+/**
+ * Possible states of a database connection
+ */
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'disconnecting';
+/**
+ * Database connection status information
+ */
+export interface ConnectionStatus {
+    /**
+     * Current connection state
+     */
+    state: ConnectionState;
+    /**
+     * Whether the database is currently connected and ready for queries
+     */
+    isConnected: boolean;
+    /**
+     * Timestamp of last successful connection, if any
+     */
+    connectedAt?: Date;
+}
+/**
+ * Infer the client type from an OrmPluginConfig
+ *
+ * @template T - OrmPluginConfig type
+ *
+ * @example
+ * ```typescript
+ * const config = { client: new PrismaClient() };
+ * type Client = InferClientType<typeof config>;
+ * // Client = PrismaClient
+ * ```
+ */
+export type InferClientType<T> = T extends OrmPluginConfig<infer C> ? C : never;
+/**
+ * Infer the client type from a Database wrapper
+ *
+ * @template T - Database wrapper type
+ */
+export type InferDatabaseClient<T> = T extends {
+    client: infer C;
+} ? C : never;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;GAIG;AACH,OAAO,QAAQ,eAAe,CAAC;IAC7B,UAAU,sBAAsB;QAC9B,GAAG,EACC,2BAA2B,GAC3B,8BAA8B,GAC9B,wBAAwB,GACxB,4BAA4B,GAC5B,iCAAiC,GACjC,oCAAoC,CAAC;KAC1C;CACF;AAMD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9B;;;;;OAKG;IACH,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAYxE;AAMD;;;;GAIG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,SAAS,cAAc;IAC7D;;;;;;;;;;;OAWG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,OAAO,SAAS,cAAc;IACnE;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB;AAMD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,eAAe,CAAC;AAE5F;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,EAAE,eAAe,CAAC;IAEvB;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC;CACpB;AAMD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,eAAe,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEhF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAC"}

package/dist/types.js

@@ -0,0 +1,35 @@
+/**
+ * Type definitions for @veloxts/orm
+ *
+ * Provides type-safe abstractions for Prisma client integration
+ * without requiring direct Prisma dependency.
+ *
+ * @module types
+ */
+/**
+ * Type guard to check if an object is a valid DatabaseClient
+ *
+ * Uses property checks to ensure the object has the required methods
+ * without using type assertions.
+ *
+ * @param value - Value to check
+ * @returns true if value satisfies DatabaseClient interface
+ *
+ * @example
+ * ```typescript
+ * if (isDatabaseClient(unknownValue)) {
+ *   await unknownValue.$connect();
+ * }
+ * ```
+ */
+export function isDatabaseClient(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    // Check for required methods
+    return ('$connect' in value &&
+        typeof value.$connect === 'function' &&
+        '$disconnect' in value &&
+        typeof value.$disconnect === 'function');
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA2DH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,6BAA6B;IAC7B,OAAO,CACL,UAAU,IAAI,KAAK;QACnB,OAAO,KAAK,CAAC,QAAQ,KAAK,UAAU;QACpC,aAAa,IAAI,KAAK;QACtB,OAAO,KAAK,CAAC,WAAW,KAAK,UAAU,CACxC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/orm",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Prisma wrapper with enhanced DX for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "fastify": "5.6.2",
-    "@veloxts/core": "0.2.0"
+    "@veloxts/core": "0.3.0"
   },
   "devDependencies": {
     "typescript": "5.9.3",