@mvx/identity/es2017/passports/PassportBuildService.js

identity is oidc for mvc, type-mvc is base on koa. Decorator, Ioc, AOP mvc framework on server.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConfigurePassportBuildService = exports.PassportBuildService = void 0;
const tslib_1 = require("tslib");
const ioc_1 = require("@tsdi/ioc");
const boot_1 = require("@tsdi/boot");
const components_1 = require("@tsdi/components");
const Strategy_1 = require("./Strategy");
const StrategySelectorHandle_1 = require("./StrategySelectorHandle");
const services_1 = require("../services");
/**
 * PassportBuildService
 *
 * @export
 * @abstract
 * @class PassportBuildService
 */
let PassportBuildService = class PassportBuildService {
    async createStrategy(option) {
        return await this.builder.resolveTemplate({ template: option, injector: this.injector });
    }
    static ρAnn() {
        return { "name": "PassportBuildService", "params": { "build": ["passport", "configuration"], "createStrategy": ["option"] } };
    }
};
tslib_1.__decorate([
    ioc_1.Inject(ioc_1.INJECTOR),
    tslib_1.__metadata("design:type", Object)
], PassportBuildService.prototype, "injector", void 0);
tslib_1.__decorate([
    ioc_1.Inject(),
    tslib_1.__metadata("design:type", components_1.ComponentBuilder)
], PassportBuildService.prototype, "builder", void 0);
PassportBuildService = tslib_1.__decorate([
    ioc_1.Abstract()
], PassportBuildService);
exports.PassportBuildService = PassportBuildService;
/**
 * register passport strategy in configuare.
 *
 * @export
 * @class ConfigurePassportBuildService
 * @extends {PassportBuildService}
 */
let ConfigurePassportBuildService = class ConfigurePassportBuildService extends PassportBuildService {
    async build(passport, configuration) {
        let actInj = this.injector.getInstance(ioc_1.ActionInjectorToken);
        let register = actInj.getInstance(boot_1.StartupDecoratorRegisterer).getRegisterer('TranslateTemplate');
        if (!register.has(StrategySelectorHandle_1.StrategySelectorHandle)) {
            register.registerBefore(components_1.Component, components_1.ComponentSelectorHandle, StrategySelectorHandle_1.StrategySelectorHandle);
        }
        if (configuration.passports) {
            let { strategies, serializers, deserializers, authInfos } = configuration.passports;
            if (strategies.length) {
                await Promise.all(strategies.map(async (p) => {
                    let strategy = await this.createStrategy(p);
                    if (strategy instanceof Strategy_1.Strategy) {
                        passport.use(strategy);
                    }
                }));
            }
            if (serializers && serializers.length) {
                serializers.forEach(ser => {
                    if (ioc_1.isClass(ser)) {
                        if (!this.injector.has(ser)) {
                            this.injector.register(ser);
                        }
                        passport.serializeUser((user, ctx) => this.injector.resolve(ser).serializeUser(user, ctx));
                    }
                    else if (ioc_1.isFunction(ser)) {
                        passport.serializeUser(ser);
                    }
                });
            }
            else {
                this.injector.getServices(services_1.SerializeUser)
                    .forEach(ser => {
                    passport.serializeUser((user, ctx) => ser.serializeUser(user, ctx));
                });
            }
            if (deserializers && deserializers.length) {
                deserializers.forEach(desr => {
                    if (ioc_1.isClass(desr)) {
                        if (!this.injector.has(desr)) {
                            this.injector.register(desr);
                        }
                        passport.deserializeUser((obj, ctx) => this.injector.resolve(desr).deserializeUser(obj, ctx));
                    }
                    else if (ioc_1.isFunction(desr)) {
                        passport.deserializeUser(desr);
                    }
                });
            }
            else {
                this.injector.getServices(services_1.DeserializeUser)
                    .forEach(desr => {
                    passport.deserializeUser((obj, ctx) => desr.deserializeUser(obj, ctx));
                });
            }
            if (authInfos && authInfos.length) {
                authInfos.forEach(trans => {
                    if (ioc_1.isClass(trans)) {
                        if (!this.injector.has(trans)) {
                            this.injector.register(trans);
                        }
                        passport.transformAuthInfo((info, ctx) => this.injector.resolve(trans).authInfo(info, ctx));
                    }
                    else if (ioc_1.isFunction(trans)) {
                        passport.transformAuthInfo(trans);
                    }
                });
            }
            else {
                this.injector.getServices(services_1.TransformAuthInfo)
                    .forEach(ser => {
                    passport.transformAuthInfo((info, ctx) => ser.authInfo(info, ctx));
                });
            }
        }
    }
    static ρAnn() {
        return { "name": "ConfigurePassportBuildService", "params": { "build": ["passport", "configuration"] } };
    }
};
ConfigurePassportBuildService = tslib_1.__decorate([
    ioc_1.Injectable()
], ConfigurePassportBuildService);
exports.ConfigurePassportBuildService = ConfigurePassportBuildService;

//# sourceMappingURL=../sourcemaps/passports/PassportBuildService.js.map