n8n-nodes-innotes 2.0.17 → 2.0.19

package/dist/nodes/InNotes/InNotes.node.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * @author Marco
- * @date 2025-06-28
+ * @date 2026-09-14
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InNotes = void 0;
@@ -14,6 +14,80 @@ const StatusDescription_1 = require("../../descriptions/StatusDescription");
 const TagDescription_1 = require("../../descriptions/TagDescription");
 const UserDescription_1 = require("../../descriptions/UserDescription");
 const AutomationDescription_1 = require("../../descriptions/AutomationDescription");
+/**
+ * One authenticated call to the InNotes API.
+ *
+ * `Content-Type` is derived from the presence of a body and `qs` is spread only
+ * when given: that is what every call site sent before this helper existed, and
+ * a header or an empty `qs` added here would change all of them at once.
+ *
+ * HTTP only: response normalisation and every catch block stay at the call site.
+ *
+ * @author Marco
+ * @date 2026-09-09
+ */
+async function apiRequest(ctx, method, path, options = {}) {
+    const credentials = await ctx.getCredentials('inNotesApi');
+    return ctx.helpers.httpRequestWithAuthentication.call(ctx, 'inNotesApi', {
+        method,
+        url: `${credentials.baseUrl}${path}`,
+        ...(options.qs ? { qs: options.qs } : {}),
+        ...(options.body ? { body: options.body } : {}),
+        headers: {
+            Accept: 'application/json',
+            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+        },
+    });
+}
+/**
+ * Fail on an unusable credential BEFORE entering a catch that would absorb it.
+ *
+ * `apiRequest` resolves the credential per request, i.e. inside whatever try the
+ * caller wrote. Two of those catches answer a failure with a successful "does not
+ * exist" item — one always, the other under continueOnFail — so a credential
+ * fault resolved in there would report that the job does not exist. Call this
+ * first at those sites; do not delete it because the result is unused.
+ *
+ * @author Marco
+ * @date 2026-09-09
+ */
+async function assertCredentials(ctx) {
+    await ctx.getCredentials('inNotesApi');
+}
+/**
+ * Resolve a job status NAME to its numeric id, case-insensitively.
+ *
+ * The caller keeps the decision about what to do with the result: job create
+ * drops a falsy id from the body, job update assigns it unconditionally. That
+ * divergence predates this helper and is preserved unchanged; whether it was
+ * ever intended is not established — see the two call sites.
+ *
+ * @author Marco
+ * @date 2026-09-09
+ */
+async function resolveJobStatusId(executeFunctions, statusName) {
+    try {
+        const statusResponse = await apiRequest(executeFunctions, 'GET', '/api/statuses', {
+            qs: { type: 'job' },
+        });
+        const statuses = Array.isArray(statusResponse) ? statusResponse : [statusResponse];
+        const matchingStatus = statuses.find((s) => { var _a; return ((_a = s.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === statusName.toLowerCase(); });
+        if (!matchingStatus) {
+            throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
+                message: `Status "${statusName}" not found. Available statuses: ${statuses.map((s) => s.name).join(', ')}`,
+            });
+        }
+        return parseInt(matchingStatus.id, 10);
+    }
+    catch (error) {
+        if (error instanceof n8n_workflow_1.NodeApiError) {
+            throw error;
+        }
+        throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
+            message: `Failed to lookup status "${statusName}": ${error.message}`,
+        });
+    }
+}
 /**
  * Turn the "Phone & Email" fixedCollection into the array the API takes.
  *
@@ -181,15 +255,8 @@ class InNotes {
             loadOptions: {
                 async jobStatuses() {
                     try {
-                        const credentials = await this.getCredentials('inNotesApi');
-                        const baseUrl = credentials.baseUrl;
-                        const response = await this.helpers.httpRequestWithAuthentication.call(this, 'inNotesApi', {
-                            method: 'GET',
-                            url: `${baseUrl}/api/statuses`,
+                        const response = await apiRequest(this, 'GET', '/api/statuses', {
                             qs: { type: 'job' },
-                            headers: {
-                                Accept: 'application/json',
-                            },
                         });
                         const statuses = Array.isArray(response) ? response : [response];
                         return statuses.map((status) => ({
@@ -216,13 +283,12 @@ class InNotes {
         const options = this.getNodeParameter('options', 0, {});
         const batchSize = options.batchSize || 10;
         const timeoutBetweenBatches = options.timeoutBetweenBatches || 1000;
-        // Create a node instance to access the methods
-        const nodeInstance = new InNotes();
         // Helper function to add delay between batches
         const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
         if (resource === 'job' && operation === 'batchExists') {
-            const credentials = await this.getCredentials('inNotesApi');
-            const baseUrl = credentials.baseUrl;
+            // Under continueOnFail the catch in the loop answers a failure with
+            // exists:false for every id.
+            await assertCredentials(this);
             const batchLimit = 200;
             const idsRaw = this.getNodeParameter('ids', 0, '');
             const allExtIds = idsRaw.split(',').map(id => id.trim()).filter(id => id.length > 0);
@@ -233,13 +299,7 @@ class InNotes {
             for (let offset = 0; offset < allExtIds.length; offset += batchLimit) {
                 const chunk = allExtIds.slice(offset, offset + batchLimit);
                 try {
-                    const response = await this.helpers.httpRequestWithAuthentication.call(this, 'inNotesApi', {
-                        method: 'POST',
-                        url: `${baseUrl}/api/job/batch-exists`,
-                        headers: {
-                            Accept: 'application/json',
-                            'Content-Type': 'application/json',
-                        },
+                    const response = await apiRequest(this, 'POST', '/api/job/batch-exists', {
                         body: { ext_ids: chunk },
                     });
                     const results = (_a = response.results) !== null && _a !== void 0 ? _a : {};
@@ -274,25 +334,25 @@ class InNotes {
                 try {
                     let responseData = {};
                     if (resource === 'automation') {
-                        responseData = await nodeInstance.executeAutomationOperation(this, actualIndex, operation);
+                        responseData = await InNotes.executeAutomationOperation(this, actualIndex, operation);
                     }
                     else if (resource === 'contact') {
-                        responseData = await nodeInstance.executeContactOperation(this, actualIndex, operation);
+                        responseData = await InNotes.executeContactOperation(this, actualIndex, operation);
                     }
                     else if (resource === 'note') {
-                        responseData = await nodeInstance.executeNoteOperation(this, actualIndex, operation);
+                        responseData = await InNotes.executeNoteOperation(this, actualIndex, operation);
                     }
                     else if (resource === 'job') {
-                        responseData = await nodeInstance.executeJobOperation(this, actualIndex, operation);
+                        responseData = await InNotes.executeJobOperation(this, actualIndex, operation);
                     }
                     else if (resource === 'status') {
-                        responseData = await nodeInstance.executeStatusOperation(this, actualIndex, operation);
+                        responseData = await InNotes.executeStatusOperation(this, actualIndex, operation);
                     }
                     else if (resource === 'tag') {
-                        responseData = await nodeInstance.executeTagOperation(this, actualIndex, operation);
+                        responseData = await InNotes.executeTagOperation(this, actualIndex, operation);
                     }
                     else if (resource === 'user') {
-                        responseData = await nodeInstance.executeUserOperation(this, actualIndex, operation);
+                        responseData = await InNotes.executeUserOperation(this, actualIndex, operation);
                     }
                     if (Array.isArray(responseData)) {
                         returnData.push(...responseData);
@@ -316,19 +376,10 @@ class InNotes {
         }
         return [this.helpers.returnJsonArray(returnData)];
     }
-    async executeAutomationOperation(executeFunctions, itemIndex, operation) {
-        const credentials = await executeFunctions.getCredentials('inNotesApi');
-        const baseUrl = credentials.baseUrl;
+    static async executeAutomationOperation(executeFunctions, itemIndex, operation) {
         if (operation === 'getConfig') {
             try {
-                const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'GET',
-                    url: `${baseUrl}/api/automation/config`,
-                    headers: {
-                        Accept: 'application/json',
-                    },
-                });
-                return response;
+                return await apiRequest(executeFunctions, 'GET', '/api/automation/config');
             }
             catch (error) {
                 throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
@@ -341,6 +392,7 @@ class InNotes {
             const status = executeFunctions.getNodeParameter('status', itemIndex, 'success');
             const errorMessage = executeFunctions.getNodeParameter('errorMessage', itemIndex, '');
             // Get the callback secret from credentials
+            const credentials = await executeFunctions.getCredentials('inNotesApi');
             const callbackSecret = credentials.callbackSecret;
             if (!callbackSecret) {
                 throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
@@ -350,13 +402,7 @@ class InNotes {
             // Get user ID from the API
             let userId;
             try {
-                const userResponse = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'GET',
-                    url: `${baseUrl}/api/user`,
-                    headers: {
-                        Accept: 'application/json',
-                    },
-                });
+                const userResponse = await apiRequest(executeFunctions, 'GET', '/api/user');
                 userId = userResponse.id;
             }
             catch (error) {
@@ -372,15 +418,7 @@ class InNotes {
                 ...(status === 'error' && errorMessage && { error: errorMessage }),
             };
             try {
-                const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'POST',
-                    url: `${baseUrl}/api/automation/callback`,
-                    body,
-                    headers: {
-                        Accept: 'application/json',
-                        'Content-Type': 'application/json',
-                    },
-                });
+                const response = await apiRequest(executeFunctions, 'POST', '/api/automation/callback', { body });
                 return {
                     success: true,
                     ...response,
@@ -398,9 +436,7 @@ class InNotes {
             message: `The operation "${operation}" is not supported for resource "automation"!`,
         });
     }
-    async executeContactOperation(executeFunctions, itemIndex, operation) {
-        const credentials = await executeFunctions.getCredentials('inNotesApi');
-        const baseUrl = credentials.baseUrl;
+    static async executeContactOperation(executeFunctions, itemIndex, operation) {
         if (operation === 'create') {
             const name = executeFunctions.getNodeParameter('name', itemIndex);
             const linkedin_key = executeFunctions.getNodeParameter('linkedin_key', itemIndex);
@@ -423,33 +459,16 @@ class InNotes {
                 ...(contact_details && { contact_details }),
             };
             try {
-                const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'POST',
-                    url: `${baseUrl}/api/contacts`,
-                    body,
-                    headers: {
-                        Accept: 'application/json',
-                        'Content-Type': 'application/json',
-                    },
-                });
-                return response;
+                return await apiRequest(executeFunctions, 'POST', '/api/contacts', { body });
             }
             catch (error) {
-                const requestParams = {
-                    name,
-                    linkedin_key,
-                    ...(linkedin_user && { linkedin_user }),
-                    ...(location && { location }),
-                    ...(current_company && { current_company }),
-                    ...(picture_url && { picture_url }),
-                    ...(tags && { tags: tags.split(',').map((tag) => tag.trim()) }),
-                    ...(status_id && { status_id }),
-                    // The COUNT, never the values: this object is interpolated into a
-                    // NodeApiError message and n8n persists execution data, so the
-                    // numbers and addresses would sit in a third party's workflow
-                    // history. Author: Marco, 2026-08-10
-                    ...(contact_details && { contact_details: `${contact_details.length} entr(y|ies)` }),
-                };
+                // The COUNT, never the values: this object is interpolated into a
+                // NodeApiError message and n8n persists execution data, so the
+                // numbers and addresses would sit in a third party's workflow
+                // history. Author: Marco, 2026-08-10
+                const requestParams = contact_details
+                    ? { ...body, contact_details: `${contact_details.length} entr(y|ies)` }
+                    : body;
                 throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
                     message: `Failed to create contact: ${error.message}. Request parameters: ${JSON.stringify(requestParams, null, 2)}`,
                 });
@@ -457,14 +476,7 @@ class InNotes {
         }
         if (operation === 'get') {
             const contactId = executeFunctions.getNodeParameter('contactId', itemIndex);
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/contacts/${contactId}`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
-            return response;
+            return await apiRequest(executeFunctions, 'GET', `/api/contacts/${contactId}`);
         }
         if (operation === 'getAll') {
             const returnAll = executeFunctions.getNodeParameter('returnAll', itemIndex, false);
@@ -480,14 +492,7 @@ class InNotes {
                 qs.pageSize = limit;
                 qs.page = 1;
             }
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/contacts`,
-                qs,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
+            const response = await apiRequest(executeFunctions, 'GET', '/api/contacts', { qs });
             return Array.isArray(response) ? response : [response];
         }
         if (operation === 'update') {
@@ -505,35 +510,18 @@ class InNotes {
             };
             if (contact_details === undefined)
                 delete body.contact_details;
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'PUT',
-                url: `${baseUrl}/api/contacts/${contactId}`,
-                body,
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                },
-            });
-            return response;
+            return await apiRequest(executeFunctions, 'PUT', `/api/contacts/${contactId}`, { body });
         }
         if (operation === 'delete') {
             const contactId = executeFunctions.getNodeParameter('contactId', itemIndex);
-            await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'DELETE',
-                url: `${baseUrl}/api/contacts/${contactId}`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
+            await apiRequest(executeFunctions, 'DELETE', `/api/contacts/${contactId}`);
             return { success: true };
         }
         throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
             message: `The operation "${operation}" is not supported for resource "contact"!`,
         });
     }
-    async executeNoteOperation(executeFunctions, itemIndex, operation) {
-        const credentials = await executeFunctions.getCredentials('inNotesApi');
-        const baseUrl = credentials.baseUrl;
+    static async executeNoteOperation(executeFunctions, itemIndex, operation) {
         if (operation === 'create') {
             const content = executeFunctions.getNodeParameter('content', itemIndex);
             const contactId = executeFunctions.getNodeParameter('contactId', itemIndex);
@@ -545,81 +533,17 @@ class InNotes {
                 ...(visibility && { visibility }),
                 ...(ext_table_name && { ext_table_name }),
             };
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'POST',
-                url: `${baseUrl}/api/note`,
-                body,
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                },
-            });
-            return response;
+            return await apiRequest(executeFunctions, 'POST', '/api/note', { body });
         }
         if (operation === 'get') {
             const noteId = executeFunctions.getNodeParameter('noteId', itemIndex);
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/note/${noteId}`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
-            return response;
-        }
-        if (operation === 'getAll') {
-            const contactId = executeFunctions.getNodeParameter('contactId', itemIndex);
-            const returnAll = executeFunctions.getNodeParameter('returnAll', itemIndex, false);
-            const qs = {
-                contact_id: contactId,
-            };
-            if (!returnAll) {
-                const limit = executeFunctions.getNodeParameter('limit', itemIndex, 24);
-                qs.pageSize = limit;
-                qs.page = 1;
-            }
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/note`,
-                qs,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
-            return Array.isArray(response) ? response : [response];
-        }
-        if (operation === 'update') {
-            const noteId = executeFunctions.getNodeParameter('noteId', itemIndex);
-            const updateFields = executeFunctions.getNodeParameter('updateFields', itemIndex);
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'PUT',
-                url: `${baseUrl}/api/note/${noteId}`,
-                body: updateFields,
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                },
-            });
-            return response;
-        }
-        if (operation === 'delete') {
-            const noteId = executeFunctions.getNodeParameter('noteId', itemIndex);
-            await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'DELETE',
-                url: `${baseUrl}/api/note/${noteId}`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
-            return { success: true };
+            return await apiRequest(executeFunctions, 'GET', `/api/note/${noteId}`);
         }
         throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
             message: `The operation "${operation}" is not supported for resource "note"!`,
         });
     }
-    async executeJobOperation(executeFunctions, itemIndex, operation) {
-        const credentials = await executeFunctions.getCredentials('inNotesApi');
-        const baseUrl = credentials.baseUrl;
+    static async executeJobOperation(executeFunctions, itemIndex, operation) {
         if (operation === 'create') {
             const name = executeFunctions.getNodeParameter('name', itemIndex);
             const company_name = executeFunctions.getNodeParameter('company_name', itemIndex);
@@ -636,36 +560,7 @@ class InNotes {
             let status_id;
             // If status is provided, lookup the status ID
             if (status) {
-                try {
-                    // Get all job statuses
-                    const statusResponse = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                        method: 'GET',
-                        url: `${baseUrl}/api/statuses`,
-                        qs: { type: 'job' },
-                        headers: {
-                            Accept: 'application/json',
-                        },
-                    });
-                    // Find matching status by name (case-insensitive)
-                    const statuses = Array.isArray(statusResponse) ? statusResponse : [statusResponse];
-                    const matchingStatus = statuses.find((s) => { var _a; return ((_a = s.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === status.toLowerCase(); });
-                    if (matchingStatus) {
-                        status_id = parseInt(matchingStatus.id, 10);
-                    }
-                    else {
-                        throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
-                            message: `Status "${status}" not found. Available statuses: ${statuses.map((s) => s.name).join(', ')}`,
-                        });
-                    }
-                }
-                catch (error) {
-                    if (error instanceof n8n_workflow_1.NodeApiError) {
-                        throw error;
-                    }
-                    throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
-                        message: `Failed to lookup status "${status}": ${error.message}`,
-                    });
-                }
+                status_id = await resolveJobStatusId(executeFunctions, status);
             }
             const body = {
                 name,
@@ -682,48 +577,18 @@ class InNotes {
                 ...(tags && { tags: tags.split(',').map((tag) => tag.trim()) }),
             };
             try {
-                const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'POST',
-                    url: `${baseUrl}/api/job`,
-                    body,
-                    headers: {
-                        Accept: 'application/json',
-                        'Content-Type': 'application/json',
-                    },
-                });
-                return response;
+                return await apiRequest(executeFunctions, 'POST', '/api/job', { body });
             }
             catch (error) {
-                const requestParams = {
-                    name,
-                    company_name,
-                    ...(description && { description }),
-                    ...(location && { location }),
-                    ...(remote_setting && { remote_setting }),
-                    ...(company_url && { company_url }),
-                    ...(provider && { provider }),
-                    ...(url && { url }),
-                    ...(status_id && { status_id }),
-                    ...(ext_id && { ext_id }),
-                    ...(picture_url && picture_url !== 'Not Available' && { picture_url }),
-                    ...(tags && { tags: tags.split(',').map((tag) => tag.trim()) }),
-                };
                 throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
-                    message: `Failed to create job: ${error.message}. Request parameters: ${JSON.stringify(requestParams, null, 2)}`,
+                    message: `Failed to create job: ${error.message}. Request parameters: ${JSON.stringify(body, null, 2)}`,
                 });
             }
         }
         if (operation === 'get') {
             const jobId = executeFunctions.getNodeParameter('jobId', itemIndex);
             try {
-                const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'GET',
-                    url: `${baseUrl}/api/job/${jobId}`,
-                    headers: {
-                        Accept: 'application/json',
-                    },
-                });
-                return response;
+                return await apiRequest(executeFunctions, 'GET', `/api/job/${jobId}`);
             }
             catch (error) {
                 throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
@@ -746,14 +611,7 @@ class InNotes {
                 qs.page = 1;
             }
             try {
-                const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'GET',
-                    url: `${baseUrl}/api/job`,
-                    qs,
-                    headers: {
-                        Accept: 'application/json',
-                    },
-                });
+                const response = await apiRequest(executeFunctions, 'GET', '/api/job', { qs });
                 return Array.isArray(response) ? response : [response];
             }
             catch (error) {
@@ -767,54 +625,15 @@ class InNotes {
             const updateFields = executeFunctions.getNodeParameter('updateFields', itemIndex);
             // Handle status string lookup if provided
             if (updateFields.status && typeof updateFields.status === 'string') {
-                try {
-                    // Get all job statuses
-                    const statusResponse = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                        method: 'GET',
-                        url: `${baseUrl}/api/statuses`,
-                        qs: { type: 'job' },
-                        headers: {
-                            Accept: 'application/json',
-                        },
-                    });
-                    // Find matching status by name (case-insensitive)
-                    const statuses = Array.isArray(statusResponse) ? statusResponse : [statusResponse];
-                    const matchingStatus = statuses.find((s) => { var _a; return ((_a = s.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === updateFields.status.toLowerCase(); });
-                    if (matchingStatus) {
-                        // Replace status with status_id and remove status field
-                        updateFields.status_id = parseInt(matchingStatus.id, 10);
-                        delete updateFields.status;
-                    }
-                    else {
-                        throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
-                            message: `Status "${updateFields.status}" not found. Available statuses: ${statuses.map((s) => s.name).join(', ')}`,
-                        });
-                    }
-                }
-                catch (error) {
-                    if (error instanceof n8n_workflow_1.NodeApiError) {
-                        throw error;
-                    }
-                    throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
-                        message: `Failed to lookup status "${updateFields.status}": ${error.message}`,
-                    });
-                }
+                updateFields.status_id = await resolveJobStatusId(executeFunctions, updateFields.status);
+                delete updateFields.status;
             }
             // Process tags if provided as comma-separated string
             if (updateFields.tags && typeof updateFields.tags === 'string') {
                 updateFields.tags = (updateFields.tags).split(',').map((tag) => tag.trim());
             }
             try {
-                const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'PUT',
-                    url: `${baseUrl}/api/job/${jobId}`,
-                    body: updateFields,
-                    headers: {
-                        Accept: 'application/json',
-                        'Content-Type': 'application/json',
-                    },
-                });
-                return response;
+                return await apiRequest(executeFunctions, 'PUT', `/api/job/${jobId}`, { body: updateFields });
             }
             catch (error) {
                 throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
@@ -825,13 +644,7 @@ class InNotes {
         if (operation === 'delete') {
             const jobId = executeFunctions.getNodeParameter('jobId', itemIndex);
             try {
-                await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                    method: 'DELETE',
-                    url: `${baseUrl}/api/job/${jobId}`,
-                    headers: {
-                        Accept: 'application/json',
-                    },
-                });
+                await apiRequest(executeFunctions, 'DELETE', `/api/job/${jobId}`);
                 return { success: true };
             }
             catch (error) {
@@ -883,40 +696,24 @@ class InNotes {
             const limit = searchOptions.limit || 24;
             qs.pageSize = limit;
             qs.page = 1;
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/job`,
-                qs,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
+            const response = await apiRequest(executeFunctions, 'GET', '/api/job', { qs });
             return Array.isArray(response) ? response : [response];
         }
         if (operation === 'exists') {
             const id = executeFunctions.getNodeParameter('id', itemIndex);
+            // Both catches below treat any failure as "not found".
+            await assertCredentials(executeFunctions);
             try {
                 // First try to get by job ID
                 try {
-                    await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                        method: 'GET',
-                        url: `${baseUrl}/api/job/${id}`,
-                        headers: {
-                            Accept: 'application/json',
-                        },
-                    });
+                    await apiRequest(executeFunctions, 'GET', `/api/job/${id}`);
                     // If we get here, the job exists by ID
                     return { exists: true, found_by: 'job_id', id };
                 }
                 catch {
                     // Job not found by ID, try searching by ext_id
-                    const searchResponse = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                        method: 'GET',
-                        url: `${baseUrl}/api/job`,
+                    const searchResponse = await apiRequest(executeFunctions, 'GET', '/api/job', {
                         qs: { ext_id: id },
-                        headers: {
-                            Accept: 'application/json',
-                        },
                     });
                     // Check if any results were returned
                     const results = Array.isArray(searchResponse) ? searchResponse : [searchResponse];
@@ -936,109 +733,38 @@ class InNotes {
             message: `The operation "${operation}" is not supported for resource "job"!`,
         });
     }
-    async executeStatusOperation(executeFunctions, itemIndex, operation) {
-        const credentials = await executeFunctions.getCredentials('inNotesApi');
-        const baseUrl = credentials.baseUrl;
+    static async executeStatusOperation(executeFunctions, itemIndex, operation) {
         if (operation === 'create') {
             const name = executeFunctions.getNodeParameter('name', itemIndex);
             const type = executeFunctions.getNodeParameter('type', itemIndex);
-            const color = executeFunctions.getNodeParameter('color', itemIndex, '');
-            const body = {
-                name,
-                type,
-                ...(color && { color }),
-            };
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'POST',
-                url: `${baseUrl}/api/statuses`,
-                body,
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                },
-            });
-            return response;
+            const body = { name, type };
+            return await apiRequest(executeFunctions, 'POST', '/api/statuses', { body });
         }
         if (operation === 'getAll') {
             const type = executeFunctions.getNodeParameter('type', itemIndex, 'contact');
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/statuses`,
-                qs: { type },
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
+            const response = await apiRequest(executeFunctions, 'GET', '/api/statuses', { qs: { type } });
             return Array.isArray(response) ? response : [response];
         }
-        if (operation === 'update') {
-            const statusId = executeFunctions.getNodeParameter('statusId', itemIndex);
-            const updateFields = executeFunctions.getNodeParameter('updateFields', itemIndex);
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'PUT',
-                url: `${baseUrl}/api/statuses/${statusId}`,
-                body: updateFields,
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                },
-            });
-            return response;
-        }
-        if (operation === 'delete') {
-            const statusId = executeFunctions.getNodeParameter('statusId', itemIndex);
-            await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'DELETE',
-                url: `${baseUrl}/api/statuses/${statusId}`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
-            return { success: true };
-        }
         throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
             message: `The operation "${operation}" is not supported for resource "status"!`,
         });
     }
-    async executeTagOperation(executeFunctions, _itemIndex, operation) {
-        const credentials = await executeFunctions.getCredentials('inNotesApi');
-        const baseUrl = credentials.baseUrl;
+    static async executeTagOperation(executeFunctions, _itemIndex, operation) {
         if (operation === 'getAll') {
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/tags`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
+            const response = await apiRequest(executeFunctions, 'GET', '/api/tags');
             return Array.isArray(response) ? response : [response];
         }
         throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
             message: `The operation "${operation}" is not supported for resource "tag"! Supported operations: getAll`,
         });
     }
-    async executeUserOperation(executeFunctions, itemIndex, operation) {
+    static async executeUserOperation(executeFunctions, _itemIndex, operation) {
         var _a, _b, _c, _d, _e, _f, _g;
-        const credentials = await executeFunctions.getCredentials('inNotesApi');
-        const baseUrl = credentials.baseUrl;
         if (operation === 'get') {
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/user`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
-            return response;
+            return await apiRequest(executeFunctions, 'GET', '/api/user');
         }
         if (operation === 'getCv') {
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'GET',
-                url: `${baseUrl}/api/user`,
-                headers: {
-                    Accept: 'application/json',
-                },
-            });
+            const response = await apiRequest(executeFunctions, 'GET', '/api/user');
             // Return only CV-related fields
             const { cv, job_preferences, cv_updated_at } = response;
             // Parse job_preferences if it's a JSON string
@@ -1082,21 +808,8 @@ class InNotes {
                 penalize: penalize.join(', '),
             };
         }
-        if (operation === 'update') {
-            const updateFields = executeFunctions.getNodeParameter('updateFields', itemIndex);
-            const response = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'inNotesApi', {
-                method: 'PUT',
-                url: `${baseUrl}/api/user`,
-                body: updateFields,
-                headers: {
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                },
-            });
-            return response;
-        }
         throw new n8n_workflow_1.NodeApiError(executeFunctions.getNode(), {
-            message: `The operation "${operation}" is not supported for resource "user"! Supported operations: get, getCv, update`,
+            message: `The operation "${operation}" is not supported for resource "user"! Supported operations: get, getCv`,
         });
     }
 }