vulcain-corejs/dist/providers/providerFactory.js

Vulcain micro-service framework

"use strict";
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);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments)).next());
    });
};
const annotations_1 = require("../di/annotations");
const annotations_2 = require("../di/annotations");
let ProviderFactory = class ProviderFactory {
    constructor(maxPoolSize = 20) {
        this.maxPoolSize = maxPoolSize;
        this.pool = new Map();
    }
    addToPool(key, state) {
        if (this.pool.size >= this.maxPoolSize) {
            // remove the least used
            let keyToRemove;
            let min = 0;
            for (const [key, value] of this.pool.entries()) {
                if (!keyToRemove || value.count < min) {
                    keyToRemove = key;
                    min = value.count;
                }
            }
            let item = this.pool.get(keyToRemove);
            item.state.dispose && item.state.dispose();
            this.pool.delete(keyToRemove);
        }
        this.pool.set(key, { count: 1, state });
    }
    getFromPool(key) {
        let item = this.pool.get(key);
        if (item) {
            item.count++;
            return item.state;
        }
    }
    getProviderAsync(container, tenant, schema) {
        return __awaiter(this, void 0, void 0, function* () {
            let key = tenant + "!" + schema.name;
            let provider = container.get(annotations_2.DefaultServiceNames.Provider, false, annotations_1.LifeTime.Transient | annotations_1.LifeTime.Scoped);
            let state = this.getFromPool(key);
            if (state) {
                provider.state = state;
            }
            else {
                state = yield provider.initializeWithSchemaAsync(tenant, schema);
                if (state) {
                    this.addToPool(key, state);
                }
            }
            return provider;
        });
    }
};
ProviderFactory = __decorate([
    annotations_1.Injectable(annotations_1.LifeTime.Singleton, annotations_2.DefaultServiceNames.ProviderFactory),
    __metadata("design:paramtypes", [Object])
], ProviderFactory);
exports.ProviderFactory = ProviderFactory;

//# sourceMappingURL=providerFactory.js.map