@methodus/server/src/config.js

dynamic rpc components

"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);
};
Object.defineProperty(exports, "__esModule", { value: true });
const yaml = require('js-yaml'), fs = require('fs');
const log_1 = require("./log");
const metadataKey = 'methodus';
let MethodusClassConfig = class MethodusClassConfig {
    /**
     *
     */
    constructor(classType, methodType, serverType, resolver) {
        this.methodType = "Local" /* Local */;
        this.classType = classType;
        this.methodType = methodType;
        this.serverType = serverType;
        this.resolver = () => {
            return resolver;
        };
    }
};
MethodusClassConfig = __decorate([
    log_1.LogClass(log_1.logger),
    __metadata("design:paramtypes", [Object, String, String, Object])
], MethodusClassConfig);
exports.MethodusClassConfig = MethodusClassConfig;
let MethodusConfig = class MethodusConfig {
    constructor(servers, map) {
        this.classes = new Map();
        if (servers)
            this.servers = servers;
        if (map)
            this.classes = map;
    }
    use(classType, methodType, serverType, resolver) {
        if (methodType === "Http" /* Http */ && !resolver)
            throw (new Error('Http transport requires a resolver, pass in a string or a promise'));
        let configEntry = new MethodusClassConfig(classType, methodType, serverType, resolver);
        this.classes.set(classType.name, configEntry);
        if (classType.methodus) {
            this.classes.set(classType.methodus.name, configEntry);
        }
    }
    run(serverType, configuration) {
        this.servers = this.servers || [];
        this.servers.push(new ServerConfig(serverType, configuration));
    }
};
MethodusConfig = __decorate([
    log_1.LogClass(console),
    __metadata("design:paramtypes", [Array, Map])
], MethodusConfig);
exports.MethodusConfig = MethodusConfig;
let ServerConfig = class ServerConfig {
    constructor(type, options) {
        this.type = type;
        this.options = options;
        if (options) {
            this.onStart = options.onStart;
        }
    }
};
ServerConfig = __decorate([
    log_1.LogClass(log_1.logger),
    __metadata("design:paramtypes", [String, Object])
], ServerConfig);
exports.ServerConfig = ServerConfig;
class MethodusConfigurations {
    static add(configurationInstance) {
        this._configurations = configurationInstance;
    }
    static get() {
        return this._configurations;
    }
}
exports.MethodusConfigurations = MethodusConfigurations;
class ConnectionOptions {
}
exports.ConnectionOptions = ConnectionOptions;
function MethodusConfigFromFile(configPath) {
    var doc = yaml.safeLoad(fs.readFileSync(configPath, 'utf8'));
    return doc;
}
exports.MethodusConfigFromFile = MethodusConfigFromFile;
//# sourceMappingURL=config.js.map