@memory-bank/mcp/dist/shared/errors/ApplicationError.js

Memory-enabled Co-Pilot (MCP) server for managing project documentation and context

import { BaseError } from './BaseError.js';
/**
 * Error class for application layer
 * Used for use case execution errors and application flow errors
 */
export class ApplicationError extends BaseError {
    /**
     * Create a new ApplicationError
     *
     * @param code Error code (without prefix)
     * @param message Human-readable error message
     * @param details Additional error details
     * @param options Additional error options
     */
    constructor(code, message, details, options) {
        super(`APP_ERROR.${code}`, message, details, options);
    }
    /**
     * Application errors may be either client or server errors
     * depending on the specific error code
     */
    getHttpStatusCode() {
        const codeWithoutPrefix = this.code.replace('APP_ERROR.', '');
        // Map specific error codes to HTTP status codes
        switch (codeWithoutPrefix) {
            case ApplicationErrorCodes.INVALID_INPUT:
                return 400; // Bad Request
            case ApplicationErrorCodes.UNAUTHORIZED:
                return 401; // Unauthorized
            case ApplicationErrorCodes.FORBIDDEN:
                return 403; // Forbidden
            case ApplicationErrorCodes.NOT_FOUND:
                return 404; // Not Found
            case ApplicationErrorCodes.CONFLICT:
                return 409; // Conflict
            case ApplicationErrorCodes.BRANCH_INITIALIZATION_FAILED:
                return 500; // Internal Server Error
            default:
                return 500; // Internal Server Error
        }
    }
    /**
     * Create a new ApplicationError with the same code but a new message
     * Useful for adding context to existing errors
     *
     * @param newMessage New error message
     * @param additionalDetails Additional details to merge with existing details
     */
    withMessage(newMessage, additionalDetails) {
        const combinedDetails = {
            ...this.details,
            ...additionalDetails,
            originalMessage: this.message
        };
        return new ApplicationError(this.code.replace('APP_ERROR.', ''), newMessage, combinedDetails, { cause: this.cause });
    }
}
/**
 * Application error code constants
 */
export const ApplicationErrorCodes = {
    INVALID_INPUT: 'INVALID_INPUT',
    USE_CASE_EXECUTION_FAILED: 'USE_CASE_EXECUTION_FAILED',
    UNAUTHORIZED: 'UNAUTHORIZED',
    FORBIDDEN: 'FORBIDDEN',
    NOT_FOUND: 'NOT_FOUND',
    CONFLICT: 'CONFLICT',
    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
    UNEXPECTED_CONTROLLER_ERROR: 'UNEXPECTED_CONTROLLER_ERROR',
    INVALID_STATE: 'INVALID_STATE',
    OPERATION_NOT_ALLOWED: 'OPERATION_NOT_ALLOWED',
    CONFIGURATION_ERROR: 'CONFIGURATION_ERROR', // Added
    VALIDATION_FAILED: 'VALIDATION_FAILED', // Added
    BRANCH_INITIALIZATION_FAILED: 'BRANCH_INITIALIZATION_FAILED', // Added for branch init errors
};
/**
 * Factory functions for creating standard application errors
 */
export const ApplicationErrors = {
    /**
     * Create an invalid input error
     */
    invalidInput: (message, additionalDetails) => {
        return new ApplicationError(ApplicationErrorCodes.INVALID_INPUT, message, additionalDetails);
    },
    /**
     * Create a not found error
     */
    notFound: (resource, id, additionalDetails) => {
        return new ApplicationError(ApplicationErrorCodes.NOT_FOUND, `${resource} with id ${id} was not found`, { resourceType: resource, resourceId: id, ...additionalDetails });
    },
    /**
     * Create an unauthorized error
     */
    unauthorized: (message, additionalDetails) => {
        return new ApplicationError(ApplicationErrorCodes.UNAUTHORIZED, message, additionalDetails);
    },
    /**
     * Create an execution failed error
     */
    executionFailed: (useCaseName, cause, additionalDetails) => {
        return new ApplicationError(ApplicationErrorCodes.USE_CASE_EXECUTION_FAILED, `Execution of use case '${useCaseName}' failed`, { useCaseName, ...additionalDetails }, { cause });
    },
    /**
     * Create an unexpected controller error
     */
    unexpectedControllerError: (controllerName, cause, additionalDetails) => {
        return new ApplicationError('UNEXPECTED_CONTROLLER_ERROR', // Assuming UNEXPECTED_CONTROLLER_ERROR is a valid code or needs to be added
        `An unexpected error occurred in controller '${controllerName}'`, { controllerName, ...additionalDetails }, { cause });
    },
    /**
     * Create a configuration error
     */
    configurationError: (message, cause, additionalDetails) => {
        return new ApplicationError(ApplicationErrorCodes.CONFIGURATION_ERROR, message, additionalDetails, { cause });
    },
    /**
     * Create a validation failed error for use cases
     */
    validationFailed: (useCaseName, message, additionalDetails) => {
        return new ApplicationError(ApplicationErrorCodes.VALIDATION_FAILED, `Validation failed in ${useCaseName}: ${message}`, { useCaseName, ...additionalDetails });
    },
    /**
     * Create a branch initialization failed error
     */
    branchInitializationFailed: (branchName, cause, additionalDetails) => {
        return new ApplicationError(ApplicationErrorCodes.BRANCH_INITIALIZATION_FAILED, `Failed to initialize branch '${branchName}'`, { branchName, ...additionalDetails }, { cause });
    }
};
//# sourceMappingURL=ApplicationError.js.map