@fnet/cli 0.111.0 → 0.111.1

package/template/fnet/node/src/app/index.js.njk

@@ -0,0 +1,36 @@
+{% if atom.doc.features.app.enabled===true %}
+
+import { default as Engine } from "../default/{{ atom.doc.features.app_default_entry_file or atom.doc.features.main_default_entry_file }}";
+
+  {% if atom.doc.features.app.export===true %}
+    {% if atom.doc.features.app.extend===true %}
+      import { default as init } from '../../../app';
+    {% endif %}
+    const createApp = ({ container }) => {
+        {% if atom.doc.features.app.extend===true %}
+          return init({container,Engine});
+        {% else %} 
+          return (props) => {
+              const engine = new Engine();
+              engine.run({ ...props, container }).catch((error) => {
+                console.log(error.message)
+              });
+          }
+        {% endif %}
+    };
+    export { createApp };
+  {% else %}
+      {% if atom.doc.features.app.extend===true %}
+        import { default as run } from '../../../app';
+        run({ Engine }).catch((error) => {
+            console.log(error.message)
+        });
+      {% else %} 
+        const engine = new Engine();
+        engine.run().catch((error) => {
+          console.log(error.message)
+        });
+      {% endif %}    
+  {% endif %}
+
+{% endif %}

package/template/fnet/node/src/cli/index.js.njk

@@ -0,0 +1,44 @@
+{% if atom.doc.features.cli.enabled===true %}
+import argv from '../default/to.args.js';
+import { default as Engine } from '../default/{{atom.doc.features.cli_default_entry_file or atom.doc.features.main_default_entry_file}}';
+
+  {% if atom.doc.features.cli.extend===true %}
+    {# TYPE 1 #}
+    import { default as runExtended } from '../../../cli';
+
+    const run = async () => {
+      return await runExtended(await argv(),{ Engine });
+    };
+
+    run()
+      .then(() => {    
+        {# process.exit(0);  #}
+      })
+      .catch((error) => {    
+        console.error(error.message);
+        process.exit(1);
+      });
+  {% else %}
+    {# TYPE 2 #}
+    const run = async () => {
+      const engine = new Engine();
+      return await engine.run(await argv());
+    };
+
+    run()
+      .then((result) => {    
+        if (typeof result !== 'undefined')
+        {
+          // TODO: REMOVE THIS LINE
+          const stdout_format=process.argv.slice(2).indexOf()!==-1? process.argv.slice(2)[process.argv.slice(2).indexOf('--stdout_format')+1]:null;
+          if(stdout_format==='json') console.log(JSON.stringify(result,null,2));
+          else console.log(result);
+        }
+        {# process.exit(0); #}    
+      })
+      .catch((error) => {    
+        console.error(error.message);
+        process.exit(1);
+      });
+  {% endif %}
+{% endif %}

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

@@ -0,0 +1,40 @@
+{% 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 (){
+      
+    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" %}
+
+      {% for assign in context.transform.assign %}
+      flow.set({{assign.key | safe}},{{assign.value | safe}});
+      {% endfor%}
+      
+      {% 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 %}
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,92 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-library-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 (){
+      
+    const args=Array.from(arguments);
+
+    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" %}
+
+        {% if context.next and context.transform.operation==='wait-for-next' %}
+          flow.waitForNext({
+            key:'{{indexKey}}',
+            next: new Promise((resolve,reject) => {
+                {% include "src/default/macros/block-next.js.njk" %}
+            })
+          });
+        {% endif %}
+        
+        {% if context.lib.type==='atom'%}
+          const lib=LIBRARY;
+        {% elseif context.lib.type==='subworkflow' %}
+          const lib={{context.lib.codeKey}};
+        {% elseif target.atom.protocol==='use:' %}
+          const lib={{context.transform.call}};
+        {% else %}
+          const lib=undefined; 
+          throw new Error('Couldn file lib.');
+        {% endif %}
+
+        {% if context.lib.atom.doc.subtype==='workflow'%}
+          const Workflow=lib;
+          const workflow=new Workflow({app:engine.app,caller:c});
+          const callLib = workflow.run.bind(workflow);
+        {% elseif context.lib.type==='subworkflow'%}
+          const Workflow=lib;
+          const workflow=new Workflow({engine,flow,caller:c});
+          const callLib = workflow.run.bind(workflow);
+        {% else %}
+          const callLib = lib;
+        {% endif %}
+
+        {% if context.transform.args %}
+          {% if context.lib.type==='subworkflow' %}
+            const callArgs ={ params: {{ context.transform.args | safe }} };
+          {% else %}
+            const callArgs ={{ context.transform.args | safe }} ;
+          {% endif %}
+
+          const result = Array.isArray(callArgs)?  await callLib.apply(_this,callArgs): await callLib.call(_this,callArgs);
+
+        {% else %}
+          const result = await callLib.call(_this);
+        {% endif %}
+
+        {% for assign in context.transform.result %}
+          flow.set({{assign.key | safe}},{{assign.value | safe}});
+        {% endfor%}
+
+        {% if context.transform.return %}
+          resolve({type:'return',value: {{context.transform.return | safe}}});
+        {% elseif context.next and context.transform.operation!=='wait-for-next'%}
+          {% include "src/default/macros/block-next.js.njk" %}
+        {% elseif not context.next%}
+          resolve();
+        {% endif %}
+      }
+      catch(error){
+          reject(error);
+      }
+    });
+  }
+
+  Object.freeze(this); 
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,81 @@
+
+{% 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" %}
+
+{% if childs.length %}
+  {% if not childs[0].definition.dynamic %}
+    // FIRST CHILD: {{childs[0].indexKey}}
+    import {{childs[0].codeKey}} from "./{{childs[0].codeKey}}";
+  {% endif %}
+{% endif%}
+
+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" %}
+
+      {% if childs.length %}
+        {% if childs[0].definition.dynamic %}
+          // FIRST CHILD: {{childs[0].indexKey}}
+          const { default: {{childs[0].codeKey}} } = await import("./{{childs[0].codeKey}}");
+        {% endif %}
+      {% endif%}
+
+      for await(const {{context.transform.for.value | safe}} of {{context.transform.for.in | safe}}){
+        c.for={ {{context.transform.for.value | safe}} };
+
+        {% if childs.length %}
+          let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:c  });
+          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});
+            currentArgs=nextBlock.withArgs;
+            
+          } while(true);
+            
+        {% endif %}
+      }
+
+      {% 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 %}
+    });
+  }    
+
+  Object.freeze(this); 
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,65 @@
+import React from "react";
+
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+{% include "src/default/macros/block-library-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 (){
+      
+    const args=Array.from(arguments);
+
+    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" %}
+        
+        flow.waitForNext({
+          key:'{{indexKey}}',
+          next: async () => {
+            {% 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 %}
+          }
+        });
+        
+        {% if context.lib.type==='atom'%}
+          const formLib=LIBRARY;
+        {% elseif context.lib.type==='subworkflow' %}
+          const formLib={{context.lib.codeKey}};
+        {% else %}
+          const formLib=undefined; 
+          throw new Error('Couldnt find form.');
+        {% endif %}
+
+        {% include "src/default/macros/block-run-form.js.njk" %}
+        
+        {% if context.transform.operation==='continue-for-next' %}
+          flow.continueForNext({key:'{{indexKey}}'});
+        {% endif %}
+      }
+      catch(error){
+        reject(error);                
+      }
+    });
+  } 
+
+  Object.freeze(this);    
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,31 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+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" %}
+      
+      {% 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 %}
+    });
+  }
+
+  Object.freeze(this);       
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,50 @@
+{% 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 (){
+      
+    const args=Array.from(arguments);
+
+    return new Promise(async (resolve,reject)=>{
+
+      try{
+        {% include "src/default/macros/block-run-header.js.njk" %}
+
+        {% include "src/default/macros/page.js.njk" %}
+
+        {% if context.next and context.transform.operation==='wait-for-next' %}
+        flow.waitForNext({
+          key:'{{indexKey}}',
+          next: new Promise((resolve,reject) => {
+              {% include "src/default/macros/block-next.js.njk" %}
+          })
+        });
+        {% endif %}
+        
+        {% include "src/default/macros/block-modules.js.njk" %}
+        
+        {% if context.transform.return %}
+          resolve({type:'return',value: {{context.transform.return | safe}}});
+        {% elseif context.next and context.transform.operation!=='wait-for-next'%}
+          {% include "src/default/macros/block-next.js.njk" %}
+        {% elseif not context.next%}
+          resolve();
+        {% endif %}
+      }
+      catch(error){
+        reject(error);
+      }
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,24 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+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" %}
+
+      {% if context.transform.operation==='continue-for-next' %}
+          await flow.continueForNext({key:'{{indexKey}}'});
+          resolve();
+      {% endif %}                        
+    });
+  }
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,25 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+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" %}
+        
+        const raise = {{context.transform.raise | safe}};
+
+        reject(new Error(raise?.message||raise||"Unknown error"));
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,27 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+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" %}
+        
+        const value = {{context.transform.return | safe}};
+
+        flow.result={value: value};
+
+        resolve();            
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,56 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% include "src/default/macros/block-next-header.js.njk" %}
+
+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" %}
+
+      {% if context.next %}
+
+        // NEXT : {{context.next.indexKey}}
+        {% if context.next.definition.dynamic %}
+          const { default: {{context.next.codeKey}} } = await import("./{{context.next.codeKey}}");
+        {% endif %}
+
+        let current=new {{context.next.codeKey}}({ parent:_this, engine, flow, caller:c });
+        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});
+          currentArgs=nextBlock.withArgs;
+
+        } while(true);
+
+      {% endif %}
+
+      resolve();
+    });
+  }
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}

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

@@ -0,0 +1,73 @@
+{% include "src/default/macros/block-header.js.njk" %}
+
+{% if not hasDefaultCondition %}
+  {% include "src/default/macros/block-next-header.js.njk" %}
+{% endif %}
+
+{% 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" %}
+      
+      {% 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}}");
+            {% endif %}
+
+            const current=new {{child.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));
+          }
+      {% endfor%}
+
+      {% if not hasDefaultCondition %}
+        {% 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 %}
+      {% endif %}
+    });
+  }  
+
+  Object.freeze(this);
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}