@egose/n8n-client 0.1.1

package/chunk-4FXZT5HT.js

@@ -0,0 +1,27 @@
+// src/handles/tag.ts
+var TagHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/tags", params);
+  }
+  async get(id) {
+    return this.http.get(`/tags/${id}`);
+  }
+  async create(data) {
+    return this.http.post("/tags", data);
+  }
+  async update(id, data) {
+    return this.http.put(`/tags/${id}`, data);
+  }
+  async delete(id) {
+    return this.http.delete(`/tags/${id}`);
+  }
+};
+
+export {
+  TagHandle
+};
+//# sourceMappingURL=chunk-4FXZT5HT.js.map

package/chunk-5DYA4LAX.cjs

@@ -0,0 +1,110 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk7B5DLJYYcjs = require('./chunk-7B5DLJYY.cjs');
+
+// src/http-client.ts
+var HttpError = class extends Error {
+  
+  
+  constructor(status, message, data) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+    this.data = data;
+  }
+};
+var HttpClient = class {
+  
+  
+  
+  constructor(config) {
+    if (!config.apiKey && !config.bearerToken) {
+      throw new Error("Either apiKey or bearerToken must be provided");
+    }
+    if (config.apiKey && config.bearerToken) {
+      throw new Error("Provide either apiKey or bearerToken, not both");
+    }
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.bearerToken = config.bearerToken;
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (this.bearerToken) {
+      headers["Authorization"] = `Bearer ${this.bearerToken}`;
+    } else if (this.apiKey) {
+      headers["X-N8N-API-KEY"] = this.apiKey;
+    }
+    return headers;
+  }
+  async parseResponseData(response) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      return response.json();
+    }
+    if (contentType.includes("application/gzip") || contentType.includes("application/octet-stream")) {
+      return response.arrayBuffer();
+    }
+    const text = await response.text();
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      return text;
+    }
+  }
+  async request(options) {
+    const { method, path, body, query, headers: extraHeaders } = options;
+    const queryString = query ? "?" + Object.entries(query).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&") : "";
+    const url = `${this.baseUrl}/api/v1${path}${queryString}`;
+    const headers = {
+      ...this.buildHeaders(),
+      ...extraHeaders
+    };
+    const response = await _chunk7B5DLJYYcjs.retryTransientError.call(void 0, async () => {
+      const init = { method, headers };
+      if (body !== void 0 && method !== "GET") {
+        if (body instanceof FormData) {
+          init.body = body;
+          delete headers["Content-Type"];
+        } else {
+          init.body = JSON.stringify(body);
+        }
+      }
+      const response2 = await fetch(url, init);
+      if (!response2.ok && response2.status !== 204) {
+        const data = await this.parseResponseData(response2);
+        const message = _optionalChain([data, 'optionalAccess', _ => _.message]) || `HTTP ${response2.status}`;
+        throw new HttpError(response2.status, message, data);
+      }
+      return response2;
+    });
+    if (response.status === 204) {
+      return void 0;
+    }
+    return await this.parseResponseData(response);
+  }
+  async get(path, query, headers) {
+    return this.request({ method: "GET", path, query, headers });
+  }
+  async post(path, body, query, headers) {
+    return this.request({ method: "POST", path, body, query, headers });
+  }
+  async put(path, body, query, headers) {
+    return this.request({ method: "PUT", path, body, query, headers });
+  }
+  async patch(path, body, query, headers) {
+    return this.request({ method: "PATCH", path, body, query, headers });
+  }
+  async delete(path, query, headers) {
+    return this.request({ method: "DELETE", path, query, headers });
+  }
+};
+
+
+
+
+exports.HttpError = HttpError; exports.HttpClient = HttpClient;
+//# sourceMappingURL=chunk-5DYA4LAX.cjs.map

package/chunk-5FIB7YIT.js

@@ -0,0 +1,24 @@
+// src/handles/community-package.ts
+var CommunityPackageHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    return this.http.get("/community-packages");
+  }
+  async install(data) {
+    return this.http.post("/community-packages", data);
+  }
+  async update(name, data) {
+    return this.http.patch(`/community-packages/${name}`, data);
+  }
+  async uninstall(name) {
+    await this.http.delete(`/community-packages/${name}`);
+  }
+};
+
+export {
+  CommunityPackageHandle
+};
+//# sourceMappingURL=chunk-5FIB7YIT.js.map

package/chunk-5PHEDSSO.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/handles/tag.ts
+var TagHandle = class {
+  
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/tags", params);
+  }
+  async get(id) {
+    return this.http.get(`/tags/${id}`);
+  }
+  async create(data) {
+    return this.http.post("/tags", data);
+  }
+  async update(id, data) {
+    return this.http.put(`/tags/${id}`, data);
+  }
+  async delete(id) {
+    return this.http.delete(`/tags/${id}`);
+  }
+};
+
+
+
+exports.TagHandle = TagHandle;
+//# sourceMappingURL=chunk-5PHEDSSO.cjs.map

package/chunk-5SY4KM4Q.js

@@ -0,0 +1,15 @@
+// src/handles/insights.ts
+var InsightsHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async getSummary(params) {
+    return this.http.get("/insights/summary", params);
+  }
+};
+
+export {
+  InsightsHandle
+};
+//# sourceMappingURL=chunk-5SY4KM4Q.js.map

package/chunk-7B5DLJYY.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/retry.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+function isTransientError(error) {
+  if (error instanceof Error && "status" in error) {
+    return RETRYABLE_STATUS_CODES.has(error.status);
+  }
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return true;
+  }
+  return false;
+}
+async function retryTransientError(operation, attempts = 3) {
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientError(error) || attempt === attempts - 1) {
+        throw error;
+      }
+      const delay = Math.min(1e3 * 2 ** attempt, 1e4);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw new Error("Unreachable");
+}
+
+
+
+exports.retryTransientError = retryTransientError;
+//# sourceMappingURL=chunk-7B5DLJYY.cjs.map

package/chunk-BWLFUF76.js

@@ -0,0 +1,36 @@
+// src/handles/credential.ts
+var CredentialHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/credentials", params);
+  }
+  async get(id) {
+    return this.http.get(`/credentials/${id}`);
+  }
+  async create(data) {
+    return this.http.post("/credentials", data);
+  }
+  async update(id, data) {
+    return this.http.patch(`/credentials/${id}`, data);
+  }
+  async delete(id) {
+    return this.http.delete(`/credentials/${id}`);
+  }
+  async test(id) {
+    return this.http.post(`/credentials/${id}/test`);
+  }
+  async transfer(id, destinationProjectId) {
+    await this.http.put(`/credentials/${id}/transfer`, { destinationProjectId });
+  }
+  async getSchema(credentialTypeName) {
+    return this.http.get(`/credentials/schema/${credentialTypeName}`);
+  }
+};
+
+export {
+  CredentialHandle
+};
+//# sourceMappingURL=chunk-BWLFUF76.js.map

package/chunk-CES6KIG5.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/handles/credential.ts
+var CredentialHandle = class {
+  
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/credentials", params);
+  }
+  async get(id) {
+    return this.http.get(`/credentials/${id}`);
+  }
+  async create(data) {
+    return this.http.post("/credentials", data);
+  }
+  async update(id, data) {
+    return this.http.patch(`/credentials/${id}`, data);
+  }
+  async delete(id) {
+    return this.http.delete(`/credentials/${id}`);
+  }
+  async test(id) {
+    return this.http.post(`/credentials/${id}/test`);
+  }
+  async transfer(id, destinationProjectId) {
+    await this.http.put(`/credentials/${id}/transfer`, { destinationProjectId });
+  }
+  async getSchema(credentialTypeName) {
+    return this.http.get(`/credentials/schema/${credentialTypeName}`);
+  }
+};
+
+
+
+exports.CredentialHandle = CredentialHandle;
+//# sourceMappingURL=chunk-CES6KIG5.cjs.map

package/chunk-CUO2M75Z.js

@@ -0,0 +1,29 @@
+// src/handles/n8n-package.ts
+var N8nPackageHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async exportWorkflows(data) {
+    return this.http.post("/n8n-packages/export", data, void 0, { Accept: "application/gzip" });
+  }
+  async importPackage(pkg, options) {
+    const formData = new FormData();
+    formData.append("package", pkg);
+    if (options?.projectId) formData.append("projectId", options.projectId);
+    if (options?.folderId) formData.append("folderId", options.folderId);
+    if (options?.credentialMatchingMode) formData.append("credentialMatchingMode", options.credentialMatchingMode);
+    if (options?.credentialMissingMode) formData.append("credentialMissingMode", options.credentialMissingMode);
+    formData.append("workflowConflictPolicy", options.workflowConflictPolicy);
+    return this.http.request({
+      method: "POST",
+      path: "/n8n-packages/import",
+      body: formData
+    });
+  }
+};
+
+export {
+  N8nPackageHandle
+};
+//# sourceMappingURL=chunk-CUO2M75Z.js.map

package/chunk-DJCG37LZ.js

@@ -0,0 +1,32 @@
+// src/handles/folder.ts
+var FolderHandle = class {
+  http;
+  projectId;
+  constructor(http, projectId) {
+    this.http = http;
+    this.projectId = projectId;
+  }
+  async list(params) {
+    return this.http.get(`/projects/${this.projectId}/folders`, params);
+  }
+  async get(folderId) {
+    return this.http.get(`/projects/${this.projectId}/folders/${folderId}`);
+  }
+  async create(data) {
+    return this.http.post(`/projects/${this.projectId}/folders`, data);
+  }
+  async update(folderId, data) {
+    return this.http.patch(`/projects/${this.projectId}/folders/${folderId}`, data);
+  }
+  async delete(folderId, transferToFolderId) {
+    await this.http.delete(
+      `/projects/${this.projectId}/folders/${folderId}`,
+      transferToFolderId ? { transferToFolderId } : void 0
+    );
+  }
+};
+
+export {
+  FolderHandle
+};
+//# sourceMappingURL=chunk-DJCG37LZ.js.map

package/chunk-DK5NLZ6U.js

@@ -0,0 +1,110 @@
+import {
+  retryTransientError
+} from "./chunk-DURH6QOX.js";
+
+// src/http-client.ts
+var HttpError = class extends Error {
+  status;
+  data;
+  constructor(status, message, data) {
+    super(message);
+    this.name = "HttpError";
+    this.status = status;
+    this.data = data;
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  bearerToken;
+  constructor(config) {
+    if (!config.apiKey && !config.bearerToken) {
+      throw new Error("Either apiKey or bearerToken must be provided");
+    }
+    if (config.apiKey && config.bearerToken) {
+      throw new Error("Provide either apiKey or bearerToken, not both");
+    }
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+    this.bearerToken = config.bearerToken;
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (this.bearerToken) {
+      headers["Authorization"] = `Bearer ${this.bearerToken}`;
+    } else if (this.apiKey) {
+      headers["X-N8N-API-KEY"] = this.apiKey;
+    }
+    return headers;
+  }
+  async parseResponseData(response) {
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      return response.json();
+    }
+    if (contentType.includes("application/gzip") || contentType.includes("application/octet-stream")) {
+      return response.arrayBuffer();
+    }
+    const text = await response.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  async request(options) {
+    const { method, path, body, query, headers: extraHeaders } = options;
+    const queryString = query ? "?" + Object.entries(query).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&") : "";
+    const url = `${this.baseUrl}/api/v1${path}${queryString}`;
+    const headers = {
+      ...this.buildHeaders(),
+      ...extraHeaders
+    };
+    const response = await retryTransientError(async () => {
+      const init = { method, headers };
+      if (body !== void 0 && method !== "GET") {
+        if (body instanceof FormData) {
+          init.body = body;
+          delete headers["Content-Type"];
+        } else {
+          init.body = JSON.stringify(body);
+        }
+      }
+      const response2 = await fetch(url, init);
+      if (!response2.ok && response2.status !== 204) {
+        const data = await this.parseResponseData(response2);
+        const message = data?.message || `HTTP ${response2.status}`;
+        throw new HttpError(response2.status, message, data);
+      }
+      return response2;
+    });
+    if (response.status === 204) {
+      return void 0;
+    }
+    return await this.parseResponseData(response);
+  }
+  async get(path, query, headers) {
+    return this.request({ method: "GET", path, query, headers });
+  }
+  async post(path, body, query, headers) {
+    return this.request({ method: "POST", path, body, query, headers });
+  }
+  async put(path, body, query, headers) {
+    return this.request({ method: "PUT", path, body, query, headers });
+  }
+  async patch(path, body, query, headers) {
+    return this.request({ method: "PATCH", path, body, query, headers });
+  }
+  async delete(path, query, headers) {
+    return this.request({ method: "DELETE", path, query, headers });
+  }
+};
+
+export {
+  HttpError,
+  HttpClient
+};
+//# sourceMappingURL=chunk-DK5NLZ6U.js.map

package/chunk-DURH6QOX.js

@@ -0,0 +1,30 @@
+// src/utils/retry.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+function isTransientError(error) {
+  if (error instanceof Error && "status" in error) {
+    return RETRYABLE_STATUS_CODES.has(error.status);
+  }
+  if (error instanceof TypeError && error.message.includes("fetch")) {
+    return true;
+  }
+  return false;
+}
+async function retryTransientError(operation, attempts = 3) {
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientError(error) || attempt === attempts - 1) {
+        throw error;
+      }
+      const delay = Math.min(1e3 * 2 ** attempt, 1e4);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw new Error("Unreachable");
+}
+
+export {
+  retryTransientError
+};
+//# sourceMappingURL=chunk-DURH6QOX.js.map

package/chunk-FHAZIAHR.js

@@ -0,0 +1,15 @@
+// src/handles/discover.ts
+var DiscoverHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async get(params) {
+    return this.http.get("/discover", params);
+  }
+};
+
+export {
+  DiscoverHandle
+};
+//# sourceMappingURL=chunk-FHAZIAHR.js.map

package/chunk-FZX275Y3.js

@@ -0,0 +1,24 @@
+// src/handles/variable.ts
+var VariableHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/variables", params);
+  }
+  async create(data) {
+    await this.http.post("/variables", data);
+  }
+  async update(id, data) {
+    await this.http.put(`/variables/${id}`, data);
+  }
+  async delete(id) {
+    await this.http.delete(`/variables/${id}`);
+  }
+};
+
+export {
+  VariableHandle
+};
+//# sourceMappingURL=chunk-FZX275Y3.js.map

package/chunk-I7NGIQIM.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/handles/workflow.ts
+var WorkflowHandle = class {
+  
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    return this.http.get("/workflows", params);
+  }
+  async get(id, params) {
+    return this.http.get(`/workflows/${id}`, params);
+  }
+  async create(data) {
+    return this.http.post("/workflows", data);
+  }
+  async update(id, data) {
+    return this.http.put(`/workflows/${id}`, data);
+  }
+  async delete(id) {
+    return this.http.delete(`/workflows/${id}`);
+  }
+  async activate(id, data) {
+    return this.http.post(`/workflows/${id}/activate`, data);
+  }
+  async deactivate(id) {
+    return this.http.post(`/workflows/${id}/deactivate`);
+  }
+  async archive(id) {
+    return this.http.post(`/workflows/${id}/archive`);
+  }
+  async unarchive(id) {
+    return this.http.post(`/workflows/${id}/unarchive`);
+  }
+  async transfer(id, destinationProjectId) {
+    await this.http.put(`/workflows/${id}/transfer`, { destinationProjectId });
+  }
+  async getTags(id) {
+    return this.http.get(`/workflows/${id}/tags`);
+  }
+  async updateTags(id, tags) {
+    return this.http.put(`/workflows/${id}/tags`, tags);
+  }
+  async getVersion(id, versionId) {
+    return this.http.get(`/workflows/${id}/${versionId}`);
+  }
+};
+
+
+
+exports.WorkflowHandle = WorkflowHandle;
+//# sourceMappingURL=chunk-I7NGIQIM.cjs.map

package/chunk-JR7A75YV.js

@@ -0,0 +1,15 @@
+// src/handles/source-control.ts
+var SourceControlHandle = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async pull(data) {
+    return this.http.post("/source-control/pull", data);
+  }
+};
+
+export {
+  SourceControlHandle
+};
+//# sourceMappingURL=chunk-JR7A75YV.js.map

package/chunk-M7GX3MEN.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/handles/audit.ts
+var AuditHandle = class {
+  
+  constructor(http) {
+    this.http = http;
+  }
+  async generate(data) {
+    return this.http.post("/audit", data);
+  }
+};
+
+
+
+exports.AuditHandle = AuditHandle;
+//# sourceMappingURL=chunk-M7GX3MEN.cjs.map