@atom8n/n8n-workflow 2.4.2 → 2.5.0

package/dist/cjs/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/cjs/errors/expression-class-extension.error.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./expression.error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExpressionClassExtensionError = void 0;
+    const expression_error_1 = require("./expression.error");
+    class ExpressionClassExtensionError extends expression_error_1.ExpressionError {
+        constructor(baseClass) {
+            super(`Cannot extend "${baseClass}" due to security concerns`);
+        }
+    }
+    exports.ExpressionClassExtensionError = ExpressionClassExtensionError;
+});

package/dist/cjs/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/cjs/errors/expression-computed-destructuring.error.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./expression.error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExpressionComputedDestructuringError = void 0;
+    const expression_error_1 = require("./expression.error");
+    class ExpressionComputedDestructuringError extends expression_error_1.ExpressionError {
+        constructor() {
+            super('Computed property names in destructuring are not allowed due to security concerns');
+        }
+    }
+    exports.ExpressionComputedDestructuringError = ExpressionComputedDestructuringError;
+});

package/dist/cjs/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/cjs/errors/expression-destructuring.error.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./expression.error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExpressionDestructuringError = void 0;
+    const expression_error_1 = require("./expression.error");
+    class ExpressionDestructuringError extends expression_error_1.ExpressionError {
+        constructor(property) {
+            super(`Cannot destructure "${property}" due to security concerns`);
+        }
+    }
+    exports.ExpressionDestructuringError = ExpressionDestructuringError;
+});

package/dist/cjs/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/cjs/node-parameters/node-parameter-value-type-guard.js

@@ -0,0 +1,120 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../type-guards"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isNodeParameterValue = isNodeParameterValue;
+    exports.isAssignmentCollectionValue = isAssignmentCollectionValue;
+    exports.isNodeParameters = isNodeParameters;
+    exports.isValidNodeParameterValueType = isValidNodeParameterValueType;
+    exports.assertIsValidNodeParameterValueType = assertIsValidNodeParameterValueType;
+    const type_guards_1 = require("../type-guards");
+    /**
+     * Type guard for primitive NodeParameterValue types.
+     * Checks if a value is string, number, boolean, undefined, or null.
+     */
+    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.
+     */
+    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.
+     */
+    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
+     * }
+     * ```
+     */
+    function isValidNodeParameterValueType(value) {
+        return (
+        // Primitives (most common case)
+        isNodeParameterValue(value) ||
+            // Special object types
+            (0, type_guards_1.isResourceLocatorValue)(value) ||
+            (0, type_guards_1.isResourceMapperValue)(value) ||
+            (0, type_guards_1.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(type_guards_1.isResourceLocatorValue) ||
+                    value.every(type_guards_1.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
+     * ```
+     */
+    function assertIsValidNodeParameterValueType(value, errorMessage = 'Value is not a valid NodeParameterValueType') {
+        if (!isValidNodeParameterValueType(value)) {
+            throw new Error(errorMessage);
+        }
+    }
+});

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/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);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom8n/n8n-workflow",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "Workflow base code of n8n",
   "types": "dist/esm/index.d.ts",
   "module": "dist/esm/index.js",
@@ -38,9 +38,9 @@
   ],
   "devDependencies": {
     "@langchain/core": "1.1.0",
-    "@n8n/config": "npm:@atom8n/config@2.3.2",
-    "@n8n/typescript-config": "npm:@atom8n/typescript-config@1.5.2",
-    "@n8n/vitest-config": "npm:@atom8n/vitest-config@1.7.2",
+    "@n8n/config": "npm:@atom8n/config@2.4.0",
+    "@n8n/typescript-config": "npm:@atom8n/typescript-config@1.6.0",
+    "@n8n/vitest-config": "npm:@atom8n/vitest-config@1.8.0",
     "@types/express": "^5.0.1",
     "@types/jmespath": "^0.15.0",
     "@types/lodash": "4.17.17",
@@ -51,7 +51,7 @@
     "vitest-mock-extended": "^3.1.0"
   },
   "dependencies": {
-    "@n8n/errors": "npm:@atom8n/errors@0.7.2",
+    "@n8n/errors": "npm:@atom8n/errors@0.8.0",
     "@n8n/tournament": "1.0.6",
     "ast-types": "0.16.1",
     "callsites": "3.1.0",