vulcain-corejs/dist/pipeline/annotations.js

Vulcain micro-service framework

"use strict";
require('reflect-metadata');
const preloader_1 = require('../preloader');
const actions_1 = require('./actions');
const serviceDescriptions_1 = require('./serviceDescriptions');
const annotations_1 = require('./../di/annotations');
const system_1 = require('../configurations/globals/system');
const symMetadata = Symbol.for("handler:metadata");
const symActions = Symbol.for("handler:actions");
function resolveType(type) {
    if (typeof type === "function" && serviceDescriptions_1.ServiceDescriptors.nativeTypes.indexOf(type.name) >= 0)
        return type.name;
    return type;
}
function getMetadata(key, target) {
    let metadata = {};
    while (target) {
        let tmp = Reflect.getOwnMetadata(key, target);
        if (tmp) {
            // merge by action
            Object.keys(tmp).forEach(p => {
                let pv = tmp[p];
                // Do not override action
                if (Object.keys(metadata).findIndex(pm => metadata[pm].action === pv.action) < 0) {
                    metadata[p] = Object.assign({}, pv); // clone
                }
            });
        }
        target = Object.getPrototypeOf(target);
    }
    return metadata;
}
/**
 * Define an action handler class
 *
 * @export
 * @param {ActionHandlerMetadata} metadata
 * @returns
 */
function ActionHandler(metadata) {
    return function (target) {
        if (metadata.enableOnTestOnly && !system_1.System.isTestEnvironnment)
            return;
        metadata.scope = metadata.scope || "?";
        let actions = getMetadata(symActions, target);
        preloader_1.Preloader.instance.registerHandler(target, (container, domain) => {
            let descriptors = container.get(annotations_1.DefaultServiceNames.ServiceDescriptors);
            descriptors.register(container, domain, target, actions, metadata, "action");
            Reflect.defineMetadata(symMetadata, metadata, target);
        });
    };
}
exports.ActionHandler = ActionHandler;
/**
 * Define an action handler
 *
 * @export
 * @param {ActionMetadata} [actionMetadata]
 * @returns
 */
function Action(actionMetadata) {
    return (target, key) => {
        let actions = Reflect.getOwnMetadata(symActions, target.constructor) || {};
        actions[key] = actionMetadata || {};
        if (actions[key].inputSchema === undefined) {
            let params = Reflect.getMetadata("design:paramtypes", target, key);
            if (params && params.length > 0) {
                actions[key].inputSchema = params[0].name !== "Object" ? resolveType(params[0]) : null; // Force null to take the schema as default value
            }
            else {
                actions[key].inputSchema = "none"; // set to to none to ignore this schema
            }
        }
        let output = Reflect.getMetadata("design:returntype", target, key);
        if (actions[key].outputSchema === undefined) {
            actions[key].outputSchema = "none";
            if (output && ["Promise", "Object"].indexOf(output.name) < 0) {
                actions[key].outputSchema = resolveType(output.name);
            }
        }
        if (!actions[key].action) {
            let tmp = key.toLowerCase();
            if (tmp.endsWith("async"))
                tmp = tmp.substr(0, tmp.length - 5);
            actions[key].action = tmp;
        }
        Reflect.defineMetadata(symActions, actions, target.constructor);
    };
}
exports.Action = Action;
/**
 * Define a query handler class
 *
 * @export
 * @param {QueryMetadata} metadata
 * @returns
 */
function QueryHandler(metadata) {
    return function (target) {
        if (metadata.enableOnTestOnly && !system_1.System.isTestEnvironnment)
            return;
        metadata.scope = metadata.scope || "?";
        let actions = getMetadata(symActions, target);
        preloader_1.Preloader.instance.registerHandler(target, (container, domain) => {
            let descriptors = container.get(annotations_1.DefaultServiceNames.ServiceDescriptors);
            descriptors.register(container, domain, target, actions, metadata, "query");
            Reflect.defineMetadata(symMetadata, metadata, target);
        });
    };
}
exports.QueryHandler = QueryHandler;
/**
 * Define a query handler
 *
 * @export
 * @param {QueryActionMetadata} [actionMetadata]
 * @returns
 */
function Query(actionMetadata) {
    return (target, key) => {
        let actions = Reflect.getOwnMetadata(symActions, target.constructor) || {};
        actions[key] = actionMetadata || {};
        if (!actions[key].inputSchema) {
            let params = Reflect.getMetadata("design:paramtypes", target, key);
            if (params && params.length > 0 && params[0].name !== "Object") {
                actions[key].inputSchema = resolveType(params[0]);
            }
        }
        let output = Reflect.getMetadata("design:returntype", target, key);
        if (output && ["Promise", "Object", "void 0", "null"].indexOf(output.name) < 0) {
            actions[key].outputSchema = resolveType(output.name);
        }
        if (!actions[key].action) {
            let tmp = key.toLowerCase();
            if (tmp.endsWith("async"))
                tmp = tmp.substr(0, tmp.length - 5);
            actions[key].action = tmp;
        }
        Reflect.defineMetadata(symActions, actions, target.constructor);
    };
}
exports.Query = Query;
/**
 * Define an event handler class
 *
 * @export
 * @param {EventMetadata} [metadata]
 * @returns
 */
function EventHandler(metadata) {
    return function (target) {
        let actions = getMetadata(symActions, target);
        preloader_1.Preloader.instance.registerHandler(target, (container, domain) => {
            actions_1.CommandManager.eventHandlersFactory.register(container, domain, target, actions, metadata);
            Reflect.defineMetadata(symMetadata, metadata, target);
        });
    };
}
exports.EventHandler = EventHandler;
/**
 * Define an event handler
 *
 * @export
 * @param {ConsumeEventMetadata} [consumeMetadata]
 * @returns
 */
function Consume(consumeMetadata) {
    return (target, key) => {
        let actions = Reflect.getOwnMetadata(symActions, target.constructor) || {};
        actions[key] = consumeMetadata || {};
        Reflect.defineMetadata(symActions, actions, target.constructor);
    };
}
exports.Consume = Consume;

//# sourceMappingURL=annotations.js.map