@couleetech/n8n-nodes-enlightenedmsp 1.6.0 → 1.7.1

package/dist/nodes/EnlightenedMsp/SearchCoreCompanies.node.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchCoreCompanies = void 0;
 const GraphqlBase_1 = require("./GraphqlBase");
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
 const DEFAULT_FIELDS = `id
                     name
                     defaultTicketLevel
@@ -72,19 +74,6 @@ class SearchCoreCompanies {
                     required: true,
                 },
             ],
-            codex: {
-                categories: ['AI'],
-                subcategories: {
-                    AI: ['Tools'],
-                },
-                resources: {
-                    primaryDocumentation: [
-                        {
-                            url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.searchcorecompanies/',
-                        },
-                    ],
-                },
-            },
             properties: [
                 {
                     displayName: 'Name Filter',
@@ -342,10 +331,119 @@ active`,
     async execute() {
         const items = this.getInputData();
         const returnData = [];
-        const length = items.length;
         const { endpoint, apiKey } = await GraphqlBase_1.GraphqlBase.getCredentials(this);
         const searchCompaniesGraphql = new SearchCoreCompaniesGraphql(endpoint, apiKey);
-        for (let i = 0; i < length; i++) {
+        const searchCompaniesTool = new tools_1.DynamicStructuredTool({
+            name: 'search_companies',
+            description: 'Search for companies in EnlightenedMSP with various filters and sorting options',
+            schema: zod_1.z.object({
+                name: zod_1.z.object({
+                    operation: zod_1.z.enum(['equals', 'notEquals', 'contains', 'notContains']),
+                    value: zod_1.z.string()
+                }).optional().describe('Filter by company name'),
+                defaultTicketLevel: zod_1.z.object({
+                    operation: zod_1.z.enum(['equals', 'notEquals', 'contains', 'notContains']),
+                    value: zod_1.z.string()
+                }).optional().describe('Filter by default ticket level'),
+                defaultHourlyRate: zod_1.z.object({
+                    operation: zod_1.z.enum(['equals', 'greaterThan', 'lessThan']),
+                    value: zod_1.z.number()
+                }).optional().describe('Filter by default hourly rate'),
+                billingConfigured: zod_1.z.boolean().optional().describe('Filter by billing configured status'),
+                active: zod_1.z.boolean().optional().describe('Filter by active status'),
+                isOwnCompany: zod_1.z.boolean().optional().describe('Filter by own company status'),
+                autotaskCompanyId: zod_1.z.number().optional().describe('Filter by Autotask company ID'),
+                sortBy: zod_1.z.enum(['name', 'defaultHourlyRate', 'id']).optional().describe('Field to sort results by'),
+                sortOrder: zod_1.z.enum(['ASC', 'DESC']).optional().describe('Sort order for results'),
+                page: zod_1.z.number().optional().describe('Page number for pagination'),
+                limit: zod_1.z.number().optional().describe('Number of results per page'),
+                fields: zod_1.z.string().optional().describe('Fields to return in the response')
+            }),
+            func: async (args) => {
+                try {
+                    const variables = {
+                        page: args.page || 1,
+                        limit: args.limit || 10,
+                        fields: args.fields || DEFAULT_FIELDS,
+                        order: args.sortBy ? { [args.sortBy]: args.sortOrder || 'ASC' } : undefined
+                    };
+                    if (args.name) {
+                        switch (args.name.operation) {
+                            case 'equals':
+                                variables.name = { eq: args.name.value };
+                                break;
+                            case 'notEquals':
+                                variables.name = { not: args.name.value };
+                                break;
+                            case 'contains':
+                                variables.name = { like: args.name.value };
+                                break;
+                            case 'notContains':
+                                variables.name = { notlike: args.name.value };
+                                break;
+                        }
+                    }
+                    if (args.defaultTicketLevel) {
+                        switch (args.defaultTicketLevel.operation) {
+                            case 'equals':
+                                variables.defaultTicketLevel = { eq: args.defaultTicketLevel.value };
+                                break;
+                            case 'notEquals':
+                                variables.defaultTicketLevel = { not: args.defaultTicketLevel.value };
+                                break;
+                            case 'contains':
+                                variables.defaultTicketLevel = { like: args.defaultTicketLevel.value };
+                                break;
+                            case 'notContains':
+                                variables.defaultTicketLevel = { notlike: args.defaultTicketLevel.value };
+                                break;
+                        }
+                    }
+                    if (args.defaultHourlyRate) {
+                        switch (args.defaultHourlyRate.operation) {
+                            case 'equals':
+                                variables.defaultHourlyRate = { eq: args.defaultHourlyRate.value };
+                                break;
+                            case 'greaterThan':
+                                variables.defaultHourlyRate = { gte: args.defaultHourlyRate.value };
+                                break;
+                            case 'lessThan':
+                                variables.defaultHourlyRate = { lte: args.defaultHourlyRate.value };
+                                break;
+                        }
+                    }
+                    if (args.billingConfigured !== undefined) {
+                        variables.billingConfigured = { eq: args.billingConfigured };
+                    }
+                    if (args.active !== undefined) {
+                        variables.active = { eq: args.active };
+                    }
+                    if (args.isOwnCompany !== undefined) {
+                        variables.isOwnCompany = { eq: args.isOwnCompany };
+                    }
+                    if (args.autotaskCompanyId) {
+                        variables.autotaskCompanyId = { eq: args.autotaskCompanyId };
+                    }
+                    const result = await searchCompaniesGraphql.searchCompanies(variables);
+                    return JSON.stringify({
+                        companies: result.findCoreCompaniesPaginated.data,
+                        totalCount: result.findCoreCompaniesPaginated.totalCount,
+                        page: result.findCoreCompaniesPaginated.page,
+                        limit: result.findCoreCompaniesPaginated.limit
+                    });
+                }
+                catch (error) {
+                    throw new Error(`Failed to search companies: ${error.message}`);
+                }
+            }
+        });
+        const toolOutput = {
+            json: {
+                tools: [searchCompaniesTool]
+            }
+        };
+        void this.addOutputData("ai_tool", 0, [[toolOutput]]);
+        for (let i = 0; i < items.length; i++) {
             try {
                 const nameFilter = this.getNodeParameter('nameFilter', i, {});
                 const defaultTicketLevelFilter = this.getNodeParameter('defaultTicketLevelFilter', i, {});
@@ -417,29 +515,17 @@ active`,
                     variables.autotaskCompanyId = { eq: autotaskCompanyId };
                 }
                 const result = await searchCompaniesGraphql.searchCompanies(variables);
-                const outputItem = {
+                returnData.push({
                     json: result.findCoreCompaniesPaginated,
-                };
-                returnData.push(outputItem);
-                const aiToolOutput = {
-                    json: {
-                        companies: result.findCoreCompaniesPaginated.data,
-                        totalCount: result.findCoreCompaniesPaginated.totalCount,
-                        page: result.findCoreCompaniesPaginated.page,
-                        limit: result.findCoreCompaniesPaginated.limit,
-                    },
-                };
-                void this.addOutputData("ai_tool", i, [[aiToolOutput]]);
+                });
             }
             catch (error) {
                 if (this.continueOnFail()) {
-                    const errorOutput = {
+                    returnData.push({
                         json: {
                             error: error.message,
                         },
-                    };
-                    returnData.push(errorOutput);
-                    void this.addOutputData("ai_tool", i, [[errorOutput]]);
+                    });
                     continue;
                 }
                 throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@couleetech/n8n-nodes-enlightenedmsp",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "n8n node for EnlightenedMSP ticketing and workflow automation",
   "keywords": [
     "n8n-community-node-package",