@chix/loader/lib/lib/NodeDefinitionManager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var _ = require("lodash");
var forOf = require("object-forof");
var util_1 = require("../util");
var NodeDefinitionManager = /** @class */ (function () {
    function NodeDefinitionManager(dependencyManager) {
        /**
         *
         * Format:
         *
         * Keeps track of all known nodeDefinitions.
         *
         * {
         *  'http://....': { // url in this case is the identifier
         *
         *    fs: {
         *       readFile:  <definition>
         *       writeFile: <definition>
         *    }
         *
         *  }
         *
         * }
         *
         */
        this.nodeDefinitions = {};
        this.dependencyManager = dependencyManager;
    }
    NodeDefinitionManager.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] = {};
                    }
                }
            }
        }
    };
    /**
     *
     * Add node definitions
     *
     * Used to `statically` add nodeDefinitions.
     *
     * @param {String} identifier
     * @param {Object} nodeDefs
     * @api public
     */
    NodeDefinitionManager.prototype.addNodeDefinitions = function (identifier, nodeDefs) {
        var _this = this;
        if (Array.isArray(nodeDefs)) {
            for (var i = 0; i < nodeDefs.length; i++) {
                this.addNodeDefinition(identifier, nodeDefs[i]);
            }
        }
        else {
            forOf(function (_ns, _name, nodeDefinition) {
                _this.addNodeDefinition(identifier, nodeDefinition);
            }, nodeDefs);
        }
    };
    /**
     *
     * Add a node definition
     *
     * @param {String} identifier
     * @param {Object} nodeDef
     * @api public
     */
    NodeDefinitionManager.prototype.addNodeDefinition = function (identifier, nodeDef) {
        if (!nodeDef.hasOwnProperty('ns')) {
            throw new Error([
                'Nodefinition for',
                identifier,
                'lacks an ns property'
            ].join(' '));
        }
        if (!nodeDef.hasOwnProperty('name')) {
            throw new Error([
                'Nodefinition for',
                identifier,
                'lacks an name property'
            ].join(' '));
        }
        // store the provider url along with the nodeDefinition
        // Needed for fetching back from storage.
        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);
    };
    NodeDefinitionManager.prototype.setNodeDefinitions = function (nodeDefinitions) {
        if (this.hasNodeDefinitions()) {
            throw Error('Node Definitions already set, only use this method to prepopulate the nodeDefinitions');
        }
        this.nodeDefinitions = nodeDefinitions;
    };
    NodeDefinitionManager.prototype.hasNodeDefinitions = function (provider) {
        if (provider) {
            return Boolean(this.nodeDefinitions[provider]);
        }
        return Object.keys(this.nodeDefinitions).length > 0;
    };
    NodeDefinitionManager.prototype.setNodeDefinition = function (provider, nodeDefinition) {
        var ns = nodeDefinition.ns, name = nodeDefinition.name;
        _.set(this.nodeDefinitions, [provider, ns, name], nodeDefinition);
    };
    /**
     *
     * Check whether we have the definition
     *
     * @param {String} providerUrl
     * @param {String} ns
     * @param {String} name
     * @api public
     */
    NodeDefinitionManager.prototype.hasNodeDefinition = function (providerUrl, ns, name) {
        return this.nodeDefinitions.hasOwnProperty(providerUrl) &&
            this.nodeDefinitions[providerUrl].hasOwnProperty(ns) &&
            this.nodeDefinitions[providerUrl][ns].hasOwnProperty(name);
    };
    /**
     * Loads the NodeDefinition for a node.
     *
     * In order to do so each node must know the provider url it was loaded from.
     *
     * This is normally not stored directly into flows, but the flow is saved with the namespaces in use.
     *
     * TODO: this really should just be (provider, name, ns, version) else use the load method.
     */
    NodeDefinitionManager.prototype.getNodeDefinition = function (node, flow) {
        var definition = this.loadNodeDefinition(node, flow);
        // merge the schema of the internal node.
        if (definition.type === 'flow') {
            this.mergeSchema(definition); // in place
        }
        return definition;
    };
    NodeDefinitionManager.prototype.loadNodeDefinition = function (node, flow) {
        var location;
        var provider;
        if (node.provider &&
            util_1.isUri(node.provider)) {
            // it's already an url
            location = node.provider;
        }
        else if (!node.provider && (!flow || !flow.providers)) {
            // for direct additions (only @ is possible)
            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');
            }
            if (node.provider) {
                // 'x': ..
                provider = flow.providers[node.provider];
            }
            else {
                provider = flow.providers['@'];
            }
            // fix: find provider by path or url, has to do with provider
            // already resolved (sub.sub.graphs)
            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');
            }
            node.provider = location;
        }
        if (!this.hasNodeDefinition(location, node.ns, node.name)) {
            // not sure.. node has a full url.
            // but it's not loaded, then we ask to load the full map.
            // which works if provider is x but not if it's already expanded.
            console.log("NodeDefinition " + location + "->" + node.ns + ":" + node.name + " is not available.");
            throw Error('Should load node definition');
            // console.error('Should load node definition')
            // proceed, but this is a bug, load() was activate before.
            // but also hardly does anything in the context of just Loader.
            // .. Behavior should be a hard fail, because the loader
            // must be instructed to preload everything either using
            // the async functions preload or load
            /*
               await this.load(flow, function () {
                 callback(nodeDefinitions[location][node.ns][node.name])
               })
       
               return false
             */
        }
        return this.nodeDefinitions[location][node.ns][node.name];
    };
    NodeDefinitionManager.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);
    };
    NodeDefinitionManager.prototype.saveNodeDefinition = function (_providerLocation, _nodeDefinition) {
        throw new Error([
            this.constructor.name,
            'must implement a save method'
        ].join(' '));
    };
    /**
     * Get Nodedefinitions
     *
     * Optionally with a provider url so it returns only the node definitions
     * at that provider.
     *
     * @param {String} provider (Optional)
     */
    NodeDefinitionManager.prototype.getNodeDefinitions = function (provider) {
        if (provider) {
            return this.nodeDefinitions[provider];
        }
        else {
            return this.nodeDefinitions;
        }
    };
    /**
     * Test whether all nodes used by this flow are resolvable
     *
     * @param {FlowDefinition} flow
     * @returns {boolean}
     */
    NodeDefinitionManager.prototype.isResolved = function (flow) {
        var seen = [];
        for (var j = 0; j < flow.nodes.length; j++) {
            var node = flow.nodes[j];
            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);
            }
        }
        return true;
    };
    NodeDefinitionManager.prototype.getUnresolved = function (flow) {
        var self = this;
        var unresolved = [];
        var seen = [];
        function resolveDefinitions(flow) {
            for (var j = 0; j < flow.nodes.length; j++) {
                var node = flow.nodes[j];
                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);
                    }
                }
            }
        }
        resolveDefinitions(flow);
        return unresolved;
    };
    NodeDefinitionManager.prototype.mergeSchema = function (graph) {
        var _this = this;
        forOf(function (type, port, externalPort) {
            if (externalPort.hasOwnProperty('nodeId')) {
                // TODO: should go recursive if internal node is a flow, in able to get the correct type.
                var internalDef = _this.getNodeDefinition(util_1.findNodeWithinGraph(externalPort.nodeId, graph), graph);
                if (!_.has(internalDef, ['ports', type, externalPort.name])) {
                    throw Error("External Port points to non-existent internal port");
                }
                var copy = JSON.parse(JSON.stringify(_.get(internalDef, ['ports', type, externalPort.name])));
                copy.title = externalPort.title;
                copy.name = externalPort.name;
                copy.nodeId = externalPort.nodeId;
                _.set(graph, ['ports', type, port], copy);
            }
            else {
                // not pointing to an internal node. :start etc.
            }
        }, graph.ports);
    };
    return NodeDefinitionManager;
}());
exports.NodeDefinitionManager = NodeDefinitionManager;
//# sourceMappingURL=NodeDefinitionManager.js.map