@chix/loader/lib/loader.js

"use strict";
var __extends = (this && this.__extends) || (function () {
    var 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 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) {
    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());
    });
};
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 = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [0, 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 m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
    if (m) return m.call(o);
    return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
};
Object.defineProperty(exports, "__esModule", { value: true });
var events = require("events");
var lib_1 = require("./lib");
var util_1 = require("./util");
/**
 * Loader
 *
 * This is the base loader class
 * Ít can be used to implement a definition loader
 * for Chix
 *
 * @api public
 * @author Rob Halff <rob.halff@gmail.com>
 * @constructor
 */
var Loader = /** @class */ (function (_super) {
    __extends(Loader, _super);
    function Loader() {
        var _this = _super.call(this) || this;
        // npm loader returns a different source
        _this.getNodeSource = Loader.prototype.getNodeDefinitionFrom;
        _this.dependencyManager = new lib_1.DependencyManager();
        _this.nodeDefinitionManager = new lib_1.NodeDefinitionManager(_this.dependencyManager);
        return _this;
    }
    /**
     * This is the main method all child classes should implement.
     *
     * @param {FlowDefinition[]} _flows
     * @param {boolean} _update
     * @returns {Promise<LoaderResponse>}
     */
    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 /*return*/, {
                        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 /*yield*/, this.loadNode({
                            ns: ns,
                            name: name,
                            url: provider.replace('{ns}', ns).replace('{name}', name),
                            providerLocation: provider
                        })];
                    case 1:
                        loadNodeResult = _a.sent();
                        nodeDefinition = loadNodeResult.nodeDef;
                        // res.providerLocation
                        // provide a way to getDependencies for only this nodeDefinition.
                        // parseDependencies will just update *all* dependencies
                        // so in case if the nodeDefinition is a flow, it's just a method to traverse
                        // all dependencies and return that.
                        if (nodeDefinition.dependencies) {
                            this.dependencyManager.parseDependencies(nodeDefinition);
                        }
                        this.nodeDefinitionManager.setNodeDefinition(provider, nodeDefinition);
                        if (!(nodeDefinition.type === 'flow')) return [3 /*break*/, 3];
                        flow = nodeDefinition;
                        // Note: returns the full state, which in this case can be ignored.
                        return [4 /*yield*/, this.load([flow])];
                    case 2:
                        // Note: returns the full state, which in this case can be ignored.
                        _a.sent();
                        return [2 /*return*/, {
                                nodeDefinition: nodeDefinition,
                                dependencies: util_1.loadDependencies(nodeDefinition, this.nodeDefinitionManager.getNodeDefinitions())
                            }];
                    case 3: return [2 /*return*/, {
                            nodeDefinition: nodeDefinition,
                            dependencies: util_1.loadDependencies(nodeDefinition, this.nodeDefinitionManager.getNodeDefinitions())
                        }];
                }
            });
        });
    };
    /**
     * Loader itself only expects preloaded nodes.
     * There is no actual load going on.
     *
     * Remote loader *does* implement loading.
     *
     * @param {ProviderDef} providerDef
     * @returns {Promise<{nodeDef: NodeDefinition | {}}>}
     */
    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.nodeDefinitionManager.getNodeDefinitionFrom(
                // provider,
                providerLocation, ns, name);
                if (nodeDef) {
                    return [2 /*return*/, {
                            providerLocation: providerLocation,
                            nodeDef: nodeDef
                        }];
                }
                throw Error("Could not load node " + ns + ":" + name + " from " + providerLocation);
            });
        });
    };
    /**
     * loop the nodes, detect what provider they expect
     * if they do not have a provider we will use the default,
     * if the flow has set it's own default we will use that.
     * the default within a flow is the one without namespace
     */
    Loader.prototype.getWorkLoad = function (flows, defaultProvider, update) {
        var _this = this;
        var willLoad = [];
        var workload = [];
        flows.forEach(function (flow) {
            var e_1, _a;
            // Todo for subflows this runs every time.
            _this.nodeDefinitionManager.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 
                    // select the name e.g. x
                    = void 0;
                    // select the name e.g. x
                    var provider = node.provider ? node.provider : '@';
                    if (!util_1.isProviderHandle(provider)) {
                        // it's already an url or path
                        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(' '));
                        }
                        // Within the flow detect what url x is about
                        if (flow.providers[provider].hasOwnProperty('path')) {
                            // hacked in, remote also takes care of local for now.
                            // just refactor this later on.
                            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.nodeDefinitionManager.hasNodeDefinition(providerLocation, node.ns, node.name) && !update) {
                        var location_1 = providerLocation
                            .replace('{ns}', node.ns)
                            .replace('{name}', node.name);
                        // Check if it carries the info for our node also.
                        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;
    };
    // proxy nodeDefinitionManager methods
    Loader.prototype.addNodeDefinitions = function (identifier, nodeDefs) {
        return this.nodeDefinitionManager.addNodeDefinitions(identifier, nodeDefs);
    };
    Loader.prototype.addNodeDefinition = function (identifier, nodeDef) {
        return this.nodeDefinitionManager.addNodeDefinition(identifier, nodeDef);
    };
    Loader.prototype.hasNodeDefinition = function (providerUrl, ns, name) {
        return this.nodeDefinitionManager.hasNodeDefinition(providerUrl, ns, name);
    };
    Loader.prototype.getNodeDefinition = function (node, flow) {
        return this.nodeDefinitionManager.getNodeDefinition(node, flow);
    };
    Loader.prototype.getNodeDefinitionFrom = function (provider, ns, name) {
        return this.nodeDefinitionManager.getNodeDefinitionFrom(provider, ns, name);
    };
    Loader.prototype.saveNodeDefinition = function (_providerLocation, _nodeDefinition) {
        throw new Error([
            this.constructor.name,
            'must implement a save method'
        ].join(' '));
    };
    Loader.prototype.getNodeDefinitions = function (provider) {
        return this.nodeDefinitionManager.getNodeDefinitions(provider);
    };
    Loader.prototype.setNodeDefinitions = function (nodeDefinitions) {
        return this.nodeDefinitionManager.setNodeDefinitions(nodeDefinitions);
    };
    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);
    };
    return Loader;
}(events.EventEmitter));
exports.Loader = Loader;
//# sourceMappingURL=loader.js.map