@c15t/backend 1.0.0 → 1.1.0-canary.0

package/src/pkgs/db-adapters/adapters/drizzle-adapter/drizzle-adapter.ts

@@ -32,15 +32,15 @@ export interface DB {
 }
 
 /**
- * Creates a transformer for converting between C15T data models and Drizzle schema
+ * Creates a transformer for converting between c15t data models and Drizzle schema
  *
  * This function creates an object with utility methods for converting data between
- * the C15T internal representation and the Drizzle ORM schema representation.
+ * the c15t internal representation and the Drizzle ORM schema representation.
  *
  * @internal This function is primarily used internally by the drizzleAdapter
  * @param db - The Drizzle database instance
  * @param config - Configuration options for the Drizzle adapter
- * @param options - C15T options
+ * @param options - c15t options
  * @returns An object containing entity transformation utilities
  * @throws {DoubleTieError} If the schema is not found or if a model or field doesn't exist
  */
@@ -56,7 +56,7 @@ const createEntityTransformer = (
 	 *
 	 * @internal
 	 * @param model - The model name
-	 * @param field - The field name in the C15T model
+	 * @param field - The field name in the c15t model
 	 * @returns The corresponding field name in the database schema
 	 */
 	function getField(model: string, field: string) {
@@ -127,11 +127,11 @@ const createEntityTransformer = (
 	};
 
 	/**
-	 * Converts C15T where clauses to Drizzle ORM conditions
+	 * Converts c15t where clauses to Drizzle ORM conditions
 	 *
 	 * @internal
 	 * @typeParam EntityType - The type of entity being queried
-	 * @param where - Array of where conditions from C15T
+	 * @param where - Array of where conditions from c15t
 	 * @param model - The model name
 	 * @returns Array of Drizzle ORM conditions
 	 * @throws {DoubleTieError} If a field doesn't exist or if the operator value is invalid
@@ -245,7 +245,7 @@ const createEntityTransformer = (
 	return {
 		getSchema,
 		/**
-		 * Transforms input data from C15T format to Drizzle format
+		 * Transforms input data from c15t format to Drizzle format
 		 *
 		 * @internal
 		 * @param data - The data to transform
@@ -285,13 +285,13 @@ const createEntityTransformer = (
 			return transformedData;
 		},
 		/**
-		 * Transforms output data from Drizzle format to C15T format
+		 * Transforms output data from Drizzle format to c15t format
 		 *
 		 * @internal
 		 * @param data - The data to transform
 		 * @param model - The model name
 		 * @param select - Optional array of fields to select
-		 * @returns Transformed data for C15T or null if no data
+		 * @returns Transformed data for c15t or null if no data
 		 */
 		transformOutput(
 			data: Record<string, unknown>,
@@ -462,14 +462,14 @@ function checkMissingFields(
 }
 
 /**
- * Creates a C15T adapter for Drizzle ORM
+ * Creates a c15t adapter for Drizzle ORM
  *
- * This factory function creates an adapter that allows C15T to use Drizzle ORM
+ * This factory function creates an adapter that allows c15t to use Drizzle ORM
  * as its database layer. It supports PostgreSQL, MySQL, and SQLite.
  *
  * @param db - The Drizzle database instance
  * @param config - Configuration options for the Drizzle adapter
- * @returns A C15T adapter factory function
+ * @returns A c15t adapter factory function
  *
  * @example
  * ```typescript
@@ -483,15 +483,13 @@ function checkMissingFields(
  * const connection = postgres('postgresql://user:password@localhost:5432/db');
  * const db = drizzle(connection, { schema });
  *
- * // Create the C15T instance with Drizzle adapter
+ * // Create the c15t instance with Drizzle adapter
  * const c15t = c15tInstance({
  *   storage: drizzleAdapter(db, {
  *     provider: 'pg',
  *     schema, // Pass your Drizzle schema
  *     usePlural: true
  *   }),
- *   // Other C15T options...
- *   secret: process.env.SECRET
  * });
  *
  * // Use in your application
@@ -517,7 +515,6 @@ function checkMissingFields(
  *   storage: drizzleAdapter(db, {
  *     provider: 'mysql'
  *   }),
- *   secret: process.env.SECRET
  * });
  * ```
  */

package/src/pkgs/db-adapters/adapters/kysely-adapter/dialect.ts

@@ -78,7 +78,7 @@ function getDatabaseType(
  * - Raw database connections (SQLite, MySQL, PostgreSQL)
  * - Kysely dialect instances
  *
- * @param config - The C15T configuration options containing database settings
+ * @param config - The c15t configuration options containing database settings
  * @returns An object containing the initialized Kysely instance and database type
  *
  * @example
@@ -103,7 +103,6 @@ function getDatabaseType(
  *
  * // Use in c15t configuration
  * const c15t = c15tInstance({
- *   secret: process.env.SECRET_KEY,
  *   database: { db, type: 'postgres' } // Pre-configured Kysely instance
  * });
  * ```
@@ -124,7 +123,6 @@ function getDatabaseType(
  *
  * // Pass the pool directly to c15t
  * const c15t = c15tInstance({
- *   secret: process.env.SECRET_KEY,
  *   database: pool // The adapter will detect it's a Postgres pool
  * });
  * ```

package/src/pkgs/db-adapters/adapters/kysely-adapter/kysely-adapter.ts

@@ -632,7 +632,6 @@ const createEntityTransformer = (
  * const c15t = c15tInstance({
  *   storage: kyselyAdapter(db, { type: 'postgres' }),
  *   // Other c15t options...
- *   secret: process.env.SECRET
  * });
  *
  * // Use in your application

package/src/pkgs/db-adapters/adapters/kysely-adapter/tests/postgres.test.ts

@@ -3,8 +3,8 @@ import { Kysely } from 'kysely';
 import { KyselyPGlite } from 'kysely-pglite';
 import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 
+import { logger } from '@doubletie/logger';
 import type { Adapter } from '~/pkgs/db-adapters';
-import { logger } from '~/pkgs/logger';
 import { getMigrations } from '~/pkgs/migrations';
 import { type KyselyDatabaseType, kyselyAdapter } from '../index';
 import type { Database } from '../types';

package/src/pkgs/db-adapters/adapters/kysely-adapter/tests/sqlite.test.ts

@@ -2,8 +2,8 @@ import { LibsqlDialect } from '@libsql/kysely-libsql';
 import { Kysely, sql } from 'kysely';
 import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 
+import { logger } from '@doubletie/logger';
 import type { Adapter } from '~/pkgs/db-adapters';
-import { logger } from '~/pkgs/logger';
 import { getMigrations } from '~/pkgs/migrations';
 import { type KyselyDatabaseType, kyselyAdapter } from '../index';
 import type { Database } from '../types';

package/src/pkgs/db-adapters/adapters/kysely-adapter/tests/test-utils.ts

@@ -1,8 +1,8 @@
 import { type Kysely, type Migration, sql } from 'kysely';
 import { beforeEach, expect, test } from 'vitest';
 
+import type { Logger } from '@doubletie/logger';
 import type { Adapter } from '~/pkgs/db-adapters';
-import type { Logger } from '~/pkgs/logger';
 import type { C15TOptions } from '~/types';
 import type { KyselyDatabaseType } from '../index';
 import type { Database } from '../types';
@@ -36,7 +36,7 @@ export const expectedTables = [
 ];
 
 /**
- * Helper to create C15T options for a database
+ * Helper to create c15t options for a database
  */
 export function createOptions(dbConfig: DbConfig): C15TOptions {
 	return {

package/src/pkgs/db-adapters/adapters/kysely-adapter/types.ts

@@ -159,7 +159,6 @@ export type SQLiteDatabaseConfig = SQLiteDatabase;
  * // Use in c15t configuration
  * const c15t = c15tInstance({
  *   storage: kyselyAdapter(dialectConfig),
- *   secret: process.env.SECRET_KEY
  * });
  * ```
  */
@@ -232,7 +231,6 @@ export interface DialectConfig {
  * // Pass to c15t configuration
  * const c15t = c15tInstance({
  *   storage: kyselyAdapter(config),
- *   secret: process.env.SECRET_KEY
  * });
  * ```
  */

package/src/pkgs/db-adapters/adapters/memory-adapter/memory-adapter.ts

@@ -330,7 +330,6 @@ const createEntityTransformer = (options: C15TOptions) => {
  * // Create the c15t instance with memory adapter
  * const c15t = c15tInstance({
  *   storage: memoryAdapter(db),
- *   secret: process.env.SECRET_KEY
  * });
  *
  * // The database will be populated as records are created

package/src/pkgs/db-adapters/adapters/prisma-adapter/prisma-adapter.ts

@@ -319,7 +319,6 @@ const createEntityTransformer = (
  * // Create the c15t instance with Prisma adapter
  * const c15t = c15tInstance({
  *   storage: prismaAdapter(prisma, { provider: 'postgresql' }),
- *   secret: process.env.SECRET_KEY
  * });
  *
  * // Use in your application

package/src/pkgs/migrations/get-migration.ts

@@ -1,5 +1,5 @@
 import { createKyselyAdapter } from '~/pkgs/db-adapters';
-import { createLogger } from '~/pkgs/logger';
+import { getLogger } from '~/pkgs/utils/logger';
 import type { C15TOptions } from '~/types';
 import { buildColumnAddMigrations } from './migration-builders';
 import { buildTableCreateMigrations } from './migration-builders';
@@ -12,7 +12,7 @@ import type { MigrationResult } from './types';
  * This is the main entry point for the migration system. It orchestrates
  * the entire process from connecting to the database to generating migrations.
  *
- * @param config - C15T configuration containing database connection and schema details
+ * @param config - c15t configuration containing database connection and schema details
  *
  * @returns MigrationResult containing:
  *   - toBeCreated: Tables that need to be created
@@ -37,7 +37,7 @@ import type { MigrationResult } from './types';
 export async function getMigrations(
 	config: C15TOptions
 ): Promise<MigrationResult> {
-	const logger = createLogger(config.logger);
+	const logger = getLogger(config.logger);
 
 	// Initialize database connection
 	let { kysely: db, databaseType: dbType } = await createKyselyAdapter(config);

package/src/pkgs/migrations/get-schema/get-schema.ts

@@ -4,13 +4,13 @@ import { processTablesIntoSchema } from './process-tables';
 import type { SchemaDefinition } from './types';
 
 /**
- * Generates a complete database schema from the C15T configuration
+ * Generates a complete database schema from the c15t configuration
  *
  * This function serves as the main entry point for schema generation.
  * It retrieves table definitions from the consent module and processes
  * them into a structured schema representation.
  *
- * @param config - The complete C15T configuration
+ * @param config - The complete c15t configuration
  * @returns A structured schema definition with fields and table properties
  *
  * @example

package/src/pkgs/migrations/get-schema/index.ts

@@ -2,7 +2,7 @@
  * Schema Generation Module
  *
  * This module handles the generation and processing of database schemas
- * based on the C15T configuration. It transforms table definitions into
+ * based on the c15t configuration. It transforms table definitions into
  * a structured schema representation that can be used for database operations.
  *
  * Example usage:

package/src/pkgs/migrations/migration-builders.ts

@@ -3,7 +3,7 @@ import type {
 	Database,
 	KyselyDatabaseType,
 } from '~/pkgs/db-adapters/adapters/kysely-adapter/types';
-import { createLogger } from '~/pkgs/logger';
+import { getLogger } from '~/pkgs/utils/logger';
 import type { C15TOptions } from '~/types';
 import { getType } from './type-mapping';
 import type { ColumnsToAdd, MigrationOperation, TableToCreate } from './types';
@@ -83,7 +83,7 @@ export function buildTableCreateMigrations(
 	toBeCreated: TableToCreate[],
 	dbType: KyselyDatabaseType
 ): MigrationOperation[] {
-	const logger = createLogger();
+	const logger = getLogger();
 	const migrations: MigrationOperation[] = [];
 
 	// Process each table that needs to be created

package/src/pkgs/migrations/migration-execution.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '~/pkgs/logger';
+import { getLogger } from '~/pkgs/utils/logger';
 import type { MigrationOperation } from './types';
 
 /**
@@ -8,7 +8,7 @@ import type { MigrationOperation } from './types';
  * @returns Object with runMigrations and compileMigrations functions
  */
 export function createMigrationExecutors(migrations: MigrationOperation[]) {
-	const logger = createLogger();
+	const logger = getLogger();
 
 	/**
 	 * Executes all migration operations against the database

package/src/pkgs/migrations/schema-comparison.ts

@@ -1,9 +1,10 @@
+import type { LoggerOptions } from '@doubletie/logger';
 import type { TableMetadata } from 'kysely';
 import type { Field } from '~/pkgs/data-model';
 import type { KyselyDatabaseType } from '~/pkgs/db-adapters/adapters/kysely-adapter/types';
-import { createLogger } from '~/pkgs/logger';
+import { getLogger } from '~/pkgs/utils/logger';
 import type { C15TOptions } from '~/types';
-import type { LoggerOptions } from '../logger';
+
 import { getSchema } from './get-schema';
 import { matchType } from './type-mapping';
 import type {
@@ -44,7 +45,7 @@ export function analyzeSchemaChanges(
 	dbType: KyselyDatabaseType
 ): { toBeCreated: TableToCreate[]; toBeAdded: ColumnsToAdd[] } {
 	const betterAuthSchema = getSchema(config);
-	const logger = createLogger(config.logger as LoggerOptions);
+	const logger = getLogger(config.logger as LoggerOptions);
 	const toBeCreated: TableToCreate[] = [];
 	const toBeAdded: ColumnsToAdd[] = [];
 
@@ -160,7 +161,7 @@ function handleExistingTable(
 	table: TableMetadata,
 	toBeAdded: ColumnsToAdd[],
 	dbType: KyselyDatabaseType,
-	logger: ReturnType<typeof createLogger>
+	logger: ReturnType<typeof getLogger>
 ): void {
 	// Collection of fields that need to be added to the existing table
 	const toBeAddedFields: Record<string, Field> = {};

package/src/pkgs/results/__tests__/error-class.test.ts

@@ -59,7 +59,7 @@ describe('DoubleTieError', () => {
 			expect(error.message).toContain('HTTP error 404');
 		});
 
-		it('should extract error details from response data', async () => {
+		it('should extract error details from response data', () => {
 			const responseData = {
 				message: 'Resource not found',
 				code: ERROR_CODES.NOT_FOUND,
@@ -101,7 +101,7 @@ describe('DoubleTieError', () => {
 	});
 
 	describe('toJSON', () => {
-		it('should serialize error to JSON with H3 compatible structure', () => {
+		it('should serialize error to JSON with oRPC compatible structure', () => {
 			const error = new DoubleTieError('Test error', {
 				code: ERROR_CODES.BAD_REQUEST,
 				status: 400,
@@ -111,11 +111,12 @@ describe('DoubleTieError', () => {
 
 			const errorJson = error.toJSON();
 
-			expect(errorJson.statusCode).toBe(400);
+			expect(errorJson.status).toBe(400);
 			expect(errorJson.message).toBe('Test error');
-			expect(errorJson.data?.code).toBe(ERROR_CODES.BAD_REQUEST);
-			expect(errorJson.data?.category).toBe(ERROR_CATEGORIES.VALIDATION);
-			expect(errorJson.data?.meta).toEqual({ field: 'username' });
+			expect(errorJson.code).toBe(ERROR_CODES.BAD_REQUEST);
+			expect(errorJson.data.category).toBe(ERROR_CATEGORIES.VALIDATION);
+			expect(errorJson.data.meta).toEqual({ field: 'username' });
+			expect(errorJson.defined).toBe(true);
 		});
 
 		it('should include validation error message when present', () => {
@@ -128,7 +129,7 @@ describe('DoubleTieError', () => {
 			const errorJson = error.toJSON();
 
 			expect(errorJson.message).toBe('Field X is required');
-			expect(errorJson.data?.originalMessage).toBe('Validation failed');
+			expect(errorJson.data.originalMessage).toBe('Validation failed');
 		});
 	});
 

package/src/pkgs/results/core/error-class.ts

@@ -1,12 +1,12 @@
-import { H3Error } from 'h3';
+import { ORPCError } from '@orpc/server';
 import type { DoubleTieErrorOptions, ErrorMessageType } from '../types';
 import { ERROR_CATEGORIES, ERROR_CODES } from './error-codes';
 import { withSpan } from './tracing';
 
 /**
- * Custom error class for DoubleTie errors that extends H3Error.
+ * Custom error class for DoubleTie errors that extends ORPCError.
  *
- * This class directly extends H3Error to provide seamless integration with H3.js
+ * This class directly extends ORPCError to provide seamless integration with oRPC
  * while adding application-specific error properties and context.
  *
  * @remarks
@@ -32,18 +32,7 @@ import { withSpan } from './tracing';
  * }
  * ```
  */
-export class DoubleTieError extends H3Error<{
-	code: ErrorMessageType;
-	category?: string;
-	meta?: Record<string, unknown>;
-	originalMessage?: string;
-}> {
-	/**
-	 * Error code as defined in ERROR_CODES or custom error codes.
-	 * Used to uniquely identify the error type.
-	 */
-	readonly code: ErrorMessageType;
-
+export class DoubleTieError extends ORPCError<string, Record<string, unknown>> {
 	/**
 	 * Error category that groups related errors.
 	 * Defaults to 'unexpected' if not specified.
@@ -58,6 +47,11 @@ export class DoubleTieError extends H3Error<{
 	 */
 	readonly meta: Record<string, unknown>;
 
+	/**
+	 * HTTP status code for the error
+	 */
+	readonly statusCode: number;
+
 	/**
 	 * Creates a new DoubleTieError instance.
 	 *
@@ -89,26 +83,25 @@ export class DoubleTieError extends H3Error<{
 			meta: {},
 		}
 	) {
-		super(message, { cause: options.cause });
+		// Call ORPCError constructor with code and options
+		super(options.code ?? ERROR_CODES.UNKNOWN_ERROR, {
+			message,
+			cause: options.cause,
+			data: options.meta ?? {},
+		});
 
-		// Initialize properties
-		this.name = this.constructor.name;
-		this.code = options.code ?? ERROR_CODES.UNKNOWN_ERROR;
-		this.statusCode = options.status ?? 500;
+		// Set name explicitly
+		this.name = 'DoubleTieError';
+
+		// Initialize additional properties
 		this.category = options.category ?? ERROR_CATEGORIES.UNEXPECTED;
 		this.meta = options.meta ?? {};
-
-		// Set H3Error data property with our structured data
-		this.data = {
-			code: this.code,
-			category: this.category,
-			meta: this.meta,
-		};
+		this.statusCode = options.status ?? 500;
 
 		// Add tracing after initialization
 		withSpan('create_doubletie_error', async (span) => {
 			span.setAttributes({
-				'error.name': this.name,
+				'error.name': this.constructor.name,
 				'error.message': message,
 				'error.code': this.code,
 				'error.status': this.statusCode,
@@ -143,17 +136,10 @@ export class DoubleTieError extends H3Error<{
 	}
 
 	/**
-	 * Convert the error to a JSON-serializable object.
+	 * Convert the error to a JSON-serializable object matching oRPC's error format.
+	 * Override of the parent ORPCError toJSON method.
 	 */
-	toJSON(): Pick<
-		H3Error<{
-			code: string;
-			category?: string;
-			meta?: Record<string, unknown>;
-			originalMessage?: string;
-		}>,
-		'message' | 'data' | 'statusCode' | 'statusMessage'
-	> {
+	toJSON() {
 		// Extract validation error details if present
 		const validationErrorMessage = this.meta?.validationErrors
 			? String(this.meta.validationErrors)
@@ -167,13 +153,15 @@ export class DoubleTieError extends H3Error<{
 					.filter((line) => line && !line.includes('Error: '))
 			: [];
 
-		// Create the result object with proper structure matching H3Error toJSON return type
+		// Create the result object with proper structure matching oRPC error format
 		return {
-			statusCode: this.statusCode,
+			code: this.code,
 			message: validationErrorMessage || this.message,
-			statusMessage: this.statusMessage,
+			// oRPC expects a status field rather than statusCode
+			status: this.statusCode,
+			// Required field in ORPCErrorJSON
+			defined: true,
 			data: {
-				code: this.code,
 				category: this.category,
 				meta: this.meta,
 				...(process.env.NODE_ENV === 'production' ? {} : { stack: stackTrace }),
@@ -268,7 +256,7 @@ export class DoubleTieError extends H3Error<{
 		const ErrorSubclass = class extends DoubleTieError {
 			constructor(message: string, options: DoubleTieErrorOptions) {
 				super(message, options);
-				this.name = name;
+				Object.defineProperty(this, 'name', { value: name });
 			}
 		};
 

package/src/pkgs/results/index.ts

@@ -113,16 +113,6 @@ export {
 	withFallbackForCategory,
 } from './results/recovery-utils';
 
-// Export pipeline utilities
-export { validationPipeline } from './pipeline/validation-pipeline';
-export { retrievalPipeline } from './pipeline/retrieval-pipeline';
-
-// Export H3.js integration helpers
-export {
-	createH3ErrorHandler,
-	withH3ErrorHandling,
-} from './h3-integration';
-
 // Export telemetry options
 export {
 	createTelemetryOptions,

package/src/pkgs/results/orpc-error-handler.ts

@@ -0,0 +1,137 @@
+import { ORPCError } from '@orpc/server';
+import { DoubleTieError } from './core/error-class';
+import { ERROR_CODES } from './core/error-codes';
+
+/**
+ * Creates an oRPC error handler middleware that properly handles DoubleTieError instances
+ *
+ * This utility ensures consistent error handling across your oRPC application and
+ * properly converts DoubleTieError objects to oRPC-compatible error responses.
+ *
+ * @returns An oRPC request handler middleware for error handling
+ *
+ * @example
+ * ```typescript
+ * import { createORPCErrorHandler } from '@doubletie/results';
+ * import { OpenAPIHandler } from '@orpc/server';
+ *
+ * const handler = new OpenAPIHandler(router);
+ *
+ * // Register the error handler middleware
+ * handler.use(createORPCErrorHandler());
+ *
+ * // Your routes...
+ * ```
+ */
+export function createORPCErrorHandler() {
+	return (
+		request: Request,
+		context: { logger?: { error: (message: string, data?: object) => void } }
+	) => {
+		// Add error handler to context
+		return {
+			context: {
+				_onError: (error: unknown) => {
+					context.logger?.error('Error in oRPC error handler', { error });
+
+					// Handle DoubleTieError instances
+					if (error instanceof DoubleTieError) {
+						context.logger?.error('Handling DoubleTieError', {
+							code: error.code,
+							message: error.message,
+						});
+
+						// Convert DoubleTieError to ORPCError
+						throw new ORPCError(error.code, {
+							message: error.message,
+							cause: error.cause instanceof Error ? error.cause : undefined,
+							data: error.meta,
+						});
+					}
+
+					// For other errors, create a new ORPCError
+					context.logger?.error('Handling generic error', { error });
+					throw new ORPCError(ERROR_CODES.INTERNAL_SERVER_ERROR, {
+						message: error instanceof Error ? error.message : String(error),
+						cause: error instanceof Error ? error : undefined,
+					});
+				},
+			},
+		};
+	};
+}
+
+/**
+ * Wraps an oRPC handler with error handling for DoubleTieError
+ *
+ * @param handler - The handler function to wrap
+ * @returns A wrapped handler that automatically handles DoubleTieError instances
+ *
+ * @example
+ * ```typescript
+ * import { withORPCErrorHandling } from '@doubletie/results';
+ * import { os } from '@orpc/server';
+ *
+ * const getUserHandler = os.handler(async ({ input }) => {
+ *   // Your handler code that might throw DoubleTieError
+ *   throw new DoubleTieError('User not found', {
+ *     code: ERROR_CODES.NOT_FOUND,
+ *     status: 404
+ *   });
+ * });
+ *
+ * // Wrap the handler with error handling
+ * const safeGetUserHandler = withORPCErrorHandling(getUserHandler);
+ * ```
+ */
+export function withORPCErrorHandling<TInput, TOutput>(
+	handler: (
+		input: TInput,
+		context: {
+			logger?: { error: (message: string, data?: object) => void };
+			_onError?: (error: unknown) => unknown;
+		}
+	) => Promise<TOutput> | TOutput
+) {
+	return async (
+		input: TInput,
+		context: {
+			logger?: { error: (message: string, data?: object) => void };
+			_onError?: (error: unknown) => unknown;
+		}
+	) => {
+		try {
+			return await handler(input, context);
+		} catch (error) {
+			context.logger?.error('Error caught in withORPCErrorHandling', {
+				error,
+			});
+
+			// Handle DoubleTieError instances
+			if (error instanceof DoubleTieError) {
+				context.logger?.error('Handling DoubleTieError in wrapper', {
+					code: error.code,
+					message: error.message,
+				});
+
+				// Convert DoubleTieError to ORPCError
+				throw new ORPCError(error.code, {
+					message: error.message,
+					cause: error.cause instanceof Error ? error.cause : undefined,
+					data: error.meta,
+				});
+			}
+
+			// Use the context error handler if available
+			if (context._onError && typeof context._onError === 'function') {
+				return context._onError(error);
+			}
+
+			// Create and throw a new ORPCError
+			throw new ORPCError(ERROR_CODES.INTERNAL_SERVER_ERROR, {
+				message: error instanceof Error ? error.message : String(error),
+				cause: error instanceof Error ? error : undefined,
+			});
+		}
+	};
+}