@fnet/cli 0.3.8 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fnet/cli",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "files": [
     "dist",
     "template"

package/template/fnet/node/src/default/blocks/parallel.js.njk

@@ -0,0 +1,103 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-modules-header.js.njk" %}
+
+{% for child in childs %}
+  {% if not child.definition.dynamic %}
+    // PARALLEL CHILD: {{child.indexKey}}
+    import {{child.codeKey}} from "./{{child.codeKey}}.js";
+  {% endif %}
+{% endfor %}
+
+export default function Block(context) {
+
+  {% include "src/default/macros/block-body-header.js.njk" %}
+
+  this.run = function () {
+      
+    {% include "src/default/macros/block-entry-args.js.njk" %}
+
+    return new Promise(async (resolve, reject) => {
+                  
+      {% include "src/default/macros/block-run-header.js.njk" %}
+
+      {% include "src/default/macros/page.js.njk" %}
+
+      {% include "src/default/macros/block-modules.js.njk" %}
+
+      // PARALLEL EXECUTION
+      const promises = [];
+
+      {% for child in childs %}
+        {% if child.definition.dynamic %}
+          // PARALLEL CHILD: {{child.indexKey}}
+          const { default: {{child.codeKey}} } = await import("./{{child.codeKey}}.js");
+        {% endif %}
+
+        promises.push((async () => {
+          const current = new {{child.codeKey}}({ parent: _this, engine, flow, caller: c, onError, error });
+
+          {% if workflow.parent.context.atom.doc.features.print_runners %}
+            console.log(new Date().toLocaleString(), ' * ', _this.constructor.IndexKey, ' -> ', current.constructor.IndexKey);
+          {% endif %}
+
+          const nextBlock = Array.isArray(args)
+            ? await current.run.apply(current, args)
+            : await current.run.call(current, args);
+
+          return nextBlock;
+        })());
+      {% endfor %}
+
+      // Execute based on strategy
+      {% set strategy = context.transform.strategy | default('all') %}
+      let results;
+
+      {% if strategy == 'race' %}
+        // Promise.race - first to complete wins
+        results = [await Promise.race(promises)];
+      {% elif strategy == 'any' %}
+        // Promise.any - first successful wins
+        results = [await Promise.any(promises)];
+      {% elif strategy == 'allsettled' %}
+        // Promise.allSettled - all complete, collect results
+        const settled = await Promise.allSettled(promises);
+        results = settled.map(r => r.status === 'fulfilled' ? r.value : null);
+      {% else %}
+        // Promise.all - all must succeed (default)
+        results = await Promise.all(promises);
+      {% endif %}
+
+      // Check if any child returned or jumped
+      for (const result of results) {
+        if (result?.type === 'return') {
+          return resolve(result);
+        }
+        if (result?.type === 'block') {
+          return resolve(result);
+        }
+      }
+
+      {% include "src/default/macros/block-assign.js.njk" %}
+
+      {% include "src/default/macros/block-signal.js.njk" %}
+
+      {% if context.transform.return %}
+        resolve({ type: 'return', value: {{context.transform.return | safe}} });
+      {% elseif context.next %}
+        {% include "src/default/macros/block-next.js.njk" %}
+      {% else %}
+        resolve();
+      {% endif %}
+
+      {% include "src/default/macros/block-run-footer.js.njk" %}
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}
+

package/template/fnet/node/src/default/blocks/pipeline.js.njk

@@ -0,0 +1,146 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-modules-header.js.njk" %}
+
+export default function Block(context){
+
+  {% include "src/default/macros/block-body-header.js.njk" %}
+
+  this.run= function (){
+
+    {% include "src/default/macros/block-entry-args.js.njk" %}
+
+    return new Promise(async (resolve,reject)=>{
+
+      try{
+        {% include "src/default/macros/block-run-header.js.njk" %}
+
+        {% include "src/default/macros/page.js.njk" %}
+
+        {% include "src/default/macros/block-modules.js.njk" %}
+
+        // PIPELINE EXECUTION
+        const { spawn } = await import('child_process');
+
+        const pipelineBinary = '{{ context.binaryName }}';
+        {% if context.transform.args %}
+        const pipelineArgs = {{ context.transform.args | safe }};
+        {% else %}
+        const pipelineArgs = [];
+        {% endif %}
+
+        {% if context.transform.input %}
+        const pipelineInput = {{ context.transform.input | safe }};
+        {% else %}
+        const pipelineInput = null;
+        {% endif %}
+
+        const pipelineFormat = '{{ context.format }}';
+
+        {% if context.transform.env %}
+        const pipelineEnv = {{ context.transform.env | safe }};
+        {% else %}
+        const pipelineEnv = {};
+        {% endif %}
+
+        {% if context.transform.cwd %}
+        const pipelineCwd = {{ context.transform.cwd | safe }};
+        {% else %}
+        const pipelineCwd = undefined;
+        {% endif %}
+
+        const result = await new Promise((pipelineResolve, pipelineReject) => {
+          const spawnOptions = {
+            env: { ...process.env, ...pipelineEnv },
+            stdio: ['pipe', 'pipe', 'pipe']  // stdin, stdout, stderr as pipes (don't inherit parent)
+          };
+
+          if (pipelineCwd) {
+            spawnOptions.cwd = pipelineCwd;
+          }
+
+          const proc = spawn(pipelineBinary, pipelineArgs, spawnOptions);
+
+          let stdout = '';
+          let stderr = '';
+
+          proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+          });
+
+          proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+          });
+
+          proc.on('error', (error) => {
+            pipelineReject(new Error(`Failed to execute pipeline '${pipelineBinary}': ${error.message}`));
+          });
+
+          proc.on('close', (code) => {
+            if (code !== 0) {
+              pipelineReject(new Error(`Pipeline '${pipelineBinary}' exited with code ${code}: ${stderr}`));
+              return;
+            }
+
+            // Parse output based on format
+            if (pipelineFormat === 'text') {
+              // Text format: return as-is
+              pipelineResolve(stdout.trim());
+            } else {
+              // JSON format (default): parse
+              try {
+                const result = JSON.parse(stdout.trim());
+                pipelineResolve(result);
+              } catch (error) {
+                pipelineReject(new Error(`Failed to parse pipeline output as JSON: ${error.message}`));
+              }
+            }
+          });
+
+          // Write input based on type (auto-detect)
+          if (pipelineInput !== null && pipelineInput !== undefined) {
+            if (typeof pipelineInput === 'object') {
+              // Object/Array → JSON
+              proc.stdin.write(JSON.stringify(pipelineInput) + '\n');
+            } else if (typeof pipelineInput === 'string') {
+              // String → as-is (text)
+              proc.stdin.write(pipelineInput + '\n');
+            } else {
+              // Other types → JSON
+              proc.stdin.write(JSON.stringify(pipelineInput) + '\n');
+            }
+          }
+          proc.stdin.end();
+        });
+
+        {% if context.transform.result %}
+        flow.set('{{ context.transform.result }}', result);
+        {% endif %}
+
+        {% include "src/default/macros/block-assign.js.njk" %}
+
+        {% include "src/default/macros/block-signal.js.njk" %}
+
+        {% if context.transform.return %}
+          resolve({type:'return',value: {{context.transform.return | safe}}});
+        {% elseif context.next %}
+          {% include "src/default/macros/block-next.js.njk" %}
+        {% else %}
+          resolve();
+        {% endif %}
+
+        {% include "src/default/macros/block-run-footer.js.njk" %}
+      }
+      catch(error){
+          onError? onError(error) : reject(error);
+      }
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}
+