@toss/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;
        this.wrappedMethodCache = new WeakMap();
    }
    onModuleInit() {
        this.bootstrapLazyDecorators();
    }
    bootstrapLazyDecorators() {
        const controllers = this.discoveryService.getControllers();
        const providers = this.discoveryService.getProviders();
        const lazyDecorators = this.lookupLazyDecorators(providers);
        if (lazyDecorators.length === 0) {
            return;
        }
        const instanceWrappers = providers
            .concat(controllers)
            .filter(({ instance }) => instance && Object.getPrototypeOf(instance));
        for (const lazyDecorator of lazyDecorators) {
            for (const wrapper of instanceWrappers) {
                this.applyLazyDecorator(lazyDecorator, wrapper);
            }
        }
    }
    applyLazyDecorator(lazyDecorator, instanceWrapper) {
        const target = instanceWrapper.isDependencyTreeStatic()
            ? instanceWrapper.instance
            : instanceWrapper.metatype.prototype;
        // Use scanFromPrototype for support nestjs 8
        const propertyKeys = this.metadataScanner.scanFromPrototype(target, instanceWrapper.isDependencyTreeStatic() ? Object.getPrototypeOf(target) : target, (name) => name);
        const metadataKey = this.reflector.get(ASPECT, lazyDecorator.constructor);
        // instance에 method names 를 순회하면서 lazyDecorator.wrap을 적용함
        for (const propertyKey of propertyKeys) {
            // the target method is must be object or function
            // @see: https://github.com/rbuckton/reflect-metadata/blob/9562d6395cc3901eaafaf8a6ed8bc327111853d5/Reflect.ts#L938
            const targetProperty = target[propertyKey];
            if (!targetProperty || (typeof targetProperty !== "object" && typeof targetProperty !== "function")) {
                continue;
            }
            const metadataList = this.reflector.get(metadataKey, targetProperty);
            if (!metadataList) {
                continue;
            }
            for (const aopMetadata of metadataList) {
                this.wrapMethod({ lazyDecorator, aopMetadata, methodName: propertyKey, target });
            }
        }
    }
    wrapMethod({ lazyDecorator, aopMetadata, methodName, target, }) {
        var _a;
        const { originalFn, metadata, aopSymbol } = aopMetadata;
        // eslint-disable-next-line @typescript-eslint/no-this-alias
        const self = this;
        const wrappedFn = function (...args) {
            const cache = self.wrappedMethodCache.get(this) || new WeakMap();
            const cached = cache.get(originalFn);
            if (cached) {
                return cached.apply(this, args);
            }
            const wrappedMethod = lazyDecorator.wrap({
                instance: this,
                methodName,
                method: originalFn.bind(this),
                metadata,
            });
            cache.set(originalFn, wrappedMethod);
            self.wrappedMethodCache.set(this, cache);
            return wrappedMethod.apply(this, args);
        };
        (_a = target[aopSymbol]) !== null && _a !== void 0 ? _a : (target[aopSymbol] = {});
        target[aopSymbol][methodName] = wrappedFn;
    }
    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) ||
                reflector.get(ASPECT, Object.getPrototypeOf(instance).constructor);
            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