Add execution ports to random-stream random-number and stream-cache

nodes/random-number@v1.go

@@ -14,25 +14,26 @@ var randomNumberNodeDefinition string
 
 type RandomNumberNode struct {
 	core.NodeBaseComponent
+	core.Executions
 	core.Inputs
 	core.Outputs
 
 	randGenLock sync.Mutex
 	randGen     *rand.Rand
 }
 
-func (n *RandomNumberNode) OutputValueById(c *core.ExecutionState, outputId core.OutputId) (any, error) {
+func (n *RandomNumberNode) ExecuteImpl(c *core.ExecutionState, inputId core.InputId, prevError error) error {
 	min, err := core.InputValueById[float64](c, n, ni.Core_random_number_v1_Input_min)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	max, err := core.InputValueById[float64](c, n, ni.Core_random_number_v1_Input_max)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	seed, err := core.InputValueById[int64](c, n, ni.Core_random_number_v1_Input_seed)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	if seed == -1 {
@@ -48,7 +49,13 @@ func (n *RandomNumberNode) OutputValueById(c *core.ExecutionState, outputId core
 	n.randGenLock.Unlock()
 
 	randomNumber := min + f*(max-min)
-	return randomNumber, nil
+
+	err = n.SetOutputValue(c, ni.Core_random_number_v1_Output_number, randomNumber, core.SetOutputValueOpts{})
+	if err != nil {
+		return err
+	}
+
+	return n.Execute(ni.Core_random_number_v1_Output_exec_success, c, nil)
 }
 
 func init() {

nodes/random-number@v1.yml

@@ -12,27 +12,37 @@ style:
     background: "#7c6652"
 short_desc: Generates a random number based on user-defined range and seed. Can be used as well for boolean values by setting the minimum and maximum values to 0 and 1 respectively.
 outputs:
+  exec-success:
+    name: ''
+    exec: true
+    index: 0
+    desc: Triggered when the random number is generated.
   number:
     type: number
     name: Random Number
     desc: The generated random number
-    index: 0
+    index: 1
 inputs:
+  exec:
+    exec: true
+    index: 0
+    name: ''
+    desc: Triggers the generation of the random number.
   min:
     type: number
     name: Minimum Value
     desc: The minimum value of the random number
-    index: 0
+    index: 1
     initial: 0.0
   max:
     type: number
     name: Maximum Value
     desc: The maximum value of the random number
-    index: 1
+    index: 2
     initial: 1.0
   seed:
     type: number
     name: Seed
     desc: The seed for the random number generator (-1 for true randomness)
-    index: 2
-    initial: -1
+    index: 3
+    initial: -1

nodes/random-stream@v1.go

@@ -18,6 +18,7 @@ var randomStreamNodeDefinition string
 
 type RandomStreamNode struct {
 	core.NodeBaseComponent
+	core.Executions
 	core.Inputs
 	core.Outputs
 }
@@ -93,37 +94,44 @@ func (r *RandomStreamReader) Read(p []byte) (n int, err error) {
 	return len(p), nil
 }
 
-func (n *RandomStreamNode) OutputValueById(c *core.ExecutionState, outputId core.OutputId) (any, error) {
+func (n *RandomStreamNode) ExecuteImpl(c *core.ExecutionState, inputId core.InputId, prevError error) error {
 	length, err := core.InputValueById[int](c, n, ni.Core_random_stream_v1_Input_length)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	includeNumbers, err := core.InputValueById[bool](c, n, ni.Core_random_stream_v1_Input_include_numbers)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	includeCharacters, err := core.InputValueById[bool](c, n, ni.Core_random_stream_v1_Input_include_characters)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	includeUppercase, err := core.InputValueById[bool](c, n, ni.Core_random_stream_v1_Input_include_uppercase)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	includeSpecial, err := core.InputValueById[bool](c, n, ni.Core_random_stream_v1_Input_include_special)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	seed, err := core.InputValueById[int64](c, n, ni.Core_random_stream_v1_Input_seed)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	reader := NewRandomStringReader(length, includeNumbers, includeCharacters, includeUppercase, includeSpecial, seed)
-	return core.DataStreamFactory{
+	outputStream := core.DataStreamFactory{
 		Reader: reader,
 		Length: core.GetReaderLength(reader),
-	}, nil
+	}
+
+	err = n.SetOutputValue(c, ni.Core_random_stream_v1_Output_stream, outputStream, core.SetOutputValueOpts{})
+	if err != nil {
+		return err
+	}
+
+	return n.Execute(ni.Core_random_stream_v1_Output_exec_success, c, nil)
 }
 
 func init() {

nodes/random-stream@v1.yml

@@ -12,41 +12,51 @@ style:
     background: "#7c6652"
 short_desc: Creates a random stream based on user-defined character set preferences.
 outputs:
+  exec-success:
+    name: ''
+    exec: true
+    index: 0
+    desc: Triggered when the stream is successfully created.
   stream:
     type: stream
     name: Random Stream
     desc: The generated random stream
-    index: 0
+    index: 1
 inputs:
+  exec:
+    exec: true
+    index: 0
+    name: ''
+    desc: Triggers the generation of the stream.
   length:
     type: number
     name: Length
     desc: The length of the stream.
-    index: 0
+    index: 1
     initial: 10
   include_numbers:
     type: bool
     name: Numbers
     desc: Include numbers (0-9) in the stream.
-    index: 1
+    index: 2
   include_characters:
     type: bool
     name: Characters
     desc: Include lower-case characters (a-z) in the stream.
-    index: 2
+    index: 3
     initial: true
   include_uppercase:
     type: bool
     name: Upper-case Characters
     desc: Include upper-case characters (A-Z) in the stream.
-    index: 3
+    index: 4
   include_special:
     type: bool
     name: Special Characters
     desc: Include special characters (!@#$%^&*() etc.) in the stream.
-    index: 4
+    index: 5
   seed:
     type: number
     name: Seed
     desc: The seed for the random number generator (-1 for true randomness)
-    index: 5
+    index: 6

nodes/stream-cache@v1.go

@@ -14,23 +14,34 @@ var streamCacheNodeDefinition string
 
 type StreamCacheNode struct {
 	core.NodeBaseComponent
+	core.Executions
 	core.Inputs
 	core.Outputs
 }
 
-func (n *StreamCacheNode) OutputValueById(c *core.ExecutionState, outputId core.OutputId) (any, error) {
+func (n *StreamCacheNode) ExecuteImpl(c *core.ExecutionState, inputId core.InputId, prevError error) error {
 	inputStream, err := core.InputValueById[io.Reader](c, n, ni.Core_stream_cache_v1_Input_stream)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	buffer := new(bytes.Buffer)
 	_, err = io.Copy(buffer, inputStream)
 	if err != nil {
-		return nil, core.CreateErr(c, err, "failed to read input stream")
+		return core.CreateErr(c, err, "failed to read input stream")
 	}
 
-	return buffer.String(), nil
+	err = n.SetOutputValue(c, ni.Core_stream_cache_v1_Output_result, buffer.String(), core.SetOutputValueOpts{})
+	if err != nil {
+		return err
+	}
+
+	err = n.Execute(ni.Core_stream_cache_v1_Output_exec_success, c, nil)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func init() {

nodes/stream-cache@v1.yml

@@ -14,13 +14,20 @@ style:
 short_desc: Cache a stream and output it as a string.
 long_desc: Like the [File Read](./../file-read/v1.md) node, some streams are readable only by a single consumer. This node caches the stream and outputs it as a string, which can be used by multiple consumers.
 outputs:
+  exec-success:
+    name:
+    exec: true
+    index: 0
   result:
     type: string
     desc: The cached stream as a string.
-    index: 0
+    index: 1
 inputs:
+  exec:
+    exec: true
+    index: 0
   stream:
     type: stream
     desc: The input stream to be cached.
-    index: 0
+    index: 1
     required: true