@fnet/cli 0.3.11 → 0.3.12

package/package.json

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

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/retry.js.njk

@@ -0,0 +1,87 @@
+{% 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;
+
+      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 %}
+
+      {% 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();