@hustleops/n8n-nodes-hustleops 0.1.5

package/dist/nodes/HustleOps/HustleOps.node.json

@@ -0,0 +1,18 @@
+{
+    "node": "@hustleops/n8n-nodes-hustleops",
+    "nodeVersion": "1.0",
+    "codexVersion": "1.0",
+    "categories": ["Development", "Security"],
+    "resources": {
+        "credentialDocumentation": [
+            {
+                "url": "https://github.com/HustleOps/hustleops-n8n-plugin#authentication"
+            }
+        ],
+        "primaryDocumentation": [
+            {
+                "url": "https://github.com/HustleOps/hustleops-n8n-plugin#readme"
+            }
+        ]
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { IDataObject, IExecuteFunctions, INodePropertyOptions } from 'n8n-workflow';
+import { type HustleOpsQueryParams } from './GenericFunctions';
+export type CommentEntityType = 'ALERT' | 'INCIDENT' | 'OBSERVABLE' | 'KNOWLEDGE';
+export type CommentOperation = 'list' | 'search' | 'unreadCount' | 'create' | 'markRead' | 'update' | 'delete' | 'toggleReaction' | 'togglePin';
+export type CommentListResponse = {
+    items: IDataObject[];
+    nextCursor: string | null;
+};
+type ValidationContext = Pick<IExecuteFunctions, 'getNode'>;
+export declare const COMMENT_RESOURCE_OPTION: INodePropertyOptions;
+export declare const COMMENT_OPERATION_OPTIONS: INodePropertyOptions[];
+export declare const COMMENT_ENTITY_TYPE_OPTIONS: INodePropertyOptions[];
+export declare function buildCommentEntityQuery(context: ValidationContext, input: IDataObject, itemIndex: number): HustleOpsQueryParams;
+export declare function buildCommentSearchQuery(context: ValidationContext, input: IDataObject, itemIndex: number): HustleOpsQueryParams;
+export declare function parseCommentMaxResults(context: ValidationContext, value: unknown, itemIndex: number): number;
+export declare function sanitizeCreateComment(context: ValidationContext, entityScope: IDataObject, body: IDataObject, itemIndex: number): IDataObject;
+export declare function sanitizeMarkReadComment(context: ValidationContext, input: IDataObject, itemIndex: number): IDataObject;
+export declare function sanitizeUpdateComment(context: ValidationContext, input: IDataObject, itemIndex: number): IDataObject;
+export declare function sanitizeToggleReaction(context: ValidationContext, input: IDataObject, itemIndex: number): IDataObject;
+export declare function assertCommentListResponse(value: unknown, label: string): CommentListResponse;
+export {};

package/dist/nodes/HustleOps/commentDefinitions.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMENT_ENTITY_TYPE_OPTIONS = exports.COMMENT_OPERATION_OPTIONS = exports.COMMENT_RESOURCE_OPTION = void 0;
+exports.buildCommentEntityQuery = buildCommentEntityQuery;
+exports.buildCommentSearchQuery = buildCommentSearchQuery;
+exports.parseCommentMaxResults = parseCommentMaxResults;
+exports.sanitizeCreateComment = sanitizeCreateComment;
+exports.sanitizeMarkReadComment = sanitizeMarkReadComment;
+exports.sanitizeUpdateComment = sanitizeUpdateComment;
+exports.sanitizeToggleReaction = sanitizeToggleReaction;
+exports.assertCommentListResponse = assertCommentListResponse;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+const resourceDefinitions_1 = require("./resourceDefinitions");
+const COMMENT_ENTITY_TYPES = Object.values(resourceDefinitions_1.CORE_RESOURCE_DEFINITIONS).map((definition) => definition.entityType);
+const COMMENT_ENTITY_TYPE_SET = new Set(COMMENT_ENTITY_TYPES);
+const MAX_COMMENT_CONTENT_LENGTH = 5000;
+const MAX_COMMENT_SEARCH_QUERY_LENGTH = 500;
+const MAX_COMMENT_ATTACHMENTS = 3;
+const MAX_COMMENT_EMOJI_LENGTH = 16;
+const MAX_COMMENT_TAKE = 100;
+const DEFAULT_COMMENT_TAKE = 50;
+const DEFAULT_COMMENT_MAX_RESULTS = 100;
+const COMMENT_CREATE_BODY_FIELDS = new Set(['content', 'parentId', 'attachmentIds']);
+const COMMENT_UPDATE_FIELDS = new Set(['content']);
+const COMMENT_REACTION_FIELDS = new Set(['emoji']);
+const COMMENT_DEFINITION_NODE = {
+    id: 'hustleops-comment-definitions',
+    name: 'HustleOps',
+    type: 'hustleOps',
+    typeVersion: 1,
+    position: [0, 0],
+    parameters: {},
+};
+exports.COMMENT_RESOURCE_OPTION = {
+    name: 'Comment',
+    value: 'comment',
+    description: 'Comment thread entries for alerts, incidents, observables, and knowledge',
+};
+exports.COMMENT_OPERATION_OPTIONS = [
+    {
+        name: 'List',
+        value: 'list',
+        description: 'List comments for an entity thread',
+        action: 'List comments',
+    },
+    {
+        name: 'Search',
+        value: 'search',
+        description: 'Search comments within an entity thread',
+        action: 'Search comments',
+    },
+    {
+        name: 'Get Unread Count',
+        value: 'unreadCount',
+        description: 'Get unread comment count for an entity thread',
+        action: 'Get unread comment count',
+    },
+    {
+        name: 'Create',
+        value: 'create',
+        description: 'Create a comment or reply',
+        action: 'Create a comment',
+    },
+    {
+        name: 'Mark Read',
+        value: 'markRead',
+        description: 'Mark an entity comment thread as read',
+        action: 'Mark comments as read',
+    },
+    {
+        name: 'Update',
+        value: 'update',
+        description: 'Update a comment body',
+        action: 'Update a comment',
+    },
+    {
+        name: 'Delete',
+        value: 'delete',
+        description: 'Delete a comment',
+        action: 'Delete a comment',
+    },
+    {
+        name: 'Toggle Reaction',
+        value: 'toggleReaction',
+        description: 'Toggle the current user reaction for a comment',
+        action: 'Toggle comment reaction',
+    },
+    {
+        name: 'Toggle Pin',
+        value: 'togglePin',
+        description: 'Toggle pinned state for a comment',
+        action: 'Toggle comment pin',
+    },
+];
+exports.COMMENT_ENTITY_TYPE_OPTIONS = COMMENT_ENTITY_TYPES.map((entityType) => ({
+    name: entityType.charAt(0) + entityType.slice(1).toLowerCase(),
+    value: entityType,
+    description: `Comment thread for ${entityType.toLowerCase()} entities`,
+}));
+function nodeError(context, message, itemIndex) {
+    var _a, _b;
+    return new n8n_workflow_1.NodeOperationError((_b = (_a = context.getNode) === null || _a === void 0 ? void 0 : _a.call(context)) !== null && _b !== void 0 ? _b : COMMENT_DEFINITION_NODE, message, {
+        itemIndex,
+    });
+}
+function requireEntityType(context, value, itemIndex) {
+    if (typeof value !== 'string' || !COMMENT_ENTITY_TYPE_SET.has(value)) {
+        throw nodeError(context, `Comment entity type must be one of: ${COMMENT_ENTITY_TYPES.join(', ')}.`, itemIndex);
+    }
+    return value;
+}
+function requireUuid(context, value, label, itemIndex) {
+    try {
+        return (0, GenericFunctions_1.assertUuid)(value, label);
+    }
+    catch {
+        throw nodeError(context, `${label} must be a valid UUID.`, itemIndex);
+    }
+}
+function optionalUuid(context, value, label, itemIndex) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    return requireUuid(context, value, label, itemIndex);
+}
+function optionalContent(context, value, required, itemIndex) {
+    if (value === undefined || value === null) {
+        if (required) {
+            throw nodeError(context, 'Comment content is required.', itemIndex);
+        }
+        return undefined;
+    }
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw nodeError(context, 'Comment content is required.', itemIndex);
+    }
+    if (value.length > MAX_COMMENT_CONTENT_LENGTH) {
+        throw nodeError(context, `Comment content cannot exceed ${MAX_COMMENT_CONTENT_LENGTH} characters.`, itemIndex);
+    }
+    return value;
+}
+function attachmentIds(context, value, itemIndex) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw nodeError(context, 'Comment attachmentIds must be an array of UUIDs.', itemIndex);
+    }
+    if (value.length > MAX_COMMENT_ATTACHMENTS) {
+        throw nodeError(context, `Comment attachmentIds cannot contain more than ${MAX_COMMENT_ATTACHMENTS} IDs.`, itemIndex);
+    }
+    return value.map((id) => requireUuid(context, id, 'Comment attachment ID', itemIndex));
+}
+function integerInRange(context, value, label, minimum, maximum, defaultValue, itemIndex) {
+    try {
+        return (0, GenericFunctions_1.parseIntegerInRange)(value, label, minimum, maximum, defaultValue);
+    }
+    catch (error) {
+        throw nodeError(context, error instanceof Error
+            ? error.message
+            : `${label} must be between ${minimum} and ${maximum}.`, itemIndex);
+    }
+}
+function assertAllowedCommentKeys(context, operationLabel, input, allowedKeys, itemIndex) {
+    for (const key of Object.keys(input)) {
+        if (!allowedKeys.has(key)) {
+            throw nodeError(context, `Unsupported Comment ${operationLabel} field: ${key}`, itemIndex);
+        }
+    }
+}
+function buildCommentEntityQuery(context, input, itemIndex) {
+    return (0, GenericFunctions_1.compactObject)({
+        entityType: requireEntityType(context, input.entityType, itemIndex),
+        entityId: requireUuid(context, input.entityId, 'Comment entity ID', itemIndex),
+        cursor: optionalUuid(context, input.cursor, 'Comment cursor', itemIndex),
+        take: input.take === undefined
+            ? undefined
+            : integerInRange(context, input.take, 'Comment take', 1, MAX_COMMENT_TAKE, DEFAULT_COMMENT_TAKE, itemIndex),
+    });
+}
+function buildCommentSearchQuery(context, input, itemIndex) {
+    const q = input.q;
+    if (typeof q !== 'string' || q.trim() === '') {
+        throw nodeError(context, 'Comment search query is required.', itemIndex);
+    }
+    if (q.length > MAX_COMMENT_SEARCH_QUERY_LENGTH) {
+        throw nodeError(context, `Comment search query cannot exceed ${MAX_COMMENT_SEARCH_QUERY_LENGTH} characters.`, itemIndex);
+    }
+    return {
+        entityType: requireEntityType(context, input.entityType, itemIndex),
+        entityId: requireUuid(context, input.entityId, 'Comment entity ID', itemIndex),
+        q,
+    };
+}
+function parseCommentMaxResults(context, value, itemIndex) {
+    return integerInRange(context, value, 'Comment Max Results', 1, MAX_COMMENT_TAKE, DEFAULT_COMMENT_MAX_RESULTS, itemIndex);
+}
+function sanitizeCreateComment(context, entityScope, body, itemIndex) {
+    assertAllowedCommentKeys(context, 'create body', body, COMMENT_CREATE_BODY_FIELDS, itemIndex);
+    const content = optionalContent(context, body.content, false, itemIndex);
+    const ids = attachmentIds(context, body.attachmentIds, itemIndex);
+    if (!content && (!ids || ids.length === 0)) {
+        throw nodeError(context, 'Comment create requires content or attachmentIds.', itemIndex);
+    }
+    return (0, GenericFunctions_1.compactObject)({
+        entityType: requireEntityType(context, entityScope.entityType, itemIndex),
+        entityId: requireUuid(context, entityScope.entityId, 'Comment entity ID', itemIndex),
+        content,
+        parentId: optionalUuid(context, body.parentId, 'Comment parent ID', itemIndex),
+        attachmentIds: ids,
+    });
+}
+function sanitizeMarkReadComment(context, input, itemIndex) {
+    return {
+        entityType: requireEntityType(context, input.entityType, itemIndex),
+        entityId: requireUuid(context, input.entityId, 'Comment entity ID', itemIndex),
+    };
+}
+function sanitizeUpdateComment(context, input, itemIndex) {
+    assertAllowedCommentKeys(context, 'update', input, COMMENT_UPDATE_FIELDS, itemIndex);
+    return {
+        content: optionalContent(context, input.content, true, itemIndex),
+    };
+}
+function sanitizeToggleReaction(context, input, itemIndex) {
+    assertAllowedCommentKeys(context, 'reaction', input, COMMENT_REACTION_FIELDS, itemIndex);
+    const emoji = input.emoji;
+    if (typeof emoji !== 'string' || emoji.trim() === '') {
+        throw nodeError(context, 'Comment emoji is required.', itemIndex);
+    }
+    if (emoji.length > MAX_COMMENT_EMOJI_LENGTH) {
+        throw nodeError(context, `Comment emoji cannot exceed ${MAX_COMMENT_EMOJI_LENGTH} characters.`, itemIndex);
+    }
+    return { emoji };
+}
+function assertCommentListResponse(value, label) {
+    var _a;
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label} must be a comment list response object.`);
+    }
+    const response = value;
+    if (!Array.isArray(response.items)) {
+        throw new Error(`${label} must include an items array.`);
+    }
+    if (response.nextCursor !== undefined &&
+        response.nextCursor !== null &&
+        typeof response.nextCursor !== 'string') {
+        throw new Error(`${label} nextCursor must be a string or null.`);
+    }
+    return {
+        items: response.items,
+        nextCursor: (_a = response.nextCursor) !== null && _a !== void 0 ? _a : null,
+    };
+}

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

@@ -0,0 +1 @@
+export declare const HUSTLEOPS_API_KEY_HEADER = "x-api-key";

package/dist/nodes/HustleOps/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUSTLEOPS_API_KEY_HEADER = void 0;
+exports.HUSTLEOPS_API_KEY_HEADER = 'x-api-key';

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

@@ -0,0 +1,36 @@
+import type { IDataObject, IExecuteFunctions, INodePropertyOptions } from 'n8n-workflow';
+export type CustomFieldOperation = 'listGroups' | 'createGroup' | 'updateGroup' | 'deleteGroup' | 'listDefinitions' | 'searchDefinitions' | 'createDefinition' | 'updateDefinition' | 'bulkUpdateDefinitions' | 'deleteDefinition' | 'bulkDeleteDefinitions' | 'getValues' | 'getAvailable' | 'batchGetValues' | 'replaceValues' | 'updateSelectedValuesSafely';
+export type CustomFieldEntityType = 'ALERT' | 'INCIDENT' | 'OBSERVABLE' | 'KNOWLEDGE';
+type ValidationContext = Pick<IExecuteFunctions, 'getNode'>;
+export declare const CUSTOM_FIELD_RESOURCE_OPTION: INodePropertyOptions;
+export declare const CUSTOM_FIELD_OPERATION_OPTIONS: INodePropertyOptions[];
+export declare const CUSTOM_FIELD_ENTITY_TYPE_OPTIONS: INodePropertyOptions[];
+export declare function sanitizeCustomFieldGroupBody(context: ValidationContext, body: IDataObject, required: boolean, itemIndex: number): IDataObject;
+export declare function sanitizeCustomFieldDefinitionBody(context: ValidationContext, body: IDataObject, operation: 'create' | 'update', itemIndex: number): IDataObject;
+export declare function sanitizeCustomFieldDefinitionBulkUpdate(context: ValidationContext, body: IDataObject, itemIndex: number): IDataObject;
+export declare function sanitizeCustomFieldDefinitionBulkDelete(context: ValidationContext, body: IDataObject, itemIndex: number): IDataObject;
+export declare function parseCustomFieldEntityIds(context: ValidationContext, value: unknown, itemIndex: number): string[];
+export declare function parseCustomFieldValues(context: ValidationContext, value: unknown, itemIndex: number): Array<{
+    fieldId: string;
+    value: string | null;
+}>;
+export declare function customFieldEntityScope(context: ValidationContext, input: IDataObject, itemIndex: number): {
+    entityType: CustomFieldEntityType;
+    entityId: string;
+};
+export declare function customFieldBatchBody(context: ValidationContext, input: IDataObject, itemIndex: number): IDataObject;
+export declare function extractAttachedCustomFieldValues(value: unknown): Array<{
+    fieldId: string;
+    value: string | null;
+}>;
+export declare function mergeCustomFieldValues(existing: Array<{
+    fieldId: string;
+    value: string | null;
+}>, updates: Array<{
+    fieldId: string;
+    value: string | null;
+}>): Array<{
+    fieldId: string;
+    value: string | null;
+}>;
+export {};