@fnet/cli 0.111.0 → 0.111.2

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

@@ -0,0 +1,65 @@
+
+{% 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 %}
+    // CHILD: {{child.indexKey}}
+    import {{child.codeKey}} from "./{{child.codeKey}}";
+  {% endif %}
+{% endfor%}
+
+export default function Block(context) {
+
+  {% include "src/default/macros/block-body-header.js.njk" %}
+
+  this.run= function (){
+      
+    const args=Array.from(arguments);
+
+    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" %}
+        
+        try{
+            
+          {% if context.try.definition.dynamic %}
+              const { default: {{context.try.codeKey}} } = await import("./{{context.try.codeKey}}");
+          {% endif %}
+          
+          const current=new {{context.try.codeKey}}({ parent:_this, engine, flow, caller:c });
+
+          {% if workflow.parent.context.atom.doc.features.print_runners %}
+            console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+          {% endif %}
+
+          return resolve(await current.run.apply(current,args));
+        }
+        catch({{context.except.context.transform.as | safe}}){
+            
+          {% if context.except.definition.dynamic %}
+              const { default: {{context.except.codeKey}} } = await import("./{{context.except.codeKey}}");
+          {% endif %}
+
+          const current=new {{context.except.codeKey}}({ parent:_this, engine, flow, caller:c });
+
+          {% if workflow.parent.context.atom.doc.features.print_runners %}
+            console.log(new Date().toLocaleString(),' * ',_this.constructor.IndexKey,' -> ',current.constructor.IndexKey);
+          {% endif %}
+
+          return resolve(await current.run.apply(current,args));
+        }
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,79 @@
+import Object from "../core/object";
+
+import { default as Workflow } from "./{{flow.codeKey}}";
+
+{% 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/bun/src/default/macros/block-body-header.js.njk

@@ -0,0 +1,7 @@
+if (this.constructor !== Block) throw Error(Message.USE_CONSTRUCTOR);
+
+this.context=context;
+
+const { engine, flow, caller }=context || {};
+
+const _this=this;

package/template/fnet/bun/src/default/macros/block-footer.js.njk

@@ -0,0 +1,3 @@
+Block.TypeId="{{ typeId }}";
+Block.ParentTypeId="{{ parent.typeId }}";
+Block.IndexKey="{{ indexKey }}";

package/template/fnet/bun/src/default/macros/block-header.js.njk

@@ -0,0 +1,14 @@
+// BLOCK: {{indexKey}}
+
+import Message from "../../core/message";
+{% if context.transform.print %}
+import print from "../../core/print";
+{% endif %}
+
+{% if context.transform.sleep %}
+import sleep from "../../core/sleep";
+{% endif %}
+
+{% if context.transform.assert %}
+import assert from "../../core/assert";
+{% endif %}

package/template/fnet/bun/src/default/macros/block-library-header.js.njk

@@ -0,0 +1,19 @@
+{% if context.lib.type==='atom'%}
+  // LIBRARY: {{context.lib.atom.name}}
+  {% if context.lib.atom.relativePath %}
+    {% if context.transform.import %}
+      import { {{ context.transform.call | safe  }} as LIBRARY } from "{{context.lib.atom.relativePath}}";
+    {% else %}
+      import { default as LIBRARY } from "{{context.lib.atom.relativePath}}";
+    {% endif %}
+  {% else %}
+    {% if context.transform.import %}
+      import { {{ context.transform.call | safe }} as LIBRARY } from "../../libs/{{context.lib.atom.id or context.lib.atom.name}}";
+    {% else %}
+      import { default as LIBRARY } from "../../libs/{{context.lib.atom.id or context.lib.atom.name}}";
+    {% endif %}  
+  {% endif %}
+{% elseif context.lib.type==='subworkflow' %}
+  // LIBRARY: {{context.lib.indexKey}}
+  import { default as {{context.lib.codeKey}} } from "../{{context.lib.codeKey}}";
+{% endif %}

package/template/fnet/bun/src/default/macros/block-modules-header.js.njk

@@ -0,0 +1,8 @@
+{% for child in childs %}
+  {% if child.module===true%}
+    {% if not child.definition.dynamic %}
+    // MODULE : {{child.indexKey}}
+    import { default as {{child.codeKey}} } from "./{{child.codeKey}}";
+    {% endif %}
+  {% endif %}
+{% endfor%}

package/template/fnet/bun/src/default/macros/block-modules.js.njk

@@ -0,0 +1,29 @@
+{% for child in childs %}
+
+  {% if child.module===true%}
+
+    // MODULE : {{child.indexKey}}
+    {% if child.definition.dynamic %}
+      const { default: {{child.codeKey}} } = await import("./{{child.codeKey}}");
+    {% endif %}
+
+    m['{{child.name}}']=async function(){
+      const entry=new {{child.codeKey}}({engine,flow,parent:_this,caller:c,module:true});
+      const nextBlock=await entry.run.apply(entry,arguments);
+
+      if(nextBlock?.type==='return') return nextBlock.value;
+      else if(nextBlock?.type==='block') {
+        {% if workflow.parent.context.atom.doc.features.print_module_final_next %}
+          console.log('MODULE FINAL NEXT:',nextBlock);
+        {% endif %}
+        resolve(nextBlock);
+      }
+    }
+    
+    {% if child.context.transform.export %}
+      flow.setModule({{child.context.transform.export | safe}}, m['{{child.name}}']);
+    {% endif %}
+
+  {% endif %}
+
+{% endfor%}

package/template/fnet/bun/src/default/macros/block-next-header.js.njk

@@ -0,0 +1,6 @@
+{% if context.next %}
+  {% if not context.next.definition.dynamic %}
+    // NEXT : {{context.next.indexKey}}
+    import { default as {{context.next.codeKey}} } from "./{{context.next.codeKey}}";
+  {% endif %}
+{% endif %}

package/template/fnet/bun/src/default/macros/block-next.js.njk

@@ -0,0 +1,20 @@
+{% if context.next %}
+
+  // NEXT : {{context.next.indexKey}}
+  {% if context.next.definition.dynamic %}
+    const { default: {{context.next.codeKey}} } = await import("./{{context.next.codeKey}}");
+  {% endif %}
+
+
+return resolve ({
+    type: 'block',
+    from: _this,
+    fromType: _this.constructor,
+    fromClosure: c,
+    toType:{{context.next.codeKey}},
+    {% if context.transform.nextArgs %}
+    withArgs: {{context.transform.nextArgs | safe}},
+    {% endif %}
+});
+
+{% endif %}

package/template/fnet/bun/src/default/macros/block-run-form.js.njk

@@ -0,0 +1,32 @@
+{% if context.transform.props %}
+  const formProps ={{context.transform.props | safe}} ;
+{% else %}
+  const formProps={};
+{% endif %}
+
+function actionClick(){
+  flow.continueForNext({key:'{{indexKey}}'});
+}
+
+formProps.form=form;
+
+formProps.actionClick=actionClick;
+
+function Form(){
+  React.useEffect(()=>{
+
+    {% if workflow.parent.context.atom.doc.features.print_form_mounts %}
+      console.log('MOUNT:','{{indexKey}}');
+    {% endif %}
+
+    return ()=>{
+      {% if workflow.parent.context.atom.doc.features.print_form_mounts %}
+        console.log('UNMOUNT:','{{indexKey}}');
+      {% endif %}
+    }
+  },[]);
+  
+  return React.createElement(formLib,formProps);
+}
+
+engine.setActiveForm({ form: Form, props:formProps });

package/template/fnet/bun/src/default/macros/block-run-header.js.njk

@@ -0,0 +1,39 @@
+{# variables #}
+const v=flow.get();
+
+{# module #}
+{% if hasModules %}
+const m={};
+{% else %}
+const m = null;
+{% endif %}
+
+{# form #}
+{% if type === 'form' %}
+const form={};
+{% else %}
+const form=null;
+{% endif %}
+
+{# closure #}
+const c={ caller, resolve, reject, args, get form(){return form||caller?.form}, get module(){return m||caller?.module} };
+
+{% if workflow.parent.context.atom.doc.features.print_steps %}
+console.log(new Date().toLocaleString(),'{{indexKey}}');
+{% endif %}
+
+{% if definition.debugger %}
+debugger;
+{% endif %}
+
+{% if context.transform.print %}
+print({{context.transform.print | safe}});
+{% endif%}
+
+{% if context.transform.assert %}
+assert({{context.transform.assert | safe}});
+{% endif%}
+
+{% if context.transform.sleep %}
+await sleep({{context.transform.sleep}});
+{% endif %}

package/template/fnet/bun/src/default/macros/page.js.njk

@@ -0,0 +1,8 @@
+{% if context.transform.page %}
+    const page= {{context.transform.page | safe}};
+    
+    {% if definition.page.title %}
+        document? document.title=page.title:undefined;
+    {% endif %}
+    
+{% endif %}

package/template/fnet/bun/src/default/macros/workflow-header.js.njk

@@ -0,0 +1,7 @@
+// WORKFLOW: {{ indexKey }}
+
+import Object from "../core/object";
+
+{% if context.transform.print %}
+import print from "../core/print";
+{% endif %}

package/template/fnet/bun/src/default/to.args.js.njk

@@ -0,0 +1,120 @@
+{% if atom.doc.features.project.format === 'esm' %}
+  import fnetArgs from '@fnet/args';
+  import validate from "./validate_input";
+{% elif atom.doc.features.project.format === 'cjs' %}
+  const fnetArgs = require('@fnet/args');
+  const validate = require("./validate_input");
+{% 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 = {{options | dump | safe}};
+    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});
+  };
+
+{% elif atom.doc.features.project.format === 'cjs' %}
+
+  module.exports = async () => {
+    let schema = {{options | dump | safe}};
+    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});
+  };
+{% endif %}

package/template/fnet/bun/src/default/workflow.js.njk

@@ -0,0 +1,117 @@
+{% include "src/default/macros/workflow-header.js.njk" %}
+
+{% if context.next %}
+  {% if not context.next.definition.dynamic %}
+    // NEXT: {{context.next.indexKey}}
+    import {{context.next.codeKey}} from "./blocks/{{context.next.codeKey}}";
+  {% endif %}
+{% endif %}
+
+export default class Workflow extends Object {
+
+  #waitContext;
+
+  constructor(context) {
+    super(context);
+
+    this.engine=context.engine;
+  }
+
+  async init(context) {
+
+    {% if context.transform.params %}
+      const params = context?.params;
+      
+      {% for param in context.transform.params %}
+        {% if param.hasDefault%}
+          {% if param.type ==='string'%}
+            this.set('{{param.key}}',  params?.hasOwnProperty('{{param.key}}')? params['{{param.key}}']:'{{param.default}}');
+          {% else %}
+            this.set('{{param.key}}',  params?.hasOwnProperty('{{param.key}}')? params['{{param.key}}']:{{param.default | dump}});
+          {% endif %}
+        {% else %}
+        this.set('{{param.key}}',this.getValue(params,'{{param.key}}'));
+        {% endif %}
+      {% endfor%}
+
+      this.set('$params',params);
+
+    {% endif %}
+  }
+
+  waitForNext(context){
+    this.#waitContext=context;
+  }
+    
+  async continueForNext(context){
+    const next=this.#waitContext?.next;
+    this.#waitContext=undefined;
+    next && await next();
+  }
+
+  async run(context) {
+
+    {% if workflow.parent.context.atom.doc.features.print_steps %}
+      console.log(new Date().toLocaleString(),'{{indexKey}}');
+    {% endif %}
+
+    {% if definition.debugger %}
+      debugger;
+    {% endif %}
+
+    {% if context.transform.print %}
+      print({{context.transform.print | safe}});
+    {% endif%}
+
+    {% if context.transform.assert %}
+      assert({{context.transform.assert | safe}});
+    {% endif%}
+
+    {% if context.transform.sleep %}
+      await sleep({{context.transform.sleep}});
+    {% endif %}
+
+    await this.init(context);
+
+    {% if context.next %}
+
+      {% if context.next.definition.dynamic %}
+        // NEXT : {{context.next.indexKey}}
+        const { default: {{context.next.codeKey}} } = await import("./blocks/{{context.next.codeKey}}");
+      {% endif %}
+      
+      {# closure #}
+      const c={};
+
+      let current=new {{context.next.codeKey}}({ parent:this, engine:this.engine, flow:this, caller:c });
+      let currentArgs;
+
+      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 nextBlock;
+        else if(nextBlock?.type!=='block') break;
+
+        if(nextBlock.toType.ParentTypeId!==this.constructor.TypeId) 
+          throw new Error('Unknown situation');
+        
+        current=new nextBlock.toType({ parent:this, engine:this.engine, flow:this, caller:c });
+        currentArgs=nextBlock.withArgs;
+
+      } while(true);
+
+    {% endif %}
+
+    return this.result;
+  }
+}
+
+Workflow.TypeId="{{typeId}}";
+Workflow.IndexKey="{{indexKey}}";

package/template/fnet/core/assert.js

@@ -0,0 +1,6 @@
+export default (args) => {
+    const [condition, message] = Array.isArray(args) ? args : [args];
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}

package/template/fnet/core/message.js

@@ -0,0 +1,3 @@
+export default {
+    USE_CONSTRUCTOR: "Please call it as constructor!"
+}

package/template/fnet/core/object.js

@@ -0,0 +1,43 @@
+import getValue from "get-value";
+import setValue from "set-value";
+import print from "./print";
+
+export default class Object {
+  #property;
+  #context;
+  #module;
+
+  constructor(context) {
+
+    this.#property = {}
+    this.#module = {};
+    this.#context = context;
+
+    this.get = (path, options) => {
+      return getValue(this.#property, path, options);
+    }
+
+    this.set = (path, value, options) => {
+      return setValue(this.#property, path, value, options);
+    }
+
+    this.print = print;
+  }
+
+  getModule(path) {
+    return getValue(this.#module, path);
+  }
+
+  setModule(path, module) {
+    if (typeof module !== "function") throw new Error("Module must be a function");
+    return setValue(this.#module, path, module);
+  }
+
+  get getValue() {
+    return getValue;
+  }
+
+  get setValue() {
+    return setValue;
+  }
+}

package/template/fnet/core/print.js

@@ -0,0 +1 @@
+export default console.log;

package/template/fnet/core/sleep.js

@@ -0,0 +1,5 @@
+export default (delay) => {
+    return new Promise(function (resolve) {
+        setTimeout(resolve, delay);
+    });
+}

package/template/fnet/node/.gitignore.njk

@@ -0,0 +1,8 @@
+node_modules
+.DS_Store
+.fnet
+.out
+.package
+.vscode
+.output
+.npmrc

package/template/fnet/node/fnet/flows.yaml.njk

@@ -0,0 +1 @@
+{{content | safe}}

package/template/fnet/node/fnet.yaml.njk

@@ -0,0 +1 @@
+{{content | safe}}