n8n-nodes-prestashop8 2.4.2 → 2.6.0

package/dist/nodes/PrestaShop8/PrestaShop8.node.description.js

@@ -670,6 +670,38 @@ exports.PrestaShop8Description = {
                         },
                     ],
                 },
+                {
+                    displayName: 'Retry On Error',
+                    name: 'retry',
+                    type: 'collection',
+                    placeholder: 'Add Retry Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Enabled',
+                            name: 'retryEnabled',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to retry a call that fails on a transient error (network timeout, connection drop, 5xx server error or 429 rate-limit). Never retries client errors (4xx).',
+                        },
+                        {
+                            displayName: 'Max Retries',
+                            name: 'maxRetries',
+                            type: 'number',
+                            typeOptions: { minValue: 0 },
+                            default: 3,
+                            description: 'Maximum number of retry attempts per failing call. This budget is reset for each call, it is not a global limit for the whole node execution.',
+                        },
+                        {
+                            displayName: 'Retry Delay (ms)',
+                            name: 'retryDelay',
+                            type: 'number',
+                            typeOptions: { minValue: 0 },
+                            default: 1000,
+                            description: 'Pause in milliseconds between two successive retry attempts of the same call',
+                        },
+                    ],
+                },
                 {
                     displayName: 'Timeout (ms)',
                     name: 'timeout',
@@ -677,6 +709,14 @@ exports.PrestaShop8Description = {
                     default: 30000,
                     description: 'Request timeout in milliseconds',
                 },
+                {
+                    displayName: 'Delay Between Calls (ms)',
+                    name: 'delayBetweenCalls',
+                    type: 'number',
+                    typeOptions: { minValue: 0 },
+                    default: 0,
+                    description: 'Pause in milliseconds applied before each PrestaShop call except the first, to throttle requests when processing multiple input items',
+                },
             ],
         },
     ],

package/dist/nodes/PrestaShop8/PrestaShop8.node.js

@@ -100,6 +100,10 @@ class PrestaShop8 {
                 let requestDebugInfo = {};
                 const opts = (0, http_1.getOperationOptions)(this, i);
                 const { rawMode, timeout, neverError, includeResponseHeaders, showRequestInfo, showRequestUrl } = opts;
+                // Throttle: pause before each PrestaShop call except the first.
+                if (i > 0 && opts.delayBetweenCalls > 0) {
+                    await (0, http_1.sleep)(opts.delayBetweenCalls);
+                }
                 switch (operation) {
                     case 'list': {
                         const advancedOptions = this.getNodeParameter('advancedOptions', i, {});
@@ -120,13 +124,13 @@ class PrestaShop8 {
                         }
                         requestUrl = (0, utils_1.buildUrlWithFilters)(`${credentials.baseUrl}/${resource}`, urlParams, rawMode);
                         if (rawMode) {
-                            const rawResult = await (0, http_1.executeRawModeRequest)(requestUrl, credentials, timeout, neverError, includeResponseHeaders, operation, resource);
+                            const rawResult = await (0, http_1.executeRawModeRequest)(requestUrl, credentials, timeout, neverError, includeResponseHeaders, operation, resource, opts.retry);
                             responseData = rawResult.responseData;
                             requestDebugInfo = rawResult.requestDebugInfo;
                         }
                         else {
                             const options = (0, http_1.buildHttpOptions)('GET', requestUrl, credentials, rawMode, timeout);
-                            const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError);
+                            const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, undefined, opts.retry);
                             requestUrl = url;
                             requestDebugInfo = debugInfo;
                             const processedResponse = (0, utils_1.processResponseForMode)(response, resource);
@@ -149,7 +153,7 @@ class PrestaShop8 {
                         }
                         requestUrl = (0, utils_1.buildUrlWithFilters)(`${credentials.baseUrl}/${resource}/${id}`, urlParams, rawMode);
                         const options = (0, http_1.buildHttpOptions)('GET', requestUrl, credentials, rawMode, timeout);
-                        const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError);
+                        const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, undefined, opts.retry);
                         requestUrl = url;
                         requestDebugInfo = debugInfo;
                         const processedResponse = rawMode ? { raw: response } : (0, utils_1.processResponseForMode)(response, resource);
@@ -186,7 +190,7 @@ class PrestaShop8 {
                         // Build XML using new format
                         body = (0, utils_1.buildCreateXml)(resource, fieldsToCreate);
                         const options = (0, http_1.buildHttpOptions)('POST', `${credentials.baseUrl}/${resource}`, credentials, rawMode, timeout, body);
-                        const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, body);
+                        const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, body, opts.retry);
                         requestUrl = url;
                         requestDebugInfo = debugInfo;
                         const processedResponse = rawMode ? { raw: response } : (0, utils_1.processResponseForMode)(response, resource);
@@ -219,7 +223,7 @@ class PrestaShop8 {
                         // Build XML using new format
                         body = (0, utils_1.buildUpdateXml)(resource, id, fieldsToUpdate);
                         const options = (0, http_1.buildHttpOptions)('PATCH', `${credentials.baseUrl}/${resource}/${id}`, credentials, rawMode, timeout, body);
-                        const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, body);
+                        const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, body, opts.retry);
                         requestUrl = url;
                         requestDebugInfo = debugInfo;
                         const processedResponse = rawMode ? { raw: response } : (0, utils_1.processResponseForMode)(response, resource);
@@ -291,13 +295,13 @@ class PrestaShop8 {
                         }
                         requestUrl = (0, utils_1.buildUrlWithFilters)(`${credentials.baseUrl}/${resource}`, urlParams, rawMode);
                         if (rawMode) {
-                            const rawResult = await (0, http_1.executeRawModeRequest)(requestUrl, credentials, timeout, neverError, includeResponseHeaders, operation, resource);
+                            const rawResult = await (0, http_1.executeRawModeRequest)(requestUrl, credentials, timeout, neverError, includeResponseHeaders, operation, resource, opts.retry);
                             responseData = rawResult.responseData;
                             requestDebugInfo = rawResult.requestDebugInfo;
                         }
                         else {
                             const options = (0, http_1.buildHttpOptions)('GET', requestUrl, credentials, rawMode, timeout);
-                            const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError);
+                            const { response, debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, undefined, opts.retry);
                             requestUrl = url;
                             requestDebugInfo = debugInfo;
                             const processedResponse = (0, utils_1.processResponseForMode)(response, resource);
@@ -311,7 +315,7 @@ class PrestaShop8 {
                             throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'ID required for this operation');
                         }
                         const options = (0, http_1.buildHttpOptions)('DELETE', `${credentials.baseUrl}/${resource}/${id}`, credentials, rawMode, timeout);
-                        const { debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError);
+                        const { debugInfo, url, responseHeaders, statusCode } = await (0, http_1.executeHttpRequest)(this.helpers, options, credentials, rawMode, operation, resource, neverError, undefined, opts.retry);
                         requestUrl = url;
                         requestDebugInfo = debugInfo;
                         const deleteResponse = {

package/dist/nodes/PrestaShop8/helpers/http.d.ts

@@ -18,7 +18,34 @@ export interface OperationOptions {
     rawMode: boolean;
     showRequestInfo: boolean;
     showRequestUrl: boolean;
+    delayBetweenCalls: number;
+    retry: RetryOptions;
 }
+/**
+ * Retry configuration applied to each individual HTTP call.
+ * The retry budget is per call: every failing call gets a fresh set of attempts.
+ */
+export interface RetryOptions {
+    enabled: boolean;
+    maxRetries: number;
+    retryDelay: number;
+}
+/**
+ * Pause execution for the given number of milliseconds (used to throttle calls).
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Determine whether an error is transient and worth retrying.
+ * Retries on network/timeout errors, 5xx server errors and 429 rate-limit.
+ * Never retries on 4xx (invalid key, not found, invalid XML, etc.).
+ */
+export declare function isRetryableError(error: any): boolean;
+/**
+ * Run an async HTTP operation with per-call retry on transient errors.
+ * Each call gets its own retry budget; on the last attempt the error is rethrown
+ * so existing neverError / continueOnFail handling applies unchanged.
+ */
+export declare function withRetry<T>(retry: RetryOptions, fn: () => Promise<T>): Promise<T>;
 /**
  * Extract common operation options from node parameters
  */
@@ -38,7 +65,7 @@ export declare function wrapResponse(processedResponse: any, includeHeaders: boo
 /**
  * Execute HTTP request with debug capture and response metadata
  */
-export declare function executeHttpRequest(helpers: any, options: IHttpRequestOptions, credentials: any, rawMode: boolean, operation: string, resource: string, neverError?: boolean, body?: string): Promise<{
+export declare function executeHttpRequest(helpers: any, options: IHttpRequestOptions, credentials: any, rawMode: boolean, operation: string, resource: string, neverError?: boolean, body?: string, retry?: RetryOptions): Promise<{
     response: any;
     debugInfo: any;
     url: string;
@@ -48,7 +75,7 @@ export declare function executeHttpRequest(helpers: any, options: IHttpRequestOp
 /**
  * Execute a raw mode request using axios directly (bypasses n8n parsing)
  */
-export declare function executeRawModeRequest(requestUrl: string, credentials: IPrestaShopCredentials, timeout: number, neverError: boolean, includeResponseHeaders: boolean, operation: string, resource: string): Promise<{
+export declare function executeRawModeRequest(requestUrl: string, credentials: IPrestaShopCredentials, timeout: number, neverError: boolean, includeResponseHeaders: boolean, operation: string, resource: string, retry?: RetryOptions): Promise<{
     responseData: any;
     requestDebugInfo: any;
     requestHeaders: any;

package/dist/nodes/PrestaShop8/helpers/http.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FILTER_OPERATOR_FORMATS = void 0;
+exports.sleep = sleep;
+exports.isRetryableError = isRetryableError;
+exports.withRetry = withRetry;
 exports.getOperationOptions = getOperationOptions;
 exports.buildHttpOptions = buildHttpOptions;
 exports.captureRequestDebugInfo = captureRequestDebugInfo;
@@ -27,6 +30,66 @@ exports.FILTER_OPERATOR_FORMATS = {
     'IS_EMPTY': { template: '[]', requiresValue: false },
     'IS_NOT_EMPTY': { template: '![]', requiresValue: false },
 };
+/**
+ * Pause execution for the given number of milliseconds (used to throttle calls).
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Determine whether an error is transient and worth retrying.
+ * Retries on network/timeout errors, 5xx server errors and 429 rate-limit.
+ * Never retries on 4xx (invalid key, not found, invalid XML, etc.).
+ */
+function isRetryableError(error) {
+    var _a, _b;
+    // Network / timeout errors expose a code on the error or its cause
+    const code = (error === null || error === void 0 ? void 0 : error.code) || ((_a = error === null || error === void 0 ? void 0 : error.cause) === null || _a === void 0 ? void 0 : _a.code);
+    const retryableCodes = [
+        'ETIMEDOUT',
+        'ECONNRESET',
+        'ECONNREFUSED',
+        'ECONNABORTED',
+        'ENOTFOUND',
+        'EAI_AGAIN',
+        'EPIPE',
+    ];
+    if (code && retryableCodes.includes(code)) {
+        return true;
+    }
+    // "socket hang up" and timeout messages have no stable code
+    const message = String((error === null || error === void 0 ? void 0 : error.message) || '').toLowerCase();
+    if (message.includes('socket hang up') || message.includes('timeout')) {
+        return true;
+    }
+    // HTTP status: retry on 429 (rate-limit) and 5xx (server errors) only
+    const status = (error === null || error === void 0 ? void 0 : error.httpCode) || ((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.status);
+    if (status === 429 || (status >= 500 && status <= 599)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Run an async HTTP operation with per-call retry on transient errors.
+ * Each call gets its own retry budget; on the last attempt the error is rethrown
+ * so existing neverError / continueOnFail handling applies unchanged.
+ */
+async function withRetry(retry, fn) {
+    const maxRetries = retry.enabled ? Math.max(0, retry.maxRetries) : 0;
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt >= maxRetries || !isRetryableError(error)) {
+                throw error;
+            }
+            if (retry.retryDelay > 0) {
+                await sleep(retry.retryDelay);
+            }
+        }
+    }
+}
 /**
  * Extract common operation options from node parameters
  */
@@ -38,6 +101,12 @@ function getOperationOptions(executeFunctions, itemIndex) {
         rawMode: executeFunctions.getNodeParameter('options.response.rawMode', itemIndex, false),
         showRequestInfo: executeFunctions.getNodeParameter('options.request.showRequestInfo', itemIndex, false),
         showRequestUrl: executeFunctions.getNodeParameter('options.request.showRequestUrl', itemIndex, false),
+        delayBetweenCalls: executeFunctions.getNodeParameter('options.delayBetweenCalls', itemIndex, 0),
+        retry: {
+            enabled: executeFunctions.getNodeParameter('options.retry.retryEnabled', itemIndex, false),
+            maxRetries: executeFunctions.getNodeParameter('options.retry.maxRetries', itemIndex, 3),
+            retryDelay: executeFunctions.getNodeParameter('options.retry.retryDelay', itemIndex, 1000),
+        },
     };
 }
 /**
@@ -107,12 +176,12 @@ function wrapResponse(processedResponse, includeHeaders, headers, statusCode) {
 /**
  * Execute HTTP request with debug capture and response metadata
  */
-async function executeHttpRequest(helpers, options, credentials, rawMode, operation, resource, neverError = false, body) {
+async function executeHttpRequest(helpers, options, credentials, rawMode, operation, resource, neverError = false, body, retry = { enabled: false, maxRetries: 0, retryDelay: 0 }) {
     var _a, _b, _c, _d;
     const requestUrl = options.url;
     const debugInfo = captureRequestDebugInfo(options, credentials, rawMode, operation, resource, body);
     try {
-        const response = await helpers.httpRequest(options);
+        const response = await withRetry(retry, () => helpers.httpRequest(options));
         return {
             response,
             debugInfo,
@@ -141,11 +210,11 @@ async function executeHttpRequest(helpers, options, credentials, rawMode, operat
 /**
  * Execute a raw mode request using axios directly (bypasses n8n parsing)
  */
-async function executeRawModeRequest(requestUrl, credentials, timeout, neverError, includeResponseHeaders, operation, resource) {
+async function executeRawModeRequest(requestUrl, credentials, timeout, neverError, includeResponseHeaders, operation, resource, retry = { enabled: false, maxRetries: 0, retryDelay: 0 }) {
     var _a, _b;
     let responseData;
     try {
-        const axiosResponse = await axios({
+        const axiosResponse = await withRetry(retry, () => axios({
             method: 'GET',
             url: requestUrl,
             auth: {
@@ -156,7 +225,7 @@ async function executeRawModeRequest(requestUrl, credentials, timeout, neverErro
             timeout: timeout || 30000,
             transformResponse: [(data) => data],
             validateStatus: neverError ? () => true : undefined,
-        });
+        }));
         const requestDebugInfo = captureRequestDebugInfo({
             method: 'GET',
             url: requestUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-prestashop8",
-  "version": "2.4.2",
+  "version": "2.6.0",
   "description": "Nœud n8n personnalisé pour PrestaShop 8 avec support CRUD complet et conversion XML/JSON automatique",
   "keywords": [
     "n8n-community-node-package",