@fnet/cli 0.5.1 → 0.5.2

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

@@ -0,0 +1,109 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+{% set result=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+  // PIPELINE EXECUTION
+  const { spawn } = await import('child_process');
+
+  const pipelineBinary = '{{ context.transform.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.transform.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();
+  });
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,15 @@
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+  const raise = {{context.transform.raise | safe}};
+
+  reject(new Error(raise?.message||raise||"Unknown error"));
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,70 @@
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+  {% for child in childs %}
+    {% if not child.definition.dynamic %}
+      // RETRYABLE CHILD: {{child.indexKey}}
+      import {{child.codeKey}} from "./{{child.codeKey}}.js";
+    {% endif %}
+  {% endfor %}
+{% endcall %}
+
+{% call block.definition() %}
+  // Retry configuration (always an object)
+  const attempts = {{ context.transform.retry.attempts }};
+  const initialDelay = {{ context.transform.retry.delay }};
+  const backoff = "{{ context.transform.retry.backoff }}";
+  const maxDelay = {% if context.transform.retry.maxDelay %}{{ context.transform.retry.maxDelay }}{% else %}null{% endif %};
+
+  {% if childs[0] %}
+  // Create child block instance
+  const retryableBlock = new {{childs[0].codeKey}}({
+    parent: _this,
+    engine: engine,
+    flow: flow
+  });
+
+  // Retry logic with backoff
+  let lastError;
+  let currentDelay = initialDelay;
+
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      // Execute child block
+      await retryableBlock.run();
+
+      // Success! Break out of retry loop
+      break;
+    } catch (error) {
+      lastError = error;
+
+      // Last attempt failed - throw error
+      if (attempt === attempts) {
+        throw new Error(`Retry failed after ${attempts} attempts: ${error.message}`);
+      }
+
+      // Wait before retry
+      await new Promise(resolve => setTimeout(resolve, currentDelay));
+
+      // Calculate next delay based on backoff strategy
+      if (backoff === 'exponential') {
+        currentDelay = currentDelay * 2;
+      } else if (backoff === 'linear') {
+        currentDelay = currentDelay + initialDelay;
+      }
+      // 'fixed' keeps currentDelay unchanged
+
+      // Apply maxDelay cap if specified
+      if (maxDelay && currentDelay > maxDelay) {
+        currentDelay = maxDelay;
+      }
+    }
+  }
+  {% endif %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,21 @@
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+  {% include "src/default/macros/block-assign.js.njk" %}
+  
+  {% include "src/default/macros/block-signal.js.njk" %}
+
+  const value = {{context.transform.return | safe}};
+
+  flow.result={value: value};
+
+  resolve({type:'return',value: value});
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,66 @@
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+  {% for child in childs %}
+    {% if not child.definition.dynamic %}
+      // SCHEDULED CHILD: {{child.indexKey}}
+      import {{child.codeKey}} from "./{{child.codeKey}}.js";
+    {% endif %}
+  {% endfor %}
+{% endcall %}
+
+{% call block.definition() %}
+  // Import node-cron for scheduling
+  const cron = await import('node-cron');
+
+  // Schedule configuration
+  const cronExpression = {{ context.transform.schedule.cron | safe }};
+  const timezone = {{ context.transform.schedule.timezone | dump | safe }};
+  const enabled = {{ context.transform.schedule.enabled | dump | safe }};
+
+  // Check if schedule is enabled
+  if (!enabled) {
+    // Schedule is disabled, skip to next block
+    {% include "src/default/macros/block-next.js.njk" %}
+    return;
+  }
+
+  // Validate cron expression
+  if (!cron.validate(cronExpression)) {
+    reject(new Error(`Invalid cron expression: ${cronExpression}`));
+    return;
+  }
+
+  // Get child block (the scheduled task)
+  {% if childs[0] %}
+  const scheduledTask = new {{childs[0].codeKey}}({
+    parent: _this,
+    engine: engine,
+    flow: flow
+  });
+  {% endif %}
+
+  // Schedule the task with optional timezone
+  const scheduleOptions = timezone ? { timezone } : {};
+  const task = cron.schedule(cronExpression, async () => {
+    try {
+      {% if childs[0] %}
+      await scheduledTask.run();
+      {% endif %}
+    } catch (error) {
+      console.error(`Scheduled task '{{indexKey}}' failed:`, error);
+    }
+  }, scheduleOptions);
+
+  // Start the scheduled task
+  task.start();
+
+  // Store task reference for potential cleanup
+  flow.set('{{indexKey}}_task', task);
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,15 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,47 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+
+  {% if context.next %}
+
+    // NEXT : {{context.next.indexKey}}
+    {% if context.next.definition.dynamic %}
+      const { default: {{context.next.codeKey}} } = await import("./{{context.next.codeKey}}.js");
+    {% endif %}
+
+    let current=new {{context.next.codeKey}}({ parent:_this, engine, flow, caller:c , error });
+    let currentArgs=args;
+
+    do {
+
+      {% if workflow.parent.context.atom.doc.features.print_runners %}
+        console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+      {% endif %}
+
+      const nextBlock= typeof currentArgs==='undefined'? await current.run()
+        : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+
+      if(nextBlock?.type==='return') return resolve(nextBlock);
+      else if(nextBlock?.type!=='block') break;
+
+      if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+        return resolve(nextBlock);
+
+      current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, error });
+      currentArgs=nextBlock.input;
+
+    } while(true);
+
+  {% endif %}
+  
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,49 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+
+  {% for child in childs %}
+    {% if not child.definition.dynamic %}
+      // CHILD: {{child.indexKey}}
+      import {{child.codeKey}} from "./{{child.codeKey}}.js";
+    {% endif %}
+  {% endfor%}
+
+{% endcall %}
+
+{% call block.definition() %}
+  
+  {% for child in childs %}
+    {% if loop.first %}
+      if ({{child.context.transform.condition | safe}}) 
+    {% else %}
+      {%if child.context.transform.condition %}
+        else if ({{child.context.transform.condition | safe}}) 
+      {% else %}
+        else
+      {% endif %}
+    {% endif %} 
+      {
+        {% if child.definition.dynamic %}
+          // CHILD: {{child.indexKey}}
+          const { default: {{child.codeKey}} } = await import("./{{child.codeKey}}.js");
+        {% endif %}
+
+        const current=new {{child.codeKey}}({ parent:_this, engine, flow, caller:c, error });
+
+        {% if workflow.parent.context.atom.doc.features.print_runners %}
+          console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+        {% endif %}
+
+        return resolve(Array.isArray(args)? await current.run.apply(current,args) : await current.run.call(current,args));
+      }
+  {% endfor%}
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,80 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+  {% for child in childs %}
+    {% if not child.definition.dynamic %}
+      // CHILD: {{child.indexKey}}
+      import {{child.codeKey}} from "./{{child.codeKey}}.js";
+    {% endif %}
+  {% endfor%}
+{% endcall %}
+
+{% call block.definition() %}
+  
+  try{
+
+    {% if context.try.definition.dynamic %}
+      const { default: {{context.try.codeKey}} } = await import("./{{context.try.codeKey}}.js");
+    {% endif %}
+
+    let current=new {{context.try.codeKey}}({ parent:_this, engine, flow, caller:c, error });
+    let currentArgs=args;
+
+    do {
+
+      {% if workflow.parent.context.atom.doc.features.print_runners %}
+        console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+      {% endif %}
+
+      const nextBlock= typeof currentArgs==='undefined'? await current.run()
+        : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+
+      if(nextBlock?.type==='return') return resolve(nextBlock);
+      else if(nextBlock?.type!=='block') break;
+
+      if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+        return resolve(nextBlock);
+
+      current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, error });
+      currentArgs=nextBlock.input;
+
+    } while(true);            
+  }
+  catch(error){
+
+    {% if context.except.definition.dynamic %}
+      const { default: {{context.except.codeKey}} } = await import("./{{context.except.codeKey}}.js");
+    {% endif %}
+
+    let current=new {{context.except.codeKey}}({ parent:_this, engine, flow, caller:c , error });
+    let currentArgs=args;
+
+    do {
+
+      {% if workflow.parent.context.atom.doc.features.print_runners %}
+        console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+      {% endif %}
+
+      const nextBlock= typeof currentArgs==='undefined'? await current.run()
+        : Array.isArray(currentArgs)? await current.run.apply(current,currentArgs) : await current.run.call(current, currentArgs) ;
+
+      if(nextBlock?.type==='return') return resolve(nextBlock);
+      else if(nextBlock?.type!=='block') break;
+
+      if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+        return resolve(nextBlock);
+
+      current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, error });
+      currentArgs=nextBlock.input;
+
+    } while(true);
+  }
+
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

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

@@ -0,0 +1,14 @@
+{% set assign=true %}
+{% set signal=true %}
+{% set resolve=true %}
+
+{% import "src/default/types/block.js.njk" as block with context %}
+
+{% call block.header() %}
+{% endcall %}
+
+{% call block.definition() %}
+{% endcall %}
+
+{% call block.footer()%} 
+{% endcall %}

package/template/fnet/node/src/default/engine.js.njk

@@ -0,0 +1,79 @@
+import Object from "../core/object.js";
+
+import { default as Workflow } from "./{{flow.codeKey}}.js";
+
+{% set form_enabled = false if flow.name === 'cli' else flow.parent.context.atom.doc.features.form_enabled %}
+
+{% set form_enabled = false if flow.definition.features.server === true else form_enabled %}
+
+{% if form_enabled %}
+import { App } from "{{ui.package}}";
+{% endif %}
+
+export default class Engine extends Object {
+
+    #main;
+    {% if form_enabled %}
+    #app;
+    #appOwner;
+    {% endif %}
+
+    constructor(context) {
+        super(context);
+
+        this.#main = new Workflow({ engine: this });
+
+        {% if form_enabled %}   
+        this.#app =context?.app || new App();
+        this.#appOwner = !!context?.app;
+        {% endif %}
+    }
+
+    async #init(context) {
+        {% if form_enabled %}
+        await this.#initApp(context);
+        {% endif %}
+    }
+
+    {% if form_enabled %}
+    
+    async #initApp(context) {
+        const container = context.params?.container;
+        await this.#app.init({ container });
+    }
+    
+    async setActiveForm(context) {
+        const form = context.form;
+        const props = context.props;
+
+        await this.#app.setActiveForm({form,props});
+    }
+
+    get app(){
+        return this.#app;
+    }
+
+    {% endif %}
+    
+    // Main entry function to run workflow
+    async run(params) {
+
+        {% if flow.parent.context.atom.doc.features.print_steps %}
+        console.log(new Date().toLocaleString(),'{{ flow.parent.context.atom.doc.title or flow.parent.context.atom.doc.name }}');
+        {% endif %}
+
+        await this.#init({ params });
+
+        const response = await this.#main.run({ params });
+
+        return response?.value;
+    }
+
+    async destroy() {
+        {% if form_enabled %}
+        if (this.#appOwner) {
+            await this.#app.destroy();
+        }
+        {% endif %}
+    }
+}

package/template/fnet/node/src/default/input.args.js.njk

@@ -0,0 +1,125 @@
+{% if atom.doc.features.project.format === 'esm' %}
+  import fnetArgs,{argsParser} from '@fnet/args';
+  import validate,{schema as inputSchema} from "./validate_input.js";
+
+{% elif atom.doc.features.project.format === 'cjs' %}
+  const {default:fnetArgs,argsParser} = require('@fnet/args');
+  const validate,{schema as inputSchema} = require("./validate_input.js");
+{% endif %}
+
+{% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}
+
+  const get_fargs = (argv) => {
+    const fargsIndex = argv.indexOf('--fargs');
+    if (fargsIndex !== -1 && argv[fargsIndex + 1]) return argv[fargsIndex + 1];
+    {% if atom.doc.features.cli.fargs.default %}
+    else return "{{atom.doc.features.cli.fargs.default}}";
+    {% endif %}
+  };
+
+  const get_ftags = (argv) => {
+    const ftags = [];
+    for (let i = 0; i < argv.length; i++) {
+      if (argv[i] === '--ftag' && argv[i + 1]) {
+        ftags.push(argv[i + 1]);
+        i++;
+      }
+    }
+    
+    {% if atom.doc.features.cli.fargs.tags %}
+      return ftags.length > 0 ? ftags : {{atom.doc.features.cli.fargs.tags | dump | safe}};
+    {% else %}
+      return ftags.length > 0 ? ftags : undefined;
+    {% endif %}
+  };
+
+{% endif %}
+
+{% if atom.doc.features.project.format === 'esm' %}
+
+  export default async () => {
+
+    let schema = inputSchema;
+    let initial;
+
+    {% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}    
+    const fargs = get_fargs(process.argv.slice(2));
+    const ftags = get_ftags(process.argv.slice(2));
+
+    if (fargs) {
+      const { default: fnetConfig } = await import("@fnet/config");
+      const config = await fnetConfig({ name: fargs, tags: ftags });
+      if (config?.data) {
+        initial=config.data;
+      }
+    }
+    {% endif %}
+
+    const packageCallback = async () => {
+      const { default: url } = await import("node:url");
+      const { default: path } = await import("node:path");
+      const { default: fs } = await import("node:fs");
+      let currentDir = path.dirname(url.fileURLToPath(import.meta.url));
+      let firstPackageJson = path.join(currentDir, "package.json");
+      while (currentDir !== path.parse(currentDir).root && !fs.existsSync(firstPackageJson)) {
+        currentDir = path.dirname(currentDir);
+        firstPackageJson = path.join(currentDir, "package.json");
+      }
+      if (!fs.existsSync(firstPackageJson)) return {
+        name: "Unknown",
+        version: "Unknown"
+      }
+      else return await JSON.parse(fs.readFileSync(firstPackageJson, "utf8"));
+    };
+
+    return await fnetArgs({schema,initial,validate,packageCallback});
+  };
+
+  export { argsParser };
+{% elif atom.doc.features.project.format === 'cjs' %}
+
+  module.exports = async () => {
+
+    let schema = inputSchema;
+    let initial;
+
+    {% if atom.doc.features.cli.fargs and atom.doc.features.cli.fargs?.enabled !== false %}    
+    const fargs = get_fargs(process.argv.slice(2));
+    const ftags = get_ftags(process.argv.slice(2));
+
+    if (fargs) {
+      const { default: fnetConfig } = await import("@fnet/config");
+      const config = await fnetConfig({ name: fargs, tags: ftags });
+      if (config?.data) {
+        initial=config.data;
+      }
+    }
+    {% endif %}
+
+    const packageCallback = async () => {
+      const path = require("node:path");
+      const fs = require("node:fs");
+
+      let currentDir = __dirname;
+      let firstPackageJson = path.join(currentDir, "package.json");
+
+      while (currentDir !== path.parse(currentDir).root && !fs.existsSync(firstPackageJson)) {
+        currentDir = path.dirname(currentDir);
+        firstPackageJson = path.join(currentDir, "package.json");
+      }
+
+      if (!fs.existsSync(firstPackageJson)) {
+        return {
+          name: "Unknown",
+          version: "Unknown"
+        };
+      } else {
+        return JSON.parse(fs.readFileSync(firstPackageJson, "utf8"));
+      }
+    };
+
+    return await fnetArgs({schema,initial,validate,packageCallback});
+  };
+
+  module.exports.argsParser = argsParser;
+{% endif %}