@malagu/core/lib/common/container/auto-bind.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.autoBind = exports.manualBind = void 0;
const inversify_1 = require("inversify");
const constants_1 = require("../constants");
const config_util_1 = require("../config/config-util");
const aop_protocol_1 = require("../aop/aop-protocol");
const container_util_1 = require("./container-util");
const scope_1 = require("./scope");
function manualBind(registry) {
    return new inversify_1.ContainerModule((bind, unbind, isBound, rebind, ...rest) => {
        if (registry) {
            registry(bind, unbind, isBound, rebind, ...rest);
        }
    });
}
exports.manualBind = manualBind;
function autoBind(registry) {
    const metadatas = Reflect.getMetadata(constants_1.METADATA_KEY.component, Reflect) || [];
    const constantMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.constantValue, Reflect) || [];
    Reflect.defineMetadata(constants_1.METADATA_KEY.component, [], Reflect);
    Reflect.defineMetadata(constants_1.METADATA_KEY.constantValue, [], Reflect);
    return new inversify_1.ContainerModule((bind, unbind, isBound, rebind, ...rest) => {
        for (let index = metadatas.length - 1; index >= 0; index--) {
            const metadata = metadatas[index];
            resolve(metadata, bind, rebind);
        }
        constantMetadata.map(metadata => resolveConstant(metadata, bind, rebind));
        if (registry) {
            registry(bind, unbind, isBound, rebind, ...rest);
        }
    });
}
exports.autoBind = autoBind;
function doProxyIfNeed(metadata, target) {
    var _a, _b;
    const enabled = (_b = (_a = config_util_1.ConfigUtil.getRaw().malagu) === null || _a === void 0 ? void 0 : _a.aop) === null || _b === void 0 ? void 0 : _b.enabled;
    if (enabled && metadata.proxy) {
        const classFilter = container_util_1.ContainerUtil.get(aop_protocol_1.ClassFilter);
        if (target.constructor && classFilter.matches(target.constructor, metadata)) {
            const aopProxyFactory = container_util_1.ContainerUtil.get(aop_protocol_1.AopProxyFactory);
            return aopProxyFactory.create({
                target,
                metadata
            }).getProxy();
        }
    }
    return target;
}
function resolve(metadata, bind, rebind) {
    let mid;
    const { ids, scope, name, tag, when, proxy, onActivation, target } = metadata;
    const _ids = [...ids];
    const id = _ids.shift();
    if (metadata.rebind) {
        const id2 = _ids.shift();
        mid = rebind(id2 || id).to(target);
    }
    else {
        mid = bind(id).to(target);
    }
    if (scope === scope_1.Scope.Singleton) {
        mid = mid.inSingletonScope();
    }
    else if (scope === scope_1.Scope.Transient) {
        mid = mid.inTransientScope();
    }
    if (name) {
        mid = mid.whenTargetNamed(name);
    }
    else if (tag) {
        mid = mid.whenTargetTagged(tag.tag, tag.value);
    }
    else if (metadata.default) {
        mid = mid.whenTargetIsDefault();
    }
    else if (when) {
        mid = mid.when(when);
    }
    if (onActivation) {
        mid.onActivation(onActivation);
    }
    else if (proxy) {
        mid.onActivation((context, t) => doProxyIfNeed(metadata, t));
    }
    for (const item of _ids) {
        bind(item).toService(id);
    }
}
function resolveConstant(metadata, bind, rebind) {
    const ids = Array.isArray(metadata.id) ? [...metadata.id] : [metadata.id];
    const id = ids.shift();
    if (metadata.rebind) {
        rebind(id).toConstantValue(metadata.constantValue);
    }
    else {
        bind(id).toConstantValue(metadata.constantValue);
    }
    for (const item of ids) {
        bind(item).toService(id);
    }
}
//# sourceMappingURL=auto-bind.js.map