@fnet/cli 0.3.11 → 0.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fnet/cli",
-  "version": "0.3.11",
+  "version": "0.3.14",
   "files": [
     "dist",
     "template"
@@ -36,7 +36,6 @@
     "@fnet/auto-conda-env": "^0.2.1",
     "@fnet/config": "^0.2.29",
     "@fnet/dir-zipper": "^0.1.8",
-    "@fnet/expression": "^0.1.30",
     "@fnet/files-to-gcs": "^0.3.12",
     "@fnet/key-value-transformer": "^0.1.4",
     "@fnet/npm-list-versions": "^0.1.35",
@@ -87,6 +86,7 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-terser": "^0.4.4",
+    "peggy": "^5.0.6",
     "rollup": "^4.52.5"
   }
 }

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

@@ -35,31 +35,51 @@ export default function Block(context) {
         {% endif %}
       {% endif%}
 
-      for await(const {{context.transform.for.value | safe}} of {{context.transform.for.in | safe}}){
-        c.for={ {{context.transform.for.value | safe}} };
+      for await(const {{context.transform.for.as | safe}} of {{context.transform.for.in | safe}}){
+        // Create Proxy for closure-like variable resolution
+        // Local variable shadows parent, but parent scope accessible via Proxy fallback
+        const localForVar = { {{context.transform.for.as | safe}}: {{context.transform.for.as | safe}} };
+        const forProxy = new Proxy(localForVar, {
+          get(target, prop) {
+            // Check local scope first (shadowing)
+            if (prop in target) return target[prop];
+            // Fallback to parent scope
+            return c.for?.[prop];
+          }
+        });
+
+        // Create new context with updated for
+        const loopContext = { ...c, for: forProxy };
 
         {% if childs.length %}
-          let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:c  });
+          let current= new {{childs[0].codeKey}}({ parent:_this, engine, flow, caller:loopContext  });
           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) ;
+            try {
+              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?.type==='return') return resolve(nextBlock);
+              else if(nextBlock?.type!=='block') break;
 
-            if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
-              return resolve(nextBlock);
+              if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+                return resolve(nextBlock);
+
+              current=new nextBlock.toType({ parent:_this, engine, flow, caller:loopContext, onError, error });
+              currentArgs=nextBlock.input;
+            } catch (err) {
+              if (onError) {
+                return onError(err);
+              }
+              throw err;
+            }
 
-            current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
-            currentArgs=nextBlock.input;
-            
           } while(true);
             
         {% endif %}

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

@@ -0,0 +1,157 @@
+{% 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)=>{
+      {% include "src/default/macros/block-run-header.js.njk" %}
+
+      {% include "src/default/macros/page.js.njk" %}
+
+      {% include "src/default/macros/block-modules.js.njk" %}
+      
+      // HTTP configuration
+      let url = {{ context.transform.http.url | safe }};
+      let method = "{{ context.transform.http.method }}";
+      let headers = {{ context.transform.http.headers | dump | safe }};
+      let timeout = {{ context.transform.http.timeout }};
+      {% if context.transform.http.body !== undefined %}
+      let body = {% if context.transform.http.body is string %}{{ context.transform.http.body | safe }}{% else %}{{ context.transform.http.body | dump | safe }}{% endif %};
+      {% endif %}
+      {% if context.transform.http.params %}
+      let params = {{ context.transform.http.params | dump | safe }};
+      {% endif %}
+
+      // Create HTTP context for modules
+      const httpContext = { url, method, headers, timeout, params: {% if context.transform.http.params %}params{% else %}undefined{% endif %}, body: {% if context.transform.http.body !== undefined %}body{% else %}undefined{% endif %} };
+
+      // If any property is a module function (m::), call it with HTTP context
+      if (typeof url === 'function') {
+        url = await url(httpContext);
+      }
+
+      if (typeof method === 'function') {
+        method = await method(httpContext);
+      }
+
+      if (typeof headers === 'function') {
+        headers = await headers(httpContext);
+      }
+
+      if (typeof timeout === 'function') {
+        timeout = await timeout(httpContext);
+      }
+
+      {% if context.transform.http.params %}
+      if (typeof params === 'function') {
+        params = await params(httpContext);
+      }
+      {% endif %}
+
+      {% if context.transform.http.body !== undefined %}
+      if (typeof body === 'function') {
+        body = await body(httpContext);
+      }
+      {% endif %}
+
+      // Build URL with query parameters if provided
+      let finalUrl = url;
+      {% if context.transform.http.params %}
+      if (params && Object.keys(params).length > 0) {
+        const queryString = new URLSearchParams(params).toString();
+        finalUrl = url + (url.includes('?') ? '&' : '?') + queryString;
+      }
+      {% endif %}
+
+      // Prepare fetch options
+      const fetchOptions = {
+        method: method,
+        headers: headers
+      };
+
+      // Add body if present (and not GET/HEAD)
+      {% if context.transform.http.body %}
+      if (body !== undefined && method !== 'GET' && method !== 'HEAD') {
+        // Auto JSON.stringify if body is object
+        if (typeof body === 'object' && body !== null) {
+          fetchOptions.body = JSON.stringify(body);
+          // Auto set Content-Type if not already set
+          if (!fetchOptions.headers['Content-Type'] && !fetchOptions.headers['content-type']) {
+            fetchOptions.headers['Content-Type'] = 'application/json';
+          }
+        } else {
+          fetchOptions.body = body;
+        }
+      }
+      {% endif %}
+
+      // Create abort controller for timeout
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      fetchOptions.signal = controller.signal;
+
+      try {
+        // Execute HTTP request
+        const response = await fetch(finalUrl, fetchOptions);
+        clearTimeout(timeoutId);
+
+        // Check if response is successful (2xx)
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        // Parse response based on Content-Type
+        const contentType = response.headers.get('content-type');
+        let result;
+        
+        if (contentType && contentType.includes('application/json')) {
+          result = await response.json();
+        } else if (contentType && contentType.includes('text/')) {
+          result = await response.text();
+        } else {
+          // Try JSON first, fallback to text
+          try {
+            result = await response.json();
+          } catch (e) {
+            result = await response.text();
+          }
+        }
+
+        // Store result in flow variable
+        flow.set('result', result);
+
+        {% include "src/default/macros/block-assign.js.njk" %}
+
+      } catch (error) {
+        clearTimeout(timeoutId);
+
+        // Handle timeout error
+        if (error.name === 'AbortError') {
+          const timeoutError = new Error(`HTTP request timeout after ${timeout}ms: ${finalUrl}`);
+          onError ? onError(timeoutError) : reject(timeoutError);
+          return;
+        }
+
+        // Handle other errors
+        onError ? onError(error) : reject(error);
+        return;
+      }
+
+      {% include "src/default/macros/block-next.js.njk" %}
+
+      {% include "src/default/macros/block-run-footer.js.njk" %}
+    });
+  }
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}
+

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

@@ -55,20 +55,27 @@ export default function Block(context) {
       {% 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 %}
+      try {
+        {% 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 %}
+      } catch (err) {
+        if (onError) {
+          return onError(err);
+        }
+        throw err;
+      }
 
       // Check if any child returned or jumped
       for (const result of results) {

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

@@ -0,0 +1,94 @@
+{% 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 %}
+    // RETRYABLE 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" %}
+
+      // 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;
+
+      try {
+        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;
+            }
+          }
+        }
+      } catch (err) {
+        if (onError) {
+          return onError(err);
+        }
+        throw err;
+      }
+      {% endif %}
+
+      {% include "src/default/macros/block-next.js.njk" %}
+
+      {% include "src/default/macros/block-run-footer.js.njk" %}
+    });
+  }
+}
+
+{% include "src/default/macros/block-footer.js.njk" %}
+

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

@@ -27,7 +27,17 @@ export default function Block(context){
       // Import node-cron for scheduling
       const cron = await import('node-cron');
 
-      const cronExpression = {{ context.transform.schedule | safe }};
+      // 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)) {
@@ -44,7 +54,8 @@ export default function Block(context){
       });
       {% endif %}
 
-      // Schedule the task
+      // Schedule the task with optional timezone
+      const scheduleOptions = timezone ? { timezone } : {};
       const task = cron.schedule(cronExpression, async () => {
         try {
           {% if childs[0] %}
@@ -53,7 +64,7 @@ export default function Block(context){
         } catch (error) {
           console.error(`Scheduled task '{{indexKey}}' failed:`, error);
         }
-      });
+      }, scheduleOptions);
 
       // Start the scheduled task
       task.start();

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

@@ -25,22 +25,29 @@ export default function Block(context){
         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) ;
+          try {
+            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?.type==='return') return resolve(nextBlock);
+            else if(nextBlock?.type!=='block') break;
 
-          if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
-            return resolve(nextBlock);
+            if(nextBlock.toType.ParentTypeId!==_this.constructor.TypeId)
+              return resolve(nextBlock);
 
-          current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
-          currentArgs=nextBlock.input;
+            current=new nextBlock.toType({ parent:_this, engine, flow, caller:c, onError, error });
+            currentArgs=nextBlock.input;
+          } catch (err) {
+            if (onError) {
+              return onError(err);
+            }
+            throw err;
+          }
 
         } while(true);
 

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

@@ -51,7 +51,14 @@ export default function Block(context) {
               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));
+            try {
+              return resolve(Array.isArray(args)? await current.run.apply(current,args) : await current.run.call(current,args));
+            } catch (err) {
+              if (onError) {
+                return onError(err);
+              }
+              throw err;
+            }
           }
       {% endfor%}
 

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

@@ -13,6 +13,7 @@ resolve ({
     fromClosure: c,
     toType:{{context.next.codeKey}},
     onError,
+    error,
     {% if context.transform.output %}
     input: {{context.transform.output | safe}},
     {% endif %}

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

@@ -16,7 +16,19 @@ const form=null;
 {% endif %}
 
 {# closure #}
-const c={ caller, resolve, reject, args, get form(){return form||caller?.form}, get module(){return m||caller?.module} };
+const c={
+  caller,
+  resolve,
+  reject,
+  args,
+  get form(){return form||caller?.form},
+  get module(){return m||caller?.module},
+  get for(){
+    // Proxy pattern for nested loop variable resolution with closure semantics
+    // Inner loops shadow outer loops, but parent scope is accessible via fallback
+    return caller?.for || {};
+  }
+};
 
 {% if workflow.parent.context.atom.doc.features.print_steps %}
 console.log(new Date().toLocaleString(),'{{indexKey}}');

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

@@ -96,10 +96,10 @@ export default class Workflow extends Object {
         if(nextBlock?.type==='return') return nextBlock;
         else if(nextBlock?.type!=='block') break;
 
-        if(nextBlock.toType.ParentTypeId!==this.constructor.TypeId) 
+        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 });
+
+        current=new nextBlock.toType({ parent:this, engine:this.engine, flow:this, caller:c, onError:nextBlock.onError, error:nextBlock.error });
         currentArgs=nextBlock.input;
 
       } while(true);