@lowdefy/operators-js 5.5.1 → 6.0.0

package/dist/operators/build/env.js

@@ -22,5 +22,5 @@ function _env({ arrayIndices, env, location, params }) {
         params
     });
 }
-_env.dynamic = false;
+_env.dynamic = true;
 export default _env;

package/dist/operators/client/api.js

@@ -12,7 +12,7 @@
   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 { get, type } from '@lowdefy/helpers';
+*/ import { ReservedKeyError, get, type } from '@lowdefy/helpers';
 function _api({ params, apiResponses }) {
     if (!type.isString(params)) {
         throw new Error(`_api accepts a string value.`);
@@ -25,10 +25,18 @@ function _api({ params, apiResponses }) {
             return entry;
         }
         const key = keyParts.join('.');
-        return get(entry, key, {
-            copy: true,
-            default: null
-        });
+        try {
+            return get(entry, key, {
+                copy: true,
+                default: null
+            });
+        } catch (error) {
+            // A runtime read: the key comes from app data or an author keypath evaluated at render time,
+            // and there is no config location to attach in the browser. The reserved rule's job — refusing
+            // the read — is already done, so degrade to the miss value rather than crashing the page.
+            if (error instanceof ReservedKeyError) return null;
+            throw error;
+        }
     }
     return null;
 }

package/dist/operators/client/request.js

@@ -12,7 +12,7 @@
   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, get, serializer, type } from '@lowdefy/helpers';
+*/ import { ReservedKeyError, applyArrayIndices, get, serializer, type } from '@lowdefy/helpers';
 function _request({ arrayIndices, params, requests }) {
     if (!type.isString(params)) {
         throw new Error(`_request accepts a string value.`);
@@ -25,10 +25,18 @@ function _request({ arrayIndices, params, requests }) {
             return serializer.copy(entry.response);
         }
         const key = keyParts.reduce((acc, value)=>acc === '' ? value : acc.concat('.', value), '');
-        return get(entry.response, applyArrayIndices(arrayIndices, key), {
-            copy: true,
-            default: null
-        });
+        try {
+            return get(entry.response, applyArrayIndices(arrayIndices, key), {
+                copy: true,
+                default: null
+            });
+        } catch (error) {
+            // A runtime read: the key comes from app data or an author keypath evaluated at render time,
+            // and there is no config location to attach in the browser. The reserved rule's job — refusing
+            // the read — is already done, so degrade to the miss value rather than crashing the page.
+            if (error instanceof ReservedKeyError) return null;
+            throw error;
+        }
     }
     return null;
 }

package/dist/operators/client/websocket.js

@@ -0,0 +1,47 @@
+/*
+  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 { ReservedKeyError, applyArrayIndices, get, type } from '@lowdefy/helpers';
+function _websocket({ arrayIndices, params, websockets }) {
+    if (!type.isString(params)) {
+        throw new Error(`_websocket accepts a string value.`);
+    }
+    if (type.isNone(websockets)) {
+        return null;
+    }
+    const splitKey = params.split('.');
+    const [websocketId, ...keyParts] = splitKey;
+    const channel = websockets[websocketId];
+    if (type.isNone(channel)) {
+        return null;
+    }
+    if (splitKey.length === 1) {
+        return channel;
+    }
+    const key = keyParts.reduce((acc, value)=>acc === '' ? value : acc.concat('.', value), '');
+    try {
+        return get(channel, applyArrayIndices(arrayIndices, key), {
+            copy: true,
+            default: null
+        });
+    } catch (error) {
+        // A runtime read: the key comes from app data or an author keypath evaluated at render time,
+        // and there is no config location to attach in the browser. The reserved rule's job — refusing
+        // the read — is already done, so degrade to the miss value rather than crashing the page.
+        if (error instanceof ReservedKeyError) return null;
+        throw error;
+    }
+}
+_websocket.dynamic = true;
+export default _websocket;

package/dist/operators/shared/app.js

@@ -13,14 +13,24 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { getFromObject } from '@lowdefy/operators';
+import { ConfigError } from '@lowdefy/errors';
+import { type } from '@lowdefy/helpers';
 function _app({ arrayIndices, location, lowdefyApp, params }) {
-    return getFromObject({
+    const value = getFromObject({
         arrayIndices,
         location,
         object: lowdefyApp,
         operator: '_app',
         params
     });
+    if (params === 'slug' && type.isNone(value)) {
+        throw new ConfigError('`slug` is required on the app but is not set. Declare `slug` in `lowdefy.yaml`.', {
+            received: {
+                slug: value
+            }
+        });
+    }
+    return value;
 }
-_app.dynamic = true;
+_app.dynamic = false;
 export default _app;

package/dist/operators/shared/regex.js

@@ -12,18 +12,36 @@
   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 { get, type } from '@lowdefy/helpers';
+*/ import { ReservedKeyError, get, type } from '@lowdefy/helpers';
 function _regex({ location, params, state }) {
     const pattern = type.isObject(params) ? params.pattern : params;
     if (!type.isString(pattern)) {
         throw new Error(`_regex.pattern must be a string.`);
     }
-    let on = !type.isUndefined(params.on) ? params.on : get(state, location);
+    let on = params.on;
+    if (type.isUndefined(on)) {
+        try {
+            on = get(state, location);
+        } catch (error) {
+            // A runtime read: the key comes from app data or an author keypath evaluated at render time,
+            // and there is no config location to attach in the browser. The reserved rule's job — refusing
+            // the read — is already done, so degrade to the miss value rather than crashing the page.
+            if (!(error instanceof ReservedKeyError)) throw error;
+        }
+    }
     if (!type.isUndefined(params.key)) {
         if (!type.isString(params.key)) {
             throw new Error(`_regex.key must be a string.`);
         }
-        on = get(state, params.key);
+        try {
+            on = get(state, params.key);
+        } catch (error) {
+            // A runtime read: the key comes from app data or an author keypath evaluated at render time,
+            // and there is no config location to attach in the browser. The reserved rule's job — refusing
+            // the read — is already done, so degrade to the miss value rather than crashing the page.
+            if (!(error instanceof ReservedKeyError)) throw error;
+            on = undefined;
+        }
     }
     if (type.isNone(on)) {
         return false;

package/dist/operators/shared/type.js

@@ -12,15 +12,27 @@
   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 { get, type } from '@lowdefy/helpers';
+*/ import { ReservedKeyError, get, type } from '@lowdefy/helpers';
 function _type({ location, params, state }) {
     const typeName = type.isObject(params) ? params.type : params;
     if (!type.isString(typeName)) {
         throw new Error(`_type.type must be a string.`);
     }
-    const on = Object.prototype.hasOwnProperty.call(params, 'on') ? params.on : get(state, get(params, 'key', {
-        default: location
-    }));
+    let on;
+    if (Object.prototype.hasOwnProperty.call(params, 'on')) {
+        on = params.on;
+    } else {
+        try {
+            on = get(state, get(params, 'key', {
+                default: location
+            }));
+        } catch (error) {
+            // A runtime read: the key comes from app data or an author keypath evaluated at render time,
+            // and there is no config location to attach in the browser. The reserved rule's job — refusing
+            // the read — is already done, so degrade to the miss value rather than crashing the page.
+            if (!(error instanceof ReservedKeyError)) throw error;
+        }
+    }
     switch(typeName){
         case 'string':
             return type.isString(on);

package/dist/operatorsBuild.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import _and from './operators/shared/and.js';
+import _app from './operators/shared/app.js';
 import _args from './operators/shared/args.js';
 import _array from './operators/shared/array.js';
 import _boolean from './operators/shared/boolean.js';
@@ -51,6 +52,7 @@ import _hash from './operators/server/hash.js';
 import _env from './operators/build/env.js';
 export default {
     _and,
+    _app,
     _args,
     _array,
     _base64,

package/dist/operatorsClient.js

@@ -67,3 +67,4 @@ export { default as _request_details } from './operators/client/request_details.
 export { default as _request } from './operators/client/request.js';
 export { default as _theme } from './operators/client/theme.js';
 export { default as _url_query } from './operators/client/url_query.js';
+export { default as _websocket } from './operators/client/websocket.js';

package/dist/types.js

@@ -69,7 +69,8 @@
             '_type',
             '_uri',
             '_url_query',
-            '_user'
+            '_user',
+            '_websocket'
         ],
         server: [
             '_and',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/operators-js",
-  "version": "5.5.1",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -43,15 +43,16 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/helpers": "5.5.1",
-    "@lowdefy/operators": "5.5.1",
+    "@lowdefy/errors": "6.0.0",
+    "@lowdefy/helpers": "6.0.0",
+    "@lowdefy/operators": "6.0.0",
     "intl-messageformat": "11.2.7"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/node-utils": "5.5.1",
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@lowdefy/node-utils": "6.0.0",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",
     "jest": "28.1.3",
     "jest-environment-jsdom": "28.1.3"