@nodeboot/ghost-server/dist/driver/GhostDriver.js

Node-Boot Ghost Server for Pure IoC Applications. Suitable for Auto-configuration testing, background jobs, etc

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GhostDriver = void 0;
const engine_1 = require("@nodeboot/engine");
const error_1 = require("@nodeboot/error");
class GhostDriver extends engine_1.NodeBootDriver {
    customErrorHandler;
    globalErrorHandler = new engine_1.GlobalErrorHandler();
    constructor() {
        super();
    }
    initialize() {
        // No HTTP server to initialize
    }
    registerAction(_m, _a) {
        // No actions to register in this driver
    }
    registerRoutes() {
        // No routes to register in this driver
        // This is a no-op since this driver does not handle HTTP requests
    }
    registerMiddleware(middleware, _options) {
        if (middleware.instance.onError) {
            this.customErrorHandler = middleware.instance;
        }
    }
    async executeAction(actionMetadata, actionData, executeAction) {
        const response = {
            statusCode: 200,
            headers: {},
            body: undefined,
        };
        const action = {
            request: actionData,
            response,
        };
        // Authorization check if needed
        if (actionMetadata.isAuthorizedUsed) {
            await this.checkAuthorization(action.request, action.response, actionMetadata);
        }
        try {
            const result = await executeAction(action);
            this.handleSuccess(result, action, actionMetadata);
        }
        catch (error) {
            await this.handleError(error, action, actionMetadata);
        }
        return response;
    }
    async checkAuthorization(request, response, actionMetadata) {
        if (!this.authorizationChecker)
            throw new error_1.AuthorizationCheckerNotDefinedError();
        const action = { request, response };
        const checkResult = await this.authorizationChecker.check(action, actionMetadata.authorizedRoles);
        if (!checkResult) {
            const error = actionMetadata.authorizedRoles.length === 0
                ? new error_1.AuthorizationRequiredError("N/A", "N/A")
                : new error_1.AccessDeniedError("N/A", "N/A");
            throw error;
        }
    }
    getParamFromRequest(action, param) {
        const request = action.request;
        switch (param.type) {
            case "session-param":
                return request.session?.[param.name];
            case "session":
                return request.session;
            case "body":
                return request.body;
            case "body-param":
                return request.body?.[param.name];
            case "param":
                return request.params?.[param.name];
            case "params":
                return request.params;
            case "query":
                return request.query?.[param.name];
            case "queries":
                return request.query;
            case "header":
                return request.headers?.[param.name.toLowerCase()];
            case "headers":
                return request.headers;
            case "cookie":
                return request.cookies?.[param.name];
            case "cookies":
                return request.cookies;
            case "file":
                return request.file;
            case "files":
                return request.files;
            default:
                return undefined;
        }
    }
    async handleError(error, action, actionMetadata) {
        if (actionMetadata) {
            Object.entries(actionMetadata.headers).forEach(([name, value]) => {
                action.response.headers = action.response.headers || {};
                action.response.headers[name] = value;
            });
        }
        if (error instanceof error_1.HttpError && error.httpCode) {
            action.response.statusCode = error.httpCode;
        }
        else {
            action.response.statusCode = 500;
        }
        if (!error.handled && this.customErrorHandler) {
            await this.customErrorHandler.onError(error, action, actionMetadata);
        }
        else {
            delete error.handled;
            const parsedError = this.globalErrorHandler.handleError(error);
            action.response.body = parsedError;
        }
    }
    handleSuccess(result, action, actionMetadata) {
        if (result && result === action.response) {
            return;
        }
        // Set status code
        if (result === undefined && actionMetadata.undefinedResultCode) {
            action.response.statusCode = actionMetadata.undefinedResultCode;
            action.response.body = {};
        }
        else if (result === null) {
            action.response.statusCode = actionMetadata.nullResultCode ?? 204;
            action.response.body = null;
        }
        else if (actionMetadata.successHttpCode) {
            action.response.statusCode = actionMetadata.successHttpCode;
            action.response.body = result;
        }
        else {
            action.response.body = result;
        }
        // Headers
        Object.entries(actionMetadata.headers).forEach(([name, value]) => {
            action.response.headers = action.response.headers || {};
            action.response.headers[name] = value;
        });
        // Redirect or template rendering not applicable here, but can be extended if needed
    }
}
exports.GhostDriver = GhostDriver;
//# sourceMappingURL=GhostDriver.js.map