@lowdefy/engine 6.0.0 → 6.1.0

package/dist/Actions.js

@@ -13,8 +13,9 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ActionError, ConfigError, UserError } from '@lowdefy/errors';
-import { type } from '@lowdefy/helpers';
+import { projectCaughtError, type } from '@lowdefy/helpers';
 import getActionMethods from './actions/getActionMethods.js';
+import { isDecodedServerError } from './decodeServerError.js';
 import { isStopChain } from './stopChain.js';
 const CONTROL_KEYS = [
     ':if',
@@ -27,24 +28,25 @@ function isControl(item) {
 let Actions = class Actions {
     logActionError({ error, action }) {
         const handleError = this.context._internal.lowdefy._internal.handleError;
-        const actionId = action?.id || '';
-        // Deduplicate by error message + action id
-        const errorKey = `${error?.message || ''}:${actionId}`;
-        if (this.loggedActionErrors.has(errorKey)) {
-            return;
-        }
-        this.loggedActionErrors.add(errorKey);
-        // User-facing errors log to browser console only, never to terminal
+        // User-facing errors log to browser console only, never to terminal. This line
+        // bypasses handleError, so it dedups here.
         if (error instanceof UserError) {
+            const errorKey = `${error.message}:${action?.id || ''}`;
+            if (this.loggedActionErrors.has(errorKey)) {
+                return;
+            }
+            this.loggedActionErrors.add(errorKey);
             this.context._internal.lowdefy._internal.logger.error(error);
             return;
         }
-        // Lowdefy errors - use handleError (-> terminal)
+        // Not deduped here: every server failure carries the same generic message, so a
+        // message + action key would hide each later failure of the action. handleError
+        // dedups on the message it displays plus the server's requestId.
         if (handleError) {
             handleError(error);
         }
     }
-    async callAsyncAction({ action, arrayIndices, block, event, index, responses }) {
+    async callAsyncAction({ action, arrayIndices, block, event, index, parseScope, responses }) {
         try {
             const response = await this.callAction({
                 action,
@@ -52,6 +54,7 @@ let Actions = class Actions {
                 block,
                 event,
                 index,
+                parseScope,
                 responses
             });
             responses[action.id] = response;
@@ -63,7 +66,7 @@ let Actions = class Actions {
     }
     // Returns true when a ':return' control or an action ended the list, so callers can
     // end the event.
-    async callActionLoop({ actions, arrayIndices, block, controls, counters, event, progress, responses }) {
+    async callActionLoop({ actions, arrayIndices, block, controls, counters, event, parseScope, progress, responses }) {
         for (const [position, action] of actions.entries()){
             if (isControl(action)) {
                 const returned = await this.callControl({
@@ -73,6 +76,7 @@ let Actions = class Actions {
                     controls,
                     counters,
                     event,
+                    parseScope,
                     progress,
                     responses
                 });
@@ -99,6 +103,7 @@ let Actions = class Actions {
                         block,
                         event,
                         index,
+                        parseScope,
                         progress,
                         responses
                     });
@@ -109,6 +114,7 @@ let Actions = class Actions {
                         block,
                         event,
                         index,
+                        parseScope,
                         progress,
                         responses
                     });
@@ -134,7 +140,7 @@ let Actions = class Actions {
         }
         return false;
     }
-    async callControl({ arrayIndices, block, control, controls, counters, event, progress, responses }) {
+    async callControl({ arrayIndices, block, control, controls, counters, event, parseScope, progress, responses }) {
         const index = counters.control;
         counters.control += 1;
         if (':return' in control) {
@@ -144,6 +150,7 @@ let Actions = class Actions {
                 event,
                 input: control[':return'],
                 node: control,
+                parseScope,
                 responses
             });
             controls.push({
@@ -160,6 +167,7 @@ let Actions = class Actions {
                 event,
                 input: control[':if'],
                 node: control,
+                parseScope,
                 responses
             });
             // JS truthiness, matching the routine ':if' - not skip's strict === true.
@@ -176,6 +184,7 @@ let Actions = class Actions {
                     controls,
                     counters,
                     event,
+                    parseScope,
                     progress,
                     responses
                 });
@@ -203,6 +212,7 @@ let Actions = class Actions {
                 controls,
                 counters,
                 event,
+                parseScope,
                 progress,
                 responses
             });
@@ -219,6 +229,7 @@ let Actions = class Actions {
                     event,
                     input: caseObject[':case'],
                     node: caseObject,
+                    parseScope,
                     responses
                 });
                 if (condition) {
@@ -235,6 +246,7 @@ let Actions = class Actions {
                         controls,
                         counters,
                         event,
+                        parseScope,
                         progress,
                         responses
                     });
@@ -267,12 +279,14 @@ let Actions = class Actions {
             controls,
             counters,
             event,
+            parseScope,
             progress,
             responses
         });
     }
-    evaluateControlValue({ arrayIndices, block, event, input, node, responses }) {
+    evaluateControlValue({ arrayIndices, block, event, input, node, parseScope, responses }) {
         const { output, errors: parserErrors } = this.context._internal.parser.parse({
+            ...parseScope,
             actions: responses,
             event,
             arrayIndices,
@@ -353,11 +367,21 @@ let Actions = class Actions {
                 controls,
                 counters,
                 event,
+                parseScope: {
+                    error: null
+                },
                 responses,
                 progress
             });
         } catch (error) {
             this.logActionError(error);
+            // A server error is already the wire shape, generic unless the author wrote
+            // it. A client-side error was built in the browser from data it already
+            // holds, so it keeps its real message - only its fields are narrowed.
+            const thrown = error.error;
+            const caught = isDecodedServerError(thrown) ? thrown : Object.assign(projectCaughtError(thrown), {
+                actionId: error.action?.id
+            });
             // Catch actions restart action numbering, matching flat-chain history; the control
             // counter continues so every control entry keeps a unique index within the event.
             counters.action = 0;
@@ -369,6 +393,9 @@ let Actions = class Actions {
                     controls,
                     counters,
                     event,
+                    parseScope: {
+                        error: caught
+                    },
                     responses,
                     progress
                 });
@@ -419,7 +446,7 @@ let Actions = class Actions {
             success: true
         };
     }
-    async callAction({ action, arrayIndices, block, event, index, progress, responses }) {
+    async callAction({ action, arrayIndices, block, event, index, parseScope, progress, responses }) {
         if (!this.actions[action.type]) {
             const error = new ConfigError(`Invalid action type "${action.type}" at "${block.blockId}".`, {
                 configKey: action['~k']
@@ -431,6 +458,7 @@ let Actions = class Actions {
             };
         }
         const { output: parsedAction, errors: parserErrors } = this.context._internal.parser.parse({
+            ...parseScope,
             actions: responses,
             event,
             arrayIndices,
@@ -491,6 +519,7 @@ let Actions = class Actions {
                 type: action.type
             };
             const { output: parsedMessages, errors: parserErrors } = this.context._internal.parser.parse({
+                ...parseScope,
                 actions: responses,
                 event,
                 arrayIndices,

package/dist/callAPIHandler.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer } from '@lowdefy/helpers';
+import decodeServerError from './decodeServerError.js';
 async function callAPIHandler(context, { blockId, params }) {
     if (!context._internal.lowdefy.apiResponses[params.endpointId]) {
         context._internal.lowdefy.apiResponses[params.endpointId] = [];
@@ -55,7 +56,10 @@ async function callAPIHandler(context, { blockId, params }) {
         throw error;
     }
     const { error, response, status, success } = apiResponse;
-    api.error = serializer.deserialize(error);
+    // Decoded once so the stored and the thrown error are the same object: the
+    // dev error is keyed by that object.
+    const decodedError = decodeServerError(error);
+    api.error = decodedError;
     api.loading = false;
     api.response = serializer.deserialize(response);
     api.status = status;
@@ -64,7 +68,7 @@ async function callAPIHandler(context, { blockId, params }) {
     api.responseTime = api.endTimestamp - api.startTimestamp;
     context._internal.update();
     if (!success) {
-        throw serializer.deserialize(error);
+        throw decodedError;
     }
     return api;
 }

package/dist/decodeServerError.js

@@ -0,0 +1,43 @@
+/*
+  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 { serializer, type } from '@lowdefy/helpers';
+// The decoded error is stored as `request.error` / `api.error` and rethrown,
+// and config reads it through `_actions`, `_request_details` and `_error`. Any
+// property on it - enumerable or not - is one operator change away from config,
+// so the dev server's full error is kept beside it here, keyed by the error
+// itself, where only the dev tools look.
+const devErrors = new WeakMap();
+// A catch list's `_error` passes a server error through as decoded, but
+// projects a client-side error. The two can share a name and class, so the
+// engine tells them apart by identity.
+const decoded = new WeakSet();
+function decodeServerError(payload) {
+    if (type.isNone(payload)) return payload;
+    const { devError, ...rest } = payload;
+    const error = serializer.deserialize(rest);
+    if (!type.isNone(devError)) {
+        devErrors.set(error, serializer.deserialize(devError));
+    }
+    decoded.add(error);
+    return error;
+}
+function getDevError(error) {
+    return devErrors.get(error);
+}
+function isDecodedServerError(error) {
+    return decoded.has(error);
+}
+export { getDevError, isDecodedServerError };
+export default decodeServerError;

package/dist/index.js

@@ -15,6 +15,7 @@
 */ import Actions from './Actions.js';
 import Slots from './Slots.js';
 import createLink from './createLink.js';
+import decodeServerError, { getDevError } from './decodeServerError.js';
 import Events from './Events.js';
 import getContext from './getContext.js';
 import getHomePathname from './getHomePathname.js';
@@ -22,5 +23,5 @@ import Requests from './Requests.js';
 import resolveTarget from './resolveTarget.js';
 import State from './State.js';
 import stopChain from './stopChain.js';
-export { Actions, Slots, createLink, Events, getHomePathname, Requests, resolveTarget, State, stopChain };
+export { Actions, Slots, createLink, decodeServerError, Events, getDevError, getHomePathname, Requests, resolveTarget, State, stopChain };
 export default getContext;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/engine",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -30,16 +30,16 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/errors": "6.0.0",
-    "@lowdefy/helpers": "6.0.0",
-    "@lowdefy/operators": "6.0.0"
+    "@lowdefy/errors": "6.1.0",
+    "@lowdefy/helpers": "6.1.0",
+    "@lowdefy/operators": "6.1.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/actions-core": "6.0.0",
-    "@lowdefy/build": "6.0.0",
-    "@lowdefy/operators-js": "6.0.0",
-    "@lowdefy/operators-mql": "6.0.0",
+    "@lowdefy/actions-core": "6.1.0",
+    "@lowdefy/build": "6.1.0",
+    "@lowdefy/operators-js": "6.1.0",
+    "@lowdefy/operators-mql": "6.1.0",
     "@swc/cli": "0.8.1",
     "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",