vulcain-corejs/dist/configurations/dependencies/annotations.js

Vulcain micro-service framework

"use strict";
const system_1 = require("./../globals/system");
const fs = require("fs");
const Path = require("path");
/**
 * Contains all service dependencies
 *
 * @export
 * @class VulcainManifest
 */
class VulcainManifest {
    constructor(serviceName, serviceVersion) {
        this.serviceName = serviceName;
        this.dependencies = {
            services: [],
            externals: [],
            databases: [],
            packages: Array.from(this.retrievePackage())
        };
        this.configurations = {};
    }
    *retrievePackage() {
        try {
            let basePath = Path.dirname(require.main.filename);
            let json = fs.readFileSync(Path.join(basePath, "..", "package.json"), "utf8");
            let pkg = JSON.parse(json);
            let dependencies = pkg.dependencies;
            for (let packageName of Object.keys(dependencies)) {
                json = fs.readFileSync(Path.join(basePath, "..", 'node_modules', packageName, "package.json"), "utf8");
                pkg = JSON.parse(json);
                yield { name: packageName, version: pkg.version };
            }
        }
        catch (e) {
            console.log("Can not read packages version. Skip it", e.message);
        }
    }
}
exports.VulcainManifest = VulcainManifest;
/**
 * Declare a vulcain service dependencie for the current service
 *
 * @export
 * @param {string} service Name of the called service
 * @param {string} version Version of the called service
 * @param {string} discoveryAddress Discovery address of the called service (ex:http://..:30000/api/_servicedesctipyion)
 * @returns
 */
function ServiceDependency(service, version, discoveryAddress) {
    return (target) => {
        target["$dependency:service"] = { targetServiceName: service, targetServiceVersion: version };
        let exists = system_1.System.manifest.dependencies.services.find(svc => svc.service === service && svc.version === version);
        if (!exists) {
            system_1.System.manifest.dependencies.services.push({ service, version, discoveryAddress });
        }
    };
}
exports.ServiceDependency = ServiceDependency;
/**
 * Declare an external http call dependencie for the current service
 *
 * @export
 * @param {string} uri External uri
 * @returns
 */
function HttpDependency(uri) {
    return (target) => {
        target["$dependency:external"] = { uri };
        let exists = system_1.System.manifest.dependencies.externals.find(ex => ex.uri === uri);
        if (!exists) {
            system_1.System.manifest.dependencies.externals.push({ uri });
        }
    };
}
exports.HttpDependency = HttpDependency;
/**
 * Declare a dynamic property configuration for the current service.
 *
 * @export
 * @param {string} propertyName Property name
 * @param {string} schema Property schema (can be a model or a native js type)
 * @returns
 */
function ConfigurationProperty(propertyName, schema) {
    return (target) => {
        if (!propertyName)
            throw new Error("Invalid property propertyName");
        if (!schema)
            throw new Error("Invalid property schema");
        schema = schema.toLowerCase();
        let existingSchema = system_1.System.manifest.configurations[propertyName];
        if (existingSchema && existingSchema !== "any") {
            if (existingSchema !== schema)
                throw new Error(`Inconsistant schema (${schema} <> ${existingSchema}) for configuration property ${propertyName}`);
            return;
        }
        system_1.System.manifest.configurations[propertyName] = schema;
    };
}
exports.ConfigurationProperty = ConfigurationProperty;

//# sourceMappingURL=annotations.js.map