@c15t/backend 1.0.5 → 1.2.0-canary.0

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/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,
+			});
+		}
+	};
+}

package/src/pkgs/results/types.ts

@@ -1,4 +1,4 @@
-import type { H3Error } from 'h3';
+import type { ORPCError } from '@orpc/server';
 import type { Result, ResultAsync } from 'neverthrow';
 
 /**
@@ -46,17 +46,13 @@ export type ErrorMessageType = string;
  *
  * @remarks
  * This interface defines the public API of the DoubleTieError class.
- * It extends the H3Error class with additional properties and methods
+ * It extends the ORPCError class with additional properties and methods
  * specific to the DoubleTie error handling system.
  *
  * @see DoubleTieErrorOptions for the options used to construct a DoubleTieError
  */
 export interface DoubleTieError
-	extends H3Error<{
-		code: ErrorMessageType;
-		category?: ErrorCategory;
-		meta?: Record<string, unknown>;
-	}> {
+	extends ORPCError<string, Record<string, unknown>> {
 	/**
 	 * Error code identifying the error type
 	 */
@@ -72,6 +68,11 @@ export interface DoubleTieError
 	 */
 	readonly meta: Record<string, unknown>;
 
+	/**
+	 * HTTP status code for the error
+	 */
+	readonly statusCode: number;
+
 	/**
 	 * Creates a new error instance with additional metadata
 	 */

package/src/pkgs/types/context.ts

@@ -1,7 +1,6 @@
-import type { H3Event } from 'h3';
+import type { createLogger } from '@doubletie/logger';
 import type { DatabaseHook, EntityName } from '~/pkgs/data-model';
 import type { Adapter } from '~/pkgs/db-adapters/types';
-import type { createLogger } from '~/pkgs/logger';
 import type { createRegistry } from '~/schema/create-registry';
 import type { getConsentTables } from '~/schema/definition';
 import type { DoubleTieOptions } from './options';
@@ -12,7 +11,12 @@ import type { DoubleTieOptions } from './options';
  * This type extends the standard endpoint context with additional properties
  * specific to DoubleTie hooks, allowing hooks to access the complete DoubleTie context.
  */
-export type HookEndpointContext = H3Event & {
+export type HookEndpointContext = {
+	/**
+	 * The request object
+	 */
+	request: Request;
+
 	/**
 	 * The DoubleTie context with possible hook-specific extensions
 	 */
@@ -35,7 +39,12 @@ export type HookEndpointContext = H3Event & {
  * A simplified context type for endpoint handlers that don't need
  * access to input-specific context properties.
  */
-export type GenericEndpointContext = H3Event & {
+export type GenericEndpointContext = {
+	/**
+	 * The request object
+	 */
+	request: Request;
+
 	/**
 	 * The DoubleTie application context
 	 */
@@ -149,6 +158,11 @@ export interface BaseDoubleTieContext {
 	 * User agent of the client
 	 */
 	userAgent?: string | null;
+
+	/**
+	 * Headers of the request
+	 */
+	headers?: Headers;
 }
 
 /**

package/src/pkgs/types/endpoints.ts

@@ -1,5 +1,3 @@
-import type { H3Event } from 'h3';
-
 export interface EndpointOptions {
 	/**
 	 * Whether authentication is required for this endpoint
@@ -12,12 +10,12 @@ export interface EndpointOptions {
 	middleware?: EndpointMiddleware[];
 }
 
-export type EndpointMiddleware = (event: H3Event) => Promise<void>;
+export type EndpointMiddleware = (request: Request) => Promise<void>;
 
-export type EndpointHandler = (event: H3Event) => Promise<unknown>;
+export type EndpointHandler = (request: Request) => Promise<unknown>;
 
 /**
- * Native H3 endpoint interface
+ * Native endpoint interface
  */
 export interface Endpoint {
 	/**

package/src/pkgs/types/options.ts

@@ -1,11 +1,10 @@
 import type { DatabaseHook } from '~/pkgs/data-model';
 import type { DatabaseConfiguration } from '~/pkgs/db-adapters/adapters/kysely-adapter/types';
 
+import type { LoggerOptions } from '@doubletie/logger';
 import type { Tracer } from '@opentelemetry/api';
-import type { H3Event } from 'h3';
 // Import table configuration types from the schema module
 import type { TablesConfig } from '~/schema/types';
-import type { LoggerOptions } from '../logger';
 import type { DoubleTiePlugin } from './plugins';
 
 /**
@@ -228,6 +227,6 @@ export interface DoubleTieOptions {
  * Middleware function for processing API requests
  */
 export type DoubleTieMiddleware = (
-	event: H3Event,
+	request: Request,
 	next: () => Promise<unknown>
 ) => Promise<unknown>;

package/src/pkgs/types/plugins.ts

@@ -1,4 +1,3 @@
-import type { H3Event } from 'h3';
 import type { Migration } from 'kysely';
 import type { Field } from '~/pkgs/data-model';
 import type { DoubleTieContext, HookEndpointContext } from './context';
@@ -75,12 +74,12 @@ export interface DoubleTiePlugin {
 	/**
 	 * Handler for intercepting and potentially modifying incoming requests
 	 */
-	onRequest?: (event: H3Event, ctx: DoubleTieContext) => Promise<unknown>;
+	onRequest?: (request: Request, ctx: DoubleTieContext) => Promise<unknown>;
 
 	/**
 	 * Handler for intercepting and potentially modifying outgoing responses
 	 */
-	onResponse?: (event: H3Event, ctx: DoubleTieContext) => Promise<unknown>;
+	onResponse?: (response: Response, ctx: DoubleTieContext) => Promise<unknown>;
 
 	/**
 	 * Request lifecycle hooks for executing code before or after endpoint handling

package/src/pkgs/utils/index.ts

@@ -1,2 +1,3 @@
 export { env, isProduction, isTest } from './env';
 export { getBaseURL } from './url';
+export * from './logger';

package/src/pkgs/utils/logger.ts

@@ -0,0 +1,38 @@
+import {
+	type LoggerOptions,
+	createLogger as createDTLogger,
+} from '@doubletie/logger';
+
+let globalLogger: ReturnType<typeof createDTLogger>;
+
+/**
+ * Gets or creates a global logger instance
+ *
+ * @param options - Optional logger configuration options
+ * @returns The global logger instance
+ */
+export function getLogger(
+	options?: LoggerOptions
+): ReturnType<typeof createDTLogger> {
+	if (!globalLogger) {
+		globalLogger = createDTLogger({
+			level: 'info',
+			appName: 'c15t',
+			...options,
+		});
+	}
+	return globalLogger;
+}
+
+/**
+ * Initializes the global logger with specific options
+ *
+ * @param options - Logger configuration options
+ * @returns The initialized global logger instance
+ */
+export function initLogger(
+	options: LoggerOptions
+): ReturnType<typeof createDTLogger> {
+	globalLogger = createDTLogger(options);
+	return globalLogger;
+}

package/src/router.ts

@@ -0,0 +1,8 @@
+import { os } from './contracts';
+import { consentHandlers } from './handlers/consent';
+import { metaHandlers } from './handlers/meta';
+
+export const router = os.router({
+	consent: consentHandlers,
+	meta: metaHandlers,
+});