@chix/loader/lib/loader.js

"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
Object.defineProperty(exports, "__esModule", { value: true });
var events = require("events");
var _ = require("lodash");
var forOf = require("object-forof");
var DependencyManager_1 = require("./lib/DependencyManager");
var util_1 = require("./util");
var Loader = (function (_super) {
    __extends(Loader, _super);
    function Loader() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.getNodeSource = Loader.prototype.getNodeDefinitionFrom;
        _this.dependencyManager = new DependencyManager_1.DependencyManager();
        _this.nodeDefinitions = {};
        return _this;
    }
    Loader.prototype.load = function (_flows, _update) {
        return __awaiter(this, void 0, void 0, function () {
            var flows, workload;
            return __generator(this, function (_a) {
                flows = Array.isArray(_flows) ? _flows : [_flows];
                workload = this.getWorkLoad(flows, '@', false);
                if (workload.length) {
                    throw Error('Default loader expects all nodeDefinitions to be preloaded');
                }
                return [2, {
                        dependencies: this.getDependencies(),
                        nodeDefinitions: this.getNodeDefinitions(),
                    }];
            });
        });
    };
    Loader.prototype.loadNodeDefinitionFrom = function (provider, ns, name) {
        return __awaiter(this, void 0, void 0, function () {
            var loadNodeResult, nodeDefinition, flow;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4, this.loadNode({
                            ns: ns,
                            name: name,
                            url: provider.replace('{ns}', ns).replace('{name}', name),
                            providerLocation: provider,
                        })];
                    case 1:
                        loadNodeResult = _a.sent();
                        nodeDefinition = loadNodeResult.nodeDef;
                        if (nodeDefinition.dependencies) {
                            this.dependencyManager.parseDependencies(nodeDefinition);
                        }
                        this.setNodeDefinition(provider, nodeDefinition);
                        if (!(nodeDefinition.type === 'flow')) return [3, 3];
                        flow = nodeDefinition;
                        return [4, this.load([flow])];
                    case 2:
                        _a.sent();
                        return [2, {
                                nodeDefinition: nodeDefinition,
                                dependencies: util_1.loadDependencies(nodeDefinition, this.getNodeDefinitions()),
                            }];
                    case 3: return [2, {
                            nodeDefinition: nodeDefinition,
                            dependencies: util_1.loadDependencies(nodeDefinition, this.getNodeDefinitions()),
                        }];
                }
            });
        });
    };
    Loader.prototype.loadNode = function (providerDef) {
        return __awaiter(this, void 0, void 0, function () {
            var providerLocation, ns, name, nodeDef;
            return __generator(this, function (_a) {
                providerLocation = providerDef.providerLocation, ns = providerDef.ns, name = providerDef.name;
                nodeDef = this.getNodeDefinitionFrom(providerLocation, ns, name);
                if (nodeDef) {
                    return [2, {
                            providerLocation: providerLocation,
                            nodeDef: nodeDef,
                        }];
                }
                throw Error("Could not load node " + ns + ":" + name + " from " + providerLocation);
            });
        });
    };
    Loader.prototype.getWorkLoad = function (flows, defaultProvider, update) {
        var _this = this;
        var willLoad = [];
        var workload = [];
        flows.forEach(function (flow) {
            var e_1, _a;
            _this.initProviderMap(flow, defaultProvider);
            try {
                for (var _b = __values(flow.nodes), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var node = _c.value;
                    var providerLocation = void 0;
                    var remote = void 0;
                    var provider = node.provider ? node.provider : '@';
                    if (!util_1.isProviderHandle(provider)) {
                        providerLocation = provider;
                        remote = true;
                    }
                    else {
                        if (!flow.providers || !flow.providers.hasOwnProperty(provider)) {
                            throw Error([
                                'Node',
                                node.ns + ':' + node.name,
                                'refers to unknown provider',
                                provider,
                                '\n\tplease specify it in the providers section',
                            ].join(' '));
                        }
                        if (flow.providers[provider].hasOwnProperty('path')) {
                            providerLocation = flow.providers[provider].path;
                            remote = false;
                        }
                        else if (flow.providers[provider].hasOwnProperty('url')) {
                            providerLocation = flow.providers[provider].url;
                            remote = true;
                        }
                        else {
                            throw Error("Do not know how to handle: " + provider);
                        }
                    }
                    if (!_this.hasNodeDefinition(providerLocation, node.ns, node.name) &&
                        !update) {
                        var location_1 = providerLocation
                            .replace('{ns}', node.ns)
                            .replace('{name}', node.name);
                        if (willLoad.indexOf(location_1) === -1) {
                            willLoad.push(location_1);
                            if (remote) {
                                workload.push({
                                    url: location_1,
                                    ns: node.ns,
                                    name: node.name,
                                    providerLocation: providerLocation,
                                });
                            }
                            else {
                                workload.push({
                                    path: location_1,
                                    ns: node.ns,
                                    name: node.name,
                                    providerLocation: providerLocation,
                                });
                            }
                        }
                    }
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_1) throw e_1.error; }
            }
        });
        return workload;
    };
    Loader.prototype.saveNodeDefinition = function (_providerLocation, _nodeDefinition) {
        throw new Error([this.constructor.name, 'must implement a save method'].join(' '));
    };
    Loader.prototype.hasDependencies = function (type) {
        return this.dependencyManager.hasDependencies(type);
    };
    Loader.prototype.getDependencies = function (type) {
        return this.dependencyManager.getDependencies(type);
    };
    Loader.prototype.setDependencies = function (dependencies) {
        return this.dependencyManager.setDependencies(dependencies);
    };
    Loader.prototype.initProviderMap = function (flow, defaultProvider) {
        if (!flow.providers) {
            flow.providers = {};
        }
        if (!flow.providers['@']) {
            flow.providers['@'] = { url: defaultProvider };
        }
        for (var key in flow.providers) {
            if (flow.providers.hasOwnProperty(key)) {
                var provider = flow.providers[key];
                if (util_1.isRemoteProvider(provider)) {
                    if (!this.nodeDefinitions.hasOwnProperty(provider.url)) {
                        this.nodeDefinitions[provider.url] = {};
                    }
                }
                else if (util_1.isFSProvider(provider)) {
                    if (!this.nodeDefinitions.hasOwnProperty(provider.path)) {
                        this.nodeDefinitions[provider.path] = {};
                    }
                }
            }
        }
    };
    Loader.prototype.addNodeDefinitions = function (identifier, nodeDefs) {
        var e_2, _a;
        var _this = this;
        if (Array.isArray(nodeDefs)) {
            try {
                for (var nodeDefs_1 = __values(nodeDefs), nodeDefs_1_1 = nodeDefs_1.next(); !nodeDefs_1_1.done; nodeDefs_1_1 = nodeDefs_1.next()) {
                    var nodeDef = nodeDefs_1_1.value;
                    this.addNodeDefinition(identifier, nodeDef);
                }
            }
            catch (e_2_1) { e_2 = { error: e_2_1 }; }
            finally {
                try {
                    if (nodeDefs_1_1 && !nodeDefs_1_1.done && (_a = nodeDefs_1.return)) _a.call(nodeDefs_1);
                }
                finally { if (e_2) throw e_2.error; }
            }
        }
        else {
            forOf(function (_ns, _name, nodeDefinition) {
                _this.addNodeDefinition(identifier, nodeDefinition);
            }, nodeDefs);
        }
    };
    Loader.prototype.addNodeDefinition = function (identifier, nodeDef) {
        if (!nodeDef.hasOwnProperty('ns')) {
            throw new Error(['Node definition for', identifier, 'lacks an ns property'].join(' '));
        }
        if (!nodeDef.hasOwnProperty('name')) {
            throw new Error(['Node definition for', identifier, 'lacks an name property'].join(' '));
        }
        nodeDef.provider = identifier;
        if (nodeDef.type === 'flow') {
            if (!nodeDef.providers || Object.keys(nodeDef.providers).length === 0) {
                nodeDef.providers = {
                    '@': {
                        url: identifier,
                    },
                };
            }
        }
        else {
            this.dependencyManager.parseDependencies(nodeDef);
        }
        this.setNodeDefinition(identifier, nodeDef);
    };
    Loader.prototype.setNodeDefinition = function (provider, nodeDefinition) {
        var ns = nodeDefinition.ns, name = nodeDefinition.name;
        _.setWith(this.nodeDefinitions, [provider, ns, name], nodeDefinition, Object);
    };
    Loader.prototype.setNodeDefinitions = function (nodeDefinitions) {
        if (this.hasNodeDefinitions()) {
            throw Error('Node Definitions already set, only use this method to pre-populate the nodeDefinitions');
        }
        this.nodeDefinitions = nodeDefinitions;
    };
    Loader.prototype.hasNodeDefinition = function (providerUrl, ns, name) {
        return (this.nodeDefinitions.hasOwnProperty(providerUrl) &&
            this.nodeDefinitions[providerUrl].hasOwnProperty(ns) &&
            this.nodeDefinitions[providerUrl][ns].hasOwnProperty(name));
    };
    Loader.prototype.hasNodeDefinitions = function (provider) {
        if (provider) {
            return Boolean(this.nodeDefinitions[provider]);
        }
        return Object.keys(this.nodeDefinitions).length > 0;
    };
    Loader.prototype.getNodeDefinition = function (node, flow) {
        return __awaiter(this, void 0, void 0, function () {
            var definition;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4, this.loadNodeDefinition(node, flow)];
                    case 1:
                        definition = _a.sent();
                        if (!(definition.type === 'flow')) return [3, 3];
                        return [4, this.mergeSchema(definition)];
                    case 2:
                        _a.sent();
                        _a.label = 3;
                    case 3: return [2, definition];
                }
            });
        });
    };
    Loader.prototype.resolveProvider = function (node, flow) {
        var location;
        var provider;
        if (node.provider && util_1.isUri(node.provider)) {
            location = node.provider;
        }
        else if (!node.provider && (!flow || !flow.providers)) {
            location = '@';
        }
        else {
            if (!flow) {
                throw Error('loadNodeDefinition needs a map or a node with a full provider url');
            }
            if (!flow.providers) {
                throw Error('loadNodeDefinition expects flow to container .providers');
            }
            provider = node.provider
                ?
                    flow.providers[node.provider]
                : flow.providers['@'];
            if (!provider) {
                for (var key in flow.providers) {
                    if (_.get(flow, ['providers', key, 'url']) === node.provider ||
                        _.get(flow, ['providers', key, 'path']) === node.provider) {
                        provider = flow.providers[key];
                    }
                }
                if (!provider) {
                    throw Error('unable to find provider');
                }
            }
            if (provider.hasOwnProperty('path')) {
                location = provider.path;
            }
            else if (provider.hasOwnProperty('url')) {
                location = provider.url;
            }
            else {
                throw new Error('Do not know how to handle provider');
            }
        }
        return location;
    };
    Loader.prototype.loadNodeDefinition = function (node, flow) {
        return __awaiter(this, void 0, void 0, function () {
            var location;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        location = this.resolveProvider(node, flow);
                        if (!!this.hasNodeDefinition(location, node.ns, node.name)) return [3, 2];
                        return [4, this.load(flow)];
                    case 1:
                        _a.sent();
                        _a.label = 2;
                    case 2: return [2, this.nodeDefinitions[location][node.ns][node.name]];
                }
            });
        });
    };
    Loader.prototype.getNodeDefinitionFrom = function (provider, ns, name) {
        if (this.hasNodeDefinition(provider, ns, name)) {
            return this.nodeDefinitions[provider][ns][name];
        }
        throw Error("Unable to find node definition for " + ns + ":" + name);
    };
    Loader.prototype.getNodeDefinitions = function (provider) {
        if (provider) {
            return this.nodeDefinitions[provider];
        }
        else {
            return this.nodeDefinitions;
        }
    };
    Loader.prototype.isResolved = function (flow) {
        var e_3, _a;
        var seen = [];
        try {
            for (var _b = __values(flow.nodes), _c = _b.next(); !_c.done; _c = _b.next()) {
                var node = _c.value;
                if (!this.hasNodeDefinition('@', node.ns, node.name)) {
                    return false;
                }
                var nodeDefinition = this.getNodeDefinitionFrom('@', node.ns, node.name);
                var identifier = nodeDefinition.ns + ":" + nodeDefinition.name;
                if (nodeDefinition.type === 'flow' &&
                    seen.indexOf(identifier) === -1) {
                    seen.push(identifier);
                    return this.isResolved(nodeDefinition);
                }
            }
        }
        catch (e_3_1) { e_3 = { error: e_3_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_3) throw e_3.error; }
        }
        return true;
    };
    Loader.prototype.getUnresolved = function (flow) {
        var self = this;
        var unresolved = [];
        var seen = [];
        function resolveDefinitions(flowDefinition) {
            var e_4, _a;
            try {
                for (var _b = __values(flowDefinition.nodes), _c = _b.next(); !_c.done; _c = _b.next()) {
                    var node = _c.value;
                    if (!self.hasNodeDefinition('@', node.ns, node.name)) {
                        unresolved.push(node);
                    }
                    else {
                        var nodeDefinition = self.getNodeDefinitionFrom('@', node.ns, node.name);
                        var identifier = nodeDefinition.ns + ":" + nodeDefinition.name;
                        if (nodeDefinition.type === 'flow' &&
                            seen.indexOf(identifier) === -1) {
                            seen.push(identifier);
                            resolveDefinitions(nodeDefinition);
                        }
                    }
                }
            }
            catch (e_4_1) { e_4 = { error: e_4_1 }; }
            finally {
                try {
                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                }
                finally { if (e_4) throw e_4.error; }
            }
        }
        resolveDefinitions(flow);
        return unresolved;
    };
    Loader.prototype.mergeSchema = function (graph) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                return [2, Promise.all(forOf(function (type, port, externalPort) { return __awaiter(_this, void 0, void 0, function () {
                        var internalDef, copy;
                        return __generator(this, function (_a) {
                            switch (_a.label) {
                                case 0:
                                    if (!externalPort.hasOwnProperty('nodeId')) return [3, 2];
                                    return [4, this.getNodeDefinition(util_1.findNodeWithinGraph(externalPort.nodeId, graph), graph)];
                                case 1:
                                    internalDef = (_a.sent());
                                    if (!_.has(internalDef, ['ports', type, externalPort.name])) {
                                        throw Error("External Port points to non-existent internal port");
                                    }
                                    copy = JSON.parse(JSON.stringify(_.get(internalDef, ['ports', type, externalPort.name])));
                                    copy.title = externalPort.title;
                                    copy.name = externalPort.name;
                                    copy.nodeId = externalPort.nodeId;
                                    _.setWith(graph, ['ports', type, port], copy, Object);
                                    return [2, true];
                                case 2: return [2, false];
                            }
                        });
                    }); }, graph.ports))];
            });
        });
    };
    return Loader;
}(events.EventEmitter));
exports.Loader = Loader;
//# sourceMappingURL=loader.js.map