nestjs-aop/esm/auto-aspect-executor.js

<!-- PROJECT LOGO --> <br /> <div align="center"> <a href="https://github.com/toss/nestjs-aop"> <img src="https://toss.tech/wp-content/uploads/2022/11/tech-article-nest-js-02.png" alt="Logo" height="200"> </a>

var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { Injectable } from '@nestjs/common';
import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
import { ASPECT } from './aspect';
/**
 * Aspect 가 선언되어 있고 LazyDecorator 가 구현되어 있는 provider 가 있는 경우 ioc 에 등록된 모든 provider 를 순회하면서 LazyDecorator 를 적용함.
 */
let AutoAspectExecutor = class AutoAspectExecutor {
    constructor(discoveryService, metadataScanner, reflector) {
        this.discoveryService = discoveryService;
        this.metadataScanner = metadataScanner;
        this.reflector = reflector;
    }
    onModuleInit() {
        const controllers = this.discoveryService.getControllers();
        const providers = this.discoveryService.getProviders();
        const lazyDecorators = this.lookupLazyDecorators(providers);
        if (lazyDecorators.length === 0) {
            return;
        }
        const singletonWrapper = providers
            .concat(controllers)
            .filter(({ instance }) => instance && Object.getPrototypeOf(instance));
        for (const wrapper of singletonWrapper) {
            const { instance } = wrapper;
            // Use scanFromPrototype for support nestjs 8
            const methodNames = this.metadataScanner.scanFromPrototype(instance, Object.getPrototypeOf(instance), (name) => name);
            for (const methodName of methodNames) {
                lazyDecorators.forEach((lazyDecorator) => {
                    var _a, _b, _c;
                    const metadataKey = this.reflector.get(ASPECT, lazyDecorator.constructor);
                    const metadataList = this.reflector.get(metadataKey, instance[methodName]);
                    if (!metadataList) {
                        return;
                    }
                    // TODO: Support request scope providers
                    if (!wrapper.isDependencyTreeStatic()) {
                        console.warn(`[${((_b = (_a = wrapper.instance) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) || 'Unknown'}] "@tossteam/nestjs-aop" does not yet support request scope providers`);
                        return;
                    }
                    for (const { originalFn, metadata, aopSymbol } of metadataList) {
                        const wrappedMethod = lazyDecorator.wrap({
                            instance,
                            methodName,
                            method: originalFn.bind(instance),
                            metadata,
                        });
                        Object.setPrototypeOf(wrappedMethod, instance[methodName]);
                        (_c = instance[aopSymbol]) !== null && _c !== void 0 ? _c : (instance[aopSymbol] = {});
                        instance[aopSymbol][methodName] = wrappedMethod;
                    }
                });
            }
        }
    }
    lookupLazyDecorators(providers) {
        const { reflector } = this;
        return providers
            .filter((wrapper) => wrapper.isDependencyTreeStatic())
            .filter(({ instance, metatype }) => {
            if (!instance || !metatype) {
                return false;
            }
            const aspect = reflector.get(ASPECT, metatype);
            if (!aspect) {
                return false;
            }
            return typeof instance.wrap === 'function';
        })
            .map(({ instance }) => instance);
    }
};
AutoAspectExecutor = __decorate([
    Injectable(),
    __metadata("design:paramtypes", [DiscoveryService,
        MetadataScanner,
        Reflector])
], AutoAspectExecutor);
export { AutoAspectExecutor };
//# sourceMappingURL=auto-aspect-executor.js.map