n8n-nodes-n8ndesigner-salla-n8nai 0.3.158

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { DEFAULT_BASE_URL, SALLA_BRAND_COLOR, SALLA_CREDENTIAL_NAME } from './shared/constants.js';
+export { clearEventCache, isDuplicateEvent } from './shared/eventStore.js';
+export { SallaActionsCredentials, SallaActionsRequestOptions, SallaActionsResponse, SallaProxyRequestOptions, createSallaActionsClient } from './shared/httpClient.js';
+export { SallaActionsApi } from './credentials/SallaActionsApi.credentials.js';
+import 'n8n-workflow';

package/dist/index.js

@@ -0,0 +1,317 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  SALLA_BRAND_COLOR: () => SALLA_BRAND_COLOR,
+  SALLA_CREDENTIAL_NAME: () => SALLA_CREDENTIAL_NAME,
+  SallaActionsApi: () => SallaActionsApi,
+  clearEventCache: () => clearEventCache,
+  createSallaActionsClient: () => createSallaActionsClient,
+  isDuplicateEvent: () => isDuplicateEvent
+});
+module.exports = __toCommonJS(index_exports);
+
+// shared/constants.ts
+var SALLA_CREDENTIAL_NAME = "sallaActionsApi";
+var DEFAULT_BASE_URL = "https://app.n8ndesigner.com";
+var SALLA_BRAND_COLOR = "#00C58E";
+
+// shared/eventStore.ts
+var TTL_MS = 10 * 60 * 1e3;
+var cache = /* @__PURE__ */ new Map();
+function prune() {
+  const now = Date.now();
+  for (const [id, expiresAt] of cache.entries()) {
+    if (expiresAt <= now) {
+      cache.delete(id);
+    }
+  }
+}
+function isDuplicateEvent(eventId) {
+  if (!eventId) {
+    return false;
+  }
+  prune();
+  const now = Date.now();
+  const expiresAt = cache.get(eventId);
+  if (expiresAt && expiresAt > now) {
+    return true;
+  }
+  cache.set(eventId, now + TTL_MS);
+  return false;
+}
+function clearEventCache() {
+  cache.clear();
+}
+
+// shared/httpClient.ts
+var import_n8n_workflow = require("n8n-workflow");
+var DEFAULT_TIMEOUT = 12e3;
+var RETRY_DELAYS = [1e3, 3e3];
+var RETRY_ERROR_CODES = /* @__PURE__ */ new Set(["ETIMEDOUT", "ECONNRESET"]);
+function trimTrailingSlash(input) {
+  const value = input && input.trim() !== "" ? input : DEFAULT_BASE_URL;
+  return value.replace(/\/+$/, "");
+}
+function ensureLeadingSlash(path) {
+  if (!path.startsWith("/")) {
+    return "/" + path;
+  }
+  return path;
+}
+function buildActionsUrl(baseUrl, path) {
+  const normalizedBase = trimTrailingSlash(baseUrl);
+  return normalizedBase + "/api/actions" + ensureLeadingSlash(path);
+}
+function buildProxyUrl(baseUrl) {
+  const normalizedBase = trimTrailingSlash(baseUrl);
+  return normalizedBase + "/api/merchant/salla";
+}
+function normalizeResponse(rawBody, statusCode) {
+  const raw = rawBody ?? null;
+  if (rawBody === void 0 || rawBody === null || rawBody === "") {
+    return {
+      ok: statusCode >= 200 && statusCode < 300,
+      status: statusCode,
+      data: null,
+      error: statusCode >= 400 ? "Request failed with status " + statusCode : null,
+      raw
+    };
+  }
+  if (typeof rawBody !== "object") {
+    return {
+      ok: statusCode >= 200 && statusCode < 300,
+      status: statusCode,
+      data: rawBody,
+      error: statusCode >= 400 ? String(rawBody) : null,
+      raw
+    };
+  }
+  const body = rawBody;
+  const successFlag = typeof body.success === "boolean" ? body.success : void 0;
+  const okFlag = typeof body.ok === "boolean" ? body.ok : void 0;
+  const status = typeof body.status === "number" ? body.status : statusCode;
+  const ok = okFlag ?? successFlag ?? (status >= 200 && status < 300);
+  let data = null;
+  if (Object.prototype.hasOwnProperty.call(body, "data")) {
+    data = body.data ?? null;
+  }
+  const errors = body.errors;
+  if (errors) {
+    if (data && typeof data === "object") {
+      data = {
+        ...data,
+        errors
+      };
+    } else {
+      data = { errors };
+    }
+  }
+  let error = null;
+  if (typeof body.error === "string") {
+    error = body.error;
+  } else if (!ok) {
+    if (typeof body.message === "string" && body.message.trim() !== "") {
+      error = body.message;
+    } else if (body.error && typeof body.error === "object") {
+      error = JSON.stringify(body.error);
+    }
+  }
+  if (!ok && !error) {
+    error = "Request failed with status " + status;
+  }
+  return {
+    ok,
+    status,
+    data: data ?? null,
+    error,
+    raw
+  };
+}
+function shouldRetryStatus(status) {
+  return status === 429 || status >= 500;
+}
+function shouldRetryError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  const status = err.statusCode ?? err.response?.statusCode;
+  if (typeof status === "number" && shouldRetryStatus(status)) {
+    return true;
+  }
+  const code = err.code ?? err.cause?.code;
+  return code ? RETRY_ERROR_CODES.has(code) : false;
+}
+async function executeWithRetry(caller, requestOptions) {
+  let lastError;
+  for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {
+    try {
+      const response = await caller(requestOptions);
+      const normalized = normalizeResponse(response.body, response.statusCode);
+      if (shouldRetryStatus(normalized.status) && attempt < RETRY_DELAYS.length) {
+        await (0, import_n8n_workflow.sleep)(RETRY_DELAYS[attempt]);
+        continue;
+      }
+      return normalized;
+    } catch (error) {
+      lastError = error;
+      if (attempt < RETRY_DELAYS.length && shouldRetryError(error)) {
+        await (0, import_n8n_workflow.sleep)(RETRY_DELAYS[attempt]);
+        continue;
+      }
+      break;
+    }
+  }
+  if (lastError && typeof lastError === "object") {
+    const err = lastError;
+    const status = err.statusCode ?? err.response?.statusCode ?? 0;
+    const body = err.response?.body;
+    const fallback = normalizeResponse(body, status || 0);
+    if (fallback.error && err.message && !fallback.error.includes(err.message)) {
+      fallback.error = fallback.error + ". " + err.message;
+    } else if (!fallback.error) {
+      fallback.error = err.message ?? "Request failed";
+    }
+    return fallback;
+  }
+  return {
+    ok: false,
+    status: 0,
+    data: null,
+    error: lastError instanceof Error ? lastError.message : "Request failed",
+    raw: null
+  };
+}
+function buildCaller(context, credentialType) {
+  return async (options) => {
+    const response = await context.helpers.requestWithAuthentication.call(
+      context,
+      credentialType,
+      options
+    );
+    return {
+      statusCode: response.statusCode,
+      body: response.body,
+      headers: response.headers
+    };
+  };
+}
+function createSallaActionsClient(context, credentials, credentialType = SALLA_CREDENTIAL_NAME) {
+  const caller = buildCaller(context, credentialType);
+  async function request(options) {
+    const requestOptions = {
+      method: options.method,
+      url: buildActionsUrl(credentials.baseUrl, options.path),
+      qs: options.qs,
+      body: options.body,
+      headers: options.headers,
+      json: true,
+      timeout: DEFAULT_TIMEOUT
+    };
+    const advanced = requestOptions;
+    advanced["returnFullResponse"] = true;
+    advanced["resolveWithFullResponse"] = true;
+    advanced["ignoreHttpStatusErrors"] = true;
+    return executeWithRetry(caller, requestOptions);
+  }
+  async function proxy(options) {
+    const requestOptions = {
+      method: "POST",
+      url: buildProxyUrl(credentials.baseUrl),
+      body: {
+        salla_merchant_id: credentials.salla_merchant_id,
+        method: options.method,
+        path: options.path,
+        payload: options.payload ?? null
+      },
+      json: true,
+      timeout: DEFAULT_TIMEOUT
+    };
+    const advanced = requestOptions;
+    advanced["returnFullResponse"] = true;
+    advanced["resolveWithFullResponse"] = true;
+    advanced["ignoreHttpStatusErrors"] = true;
+    return executeWithRetry(caller, requestOptions);
+  }
+  return {
+    request,
+    proxy
+  };
+}
+
+// credentials/SallaActionsApi.credentials.ts
+var SallaActionsApi = class {
+  constructor() {
+    this.name = SALLA_CREDENTIAL_NAME;
+    this.displayName = "Salla (N8NDesigner Actions)";
+    this.documentationUrl = void 0;
+    this.properties = [
+      {
+        displayName: "Base URL",
+        name: "baseUrl",
+        type: "string",
+        default: DEFAULT_BASE_URL,
+        placeholder: DEFAULT_BASE_URL,
+        description: "Root URL for the N8NDesigner Actions API. Leave as default unless instructed otherwise."
+      },
+      {
+        displayName: "Salla Merchant ID",
+        name: "salla_merchant_id",
+        type: "string",
+        default: "",
+        required: true,
+        description: "Numeric merchant identifier from your Salla store configuration."
+      },
+      {
+        displayName: "MAK Key",
+        name: "makKey",
+        type: "string",
+        typeOptions: {
+          password: true
+        },
+        default: "",
+        required: true,
+        description: "Backend-issued token that starts with mak_. Used for Bearer authentication."
+      }
+    ];
+    this.authenticate = {
+      type: "generic",
+      properties: {
+        headers: {
+          Authorization: "={{'Bearer ' + $credentials.makKey}}",
+          "Content-Type": "application/json"
+        }
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BASE_URL,
+  SALLA_BRAND_COLOR,
+  SALLA_CREDENTIAL_NAME,
+  SallaActionsApi,
+  clearEventCache,
+  createSallaActionsClient,
+  isDuplicateEvent
+});

package/dist/nodes/Actions/SallaActions.node.d.ts

@@ -0,0 +1,14 @@
+import { INodeType, INodeTypeDescription, IExecuteFunctions, INodeExecutionData, ILoadOptionsFunctions } from 'n8n-workflow';
+
+declare class SallaActions implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getSallaSubResources(this: ILoadOptionsFunctions): Promise<Array<{ name: string; value: string }>>;
+            getSallaOperations(this: ILoadOptionsFunctions): Promise<Array<{ name: string; value: string }>>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}
+
+export { SallaActions };