n8n-nodes-confirm8 0.23.0 → 0.24.0

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

@@ -1,17 +1,14 @@
 import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from "n8n-workflow";
-export declare class Confirm8AgentTool implements INodeType {
+/**
+ * CONFIRM8 OS TOOL (CHUMBED)
+ * - resource is ALWAYS "order"
+ * - operation is ALWAYS "getAll" OR "get" (derived only from presence of recordId)
+ * - dates are ALWAYS ISO YYYY-MM-DD (validated / computed here)
+ *
+ * This is the recommended single-tool version to use inside an AI Agent.
+ * The agent never sees 'resource' or 'operation' parameters, so it cannot fill them wrong.
+ */
+export declare class Confirm8OSTool implements INodeType {
     description: INodeTypeDescription;
-    /**
-     * Parse natural date queries into filter JSON
-     */
-    private parseDateQuery;
-    /**
-     * Validate ISO date string yyyy-mm-dd
-     */
-    private isIsoDate;
-    /**
-     * Enforce date filters format when present
-     */
-    private validateDateFilters;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

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

@@ -1,32 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Confirm8AgentTool = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-class Confirm8AgentTool {
+exports.Confirm8OSTool = void 0;
+const confirm8_utils_1 = require("./confirm8.utils");
+/**
+ * CONFIRM8 OS TOOL (CHUMBED)
+ * - resource is ALWAYS "order"
+ * - operation is ALWAYS "getAll" OR "get" (derived only from presence of recordId)
+ * - dates are ALWAYS ISO YYYY-MM-DD (validated / computed here)
+ *
+ * This is the recommended single-tool version to use inside an AI Agent.
+ * The agent never sees 'resource' or 'operation' parameters, so it cannot fill them wrong.
+ */
+class Confirm8OSTool {
     constructor() {
         this.description = {
-            displayName: "Confirm8 AI Tool",
-            name: "confirm8AgentTool",
+            displayName: "Confirm8 OS (Chumbed AI Tool)",
+            name: "confirm8OsTool",
             icon: "file:tool.svg",
             group: ["transform"],
             version: 1,
-            description: `AI tool for Confirm8 (STRICT).
-
-CRITICAL FOR AGENTS:
-- "resource" MUST be exactly one of: user, client, item, itemType, task, service, product, order, modality, ticket, property
-- "operation" MUST be exactly one of: getAll, get, create, update, activate, deactivate
-- Use ONLY these tokens. Do NOT use labels like "OS", "Ordem de Serviço", "buscar".
-- For OS/ordem de serviço => resource="order"
-- To list/search => operation="getAll"
-- Date filters MUST be ISO yyyy-mm-dd.`,
-            defaults: {
-                name: "Confirm8 AI Tool",
-            },
-            usableAsTool: true,
+            description: "Work Orders (OS) tool for Confirm8. CHUMBED: resource/order is fixed; operation is derived internally (getAll vs get). Dates are always ISO YYYY-MM-DD.",
+            defaults: { name: "Confirm8 OS" },
             inputs: ["main"],
             outputs: ["main"],
             properties: [
-                // API Configuration
                 {
                     displayName: "Base URL",
                     name: "baseUrl",
@@ -44,243 +41,97 @@ CRITICAL FOR AGENTS:
                     required: true,
                 },
                 {
-                    displayName: "X-API-DOMAIN",
+                    displayName: "API Domain",
                     name: "apiDomain",
                     type: "string",
                     default: "",
                     required: true,
                 },
                 {
-                    displayName: "X-APIKEY-TOKEN",
+                    displayName: "API Key Token",
                     name: "apiKeyToken",
                     type: "string",
                     typeOptions: { password: true },
                     default: "",
                     required: true,
                 },
-                // Tool parameters
                 {
-                    displayName: "Resource",
-                    name: "resource",
-                    type: "options",
-                    options: [
-                        {
-                            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: "itemType",
-                            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",
-                            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: `CRITICAL (Agents): Resource MUST be EXACTLY one of: user, client, item, itemType, task, service, product, order, modality, ticket, property.
-Use ONLY the value token (example: order), never labels like OS.`,
+                    displayName: "Session ID",
+                    name: "sessionId",
+                    type: "string",
+                    default: "",
                 },
                 {
-                    displayName: "Operation",
-                    name: "operation",
-                    type: "options",
-                    options: [
-                        {
-                            name: "getAll",
-                            value: "getAll",
-                            description: "List/Listar/Buscar todos/Mostrar todos",
-                        },
-                        {
-                            name: "get",
-                            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: `CRITICAL (Agents): Operation MUST be EXACTLY one of: getAll, get, create, update, activate, deactivate.
-Use ONLY the value token (example: getAll), never labels like buscar.`,
+                    displayName: "User Query (Optional)",
+                    name: "chatinput",
+                    type: "string",
+                    default: "",
                 },
+                // If filled, tool performs GET by ID; otherwise, GET ALL (list)
                 {
-                    displayName: "Record ID",
+                    displayName: "OS ID (recordId)",
                     name: "recordId",
                     type: "string",
                     default: "",
-                    description: "Record ID (only for get/update/activate/deactivate)",
+                    description: "If provided, fetches a single OS (get). If empty, lists OS (getAll).",
+                },
+                // Listing options (only relevant when recordId is empty)
+                {
+                    displayName: "Date Range",
+                    name: "dateRange",
+                    type: "options",
+                    default: "thisWeek",
+                    displayOptions: { show: { recordId: [""] } },
+                    options: [
+                        { name: "This week (Mon..Sun)", value: "thisWeek" },
+                        { name: "Custom", value: "custom" },
+                    ],
                 },
                 {
-                    displayName: "Data",
-                    name: "data",
+                    displayName: "Start Date (YYYY-MM-DD)",
+                    name: "startDate",
                     type: "string",
                     default: "",
-                    description: "JSON data (only for create/update)",
+                    displayOptions: { show: { dateRange: ["custom"], recordId: [""] } },
                 },
                 {
-                    displayName: "Filters",
-                    name: "filters",
+                    displayName: "End Date (YYYY-MM-DD)",
+                    name: "endDate",
                     type: "string",
                     default: "",
-                    description: `Filters as JSON ONLY.
-Dates MUST be ISO yyyy-mm-dd.
-Example (this week): {"start_date":{"gte":"2025-06-16"},"end_date":{"lte":"2025-06-22"}}
-Do NOT send expressions like "data >= start_of_week".`,
+                    displayOptions: { show: { dateRange: ["custom"], recordId: [""] } },
+                },
+                {
+                    displayName: "Date Field",
+                    name: "dateField",
+                    type: "options",
+                    default: "created_at",
+                    displayOptions: { show: { recordId: [""] } },
+                    options: [
+                        { name: "created_at (recommended)", value: "created_at" },
+                        { name: "date", value: "date" },
+                        { name: "data", value: "data" },
+                    ],
+                },
+                {
+                    displayName: "Per Page",
+                    name: "perPage",
+                    type: "number",
+                    default: 50,
+                    displayOptions: { show: { recordId: [""] } },
+                    typeOptions: { minValue: 1, maxValue: 200 },
+                },
+                {
+                    displayName: "Page",
+                    name: "page",
+                    type: "number",
+                    default: 1,
+                    displayOptions: { show: { recordId: [""] } },
+                    typeOptions: { minValue: 1 },
                 },
             ],
         };
     }
-    /**
-     * 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;
-    }
-    /**
-     * Validate ISO date string yyyy-mm-dd
-     */
-    isIsoDate(value) {
-        if (typeof value !== "string")
-            return false;
-        return /^\d{4}-\d{2}-\d{2}$/.test(value);
-    }
-    /**
-     * Enforce date filters format when present
-     */
-    validateDateFilters(filters) {
-        const dateFields = ["start_date", "end_date", "date", "data"];
-        for (const field of dateFields) {
-            if (!filters[field])
-                continue;
-            const ops = filters[field];
-            if (!ops || typeof ops !== "object")
-                continue;
-            for (const op of Object.keys(ops)) {
-                const v = ops[op];
-                if (v == null)
-                    continue;
-                if (!this.isIsoDate(v)) {
-                    throw new Error(`Invalid date format in filters["${field}"]["${op}"]="${String(v)}". ` +
-                        `Dates MUST be yyyy-mm-dd (ISO), e.g. "2025-06-16".`);
-                }
-            }
-        }
-    }
     async execute() {
         const items = this.getInputData();
         const returnData = [];
@@ -290,402 +141,98 @@ Do NOT send expressions like "data >= start_of_week".`,
                 const bearerToken = this.getNodeParameter("bearerToken", i);
                 const apiDomain = this.getNodeParameter("apiDomain", i);
                 const apiKeyToken = this.getNodeParameter("apiKeyToken", i);
-                let resource = this.getNodeParameter("resource", i, "");
-                let operation = this.getNodeParameter("operation", i, "");
-                const recordId = this.getNodeParameter("recordId", i, "");
-                // Parse data
-                let data = {};
-                const dataParam = this.getNodeParameter("data", i, "");
-                if (dataParam) {
-                    try {
-                        data = JSON.parse(dataParam);
-                    }
-                    catch (e) {
-                        // Ignore
-                    }
-                }
-                // 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;
-                        }
-                    }
-                    // Enforce ISO date filters when present
-                    this.validateDateFilters(filters);
-                }
-                // Aggressive normalization - EXPAND THIS
-                const resourceMap = {
-                    // 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",
-                    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/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 - clean and map (remove accents/punctuation)
-                const normalizeKey = (value) => value
-                    .toLowerCase()
-                    .normalize("NFD")
-                    .replace(/\p{Diacritic}/gu, "")
-                    .replace(/[^a-z0-9\s.\-_/]/g, " ")
-                    .trim()
-                    .replace(/\s+/g, " ");
-                const cleanResource = normalizeKey(resource);
-                const cleanOperation = normalizeKey(operation);
-                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".`);
-                }
-                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 endpoint
-                switch (operation) {
-                    case "getAll":
-                        endpoint = `/v3/${baseEndpoint}`;
-                        break;
-                    case "get":
-                        if (!recordId)
-                            throw new Error("recordId required");
-                        endpoint = `/v3/${baseEndpoint}/${recordId}`;
-                        break;
-                    case "create":
-                        endpoint = `/v3/${baseEndpoint}`;
-                        method = "POST";
-                        body = data;
-                        break;
-                    case "update":
-                        if (!recordId)
-                            throw new Error("recordId required");
-                        endpoint = `/v3/${baseEndpoint}/${recordId}`;
-                        method = "PUT";
-                        body = data;
-                        break;
-                    case "activate":
-                        if (!recordId)
-                            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");
-                        endpoint = `/v3/${baseEndpoint}/${recordId}/inactive`;
-                        method = [
-                            "client",
-                            "item",
-                            "itemType",
-                            "task",
-                            "service",
-                            "product",
-                            "order",
-                            "modality",
-                        ].includes(resource)
-                            ? "PUT"
-                            : "PATCH";
-                        break;
-                }
-                // Build query string
-                const queryParams = [];
-                // Add relations (only GET)
-                if (method === "GET" && config.relations.length > 0) {
-                    config.relations.forEach((relation) => {
-                        queryParams.push(`relations=${relation}`);
+                const sessionId = this.getNodeParameter("sessionId", i, "");
+                const chatinput = this.getNodeParameter("chatinput", i, "");
+                const recordId = this.getNodeParameter("recordId", i, "").trim();
+                // CHUMBED RESOURCE
+                const resource = "order";
+                const config = confirm8_utils_1.RESOURCE_ENDPOINTS[resource];
+                // Decide operation internally
+                const operation = recordId ? "get" : "getAll";
+                if (operation === "get") {
+                    const endpoint = `/v3/${config.endpoint}/${encodeURIComponent(recordId)}`;
+                    const query = config.relations?.length
+                        ? `?${config.relations.map((r) => `relations=${encodeURIComponent(r)}`).join("&")}`
+                        : "";
+                    const data = await confirm8_utils_1.confirm8Request.call(this, i, {
+                        baseUrl,
+                        bearerToken,
+                        apiDomain,
+                        apiKeyToken,
+                        method: "GET",
+                        endpoint,
+                        query,
                     });
-                }
-                // 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))}`);
-                        });
+                    returnData.push({
+                        json: {
+                            success: true,
+                            fixed: { resource, operation },
+                            request: { sessionId, chatinput, recordId, endpoint },
+                            data,
+                        },
+                        pairedItem: { item: i },
                     });
+                    continue;
                 }
-                // Full URL
-                let fullUrl = `${baseUrl}${endpoint}`;
-                if (queryParams.length > 0) {
-                    fullUrl += "?" + queryParams.join("&");
+                // operation === getAll
+                const dateRange = this.getNodeParameter("dateRange", i);
+                const dateField = this.getNodeParameter("dateField", i);
+                let start;
+                let end;
+                if (dateRange === "custom") {
+                    start = this.getNodeParameter("startDate", i) || "";
+                    end = this.getNodeParameter("endDate", i) || "";
+                    if (!start || !end) {
+                        throw new Error("When Date Range is Custom, startDate and endDate are required.");
+                    }
+                    (0, confirm8_utils_1.assertIsoDate)(start, "startDate");
+                    (0, confirm8_utils_1.assertIsoDate)(end, "endDate");
                 }
-                // Make request
-                const options = {
-                    method,
-                    uri: fullUrl,
-                    headers: {
-                        Authorization: `Bearer ${bearerToken}`,
-                        "X-API-DOMAIN": apiDomain,
-                        "X-APIKEY-TOKEN": apiKeyToken,
-                        "Content-Type": "application/json",
-                    },
-                    json: true,
-                };
-                if (method !== "GET" &&
-                    method !== "DELETE" &&
-                    Object.keys(body).length > 0) {
-                    options.body = body;
+                else {
+                    const r = (0, confirm8_utils_1.getThisWeekRange)(new Date());
+                    start = r.start;
+                    end = r.end;
                 }
-                const responseData = await this.helpers.request(options);
+                const endpoint = `/v3/${config.endpoint}`;
+                const filters = { [dateField]: { gte: start, lte: end } };
+                const page = this.getNodeParameter("page", i);
+                const perPage = this.getNodeParameter("perPage", i);
+                const query = (0, confirm8_utils_1.buildQueryParams)(config.relations, filters);
+                const pagination = `&page=${encodeURIComponent(String(page))}&per_page=${encodeURIComponent(String(perPage))}`;
+                const finalQuery = query ? `${query}${pagination}` : `?page=${page}&per_page=${perPage}`;
+                const data = await confirm8_utils_1.confirm8Request.call(this, i, {
+                    baseUrl,
+                    bearerToken,
+                    apiDomain,
+                    apiKeyToken,
+                    method: "GET",
+                    endpoint,
+                    query: finalQuery,
+                });
                 returnData.push({
                     json: {
                         success: true,
-                        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,
+                        fixed: { resource, operation },
+                        request: {
+                            sessionId,
+                            chatinput,
+                            endpoint,
+                            dateField,
+                            startDate: start,
+                            endDate: end,
+                            page,
+                            perPage,
+                        },
+                        data,
                     },
                     pairedItem: { item: i },
                 });
             }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({
-                        json: {
-                            success: false,
-                            error: error.message || "Unknown error",
-                        },
-                        pairedItem: { item: i },
-                    });
-                    continue;
-                }
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            catch (err) {
+                throw (0, confirm8_utils_1.toNodeError)(this.getNode(), err, i);
             }
         }
         return [returnData];
     }
 }
-exports.Confirm8AgentTool = Confirm8AgentTool;
+exports.Confirm8OSTool = Confirm8OSTool;

package/dist/nodes/Confirm8Tool/confirm8.utils.d.ts

@@ -0,0 +1,32 @@
+import { IDataObject, NodeOperationError, IExecuteFunctions } from "n8n-workflow";
+export declare const VALID_RESOURCES: readonly ["user", "client", "item", "itemType", "task", "service", "product", "order", "modality", "ticket", "property"];
+export declare const VALID_OPERATIONS: readonly ["getAll", "get", "create", "update", "activate", "deactivate"];
+export type Confirm8Resource = (typeof VALID_RESOURCES)[number];
+export type Confirm8Operation = (typeof VALID_OPERATIONS)[number];
+export declare const RESOURCE_ENDPOINTS: Record<Confirm8Resource, {
+    endpoint: string;
+    relations: string[];
+}>;
+export declare function assertIsoDate(dateStr: string, label: string): void;
+export declare function formatIsoDate(d: Date): string;
+/**
+ * Week starts on Monday (pt-BR business default).
+ * Returns inclusive start/end in YYYY-MM-DD.
+ */
+export declare function getThisWeekRange(now?: Date): {
+    start: string;
+    end: string;
+};
+/** Build query params for relations + filters in Confirm8 format. */
+export declare function buildQueryParams(relations: string[], filters?: IDataObject): string;
+export declare function confirm8Request(this: IExecuteFunctions, i: number, args: {
+    baseUrl: string;
+    bearerToken: string;
+    apiDomain: string;
+    apiKeyToken: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    endpoint: string;
+    query?: string;
+    body?: IDataObject;
+}): Promise<any>;
+export declare function toNodeError(node: any, err: unknown, i: number): NodeOperationError;

package/dist/nodes/Confirm8Tool/confirm8.utils.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_ENDPOINTS = exports.VALID_OPERATIONS = exports.VALID_RESOURCES = void 0;
+exports.assertIsoDate = assertIsoDate;
+exports.formatIsoDate = formatIsoDate;
+exports.getThisWeekRange = getThisWeekRange;
+exports.buildQueryParams = buildQueryParams;
+exports.confirm8Request = confirm8Request;
+exports.toNodeError = toNodeError;
+const n8n_workflow_1 = require("n8n-workflow");
+exports.VALID_RESOURCES = [
+    "user",
+    "client",
+    "item",
+    "itemType",
+    "task",
+    "service",
+    "product",
+    "order",
+    "modality",
+    "ticket",
+    "property",
+];
+exports.VALID_OPERATIONS = [
+    "getAll",
+    "get",
+    "create",
+    "update",
+    "activate",
+    "deactivate",
+];
+exports.RESOURCE_ENDPOINTS = {
+    user: {
+        endpoint: "users",
+        relations: ["clients", "attachments", "permissions", "device", "employee"],
+    },
+    client: {
+        endpoint: "clients",
+        relations: [
+            "address",
+            "contacts",
+            "items",
+            "tickets",
+            "orders",
+            "properties",
+            "attachments",
+        ],
+    },
+    item: {
+        endpoint: "items",
+        relations: ["client", "itemType", "properties", "attachments"],
+    },
+    itemType: { endpoint: "item-types", relations: ["properties"] },
+    task: {
+        endpoint: "tasks",
+        relations: ["itemType", "modality", "services", "products"],
+    },
+    service: { endpoint: "services", relations: ["task"] },
+    product: { endpoint: "products", relations: [] },
+    // IMPORTANT: Confirm8 Work Orders endpoint is 'wos'
+    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", "user", "attachments"],
+    },
+    property: { endpoint: "properties", relations: ["client", "item", "itemType"] },
+};
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+function assertIsoDate(dateStr, label) {
+    if (!ISO_DATE.test(dateStr)) {
+        throw new Error(`${label} must be in YYYY-MM-DD format. Received: "${dateStr}"`);
+    }
+}
+function formatIsoDate(d) {
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+/**
+ * Week starts on Monday (pt-BR business default).
+ * Returns inclusive start/end in YYYY-MM-DD.
+ */
+function getThisWeekRange(now = new Date()) {
+    const d = new Date(now);
+    d.setHours(0, 0, 0, 0);
+    // JS: Sunday=0 ... Saturday=6
+    const day = d.getDay();
+    const diffToMonday = day === 0 ? -6 : 1 - day; // if Sunday -> go back 6 days
+    const startDate = new Date(d);
+    startDate.setDate(d.getDate() + diffToMonday);
+    const endDate = new Date(startDate);
+    endDate.setDate(startDate.getDate() + 6);
+    return { start: formatIsoDate(startDate), end: formatIsoDate(endDate) };
+}
+/** Build query params for relations + filters in Confirm8 format. */
+function buildQueryParams(relations, filters) {
+    const queryParams = [];
+    if (relations?.length) {
+        for (const rel of relations)
+            queryParams.push(`relations=${encodeURIComponent(rel)}`);
+    }
+    if (filters && Object.keys(filters).length) {
+        for (const field of Object.keys(filters)) {
+            const operators = filters[field];
+            for (const op of Object.keys(operators)) {
+                const value = operators[op];
+                queryParams.push(`filters[${encodeURIComponent(field)}][${encodeURIComponent(op)}]=${encodeURIComponent(String(value))}`);
+            }
+        }
+    }
+    return queryParams.length ? `?${queryParams.join("&")}` : "";
+}
+function confirm8Request(i, args) {
+    const { baseUrl, bearerToken, apiDomain, apiKeyToken, method, endpoint, query, body } = args;
+    const uri = `${baseUrl}${endpoint}${query ?? ""}`;
+    const options = {
+        method,
+        uri,
+        headers: {
+            Authorization: `Bearer ${bearerToken}`,
+            "X-API-DOMAIN": apiDomain,
+            "X-APIKEY-TOKEN": apiKeyToken,
+            "Content-Type": "application/json",
+        },
+        json: true,
+    };
+    if (body && method !== "GET" && method !== "DELETE") {
+        options.body = body;
+    }
+    return this.helpers.request(options);
+}
+function toNodeError(node, err, i) {
+    if (err instanceof n8n_workflow_1.NodeOperationError)
+        return err;
+    const message = err instanceof Error ? err.message : String(err);
+    return new n8n_workflow_1.NodeOperationError(node, message, { itemIndex: i });
+}

package/package.json

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