@lowdefy/operators 4.5.1 → 4.6.0

package/dist/buildParser.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -12,11 +12,41 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { serializer, type } from '@lowdefy/helpers';
+*/ import { ConfigError, OperatorError } from '@lowdefy/errors';
+import { serializer, type } from '@lowdefy/helpers';
 let BuildParser = class BuildParser {
-    // TODO: Look at logging here
-    // TODO: Remove console.error = () => {}; from tests
-    parse({ args, input, location, operatorPrefix = '_' }) {
+    // Check if value or its immediate children have the dynamic marker
+    // Note: Only checks immediate children because bubble-up happens bottom-up in reviver
+    static hasDynamicMarker(value) {
+        if (type.isArray(value) && value['~dyn'] === true) return true;
+        if (type.isObject(value) && value['~dyn'] === true) return true;
+        if (type.isArray(value)) {
+            return value.some((item)=>{
+                if (type.isArray(item) && item['~dyn'] === true) return true;
+                if (type.isObject(item) && item['~dyn'] === true) return true;
+                return false;
+            });
+        }
+        if (type.isObject(value)) {
+            return Object.values(value).some((item)=>{
+                if (type.isArray(item) && item['~dyn'] === true) return true;
+                if (type.isObject(item) && item['~dyn'] === true) return true;
+                return false;
+            });
+        }
+        return false;
+    }
+    // Set dynamic marker as non-enumerable property
+    static setDynamicMarker(value) {
+        if (type.isObject(value) || type.isArray(value)) {
+            Object.defineProperty(value, '~dyn', {
+                value: true,
+                enumerable: false
+            });
+        }
+        return value;
+    }
+    parse({ args, input, operatorPrefix = '_' }) {
         if (type.isUndefined(input)) {
             return {
                 output: input,
@@ -26,28 +56,76 @@ let BuildParser = class BuildParser {
         if (args && !type.isArray(args)) {
             throw new Error('Operator parser args must be an array.');
         }
-        if (!type.isString(location)) {
-            throw new Error('Operator parser location must be a string.');
-        }
         const errors = [];
         const reviver = (_, value)=>{
+            // Handle arrays: bubble up dynamic marker if any element is dynamic
+            if (type.isArray(value)) {
+                if (BuildParser.hasDynamicMarker(value)) {
+                    return BuildParser.setDynamicMarker(value);
+                }
+                return value;
+            }
             if (!type.isObject(value)) return value;
-            // TODO: pass ~r in errors. Build does not have ~k.
-            if (type.isString(value['~r'])) return value;
-            if (Object.keys(value).length !== 1) return value;
-            const key = Object.keys(value)[0];
-            if (!key.startsWith(operatorPrefix)) return value;
+            // ~shallow placeholders are unresolved refs — mark as dynamic so operators
+            // wrapping them are preserved for evaluation after resolution (JIT builds).
+            if (value['~shallow'] === true) {
+                return BuildParser.setDynamicMarker(value);
+            }
+            // Check if this is an operator object BEFORE checking ~r
+            // Operators in vars have ~r set by copyVarValue (as enumerable), but should still be evaluated
+            // Filter out ~ prefixed keys (like ~r, ~k, ~l) when determining if single-key operator
+            const keys = Object.keys(value);
+            const nonTildeKeys = keys.filter((k)=>!k.startsWith('~'));
+            const isSingleKeyObject = nonTildeKeys.length === 1;
+            const key = isSingleKeyObject ? nonTildeKeys[0] : null;
+            const isOperatorObject = key && key.startsWith(operatorPrefix);
+            // Type boundary reset: if object has a 'type' key matching a registered type,
+            // delete the ~dyn marker and skip bubble-up to prevent propagation past this boundary
+            const isTypeBoundary = type.isString(value.type) && this.typeNames.has(value.type);
+            if (isTypeBoundary) {
+                delete value['~dyn'];
+            }
+            // Check if params contain dynamic content (bubble up), but not at type boundaries
+            // This must happen BEFORE the ~r check to allow dynamic markers to propagate
+            if (!isTypeBoundary && BuildParser.hasDynamicMarker(value)) {
+                return BuildParser.setDynamicMarker(value);
+            }
+            // Skip non-operator objects that have already been processed (have ~r marker)
+            // But allow operator objects to be evaluated even if they have ~r
+            if (type.isString(value['~r']) && !isOperatorObject) return value;
+            if (!isSingleKeyObject) return value;
+            if (!isOperatorObject) return value;
             const [op, methodName] = `_${key.substring(operatorPrefix.length)}`.split('.');
-            if (type.isUndefined(this.operators[op])) return value;
+            // Check if this operator/method is dynamic
+            // Skip this check for _build.* operators (operatorPrefix === '_build.') because
+            // build operators should ALWAYS be evaluated at build time
+            const fullIdentifier = methodName ? `${op}.${methodName}` : op;
+            if (operatorPrefix !== '_build.') {
+                if (this.dynamicIdentifiers.has(fullIdentifier) || this.dynamicIdentifiers.has(op)) {
+                    return BuildParser.setDynamicMarker(value);
+                }
+            }
+            // If operator is not in our operators map, it's a runtime-only operator
+            // Mark it as dynamic to preserve it for runtime evaluation
+            if (type.isUndefined(this.operators[op])) {
+                return BuildParser.setDynamicMarker(value);
+            }
+            // Check if params contain dynamic content before evaluating
+            if (BuildParser.hasDynamicMarker(value[key])) {
+                return BuildParser.setDynamicMarker(value);
+            }
+            const configKey = value['~k'];
+            const lineNumber = value['~l'];
+            const refId = value['~r'];
+            const params = value[key];
             try {
                 const res = this.operators[op]({
                     args,
                     arrayIndices: [],
                     env: this.env,
-                    location,
                     methodName,
                     operators: this.operators,
-                    params: value[key],
+                    params,
                     operatorPrefix,
                     parser: this,
                     payload: this.payload,
@@ -57,10 +135,34 @@ let BuildParser = class BuildParser {
                 });
                 return res;
             } catch (e) {
-                errors.push(e);
-                if (this.verbose) {
-                    console.error(e);
+                if (e instanceof ConfigError) {
+                    if (!e.configKey) {
+                        e.configKey = configKey;
+                    }
+                    if (!e.lineNumber) {
+                        e.lineNumber = lineNumber;
+                    }
+                    if (!e.refId) {
+                        e.refId = refId;
+                    }
+                    errors.push(e);
+                    return null;
                 }
+                const operatorError = new OperatorError(e.message, {
+                    cause: e,
+                    typeName: op,
+                    received: {
+                        [key]: params
+                    },
+                    configKey: e.configKey ?? configKey
+                });
+                // lineNumber and refId needed by buildRefs consumers (evaluateBuildOperators,
+                // evaluateStaticOperators) which run before addKeys — no configKey
+                // exists yet, so they use filePath + lineNumber for resolution.
+                // refId (from ~r) identifies the source file in the refMap.
+                operatorError.lineNumber = lineNumber;
+                operatorError.refId = refId;
+                errors.push(operatorError);
                 return null;
             }
         };
@@ -71,14 +173,15 @@ let BuildParser = class BuildParser {
             errors
         };
     }
-    constructor({ env, payload, secrets, user, operators, verbose }){
+    constructor({ env, payload, secrets, user, operators, dynamicIdentifiers, typeNames }){
         this.env = env;
         this.operators = operators;
         this.parse = this.parse.bind(this);
         this.payload = payload;
         this.secrets = secrets;
         this.user = user;
-        this.verbose = verbose;
+        this.dynamicIdentifiers = dynamicIdentifiers ?? new Set();
+        this.typeNames = typeNames ?? new Set();
     }
 };
 export default BuildParser;

package/dist/getFromArray.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -26,12 +26,12 @@ function getFromArray({ params, array, key, operator, location }) {
         if (type.isString(params.value)) return array.find((item)=>item[key] === params.value);
         if (type.isNumber(params.index)) return array[params.index];
         if (!type.isNone(params.value) && !type.isString(params.value)) {
-            throw new Error(`Operator Error: ${operator}.value must be of type string. Received: ${JSON.stringify(params)} at ${location}.`);
+            throw new Error(`${operator}.value must be of type string.`);
         }
         if (!type.isNone(params.index) && !type.isNumber(params.index)) {
-            throw new Error(`Operator Error: ${operator}.index must be of type number. Received: ${JSON.stringify(params)} at ${location}.`);
+            throw new Error(`${operator}.index must be of type number.`);
         }
     }
-    throw new Error(`Operator Error: ${operator} must be of type string, number or object. Received: ${JSON.stringify(params)} at ${location}.`);
+    throw new Error(`${operator} must be of type string, number or object.`);
 }
 export default getFromArray;

package/dist/getFromObject.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@ function getFromObject({ params, object, arrayIndices, operator, location }) {
         key: params
     };
     if (!type.isObject(params)) {
-        throw new Error(`Operator Error: ${operator} params must be of type string, integer, boolean or object. Received: ${JSON.stringify(params)} at ${location}.`);
+        throw new Error(`${operator} params must be of type string, integer, boolean or object.`);
     }
     if (params.key === null) return get(params, 'default', {
         default: null,
@@ -29,7 +29,7 @@ function getFromObject({ params, object, arrayIndices, operator, location }) {
     });
     if (params.all === true) return serializer.copy(object);
     if (!type.isString(params.key) && !type.isInt(params.key)) {
-        throw new Error(`Operator Error: ${operator}.key must be of type string or integer. Received: ${JSON.stringify(params)} at ${location}.`);
+        throw new Error(`${operator}.key must be of type string or integer.`);
     }
     return get(object, applyArrayIndices(arrayIndices, params.key), {
         default: get(params, 'default', {

package/dist/index.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.

package/dist/runClass.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -20,25 +20,18 @@ const runClass = ({ location, meta, methodName, operator, params, functions, def
         } else if (defaultFunction) {
             methodName = defaultFunction;
         } else {
-            throw new Error(`Operator Error: ${operator} requires a valid method name, use one of the following: ${Object.keys(meta).join(', ')}.
-        Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+            throw new Error(`${operator} requires a valid method name, use one of the following: ${Object.keys(meta).join(', ')}.`);
         }
     }
     if (!meta[methodName] && !functions[methodName]) {
-        throw new Error(`Operator Error: ${operator}.${methodName} is not supported, use one of the following: ${Object.keys(meta).join(', ')}.
-      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+        throw new Error(`${operator}.${methodName} is not supported, use one of the following: ${Object.keys(meta).join(', ')}.`);
     }
     // validate params type
     if (meta[methodName].validTypes && !meta[methodName].validTypes.includes(type.typeOf(params))) {
-        throw new Error(`Operator Error: ${operator}.${methodName} accepts one of the following types: ${meta[methodName].validTypes.join(', ')}.
-      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+        throw new Error(`${operator}.${methodName} accepts one of the following types: ${meta[methodName].validTypes.join(', ')}.`);
     }
     if (meta[methodName].noArgs) {
-        try {
-            return functions[methodName]();
-        } catch (e) {
-            throw new Error(`Operator Error: ${operator}: - ${e.message} Received: {"${operator}":${JSON.stringify(params)}} at ${location}.`);
-        }
+        return functions[methodName]();
     }
     let args = [];
     if (meta[methodName].singleArg || meta[methodName].property) {
@@ -52,8 +45,7 @@ const runClass = ({ location, meta, methodName, operator, params, functions, def
         if (type.isObject(params)) {
             args.push(...(meta[methodName].namedArgs || []).map((key)=>params[key]));
             if (!type.isNone(meta[methodName].spreadArgs) && !type.isArray(params[meta[methodName].spreadArgs])) {
-                throw new Error(`Operator Error: ${operator}.${methodName} takes an array as input argument for ${meta[methodName].spreadArgs}.
-          Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+                throw new Error(`${operator}.${methodName} takes an array as input argument for ${meta[methodName].spreadArgs}.`);
             }
             args.push(...params[meta[methodName].spreadArgs] || []);
         }
@@ -67,10 +59,6 @@ const runClass = ({ location, meta, methodName, operator, params, functions, def
     if (meta[methodName].property) {
         return functions[methodName];
     }
-    try {
-        return functions[methodName](...args);
-    } catch (e) {
-        throw new Error(`Operator Error: ${operator}.${methodName} - ${e.message} Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
-    }
+    return functions[methodName](...args);
 };
 export default runClass;

package/dist/runInstance.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -14,14 +14,15 @@
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
 const runInstance = ({ location, meta, methodName, operator, params, instanceType })=>{
+    if (type.isUndefined(methodName)) {
+        throw new Error(`${operator} requires a method. Use one of the following: ${Object.keys(meta).join(', ')}.`);
+    }
     if (!meta[methodName]) {
-        throw new Error(`Operator Error: ${operator}.${methodName} is not supported, use one of the following: ${Object.keys(meta).join(', ')}.
-      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+        throw new Error(`${operator}.${methodName} is not supported, use one of the following: ${Object.keys(meta).join(', ')}.`);
     }
     // validate params type
     if (meta[methodName].validTypes && !meta[methodName].validTypes.includes(type.typeOf(params))) {
-        throw new Error(`Operator Error: ${operator}.${methodName} accepts one of the following types: ${meta[methodName].validTypes.join(', ')}.
-      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+        throw new Error(`${operator}.${methodName} accepts one of the following types: ${meta[methodName].validTypes.join(', ')}.`);
     }
     let instance;
     let args = [];
@@ -38,8 +39,7 @@ const runInstance = ({ location, meta, methodName, operator, params, instanceTyp
             instance = params[meta[methodName].namedArgs[0]];
             args.push(...meta[methodName].namedArgs.slice(1).map((key)=>params[key]));
             if (!type.isNone(meta[methodName].spreadArgs) && !type.isArray(params[meta[methodName].spreadArgs])) {
-                throw new Error(`Operator Error: ${operator}.${methodName} takes an array as input argument for ${meta[methodName].spreadArgs}.
-          Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+                throw new Error(`${operator}.${methodName} takes an array as input argument for ${meta[methodName].spreadArgs}.`);
             }
             args.push(...params[meta[methodName].spreadArgs] || []);
         }
@@ -51,26 +51,20 @@ const runInstance = ({ location, meta, methodName, operator, params, instanceTyp
         ]);
     }
     if (type.typeOf(instance) !== instanceType) {
-        throw new Error(`Operator Error: ${operator}.${methodName} must be evaluated on an ${instanceType} instance. For named args provide an ${instanceType} instance to the "on" property, for listed args provide and ${instanceType} instance as the first element in the operator argument array.
-    Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+        throw new Error(`${operator}.${methodName} must be evaluated on an ${instanceType} instance. For named args provide an ${instanceType} instance to the "on" property, for listed args provide an ${instanceType} instance as the first element in the operator argument array.`);
     }
     // Error for invalid method key.
     if (type.isNone(instance[methodName])) {
-        throw new Error(`Operator Error: ${operator} must be evaluated using one of the following: ${Object.keys(meta).join(', ')}.
-      Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+        throw new Error(`${operator} must be evaluated using one of the following: ${Object.keys(meta).join(', ')}.`);
     }
     // for property
     if (meta[methodName].property) {
         return instance[methodName];
     }
-    try {
-        const result = instance[methodName](...args);
-        if (meta[methodName].returnInstance) {
-            return instance;
-        }
-        return result;
-    } catch (e) {
-        throw new Error(`Operator Error: ${operator}.${methodName} - ${e.message} Received: {"${operator}.${methodName}":${JSON.stringify(params)}} at ${location}.`);
+    const result = instance[methodName](...args);
+    if (meta[methodName].returnInstance) {
+        return instance;
     }
+    return result;
 };
 export default runInstance;

package/dist/serverParser.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -12,10 +12,9 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { serializer, type } from '@lowdefy/helpers';
+*/ import { ConfigError, OperatorError } from '@lowdefy/errors';
+import { serializer, type } from '@lowdefy/helpers';
 let ServerParser = class ServerParser {
-    // TODO: Look at logging here
-    // TODO: Remove console.error = () => {}; from tests
     parse({ args, input, items, location, operatorPrefix = '_' }) {
         if (type.isUndefined(input)) {
             return {
@@ -32,14 +31,13 @@ let ServerParser = class ServerParser {
         const errors = [];
         const reviver = (_, value)=>{
             if (!type.isObject(value)) return value;
-            // TODO: pass ~k in errors.
-            // const _k = value['~k'];
-            delete value['~k'];
             if (Object.keys(value).length !== 1) return value;
             const key = Object.keys(value)[0];
             if (!key.startsWith(operatorPrefix)) return value;
             const [op, methodName] = `_${key.substring(operatorPrefix.length)}`.split('.');
             if (type.isUndefined(this.operators[op])) return value;
+            const configKey = value['~k'];
+            const params = value[key];
             try {
                 const res = this.operators[op]({
                     args,
@@ -51,7 +49,7 @@ let ServerParser = class ServerParser {
                     methodName,
                     operatorPrefix,
                     operators: this.operators,
-                    params: value[key],
+                    params,
                     parser: this,
                     payload: this.payload,
                     runtime: 'node',
@@ -62,10 +60,24 @@ let ServerParser = class ServerParser {
                 });
                 return res;
             } catch (e) {
-                errors.push(e);
-                if (this.verbose) {
-                    console.error(e);
+                if (e instanceof ConfigError) {
+                    if (!e.configKey) {
+                        e.configKey = configKey;
+                    }
+                    errors.push(e);
+                    return null;
                 }
+                const operatorError = new OperatorError(e.message, {
+                    cause: e,
+                    typeName: op,
+                    methodName,
+                    received: {
+                        [key]: params
+                    },
+                    location,
+                    configKey: e.configKey ?? configKey
+                });
+                errors.push(operatorError);
                 return null;
             }
         };
@@ -76,7 +88,7 @@ let ServerParser = class ServerParser {
             errors
         };
     }
-    constructor({ env, jsMap, operators, payload, secrets, state, steps, user, verbose }){
+    constructor({ env, jsMap, operators, payload, secrets, state, steps, user }){
         this.env = env;
         this.jsMap = jsMap;
         this.operators = operators;
@@ -86,7 +98,6 @@ let ServerParser = class ServerParser {
         this.state = state;
         this.steps = steps;
         this.user = user;
-        this.verbose = verbose;
     }
 };
 export default ServerParser;

package/dist/webParser.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  Copyright 2020-2026 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -12,7 +12,8 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { applyArrayIndices, serializer, type } from '@lowdefy/helpers';
+*/ import { ConfigError, OperatorError } from '@lowdefy/errors';
+import { applyArrayIndices, serializer, type } from '@lowdefy/helpers';
 let WebParser = class WebParser {
     parse({ actions, args, arrayIndices, event, input, location, operatorPrefix = '_' }) {
         if (type.isUndefined(input)) {
@@ -34,14 +35,14 @@ let WebParser = class WebParser {
         const { apiResponses, basePath, home, inputs, lowdefyGlobal, menus, pageId, user, _internal } = this.context._internal.lowdefy;
         const reviver = (_, value)=>{
             if (!type.isObject(value)) return value;
-            // TODO: pass ~k in errors.
-            // const _k = value['~k'];
-            delete value['~k'];
             if (Object.keys(value).length !== 1) return value;
             const key = Object.keys(value)[0];
             if (!key.startsWith(operatorPrefix)) return value;
             const [op, methodName] = `_${key.substring(operatorPrefix.length)}`.split('.');
             if (type.isUndefined(this.operators[op])) return value;
+            const configKey = value['~k'];
+            const params = value[key];
+            const operatorLocation = applyArrayIndices(arrayIndices, location);
             try {
                 const res = this.operators[op]({
                     actions,
@@ -55,14 +56,14 @@ let WebParser = class WebParser {
                     home,
                     input: inputs[this.context.id],
                     jsMap: this.context.jsMap,
-                    location: applyArrayIndices(arrayIndices, location),
+                    location: operatorLocation,
                     lowdefyGlobal,
                     menus,
                     methodName,
                     operatorPrefix,
                     operators: this.operators,
                     pageId,
-                    params: value[key],
+                    params,
                     parser: this,
                     requests: this.context.requests,
                     runtime: 'browser',
@@ -71,8 +72,25 @@ let WebParser = class WebParser {
                 });
                 return res;
             } catch (e) {
-                errors.push(e);
-                console.error(e);
+                // ConfigError from plugin - add configKey and re-throw structure
+                if (e instanceof ConfigError) {
+                    if (!e.configKey) {
+                        e.configKey = configKey;
+                    }
+                    errors.push(e);
+                    return null;
+                }
+                // Plain error from plugin - wrap in OperatorError
+                errors.push(new OperatorError(e.message, {
+                    cause: e,
+                    typeName: op,
+                    methodName,
+                    received: {
+                        [key]: params
+                    },
+                    location: operatorLocation,
+                    configKey: e.configKey ?? configKey
+                }));
                 return null;
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/operators",
-  "version": "4.5.1",
+  "version": "4.6.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -34,7 +34,8 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/helpers": "4.5.1"
+    "@lowdefy/errors": "4.6.0",
+    "@lowdefy/helpers": "4.6.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",