@atom8n/n8n-workflow 2.4.3 → 2.5.1

package/dist/esm/errors/expression-class-extension.error.d.ts

@@ -0,0 +1,4 @@
+import { ExpressionError } from './expression.error';
+export declare class ExpressionClassExtensionError extends ExpressionError {
+    constructor(baseClass: string);
+}

package/dist/esm/errors/expression-class-extension.error.js

@@ -0,0 +1,6 @@
+import { ExpressionError } from './expression.error';
+export class ExpressionClassExtensionError extends ExpressionError {
+    constructor(baseClass) {
+        super(`Cannot extend "${baseClass}" due to security concerns`);
+    }
+}

package/dist/esm/errors/expression-computed-destructuring.error.d.ts

@@ -0,0 +1,4 @@
+import { ExpressionError } from './expression.error';
+export declare class ExpressionComputedDestructuringError extends ExpressionError {
+    constructor();
+}

package/dist/esm/errors/expression-computed-destructuring.error.js

@@ -0,0 +1,6 @@
+import { ExpressionError } from './expression.error';
+export class ExpressionComputedDestructuringError extends ExpressionError {
+    constructor() {
+        super('Computed property names in destructuring are not allowed due to security concerns');
+    }
+}

package/dist/esm/errors/expression-destructuring.error.d.ts

@@ -0,0 +1,4 @@
+import { ExpressionError } from './expression.error';
+export declare class ExpressionDestructuringError extends ExpressionError {
+    constructor(property: string);
+}

package/dist/esm/errors/expression-destructuring.error.js

@@ -0,0 +1,6 @@
+import { ExpressionError } from './expression.error';
+export class ExpressionDestructuringError extends ExpressionError {
+    constructor(property) {
+        super(`Cannot destructure "${property}" due to security concerns`);
+    }
+}

package/dist/esm/interfaces.d.ts

@@ -742,6 +742,7 @@ export interface ILoadOptionsFunctions extends FunctionsBase {
 export type FieldValueOption = {
     name: string;
     type: FieldType | 'any';
+    defaultValue?: string;
 };
 export type IWorkflowNodeContext = ExecuteFunctions.GetNodeParameterFn & Pick<FunctionsBase, 'getNode' | 'getWorkflow'>;
 export interface ILocalLoadOptionsFunctions {

package/dist/esm/node-parameters/node-parameter-value-type-guard.d.ts

@@ -0,0 +1,48 @@
+import type { AssignmentCollectionValue, INodeParameters, NodeParameterValue, NodeParameterValueType } from '../interfaces';
+/**
+ * Type guard for primitive NodeParameterValue types.
+ * Checks if a value is string, number, boolean, undefined, or null.
+ */
+export declare function isNodeParameterValue(value: unknown): value is NodeParameterValue;
+/**
+ * Type guard for AssignmentCollectionValue.
+ * Checks if a value has the structure of an assignment collection.
+ */
+export declare function isAssignmentCollectionValue(value: unknown): value is AssignmentCollectionValue;
+/**
+ * Type guard for INodeParameters.
+ * Recursively validates that all values in the object are valid NodeParameterValueType.
+ */
+export declare function isNodeParameters(value: unknown): value is INodeParameters;
+/**
+ * Comprehensive type guard for NodeParameterValueType.
+ * Validates that a value matches any of the valid node parameter value types.
+ *
+ * @param value - The value to check
+ * @returns true if the value is a valid NodeParameterValueType
+ *
+ * @example
+ * ```typescript
+ * const value: unknown = { foo: 'bar' };
+ * if (isValidNodeParameterValueType(value)) {
+ *   // value is now typed as NodeParameterValueType
+ * }
+ * ```
+ */
+export declare function isValidNodeParameterValueType(value: unknown): value is NodeParameterValueType;
+/**
+ * Assertion function that throws if the value is not a valid NodeParameterValueType.
+ * Useful for runtime validation with TypeScript type narrowing.
+ *
+ * @param value - The value to validate
+ * @param errorMessage - Optional custom error message
+ * @throws Error if the value is not a valid NodeParameterValueType
+ *
+ * @example
+ * ```typescript
+ * const value: unknown = getData();
+ * assertIsValidNodeParameterValueType(value);
+ * // value is now typed as NodeParameterValueType
+ * ```
+ */
+export declare function assertIsValidNodeParameterValueType(value: unknown, errorMessage?: string): asserts value is NodeParameterValueType;

package/dist/esm/node-parameters/node-parameter-value-type-guard.js

@@ -0,0 +1,103 @@
+import { isResourceLocatorValue, isResourceMapperValue, isFilterValue } from '../type-guards';
+/**
+ * Type guard for primitive NodeParameterValue types.
+ * Checks if a value is string, number, boolean, undefined, or null.
+ */
+export function isNodeParameterValue(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === undefined ||
+        value === null);
+}
+/**
+ * Type guard for AssignmentCollectionValue.
+ * Checks if a value has the structure of an assignment collection.
+ */
+export function isAssignmentCollectionValue(value) {
+    if (typeof value !== 'object' || value === null || !('assignments' in value)) {
+        return false;
+    }
+    const assignments = value.assignments;
+    if (!Array.isArray(assignments)) {
+        return false;
+    }
+    return assignments.every((assignment) => typeof assignment === 'object' &&
+        assignment !== null &&
+        'id' in assignment &&
+        'name' in assignment &&
+        'value' in assignment &&
+        typeof assignment.id === 'string' &&
+        typeof assignment.name === 'string' &&
+        isNodeParameterValue(assignment.value));
+}
+/**
+ * Type guard for INodeParameters.
+ * Recursively validates that all values in the object are valid NodeParameterValueType.
+ */
+export function isNodeParameters(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    // Reject built-in class instances (Date, RegExp, etc.)
+    // Only accept plain objects created with {} or Object.create(null)
+    if (Object.prototype.toString.call(value) !== '[object Object]') {
+        return false;
+    }
+    // Recursively validate all values
+    return Object.values(value).every((val) => isValidNodeParameterValueType(val));
+}
+/**
+ * Comprehensive type guard for NodeParameterValueType.
+ * Validates that a value matches any of the valid node parameter value types.
+ *
+ * @param value - The value to check
+ * @returns true if the value is a valid NodeParameterValueType
+ *
+ * @example
+ * ```typescript
+ * const value: unknown = { foo: 'bar' };
+ * if (isValidNodeParameterValueType(value)) {
+ *   // value is now typed as NodeParameterValueType
+ * }
+ * ```
+ */
+export function isValidNodeParameterValueType(value) {
+    return (
+    // Primitives (most common case)
+    isNodeParameterValue(value) ||
+        // Special object types
+        isResourceLocatorValue(value) ||
+        isResourceMapperValue(value) ||
+        isFilterValue(value) ||
+        isAssignmentCollectionValue(value) ||
+        // Arrays - all items should be valid NodeParameterValueType
+        (Array.isArray(value) &&
+            (value.length === 0 ||
+                value.every(isNodeParameterValue) ||
+                value.every(isNodeParameters) ||
+                value.every(isResourceLocatorValue) ||
+                value.every(isResourceMapperValue))) ||
+        // INodeParameters (must be last to avoid infinite recursion on first check)
+        isNodeParameters(value));
+}
+/**
+ * Assertion function that throws if the value is not a valid NodeParameterValueType.
+ * Useful for runtime validation with TypeScript type narrowing.
+ *
+ * @param value - The value to validate
+ * @param errorMessage - Optional custom error message
+ * @throws Error if the value is not a valid NodeParameterValueType
+ *
+ * @example
+ * ```typescript
+ * const value: unknown = getData();
+ * assertIsValidNodeParameterValueType(value);
+ * // value is now typed as NodeParameterValueType
+ * ```
+ */
+export function assertIsValidNodeParameterValueType(value, errorMessage = 'Value is not a valid NodeParameterValueType') {
+    if (!isValidNodeParameterValueType(value)) {
+        throw new Error(errorMessage);
+    }
+}