typenexus/lib/builder/MetadataBuilder.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 { ControllerMetadata } from '../metadata/ControllerMetadata.js';
import { MiddlewareMetadata } from '../metadata/MiddlewareMetadata.js';
import { getMetadataArgsStorage } from '../metadata/MetadataArgsStorage.js';
import { ActionMetadata } from '../metadata/ActionMetadata.js';
import { ResponseHandlerMetadata } from '../metadata/ResponseHandleMetadata.js';
import { ParamMetadata } from '../metadata/ParamMetadata.js';
import { ParamConstructorMetadata } from '../metadata/ParamConstructorMetadata.js';
import { UseMetadata } from '../metadata/UseMetadata.js';
/**
 * Builds metadata from the given metadata arguments.
 */
export class MetadataBuilder {
    options;
    constructor(options) {
        this.options = options;
    }
    /**
     * Builds controller metadata from a registered controller metadata args.
     */
    buildControllerMetadata(classes) {
        return this.createControllers(classes);
    }
    /**
     * Builds middleware metadata from a registered middleware metadata args.
     */
    buildMiddlewareMetadata(classes) {
        return this.createMiddlewares(classes);
    }
    /**
     * Creates middleware metadatas.
     */
    createMiddlewares(classes) {
        const middlewares = !classes
            ? getMetadataArgsStorage().middlewares
            : getMetadataArgsStorage().filterMiddlewareMetadatasForClasses(classes);
        return middlewares.map((middlewareArgs) => new MiddlewareMetadata(middlewareArgs));
    }
    /**
     * Creates controller metadatas.
     */
    createControllers(classes) {
        const controllers = !classes
            ? getMetadataArgsStorage().controllers
            : getMetadataArgsStorage().filterControllerMetadataForClasses(classes);
        return controllers.map((controllerArgs) => {
            const controller = new ControllerMetadata(controllerArgs);
            controller.build(this.createControllerResponseHandlers(controller));
            controller.actions = this.createActions(controller);
            controller.uses = this.createControllerUses(controller);
            return controller;
        });
    }
    /**
     * Creates action metadata.
     */
    createActions(controller) {
        const actionsWithTarget = [];
        for (let target = controller.target; target; target = Object.getPrototypeOf(target)) {
            const actions = getMetadataArgsStorage().filterActionsWithTarget(target);
            const methods = actionsWithTarget.map((a) => a.method);
            actions
                .filter(({ method }) => !methods.includes(method))
                .forEach((actionArgs) => {
                const action = new ActionMetadata(controller, { ...actionArgs, target: controller.target }, this.options);
                action.params = this.createParams(action);
                action.paramsConstructor = this.createParamsConstructor(action);
                action.uses = this.createActionUses(action);
                action.build(this.createActionResponseHandlers(action));
                actionsWithTarget.push(action);
            });
        }
        return actionsWithTarget;
    }
    /**
     * Creates constructor param metadatas.
     */
    createParamsConstructor(action) {
        return getMetadataArgsStorage()
            .filterParamsConstructorWithTargetAndMethod('constructor')
            .map((paramArgs) => new ParamConstructorMetadata(action, paramArgs));
    }
    /**
     * Creates param metadatas.
     */
    createParams(action) {
        const dta = getMetadataArgsStorage()
            .filterParamsWithTargetAndMethod(action.target, action.method)
            .map((paramArgs) => {
            return new ParamMetadata(action, paramArgs);
        });
        return dta;
    }
    /**
     * Creates response handler metadatas for action.
     */
    createActionResponseHandlers(action) {
        return getMetadataArgsStorage()
            .filterResponseHandlersWithTargetAndMethod(action.target, action.method)
            .map((handlerArgs) => {
            return new ResponseHandlerMetadata(handlerArgs);
        });
    }
    /**
     * Creates use metadatas for actions.
     */
    createActionUses(action) {
        return getMetadataArgsStorage()
            .filterUsesWithTargetAndMethod(action.target, action.method)
            .map((useArgs) => new UseMetadata(useArgs));
    }
    /**
     * Creates response handler metadatas for controller.
     */
    createControllerResponseHandlers(controller) {
        return getMetadataArgsStorage()
            .filterResponseHandlersWithTarget(controller.target)
            .map((handlerArgs) => new ResponseHandlerMetadata(handlerArgs));
    }
    /**
     * Creates use metadatas for controllers.
     */
    createControllerUses(controller) {
        return getMetadataArgsStorage()
            .filterUsesWithTargetAndMethod(controller.target, undefined)
            .map((useArgs) => new UseMetadata(useArgs));
    }
}