@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-CY3RNVML.js

@@ -0,0 +1,296 @@
+import {
+  EXECUTION_STRATEGIES
+} from "./chunk-R4QGNK34.js";
+
+// src/ast/builder.ts
+var WorkflowBuilder = class {
+  ast;
+  /**
+   * Create a new workflow builder
+   * @param name - Internal workflow name
+   * @param functionName - Exported function name
+   * @param sourceFile - Source file path
+   */
+  constructor(name, functionName, sourceFile) {
+    this.ast = {
+      type: "Workflow",
+      sourceFile,
+      name,
+      functionName,
+      nodeTypes: [],
+      instances: [],
+      connections: [],
+      startPorts: {},
+      exitPorts: {},
+      imports: []
+    };
+  }
+  description(desc) {
+    this.ast.description = desc;
+    return this;
+  }
+  generatedFile(path) {
+    this.ast.generatedFile = path;
+    return this;
+  }
+  addNodeType(nodeType2) {
+    this.ast.nodeTypes.push(nodeType2);
+    return this;
+  }
+  addNodeInstance(instance) {
+    this.ast.instances.push(instance);
+    return this;
+  }
+  addConnection(connection2) {
+    this.ast.connections.push(connection2);
+    return this;
+  }
+  addScope(scopeName, instanceIds) {
+    if (!this.ast.scopes) {
+      this.ast.scopes = {};
+    }
+    this.ast.scopes[scopeName] = instanceIds;
+    return this;
+  }
+  addImport(importDecl2) {
+    this.ast.imports.push(importDecl2);
+    return this;
+  }
+  metadata(key, value) {
+    if (!this.ast.metadata) {
+      this.ast.metadata = {};
+    }
+    this.ast.metadata[key] = value;
+    return this;
+  }
+  /** Build and return the final TWorkflowAST */
+  build() {
+    return this.ast;
+  }
+};
+var NodeTypeBuilder = class {
+  nodeType;
+  /**
+   * Create a new node type builder
+   * @param name - Unique node type name
+   * @param functionName - Name of the implementing function
+   */
+  constructor(name, functionName) {
+    this.nodeType = {
+      type: "NodeType",
+      name,
+      functionName,
+      inputs: {},
+      outputs: {},
+      hasSuccessPort: false,
+      hasFailurePort: false,
+      executeWhen: EXECUTION_STRATEGIES.CONJUNCTION,
+      isAsync: false
+    };
+  }
+  label(label) {
+    this.nodeType.label = label;
+    return this;
+  }
+  description(desc) {
+    this.nodeType.description = desc;
+    return this;
+  }
+  scope(scopeName) {
+    this.nodeType.scope = scopeName;
+    return this;
+  }
+  input(name, definition) {
+    this.nodeType.inputs[name] = definition;
+    return this;
+  }
+  output(name, definition) {
+    this.nodeType.outputs[name] = definition;
+    return this;
+  }
+  successPort(enabled = true) {
+    this.nodeType.hasSuccessPort = enabled;
+    return this;
+  }
+  failurePort(enabled = true) {
+    this.nodeType.hasFailurePort = enabled;
+    return this;
+  }
+  executeWhen(when) {
+    this.nodeType.executeWhen = when;
+    return this;
+  }
+  branchingStrategy(strategy, field) {
+    this.nodeType.branchingStrategy = strategy;
+    if (field) {
+      this.nodeType.branchField = field;
+    }
+    return this;
+  }
+  defaultConfig(config) {
+    this.nodeType.defaultConfig = config;
+    return this;
+  }
+  metadata(key, value) {
+    if (!this.nodeType.metadata) {
+      this.nodeType.metadata = {};
+    }
+    this.nodeType.metadata[key] = value;
+    return this;
+  }
+  /** Build and return the final TNodeTypeAST */
+  build() {
+    return this.nodeType;
+  }
+};
+var NodeInstanceBuilder = class {
+  instance;
+  /**
+   * Create a new node instance builder
+   * @param id - Unique instance ID within the workflow
+   * @param nodeType - Name of the NodeType this instance references
+   */
+  constructor(id, nodeType2) {
+    this.instance = {
+      type: "NodeInstance",
+      id,
+      nodeType: nodeType2
+    };
+  }
+  config(configData) {
+    this.instance.config = configData;
+    return this;
+  }
+  parentScope(scope) {
+    const dotIndex = scope.indexOf(".");
+    const parentNodeName = dotIndex > 0 ? scope.substring(0, dotIndex) : scope;
+    const scopeName = dotIndex > 0 ? scope.substring(dotIndex + 1) : "";
+    this.instance.parent = { id: parentNodeName, scope: scopeName };
+    return this;
+  }
+  metadata(key, value) {
+    if (!this.instance.metadata) {
+      this.instance.metadata = {};
+    }
+    this.instance.metadata[key] = value;
+    return this;
+  }
+  /** Build and return the final TNodeInstanceAST */
+  build() {
+    return this.instance;
+  }
+};
+var ConnectionBuilder = class {
+  connection;
+  /**
+   * Create a new connection builder
+   * @param from - Source port reference
+   * @param to - Target port reference
+   */
+  constructor(from, to) {
+    this.connection = {
+      type: "Connection",
+      from,
+      to
+    };
+  }
+  controlFlow(isControlFlow = true) {
+    if (!this.connection.metadata) {
+      this.connection.metadata = {};
+    }
+    this.connection.metadata.isControlFlow = isControlFlow;
+    return this;
+  }
+  dataFlow(isDataFlow = true) {
+    if (!this.connection.metadata) {
+      this.connection.metadata = {};
+    }
+    this.connection.metadata.isDataFlow = isDataFlow;
+    return this;
+  }
+  metadata(key, value) {
+    if (!this.connection.metadata) {
+      this.connection.metadata = {};
+    }
+    this.connection.metadata[key] = value;
+    return this;
+  }
+  /** Build and return the final TConnectionAST */
+  build() {
+    return this.connection;
+  }
+};
+function portRef(node, port2) {
+  return { node, port: port2 };
+}
+function port(dataType, options) {
+  return {
+    dataType,
+    ...options
+  };
+}
+function importDecl(specifiers, source, importKind = "value") {
+  return {
+    type: "Import",
+    specifiers,
+    source,
+    importKind
+  };
+}
+function namedImport(name, alias) {
+  return {
+    imported: name,
+    local: alias || name,
+    kind: "named"
+  };
+}
+function defaultImport(name) {
+  return {
+    imported: "default",
+    local: name,
+    kind: "default"
+  };
+}
+function namespaceImport(name) {
+  return {
+    imported: "*",
+    local: name,
+    kind: "namespace"
+  };
+}
+function workflow(name, functionName, sourceFile) {
+  return new WorkflowBuilder(name, functionName, sourceFile);
+}
+function nodeType(name, functionName) {
+  return new NodeTypeBuilder(name, functionName);
+}
+function nodeInstance(id, nodeTypeName) {
+  return new NodeInstanceBuilder(id, nodeTypeName);
+}
+function connection(from, to) {
+  return new ConnectionBuilder(from, to);
+}
+function connect(fromNode, fromPort, toNode, toPort) {
+  return connection(
+    portRef(fromNode, fromPort),
+    portRef(toNode, toPort)
+  ).build();
+}
+
+export {
+  WorkflowBuilder,
+  NodeTypeBuilder,
+  NodeInstanceBuilder,
+  ConnectionBuilder,
+  portRef,
+  port,
+  importDecl,
+  namedImport,
+  defaultImport,
+  namespaceImport,
+  workflow,
+  nodeType,
+  nodeInstance,
+  connection,
+  connect
+};