n8n-nodes-confirm8 0.19.0 → 0.21.0

package/dist/nodes/Confirm8Tool/Confirm8AgentTool.node.d.ts

@@ -1,5 +1,9 @@
 import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
 export declare class Confirm8AgentTool implements INodeType {
     description: INodeTypeDescription;
+    /**
+     * Parse natural date queries into filter JSON
+     */
+    private parseDateQuery;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

package/dist/nodes/Confirm8Tool/Confirm8AgentTool.node.js

@@ -10,7 +10,7 @@ class Confirm8AgentTool {
             icon: 'file:tool.svg',
             group: ['transform'],
             version: 1,
-            description: 'AI Agent tool for Confirm8 API - use EXACT enum values: resource (user/client/item/task/service/product/order/ticket/property) and operation (getAll/get/create/update/activate/deactivate)',
+            description: 'AI tool for Confirm8. IMPORTANT: For "OS/ordem de serviço" use resource="order". For dates use filters with start_date/end_date. Example: {"start_date":{"gte":"2025-11-23"},"end_date":{"lte":"2025-11-25"}}',
             defaults: {
                 name: 'Confirm8 AI Tool',
             },
@@ -50,59 +50,132 @@ class Confirm8AgentTool {
                     default: '',
                     required: true,
                 },
-                // Tool parameters - MUST use exact enum values
+                // Tool parameters
                 {
                     displayName: 'Resource',
                     name: 'resource',
                     type: 'options',
                     options: [
-                        { name: 'User', value: 'user', description: 'Users/employees' },
-                        { name: 'Client', value: 'client', description: 'Clients/customers' },
-                        { name: 'Item', value: 'item', description: 'Items/inventory' },
-                        { name: 'Item Type', value: 'itemType', description: 'Item categories' },
-                        { name: 'Task', value: 'task', description: 'Tasks/checklists' },
-                        { name: 'Service', value: 'service', description: 'Services' },
-                        { name: 'Product', value: 'product', description: 'Products' },
-                        { name: 'Order', value: 'order', description: 'Work orders' },
-                        { name: 'Modality', value: 'modality', description: 'Order modalities' },
-                        { name: 'Ticket', value: 'ticket', description: 'Tickets' },
-                        { name: 'Property', value: 'property', description: 'Properties' },
+                        { name: 'User', value: 'user', description: 'Users/Employees/Funcionários' },
+                        { name: 'Client', value: 'client', description: 'Clients/Customers/Clientes' },
+                        { name: 'Item', value: 'item', description: 'Items/Itens' },
+                        { name: 'Item Type', value: 'itemType', description: 'Item Types/Tipos' },
+                        { name: 'Task', value: 'task', description: 'Tasks/Tarefas/Checklists' },
+                        { name: 'Service', value: 'service', description: 'Services/Serviços' },
+                        { name: 'Product', value: 'product', description: 'Products/Produtos' },
+                        { name: 'Order (OS)', value: 'order', description: 'Work Orders/OS/Ordens de Serviço/WOS' },
+                        { name: 'Modality', value: 'modality', description: 'Modalities/Modalidades' },
+                        { name: 'Ticket', value: 'ticket', description: 'Tickets/Chamados' },
+                        { name: 'Property', value: 'property', description: 'Properties/Propriedades' },
                     ],
                     default: 'user',
-                    description: 'IMPORTANT: Use EXACT value from list',
+                    description: 'CRITICAL: For "OS" or "ordem de serviço" ALWAYS use "order"',
                 },
                 {
                     displayName: 'Operation',
                     name: 'operation',
                     type: 'options',
                     options: [
-                        { name: 'Get All', value: 'getAll', description: 'List all records' },
-                        { name: 'Get', value: 'get', description: 'Get single record' },
-                        { name: 'Create', value: 'create', description: 'Create new record' },
-                        { name: 'Update', value: 'update', description: 'Update record' },
-                        { name: 'Activate', value: 'activate', description: 'Activate record' },
-                        { name: 'Deactivate', value: 'deactivate', description: 'Deactivate record' },
+                        { name: 'Get All (List)', value: 'getAll', description: 'List/Listar/Buscar todos/Mostrar todos' },
+                        { name: 'Get (Single)', value: 'get', description: 'Get one/Buscar um/Obter' },
+                        { name: 'Create', value: 'create', description: 'Create/Criar/Adicionar' },
+                        { name: 'Update', value: 'update', description: 'Update/Atualizar/Modificar' },
+                        { name: 'Activate', value: 'activate', description: 'Activate/Ativar' },
+                        { name: 'Deactivate', value: 'deactivate', description: 'Deactivate/Desativar' },
                     ],
                     default: 'getAll',
-                    description: 'IMPORTANT: Use EXACT value from list',
+                    description: 'CRITICAL: To list/search use "getAll"',
                 },
                 {
                     displayName: 'Record ID',
                     name: 'recordId',
                     type: 'string',
                     default: '',
-                    description: 'ID of record (for get/update/activate/deactivate)',
+                    description: 'Record ID (only for get/update/activate/deactivate)',
                 },
                 {
                     displayName: 'Data',
                     name: 'data',
                     type: 'string',
                     default: '',
-                    description: 'JSON data for create/update',
+                    description: 'JSON data (only for create/update)',
+                },
+                {
+                    displayName: 'Filters',
+                    name: 'filters',
+                    type: 'string',
+                    default: '',
+                    description: 'Filters as JSON. For dates: {"start_date":{"gte":"YYYY-MM-DD"},"end_date":{"lte":"YYYY-MM-DD"}}. For status: {"status":{"eq":"complete"}}',
                 },
             ],
         };
     }
+    /**
+     * Parse natural date queries into filter JSON
+     */
+    parseDateQuery(query) {
+        const now = new Date();
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        query = query.toLowerCase().trim();
+        // Helper to format date as YYYY-MM-DD
+        const formatDate = (date) => {
+            return date.toISOString().split('T')[0];
+        };
+        // Today
+        if (query.includes('hoje') || query.includes('today')) {
+            const endOfDay = new Date(today);
+            endOfDay.setHours(23, 59, 59, 999);
+            return {
+                start_date: { gte: formatDate(today) },
+                end_date: { lte: formatDate(endOfDay) }
+            };
+        }
+        // This week / semana atual
+        if (query.includes('semana') || query.includes('week')) {
+            const dayOfWeek = today.getDay();
+            const diff = dayOfWeek === 0 ? -6 : 1 - dayOfWeek; // Monday is start
+            const weekStart = new Date(today);
+            weekStart.setDate(today.getDate() + diff);
+            const weekEnd = new Date(weekStart);
+            weekEnd.setDate(weekStart.getDate() + 6);
+            return {
+                start_date: { gte: formatDate(weekStart) },
+                end_date: { lte: formatDate(weekEnd) }
+            };
+        }
+        // This month / mês atual
+        if (query.includes('mês') || query.includes('mes') || query.includes('month')) {
+            const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+            const monthEnd = new Date(now.getFullYear(), now.getMonth() + 1, 0);
+            return {
+                start_date: { gte: formatDate(monthStart) },
+                end_date: { lte: formatDate(monthEnd) }
+            };
+        }
+        // Last N days
+        const lastDaysMatch = query.match(/últimos?\s+(\d+)\s+dias?|last\s+(\d+)\s+days?/);
+        if (lastDaysMatch) {
+            const days = parseInt(lastDaysMatch[1] || lastDaysMatch[2]);
+            const startDate = new Date(today);
+            startDate.setDate(today.getDate() - days);
+            return {
+                start_date: { gte: formatDate(startDate) },
+                end_date: { lte: formatDate(today) }
+            };
+        }
+        // Next N days
+        const nextDaysMatch = query.match(/próximos?\s+(\d+)\s+dias?|next\s+(\d+)\s+days?/);
+        if (nextDaysMatch) {
+            const days = parseInt(nextDaysMatch[1] || nextDaysMatch[2]);
+            const endDate = new Date(today);
+            endDate.setDate(today.getDate() + days);
+            return {
+                start_date: { gte: formatDate(today) },
+                end_date: { lte: formatDate(endDate) }
+            };
+        }
+        return null;
+    }
     async execute() {
         const items = this.getInputData();
         const returnData = [];
@@ -123,104 +196,233 @@ class Confirm8AgentTool {
                         data = JSON.parse(dataParam);
                     }
                     catch (e) {
-                        // Ignore parse errors
+                        // Ignore
                     }
                 }
-                // Normalize common variations
+                // Parse filters
+                let filters = {};
+                const filtersParam = this.getNodeParameter('filters', i, '');
+                if (filtersParam) {
+                    try {
+                        // Try to parse as JSON first
+                        filters = JSON.parse(filtersParam);
+                    }
+                    catch (e) {
+                        // If not JSON, try to parse as natural language date query
+                        const parsedDate = this.parseDateQuery(filtersParam);
+                        if (parsedDate) {
+                            filters = parsedDate;
+                        }
+                    }
+                }
+                // Aggressive normalization - EXPAND THIS
                 const resourceMap = {
-                    'users': 'user', 'usuarios': 'user', 'usuários': 'user', 'employees': 'user', 'funcionários': 'user',
+                    // Standard
+                    'users': 'user', 'usuarios': 'user', 'usuários': 'user', 'employees': 'user', 'funcionários': 'user', 'funcionarios': 'user',
                     'clients': 'client', 'clientes': 'client', 'customers': 'client',
                     'items': 'item', 'itens': 'item',
                     'itemtypes': 'itemType', 'tipos': 'itemType',
                     'tasks': 'task', 'tarefas': 'task',
                     'services': 'service', 'serviços': 'service', 'servicos': 'service',
                     'products': 'product', 'produtos': 'product',
-                    'orders': 'order', 'ordens': 'order', 'pedidos': 'order', 'wos': 'order',
                     'modalities': 'modality', 'modalidades': 'modality',
                     'tickets': 'ticket', 'chamados': 'ticket',
                     'properties': 'property', 'propriedades': 'property',
+                    // CRITICAL: OS mappings
+                    'os': 'order',
+                    'o.s': 'order',
+                    'o.s.': 'order',
+                    'orders': 'order',
+                    'ordens': 'order',
+                    'ordem': 'order',
+                    'ordem de serviço': 'order',
+                    'ordem de servico': 'order',
+                    'ordens de serviço': 'order',
+                    'ordens de servico': 'order',
+                    'wos': 'order',
+                    'work order': 'order',
+                    'work orders': 'order',
+                    'pedidos': 'order',
+                    'pedido': 'order',
                 };
                 const operationMap = {
-                    'list': 'getAll', 'listar': 'getAll', 'mostrar': 'getAll', 'show': 'getAll',
-                    'buscar': 'getAll', 'busque': 'getAll', 'buscar todos': 'getAll', 'get all': 'getAll',
-                    'show all': 'getAll', 'list all': 'getAll', 'todos': 'getAll',
-                    'obter': 'get', 'pegar': 'get',
-                    'criar': 'create', 'adicionar': 'create', 'add': 'create', 'novo': 'create', 'new': 'create',
-                    'atualizar': 'update', 'modificar': 'update', 'modify': 'update', 'editar': 'update',
-                    'ativar': 'activate', 'enable': 'activate', 'habilitar': 'activate',
-                    'desativar': 'deactivate', 'disable': 'deactivate', 'desabilitar': 'deactivate',
+                    // List/Get All
+                    'list': 'getAll',
+                    'listar': 'getAll',
+                    'mostrar': 'getAll',
+                    'buscar': 'getAll',
+                    'busque': 'getAll',
+                    'buscar todos': 'getAll',
+                    'buscar todas': 'getAll',
+                    'buscar todo': 'getAll',
+                    'buscar toda': 'getAll',
+                    'get all': 'getAll',
+                    'show all': 'getAll',
+                    'list all': 'getAll',
+                    'todos': 'getAll',
+                    'todas': 'getAll',
+                    'obter todos': 'getAll',
+                    'obter todas': 'getAll',
+                    'pegar todos': 'getAll',
+                    'pegar todas': 'getAll',
+                    // Get Single
+                    'obter': 'get',
+                    'pegar': 'get',
+                    'ver': 'get',
+                    'visualizar': 'get',
+                    // Create
+                    'criar': 'create',
+                    'adicionar': 'create',
+                    'add': 'create',
+                    'novo': 'create',
+                    'nova': 'create',
+                    'new': 'create',
+                    // Update
+                    'atualizar': 'update',
+                    'modificar': 'update',
+                    'modify': 'update',
+                    'editar': 'update',
+                    'edit': 'update',
+                    // Activate/Deactivate
+                    'ativar': 'activate',
+                    'enable': 'activate',
+                    'habilitar': 'activate',
+                    'desativar': 'deactivate',
+                    'disable': 'deactivate',
+                    'desabilitar': 'deactivate',
                 };
-                // Normalize
-                resource = resourceMap[resource.toLowerCase().trim()] || resource;
-                operation = operationMap[operation.toLowerCase().trim()] || operation;
-                if (!resource || !operation) {
-                    throw new Error('Resource and operation are required');
+                // Normalize - clean and map
+                const cleanResource = resource.toLowerCase().trim().replace(/\s+/g, ' ');
+                const cleanOperation = operation.toLowerCase().trim().replace(/\s+/g, ' ');
+                resource = resourceMap[cleanResource] || resource;
+                operation = operationMap[cleanOperation] || operation;
+                // If still not valid, throw clear error
+                const validResources = ['user', 'client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality', 'ticket', 'property'];
+                const validOperations = ['getAll', 'get', 'create', 'update', 'activate', 'deactivate'];
+                if (!validResources.includes(resource)) {
+                    throw new Error(`Invalid resource: "${resource}". Must be one of: ${validResources.join(', ')}. ` +
+                        `For OS/Ordem de Serviço use "order".`);
                 }
-                // Map to endpoints
-                const endpointMap = {
-                    user: 'users',
-                    client: 'clients',
-                    item: 'items',
-                    itemType: 'itemTypes',
-                    task: 'tasks',
-                    service: 'services',
-                    product: 'products',
-                    order: 'wos',
-                    modality: 'modalities',
-                    ticket: 'tickets',
-                    property: 'properties',
-                };
-                const baseEndpoint = endpointMap[resource];
-                if (!baseEndpoint) {
-                    throw new Error(`Unknown resource: ${resource}. Must be one of: user, client, item, itemType, task, service, product, order, modality, ticket, property`);
+                if (!validOperations.includes(operation)) {
+                    throw new Error(`Invalid operation: "${operation}". Must be one of: ${validOperations.join(', ')}. ` +
+                        `To list/search use "getAll".`);
                 }
+                // Resource config with relations
+                const resourceConfig = {
+                    user: {
+                        endpoint: 'users',
+                        relations: ['clients', 'attachments', 'permissions', 'device', 'employee']
+                    },
+                    client: {
+                        endpoint: 'clients',
+                        relations: ['wos', 'items', 'employees', 'headquarter', 'files', 'userGroup', 'properties']
+                    },
+                    item: {
+                        endpoint: 'items',
+                        relations: ['client', 'item_type', 'properties', 'parent', 'children', 'collects', 'wos']
+                    },
+                    itemType: {
+                        endpoint: 'itemTypes',
+                        relations: ['properties']
+                    },
+                    task: {
+                        endpoint: 'tasks',
+                        relations: ['itemType', 'activities', 'wos', 'modalities']
+                    },
+                    service: {
+                        endpoint: 'services',
+                        relations: ['task']
+                    },
+                    product: {
+                        endpoint: 'products',
+                        relations: []
+                    },
+                    order: {
+                        endpoint: 'wos',
+                        relations: ['client', 'modalities', 'tasks', 'pivot_tasks', 'products', 'users', 'items', 'tickets', 'services', 'collects', 'attachments']
+                    },
+                    modality: {
+                        endpoint: 'modalities',
+                        relations: ['tasks']
+                    },
+                    ticket: {
+                        endpoint: 'tickets',
+                        relations: ['client', 'subject_category', 'category', 'status', 'attachments', 'item', 'owner', 'priority', 'users', 'orders', 'properties']
+                    },
+                    property: {
+                        endpoint: 'properties',
+                        relations: []
+                    },
+                };
+                const config = resourceConfig[resource];
+                const baseEndpoint = config.endpoint;
                 let endpoint = '';
                 let method = 'GET';
                 let body = {};
-                // Build request
+                // Build endpoint
                 switch (operation) {
                     case 'getAll':
-                        endpoint = `/${baseEndpoint}`;
+                        endpoint = `/v3/${baseEndpoint}`;
                         break;
                     case 'get':
                         if (!recordId)
-                            throw new Error('recordId required for get operation');
-                        endpoint = `/${baseEndpoint}/${recordId}`;
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}`;
                         break;
                     case 'create':
-                        endpoint = `/${baseEndpoint}`;
+                        endpoint = `/v3/${baseEndpoint}`;
                         method = 'POST';
                         body = data;
                         break;
                     case 'update':
                         if (!recordId)
-                            throw new Error('recordId required for update operation');
-                        endpoint = `/${baseEndpoint}/${recordId}`;
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}`;
                         method = 'PUT';
                         body = data;
                         break;
                     case 'activate':
                         if (!recordId)
-                            throw new Error('recordId required for activate operation');
-                        endpoint = `/${baseEndpoint}/${recordId}/active`;
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}/active`;
                         method = ['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)
                             ? 'PUT' : 'PATCH';
                         break;
                     case 'deactivate':
                         if (!recordId)
-                            throw new Error('recordId required for deactivate operation');
-                        endpoint = `/${baseEndpoint}/${recordId}/inactive`;
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}/inactive`;
                         method = ['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)
                             ? 'PUT' : 'PATCH';
                         break;
-                    default:
-                        throw new Error(`Unknown operation: ${operation}. Must be one of: getAll, get, create, update, activate, deactivate`);
+                }
+                // Build query string
+                const queryParams = [];
+                // Add relations (only GET)
+                if (method === 'GET' && config.relations.length > 0) {
+                    config.relations.forEach(relation => {
+                        queryParams.push(`relations=${relation}`);
+                    });
+                }
+                // Add filters
+                if (Object.keys(filters).length > 0) {
+                    Object.keys(filters).forEach(field => {
+                        const operators = filters[field];
+                        Object.keys(operators).forEach(operator => {
+                            const value = operators[operator];
+                            queryParams.push(`filters[${field}][${operator}]=${encodeURIComponent(String(value))}`);
+                        });
+                    });
+                }
+                // Full URL
+                let fullUrl = `${baseUrl}${endpoint}`;
+                if (queryParams.length > 0) {
+                    fullUrl += '?' + queryParams.join('&');
                 }
                 // Make request
-                const url = `${baseUrl}${endpoint}`;
                 const options = {
                     method,
-                    uri: url,
+                    uri: fullUrl,
                     headers: {
                         'Authorization': `Bearer ${bearerToken}`,
                         'X-API-DOMAIN': apiDomain,
@@ -236,15 +438,18 @@ class Confirm8AgentTool {
                 returnData.push({
                     json: {
                         success: true,
-                        operation,
-                        resource,
                         normalized: {
                             originalResource: this.getNodeParameter('resource', i, ''),
                             originalOperation: this.getNodeParameter('operation', i, ''),
                             normalizedResource: resource,
                             normalizedOperation: operation,
                         },
+                        operation,
+                        resource,
                         endpoint,
+                        fullUrl,
+                        relations: config.relations,
+                        filters: filters,
                         method,
                         data: responseData,
                     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-confirm8",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "Simple n8n node for Confirm8 API - no credentials needed",
   "license": "MIT",
   "author": "Bill Hebert",