@lowdefy/api 4.4.0 → 4.5.1

package/dist/routes/endpoints/runRoutine.js

@@ -0,0 +1,60 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+import handleRequest from './handleRequest.js';
+import handleControl from './control/handleControl.js';
+async function runRoutine(context, routineContext, { routine }) {
+    try {
+        if (type.isObject(routine)) {
+            if (routine.id?.startsWith?.('request:')) {
+                return await handleRequest(context, routineContext, {
+                    request: routine
+                });
+            }
+            return await handleControl(context, routineContext, {
+                control: routine
+            });
+        }
+        if (type.isArray(routine)) {
+            for (const item of routine){
+                const res = await runRoutine(context, routineContext, {
+                    routine: item
+                });
+                if ([
+                    'return',
+                    'error',
+                    'reject'
+                ].includes(res.status)) {
+                    return res;
+                }
+            }
+            return {
+                status: 'continue'
+            };
+        }
+        throw new Error('Invalid routine.', {
+            cause: {
+                routine
+            }
+        });
+    } catch (error) {
+        context.logger.error(error);
+        return {
+            status: 'error',
+            error
+        };
+    }
+}
+export default runRoutine;

package/dist/routes/endpoints/test/runTest.js

@@ -0,0 +1,107 @@
+import { jest } from '@jest/globals';
+import { wait } from '@lowdefy/helpers';
+import { operatorsServer } from '@lowdefy/operators-js';
+import createEvaluateOperators from '../../../context/createEvaluateOperators.js';
+import runRoutine from '../runRoutine.js';
+import testContext from '../../../test/testContext.js';
+// const { _date, _eq, _payload, _secret, _user } = operatorsServer;
+const operators = {
+    ...operatorsServer,
+    _error: ()=>{
+        throw new Error('Test error.');
+    }
+};
+const secrets = {
+    CONNECTION: 'connectionSecret',
+    REQUEST: 'requestSecret'
+};
+const defaultReadConfigImp = ({ connectionConfig = {
+    id: 'connection:test',
+    type: 'TestConnection',
+    connectionId: 'test'
+} } = {})=>(path)=>{
+        if (path === 'connections/test.json') {
+            return connectionConfig;
+        }
+        return null;
+    };
+const mockReadConfigFile = jest.fn().mockImplementation(defaultReadConfigImp());
+const mockTestRequest = jest.fn((request)=>{
+    return request.request.response;
+});
+const mockTestRequestError = jest.fn((request)=>{
+    throw new Error(request.request.message);
+});
+const mockTestRequestWait = jest.fn((request)=>wait(request.request.ms));
+mockTestRequest.schema = {};
+mockTestRequestError.schema = {};
+mockTestRequestWait.schema = {};
+mockTestRequest.meta = {
+    checkRead: false,
+    checkWrite: false
+};
+mockTestRequestError.meta = {
+    checkRead: false,
+    checkWrite: false
+};
+mockTestRequestWait.meta = {
+    checkRead: false,
+    checkWrite: false
+};
+const connections = {
+    TestConnection: {
+        schema: {},
+        requests: {
+            TestRequest: mockTestRequest,
+            TestRequestError: mockTestRequestError,
+            TestRequestWait: mockTestRequestWait
+        }
+    }
+};
+const logger = {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    // error: console.error,
+    error: jest.fn()
+};
+function createTextContext({ payload }) {
+    const context = testContext({
+        connections,
+        operators,
+        logger,
+        readConfigFile: mockReadConfigFile,
+        secrets,
+        session: {
+            user: {
+                id: 'id'
+            }
+        }
+    });
+    context.payload = payload;
+    context.steps = {};
+    context.blockId = 'blockId';
+    context.pageId = 'pageId';
+    context.endpointId = 'endpointId';
+    context.evaluateOperators = createEvaluateOperators(context, {
+        payload
+    });
+    return context;
+}
+async function runTest({ routine, payload = {} }) {
+    const context = createTextContext({
+        payload
+    });
+    const routineContext = {
+        items: {},
+        arrayIndices: []
+    };
+    const res = await runRoutine(context, routineContext, {
+        routine
+    });
+    return {
+        res,
+        context
+    };
+}
+export default runTest;

package/dist/routes/request/callRequest.js

@@ -23,8 +23,13 @@ import getConnectionConfig from './getConnectionConfig.js';
 import getRequestConfig from './getRequestConfig.js';
 import getRequestResolver from './getRequestResolver.js';
 import validateSchemas from './validateSchemas.js';
+import createEvaluateOperators from '../../context/createEvaluateOperators.js';
 async function callRequest(context, { blockId, pageId, payload, requestId }) {
     const { logger } = context;
+    context.blockId = blockId;
+    context.pageId = pageId;
+    context.payload = serializer.deserialize(payload);
+    context.evaluateOperators = createEvaluateOperators(context);
     logger.debug({
         event: 'debug_request',
         blockId,
@@ -49,10 +54,8 @@ async function callRequest(context, { blockId, pageId, payload, requestId }) {
         connection,
         requestConfig
     });
-    const deserializedPayload = serializer.deserialize(payload);
     const { connectionProperties, requestProperties } = evaluateOperators(context, {
         connectionConfig,
-        payload: deserializedPayload,
         requestConfig
     });
     checkConnectionRead(context, {
@@ -75,9 +78,7 @@ async function callRequest(context, { blockId, pageId, payload, requestId }) {
         requestProperties
     });
     const response = await callRequestResolver(context, {
-        blockId,
         connectionProperties,
-        payload: deserializedPayload,
         requestConfig,
         requestProperties,
         requestResolver

package/dist/routes/request/callRequestResolver.js

@@ -13,13 +13,14 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { RequestError } from '../../context/errors.js';
-async function callRequestResolver({ logger }, { blockId, connectionProperties, payload, requestConfig, requestProperties, requestResolver }) {
+async function callRequestResolver({ blockId, endpointId, logger, pageId, payload }, { connectionProperties, requestConfig, requestProperties, requestResolver }) {
     try {
         const response = await requestResolver({
             blockId,
+            endpointId,
             connection: connectionProperties,
             connectionId: requestConfig.connectionId,
-            pageId: requestConfig.pageId,
+            pageId,
             payload,
             request: requestProperties,
             requestId: requestConfig.requestId

package/dist/routes/request/evaluateOperators.js

@@ -12,30 +12,16 @@
   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 { ServerParser } from '@lowdefy/operators';
-import { RequestError } from '../../context/errors.js';
-function evaluateOperators({ jsMap, operators, secrets, session }, { connectionConfig, payload, requestConfig }) {
-    const operatorsParser = new ServerParser({
-        jsMap,
-        operators,
-        payload,
-        secrets,
-        user: session?.user
-    });
-    const { output: connectionProperties, errors: connectionErrors } = operatorsParser.parse({
+*/ function evaluateOperators({ evaluateOperators }, { connectionConfig, items, requestConfig }) {
+    const connectionProperties = evaluateOperators({
         input: connectionConfig.properties || {},
         location: connectionConfig.connectionId
     });
-    if (connectionErrors.length > 0) {
-        throw new RequestError(connectionErrors[0]);
-    }
-    const { output: requestProperties, errors: requestErrors } = operatorsParser.parse({
+    const requestProperties = evaluateOperators({
         input: requestConfig.properties || {},
+        items,
         location: requestConfig.requestId
     });
-    if (requestErrors.length > 0) {
-        throw new RequestError(requestErrors[0]);
-    }
     return {
         connectionProperties,
         requestProperties

package/dist/test/testContext.js

@@ -32,7 +32,10 @@ function testContext({ config = {}, connections = {}, headers = {}, logger = {
         operators,
         readConfigFile,
         secrets,
-        session
+        session,
+        state: {},
+        steps: {},
+        user: session?.user
     };
 }
 export default testContext;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/api",
-  "version": "4.4.0",
+  "version": "4.5.1",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -34,12 +34,12 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/ajv": "4.4.0",
-    "@lowdefy/helpers": "4.4.0",
-    "@lowdefy/node-utils": "4.4.0",
-    "@lowdefy/nunjucks": "4.4.0",
-    "@lowdefy/operators": "4.4.0",
-    "@lowdefy/operators-js": "4.4.0"
+    "@lowdefy/ajv": "4.5.1",
+    "@lowdefy/helpers": "4.5.1",
+    "@lowdefy/node-utils": "4.5.1",
+    "@lowdefy/nunjucks": "4.5.1",
+    "@lowdefy/operators": "4.5.1",
+    "@lowdefy/operators-js": "4.5.1"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",