@c15t/backend 1.0.5 → 1.2.0-canary.0

package/src/pkgs/results/__tests__/validation-pipeline.test.ts

@@ -1,151 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { z } from 'zod';
-import { DoubleTieError } from '../core/error-class';
-import { ERROR_CODES } from '../core/error-codes';
-import { validationPipeline } from '../pipeline/validation-pipeline';
-
-describe('validationPipeline', () => {
-	// Define a simple schema for testing
-	const userSchema = z.object({
-		name: z.string().min(2),
-		email: z.string().email(),
-		age: z.number().min(18),
-	});
-
-	// Define a simple transformer
-	const transformer = (data: z.infer<typeof userSchema>) => ({
-		...data,
-		nameUpperCase: data.name.toUpperCase(),
-		isAdult: data.age >= 18,
-	});
-
-	it('should return a function that takes data to validate', () => {
-		const validate = validationPipeline(userSchema, transformer);
-		expect(typeof validate).toBe('function');
-	});
-
-	it('should validate and transform valid data successfully', () => {
-		const validate = validationPipeline(userSchema, transformer);
-
-		const validData = {
-			name: 'John',
-			email: 'john@example.com',
-			age: 25,
-		};
-
-		const result = validate(validData);
-
-		expect(result.isOk()).toBe(true);
-		expect(result._unsafeUnwrap()).toEqual({
-			name: 'John',
-			email: 'john@example.com',
-			age: 25,
-			nameUpperCase: 'JOHN',
-			isAdult: true,
-		});
-	});
-
-	it('should return an error result when validation fails', () => {
-		const validate = validationPipeline(userSchema, transformer);
-
-		const invalidData = {
-			name: 'J', // Too short
-			email: 'not-an-email', // Invalid email
-			age: 16, // Below minimum age
-		};
-
-		const result = validate(invalidData);
-
-		expect(result.isErr()).toBe(true);
-		const error = result._unsafeUnwrapErr();
-
-		expect(error).toBeInstanceOf(DoubleTieError);
-		expect(error.code).toBe(ERROR_CODES.INVALID_REQUEST);
-		expect(error.statusCode).toBe(400);
-		expect(error.meta).toBeDefined();
-		expect(error.meta.validationErrors).toBeDefined();
-
-		// Check that validation errors contain the expected fields
-		const validationErrors = error.meta.validationErrors as z.ZodIssue[];
-
-		// Verify we have all three validation errors
-		expect(validationErrors).toHaveLength(3);
-
-		// Find errors for each field by their path
-		const nameError = validationErrors.find((e) => e.path[0] === 'name');
-		const emailError = validationErrors.find((e) => e.path[0] === 'email');
-		const ageError = validationErrors.find((e) => e.path[0] === 'age');
-
-		// Verify each error exists
-		expect(nameError).toBeDefined();
-		expect(emailError).toBeDefined();
-		expect(ageError).toBeDefined();
-
-		// Verify specific error messages
-		expect(nameError?.message).toBe(
-			'String must contain at least 2 character(s)'
-		);
-		expect(emailError?.message).toBe('Invalid email');
-		expect(ageError?.message).toBe(
-			'Number must be greater than or equal to 18'
-		);
-
-		// Verify error codes
-		expect(nameError?.code).toBe('too_small');
-		expect(emailError?.code).toBe('invalid_string');
-		expect(ageError?.code).toBe('too_small');
-	});
-
-	it('should return an error result when transformer throws', () => {
-		const errorThrowingTransformer = vi.fn().mockImplementation(() => {
-			throw new Error('Transformation error');
-		});
-
-		const validate = validationPipeline(userSchema, errorThrowingTransformer);
-
-		const validData = {
-			name: 'John',
-			email: 'john@example.com',
-			age: 25,
-		};
-
-		const result = validate(validData);
-
-		expect(result.isErr()).toBe(true);
-		const error = result._unsafeUnwrapErr();
-
-		expect(error).toBeInstanceOf(DoubleTieError);
-		expect(error.code).toBe(ERROR_CODES.BAD_REQUEST);
-		expect(error.cause).toBeInstanceOf(Error);
-		expect(error.cause instanceof Error && error.cause.message).toBe(
-			'Transformation error'
-		);
-
-		// Check that the transformer was called with the validated data
-		expect(errorThrowingTransformer).toHaveBeenCalledWith(validData);
-
-		// Check that the input data is included in the metadata
-		expect(error.meta.inputData).toEqual(validData);
-	});
-
-	it('should handle different schema types correctly', () => {
-		// Array schema
-		const arraySchema = z.array(z.string());
-		const arrayTransformer = (data: string[]) =>
-			data.map((item) => item.toUpperCase());
-		const validateArray = validationPipeline(arraySchema, arrayTransformer);
-
-		const arrayResult = validateArray(['a', 'b', 'c']);
-		expect(arrayResult.isOk()).toBe(true);
-		expect(arrayResult._unsafeUnwrap()).toEqual(['A', 'B', 'C']);
-
-		// Number schema
-		const numberSchema = z.number().positive();
-		const numberTransformer = (num: number) => num * 2;
-		const validateNumber = validationPipeline(numberSchema, numberTransformer);
-
-		const numberResult = validateNumber(5);
-		expect(numberResult.isOk()).toBe(true);
-		expect(numberResult._unsafeUnwrap()).toBe(10);
-	});
-});

package/src/pkgs/results/h3-integration.ts

@@ -1,142 +0,0 @@
-import { eventHandler, sendError } from 'h3';
-import type { H3Event } from 'h3';
-import { DoubleTieError } from './core/error-class';
-import { ERROR_CODES } from './core/error-codes';
-
-// Extend the H3 context type to include our custom _onError property
-declare module 'h3' {
-	interface H3EventContext {
-		_onError?: (error: unknown) => unknown;
-	}
-}
-
-/**
- * Creates an H3 error handler middleware that properly handles DoubleTieError instances
- *
- * This utility ensures consistent error handling across your H3.js application and
- * properly converts DoubleTieError objects to H3-compatible error responses.
- *
- * @returns An H3 event handler middleware for error handling
- *
- * @example
- * ```typescript
- * import { createH3ErrorHandler } from '@doubletie/results';
- * import { createApp } from 'h3';
- *
- * const app = createApp();
- *
- * // Register the error handler middleware
- * app.use(createH3ErrorHandler());
- *
- * // Your routes...
- * ```
- */
-export function createH3ErrorHandler() {
-	return eventHandler((event) => {
-		// Attach our error handler to the event context
-		event.context._onError = (error: unknown) => {
-			event.context.logger.error('Error in H3 error handler', { error });
-			// Handle DoubleTieError instances
-			if (error instanceof DoubleTieError) {
-				event.context.logger.error(
-					'Handling DoubleTieError:',
-					error.statusCode,
-					error.message
-				);
-				// DoubleTieError is already an H3Error, so we can send it directly
-				return sendError(event, error);
-			}
-
-			// For other errors, create a new DoubleTieError
-			event.context.logger.error('Handling generic error', { error });
-			const dtError = new DoubleTieError(
-				error instanceof Error ? error.message : String(error),
-				{
-					code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-					status: 500,
-					cause: error instanceof Error ? error : undefined,
-				}
-			);
-
-			return sendError(event, dtError);
-		};
-
-		// We need to call event.node.req.on('error') to handle connection errors
-		event.node.req.on('error', (err) => {
-			event.context.logger.error('Request error event triggered:', { err });
-			if (event.context._onError) {
-				event.context._onError(err);
-			}
-		});
-
-		// Continue with request processing
-		return;
-	});
-}
-
-/**
- * Wraps an H3 event handler with error handling for DoubleTieError
- *
- * @param handler - The event handler to wrap
- * @returns A wrapped handler that automatically handles DoubleTieError instances
- *
- * @example
- * ```typescript
- * import { withH3ErrorHandling } from '@doubletie/results';
- * import { eventHandler } from 'h3';
- *
- * app.use('/api/users', withH3ErrorHandling(
- *   eventHandler(async (event) => {
- *     // Your handler code that might throw DoubleTieError
- *     throw new DoubleTieError('User not found', {
- *       code: ERROR_CODES.NOT_FOUND,
- *       status: 404
- *     });
- *   })
- * ));
- * ```
- */
-export function withH3ErrorHandling(
-	handler: (event: H3Event) => Promise<unknown> | unknown
-) {
-	return eventHandler(async (event) => {
-		try {
-			return await handler(event);
-		} catch (error) {
-			event.context.logger.error('Error caught in withH3ErrorHandling:', {
-				error,
-			});
-
-			// Handle DoubleTieError instances
-			if (error instanceof DoubleTieError) {
-				event.context.logger.error(
-					'Handling DoubleTieError in wrapper:',
-					error.statusCode,
-					error.message
-				);
-				// DoubleTieError is already an H3Error, so we can send it directly
-				return sendError(event, error);
-			}
-
-			// Use the context error handler if available
-			if (
-				event.context._onError &&
-				typeof event.context._onError === 'function'
-			) {
-				return event.context._onError(error);
-			}
-
-			// Create and send a new DoubleTieError
-			const dtError = new DoubleTieError(
-				error instanceof Error ? error.message : String(error),
-				{
-					code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-					status: 500,
-					cause: error instanceof Error ? error : undefined,
-				}
-			);
-
-			return sendError(event, dtError);
-		}
-	});
-}

package/src/pkgs/results/pipeline/retrieval-pipeline.ts

@@ -1,188 +0,0 @@
-import { ResultAsync } from 'neverthrow';
-import { DoubleTieError } from '../core/error-class';
-import { ERROR_CODES } from '../core/error-codes';
-import type { ErrorMessageType, SDKResultAsync } from '../types';
-
-/**
- * Creates a retrieval pipeline that fetches data asynchronously and transforms it.
- * Handles errors in a standardized way and includes null/undefined checks.
- *
- * @template TRawData - Type of the raw data fetched from the source
- * @template TTransformedData - Type of the data after transformation
- *
- * @param fetcher - Async function that fetches the raw data
- * @param transformer - Function that transforms the raw data
- * @param errorCode - Error code to use if the fetcher throws (defaults to NOT_FOUND)
- * @returns A function that returns a ResultAsync with the transformed data or an error
- *
- * @remarks
- * This function implements a common pattern for retrieving and transforming data from
- * external sources like databases, APIs, or file systems. It handles:
- *
- * 1. Asynchronous data fetching with proper error handling
- * 2. Null/undefined checks to detect missing resources
- * 3. Data transformation to convert raw data to the desired format
- * 4. Standardized error creation with appropriate error codes and metadata
- *
- * The pipeline is particularly useful for:
- * - Database queries where records might not exist
- * - API calls that may fail or return empty results
- * - File system operations where files might be missing
- *
- * @see ERROR_CODES.NOT_FOUND for the default error code used when resources are missing
- * @see validationPipeline for handling data validation
- *
- * @example
- * ```typescript
- * import { retrievalPipeline, ERROR_CODES } from '@doubletie/results';
- * import { db } from './database';
- *
- * // Define types for raw and transformed data
- * interface UserRecord {
- *   id: string;
- *   first_name: string;
- *   last_name: string;
- *   email: string;
- *   created_at: string;
- * }
- *
- * interface User {
- *   id: string;
- *   fullName: string;
- *   email: string;
- *   createdAt: Date;
- * }
- *
- * // Create a retrieval pipeline for fetching users
- * const getUserById = (userId: string) => {
- *   return retrievalPipeline<UserRecord, User>(
- *     // Fetcher function to get raw data
- *     async () => {
- *       return await db.users.findUnique({
- *         where: { id: userId }
- *       });
- *     },
- *
- *     // Transformer function to format the data
- *     (record) => ({
- *       id: record.id,
- *       fullName: `${record.first_name} ${record.last_name}`,
- *       email: record.email,
- *       createdAt: new Date(record.created_at)
- *     }),
- *
- *     // Custom error code for this specific resource type
- *     ERROR_CODES.USER_NOT_FOUND
- *   );
- * };
- *
- * // Using the pipeline
- * async function handleUserRequest(req, res) {
- *   const userId = req.params.id;
- *
- *   const userResult = await getUserById(userId)();
- *
- *   return userResult.match(
- *     (user) => {
- *       // Successfully retrieved and transformed the user
- *       return res.json(user);
- *     },
- *     (error) => {
- *       // Handle the error based on its code
- *       if (error.code === ERROR_CODES.USER_NOT_FOUND) {
- *         return res.status(404).json({ error: `User ${userId} not found` });
- *       }
- *
- *       // Handle other errors
- *       console.error(`Error fetching user:`, error);
- *       return res.status(error.status).json({ error: error.message });
- *     }
- *   );
- * }
- * ```
- */
-export const retrievalPipeline = <TRawData, TTransformedData>(
-	fetcher: () => Promise<TRawData>,
-	transformer: (data: TRawData) => TTransformedData,
-	errorCode: ErrorMessageType = ERROR_CODES.NOT_FOUND
-): (() => SDKResultAsync<TTransformedData>) => {
-	return () => {
-		return ResultAsync.fromPromise(
-			fetcher().then((data) => {
-				// Check if data is null or undefined
-				if (data === null || data === undefined) {
-					throw new Error('Resource not found');
-				}
-
-				try {
-					// Transform the data (wrapping in try/catch to handle transformer errors)
-					return transformer(data);
-				} catch (transformerError) {
-					// Explicitly handle transformer errors as BAD_REQUEST
-					throw new DoubleTieError(
-						transformerError instanceof Error
-							? transformerError.message
-							: 'Error transforming data',
-						{
-							code: ERROR_CODES.BAD_REQUEST,
-							status: 400,
-							cause:
-								transformerError instanceof Error
-									? transformerError
-									: undefined,
-						}
-					);
-				}
-			}),
-			(error) => {
-				// If the error is already a DoubleTieError, return it directly
-				if (error instanceof DoubleTieError) {
-					return error;
-				}
-
-				// Check if this is a custom error code or a standard one
-				const useCustomErrorCode = errorCode !== ERROR_CODES.NOT_FOUND;
-
-				// If a custom error code is provided, always use it
-				if (useCustomErrorCode) {
-					return new DoubleTieError(
-						error instanceof Error
-							? error.message
-							: 'Failed to retrieve resource',
-						{
-							code: errorCode,
-							status: 400, // Custom codes default to 400
-							cause: error instanceof Error ? error : undefined,
-						}
-					);
-				}
-
-				// Handle standard error cases
-				const isNotFoundError =
-					error instanceof Error &&
-					error.message.toLowerCase().includes('not found');
-
-				// Use specific error code based on error type
-				if (isNotFoundError) {
-					// Not found errors
-					return new DoubleTieError(error.message, {
-						code: ERROR_CODES.NOT_FOUND,
-						status: 404,
-						cause: error,
-					});
-				}
-				// All other errors use BAD_REQUEST
-				return new DoubleTieError(
-					error instanceof Error
-						? error.message
-						: 'Failed to retrieve resource',
-					{
-						code: ERROR_CODES.BAD_REQUEST,
-						status: 400,
-						cause: error instanceof Error ? error : undefined,
-					}
-				);
-			}
-		);
-	};
-};

package/src/pkgs/results/pipeline/validation-pipeline.ts

@@ -1,164 +0,0 @@
-import type { ZodSchema } from 'zod';
-import { ERROR_CODES } from '../core/error-codes';
-import { fail, ok } from '../results/result-helpers';
-import type { SDKResult } from '../types';
-
-/**
- * Creates a validation pipeline that validates input data with a Zod schema
- * and transforms it to an output format.
- *
- * @template TInput - Type of the input data after validation
- * @template TOutput - Type of the output data after transformation
- *
- * @param schema - Zod schema to validate the input data
- * @param transformer - Function to transform validated data
- * @returns A function that takes input data and returns a Result with the transformed data or an error
- *
- * @remarks
- * This function implements a common pattern for validating and transforming input data.
- * It first validates the input using a Zod schema, and if valid, transforms it using
- * the provided transformer function. If validation fails, it returns a well-structured
- * error with validation details.
- *
- * The validation pipeline is particularly useful for:
- * - API request body validation
- * - Form data validation
- * - Configuration validation
- * - Data import/export validation
- *
- * The transformer function allows you to adapt the validated data to the shape
- * expected by your application logic.
- *
- * @see ValidationErrorDetails for the structure of validation errors
- *
- * @example
- * ```typescript
- * import { z } from 'zod';
- * import { validationPipeline, ERROR_CODES } from '@doubletie/results';
- *
- * // Define a schema for user input
- * const userSchema = z.object({
- *   name: z.string().min(2).max(100),
- *   email: z.string().email(),
- *   age: z.number().int().min(18).optional(),
- *   role: z.enum(['admin', 'user', 'guest'])
- * });
- *
- * // Type inferred from schema
- * type UserInput = z.infer<typeof userSchema>;
- *
- * // Type for the transformed output
- * interface UserRecord {
- *   id: string;
- *   displayName: string;
- *   email: string;
- *   age?: number;
- *   role: string;
- *   createdAt: Date;
- * }
- *
- * // Create a validation pipeline
- * const validateUser = validationPipeline<UserInput, UserRecord>(
- *   userSchema,
- *   (validData) => ({
- *     id: generateId(),
- *     displayName: validData.name,
- *     email: validData.email.toLowerCase(),
- *     age: validData.age,
- *     role: validData.role,
- *     createdAt: new Date()
- *   })
- * );
- *
- * // Using the pipeline
- * function createUser(rawData: unknown) {
- *   const result = validateUser(rawData);
- *
- *   return result.match(
- *     (user) => {
- *       // Work with validated and transformed data
- *       return saveUserToDatabase(user);
- *     },
- *     (error) => {
- *       // Handle validation errors
- *       console.error('Validation failed:', error.meta.validationErrors);
- *       throw error;
- *     }
- *   );
- * }
- * ```
- */
-export const validationPipeline = <TInput, TOutput>(
-	schema: ZodSchema<TInput>,
-	transformer: (data: TInput) => TOutput
-): ((data: unknown) => SDKResult<TOutput>) => {
-	return (data: unknown) => {
-		// Preprocess the data to handle stringified values
-		const preprocessData = (value: unknown): unknown => {
-			if (typeof value !== 'object' || value === null) {
-				// Try parsing stringified JSON values
-				if (typeof value === 'string') {
-					try {
-						// Check if it's a stringified array
-						if (value.startsWith('[') && value.endsWith(']')) {
-							return JSON.parse(value);
-						}
-						// Check if it's a stringified boolean
-						if (value.toLowerCase() === 'true') {
-							return true;
-						}
-						if (value.toLowerCase() === 'false') {
-							return false;
-						}
-						// Check if it's a stringified object
-						if (value.startsWith('{') && value.endsWith('}')) {
-							return JSON.parse(value);
-						}
-					} catch {
-						// If parsing fails, return original value
-						return value;
-					}
-				}
-				return value;
-			}
-
-			// Handle arrays
-			if (Array.isArray(value)) {
-				return value.map(preprocessData);
-			}
-
-			// Handle objects
-			const processed: Record<string, unknown> = {};
-			for (const [key, val] of Object.entries(value)) {
-				processed[key] = preprocessData(val);
-			}
-			return processed;
-		};
-
-		const preprocessedData = preprocessData(data);
-		const parseResult = schema.safeParse(preprocessedData);
-
-		if (!parseResult.success) {
-			return fail<TOutput>('Validation failed', {
-				code: ERROR_CODES.INVALID_REQUEST,
-				status: 400,
-				meta: {
-					validationErrors: parseResult.error.issues,
-				},
-			});
-		}
-
-		try {
-			return ok(transformer(parseResult.data));
-		} catch (error) {
-			return fail<TOutput>('Error transforming data after validation', {
-				code: ERROR_CODES.BAD_REQUEST,
-				status: 400,
-				cause: error instanceof Error ? error : undefined,
-				meta: {
-					inputData: parseResult.data,
-				},
-			});
-		}
-	};
-};

package/src/response-types.ts

@@ -1,29 +0,0 @@
-/**
- * Public API Types
- *
- * This file exports all the types needed by client applications to interact with the API.
- * It contains request and response type definitions for all public endpoints.
- */
-
-// Import route definitions to extract their types
-import type { z } from 'zod';
-import type { RouteResponseType } from './pkgs/api-router/utils/define-route';
-import type { setConsent } from './routes/set-consent';
-import type { showConsentBanner } from './routes/show-consent-banner';
-import type { verifyConsent } from './routes/verify-consent';
-
-// Export the schemas
-import type { SetConsentRequestBody as SetConsentRequestBodyZod } from './routes/set-consent';
-import type { VerifyConsentRequestBody as VerifyConsentRequestBodyZod } from './routes/verify-consent';
-
-// Export response types extracted directly from route definitions
-export type SetConsentResponse = RouteResponseType<typeof setConsent>;
-export type ShowConsentBannerResponse = RouteResponseType<
-	typeof showConsentBanner
->;
-export type VerifyConsentResponse = RouteResponseType<typeof verifyConsent>;
-
-export type SetConsentRequestBody = z.infer<typeof SetConsentRequestBodyZod>;
-export type VerifyConsentRequestBody = z.infer<
-	typeof VerifyConsentRequestBodyZod
->;