@foresthubai/workflow-core 0.4.3 → 0.4.5

package/src/node/MqttNode.ts

@@ -1,127 +1,130 @@
-import { NodeBase } from "./Node";
-import type { Expression } from "../api";
-import { OutputBinding } from "../parameter";
-import { NodeCategory, NodeTag } from "./constants";
-import { NodeDefinition } from "./NodeDefinition";
-
-// MQTT Publish - publishes a single value to an MQTT topic
-export interface MqttPublishNode extends NodeBase {
-  type: "MqttPublish";
-  arguments: {
-    channelReference: string;
-    dataType: "int" | "float" | "bool" | "string";
-    value: Expression;
-    qos: "0" | "1" | "2";
-    retain: boolean;
-  };
-}
-
-// On MQTT Message - fires when a message is received on a subscribed topic
-export interface OnMqttMessageNode extends NodeBase {
-  type: "OnMqttMessage";
-  arguments: {
-    channelReference: string;
-    dataType: "int" | "float" | "bool" | "string";
-    output: OutputBinding;
-  };
-}
-
-export type MqttNodeType = "MqttPublish" | "OnMqttMessage";
-export type MqttNode = MqttPublishNode | OnMqttMessageNode;
-
-// Node Definitions
-
-export const MqttPublishNodeDefinition: NodeDefinition = {
-  type: "MqttPublish",
-  label: "MQTT Publish",
-  category: NodeCategory.Output,
-  tags: [NodeTag.Network],
-  description: "Publish a value to an MQTT topic",
-  parameters: [
-    {
-      id: "channelReference",
-      label: "Channel",
-      description: "MQTT channel to publish through",
-      type: "channelSelect",
-      channelType: ["MQTT"],
-    },
-    {
-      id: "dataType",
-      label: "Data Type",
-      description: "Data type of the value to publish",
-      type: "selection",
-      options: [
-        { value: "int", label: "Integer" },
-        { value: "float", label: "Float" },
-        { value: "bool", label: "Boolean" },
-        { value: "string", label: "String" },
-      ],
-      default: "string",
-    },
-    {
-      id: "value",
-      label: "Value",
-      description: "Value to publish",
-      type: "expression",
-      expressionType: (args) => (args as MqttPublishNode["arguments"]).dataType,
-      default: { expression: "", references: [], dataType: "string" },
-    },
-    {
-      id: "qos",
-      label: "QoS",
-      description: "Quality of Service level",
-      type: "selection",
-      options: [
-        { value: "0", label: "0 - At most once" },
-        { value: "1", label: "1 - At least once" },
-        { value: "2", label: "2 - Exactly once" },
-      ],
-      default: "0",
-    },
-    {
-      id: "retain",
-      label: "Retain",
-      description: "Whether the broker should retain the message",
-      type: "bool",
-      default: false,
-    },
-  ],
-};
-
-export const OnMqttMessageNodeDefinition: NodeDefinition = {
-  type: "OnMqttMessage",
-  label: "On MQTT Message",
-  category: NodeCategory.Trigger,
-  tags: [NodeTag.Network],
-  description: "Fires when a message is received on a subscribed MQTT topic",
-  outputs: [
-    {
-      id: "output",
-      label: "Message Value",
-      type: "static",
-      dataType: (args) => (args as OnMqttMessageNode["arguments"]).dataType,
-    },
-  ],
-  parameters: [
-    {
-      id: "channelReference",
-      label: "Channel",
-      description: "MQTT channel to subscribe through",
-      type: "channelSelect",
-      channelType: ["MQTT"],
-    },
-    {
-      id: "dataType",
-      label: "Data Type",
-      description: "Expected data type of the received message value",
-      type: "selection",
-      options: [
-        { value: "int", label: "Integer" },
-        { value: "float", label: "Float" },
-        { value: "bool", label: "Boolean" },
-        { value: "string", label: "String" },
-      ],
-      default: "string",
-    },
-  ],
-};
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 ForestHub.
+
+import { NodeBase } from "./Node";
+import type { Expression } from "../api";
+import { OutputBinding } from "../parameter";
+import { NodeCategory, NodeTag } from "./constants";
+import { NodeDefinition } from "./NodeDefinition";
+
+// MQTT Publish - publishes a single value to an MQTT topic
+export interface MqttPublishNode extends NodeBase {
+  type: "MqttPublish";
+  arguments: {
+    channelReference: string;
+    dataType: "int" | "float" | "bool" | "string";
+    value: Expression;
+    qos: "0" | "1" | "2";
+    retain: boolean;
+  };
+}
+
+// On MQTT Message - fires when a message is received on a subscribed topic
+export interface OnMqttMessageNode extends NodeBase {
+  type: "OnMqttMessage";
+  arguments: {
+    channelReference: string;
+    dataType: "int" | "float" | "bool" | "string";
+    output: OutputBinding;
+  };
+}
+
+export type MqttNodeType = "MqttPublish" | "OnMqttMessage";
+export type MqttNode = MqttPublishNode | OnMqttMessageNode;
+
+// Node Definitions
+
+export const MqttPublishNodeDefinition: NodeDefinition = {
+  type: "MqttPublish",
+  label: "MQTT Publish",
+  category: NodeCategory.Output,
+  tags: [NodeTag.Network],
+  description: "Publish a value to an MQTT topic",
+  parameters: [
+    {
+      id: "channelReference",
+      label: "Channel",
+      description: "MQTT channel to publish through",
+      type: "channelSelect",
+      channelType: ["MQTT"],
+    },
+    {
+      id: "dataType",
+      label: "Data Type",
+      description: "Data type of the value to publish",
+      type: "selection",
+      options: [
+        { value: "int", label: "Integer" },
+        { value: "float", label: "Float" },
+        { value: "bool", label: "Boolean" },
+        { value: "string", label: "String" },
+      ],
+      default: "string",
+    },
+    {
+      id: "value",
+      label: "Value",
+      description: "Value to publish",
+      type: "expression",
+      expressionType: (args) => (args as MqttPublishNode["arguments"]).dataType,
+      default: { expression: "", references: [], dataType: "string" },
+    },
+    {
+      id: "qos",
+      label: "QoS",
+      description: "Quality of Service level",
+      type: "selection",
+      options: [
+        { value: "0", label: "0 - At most once" },
+        { value: "1", label: "1 - At least once" },
+        { value: "2", label: "2 - Exactly once" },
+      ],
+      default: "0",
+    },
+    {
+      id: "retain",
+      label: "Retain",
+      description: "Whether the broker should retain the message",
+      type: "bool",
+      default: false,
+    },
+  ],
+};
+
+export const OnMqttMessageNodeDefinition: NodeDefinition = {
+  type: "OnMqttMessage",
+  label: "On MQTT Message",
+  category: NodeCategory.Trigger,
+  tags: [NodeTag.Network],
+  description: "Fires when a message is received on a subscribed MQTT topic",
+  outputs: [
+    {
+      id: "output",
+      label: "Message Value",
+      type: "static",
+      dataType: (args) => (args as OnMqttMessageNode["arguments"]).dataType,
+    },
+  ],
+  parameters: [
+    {
+      id: "channelReference",
+      label: "Channel",
+      description: "MQTT channel to subscribe through",
+      type: "channelSelect",
+      channelType: ["MQTT"],
+    },
+    {
+      id: "dataType",
+      label: "Data Type",
+      description: "Expected data type of the received message value",
+      type: "selection",
+      options: [
+        { value: "int", label: "Integer" },
+        { value: "float", label: "Float" },
+        { value: "bool", label: "Boolean" },
+        { value: "string", label: "String" },
+      ],
+      default: "string",
+    },
+  ],
+};

package/src/node/Node.ts

@@ -1,61 +1,64 @@
-// Domain Node — the base shape every node variant builds on. NodeBase is the
-// generic, untyped-parameters shape used wherever a node is handled generically
-// (e.g. React Flow nodes); NodeData is the discriminated union over the
-// per-variant interfaces (InputNode, AgentNode, …) for strongly-typed work.
-// Mirrors how channel/memory/model keep their base shape in a same-named file and
-// leave index.ts as a pure barrel. The per-variant interfaces import NodeBase
-// from here directly, not via the barrel.
-
-import type { DataType } from "../api";
-import { InputNode, InputNodeType } from "./InputNode";
-import { OutputNode, OutputNodeType } from "./OutputNode";
-import { AgentNode, AgentNodeType } from "./AgentNode";
-import { LogicNode, LogicNodeType } from "./LogicNode";
-import { DataNode, DataNodeType } from "./DataNode";
-import { TriggerNode, TriggerNodeType } from "./TriggerNode";
-import { ToolNode, ToolNodeType } from "./ToolNode";
-import { FunctionCallNode, FunctionCallNodeType } from "./FunctionNode";
-import { MqttNode, MqttNodeType } from "./MqttNode";
-
-export type NodeOutput = { name: string; dataType: DataType };
-export type NodeType =
-  | InputNodeType
-  | OutputNodeType
-  | AgentNodeType
-  | LogicNodeType
-  | DataNodeType
-  | TriggerNodeType
-  | ToolNodeType
-  | FunctionCallNodeType
-  | MqttNodeType;
-
-/**
- * NodeData represents the runtime data for a node in the workflow builder.
- * It is a union type of all specific node types, each with their own typed parameters.
- * Use this type when you need strong typing for a specific node.
- */
-export type NodeData = InputNode | OutputNode | AgentNode | LogicNode | DataNode | TriggerNode | ToolNode | FunctionCallNode | MqttNode;
-
-/**
- * Full domain node entity held on a {@link Canvas}: the {@link NodeData}
- * payload plus its canvas layout position, flattened. id/type/arguments/label
- * come from NodeData; only `position` is added. The editor projects this into
- * a React Flow node (adding the display type) at its store boundary.
- */
-export type Node = NodeData & { position: { x: number; y: number } };
-
-/**
- * NodeBase is a generic interface for all node instances.
- * It uses an untyped parameters record to allow generic parameter handling (e.g., in React Flow nodes).
- * Narrow to NodeData for specific node operations that require typed parameters.
- *
- * Per-output bindings (emit/assign/discard) live as flat entries inside `arguments`,
- * keyed by the output id — same namespace as parameter values. List output entries
- * (e.g. AgentNode's `outputDeclarations`) bundle their binding alongside their variable
- * declaration as OutputDeclaration[].
- */
-export interface NodeBase extends Record<string, unknown> {
-  id: string; // Same as the React Flow node ID
-  type: NodeType; // Node discriminator
-  label?: string; // User-editable display label (falls back to nodeDefinition.label)
-}
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 ForestHub.
+
+// Domain Node — the base shape every node variant builds on. NodeBase is the
+// generic, untyped-parameters shape used wherever a node is handled generically
+// (e.g. React Flow nodes); NodeData is the discriminated union over the
+// per-variant interfaces (InputNode, AgentNode, …) for strongly-typed work.
+// Mirrors how channel/memory/model keep their base shape in a same-named file and
+// leave index.ts as a pure barrel. The per-variant interfaces import NodeBase
+// from here directly, not via the barrel.
+
+import type { DataType } from "../api";
+import { InputNode, InputNodeType } from "./InputNode";
+import { OutputNode, OutputNodeType } from "./OutputNode";
+import { AgentNode, AgentNodeType } from "./AgentNode";
+import { LogicNode, LogicNodeType } from "./LogicNode";
+import { DataNode, DataNodeType } from "./DataNode";
+import { TriggerNode, TriggerNodeType } from "./TriggerNode";
+import { ToolNode, ToolNodeType } from "./ToolNode";
+import { FunctionCallNode, FunctionCallNodeType } from "./FunctionNode";
+import { MqttNode, MqttNodeType } from "./MqttNode";
+
+export type NodeOutput = { name: string; dataType: DataType };
+export type NodeType =
+  | InputNodeType
+  | OutputNodeType
+  | AgentNodeType
+  | LogicNodeType
+  | DataNodeType
+  | TriggerNodeType
+  | ToolNodeType
+  | FunctionCallNodeType
+  | MqttNodeType;
+
+/**
+ * NodeData represents the runtime data for a node in the workflow builder.
+ * It is a union type of all specific node types, each with their own typed parameters.
+ * Use this type when you need strong typing for a specific node.
+ */
+export type NodeData = InputNode | OutputNode | AgentNode | LogicNode | DataNode | TriggerNode | ToolNode | FunctionCallNode | MqttNode;
+
+/**
+ * Full domain node entity held on a {@link Canvas}: the {@link NodeData}
+ * payload plus its canvas layout position, flattened. id/type/arguments/label
+ * come from NodeData; only `position` is added. The editor projects this into
+ * a React Flow node (adding the display type) at its store boundary.
+ */
+export type Node = NodeData & { position: { x: number; y: number } };
+
+/**
+ * NodeBase is a generic interface for all node instances.
+ * It uses an untyped parameters record to allow generic parameter handling (e.g., in React Flow nodes).
+ * Narrow to NodeData for specific node operations that require typed parameters.
+ *
+ * Per-output bindings (emit/assign/discard) live as flat entries inside `arguments`,
+ * keyed by the output id — same namespace as parameter values. List output entries
+ * (e.g. AgentNode's `outputDeclarations`) bundle their binding alongside their variable
+ * declaration as OutputDeclaration[].
+ */
+export interface NodeBase extends Record<string, unknown> {
+  id: string; // Same as the React Flow node ID
+  type: NodeType; // Node discriminator
+  label?: string; // User-editable display label (falls back to nodeDefinition.label)
+}

package/src/node/NodeDefinition.ts

@@ -1,37 +1,40 @@
-import { NodeType } from "./Node";
-import { NodeCategory, NodeTag } from "./constants";
-import { OutputParameter, Parameter } from "../parameter";
-
-/**
- * NodeDefinition describes static class-level node metadata.
- * Methods (getPorts) are optional and take no arguments for static port definitions.
- * Instance-dependent behavior lives in NodeBehavior.ts instead.
- */
-export interface NodeDefinition {
-  type: NodeType; // Node discriminator
-  label: string; // Human-readable, displayed name
-  category: NodeCategory; // Category for grouping (e.g., 'Input', 'Output', 'Logic')
-  description: string; // Description of what the node does
-  parameters: Parameter[]; // Parameter definitions for the node.
-  outputs?: OutputParameter[]; // Declarative output definitions — consumed by getNodeAvailableOutput() to compute a node's outputs
-  tags?: NodeTag[]; // Cross-cutting subsystem labels (Network, Pin, Serial, ...)
-  isUnremovable?: boolean; // Whether the node cannot be added or removed by a user
-  isSingleton?: boolean; // Whether only one instance of this node can exist in a canvas
-  canBranch?: boolean; // Whether the control output port may fan out to multiple branches (tool output ports are always multi-target)
-}
-
-// =============================================================================
-// PORT DEFINITIONS
-// =============================================================================
-
-// Port represents a connectable port of a node
-export interface Port {
-  id: string;
-  type: "control" | "tool";
-  label?: string;
-}
-
-export interface PortDefinitions {
-  input: Port[];
-  output: Port[];
-}
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 ForestHub.
+
+import { NodeType } from "./Node";
+import { NodeCategory, NodeTag } from "./constants";
+import { OutputParameter, Parameter } from "../parameter";
+
+/**
+ * NodeDefinition describes static class-level node metadata.
+ * Methods (getPorts) are optional and take no arguments for static port definitions.
+ * Instance-dependent behavior lives in NodeBehavior.ts instead.
+ */
+export interface NodeDefinition {
+  type: NodeType; // Node discriminator
+  label: string; // Human-readable, displayed name
+  category: NodeCategory; // Category for grouping (e.g., 'Input', 'Output', 'Logic')
+  description: string; // Description of what the node does
+  parameters: Parameter[]; // Parameter definitions for the node.
+  outputs?: OutputParameter[]; // Declarative output definitions — consumed by getNodeAvailableOutput() to compute a node's outputs
+  tags?: NodeTag[]; // Cross-cutting subsystem labels (Network, Pin, Serial, ...)
+  isUnremovable?: boolean; // Whether the node cannot be added or removed by a user
+  isSingleton?: boolean; // Whether only one instance of this node can exist in a canvas
+  canBranch?: boolean; // Whether the control output port may fan out to multiple branches (tool output ports are always multi-target)
+}
+
+// =============================================================================
+// PORT DEFINITIONS
+// =============================================================================
+
+// Port represents a connectable port of a node
+export interface Port {
+  id: string;
+  type: "control" | "tool";
+  label?: string;
+}
+
+export interface PortDefinitions {
+  input: Port[];
+  output: Port[];
+}