typenexus/lib/metadata/MetadataArgsStorage.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.

/**
 * Gets metadata args storage.
 * Metadata args storage follows the best practices and stores metadata in a global variable.
 */
export function getMetadataArgsStorage() {
    if (!global.metadataArgsStorage)
        global.metadataArgsStorage = new MetadataArgsStorage();
    return global.metadataArgsStorage;
}
export class MetadataArgsStorage {
    /**
     * Registered controller metadata args.
     */
    controllers = [];
    /**
     * Registered middleware metadata args.
     */
    middlewares = [];
    /**
     * Registered action metadata args.
     */
    actions = [];
    /**
     * Registered param metadata args.
     */
    params = [];
    /**
     * Registered constructor param metadata args.
     */
    paramsConstructor = [];
    /**
     * Registered response handler metadata args.
     */
    responseHandlers = [];
    /**
     * Registered "use middleware" metadata args.
     */
    uses = [];
    /**
     * Filters registered controllers by a given classes.
     */
    filterControllerMetadataForClasses(classes) {
        return this.controllers.filter((ctrl) => {
            return classes.filter((cls) => ctrl.target === cls).length > 0;
        });
    }
    /**
     * Filters registered actions by a given classes.
     */
    filterActionsWithTarget(target) {
        return this.actions.filter((action) => {
            return action.target === target;
        });
    }
    /**
     * Filters response handlers by a given classes.
     */
    filterResponseHandlersWithTargetAndMethod(target, methodName) {
        return this.responseHandlers.filter((property) => {
            return property.target === target && property.method === methodName;
        });
    }
    /**
     * Filters constructor parameters by a given classes.
     */
    filterParamsConstructorWithTargetAndMethod(methodName) {
        return this.paramsConstructor.filter((param) => {
            return param.method === methodName;
        });
    }
    /**
     * Filters parameters by a given classes.
     */
    filterParamsWithTargetAndMethod(target, methodName) {
        return this.params.filter((param) => {
            return param.object.constructor === target && param.method === methodName;
        });
    }
    /**
     * Filters response handlers by a given class.
     */
    filterResponseHandlersWithTarget(target) {
        return this.responseHandlers.filter((property) => {
            return property.target === target;
        });
    }
    /**
     * Filters registered "use middlewares" by a given target class and method name.
     */
    filterUsesWithTargetAndMethod(target, methodName) {
        return this.uses.filter((use) => {
            return use.target === target && use.method === methodName;
        });
    }
    /**
     * Filters registered middlewares by a given classes.
     */
    filterMiddlewareMetadatasForClasses(classes) {
        return classes
            .map((cls) => this.middlewares.find((mid) => mid.target === cls))
            .filter((midd) => midd !== undefined); // this might be not needed if all classes where decorated with `@Middleware`
    }
}