@lowdefy/operators 4.5.2 → 4.7.0

package/dist/evaluateOperators.js

@@ -0,0 +1,180 @@
+/*
+  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.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  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 { ConfigError, OperatorError } from '@lowdefy/errors';
+import { type } from '@lowdefy/helpers';
+function setDynamicMarker(node) {
+    if (type.isObject(node) || type.isArray(node)) {
+        Object.defineProperty(node, '~dyn', {
+            value: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return node;
+}
+function hasDynChild(node) {
+    if (type.isArray(node)) {
+        return node.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(node)) {
+        return Object.values(node).some((item)=>{
+            if (type.isArray(item) && item['~dyn'] === true) return true;
+            if (type.isObject(item) && item['~dyn'] === true) return true;
+            return false;
+        });
+    }
+    return false;
+}
+function hasDynamicMarker(value) {
+    if ((type.isArray(value) || type.isObject(value)) && value['~dyn'] === true) return true;
+    return hasDynChild(value);
+}
+function evaluateOperators({ input, operators, operatorPrefix = '_', env, dynamicIdentifiers, typeNames, args }) {
+    if (type.isUndefined(input)) {
+        return {
+            output: input,
+            errors: []
+        };
+    }
+    if (args && !type.isArray(args)) {
+        throw new Error('Operator parser args must be an array.');
+    }
+    const resolvedDynamicIdentifiers = dynamicIdentifiers ?? new Set();
+    const resolvedTypeNames = typeNames ?? new Set();
+    const errors = [];
+    const parser = {
+        parse: ({ args: callArgs, input: callInput, operatorPrefix: callPrefix })=>evaluateOperators({
+                input: callInput,
+                operators,
+                operatorPrefix: callPrefix ?? operatorPrefix,
+                env,
+                dynamicIdentifiers: resolvedDynamicIdentifiers,
+                typeNames: resolvedTypeNames,
+                args: callArgs
+            })
+    };
+    function walk(node) {
+        // Primitives pass through
+        if (!type.isObject(node) && !type.isArray(node)) return node;
+        // Arrays: walk children, then bubble up
+        if (type.isArray(node)) {
+            for(let i = 0; i < node.length; i++){
+                node[i] = walk(node[i]);
+            }
+            if (hasDynamicMarker(node)) {
+                return setDynamicMarker(node);
+            }
+            return node;
+        }
+        // Object handling
+        // Walk children in-place (bottom-up)
+        const keys = Object.keys(node);
+        for (const k of keys){
+            node[k] = walk(node[k]);
+        }
+        // Operator detection (before type boundary and bubble-up, to match BuildParser order)
+        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
+        const isTypeBoundary = type.isString(node.type) && resolvedTypeNames.has(node.type);
+        if (isTypeBoundary) {
+            delete node['~dyn'];
+        }
+        // Bubble up ~dyn from children (but not at type boundaries).
+        // _build.* operators always evaluate even with dynamic params, so skip bubble-up for them.
+        const isBuildOperator = isOperatorObject && operatorPrefix === '_build.';
+        if (!isTypeBoundary && !isBuildOperator && hasDynamicMarker(node)) {
+            return setDynamicMarker(node);
+        }
+        // Skip non-operator objects with ~r marker
+        if (type.isString(node['~r']) && !isOperatorObject) return node;
+        if (!isSingleKeyObject) return node;
+        if (!isOperatorObject) return node;
+        const [op, methodName] = `_${key.substring(operatorPrefix.length)}`.split('.');
+        // Dynamic identifier check — skip for _build.* operators
+        const fullIdentifier = methodName ? `${op}.${methodName}` : op;
+        if (operatorPrefix !== '_build.') {
+            if (resolvedDynamicIdentifiers.has(fullIdentifier) || resolvedDynamicIdentifiers.has(op)) {
+                return setDynamicMarker(node);
+            }
+        }
+        // Unknown operator — mark as dynamic
+        if (type.isUndefined(operators[op])) {
+            return setDynamicMarker(node);
+        }
+        // Dynamic params check — skip for _build.* operators (they always evaluate)
+        if (operatorPrefix !== '_build.') {
+            if (hasDynamicMarker(node[key])) {
+                return setDynamicMarker(node);
+            }
+        }
+        const configKey = node['~k'];
+        const lineNumber = node['~l'];
+        const refId = node['~r'];
+        const params = node[key];
+        try {
+            return operators[op]({
+                args,
+                arrayIndices: [],
+                env,
+                methodName,
+                operators,
+                params,
+                operatorPrefix,
+                parser,
+                runtime: 'node'
+            });
+        } catch (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
+            });
+            operatorError.lineNumber = lineNumber;
+            operatorError.refId = refId;
+            errors.push(operatorError);
+            return null;
+        }
+    }
+    const output = walk(input);
+    return {
+        output,
+        errors
+    };
+}
+export default evaluateOperators;
+export { hasDynamicMarker, hasDynChild };

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.
@@ -12,11 +12,11 @@
   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 BuildParser from './buildParser.js';
+*/ import evaluateOperators, { hasDynamicMarker, hasDynChild } from './evaluateOperators.js';
 import getFromArray from './getFromArray.js';
 import getFromObject from './getFromObject.js';
 import ServerParser from './serverParser.js';
 import runClass from './runClass.js';
 import runInstance from './runInstance.js';
 import WebParser from './webParser.js';
-export { BuildParser, getFromArray, getFromObject, ServerParser, runClass, runInstance, WebParser };
+export { evaluateOperators, hasDynamicMarker, hasDynChild, getFromArray, getFromObject, ServerParser, runClass, runInstance, WebParser };

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.2",
+  "version": "4.7.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -34,7 +34,8 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/helpers": "4.5.2"
+    "@lowdefy/errors": "4.7.0",
+    "@lowdefy/helpers": "4.7.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",

package/dist/buildParser.js

@@ -1,84 +0,0 @@
-/*
-  Copyright 2020-2024 Lowdefy, Inc
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  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';
-let BuildParser = class BuildParser {
-    // TODO: Look at logging here
-    // TODO: Remove console.error = () => {}; from tests
-    parse({ args, input, location, operatorPrefix = '_' }) {
-        if (type.isUndefined(input)) {
-            return {
-                output: input,
-                errors: []
-            };
-        }
-        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)=>{
-            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;
-            const [op, methodName] = `_${key.substring(operatorPrefix.length)}`.split('.');
-            if (type.isUndefined(this.operators[op])) return value;
-            try {
-                const res = this.operators[op]({
-                    args,
-                    arrayIndices: [],
-                    env: this.env,
-                    location,
-                    methodName,
-                    operators: this.operators,
-                    params: value[key],
-                    operatorPrefix,
-                    parser: this,
-                    payload: this.payload,
-                    runtime: 'node',
-                    secrets: this.secrets,
-                    user: this.user
-                });
-                return res;
-            } catch (e) {
-                errors.push(e);
-                if (this.verbose) {
-                    console.error(e);
-                }
-                return null;
-            }
-        };
-        return {
-            output: serializer.copy(input, {
-                reviver
-            }),
-            errors
-        };
-    }
-    constructor({ env, payload, secrets, user, operators, verbose }){
-        this.env = env;
-        this.operators = operators;
-        this.parse = this.parse.bind(this);
-        this.payload = payload;
-        this.secrets = secrets;
-        this.user = user;
-        this.verbose = verbose;
-    }
-};
-export default BuildParser;