@egose/n8n-client 0.1.1 → 0.2.0

package/chunk-GEWLPVNV.cjs

@@ -0,0 +1,48 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkTY76RTXQcjs = require('./chunk-TY76RTXQ.cjs');
+
+
+var _chunkLC3TKRMXcjs = require('./chunk-LC3TKRMX.cjs');
+
+
+var _chunk4M2HGY3Fcjs = require('./chunk-4M2HGY3F.cjs');
+
+// src/clients/community-package.ts
+var CommunityPackageClient = class extends _chunk4M2HGY3Fcjs.BaseClient {
+  async list() {
+    return this.http.get("/community-packages");
+  }
+  async listResources() {
+    const communityPackages = await this.list();
+    return communityPackages.map((communityPackage) => new (0, _chunkTY76RTXQcjs.CommunityPackageResource)(this, communityPackage));
+  }
+  async getResource(name) {
+    const communityPackages = await this.list();
+    const communityPackage = communityPackages.find((entry) => entry.packageName === name);
+    if (!communityPackage) {
+      throw new (0, _chunkLC3TKRMXcjs.HttpError)(404, `Community package not found: ${name}`, { name });
+    }
+    return new (0, _chunkTY76RTXQcjs.CommunityPackageResource)(this, communityPackage);
+  }
+  async install(data) {
+    return this.http.post("/community-packages", data);
+  }
+  async installResource(data) {
+    return new (0, _chunkTY76RTXQcjs.CommunityPackageResource)(this, await this.install(data));
+  }
+  async update(name, data) {
+    return this.http.patch(`/community-packages/${name}`, data);
+  }
+  async updateResource(name, data) {
+    return new (0, _chunkTY76RTXQcjs.CommunityPackageResource)(this, await this.update(name, data));
+  }
+  async uninstall(name) {
+    await this.http.delete(`/community-packages/${name}`);
+  }
+};
+
+
+
+exports.CommunityPackageClient = CommunityPackageClient;
+//# sourceMappingURL=chunk-GEWLPVNV.cjs.map

package/{chunk-I7NGIQIM.cjs → chunk-GZ3POWDP.cjs}

@@ -1,21 +1,43 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/handles/workflow.ts
-var WorkflowHandle = class {
-  
-  constructor(http) {
-    this.http = http;
-  }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk3YWWR6UDcjs = require('./chunk-3YWWR6UD.cjs');
+
+
+var _chunkYBMEMKCNcjs = require('./chunk-YBMEMKCN.cjs');
+
+
+var _chunk4M2HGY3Fcjs = require('./chunk-4M2HGY3F.cjs');
+
+// src/clients/workflow.ts
+var WorkflowClient = class extends _chunk4M2HGY3Fcjs.BaseClient {
   async list(params) {
     return this.http.get("/workflows", params);
   }
   async get(id, params) {
     return this.http.get(`/workflows/${id}`, params);
   }
+  async getResource(id, params) {
+    return new (0, _chunk3YWWR6UDcjs.WorkflowResource)(this, new (0, _chunkYBMEMKCNcjs.ExecutionClient)(this.http), await this.get(id, params));
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((workflow) => new (0, _chunk3YWWR6UDcjs.WorkflowResource)(this, new (0, _chunkYBMEMKCNcjs.ExecutionClient)(this.http), workflow)),
+      nextCursor: response.nextCursor
+    };
+  }
   async create(data) {
     return this.http.post("/workflows", data);
   }
+  async createResource(data) {
+    return new (0, _chunk3YWWR6UDcjs.WorkflowResource)(this, new (0, _chunkYBMEMKCNcjs.ExecutionClient)(this.http), await this.create(data));
+  }
   async update(id, data) {
     return this.http.put(`/workflows/${id}`, data);
   }
+  async updateResource(id, data) {
+    return new (0, _chunk3YWWR6UDcjs.WorkflowResource)(this, new (0, _chunkYBMEMKCNcjs.ExecutionClient)(this.http), await this.update(id, data));
+  }
   async delete(id) {
     return this.http.delete(`/workflows/${id}`);
   }
@@ -47,5 +69,5 @@ var WorkflowHandle = class {
 
 
 
-exports.WorkflowHandle = WorkflowHandle;
-//# sourceMappingURL=chunk-I7NGIQIM.cjs.map
+exports.WorkflowClient = WorkflowClient;
+//# sourceMappingURL=chunk-GZ3POWDP.cjs.map

package/chunk-HISH4ORK.js

@@ -0,0 +1,59 @@
+import {
+  VariableResource
+} from "./chunk-2R6A6NJE.js";
+import {
+  HttpError
+} from "./chunk-RMEH2UPX.js";
+import {
+  BaseClient
+} from "./chunk-Q6FSREKN.js";
+
+// src/clients/variable.ts
+var VariableClient = class extends BaseClient {
+  async list(params) {
+    return this.http.get("/variables", params);
+  }
+  async get(id, params) {
+    const variable = await this.findVariable(id, params);
+    if (!variable) {
+      throw new HttpError(404, `Variable not found: ${id}`, { id });
+    }
+    return variable;
+  }
+  async getResource(id, params) {
+    return new VariableResource(this, await this.get(id, params), params);
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((variable) => new VariableResource(this, variable, params)),
+      nextCursor: response.nextCursor
+    };
+  }
+  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}`);
+  }
+  async findVariable(id, params) {
+    let cursor = params?.cursor;
+    do {
+      const response = await this.list({ ...params, cursor });
+      const variable = response.data.find((entry) => entry.id === id);
+      if (variable) {
+        return variable;
+      }
+      cursor = response.nextCursor;
+    } while (cursor);
+    return void 0;
+  }
+};
+
+export {
+  VariableClient
+};
+//# sourceMappingURL=chunk-HISH4ORK.js.map

package/chunk-I4MMTW33.js

@@ -0,0 +1,98 @@
+import {
+  HttpError
+} from "./chunk-RMEH2UPX.js";
+import {
+  BaseResource
+} from "./chunk-TLBDBRPJ.js";
+
+// src/resources/workflow.ts
+var WorkflowResource = class extends BaseResource {
+  constructor(workflows, executionsClient, workflow) {
+    super(workflow);
+    this.workflows = workflows;
+    this.executionsClient = executionsClient;
+  }
+  workflows;
+  executionsClient;
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get active() {
+    return this.data.active;
+  }
+  get isArchived() {
+    return this.data.isArchived;
+  }
+  get versionId() {
+    return this.data.versionId;
+  }
+  async update(data) {
+    return this.replaceSnapshot(await this.workflows.update(this.id, data));
+  }
+  async delete() {
+    return this.workflows.delete(this.id);
+  }
+  async activate(data) {
+    return this.replaceSnapshot(await this.workflows.activate(this.id, data));
+  }
+  async deactivate() {
+    return this.replaceSnapshot(await this.workflows.deactivate(this.id));
+  }
+  async archive() {
+    return this.replaceSnapshot(await this.workflows.archive(this.id));
+  }
+  async unarchive() {
+    return this.replaceSnapshot(await this.workflows.unarchive(this.id));
+  }
+  async transfer(destinationProjectId) {
+    await this.workflows.transfer(this.id, destinationProjectId);
+  }
+  async getTags() {
+    return this.workflows.getTags(this.id);
+  }
+  async updateTags(tags) {
+    const updatedTags = await this.workflows.updateTags(this.id, tags);
+    this.mergeSnapshot({ tags: updatedTags });
+    return updatedTags;
+  }
+  async getVersion(versionId) {
+    return this.workflows.getVersion(this.id, versionId);
+  }
+  executions() {
+    return {
+      list: (params) => this.executionsClient.list({ ...params, workflowId: this.id }),
+      listResources: (params) => this.executionsClient.listResources({ ...params, workflowId: this.id }),
+      get: async (id, params) => {
+        if (!await this.hasExecutionInWorkflow(id)) {
+          throw new HttpError(404, `Execution not found in workflow: ${id}`, { id, workflowId: this.id });
+        }
+        return this.executionsClient.get(id, params);
+      },
+      getResource: async (id, params) => {
+        if (!await this.hasExecutionInWorkflow(id)) {
+          throw new HttpError(404, `Execution not found in workflow: ${id}`, { id, workflowId: this.id });
+        }
+        return this.executionsClient.getResource(id, params);
+      }
+    };
+  }
+  async hasExecutionInWorkflow(id) {
+    let cursor;
+    do {
+      const response = await this.executionsClient.list({ workflowId: this.id, cursor });
+      if (response.data.some((execution) => execution.id === id)) {
+        return true;
+      }
+      cursor = response.nextCursor;
+    } while (cursor);
+    return false;
+  }
+};
+
+export {
+  WorkflowResource
+};
+//# sourceMappingURL=chunk-I4MMTW33.js.map

package/chunk-KRPRS2E5.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk7H75UBMHcjs = require('./chunk-7H75UBMH.cjs');
+
+
+var _chunk4M2HGY3Fcjs = require('./chunk-4M2HGY3F.cjs');
+
+// src/clients/tag.ts
+var TagClient = class extends _chunk4M2HGY3Fcjs.BaseClient {
+  async list(params) {
+    return this.http.get("/tags", params);
+  }
+  async get(id) {
+    return this.http.get(`/tags/${id}`);
+  }
+  async getResource(id) {
+    return new (0, _chunk7H75UBMHcjs.TagResource)(this, await this.get(id));
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((tag) => new (0, _chunk7H75UBMHcjs.TagResource)(this, tag)),
+      nextCursor: response.nextCursor
+    };
+  }
+  async create(data) {
+    return this.http.post("/tags", data);
+  }
+  async createResource(data) {
+    return new (0, _chunk7H75UBMHcjs.TagResource)(this, await this.create(data));
+  }
+  async update(id, data) {
+    return this.http.put(`/tags/${id}`, data);
+  }
+  async updateResource(id, data) {
+    return new (0, _chunk7H75UBMHcjs.TagResource)(this, await this.update(id, data));
+  }
+  async delete(id) {
+    return this.http.delete(`/tags/${id}`);
+  }
+};
+
+
+
+exports.TagClient = TagClient;
+//# sourceMappingURL=chunk-KRPRS2E5.cjs.map

package/chunk-L2FFL3BY.js

@@ -0,0 +1,35 @@
+import {
+  BaseResource
+} from "./chunk-TLBDBRPJ.js";
+
+// src/resources/user.ts
+var UserResource = class extends BaseResource {
+  constructor(users, user, params) {
+    super(user);
+    this.users = users;
+    this.params = params;
+  }
+  users;
+  params;
+  get id() {
+    return this.data.id;
+  }
+  get email() {
+    return this.data.email;
+  }
+  async refresh() {
+    return this.replaceSnapshot(await this.users.get(this.id, this.params));
+  }
+  async delete() {
+    await this.users.delete(this.id);
+  }
+  async changeRole(newRoleName) {
+    await this.users.changeRole(this.id, newRoleName);
+    return this.mergeSnapshot({ role: newRoleName });
+  }
+};
+
+export {
+  UserResource
+};
+//# sourceMappingURL=chunk-L2FFL3BY.js.map

package/{chunk-5DYA4LAX.cjs → chunk-LC3TKRMX.cjs}

@@ -107,4 +107,4 @@ var HttpClient = class {
 
 
 exports.HttpError = HttpError; exports.HttpClient = HttpClient;
-//# sourceMappingURL=chunk-5DYA4LAX.cjs.map
+//# sourceMappingURL=chunk-LC3TKRMX.cjs.map

package/chunk-LQULSPET.cjs

@@ -0,0 +1,55 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkMMN2UKTIcjs = require('./chunk-MMN2UKTI.cjs');
+
+
+var _chunk4M2HGY3Fcjs = require('./chunk-4M2HGY3F.cjs');
+
+// src/clients/credential.ts
+var CredentialClient = class extends _chunk4M2HGY3Fcjs.BaseClient {
+  async list(params) {
+    return this.http.get("/credentials", params);
+  }
+  async get(id) {
+    return this.http.get(`/credentials/${id}`);
+  }
+  async getResource(id) {
+    return new (0, _chunkMMN2UKTIcjs.CredentialResource)(this, await this.get(id));
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((credential) => new (0, _chunkMMN2UKTIcjs.CredentialResource)(this, credential)),
+      nextCursor: response.nextCursor
+    };
+  }
+  async create(data) {
+    return this.http.post("/credentials", data);
+  }
+  async createResource(data) {
+    return new (0, _chunkMMN2UKTIcjs.CredentialResource)(this, await this.create(data));
+  }
+  async update(id, data) {
+    return this.http.patch(`/credentials/${id}`, data);
+  }
+  async updateResource(id, data) {
+    return new (0, _chunkMMN2UKTIcjs.CredentialResource)(this, await this.update(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.CredentialClient = CredentialClient;
+//# sourceMappingURL=chunk-LQULSPET.cjs.map

package/chunk-LTYQTCHM.js

@@ -0,0 +1,196 @@
+import {
+  DataTableResource
+} from "./chunk-T62VHXNY.js";
+import {
+  HttpError
+} from "./chunk-RMEH2UPX.js";
+import {
+  BaseResource
+} from "./chunk-TLBDBRPJ.js";
+
+// src/resources/project.ts
+var ProjectResource = class extends BaseResource {
+  constructor(projects, workflowsClient, foldersClient, variablesClient, dataTablesClient, executionsClient, project) {
+    super(project);
+    this.projects = projects;
+    this.relations = {
+      workflows: workflowsClient,
+      folders: foldersClient,
+      variables: variablesClient,
+      dataTables: dataTablesClient,
+      executions: executionsClient
+    };
+  }
+  projects;
+  relations;
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get type() {
+    return this.data.type;
+  }
+  async update(data) {
+    await this.projects.update(this.id, data);
+    return this.mergeSnapshot(data);
+  }
+  async delete() {
+    await this.projects.delete(this.id);
+  }
+  async listMembers(params) {
+    return this.projects.listMembers(this.id, params);
+  }
+  async addMembers(relations) {
+    await this.projects.addMembers(this.id, relations);
+  }
+  async removeMember(userId) {
+    await this.projects.removeMember(this.id, userId);
+  }
+  async changeMemberRole(userId, role) {
+    await this.projects.changeMemberRole(this.id, userId, role);
+  }
+  workflows() {
+    return {
+      list: (params) => this.relations.workflows.list({ ...params, projectId: this.id }),
+      listResources: async (params) => {
+        const response = await this.relations.workflows.listResources({ ...params, projectId: this.id });
+        return response;
+      },
+      get: async (id) => {
+        if (!await this.hasResourceInProject({
+          listPage: (cursor) => this.relations.workflows.list({ projectId: this.id, cursor }),
+          matches: (workflow) => workflow.id === id
+        })) {
+          throw new HttpError(404, `Workflow not found in project: ${id}`, { id, projectId: this.id });
+        }
+        return this.relations.workflows.get(id);
+      },
+      getResource: async (id) => {
+        if (!await this.hasResourceInProject({
+          listPage: (cursor) => this.relations.workflows.list({ projectId: this.id, cursor }),
+          matches: (workflow) => workflow.id === id
+        })) {
+          throw new HttpError(404, `Workflow not found in project: ${id}`, { id, projectId: this.id });
+        }
+        return this.relations.workflows.getResource(id);
+      },
+      createResource: (data) => this.relations.workflows.createResource({ ...data, projectId: this.id }),
+      create: (data) => this.relations.workflows.create({ ...data, projectId: this.id }),
+      update: async (id, data) => {
+        if (!await this.hasResourceInProject({
+          listPage: (cursor) => this.relations.workflows.list({ projectId: this.id, cursor }),
+          matches: (workflow) => workflow.id === id
+        })) {
+          throw new HttpError(404, `Workflow not found in project: ${id}`, { id, projectId: this.id });
+        }
+        return this.relations.workflows.update(id, data);
+      },
+      updateResource: async (id, data) => {
+        if (!await this.hasResourceInProject({
+          listPage: (cursor) => this.relations.workflows.list({ projectId: this.id, cursor }),
+          matches: (workflow) => workflow.id === id
+        })) {
+          throw new HttpError(404, `Workflow not found in project: ${id}`, { id, projectId: this.id });
+        }
+        return this.relations.workflows.updateResource(id, data);
+      }
+    };
+  }
+  folders() {
+    return {
+      list: (params) => this.relations.folders.list(params),
+      listResources: (params) => this.relations.folders.listResources(params),
+      getResource: (id) => this.relations.folders.getResource(id),
+      createResource: (data) => this.relations.folders.createResource(data),
+      create: (data) => this.relations.folders.create(data),
+      get: (id) => this.relations.folders.get(id),
+      update: (id, data) => this.relations.folders.update(id, data),
+      updateResource: (id, data) => this.relations.folders.updateResource(id, data),
+      delete: (id, transferToFolderId) => this.relations.folders.delete(id, transferToFolderId)
+    };
+  }
+  variables() {
+    return {
+      list: (params) => this.relations.variables.list({ ...params, projectId: this.id }),
+      listResources: (params) => this.relations.variables.listResources({ ...params, projectId: this.id }),
+      get: (id) => this.relations.variables.get(id, { projectId: this.id }),
+      getResource: (id) => this.relations.variables.getResource(id, { projectId: this.id }),
+      create: (data) => this.relations.variables.create({ ...data, projectId: this.id }),
+      update: (id, data) => this.relations.variables.update(id, { ...data, projectId: this.id }),
+      updateResource: async (id, data) => {
+        await this.relations.variables.update(id, { ...data, projectId: this.id });
+        return this.relations.variables.getResource(id, { projectId: this.id });
+      },
+      delete: (id) => this.relations.variables.delete(id)
+    };
+  }
+  dataTables() {
+    return {
+      get: (id) => this.getProjectDataTableOrThrow(id),
+      getResource: async (id) => new DataTableResource(this.relations.dataTables, await this.getProjectDataTableOrThrow(id)),
+      create: (data) => this.relations.dataTables.create({ ...data, projectId: this.id }),
+      createResource: (data) => this.relations.dataTables.createResource({ ...data, projectId: this.id }),
+      update: async (id, data) => {
+        await this.getProjectDataTableOrThrow(id);
+        return this.relations.dataTables.update(id, data);
+      },
+      updateResource: async (id, data) => {
+        await this.getProjectDataTableOrThrow(id);
+        return this.relations.dataTables.updateResource(id, data);
+      },
+      delete: async (id) => {
+        await this.getProjectDataTableOrThrow(id);
+        await this.relations.dataTables.delete(id);
+      }
+    };
+  }
+  executions() {
+    return {
+      list: (params) => this.relations.executions.list({ ...params, projectId: this.id }),
+      listResources: (params) => this.relations.executions.listResources({ ...params, projectId: this.id }),
+      get: async (id, params) => {
+        if (!await this.hasResourceInProject({
+          listPage: (cursor) => this.relations.executions.list({ projectId: this.id, cursor }),
+          matches: (execution) => execution.id === id
+        })) {
+          throw new HttpError(404, `Execution not found in project: ${id}`, { id, projectId: this.id });
+        }
+        return this.relations.executions.get(id, params);
+      },
+      getResource: async (id, params) => {
+        if (!await this.hasResourceInProject({
+          listPage: (cursor) => this.relations.executions.list({ projectId: this.id, cursor }),
+          matches: (execution) => execution.id === id
+        })) {
+          throw new HttpError(404, `Execution not found in project: ${id}`, { id, projectId: this.id });
+        }
+        return this.relations.executions.getResource(id, params);
+      }
+    };
+  }
+  async getProjectDataTableOrThrow(id) {
+    const dataTable = await this.relations.dataTables.get(id);
+    if (dataTable.projectId !== this.id) {
+      throw new HttpError(404, `Data table not found in project: ${id}`, { id, projectId: this.id });
+    }
+    return dataTable;
+  }
+  async hasResourceInProject(options) {
+    let cursor;
+    do {
+      const response = await options.listPage(cursor);
+      if (response.data.some(options.matches)) {
+        return true;
+      }
+      cursor = response.nextCursor;
+    } while (cursor);
+    return false;
+  }
+};
+
+export {
+  ProjectResource
+};
+//# sourceMappingURL=chunk-LTYQTCHM.js.map

package/chunk-MMN2UKTI.cjs

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkFIKGC2ELcjs = require('./chunk-FIKGC2EL.cjs');
+
+// src/resources/credential.ts
+var CredentialResource = class extends _chunkFIKGC2ELcjs.BaseResource {
+  constructor(credentials, credential) {
+    super(credential);
+    this.credentials = credentials;
+  }
+  
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  get type() {
+    return this.data.type;
+  }
+  async update(data) {
+    return this.replaceSnapshot(await this.credentials.update(this.id, data));
+  }
+  async delete() {
+    return this.credentials.delete(this.id);
+  }
+  async test() {
+    return this.credentials.test(this.id);
+  }
+  async transfer(destinationProjectId) {
+    await this.credentials.transfer(this.id, destinationProjectId);
+  }
+  async getSchema() {
+    return this.credentials.getSchema(this.type);
+  }
+};
+
+
+
+exports.CredentialResource = CredentialResource;
+//# sourceMappingURL=chunk-MMN2UKTI.cjs.map