@lowdefy/api 5.5.1 → 6.0.0

package/dist/routes/websocket/createWebSocketConnection.js

@@ -0,0 +1,131 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+// Wraps one client websocket connection: parses frames, dispatches
+// subscribe/unsubscribe/publish to the channel registry, and answers every
+// frame with an ack or an error so client actions never hang.
+function createWebSocketConnection(context, { registry, send }) {
+    const { logger } = context;
+    const subscriber = {
+        id: context.rid,
+        subscriptions: new Map(),
+        send
+    };
+    function sendError({ message, requestId, websocketId }) {
+        send(JSON.stringify({
+            type: 'error',
+            websocketId,
+            requestId,
+            message
+        }));
+    }
+    async function handleFrame(frame) {
+        const { payload, requestId, websocketId } = frame;
+        if (!type.isString(websocketId)) {
+            sendError({
+                message: 'Frame "websocketId" should be a string.',
+                requestId
+            });
+            return;
+        }
+        switch(frame.type){
+            case 'subscribe':
+                await registry.subscribe(context, {
+                    websocketId,
+                    payload,
+                    subscriber
+                });
+                send(JSON.stringify({
+                    type: 'subscribed',
+                    websocketId
+                }));
+                return;
+            case 'unsubscribe':
+                registry.unsubscribe({
+                    websocketId,
+                    subscriber
+                });
+                send(JSON.stringify({
+                    type: 'unsubscribed',
+                    websocketId
+                }));
+                return;
+            case 'publish':
+                await registry.publish(context, {
+                    websocketId,
+                    payload
+                });
+                send(JSON.stringify({
+                    type: 'published',
+                    websocketId,
+                    requestId
+                }));
+                return;
+            default:
+                // Unknown frame types are ignored for forward compatibility.
+                logger.debug({
+                    event: 'ws_unknown_frame',
+                    frameType: frame.type
+                });
+        }
+    }
+    async function handleMessage(raw) {
+        let frame;
+        try {
+            frame = JSON.parse(raw);
+        } catch (error) {
+            sendError({
+                message: 'Invalid frame — expected JSON.'
+            });
+            return;
+        }
+        if (!type.isObject(frame)) {
+            sendError({
+                message: 'Invalid frame — expected an object.'
+            });
+            return;
+        }
+        try {
+            await handleFrame(frame);
+        } catch (error) {
+            logger.debug({
+                err: error
+            }, error.message);
+            context.handleError(error);
+            sendError({
+                message: error.message,
+                requestId: frame.requestId,
+                websocketId: frame.websocketId
+            });
+        }
+    }
+    function close() {
+        registry.unsubscribeAll({
+            subscriber
+        });
+        logger.debug({
+            event: 'ws_disconnect'
+        });
+    }
+    logger.debug({
+        event: 'ws_connect'
+    });
+    return {
+        close,
+        handleMessage,
+        subscriber
+    };
+}
+export default createWebSocketConnection;

package/dist/routes/websocket/getWebsocketConfig.js

@@ -0,0 +1,30 @@
+/*
+  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 } from '@lowdefy/errors';
+async function getWebsocketConfig({ logger, readConfigFile }, { websocketId }) {
+    const websocketConfig = await readConfigFile(`websockets/${websocketId}.json`);
+    if (!websocketConfig) {
+        const err = new ConfigError(`Websocket "${websocketId}" does not exist.`);
+        logger.debug({
+            params: {
+                websocketId
+            },
+            err
+        }, err.message);
+        throw err;
+    }
+    return websocketConfig;
+}
+export default getWebsocketConfig;

package/dist/routes/websocket/getWebsocketResolver.js

@@ -0,0 +1,33 @@
+/*
+  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 } from '@lowdefy/errors';
+function getWebsocketResolver({ logger, websockets }, { websocketConfig }) {
+    const websocketResolver = (websockets ?? {})[websocketConfig.type];
+    if (!websocketResolver) {
+        const err = new ConfigError(`Websocket type "${websocketConfig.type}" can not be found.`, {
+            configKey: websocketConfig['~k']
+        });
+        logger.debug({
+            params: {
+                id: websocketConfig.websocketId,
+                type: websocketConfig.type
+            },
+            err
+        }, err.message);
+        throw err;
+    }
+    return websocketResolver;
+}
+export default getWebsocketResolver;

package/dist/routes/websocket/prepareChannel.js

@@ -0,0 +1,72 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import authorizeWebsocket from './authorizeWebsocket.js';
+import getConnection from '../connections/getConnection.js';
+import getConnectionConfig from '../connections/getConnectionConfig.js';
+import getWebsocketConfig from './getWebsocketConfig.js';
+import getWebsocketResolver from './getWebsocketResolver.js';
+import createEvaluateOperators from '../../context/createEvaluateOperators.js';
+// Shared preparation for subscribe and publish frames: load config, authorize,
+// resolve the websocket type, and evaluate server operators per subscription.
+// Properties are evaluated with the subscriber's payload and user, so the same
+// websocket definition can produce user- or filter-specific channels. The
+// evaluated result is the channel identity — subscribers whose evaluation is
+// identical share one running source.
+async function prepareChannel(context, { websocketId, payload }) {
+    context.evaluateOperators = createEvaluateOperators(context);
+    const websocketConfig = await getWebsocketConfig(context, {
+        websocketId
+    });
+    authorizeWebsocket(context, {
+        websocketConfig
+    });
+    const websocketResolver = getWebsocketResolver(context, {
+        websocketConfig
+    });
+    let connectionProperties = null;
+    if (!type.isNone(websocketConfig.connectionId)) {
+        const connectionConfig = await getConnectionConfig(context, {
+            connectionId: websocketConfig.connectionId,
+            configKey: websocketConfig['~k']
+        });
+        // Validates the connection type exists — resolver lookup is on the
+        // websocket type itself, not nested on the connection.
+        getConnection(context, {
+            connectionConfig
+        });
+        connectionProperties = context.evaluateOperators({
+            input: connectionConfig.properties ?? {},
+            location: connectionConfig.connectionId,
+            payload,
+            state: {},
+            steps: {}
+        });
+    }
+    const properties = context.evaluateOperators({
+        input: websocketConfig.properties ?? {},
+        location: websocketConfig.websocketId,
+        payload,
+        state: {},
+        steps: {}
+    });
+    return {
+        connectionProperties,
+        properties,
+        websocketConfig,
+        websocketResolver
+    };
+}
+export default prepareChannel;

package/dist/test/testContext.js

@@ -13,23 +13,29 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import createAuthorize from '../context/createAuthorize.js';
-function testContext({ appMeta = {}, config = {}, connections = {}, headers = {}, logger = {
+function testContext({ appMeta = {}, config = {}, configDirectory, connections = {}, headers = {}, logger = {
     debug: ()=>{},
     error: ()=>{},
     info: ()=>{},
     warn: ()=>{}
 }, operators = {
     _test: ()=>'test'
-}, readConfigFile, secrets = {}, session } = {}) {
+}, readConfigFile, secrets = {}, session, system } = {}) {
     return {
         appMeta,
         authorize: createAuthorize({
-            session
+            session,
+            system
         }),
         config,
+        configDirectory,
         connections,
+        // Mirrors the servers' createHandleError contract: the sink logs the error
+        // and marks it handled, which is what runRoutine's guard and the client's
+        // already-logged check both read.
         handleError: async (error)=>{
             logger.error(error);
+            error.handled = true;
         },
         headers,
         logger,
@@ -38,6 +44,7 @@ function testContext({ appMeta = {}, config = {}, connections = {}, headers = {}
         secrets,
         session,
         steps: {},
+        system,
         user: session?.user
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/api",
-  "version": "5.5.1",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -34,18 +34,20 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/ajv": "5.5.1",
-    "@lowdefy/errors": "5.5.1",
-    "@lowdefy/helpers": "5.5.1",
-    "@lowdefy/node-utils": "5.5.1",
-    "@lowdefy/nunjucks": "5.5.1",
-    "@lowdefy/operators": "5.5.1",
-    "@lowdefy/operators-js": "5.5.1"
+    "@lowdefy/ajv": "6.0.0",
+    "@lowdefy/build": "6.0.0",
+    "@lowdefy/errors": "6.0.0",
+    "@lowdefy/helpers": "6.0.0",
+    "@lowdefy/node-utils": "6.0.0",
+    "@lowdefy/nunjucks": "6.0.0",
+    "@lowdefy/operators": "6.0.0",
+    "@lowdefy/operators-js": "6.0.0",
+    "@modelcontextprotocol/sdk": "1.29.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",
     "jest": "28.1.3"
   },