@hustleops/n8n-nodes-hustleops 0.1.5

package/dist/nodes/HustleOps/GenericFunctions.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_JSON_PARAMETER_CHARS = void 0;
+exports.normalizeBaseUrl = normalizeBaseUrl;
+exports.isUuid = isUuid;
+exports.assertUuid = assertUuid;
+exports.parseIntegerInRange = parseIntegerInRange;
+exports.safePathSegment = safePathSegment;
+exports.compactObject = compactObject;
+exports.redactSensitiveText = redactSensitiveText;
+exports.assertPaginatedResponse = assertPaginatedResponse;
+exports.parsePositiveInteger = parsePositiveInteger;
+exports.parseJsonObject = parseJsonObject;
+exports.parseJsonArray = parseJsonArray;
+exports.testHustleOpsApiCredentials = testHustleOpsApiCredentials;
+exports.createHustleOpsApiClient = createHustleOpsApiClient;
+exports.hustleOpsApiRequest = hustleOpsApiRequest;
+exports.hustleOpsApiRequestEachPage = hustleOpsApiRequestEachPage;
+const n8n_workflow_1 = require("n8n-workflow");
+const constants_1 = require("./constants");
+exports.MAX_JSON_PARAMETER_CHARS = 100000;
+const MAX_ERROR_MESSAGE_CHARS = 1000;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const HELPER_NODE = {
+    id: 'hustleops-helper',
+    name: 'HustleOps',
+    type: 'hustleOps',
+    typeVersion: 1,
+    position: [0, 0],
+    parameters: {},
+};
+function isLocalHttpHost(hostname) {
+    return (hostname === 'localhost' ||
+        hostname === '127.0.0.1' ||
+        hostname === '::1' ||
+        hostname === '[::1]');
+}
+function normalizeBaseUrl(input) {
+    const trimmed = input.trim().replace(/\/+$/, '');
+    if (trimmed === '') {
+        throw new Error('Base URL is required.');
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        throw new n8n_workflow_1.NodeOperationError(HELPER_NODE, 'Base URL must be a valid URL.');
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new Error('Base URL must use HTTP or HTTPS.');
+    }
+    if (url.protocol === 'http:' && !isLocalHttpHost(url.hostname)) {
+        throw new Error('HTTPS is required unless the Base URL host is localhost, 127.0.0.1, or ::1.');
+    }
+    if (url.username !== '' || url.password !== '') {
+        throw new Error('Base URL must not contain embedded credentials.');
+    }
+    if (url.search !== '') {
+        throw new Error('Base URL must not contain query strings.');
+    }
+    if (url.hash !== '') {
+        throw new Error('Base URL must not contain fragments.');
+    }
+    const path = url.pathname.replace(/\/+$/, '');
+    url.pathname = path.endsWith('/api/v1') ? path : `${path}/api/v1`;
+    return url.toString().replace(/\/$/, '');
+}
+function isUuid(value) {
+    return typeof value === 'string' && UUID_PATTERN.test(value.trim());
+}
+function assertUuid(value, label) {
+    if (!isUuid(value)) {
+        throw new Error(`${label} must be a valid UUID.`);
+    }
+    return value.trim();
+}
+function parseIntegerInRange(value, label, minimum, maximum, defaultValue) {
+    const numericValue = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim() !== ''
+            ? Number(value)
+            : (defaultValue !== null && defaultValue !== void 0 ? defaultValue : Number.NaN);
+    if (!Number.isInteger(numericValue) || numericValue < minimum || numericValue > maximum) {
+        throw new Error(`${label} must be between ${minimum} and ${maximum}.`);
+    }
+    return numericValue;
+}
+function safePathSegment(value, label) {
+    return encodeURIComponent(assertUuid(value, label));
+}
+function compactObject(value) {
+    if (Array.isArray(value)) {
+        return value.filter((item) => item !== undefined).map((item) => compactObject(item));
+    }
+    if (value && typeof value === 'object') {
+        const output = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (child !== undefined) {
+                output[key] = compactObject(child);
+            }
+        }
+        return output;
+    }
+    return value;
+}
+function buildRequestId(itemIndex) {
+    return `hustleops-n8n-${Date.now()}-${itemIndex}`;
+}
+function shouldIgnoreSslIssues(value) {
+    return value === true || value === 'true';
+}
+function getErrorBody(error) {
+    var _a, _b, _c, _d, _e, _f;
+    if (error && typeof error === 'object') {
+        const maybeError = error;
+        const statusCode = (_b = (_a = maybeError.response) === null || _a === void 0 ? void 0 : _a.statusCode) !== null && _b !== void 0 ? _b : (_c = maybeError.response) === null || _c === void 0 ? void 0 : _c.status;
+        const body = (_e = (_d = maybeError.response) === null || _d === void 0 ? void 0 : _d.body) !== null && _e !== void 0 ? _e : (_f = maybeError.response) === null || _f === void 0 ? void 0 : _f.data;
+        if (body && typeof body === 'object' && !Array.isArray(body)) {
+            return {
+                ...(typeof statusCode === 'number' ? { statusCode } : {}),
+                ...body,
+            };
+        }
+        if (typeof body === 'string' && body.trim() !== '') {
+            try {
+                const parsed = JSON.parse(body);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                    return {
+                        ...(typeof statusCode === 'number' ? { statusCode } : {}),
+                        ...parsed,
+                    };
+                }
+            }
+            catch {
+                return {
+                    ...(typeof statusCode === 'number' ? { statusCode } : {}),
+                    message: body,
+                };
+            }
+        }
+        if (typeof statusCode === 'number') {
+            return { statusCode };
+        }
+    }
+    return {};
+}
+function redactUrlQuery(value) {
+    return value.replace(/(\/api\/v\d+\/[^?\s]+)\?[^,\s}]*/g, '$1?[REDACTED]');
+}
+function redactSensitiveText(value) {
+    return redactUrlQuery(value)
+        .replace(/Authorization:\s*Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Authorization: Bearer [REDACTED]')
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [REDACTED]')
+        .replace(/x-api-key\s*(?:[:=]|\s)\s*[A-Za-z0-9._~+/=-]+/gi, 'x-api-key [REDACTED]')
+        .replace(/ho_sk_[A-Za-z0-9._~+/=-]+/g, 'ho_sk_[REDACTED]')
+        .replace(/\b(apiKey|token|secret|password)\s*[:=]\s*[^,\s}]+/gi, '$1=[REDACTED]')
+        .slice(0, MAX_ERROR_MESSAGE_CHARS);
+}
+function formatApiError(error) {
+    const body = getErrorBody(error);
+    const statusCode = body.statusCode;
+    const message = Array.isArray(body.message)
+        ? body.message.join(', ')
+        : typeof body.message === 'string'
+            ? body.message
+            : error instanceof Error
+                ? error.message
+                : String(error);
+    const requestId = typeof body.requestId === 'string' ? ` requestId=${body.requestId}` : '';
+    const path = typeof body.path === 'string' ? ` path=${redactUrlQuery(body.path)}` : '';
+    const status = typeof statusCode === 'number' ? ` ${statusCode}` : '';
+    return redactSensitiveText(`HustleOps API error${status}: ${message}${requestId}${path}`);
+}
+function assertPaginatedResponse(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be a paginated response object.`);
+    }
+    const response = value;
+    if (!Array.isArray(response.data)) {
+        throw new Error(`${label} must include a data array.`);
+    }
+    for (const field of ['total', 'page', 'pageSize', 'totalPages']) {
+        const minimum = field === 'total' || field === 'totalPages' ? 0 : 1;
+        if (!Number.isInteger(response[field]) || response[field] < minimum) {
+            throw new Error(`${label} must include integer ${field}.`);
+        }
+    }
+    return response;
+}
+function parsePositiveInteger(context, value, label, itemIndex) {
+    const numericValue = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim() !== ''
+            ? Number(value)
+            : Number.NaN;
+    if (!Number.isInteger(numericValue) || numericValue < 1) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${label} must be a positive integer.`, {
+            itemIndex,
+        });
+    }
+    return numericValue;
+}
+function parseJsonObject(context, value, fieldName, itemIndex) {
+    if (value === undefined || value === null || value === '') {
+        return {};
+    }
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldName} must be a JSON object.`, {
+            itemIndex,
+        });
+    }
+    if (value.length > exports.MAX_JSON_PARAMETER_CHARS) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldName} is too large. Keep JSON parameters under ${exports.MAX_JSON_PARAMETER_CHARS} characters.`, { itemIndex });
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('not an object');
+        }
+        return parsed;
+    }
+    catch {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldName} must be a valid JSON object.`, {
+            itemIndex,
+        });
+    }
+}
+function parseJsonArray(context, value, fieldName, itemIndex) {
+    if (value === undefined || value === null || value === '') {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldName} must be a JSON array.`, {
+            itemIndex,
+        });
+    }
+    if (value.length > exports.MAX_JSON_PARAMETER_CHARS) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldName} is too large. Keep JSON parameters under ${exports.MAX_JSON_PARAMETER_CHARS} characters.`, { itemIndex });
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            throw new Error('not an array');
+        }
+        return parsed;
+    }
+    catch {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `${fieldName} must be a valid JSON array.`, {
+            itemIndex,
+        });
+    }
+}
+async function testHustleOpsApiCredentials(context, credentialData) {
+    var _a, _b, _c;
+    const baseUrl = normalizeBaseUrl(String((_a = credentialData.baseUrl) !== null && _a !== void 0 ? _a : ''));
+    const apiKey = String((_b = credentialData.apiKey) !== null && _b !== void 0 ? _b : '');
+    const ignoreSslIssues = shouldIgnoreSslIssues(credentialData.ignoreSslIssues);
+    const helpers = context.helpers;
+    const usesHttpRequest = !!helpers.httpRequest;
+    const request = (_c = helpers.httpRequest) !== null && _c !== void 0 ? _c : helpers.request;
+    if (!request) {
+        throw new Error('n8n credential-test HTTP helper is not available.');
+    }
+    try {
+        await request.call(helpers, {
+            method: 'GET',
+            url: `${baseUrl}/tags`,
+            headers: {
+                [constants_1.HUSTLEOPS_API_KEY_HEADER]: apiKey,
+                Accept: 'application/json',
+                'x-request-id': buildRequestId(0),
+            },
+            json: true,
+            ...(ignoreSslIssues && usesHttpRequest ? { skipSslCertificateValidation: true } : {}),
+            ...(ignoreSslIssues && !usesHttpRequest ? { rejectUnauthorized: false } : {}),
+        });
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(HELPER_NODE, formatApiError(error));
+    }
+}
+async function createHustleOpsApiClient(context, itemIndex) {
+    const credentials = (await context.getCredentials('hustleOpsApi'));
+    const baseUrl = normalizeBaseUrl(credentials.baseUrl);
+    const ignoreSslIssues = shouldIgnoreSslIssues(credentials.ignoreSslIssues);
+    function buildRequestUrl(path, query) {
+        const url = new URL(`${baseUrl}${path}`);
+        for (const [key, value] of Object.entries(query !== null && query !== void 0 ? query : {})) {
+            if (value !== undefined && value !== null && value !== '') {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+    const request = async (method, path, body, query) => {
+        const hasJsonBody = body !== undefined;
+        try {
+            return (await context.helpers.httpRequest({
+                method,
+                url: buildRequestUrl(path, query),
+                headers: {
+                    [constants_1.HUSTLEOPS_API_KEY_HEADER]: credentials.apiKey,
+                    Accept: 'application/json',
+                    'x-request-id': buildRequestId(itemIndex),
+                    ...(hasJsonBody ? { 'Content-Type': 'application/json' } : {}),
+                },
+                body: hasJsonBody ? compactObject(body) : undefined,
+                json: true,
+                ...(ignoreSslIssues ? { skipSslCertificateValidation: true } : {}),
+            }));
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), formatApiError(error), { itemIndex });
+        }
+    };
+    const requestEachPage = async (path, initialBody, options, onRow) => {
+        var _a, _b, _c;
+        const firstPagination = ((_a = initialBody.pagination) !== null && _a !== void 0 ? _a : {});
+        const pageSize = typeof firstPagination.pageSize === 'number' ? firstPagination.pageSize : 25;
+        const maxItems = (_b = options.maxItems) !== null && _b !== void 0 ? _b : Number.POSITIVE_INFINITY;
+        const maxPages = (_c = options.maxPages) !== null && _c !== void 0 ? _c : Number.POSITIVE_INFINITY;
+        let emitted = 0;
+        let pagesFetched = 0;
+        let page = typeof firstPagination.page === 'number' ? firstPagination.page : 1;
+        let totalPages = 1;
+        do {
+            if (emitted >= maxItems) {
+                return;
+            }
+            const response = assertPaginatedResponse(await request('POST', path, {
+                ...initialBody,
+                pagination: {
+                    ...firstPagination,
+                    page,
+                    pageSize,
+                },
+            }), `${path} paginated response`);
+            for (const row of response.data) {
+                if (emitted >= maxItems) {
+                    return;
+                }
+                onRow(row);
+                emitted += 1;
+            }
+            totalPages = response.totalPages;
+            page += 1;
+            pagesFetched += 1;
+        } while (page <= totalPages && pagesFetched < maxPages);
+    };
+    return { request, requestEachPage };
+}
+async function hustleOpsApiRequest(context, method, path, body, itemIndex, query) {
+    const client = await createHustleOpsApiClient(context, itemIndex);
+    return client.request(method, path, body, query);
+}
+async function hustleOpsApiRequestEachPage(context, path, initialBody, itemIndex, options, onRow) {
+    const client = await createHustleOpsApiClient(context, itemIndex);
+    await client.requestEachPage(path, initialBody, options, onRow);
+}

package/dist/nodes/HustleOps/HustleOps.node.d.ts

@@ -0,0 +1,29 @@
+import type { ICredentialDataDecryptedObject, ICredentialTestFunctions, IExecuteFunctions, ILoadOptionsFunctions, INodeCredentialTestResult, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { type CoreResource } from './resourceDefinitions';
+import { type EntityTagOperation } from './tagDefinitions';
+export type CoreOperation = 'search' | 'count' | 'get' | 'create' | 'update';
+export type HustleOpsOperation = CoreOperation | EntityTagOperation;
+export type HustleOpsResource = CoreResource | 'comment' | 'tag' | 'customField';
+export declare class HustleOps implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        credentialTest: {
+            hustleOps(this: ICredentialTestFunctions, credential: {
+                data?: ICredentialDataDecryptedObject;
+            }): Promise<INodeCredentialTestResult>;
+        };
+        loadOptions: {
+            getTagOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getCustomFieldDefinitionOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getAlertTypeOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getAlertStatusOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getIncidentStatusOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getIncidentCategoryOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getObservableTypeOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getThreatLevelOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getCriticalityOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getKnowledgeTypeOptions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}