typenexus/lib/Controllers.js

TypeNexus is a good tool for API encapsulation and management. It provides a clean and lightweight way to package TypeORM functionality, helping you build applications faster while reducing template code redundancy and type conversion work.

import { MetadataBuilder } from './builder/MetadataBuilder.js';
import { isPromiseLike } from './utils/isPromiseLike.js';
import { ActionParameterHandler } from './ActionParameterHandler.js';
export class Controllers {
    driver;
    options;
    /**
     * Used to build metadata objects for controllers and middlewares.
     */
    metadataBuilder;
    /**
     * Used to check and handle controller action parameters.
     */
    parameterHandler;
    constructor(driver, options) {
        this.driver = driver;
        this.options = options;
        this.parameterHandler = new ActionParameterHandler(driver);
        this.metadataBuilder = new MetadataBuilder(this.options);
    }
    registerControllers(classes) {
        const controllers = this.metadataBuilder.buildControllerMetadata(classes);
        controllers.map((controller) => {
            controller.actions.forEach((actionMetadata) => {
                this.driver.registerAction(actionMetadata, (action) => {
                    this.executeAction(actionMetadata, action);
                });
            });
        });
        return this;
    }
    /**
     * Registers middleware that run before controller actions.
     */
    registerMiddlewares(type, classes, option) {
        this.metadataBuilder
            .buildMiddlewareMetadata(classes)
            .filter((middleware) => middleware.global && middleware.type === type)
            .sort((middleware1, middleware2) => middleware2.priority - middleware1.priority)
            .forEach((middleware) => this.driver.registerMiddleware(middleware, option));
        return this;
    }
    /**
     * Executes given controller action.
     */
    executeAction(actionMetadata, action) {
        // compute all parameters
        const paramsPromises = actionMetadata.params
            .sort((param1, param2) => param1.index - param2.index)
            .map((param) => {
            return this.parameterHandler.handle(action, param);
        });
        // compute all constructor parameters
        const paramsConstructor = actionMetadata.paramsConstructor
            .sort((param1, param2) => param1.index - param2.index)
            .map((param) => this.parameterHandler.handleConstructor(action, param))
            .filter(Boolean);
        return Promise.all(paramsPromises)
            .then((params) => {
            const result = actionMetadata.callMethod(params, paramsConstructor, action);
            return this.handleCallMethodResult(result, actionMetadata, action);
        })
            .catch((error) => {
            return this.driver.handleError(error, actionMetadata, action);
        });
    }
    /**
     * Handles result of the action method execution.
     */
    handleCallMethodResult(result, action, options) {
        if (isPromiseLike(result)) {
            return result
                .then((data) => {
                return this.handleCallMethodResult(data, action, options);
            })
                .catch((error) => {
                return this.driver.handleError(error, action, options);
            });
        }
        else {
            return this.driver.handleSuccess(result, action, options);
        }
    }
}