@hustleops/n8n-nodes-hustleops 0.1.5

package/dist/nodes/HustleOps/customFieldDefinitions.js

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_FIELD_ENTITY_TYPE_OPTIONS = exports.CUSTOM_FIELD_OPERATION_OPTIONS = exports.CUSTOM_FIELD_RESOURCE_OPTION = void 0;
+exports.sanitizeCustomFieldGroupBody = sanitizeCustomFieldGroupBody;
+exports.sanitizeCustomFieldDefinitionBody = sanitizeCustomFieldDefinitionBody;
+exports.sanitizeCustomFieldDefinitionBulkUpdate = sanitizeCustomFieldDefinitionBulkUpdate;
+exports.sanitizeCustomFieldDefinitionBulkDelete = sanitizeCustomFieldDefinitionBulkDelete;
+exports.parseCustomFieldEntityIds = parseCustomFieldEntityIds;
+exports.parseCustomFieldValues = parseCustomFieldValues;
+exports.customFieldEntityScope = customFieldEntityScope;
+exports.customFieldBatchBody = customFieldBatchBody;
+exports.extractAttachedCustomFieldValues = extractAttachedCustomFieldValues;
+exports.mergeCustomFieldValues = mergeCustomFieldValues;
+const n8n_workflow_1 = require("n8n-workflow");
+const GenericFunctions_1 = require("./GenericFunctions");
+const resourceDefinitions_1 = require("./resourceDefinitions");
+const CUSTOM_FIELD_ENTITY_TYPES = Object.values(resourceDefinitions_1.CORE_RESOURCE_DEFINITIONS).map((definition) => definition.entityType);
+const CUSTOM_FIELD_ENTITY_TYPE_SET = new Set(CUSTOM_FIELD_ENTITY_TYPES);
+const CUSTOM_FIELD_TYPES = new Set([
+    'TEXT',
+    'NUMBER',
+    'BOOLEAN',
+    'SELECT',
+    'MULTI_SELECT',
+    'DATE',
+    'URL',
+]);
+const GROUP_FIELDS = new Set(['name', 'description', 'sortOrder']);
+const CREATE_DEFINITION_FIELDS = new Set([
+    'name',
+    'description',
+    'fieldType',
+    'isRequired',
+    'defaultValue',
+    'options',
+    'entityTypes',
+    'groupId',
+    'sortOrder',
+]);
+const UPDATE_DEFINITION_FIELDS = new Set([
+    'name',
+    'description',
+    'isRequired',
+    'defaultValue',
+    'options',
+    'entityTypes',
+    'groupId',
+    'sortOrder',
+]);
+const BULK_UPDATE_DEFINITION_FIELDS = new Set(['ids', 'isRequired', 'groupId']);
+const BULK_DELETE_DEFINITION_FIELDS = new Set(['ids', 'force']);
+const MAX_BULK_IDS = 100;
+const CUSTOM_FIELD_DEFINITION_NODE = {
+    id: 'hustleops-custom-field-definitions',
+    name: 'HustleOps',
+    type: 'hustleOps',
+    typeVersion: 1,
+    position: [0, 0],
+    parameters: {},
+};
+exports.CUSTOM_FIELD_RESOURCE_OPTION = {
+    name: 'Custom Field',
+    value: 'customField',
+    description: 'Custom field groups, definitions, and entity values',
+};
+exports.CUSTOM_FIELD_OPERATION_OPTIONS = [
+    {
+        name: 'List Groups',
+        value: 'listGroups',
+        description: 'List custom field groups',
+        action: 'List custom field groups',
+    },
+    {
+        name: 'Create Group',
+        value: 'createGroup',
+        description: 'Create a custom field group. Requires Admin.',
+        action: 'Create a custom field group',
+    },
+    {
+        name: 'Update Group',
+        value: 'updateGroup',
+        description: 'Update a custom field group. Requires Admin.',
+        action: 'Update a custom field group',
+    },
+    {
+        name: 'Delete Group',
+        value: 'deleteGroup',
+        description: 'Delete a custom field group. Requires Admin.',
+        action: 'Delete a custom field group',
+    },
+    {
+        name: 'List Definitions',
+        value: 'listDefinitions',
+        description: 'List custom field definitions',
+        action: 'List custom field definitions',
+    },
+    {
+        name: 'Search Definitions',
+        value: 'searchDefinitions',
+        description: 'Search custom field definitions. Requires Admin.',
+        action: 'Search custom field definitions',
+    },
+    {
+        name: 'Create Definition',
+        value: 'createDefinition',
+        description: 'Create a custom field definition. Requires Admin.',
+        action: 'Create a custom field definition',
+    },
+    {
+        name: 'Update Definition',
+        value: 'updateDefinition',
+        description: 'Update a custom field definition except immutable fieldType. Requires Admin.',
+        action: 'Update a custom field definition',
+    },
+    {
+        name: 'Bulk Update Definitions',
+        value: 'bulkUpdateDefinitions',
+        description: 'Bulk update custom field definition required state or group. Requires Admin.',
+        action: 'Bulk update custom field definitions',
+    },
+    {
+        name: 'Delete Definition',
+        value: 'deleteDefinition',
+        description: 'Delete one custom field definition. Requires Admin.',
+        action: 'Delete a custom field definition',
+    },
+    {
+        name: 'Bulk Delete Definitions',
+        value: 'bulkDeleteDefinitions',
+        description: 'Delete multiple custom field definitions. Requires Admin.',
+        action: 'Bulk delete custom field definitions',
+    },
+    {
+        name: 'Get Values',
+        value: 'getValues',
+        description: 'Get custom field values for one entity',
+        action: 'Get custom field values',
+    },
+    {
+        name: 'Get Available',
+        value: 'getAvailable',
+        description: 'Get applicable custom field definitions plus values for one entity',
+        action: 'Get available custom fields',
+    },
+    {
+        name: 'Batch Get Values',
+        value: 'batchGetValues',
+        description: 'Get custom field values for up to 100 entity IDs',
+        action: 'Batch get custom field values',
+    },
+    {
+        name: 'Replace Values',
+        value: 'replaceValues',
+        description: 'Replace the attached custom field value set for one entity',
+        action: 'Replace custom field values',
+    },
+    {
+        name: 'Update Selected Values Safely',
+        value: 'updateSelectedValuesSafely',
+        description: 'Read current values, merge selected field changes, and send the complete attached set',
+        action: 'Safely update selected custom field values',
+    },
+];
+exports.CUSTOM_FIELD_ENTITY_TYPE_OPTIONS = CUSTOM_FIELD_ENTITY_TYPES.map((entityType) => ({
+    name: entityType.charAt(0) + entityType.slice(1).toLowerCase(),
+    value: entityType,
+    description: `Custom fields 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 : CUSTOM_FIELD_DEFINITION_NODE, message, {
+        itemIndex,
+    });
+}
+function assertAllowedKeys(context, label, body, allowedFields, itemIndex) {
+    for (const key of Object.keys(body)) {
+        if (!allowedFields.has(key)) {
+            throw nodeError(context, `Unsupported Custom Field ${label} field: ${key}`, itemIndex);
+        }
+    }
+}
+function requireString(context, value, label, itemIndex) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw nodeError(context, `${label} is required.`, itemIndex);
+    }
+    return value;
+}
+function optionalString(context, value, label, itemIndex) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw nodeError(context, `${label} must be a string.`, itemIndex);
+    }
+    return value;
+}
+function optionalNumber(context, value, label, itemIndex) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw nodeError(context, `${label} must be a number.`, itemIndex);
+    }
+    return value;
+}
+function optionalBoolean(context, value, label, itemIndex) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'boolean') {
+        throw nodeError(context, `${label} must be a boolean.`, 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 === '') {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return requireUuid(context, value, label, itemIndex);
+}
+function requireEntityType(context, value, itemIndex) {
+    if (typeof value !== 'string' || !CUSTOM_FIELD_ENTITY_TYPE_SET.has(value)) {
+        throw nodeError(context, `Custom field entity type must be one of: ${CUSTOM_FIELD_ENTITY_TYPES.join(', ')}.`, itemIndex);
+    }
+    return value;
+}
+function entityTypes(context, value, required, itemIndex) {
+    if (value === undefined || value === null) {
+        if (required) {
+            throw nodeError(context, 'Custom field definition entityTypes is required.', itemIndex);
+        }
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.length === 0) {
+        throw nodeError(context, 'Custom field definition entityTypes must contain at least one entity type.', itemIndex);
+    }
+    return value.map((entityType) => requireEntityType(context, entityType, itemIndex));
+}
+function definitionOptions(context, value, fieldType, required, itemIndex) {
+    if (value === undefined || value === null) {
+        if (required && (fieldType === 'SELECT' || fieldType === 'MULTI_SELECT')) {
+            throw nodeError(context, 'Custom field definition options are required for SELECT and MULTI_SELECT.', itemIndex);
+        }
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some((option) => typeof option !== 'string')) {
+        throw nodeError(context, 'Custom field definition options must be an array of strings.', itemIndex);
+    }
+    return value;
+}
+function definitionIds(context, value, label, itemIndex) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw nodeError(context, `${label} must contain at least one ID.`, itemIndex);
+    }
+    if (value.length > MAX_BULK_IDS) {
+        throw nodeError(context, `${label} cannot contain more than ${MAX_BULK_IDS} IDs.`, itemIndex);
+    }
+    return value.map((id) => requireUuid(context, id, 'Custom field definition ID', itemIndex));
+}
+function requireFieldType(context, value, itemIndex) {
+    if (typeof value !== 'string' || !CUSTOM_FIELD_TYPES.has(value)) {
+        throw nodeError(context, 'Custom field definition fieldType is required.', itemIndex);
+    }
+    return value;
+}
+function sanitizeCustomFieldGroupBody(context, body, required, itemIndex) {
+    assertAllowedKeys(context, 'group', body, GROUP_FIELDS, itemIndex);
+    const sanitized = (0, GenericFunctions_1.compactObject)({
+        name: required
+            ? requireString(context, body.name, 'Custom field group name', itemIndex)
+            : optionalString(context, body.name, 'Custom field group name', itemIndex),
+        description: optionalString(context, body.description, 'Custom field group description', itemIndex),
+        sortOrder: optionalNumber(context, body.sortOrder, 'Custom field group sortOrder', itemIndex),
+    });
+    if (!required && Object.keys(sanitized).length === 0) {
+        throw nodeError(context, 'Custom field group update body must include at least one field.', itemIndex);
+    }
+    return sanitized;
+}
+function sanitizeCustomFieldDefinitionBody(context, body, operation, itemIndex) {
+    if (operation === 'update' && Object.prototype.hasOwnProperty.call(body, 'fieldType')) {
+        throw nodeError(context, 'Custom field definition fieldType is immutable.', itemIndex);
+    }
+    const allowedFields = operation === 'create' ? CREATE_DEFINITION_FIELDS : UPDATE_DEFINITION_FIELDS;
+    assertAllowedKeys(context, 'definition', body, allowedFields, itemIndex);
+    const fieldType = operation === 'create' ? requireFieldType(context, body.fieldType, itemIndex) : undefined;
+    const sanitized = (0, GenericFunctions_1.compactObject)({
+        name: operation === 'create'
+            ? requireString(context, body.name, 'Custom field definition name', itemIndex)
+            : optionalString(context, body.name, 'Custom field definition name', itemIndex),
+        description: optionalString(context, body.description, 'Custom field definition description', itemIndex),
+        fieldType,
+        isRequired: optionalBoolean(context, body.isRequired, 'Custom field definition isRequired', itemIndex),
+        defaultValue: optionalString(context, body.defaultValue, 'Custom field definition defaultValue', itemIndex),
+        options: definitionOptions(context, body.options, fieldType, operation === 'create', itemIndex),
+        entityTypes: entityTypes(context, body.entityTypes, operation === 'create', itemIndex),
+        groupId: optionalUuid(context, body.groupId, 'Custom field group ID', itemIndex),
+        sortOrder: optionalNumber(context, body.sortOrder, 'Custom field definition sortOrder', itemIndex),
+    });
+    if (operation === 'update' && Object.keys(sanitized).length === 0) {
+        throw nodeError(context, 'Custom field definition update body must include at least one field.', itemIndex);
+    }
+    return sanitized;
+}
+function sanitizeCustomFieldDefinitionBulkUpdate(context, body, itemIndex) {
+    assertAllowedKeys(context, 'definition bulk update', body, BULK_UPDATE_DEFINITION_FIELDS, itemIndex);
+    return (0, GenericFunctions_1.compactObject)({
+        ids: definitionIds(context, body.ids, 'Custom field definition bulk update IDs', itemIndex),
+        isRequired: optionalBoolean(context, body.isRequired, 'Custom field definition isRequired', itemIndex),
+        groupId: optionalUuid(context, body.groupId, 'Custom field group ID', itemIndex),
+    });
+}
+function sanitizeCustomFieldDefinitionBulkDelete(context, body, itemIndex) {
+    assertAllowedKeys(context, 'definition bulk delete', body, BULK_DELETE_DEFINITION_FIELDS, itemIndex);
+    return (0, GenericFunctions_1.compactObject)({
+        ids: definitionIds(context, body.ids, 'Custom field definition bulk delete IDs', itemIndex),
+        force: optionalBoolean(context, body.force, 'Custom field definition bulk delete force', itemIndex),
+    });
+}
+function parseCustomFieldEntityIds(context, value, itemIndex) {
+    const ids = (0, GenericFunctions_1.parseJsonArray)(context, value, 'Entity IDs', itemIndex);
+    if (ids.length === 0) {
+        throw nodeError(context, 'Custom field batch requires at least one entity ID.', itemIndex);
+    }
+    if (ids.length > MAX_BULK_IDS) {
+        throw nodeError(context, `Custom field batch cannot contain more than ${MAX_BULK_IDS} IDs.`, itemIndex);
+    }
+    return ids.map((id) => requireUuid(context, id, 'Custom field entity ID', itemIndex));
+}
+function validateFieldValueByType(context, fieldType, value, itemIndex) {
+    if (fieldType === 'BOOLEAN' && value !== 'true' && value !== 'false') {
+        throw nodeError(context, 'BOOLEAN custom field values must be "true" or "false".', itemIndex);
+    }
+    if (fieldType === 'MULTI_SELECT') {
+        try {
+            const parsed = JSON.parse(value);
+            if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== 'string')) {
+                throw new Error('not a string array');
+            }
+        }
+        catch {
+            throw nodeError(context, 'MULTI_SELECT custom field values must be a JSON array string.', itemIndex);
+        }
+    }
+    if (fieldType === 'NUMBER' && (value.trim() === '' || Number.isNaN(Number(value)))) {
+        throw nodeError(context, 'NUMBER custom field values must parse as a number.', itemIndex);
+    }
+    if (fieldType === 'DATE' && Number.isNaN(Date.parse(value))) {
+        throw nodeError(context, 'DATE custom field values must parse as an ISO date.', itemIndex);
+    }
+    if (fieldType === 'URL') {
+        try {
+            new URL(value);
+        }
+        catch {
+            throw nodeError(context, 'URL custom field values must be valid URLs.', itemIndex);
+        }
+    }
+}
+function serializeCustomFieldValue(context, fieldType, value, itemIndex) {
+    if (value === null) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        if (fieldType && fieldType !== 'MULTI_SELECT') {
+            throw nodeError(context, 'Only MULTI_SELECT custom fields accept array values.', itemIndex);
+        }
+        if (value.some((entry) => typeof entry !== 'string')) {
+            throw nodeError(context, 'MULTI_SELECT custom field arrays must contain only strings.', itemIndex);
+        }
+        return JSON.stringify(value);
+    }
+    if (fieldType === 'NUMBER' && typeof value === 'number' && Number.isFinite(value)) {
+        return String(value);
+    }
+    if (typeof value !== 'string') {
+        throw nodeError(context, 'Custom field values must be strings or null.', itemIndex);
+    }
+    validateFieldValueByType(context, fieldType, value, itemIndex);
+    return value;
+}
+function parseCustomFieldValues(context, value, itemIndex) {
+    return (0, GenericFunctions_1.parseJsonArray)(context, value, 'Custom Field Values', itemIndex).map((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw nodeError(context, 'Each custom field value must be an object.', itemIndex);
+        }
+        const valueEntry = entry;
+        const fieldType = valueEntry.fieldType === undefined
+            ? undefined
+            : requireFieldType(context, valueEntry.fieldType, itemIndex);
+        return {
+            fieldId: requireUuid(context, valueEntry.fieldId, 'Custom field definition ID', itemIndex),
+            value: serializeCustomFieldValue(context, fieldType, valueEntry.value, itemIndex),
+        };
+    });
+}
+function customFieldEntityScope(context, input, itemIndex) {
+    return {
+        entityType: requireEntityType(context, input.entityType, itemIndex),
+        entityId: requireUuid(context, input.entityId, 'Custom field entity ID', itemIndex),
+    };
+}
+function customFieldBatchBody(context, input, itemIndex) {
+    return {
+        entityType: requireEntityType(context, input.entityType, itemIndex),
+        entityIds: parseCustomFieldEntityIds(context, input.entityIds, itemIndex),
+    };
+}
+function extractAttachedCustomFieldValues(value) {
+    const container = value;
+    const rows = Array.isArray(value)
+        ? value
+        : Array.isArray(container === null || container === void 0 ? void 0 : container.values)
+            ? container.values
+            : Array.isArray(container === null || container === void 0 ? void 0 : container.data)
+                ? container.data
+                : [];
+    return rows
+        .filter((row) => !!row && typeof row === 'object' && !Array.isArray(row))
+        .filter((row) => typeof row.fieldId === 'string' && Object.prototype.hasOwnProperty.call(row, 'value'))
+        .map((row) => ({
+        fieldId: row.fieldId,
+        value: row.value === null ? null : String(row.value),
+    }));
+}
+function mergeCustomFieldValues(existing, updates) {
+    const updatesByFieldId = new Map(updates.map((value) => [value.fieldId, value]));
+    const merged = existing.map((value) => { var _a; return (_a = updatesByFieldId.get(value.fieldId)) !== null && _a !== void 0 ? _a : value; });
+    const existingIds = new Set(existing.map((value) => value.fieldId));
+    for (const update of updates) {
+        if (!existingIds.has(update.fieldId)) {
+            merged.push(update);
+        }
+    }
+    return merged;
+}

package/dist/nodes/HustleOps/hustleops.dark.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <path d="M16 3C16 3 2 6 2 6C2 6 1.5 17 7 22.5C10 25.5 16 29 16 29C16 29 22 25.5 25 22.5C30.5 17 30 6 30 6C30 6 16 3 16 3Z" fill="#FEED01" stroke="#E5D600" stroke-width="0.5"/>
+  <path d="M16 4.5C16 4.5 4 7 4 7C4 7 3.5 16.5 8.5 21.5C11 24 16 27 16 27C16 27 21 24 23.5 21.5C28.5 16.5 28 7 28 7C28 7 16 4.5 16 4.5Z" fill="#FEED01"/>
+  <path d="M16 4.5C16 4.5 4 7 4 7C4 7 3.5 13 6 17.5C6 17.5 5 9 16 6.5C16 6.5 16 4.5 16 4.5Z" fill="#FFF84D" opacity="0.4"/>
+  <path d="M18.5 7L11 17H15L13 25L22 14.5H17.5L18.5 7Z" fill="#1a1a1a"/>
+  <path d="M17.8 8.5L12.5 16H15.5L14 23L20.5 15.5H17L17.8 8.5Z" fill="#333" opacity="0.3"/>
+</svg>

package/dist/nodes/HustleOps/hustleops.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <path d="M16 3C16 3 2 6 2 6C2 6 1.5 17 7 22.5C10 25.5 16 29 16 29C16 29 22 25.5 25 22.5C30.5 17 30 6 30 6C30 6 16 3 16 3Z" fill="#FEED01" stroke="#E5D600" stroke-width="0.5"/>
+  <path d="M16 4.5C16 4.5 4 7 4 7C4 7 3.5 16.5 8.5 21.5C11 24 16 27 16 27C16 27 21 24 23.5 21.5C28.5 16.5 28 7 28 7C28 7 16 4.5 16 4.5Z" fill="#FEED01"/>
+  <path d="M16 4.5C16 4.5 4 7 4 7C4 7 3.5 13 6 17.5C6 17.5 5 9 16 6.5C16 6.5 16 4.5 16 4.5Z" fill="#FFF84D" opacity="0.4"/>
+  <path d="M18.5 7L11 17H15L13 25L22 14.5H17.5L18.5 7Z" fill="#1a1a1a"/>
+  <path d="M17.8 8.5L12.5 16H15.5L14 23L20.5 15.5H17L17.8 8.5Z" fill="#333" opacity="0.3"/>
+</svg>

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

@@ -0,0 +1,18 @@
+import type { INodeProperties } from 'n8n-workflow';
+export declare const PAYLOAD_INPUT_MODE_PARAMETER = "payloadInputMode";
+export declare const PAYLOAD_MODE_INDIVIDUAL_FIELDS = "individualFields";
+export declare const PAYLOAD_MODE_JSON_OBJECT = "jsonObject";
+export type PayloadInputMode = typeof PAYLOAD_MODE_INDIVIDUAL_FIELDS | typeof PAYLOAD_MODE_JSON_OBJECT;
+export declare const PAYLOAD_INPUT_MODE_OPTIONS: readonly [{
+    readonly name: "Individual Fields";
+    readonly value: "individualFields";
+    readonly description: "Build the request body from visible node fields";
+}, {
+    readonly name: "JSON Object";
+    readonly value: "jsonObject";
+    readonly description: "Submit the JSON object as the complete request body";
+}];
+export declare const RETIRED_PAYLOAD_PARAMETERS: readonly [string, "body", string, string, string, string, string, string, "entityIds"];
+export declare function payloadJsonObjectParameterName(resource: string, operation: string): string;
+export declare function payloadModeDisplayOptions(resources: readonly string[], operations: readonly string[]): INodeProperties['displayOptions'];
+export declare function modeDisplayOptions(resources: readonly string[], operations: readonly string[], mode: PayloadInputMode): INodeProperties['displayOptions'];

package/dist/nodes/HustleOps/payloadInputMode.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETIRED_PAYLOAD_PARAMETERS = exports.PAYLOAD_INPUT_MODE_OPTIONS = exports.PAYLOAD_MODE_JSON_OBJECT = exports.PAYLOAD_MODE_INDIVIDUAL_FIELDS = exports.PAYLOAD_INPUT_MODE_PARAMETER = void 0;
+exports.payloadJsonObjectParameterName = payloadJsonObjectParameterName;
+exports.payloadModeDisplayOptions = payloadModeDisplayOptions;
+exports.modeDisplayOptions = modeDisplayOptions;
+exports.PAYLOAD_INPUT_MODE_PARAMETER = 'payloadInputMode';
+exports.PAYLOAD_MODE_INDIVIDUAL_FIELDS = 'individualFields';
+exports.PAYLOAD_MODE_JSON_OBJECT = 'jsonObject';
+exports.PAYLOAD_INPUT_MODE_OPTIONS = [
+    {
+        name: 'Individual Fields',
+        value: exports.PAYLOAD_MODE_INDIVIDUAL_FIELDS,
+        description: 'Build the request body from visible node fields',
+    },
+    {
+        name: 'JSON Object',
+        value: exports.PAYLOAD_MODE_JSON_OBJECT,
+        description: 'Submit the JSON object as the complete request body',
+    },
+];
+const retiredParameter = (...parts) => parts.join('');
+exports.RETIRED_PAYLOAD_PARAMETERS = [
+    retiredParameter('additional', 'Json'),
+    'body',
+    retiredParameter('search', 'Body'),
+    retiredParameter('tag', 'Body'),
+    retiredParameter('tag', 'Values'),
+    retiredParameter('comment', 'Body'),
+    retiredParameter('customField', 'Body'),
+    retiredParameter('customField', 'Values'),
+    'entityIds',
+];
+function toPascalCase(value) {
+    return value.replace(/(^|[-_\s]+)([a-z0-9])/g, (_match, _separator, character) => character.toUpperCase());
+}
+function payloadJsonObjectParameterName(resource, operation) {
+    return `payload${toPascalCase(resource)}${toPascalCase(operation)}JsonObject`;
+}
+function payloadModeDisplayOptions(resources, operations) {
+    return {
+        show: {
+            resource: [...resources],
+            operation: [...operations],
+        },
+    };
+}
+function modeDisplayOptions(resources, operations, mode) {
+    return {
+        show: {
+            resource: [...resources],
+            operation: [...operations],
+            [exports.PAYLOAD_INPUT_MODE_PARAMETER]: [mode],
+        },
+    };
+}

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

@@ -0,0 +1,48 @@
+import type { IDataObject } from 'n8n-workflow';
+export type CoreResource = 'alert' | 'incident' | 'observable' | 'knowledge';
+export type DtoOperation = 'create' | 'update';
+export type FieldSpec = {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'uuid' | 'uuid[]' | 'enum' | 'date-time' | 'url' | 'tags';
+    requiredForCreate?: boolean;
+    allowedValues?: readonly string[];
+    picklistDomain?: string;
+    picklistValueTransform?: 'uppercase';
+    maxLength?: number;
+    nonEmpty?: boolean;
+    pattern?: RegExp;
+    patternDescription?: string;
+    description?: string;
+};
+export type CoreResourceDefinition = {
+    resource: CoreResource;
+    displayName: string;
+    description: string;
+    entityType: 'ALERT' | 'INCIDENT' | 'OBSERVABLE' | 'KNOWLEDGE';
+    path: string;
+    defaultSortBy: string;
+    defaultSortOrder: 'asc' | 'desc';
+    searchFields: readonly string[];
+    sortFields: readonly string[];
+    createFields: readonly string[];
+    updateFields: readonly string[];
+    requiredCreateFields: readonly string[];
+    fieldSpecs: Readonly<Record<string, FieldSpec>>;
+};
+export type SearchRequestDefinition = {
+    displayName: string;
+    defaultSortBy: string;
+    defaultSortOrder: 'asc' | 'desc';
+    searchFields: readonly string[];
+    sortFields: readonly string[];
+};
+export declare const CORE_RESOURCE_DEFINITIONS: Record<CoreResource, CoreResourceDefinition>;
+export declare const CORE_RESOURCE_OPTIONS: {
+    name: string;
+    value: CoreResource;
+    description: string;
+}[];
+export declare function getCoreResourceDefinition(resource: string): CoreResourceDefinition;
+export declare function sanitizeDtoBody(definition: CoreResourceDefinition, operation: DtoOperation, body: IDataObject): IDataObject;
+export declare function buildGenericSearchRequest(definition: SearchRequestDefinition, input: IDataObject): IDataObject;
+export declare function buildSearchRequest(definition: CoreResourceDefinition, input: IDataObject): IDataObject;