@c15t/backend 1.8.0 → 2.0.0-rc.0

package/dist/pkgs/results/index.js

@@ -1,377 +0,0 @@
-import { Result, ResultAsync, err, errAsync, fromPromise, ok, okAsync } from "neverthrow";
-import { ORPCError } from "@orpc/server";
-import { SpanStatusCode, trace } from "@opentelemetry/api";
-const ERROR_CODES = Object.freeze({
-    NOT_FOUND: 'Resource not found',
-    BAD_REQUEST: 'Bad request',
-    CONFLICT: 'Conflict with current state',
-    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
-    UNAUTHORIZED: 'Unauthorized',
-    FORBIDDEN: 'Forbidden',
-    INTERNAL_SERVER_ERROR: 'Internal server error',
-    INITIALIZATION_FAILED: 'Initialization failed',
-    DATABASE_CONNECTION_ERROR: 'Database connection error',
-    DATABASE_QUERY_ERROR: 'Database query error',
-    INVALID_CONFIGURATION: 'Invalid configuration',
-    REQUEST_HANDLER_ERROR: 'Request handler error',
-    INVALID_REQUEST: 'Invalid request',
-    UNKNOWN_ERROR: 'Unknown error',
-    NETWORK_ERROR: 'Network error',
-    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
-    API_RETRIEVAL_ERROR: 'API retrieval error',
-    VALIDATION_ERROR: 'Validation error',
-    UNEXPECTED: 'Unexpected error'
-});
-const ERROR_CATEGORIES = Object.freeze({
-    VALIDATION: 'validation',
-    AUTHORIZATION: 'authorization',
-    STORAGE: 'storage',
-    NETWORK: 'network',
-    PLUGIN: 'plugin',
-    CONFIGURATION: 'configuration',
-    UNEXPECTED: 'unexpected'
-});
-const tracer = trace.getTracer('@doubletie/results');
-async function withSpan(name, fn, attributes = {}) {
-    return await tracer.startActiveSpan(name, async (span)=>{
-        try {
-            span.setAttributes(attributes);
-            const result = await fn(span);
-            span.setStatus({
-                code: SpanStatusCode.OK
-            });
-            span.end();
-            return result;
-        } catch (error) {
-            if (error instanceof DoubleTieError) {
-                span.setAttributes({
-                    'error.type': 'DoubleTieError',
-                    'error.code': error.code,
-                    'error.statusCode': error.statusCode,
-                    'error.message': error.message
-                });
-                if (error.meta) span.setAttributes({
-                    'error.meta': JSON.stringify(error.meta)
-                });
-            } else span.setAttributes({
-                'error.type': error instanceof Error ? error.constructor.name : 'Unknown',
-                'error.message': error instanceof Error ? error.message : String(error)
-            });
-            span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: error instanceof Error ? error.message : String(error)
-            });
-            span.end();
-            throw error;
-        }
-    });
-}
-class DoubleTieError extends ORPCError {
-    category;
-    meta;
-    statusCode;
-    constructor(message, options = {
-        code: ERROR_CODES.UNKNOWN_ERROR,
-        status: 500,
-        category: ERROR_CATEGORIES.UNEXPECTED,
-        cause: void 0,
-        meta: {}
-    }){
-        super(options.code ?? ERROR_CODES.UNKNOWN_ERROR, {
-            message,
-            cause: options.cause,
-            data: options.meta ?? {}
-        });
-        this.name = 'DoubleTieError';
-        this.category = options.category ?? ERROR_CATEGORIES.UNEXPECTED;
-        this.meta = options.meta ?? {};
-        this.statusCode = options.status ?? 500;
-        withSpan('create_doubletie_error', async (span)=>{
-            span.setAttributes({
-                'error.name': this.constructor.name,
-                'error.message': message,
-                'error.code': this.code,
-                'error.status': this.statusCode,
-                'error.category': this.category,
-                'error.has_cause': !!this.cause,
-                'error.cause_type': this.cause instanceof Error ? this.cause.constructor.name : typeof this.cause,
-                'error.has_meta': !!this.meta
-            });
-            if (this.cause instanceof Error) span.recordException(this.cause);
-        });
-        if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-    }
-    static isDoubleTieError(error) {
-        return error instanceof DoubleTieError;
-    }
-    toJSON() {
-        const validationErrorMessage = this.meta?.validationErrors ? String(this.meta.validationErrors) : void 0;
-        const stackTrace = this.stack ? this.stack.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.includes('Error: ')) : [];
-        return {
-            code: this.code,
-            message: validationErrorMessage || this.message,
-            status: this.statusCode,
-            defined: true,
-            data: {
-                category: this.category,
-                meta: this.meta,
-                ...'production' === process.env.NODE_ENV ? {} : {
-                    stack: stackTrace
-                },
-                ...validationErrorMessage && this.message ? {
-                    originalMessage: this.message
-                } : {},
-                ...this.cause ? {
-                    cause: this.cause instanceof Error ? {
-                        name: this.cause.name,
-                        message: this.cause.message,
-                        stack: this.cause.stack ? this.cause.stack.split('\n').map((line)=>line.trim()) : void 0
-                    } : this.cause
-                } : {}
-            }
-        };
-    }
-    static fromResponse(response, data) {
-        let message = `HTTP error ${response.status}`;
-        let errorCode = `HTTP ${response.status}`;
-        let errorMeta = {};
-        if (data && 'object' == typeof data && null !== data) {
-            const errorObj = data;
-            if ('string' == typeof errorObj.message) message = errorObj.message;
-            if ('string' == typeof errorObj.code) errorCode = errorObj.code;
-            if ('object' == typeof errorObj.data && null !== errorObj.data) errorMeta = errorObj.data;
-        }
-        return new DoubleTieError(message, {
-            code: errorCode,
-            status: response.status,
-            meta: errorMeta
-        });
-    }
-    withMeta(additionalMeta) {
-        return new DoubleTieError(this.message, {
-            code: this.code,
-            status: this.statusCode,
-            category: this.category,
-            cause: this.cause instanceof Error ? this.cause : void 0,
-            meta: {
-                ...this.meta,
-                ...additionalMeta
-            }
-        });
-    }
-    static createSubclass(name) {
-        const ErrorSubclass = class extends DoubleTieError {
-            constructor(message, options){
-                super(message, options);
-                Object.defineProperty(this, 'name', {
-                    value: name
-                });
-            }
-        };
-        Object.defineProperty(ErrorSubclass, 'name', {
-            value: name
-        });
-        return ErrorSubclass;
-    }
-    static formatValidationError(error) {
-        if (!error.meta) return error.message;
-        let formattedMessage = `${error.message} (${error.code})`;
-        if (error.meta.validationErrors) formattedMessage += `\nValidation Errors: ${JSON.stringify(error.meta.validationErrors, null, 2)}`;
-        const otherMeta = Object.fromEntries(Object.entries(error.meta).filter(([key])=>'validationErrors' !== key));
-        if (Object.keys(otherMeta).length > 0) formattedMessage += `\nAdditional Context: ${JSON.stringify(otherMeta, null, 2)}`;
-        return formattedMessage;
-    }
-}
-function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
-    const serviceVersion = process.env.npm_package_version || '1.0.0';
-    const config = {
-        disabled: telemetryConfig?.disabled ?? false,
-        tracer: telemetryConfig?.tracer,
-        defaultAttributes: {
-            ...telemetryConfig?.defaultAttributes || {},
-            'service.name': String(appName),
-            'service.version': serviceVersion
-        }
-    };
-    return config;
-}
-const withFallbackForCodes = (result, errorCodes, defaultValue)=>{
-    withSpan('recovery_with_fallback_codes', async (span)=>{
-        span.setAttributes({
-            'recovery.type': 'error_codes',
-            'recovery.codes': errorCodes.join(','),
-            'result.is_error': result.isErr()
-        });
-    });
-    return result.orElse((error)=>{
-        if (error.code && errorCodes.includes(error.code)) {
-            withSpan('recovery_with_fallback_codes', async (span)=>{
-                span.setAttributes({
-                    'recovery.matched': true,
-                    'recovery.error_code': error.code
-                });
-            });
-            return ok(defaultValue);
-        }
-        withSpan('recovery_with_fallback_codes', async (span)=>{
-            span.setAttributes({
-                'recovery.matched': false,
-                'recovery.error_code': error.code
-            });
-        });
-        return err(error);
-    });
-};
-const withFallbackForCategory = (result, category, defaultValue)=>{
-    withSpan('recovery_with_fallback_category', async (span)=>{
-        span.setAttributes({
-            'recovery.type': 'error_category',
-            'recovery.category': category,
-            'result.is_error': result.isErr()
-        });
-    });
-    return result.orElse((error)=>{
-        if (error.category === category) {
-            withSpan('recovery_with_fallback_category', async (span)=>{
-                span.setAttributes({
-                    'recovery.matched': true,
-                    'recovery.error_category': error.category
-                });
-            });
-            return ok(defaultValue);
-        }
-        withSpan('recovery_with_fallback_category', async (span)=>{
-            span.setAttributes({
-                'recovery.matched': false,
-                'recovery.error_category': error.category
-            });
-        });
-        return err(error);
-    });
-};
-function fail(message, options) {
-    const error = new DoubleTieError(message, options);
-    withSpan('create_error_result', async (span)=>{
-        span.setAttributes({
-            'error.message': message,
-            'error.code': options?.code,
-            'error.status': options?.status,
-            'error.category': options?.category
-        });
-    });
-    return err(error);
-}
-function failAsync(message, options) {
-    const error = new DoubleTieError(message, options);
-    withSpan('create_error_result_async', async (span)=>{
-        span.setAttributes({
-            'error.message': message,
-            'error.code': options?.code,
-            'error.status': options?.status,
-            'error.category': options?.category
-        });
-    });
-    return errAsync(error);
-}
-function tryCatch(fn, errorCode = ERROR_CODES.UNKNOWN_ERROR, errorMapper) {
-    try {
-        const result = fn();
-        withSpan('try_catch', async (span)=>{
-            span.setAttributes({
-                'operation.success': true,
-                'result.type': typeof result
-            });
-        });
-        return ok(result);
-    } catch (error) {
-        withSpan('try_catch', async (span)=>{
-            span.setAttributes({
-                'operation.success': false,
-                'error.type': error instanceof Error ? error.constructor.name : 'Unknown',
-                'error.message': error instanceof Error ? error.message : String(error)
-            });
-        });
-        if (errorMapper && error instanceof Error) {
-            const mappedError = errorMapper(error);
-            withSpan('try_catch', async (span)=>{
-                span.setAttributes({
-                    'error.mapped': true,
-                    'error.mapped_code': mappedError.code
-                });
-            });
-            return err(mappedError);
-        }
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return err(new DoubleTieError(errorMessage, {
-            code: errorCode,
-            cause: error instanceof Error ? error : void 0
-        }));
-    }
-}
-function tryCatchAsync(fn, errorCode = ERROR_CODES.UNKNOWN_ERROR, errorMapper) {
-    return ResultAsync.fromPromise((async ()=>{
-        try {
-            const result = await fn();
-            withSpan('try_catch_async', async (span)=>{
-                span.setAttributes({
-                    'operation.success': true,
-                    'result.type': typeof result
-                });
-            });
-            return result;
-        } catch (error) {
-            withSpan('try_catch_async', async (span)=>{
-                span.setAttributes({
-                    'operation.success': false,
-                    'error.type': error instanceof Error ? error.constructor.name : 'Unknown',
-                    'error.message': error instanceof Error ? error.message : String(error)
-                });
-            });
-            if (errorMapper && error instanceof Error) {
-                const mappedError = errorMapper(error);
-                withSpan('try_catch_async', async (span)=>{
-                    span.setAttributes({
-                        'error.mapped': true,
-                        'error.mapped_code': mappedError.code
-                    });
-                });
-                throw mappedError;
-            }
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new DoubleTieError(errorMessage, {
-                code: errorCode,
-                cause: error instanceof Error ? error : void 0
-            });
-        }
-    })(), (error)=>error instanceof DoubleTieError ? error : new DoubleTieError(String(error), {
-            code: errorCode,
-            cause: error instanceof Error ? error : void 0
-        }));
-}
-function promiseToResult(promise, errorCode = ERROR_CODES.UNKNOWN_ERROR) {
-    return ResultAsync.fromPromise(promise, (error)=>{
-        withSpan('promise_to_result', async (span)=>{
-            span.setAttributes({
-                'operation.success': false,
-                'error.type': error instanceof Error ? error.constructor.name : 'Unknown',
-                'error.message': error instanceof Error ? error.message : String(error)
-            });
-        });
-        return new DoubleTieError(error instanceof Error ? error.message : String(error), {
-            code: errorCode,
-            cause: error instanceof Error ? error : void 0,
-            meta: {
-                error
-            }
-        });
-    }).map((result)=>{
-        withSpan('promise_to_result', async (span)=>{
-            span.setAttributes({
-                'operation.success': true,
-                'result.type': typeof result
-            });
-        });
-        return result;
-    });
-}
-export { DoubleTieError, ERROR_CATEGORIES, ERROR_CODES, Result, ResultAsync, createTelemetryOptions, err, errAsync, fail, failAsync, fromPromise, ok, okAsync, promiseToResult, tryCatch, tryCatchAsync, withFallbackForCategory, withFallbackForCodes };

package/dist/pkgs/results/orpc-error-handler.d.ts

@@ -1,65 +0,0 @@
-/**
- * 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 declare function createORPCErrorHandler(): (_request: Request, context: {
-    logger?: {
-        error: (message: string, data?: object) => void;
-    };
-}) => {
-    context: {
-        _onError: (error: unknown) => never;
-    };
-};
-/**
- * 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 declare function withORPCErrorHandling<TInput, TOutput>(handler: (input: TInput, context: {
-    logger?: {
-        error: (message: string, data?: object) => void;
-    };
-    _onError?: (error: unknown) => unknown;
-}) => Promise<TOutput> | TOutput): (input: TInput, context: {
-    logger?: {
-        error: (message: string, data?: object) => void;
-    };
-    _onError?: (error: unknown) => unknown;
-}) => Promise<unknown>;
-//# sourceMappingURL=orpc-error-handler.d.ts.map

package/dist/pkgs/results/orpc-error-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"orpc-error-handler.d.ts","sourceRoot":"","sources":["../../../src/pkgs/results/orpc-error-handler.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,KAEpC,UAAU,OAAO,EACjB,SAAS;IAAE,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAA;CAAE;;0BAKrD,OAAO;;EA4B5B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,OAAO,EACpD,OAAO,EAAE,CACR,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IACR,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IAC7D,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACvC,KACG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,IAG9B,OAAO,MAAM,EACb,SAAS;IACR,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,CAAC;IAC7D,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACvC,sBAoCF"}

package/dist/pkgs/results/results/recovery-utils.d.ts

@@ -1,115 +0,0 @@
-import type { ErrorCategory, ErrorMessageType, SDKResult } from '../types';
-/**
- * Recovers from specific error codes by handling the error and returning a default value.
- * If the error is one of the specified codes, returns the default value.
- * Otherwise, passes the error through.
- *
- * @template TValue - Type of the success value in the result
- * @param result - The result that may contain an error
- * @param errorCodes - Array of error codes to recover from
- * @param defaultValue - Value to return if the error code matches
- * @returns The original result if successful or if error code doesn't match,
- *          or a new successful result with the default value
- *
- * @remarks
- * This function implements the "fallback value" pattern for error recovery.
- * It's particularly useful for handling expected error conditions like "not found"
- * where you want to provide a default value instead of propagating the error.
- *
- * The function does not modify the original result if it is successful or
- * if the error doesn't match any of the specified codes.
- *
- * @see withFallbackForCategory for recovery based on error category
- *
- * @example
- * ```typescript
- * import { withFallbackForCodes, ERROR_CODES } from '@doubletie/results';
- *
- * // Recover from not found errors with a default user
- * const getUserById = async (userId: string) => {
- *   const result = await fetchUserFromDatabase(userId);
- *
- *   return withFallbackForCodes(
- *     result,
- *     [ERROR_CODES.NOT_FOUND, ERROR_CODES.RESOURCE_DELETED],
- *     {
- *       id: userId,
- *       name: 'Unknown User',
- *       isDefault: true,
- *       email: 'unknown@example.com'
- *     }
- *   );
- * };
- *
- * // Usage with pattern matching
- * const userResult = await getUserById('123');
- * userResult.match(
- *   user => {
- *     console.log(`User: ${user.name}`);
- *     if (user.isDefault) {
- *       console.log('Using default user');
- *     }
- *   },
- *   error => console.error(`Unexpected error: ${error.message}`)
- * );
- * ```
- */
-export declare const withFallbackForCodes: <TValue>(result: SDKResult<TValue>, errorCodes: ErrorMessageType[], defaultValue: TValue) => SDKResult<TValue>;
-/**
- * Recovers from errors in a specific category by handling the error and returning a default value.
- * If the error's category matches the specified category, returns the default value.
- * Otherwise, passes the error through.
- *
- * @template TValue - Type of the success value in the result
- * @param result - The result that may contain an error
- * @param category - Error category to recover from
- * @param defaultValue - Value to return if the error category matches
- * @returns The original result if successful or if error category doesn't match,
- *          or a new successful result with the default value
- *
- * @remarks
- * This function is similar to `withFallbackForCodes` but matches errors based on
- * their category rather than specific error codes. This is useful when you want to
- * handle all errors in a particular domain (e.g., network, database, validation)
- * in a consistent way.
- *
- * The function does not modify the original result if it is successful or
- * if the error's category doesn't match the specified category.
- *
- * @see withFallbackForCodes for recovery based on specific error codes
- * @see ERROR_CATEGORIES for predefined categories
- *
- * @example
- * ```typescript
- * import { withFallbackForCategory, ERROR_CATEGORIES } from '@doubletie/results';
- *
- * // Recover from all network-related errors with a cached value
- * const fetchData = async (url: string, cachedData: ApiResponse) => {
- *   const result = await makeApiRequest(url);
- *
- *   return withFallbackForCategory(
- *     result,
- *     ERROR_CATEGORIES.NETWORK,
- *     {
- *       ...cachedData,
- *       fromCache: true,
- *       lastUpdated: new Date(cachedData.timestamp)
- *     }
- *   );
- * };
- *
- * // Usage with pattern matching
- * const dataResult = await fetchData('/api/stats', cachedStats);
- * dataResult.match(
- *   data => {
- *     if (data.fromCache) {
- *       console.log(`Using cached data from ${data.lastUpdated}`);
- *     }
- *     renderDashboard(data);
- *   },
- *   error => console.error(`Error: ${error.message}`)
- * );
- * ```
- */
-export declare const withFallbackForCategory: <TValue>(result: SDKResult<TValue>, category: ErrorCategory, defaultValue: TValue) => SDKResult<TValue>;
-//# sourceMappingURL=recovery-utils.d.ts.map

package/dist/pkgs/results/results/recovery-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recovery-utils.d.ts","sourceRoot":"","sources":["../../../../src/pkgs/results/results/recovery-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,EAC1C,QAAQ,SAAS,CAAC,MAAM,CAAC,EACzB,YAAY,gBAAgB,EAAE,EAC9B,cAAc,MAAM,KAClB,SAAS,CAAC,MAAM,CA4BlB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,eAAO,MAAM,uBAAuB,GAAI,MAAM,EAC7C,QAAQ,SAAS,CAAC,MAAM,CAAC,EACzB,UAAU,aAAa,EACvB,cAAc,MAAM,KAClB,SAAS,CAAC,MAAM,CA2BlB,CAAC"}