@stoplight/graphite/graphite.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lifecycle_1 = require("@stoplight/lifecycle");
const uuidv4 = require("uuid/v4");
const errorReporter_1 = require("./errorReporter");
const graph_1 = require("./graph");
const dom_1 = require("./graph/dom");
const nodes_1 = require("./graph/nodes");
const notifier_1 = require("./notifier");
const resolver_1 = require("./resolver");
const scheduler_1 = require("./scheduler");
const taskHandler_1 = require("./scheduler/taskHandler");
const specProviderRegistry_1 = require("./services/specProviderRegistry");
function createGraphite(props = {}) {
    return new Graphite(props);
}
exports.createGraphite = createGraphite;
class Graphite {
    constructor(props) {
        this._disposables = new lifecycle_1.DisposableCollection();
        this.dispose = () => {
            this._disposables.dispose();
        };
        this.id = props.id || uuidv4();
        this.notifier = (props.graph && props.graph.notifier) || props.notifier || notifier_1.createNotifier();
        this.graph =
            props.graph ||
                graph_1.createGraph({
                    id: this.id,
                    idGenerator: props.idGenerator,
                    notifier: this.notifier,
                });
        this.resolver = resolver_1.createResolver(new resolver_1.ResolveCache(), this.graph.getNodeByUri);
        this.scheduler =
            props.scheduler ||
                scheduler_1.createScheduler({
                    graph: this.graph,
                    resolver: this.resolver,
                });
        this._disposables.pushAll([this.graph, this.notifier]);
        this._disposables.pushAll(this.scheduleSerialize());
        this._disposables.pushAll(this.scheduleDeserialize());
        this._disposables.pushAll(this.scheduleComputeSourceMap());
        this._disposables.pushAll(this.scheduleTransformations());
        if (!props.isMirror) {
            this._disposables.pushAll(this.scheduleValidateSourceNode());
            this._disposables.pushAll(this.scheduleResolveSourceNode(props.resolveEagerly));
        }
        const sourceNodeDataHandler = (op) => {
            const node = this.graph.getNodeById(op.id);
            if (!node) {
                console.debug(`${dom_1.GraphOp[op.op]} node with id ${op.id} not found.`);
                return;
            }
            this.notifier.emit(notifier_1.GraphiteEvent.DidChangeSourceNode, {
                node: node.dehydrate(),
                change: op,
            });
        };
        this._disposables.pushAll([
            this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, sourceNodeDataHandler),
            this.notifier.on(notifier_1.GraphiteEvent.DidPatchSourceNodeProp, sourceNodeDataHandler),
        ]);
        this._disposables.push(errorReporter_1.errorReporter.onError(result => {
            this.notifier.emit(notifier_1.GraphiteEvent.DidError, result);
        }));
    }
    registerPlugins(...plugins) {
        const disposables = new lifecycle_1.DisposableCollection();
        plugins.forEach(plugin => {
            plugin.tasks.forEach(task => {
                disposables.push(this.scheduler.registerHandler(task.operation, task.handler));
            });
            if (plugin.specProvider) {
                disposables.push(specProviderRegistry_1.registry.register(plugin.specProvider));
            }
        });
        return disposables;
    }
    scheduleTransformations() {
        return [
            this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, ({ id, prop, trace = {}, previousValue }) => {
                if (prop === 'spec') {
                    this.scheduler.queue({
                        op: scheduler_1.GraphTaskOp.TransformParsed,
                        nodeId: id,
                        trace,
                    });
                }
                else if (prop === 'data.resolved') {
                    this.scheduler.queue({
                        op: scheduler_1.GraphTaskOp.TransformParsed,
                        nodeId: id,
                        trace,
                        oldValue: previousValue,
                    });
                }
            }),
            this.notifier.on(notifier_1.GraphiteEvent.DidUpdateSourceMapNodeResolved, ({ id, oldValue, trace }) => {
                this.scheduler.queue({
                    op: scheduler_1.GraphTaskOp.TransformParsed,
                    nodeId: id,
                    trace,
                    oldValue,
                });
            }),
        ];
    }
    scheduleDeserialize() {
        const handler = (op) => {
            const { id, prop, trace = {} } = op;
            if (prop !== 'data.raw' && prop !== 'data.original' && prop !== 'data.parsed')
                return;
            this.scheduler
                .queue({
                op: scheduler_1.GraphTaskOp.DeserializeSourceNode,
                nodeId: id,
                trace,
                recomputeOnly: prop === 'data.parsed',
            })
                .then(() => {
                this.notifier.emit(notifier_1.GraphiteEvent.DidPatchSourceNodePropComplete, op);
            });
        };
        return [
            this.notifier.on(notifier_1.GraphiteEvent.DidAddNode, ({ node, trace = {} }) => {
                if (node.category !== nodes_1.NodeCategory.Source || !node.data || !node.data.raw)
                    return;
                this.scheduler.queue({
                    op: scheduler_1.GraphTaskOp.DeserializeSourceNode,
                    nodeId: node.id,
                    trace,
                });
            }),
            this.notifier.on(notifier_1.GraphiteEvent.DidPatchSourceNodeProp, handler),
            this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, handler),
        ];
    }
    scheduleSerialize() {
        const handler = ({ id, prop, trace = {} }) => {
            if (prop !== 'data.parsed' || trace.sourceOp === scheduler_1.GraphTaskOp.DeserializeSourceNode)
                return;
            this.scheduler.queue({
                op: scheduler_1.GraphTaskOp.SerializeSourceNode,
                nodeId: id,
                trace,
            });
        };
        return [
            this.notifier.on(notifier_1.GraphiteEvent.DidPatchSourceNodeProp, handler),
            this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, handler),
        ];
    }
    scheduleComputeSourceMap() {
        return [
            this.notifier.on(notifier_1.GraphiteEvent.DidPatchSourceNodeProp, ({ id, prop, trace = {}, value }) => {
                if (prop !== 'data.parsed')
                    return;
                this.scheduler.queue({
                    op: scheduler_1.GraphTaskOp.ComputeSourceMap,
                    nodeId: id,
                    patch: value,
                    trace,
                });
            }),
            this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, ({ id, prop, trace = {}, value }) => {
                if (prop !== 'data.parsed')
                    return;
                this.scheduler.queue({
                    op: scheduler_1.GraphTaskOp.ComputeSourceMap,
                    nodeId: id,
                    trace,
                });
            }),
            this.notifier.on(notifier_1.GraphiteEvent.DidAddNode, ({ node, trace }) => {
                if (node.category !== nodes_1.NodeCategory.Source || !node.data || !node.data.parsed)
                    return;
                this.scheduler.queue({
                    op: scheduler_1.GraphTaskOp.ComputeSourceMap,
                    nodeId: node.id,
                    trace,
                });
            }),
        ];
    }
    scheduleResolveSourceNode(eager) {
        const disposables = [
            this.scheduler.registerHandler(scheduler_1.GraphTaskOp.ResolveSourceNode, taskHandler_1.createTaskHandler({
                selector: node => node.category === nodes_1.NodeCategory.Source,
                run: scheduler_1.resolveSourceNodeHandler,
            }, 'resolver-handler')),
        ];
        const isCustomized = Array.isArray(eager) && eager.length > 0;
        const shouldResolve = isCustomized
            ? (id) => {
                const node = this.graph.getNodeById(id);
                return (node !== void 0 &&
                    node.category === nodes_1.NodeCategory.Source &&
                    node.spec !== void 0 &&
                    eager.includes(node.spec));
            }
            : null;
        if (eager !== false || isCustomized) {
            const scheduleResolving = ({ id, trace = {} }) => {
                return this.scheduler.queue({
                    op: scheduler_1.GraphTaskOp.ResolveSourceNode,
                    nodeId: id,
                    trace,
                });
            };
            const handler = (op) => {
                if (op.prop !== 'data.parsed' || (shouldResolve !== null && !shouldResolve(op.id)))
                    return;
                return scheduleResolving(op);
            };
            disposables.push(this.notifier.on(notifier_1.GraphiteEvent.DidPatchSourceNodeProp, handler), this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, handler));
            if (isCustomized) {
                disposables.push(this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, op => {
                    if (op.prop !== 'spec')
                        return;
                    const node = this.graph.getNodeById(op.id);
                    if (node === void 0 || node.category !== nodes_1.NodeCategory.Source) {
                        throw new Error('Invalid node given');
                    }
                    if (node.data.resolved !== void 0) {
                        return;
                    }
                    return scheduleResolving(op);
                }));
            }
        }
        return disposables;
    }
    scheduleValidateSourceNode() {
        const handler = ({ id, prop, trace = {} }) => {
            if (prop !== 'data.parsed')
                return;
            this.scheduler.queue({
                op: scheduler_1.GraphTaskOp.ValidateSourceNode,
                nodeId: id,
                trace,
            });
        };
        return [
            this.notifier.on(notifier_1.GraphiteEvent.DidSetSourceNodeProp, handler),
            this.notifier.on(notifier_1.GraphiteEvent.DidPatchSourceNodeProp, handler),
        ];
    }
}
//# sourceMappingURL=graphite.js.map