@egose/n8n-client 0.1.2 → 0.2.0

package/chunk-NBLW25ME.cjs

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkFIKGC2ELcjs = require('./chunk-FIKGC2EL.cjs');
+
+// src/resources/data-table.ts
+var DataTableResource = class extends _chunkFIKGC2ELcjs.BaseResource {
+  constructor(dataTables, dataTable) {
+    super(dataTable);
+    this.dataTables = dataTables;
+  }
+  
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  async refresh() {
+    return this.replaceSnapshot(await this.dataTables.get(this.id));
+  }
+  async update(data) {
+    return this.replaceSnapshot(await this.dataTables.update(this.id, data));
+  }
+  async delete() {
+    await this.dataTables.delete(this.id);
+  }
+  async listRows(params) {
+    return this.dataTables.listRows(this.id, params);
+  }
+  async insertRows(data) {
+    return this.dataTables.insertRows(
+      this.id,
+      data
+    );
+  }
+  async updateRows(data) {
+    return this.dataTables.updateRows(this.id, data);
+  }
+  async upsertRow(data) {
+    return this.dataTables.upsertRow(this.id, data);
+  }
+  async deleteRows(params) {
+    return this.dataTables.deleteRows(this.id, params);
+  }
+  async listColumns() {
+    return this.dataTables.listColumns(this.id);
+  }
+  async createColumn(data) {
+    const column = await this.dataTables.createColumn(this.id, data);
+    this.mergeSnapshot({ columns: [...this.data.columns, column] });
+    return column;
+  }
+  async updateColumn(columnId, data) {
+    const column = await this.dataTables.updateColumn(this.id, columnId, data);
+    this.mergeSnapshot({ columns: this.data.columns.map((entry) => entry.id === columnId ? column : entry) });
+    return column;
+  }
+  async deleteColumn(columnId) {
+    await this.dataTables.deleteColumn(this.id, columnId);
+    this.mergeSnapshot({ columns: this.data.columns.filter((entry) => entry.id !== columnId) });
+  }
+};
+
+
+
+exports.DataTableResource = DataTableResource;
+//# sourceMappingURL=chunk-NBLW25ME.cjs.map

package/chunk-NS2RDZ7W.js

@@ -0,0 +1,15 @@
+import {
+  BaseClient
+} from "./chunk-Q6FSREKN.js";
+
+// src/clients/insights.ts
+var InsightsClient = class extends BaseClient {
+  async getSummary(params) {
+    return this.http.get("/insights/summary", params);
+  }
+};
+
+export {
+  InsightsClient
+};
+//# sourceMappingURL=chunk-NS2RDZ7W.js.map

package/chunk-OUOWDGL7.js

@@ -0,0 +1,15 @@
+import {
+  BaseClient
+} from "./chunk-Q6FSREKN.js";
+
+// src/clients/source-control.ts
+var SourceControlClient = class extends BaseClient {
+  async pull(data) {
+    return this.http.post("/source-control/pull", data);
+  }
+};
+
+export {
+  SourceControlClient
+};
+//# sourceMappingURL=chunk-OUOWDGL7.js.map

package/chunk-PT5DDLHC.js

@@ -0,0 +1,46 @@
+import {
+  TagResource
+} from "./chunk-4VK7K4IF.js";
+import {
+  BaseClient
+} from "./chunk-Q6FSREKN.js";
+
+// src/clients/tag.ts
+var TagClient = class extends BaseClient {
+  async list(params) {
+    return this.http.get("/tags", params);
+  }
+  async get(id) {
+    return this.http.get(`/tags/${id}`);
+  }
+  async getResource(id) {
+    return new TagResource(this, await this.get(id));
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((tag) => new TagResource(this, tag)),
+      nextCursor: response.nextCursor
+    };
+  }
+  async create(data) {
+    return this.http.post("/tags", data);
+  }
+  async createResource(data) {
+    return new TagResource(this, await this.create(data));
+  }
+  async update(id, data) {
+    return this.http.put(`/tags/${id}`, data);
+  }
+  async updateResource(id, data) {
+    return new TagResource(this, await this.update(id, data));
+  }
+  async delete(id) {
+    return this.http.delete(`/tags/${id}`);
+  }
+};
+
+export {
+  TagClient
+};
+//# sourceMappingURL=chunk-PT5DDLHC.js.map

package/chunk-Q6FSREKN.js

@@ -0,0 +1,12 @@
+// src/clients/base.ts
+var BaseClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+};
+
+export {
+  BaseClient
+};
+//# sourceMappingURL=chunk-Q6FSREKN.js.map

package/chunk-QJR4WFNV.js

@@ -0,0 +1,55 @@
+import {
+  CredentialResource
+} from "./chunk-XJP6FPN3.js";
+import {
+  BaseClient
+} from "./chunk-Q6FSREKN.js";
+
+// src/clients/credential.ts
+var CredentialClient = class extends BaseClient {
+  async list(params) {
+    return this.http.get("/credentials", params);
+  }
+  async get(id) {
+    return this.http.get(`/credentials/${id}`);
+  }
+  async getResource(id) {
+    return new CredentialResource(this, await this.get(id));
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((credential) => new CredentialResource(this, credential)),
+      nextCursor: response.nextCursor
+    };
+  }
+  async create(data) {
+    return this.http.post("/credentials", data);
+  }
+  async createResource(data) {
+    return new CredentialResource(this, await this.create(data));
+  }
+  async update(id, data) {
+    return this.http.patch(`/credentials/${id}`, data);
+  }
+  async updateResource(id, data) {
+    return new 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}`);
+  }
+};
+
+export {
+  CredentialClient
+};
+//# sourceMappingURL=chunk-QJR4WFNV.js.map

package/chunk-RPB226OX.cjs

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk6JJ6RA5Bcjs = require('./chunk-6JJ6RA5B.cjs');
+
+
+var _chunk4M2HGY3Fcjs = require('./chunk-4M2HGY3F.cjs');
+
+// src/clients/folder.ts
+var FolderClient = class extends _chunk4M2HGY3Fcjs.BaseClient {
+  
+  constructor(http, projectId) {
+    super(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 getResource(folderId) {
+    return new (0, _chunk6JJ6RA5Bcjs.FolderResource)(this, await this.get(folderId));
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map((folder) => new (0, _chunk6JJ6RA5Bcjs.FolderResource)(this, folder)),
+      nextCursor: void 0
+    };
+  }
+  async create(data) {
+    return this.http.post(`/projects/${this.projectId}/folders`, data);
+  }
+  async createResource(data) {
+    return new (0, _chunk6JJ6RA5Bcjs.FolderResource)(this, await this.create(data));
+  }
+  async update(folderId, data) {
+    return this.http.patch(`/projects/${this.projectId}/folders/${folderId}`, data);
+  }
+  async updateResource(folderId, data) {
+    return new (0, _chunk6JJ6RA5Bcjs.FolderResource)(this, await this.update(folderId, data));
+  }
+  async delete(folderId, transferToFolderId) {
+    await this.http.delete(
+      `/projects/${this.projectId}/folders/${folderId}`,
+      transferToFolderId ? { transferToFolderId } : void 0
+    );
+  }
+};
+
+
+
+exports.FolderClient = FolderClient;
+//# sourceMappingURL=chunk-RPB226OX.cjs.map

package/chunk-S4ZASMBT.js

@@ -0,0 +1,43 @@
+import {
+  BaseResource
+} from "./chunk-TLBDBRPJ.js";
+
+// src/resources/execution.ts
+var ExecutionResource = class extends BaseResource {
+  constructor(executions, execution, params) {
+    super(execution);
+    this.executions = executions;
+    this.params = params;
+  }
+  executions;
+  params;
+  get id() {
+    return this.data.id;
+  }
+  get status() {
+    return this.data.status;
+  }
+  async refresh() {
+    return this.replaceSnapshot(await this.executions.get(this.id, this.params));
+  }
+  async delete() {
+    return this.executions.delete(this.id);
+  }
+  async retry(data) {
+    return this.replaceSnapshot(await this.executions.retry(this.id, data));
+  }
+  async stop() {
+    return this.replaceSnapshot(await this.executions.stop(this.id));
+  }
+  async getTags() {
+    return this.executions.getTags(this.id);
+  }
+  async updateTags(tags) {
+    return this.executions.updateTags(this.id, tags);
+  }
+};
+
+export {
+  ExecutionResource
+};
+//# sourceMappingURL=chunk-S4ZASMBT.js.map

package/chunk-T62VHXNY.js

@@ -0,0 +1,67 @@
+import {
+  BaseResource
+} from "./chunk-TLBDBRPJ.js";
+
+// src/resources/data-table.ts
+var DataTableResource = class extends BaseResource {
+  constructor(dataTables, dataTable) {
+    super(dataTable);
+    this.dataTables = dataTables;
+  }
+  dataTables;
+  get id() {
+    return this.data.id;
+  }
+  get name() {
+    return this.data.name;
+  }
+  async refresh() {
+    return this.replaceSnapshot(await this.dataTables.get(this.id));
+  }
+  async update(data) {
+    return this.replaceSnapshot(await this.dataTables.update(this.id, data));
+  }
+  async delete() {
+    await this.dataTables.delete(this.id);
+  }
+  async listRows(params) {
+    return this.dataTables.listRows(this.id, params);
+  }
+  async insertRows(data) {
+    return this.dataTables.insertRows(
+      this.id,
+      data
+    );
+  }
+  async updateRows(data) {
+    return this.dataTables.updateRows(this.id, data);
+  }
+  async upsertRow(data) {
+    return this.dataTables.upsertRow(this.id, data);
+  }
+  async deleteRows(params) {
+    return this.dataTables.deleteRows(this.id, params);
+  }
+  async listColumns() {
+    return this.dataTables.listColumns(this.id);
+  }
+  async createColumn(data) {
+    const column = await this.dataTables.createColumn(this.id, data);
+    this.mergeSnapshot({ columns: [...this.data.columns, column] });
+    return column;
+  }
+  async updateColumn(columnId, data) {
+    const column = await this.dataTables.updateColumn(this.id, columnId, data);
+    this.mergeSnapshot({ columns: this.data.columns.map((entry) => entry.id === columnId ? column : entry) });
+    return column;
+  }
+  async deleteColumn(columnId) {
+    await this.dataTables.deleteColumn(this.id, columnId);
+    this.mergeSnapshot({ columns: this.data.columns.filter((entry) => entry.id !== columnId) });
+  }
+};
+
+export {
+  DataTableResource
+};
+//# sourceMappingURL=chunk-T62VHXNY.js.map

package/chunk-TLBDBRPJ.js

@@ -0,0 +1,29 @@
+// src/resources/base.ts
+var BaseResource = class {
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  snapshot;
+  get data() {
+    return this.snapshot;
+  }
+  toObject() {
+    return this.snapshot;
+  }
+  toJSON() {
+    return this.toObject();
+  }
+  replaceSnapshot(data) {
+    this.snapshot = data;
+    return this;
+  }
+  mergeSnapshot(data) {
+    this.snapshot = { ...this.snapshot, ...data };
+    return this;
+  }
+};
+
+export {
+  BaseResource
+};
+//# sourceMappingURL=chunk-TLBDBRPJ.js.map

package/chunk-TY76RTXQ.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkFIKGC2ELcjs = require('./chunk-FIKGC2EL.cjs');
+
+// src/resources/community-package.ts
+var CommunityPackageResource = class extends _chunkFIKGC2ELcjs.BaseResource {
+  constructor(communityPackages, communityPackage) {
+    super(communityPackage);
+    this.communityPackages = communityPackages;
+  }
+  
+  get packageName() {
+    return this.data.packageName;
+  }
+  get installedVersion() {
+    return this.data.installedVersion;
+  }
+  async refresh() {
+    return this.replaceSnapshot((await this.communityPackages.getResource(this.packageName)).data);
+  }
+  async update(data) {
+    return this.replaceSnapshot(await this.communityPackages.update(this.packageName, data));
+  }
+  async uninstall() {
+    await this.communityPackages.uninstall(this.packageName);
+  }
+};
+
+
+
+exports.CommunityPackageResource = CommunityPackageResource;
+//# sourceMappingURL=chunk-TY76RTXQ.cjs.map

package/chunk-USTEEQQG.js

@@ -0,0 +1,43 @@
+import {
+  UserResource
+} from "./chunk-L2FFL3BY.js";
+import {
+  BaseClient
+} from "./chunk-Q6FSREKN.js";
+
+// src/clients/user.ts
+var UserClient = class extends BaseClient {
+  async list(params) {
+    return this.http.get("/users", params);
+  }
+  async get(id, params) {
+    return this.http.get(`/users/${id}`, params);
+  }
+  async getResource(id, params) {
+    return new UserResource(this, await this.get(id, params), params);
+  }
+  async listResources(params) {
+    const response = await this.list(params);
+    return {
+      data: response.data.map(
+        (user) => new UserResource(this, user, params?.includeRole ? { includeRole: true } : void 0)
+      ),
+      nextCursor: response.nextCursor
+    };
+  }
+  async create(data) {
+    return this.http.post("/users", data);
+  }
+  async delete(id) {
+    await this.http.delete(`/users/${id}`);
+  }
+  async changeRole(id, newRoleName) {
+    const data = { newRoleName };
+    await this.http.patch(`/users/${id}/role`, data);
+  }
+};
+
+export {
+  UserClient
+};
+//# sourceMappingURL=chunk-USTEEQQG.js.map

package/chunk-W5P34RYO.cjs

@@ -0,0 +1,196 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkNBLW25MEcjs = require('./chunk-NBLW25ME.cjs');
+
+
+var _chunkLC3TKRMXcjs = require('./chunk-LC3TKRMX.cjs');
+
+
+var _chunkFIKGC2ELcjs = require('./chunk-FIKGC2EL.cjs');
+
+// src/resources/project.ts
+var ProjectResource = class extends _chunkFIKGC2ELcjs.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
+    };
+  }
+  
+  
+  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 (0, _chunkLC3TKRMXcjs.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 (0, _chunkLC3TKRMXcjs.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 (0, _chunkLC3TKRMXcjs.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 (0, _chunkLC3TKRMXcjs.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 (0, _chunkNBLW25MEcjs.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 (0, _chunkLC3TKRMXcjs.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 (0, _chunkLC3TKRMXcjs.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 (0, _chunkLC3TKRMXcjs.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;
+  }
+};
+
+
+
+exports.ProjectResource = ProjectResource;
+//# sourceMappingURL=chunk-W5P34RYO.cjs.map