@n8n/workflow-sdk 0.2.0

package/dist/workflow-builder.js

@@ -0,0 +1,636 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflow = void 0;
+const base_1 = require("./types/base");
+const index_1 = require("./validation/index");
+const connection_utils_1 = require("./workflow-builder/connection-utils");
+const node_builder_1 = require("./workflow-builder/node-builders/node-builder");
+const pin_data_utils_1 = require("./workflow-builder/pin-data-utils");
+const defaults_1 = require("./workflow-builder/plugins/defaults");
+const registry_1 = require("./workflow-builder/plugins/registry");
+const serializers_1 = require("./workflow-builder/plugins/serializers");
+const string_utils_1 = require("./workflow-builder/string-utils");
+const subnode_utils_1 = require("./workflow-builder/subnode-utils");
+const workflow_import_1 = require("./workflow-builder/workflow-import");
+(0, defaults_1.registerDefaultPlugins)(registry_1.pluginRegistry);
+class WorkflowBuilderImpl {
+    constructor(id, name, settings = {}, nodes, currentNode, pinData, meta, registry) {
+        this.id = id;
+        this.name = name;
+        this._settings = { ...settings };
+        this._nodes = nodes ? new Map(nodes) : new Map();
+        this._currentNode = currentNode ?? null;
+        this._currentOutput = 0;
+        this._pinData = pinData;
+        this._meta = meta;
+        this._registry = registry;
+    }
+    createMutablePluginContext(nodes, nameMapping) {
+        const effectiveNameMapping = nameMapping ?? new Map();
+        return {
+            nodes,
+            workflowId: this.id,
+            workflowName: this.name,
+            settings: this._settings,
+            pinData: this._pinData,
+            nameMapping: effectiveNameMapping,
+            addNodeWithSubnodes: (node) => {
+                const actualKey = this.addNodeWithSubnodes(nodes, node);
+                if (actualKey && actualKey !== node.name) {
+                    effectiveNameMapping.set(node.id, actualKey);
+                }
+                return actualKey;
+            },
+            addBranchToGraph: (branch) => {
+                return this.addBranchToGraph(nodes, branch, effectiveNameMapping);
+            },
+            trackRename: (nodeId, actualKey) => {
+                effectiveNameMapping.set(nodeId, actualKey);
+            },
+        };
+    }
+    collectPinData(node) {
+        const nodePinData = node.config?.pinData;
+        if (!nodePinData || nodePinData.length === 0) {
+            return this._pinData;
+        }
+        return {
+            ...this._pinData,
+            [node.name]: nodePinData,
+        };
+    }
+    collectPinDataFromChain(chain) {
+        let pinData = this._pinData;
+        const registry = this._registry ?? registry_1.pluginRegistry;
+        for (const chainNode of chain.allNodes) {
+            const handler = registry.findCompositeHandler(chainNode);
+            if (handler?.collectPinData) {
+                handler.collectPinData(chainNode, (node) => {
+                    pinData = this.collectPinDataFromNode(node, pinData);
+                });
+            }
+            else if (chainNode?.config?.pinData) {
+                pinData = this.collectPinDataFromNode(chainNode, pinData);
+            }
+        }
+        return pinData;
+    }
+    collectPinDataFromNode(node, existingPinData) {
+        const nodePinData = node.config?.pinData;
+        if (nodePinData && nodePinData.length > 0) {
+            return {
+                ...existingPinData,
+                [node.name]: nodePinData,
+            };
+        }
+        return existingPinData;
+    }
+    add(node) {
+        if (Array.isArray(node)) {
+            for (const target of node) {
+                if ((0, node_builder_1.isInputTarget)(target)) {
+                    const inputTargetNode = target.node;
+                    if (!this._nodes.has(inputTargetNode.name)) {
+                        this.addNodeWithSubnodes(this._nodes, inputTargetNode);
+                    }
+                }
+                else if ((0, base_1.isNodeChain)(target)) {
+                    for (const chainNode of target.allNodes) {
+                        if (!this._nodes.has(chainNode.name)) {
+                            this.addNodeWithSubnodes(this._nodes, chainNode);
+                        }
+                    }
+                    this.addConnectionTargetNodes(this._nodes, target);
+                }
+                else {
+                    const targetNode = target;
+                    if (!this._nodes.has(targetNode.name)) {
+                        this.addNodeWithSubnodes(this._nodes, targetNode);
+                    }
+                }
+            }
+            return this;
+        }
+        const addRegistry = this._registry ?? registry_1.pluginRegistry;
+        const addHandler = addRegistry.findCompositeHandler(node);
+        if (addHandler) {
+            const ctx = this.createMutablePluginContext(this._nodes);
+            const headName = addHandler.addNodes(node, ctx);
+            this._currentNode = headName;
+            this._currentOutput = 0;
+            return this;
+        }
+        if ((0, base_1.isNodeChain)(node)) {
+            const nameMapping = new Map();
+            for (const chainNode of node.allNodes) {
+                const pluginResult = this.tryPluginDispatch(this._nodes, chainNode, nameMapping);
+                if (pluginResult === undefined) {
+                    const actualKey = this.addNodeWithSubnodes(this._nodes, chainNode);
+                    if (actualKey && actualKey !== chainNode.name) {
+                        nameMapping.set(chainNode.id, actualKey);
+                    }
+                }
+            }
+            this.addConnectionTargetNodes(this._nodes, node, nameMapping);
+            this._pinData = this.collectPinDataFromChain(node);
+            this._currentNode = nameMapping.get(node.tail.id) ?? node.tail.name;
+            this._currentOutput = 0;
+            return this;
+        }
+        const regularNode = node;
+        const actualKey = this.addNodeWithSubnodes(this._nodes, regularNode) ?? regularNode.name;
+        this.addSingleNodeConnectionTargets(this._nodes, regularNode);
+        this._pinData = this.collectPinData(regularNode);
+        this._currentNode = actualKey;
+        this._currentOutput = 0;
+        return this;
+    }
+    to(nodeOrComposite) {
+        if ((0, node_builder_1.isInputTarget)(nodeOrComposite)) {
+            const actualNode = nodeOrComposite.node;
+            const actualKey = this.addNodeWithSubnodes(this._nodes, actualNode) ?? actualNode.name;
+            if (this._currentNode) {
+                const currentGraphNode = this._nodes.get(this._currentNode);
+                if (currentGraphNode) {
+                    const mainConns = currentGraphNode.connections.get('main') ?? new Map();
+                    const outputConns = mainConns.get(this._currentOutput) ?? [];
+                    const alreadyConnected = outputConns.some((c) => c.node === actualKey && c.index === nodeOrComposite.inputIndex);
+                    if (!alreadyConnected) {
+                        outputConns.push({
+                            node: actualKey,
+                            type: 'main',
+                            index: nodeOrComposite.inputIndex,
+                        });
+                    }
+                    mainConns.set(this._currentOutput, outputConns);
+                    currentGraphNode.connections.set('main', mainConns);
+                }
+            }
+            this._currentNode = actualKey;
+            this._currentOutput = 0;
+            return this;
+        }
+        if (Array.isArray(nodeOrComposite)) {
+            return this.handleFanOut(nodeOrComposite);
+        }
+        if ((0, base_1.isNodeChain)(nodeOrComposite)) {
+            return this.handleNodeChain(nodeOrComposite);
+        }
+        const thenRegistry = this._registry ?? registry_1.pluginRegistry;
+        const thenHandler = thenRegistry.findCompositeHandler(nodeOrComposite);
+        if (thenHandler) {
+            const ctx = this.createMutablePluginContext(this._nodes);
+            const headName = thenHandler.addNodes(nodeOrComposite, ctx);
+            if (this._currentNode) {
+                const currentGraphNode = this._nodes.get(this._currentNode);
+                if (currentGraphNode) {
+                    const mainConns = currentGraphNode.connections.get('main') ?? new Map();
+                    const outputConns = mainConns.get(this._currentOutput) ?? [];
+                    outputConns.push({ node: headName, type: 'main', index: 0 });
+                    mainConns.set(this._currentOutput, outputConns);
+                    currentGraphNode.connections.set('main', mainConns);
+                }
+            }
+            this._currentNode = headName;
+            this._currentOutput = 0;
+            return this;
+        }
+        const node = nodeOrComposite;
+        const actualKey = this.addNodeWithSubnodes(this._nodes, node) ?? node.name;
+        this.addSingleNodeConnectionTargets(this._nodes, node);
+        if (this._currentNode) {
+            const currentGraphNode = this._nodes.get(this._currentNode);
+            if (currentGraphNode) {
+                const mainConns = currentGraphNode.connections.get('main') ?? new Map();
+                const outputConnections = mainConns.get(this._currentOutput) ?? [];
+                const alreadyConnected = outputConnections.some((c) => c.node === actualKey);
+                if (!alreadyConnected) {
+                    mainConns.set(this._currentOutput, [
+                        ...outputConnections,
+                        { node: actualKey, type: 'main', index: 0 },
+                    ]);
+                    currentGraphNode.connections.set('main', mainConns);
+                }
+            }
+        }
+        this._pinData = this.collectPinData(node);
+        this._currentNode = actualKey;
+        this._currentOutput = 0;
+        return this;
+    }
+    output() {
+        throw new Error('Cannot call .output() on the workflow builder. ' +
+            'Use .output() on a node variable instead: myNode.output(0).to(targetNode)');
+    }
+    input() {
+        throw new Error('Cannot call .input() on the workflow builder. ' +
+            'Use .input() on a node variable instead: myNode.input(1)');
+    }
+    settings(settings) {
+        this._settings = { ...this._settings, ...settings };
+        return this;
+    }
+    connect(source, sourceOutput, target, targetInput) {
+        if (!this._nodes.has(source.name)) {
+            this.addNodeWithSubnodes(this._nodes, source);
+        }
+        if (!this._nodes.has(target.name)) {
+            this.addNodeWithSubnodes(this._nodes, target);
+        }
+        const sourceNode = this._nodes.get(source.name);
+        if (sourceNode) {
+            const mainConns = sourceNode.connections.get('main') ?? new Map();
+            const outputConns = mainConns.get(sourceOutput) ?? [];
+            const alreadyExists = outputConns.some((c) => c.node === target.name && c.index === targetInput);
+            if (!alreadyExists) {
+                outputConns.push({ node: target.name, type: 'main', index: targetInput });
+                mainConns.set(sourceOutput, outputConns);
+                sourceNode.connections.set('main', mainConns);
+            }
+        }
+        return this;
+    }
+    getNode(name) {
+        const directLookup = this._nodes.get(name);
+        if (directLookup) {
+            return directLookup.instance;
+        }
+        for (const graphNode of this._nodes.values()) {
+            if (graphNode.instance.name === name) {
+                return graphNode.instance;
+            }
+        }
+        return undefined;
+    }
+    toJSON() {
+        this.mergeInstanceConnections();
+        const ctx = {
+            nodes: this._nodes,
+            workflowId: this.id,
+            workflowName: this.name,
+            settings: this._settings,
+            pinData: this._pinData,
+            meta: this._meta,
+            resolveTargetNodeName: (target) => this.resolveTargetNodeName(target),
+        };
+        return serializers_1.jsonSerializer.serialize(ctx);
+    }
+    mergeInstanceConnections() {
+        for (const graphNode of this._nodes.values()) {
+            if (typeof graphNode.instance.getConnections === 'function') {
+                const nodeConns = graphNode.instance.getConnections();
+                for (const { target, outputIndex, targetInputIndex } of nodeConns) {
+                    const targetName = this.resolveTargetNodeName(target, this._staleIdToKeyMap);
+                    if (!targetName)
+                        continue;
+                    const mainConns = graphNode.connections.get('main') ?? new Map();
+                    const outputConns = mainConns.get(outputIndex) ?? [];
+                    const targetIndex = targetInputIndex ?? 0;
+                    const alreadyExists = outputConns.some((c) => c.node === targetName && c.index === targetIndex);
+                    if (!alreadyExists) {
+                        outputConns.push({ node: targetName, type: 'main', index: targetIndex });
+                        mainConns.set(outputIndex, outputConns);
+                        graphNode.connections.set('main', mainConns);
+                    }
+                }
+            }
+        }
+    }
+    regenerateNodeIds() {
+        const newNodes = new Map();
+        const staleIdToKeyMap = new Map();
+        for (const [mapKey, graphNode] of this._nodes) {
+            const instance = graphNode.instance;
+            staleIdToKeyMap.set(instance.id, mapKey);
+            const newId = (0, string_utils_1.generateDeterministicNodeId)(this.id, instance.type, mapKey);
+            const newInstance = (0, node_builder_1.cloneNodeWithId)(instance, newId);
+            newNodes.set(mapKey, {
+                instance: newInstance,
+                connections: graphNode.connections,
+            });
+        }
+        this._staleIdToKeyMap = staleIdToKeyMap;
+        this._nodes = newNodes;
+    }
+    validate(options = {}) {
+        const errors = [];
+        const warnings = [];
+        const registry = this._registry ?? registry_1.pluginRegistry;
+        const pluginCtx = {
+            nodes: this._nodes,
+            workflowId: this.id,
+            workflowName: this.name,
+            settings: this._settings,
+            pinData: this._pinData,
+            validationOptions: {
+                allowDisconnectedNodes: options.allowDisconnectedNodes,
+                allowNoTrigger: options.allowNoTrigger,
+                nodeTypesProvider: options.nodeTypesProvider,
+            },
+        };
+        for (const [_mapKey, graphNode] of this._nodes) {
+            const nodeType = graphNode.instance.type;
+            const validators = registry.getValidatorsForNodeType(nodeType);
+            for (const validator of validators) {
+                const issues = validator.validateNode(graphNode.instance, graphNode, pluginCtx);
+                this.collectValidationIssues(issues, errors, warnings, index_1.ValidationError, index_1.ValidationWarning);
+            }
+        }
+        for (const validator of registry.getValidators()) {
+            if (validator.validateWorkflow) {
+                const issues = validator.validateWorkflow(pluginCtx);
+                this.collectValidationIssues(issues, errors, warnings, index_1.ValidationError, index_1.ValidationWarning);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    collectValidationIssues(issues, errors, warnings, ValidationErrorClass, ValidationWarningClass) {
+        for (const issue of issues) {
+            const code = issue.code;
+            if (issue.severity === 'error') {
+                errors.push(new ValidationErrorClass(code, issue.message, issue.nodeName, undefined, issue.violationLevel));
+            }
+            else {
+                warnings.push(new ValidationWarningClass(code, issue.message, issue.nodeName, issue.parameterPath, issue.originalName, issue.violationLevel));
+            }
+        }
+    }
+    toString() {
+        return JSON.stringify(this.toJSON(), null, 2);
+    }
+    toFormat(format) {
+        const registry = this._registry;
+        if (!registry) {
+            throw new Error(`No serializer registered for format '${format}'. Provide a registry with serializers when creating the workflow.`);
+        }
+        const serializer = registry.getSerializer(format);
+        if (!serializer) {
+            throw new Error(`No serializer registered for format '${format}'`);
+        }
+        const ctx = {
+            nodes: this._nodes,
+            workflowId: this.id,
+            workflowName: this.name,
+            settings: this._settings,
+            pinData: this._pinData,
+            meta: this._meta,
+            resolveTargetNodeName: (target) => this.resolveTargetNodeName(target),
+        };
+        return serializer.serialize(ctx);
+    }
+    generatePinData(options) {
+        const { beforeWorkflow } = options ?? {};
+        const existingNodeNames = beforeWorkflow
+            ? new Set(beforeWorkflow.nodes.map((n) => n.name))
+            : undefined;
+        for (const graphNode of this._nodes.values()) {
+            const node = graphNode.instance;
+            const nodeName = node.name;
+            if (existingNodeNames?.has(nodeName)) {
+                continue;
+            }
+            if (this._pinData?.[nodeName]) {
+                continue;
+            }
+            if (!(0, pin_data_utils_1.shouldGeneratePinData)(node)) {
+                continue;
+            }
+            const output = node.config?.output;
+            if (output && output.length > 0) {
+                this._pinData = this._pinData ?? {};
+                this._pinData[nodeName] = output;
+            }
+        }
+        return this;
+    }
+    resolveTargetNodeName(target, nameMapping) {
+        const registry = this._registry ?? registry_1.pluginRegistry;
+        return (0, connection_utils_1.resolveTargetNodeName)(target, this._nodes, registry, nameMapping);
+    }
+    addConnectionTargetNodes(nodes, chain, nameMapping) {
+        const registry = this._registry ?? registry_1.pluginRegistry;
+        const connections = chain.getConnections();
+        for (const { target } of connections) {
+            if (registry.isCompositeType(target))
+                continue;
+            if ((0, base_1.isNodeChain)(target)) {
+                this.addBranchToGraph(nodes, target, nameMapping);
+                continue;
+            }
+            if ((0, node_builder_1.isInputTarget)(target)) {
+                const inputTargetNode = target.node;
+                if (!nodes.has(inputTargetNode.name)) {
+                    const actualKey = this.addNodeWithSubnodes(nodes, inputTargetNode);
+                    if (actualKey && nameMapping && actualKey !== inputTargetNode.name) {
+                        nameMapping.set(inputTargetNode.id, actualKey);
+                    }
+                }
+                continue;
+            }
+            const targetNode = target;
+            if (!nodes.has(targetNode.name)) {
+                const actualKey = this.addNodeWithSubnodes(nodes, targetNode);
+                if (actualKey && nameMapping && actualKey !== targetNode.name) {
+                    nameMapping.set(targetNode.id, actualKey);
+                }
+            }
+        }
+    }
+    addSingleNodeConnectionTargets(nodes, nodeInstance) {
+        if (typeof nodeInstance.getConnections !== 'function')
+            return;
+        const registry = this._registry ?? registry_1.pluginRegistry;
+        const connections = nodeInstance.getConnections();
+        for (const { target } of connections) {
+            if (registry.isCompositeType(target))
+                continue;
+            if ((0, base_1.isNodeChain)(target)) {
+                this.addBranchToGraph(nodes, target);
+                continue;
+            }
+            if ((0, node_builder_1.isInputTarget)(target)) {
+                const inputTargetNode = target.node;
+                if (!nodes.has(inputTargetNode.name)) {
+                    this.addNodeWithSubnodes(nodes, inputTargetNode);
+                }
+                continue;
+            }
+            const targetNode = target;
+            if (!nodes.has(targetNode.name)) {
+                this.addNodeWithSubnodes(nodes, targetNode);
+            }
+        }
+    }
+    tryPluginDispatch(nodes, target, nameMapping) {
+        const registry = this._registry ?? registry_1.pluginRegistry;
+        const handler = registry.findCompositeHandler(target);
+        if (handler) {
+            const ctx = this.createMutablePluginContext(nodes, nameMapping);
+            return handler.addNodes(target, ctx);
+        }
+        return undefined;
+    }
+    addNodeWithSubnodes(nodes, nodeInstance) {
+        return (0, subnode_utils_1.addNodeWithSubnodes)(nodes, nodeInstance);
+    }
+    handleFanOut(nodes) {
+        if (nodes.length === 0) {
+            return this;
+        }
+        const currentGraphNode = this._currentNode ? this._nodes.get(this._currentNode) : undefined;
+        nodes.forEach((node, index) => {
+            if (node === null) {
+                return;
+            }
+            const headNodeName = this.addBranchToGraph(this._nodes, node);
+            if (this._currentNode && currentGraphNode) {
+                const mainConns = currentGraphNode.connections.get('main') ?? new Map();
+                const outputConnections = mainConns.get(index) ?? [];
+                mainConns.set(index, [
+                    ...outputConnections,
+                    { node: headNodeName, type: 'main', index: 0 },
+                ]);
+                currentGraphNode.connections.set('main', mainConns);
+            }
+        });
+        const nonNullNodes = nodes.filter((n) => n !== null);
+        const lastNode = nonNullNodes[nonNullNodes.length - 1];
+        this._currentNode = lastNode
+            ? (0, base_1.isNodeChain)(lastNode)
+                ? (lastNode.tail?.name ?? this._currentNode)
+                : lastNode.name
+            : this._currentNode;
+        this._currentOutput = 0;
+        return this;
+    }
+    handleNodeChain(chain) {
+        const headNodeName = this.addBranchToGraph(this._nodes, chain);
+        if (this._currentNode) {
+            const currentGraphNode = this._nodes.get(this._currentNode);
+            if (currentGraphNode) {
+                const mainConns = currentGraphNode.connections.get('main') ?? new Map();
+                const outputConnections = mainConns.get(this._currentOutput) ?? [];
+                outputConnections.push({ node: headNodeName, type: 'main', index: 0 });
+                mainConns.set(this._currentOutput, outputConnections);
+                currentGraphNode.connections.set('main', mainConns);
+            }
+        }
+        this._pinData = this.collectPinDataFromChain(chain);
+        this._currentNode = chain.tail?.name ?? headNodeName;
+        this._currentOutput = 0;
+        return this;
+    }
+    addBranchToGraph(nodes, branch, nameMapping) {
+        const effectiveNameMapping = nameMapping ?? new Map();
+        const registry = this._registry ?? registry_1.pluginRegistry;
+        const pluginResult = this.tryPluginDispatch(nodes, branch, effectiveNameMapping);
+        if (pluginResult !== undefined) {
+            return pluginResult;
+        }
+        if ((0, base_1.isNodeChain)(branch)) {
+            for (const chainNode of branch.allNodes) {
+                if (chainNode === null) {
+                    continue;
+                }
+                if (typeof chainNode !== 'object' ||
+                    (!('name' in chainNode) && !registry.isCompositeType(chainNode))) {
+                    continue;
+                }
+                const chainPluginResult = this.tryPluginDispatch(nodes, chainNode, effectiveNameMapping);
+                if (chainPluginResult === undefined) {
+                    const actualKey = this.addNodeWithSubnodes(nodes, chainNode);
+                    if (actualKey && actualKey !== chainNode.name) {
+                        effectiveNameMapping.set(chainNode.id, actualKey);
+                    }
+                }
+            }
+            const connections = branch.getConnections();
+            for (const { target, outputIndex, targetInputIndex } of connections) {
+                for (const chainNode of branch.allNodes) {
+                    if (chainNode === null) {
+                        continue;
+                    }
+                    if (typeof chainNode.getConnections !== 'function') {
+                        continue;
+                    }
+                    const nodeToCheck = chainNode;
+                    const nodeName = chainNode.name;
+                    if (nodeToCheck && nodeName && typeof nodeToCheck.getConnections === 'function') {
+                        const nodeConns = nodeToCheck.getConnections();
+                        if (nodeConns.some((c) => c.target === target &&
+                            c.outputIndex === outputIndex &&
+                            c.targetInputIndex === targetInputIndex)) {
+                            if ((0, base_1.isNodeChain)(target)) {
+                                const chainTarget = target;
+                                for (const targetChainNode of chainTarget.allNodes) {
+                                    if (targetChainNode === null)
+                                        continue;
+                                    const targetPluginResult = this.tryPluginDispatch(nodes, targetChainNode, effectiveNameMapping);
+                                    if (targetPluginResult === undefined && !nodes.has(targetChainNode.name)) {
+                                        this.addNodeWithSubnodes(nodes, targetChainNode);
+                                    }
+                                }
+                            }
+                            else if (typeof target.name === 'string' &&
+                                !nodes.has(target.name)) {
+                                this.addNodeWithSubnodes(nodes, target);
+                            }
+                            const mappedKey = nodeToCheck && effectiveNameMapping.get(nodeToCheck.id);
+                            const actualSourceKey = mappedKey ?? nodeName;
+                            const sourceGraphNode = nodes.get(actualSourceKey);
+                            if (sourceGraphNode) {
+                                const targetName = this.resolveTargetNodeName(target, effectiveNameMapping);
+                                if (targetName) {
+                                    const mainConns = sourceGraphNode.connections.get('main') ??
+                                        new Map();
+                                    const outputConns = mainConns.get(outputIndex) ?? [];
+                                    if (!outputConns.some((c) => c.node === targetName && c.index === (targetInputIndex ?? 0))) {
+                                        outputConns.push({
+                                            node: targetName,
+                                            type: 'main',
+                                            index: targetInputIndex ?? 0,
+                                        });
+                                        mainConns.set(outputIndex, outputConns);
+                                        sourceGraphNode.connections.set('main', mainConns);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            const headKey = effectiveNameMapping.get(branch.head.id) ?? branch.head.name;
+            return headKey;
+        }
+        else {
+            const actualKey = this.addNodeWithSubnodes(nodes, branch);
+            if (actualKey && actualKey !== branch.name) {
+                effectiveNameMapping.set(branch.id, actualKey);
+            }
+            return actualKey ?? branch.name;
+        }
+    }
+}
+function isWorkflowBuilderOptions(options) {
+    if (!options)
+        return false;
+    return 'settings' in options || 'registry' in options;
+}
+function createWorkflow(id, name, options) {
+    if (isWorkflowBuilderOptions(options)) {
+        return new WorkflowBuilderImpl(id, name, options.settings, undefined, undefined, undefined, undefined, options.registry);
+    }
+    return new WorkflowBuilderImpl(id, name, options);
+}
+function fromJSON(json) {
+    const parsed = (0, workflow_import_1.parseWorkflowJSON)(json);
+    return new WorkflowBuilderImpl(parsed.id, parsed.name, parsed.settings, parsed.nodes, parsed.lastNode, parsed.pinData, parsed.meta);
+}
+exports.workflow = Object.assign(createWorkflow, {
+    fromJSON,
+});
+//# sourceMappingURL=workflow-builder.js.map