@lowdefy/api 4.3.2 → 4.5.0

package/dist/routes/endpoints/control/controlIf.js

@@ -0,0 +1,53 @@
+/*
+  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 runRoutine from '../runRoutine.js';
+async function controlIf(context, routineContext, { control }) {
+    const { logger, evaluateOperators } = context;
+    const { items } = routineContext;
+    const evaluatedIf = evaluateOperators({
+        input: control[':if'],
+        items,
+        location: 'TODO:'
+    });
+    logger.debug({
+        event: 'debug_control_if',
+        condition: {
+            input: control[':if'],
+            evaluated: evaluatedIf
+        }
+    });
+    if (evaluatedIf) {
+        logger.debug({
+            event: 'debug_control_if_run_then'
+        });
+        if (!control[':then']) {
+            throw new Error('Invalid :if - missing :then.');
+        }
+        return runRoutine(context, routineContext, {
+            routine: control[':then']
+        });
+    } else if (control[':else']) {
+        logger.debug({
+            event: 'debug_control_if_run_else'
+        });
+        return runRoutine(context, routineContext, {
+            routine: control[':else']
+        });
+    }
+    return {
+        status: 'continue'
+    };
+}
+export default controlIf;

package/dist/routes/endpoints/control/controlLog.js

@@ -0,0 +1,43 @@
+/*
+  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';
+async function controlLog(context, routineContext, { control }) {
+    const { logger, evaluateOperators } = context;
+    const { items } = routineContext;
+    logger.debug({
+        event: 'debug_control_log'
+    });
+    const log = evaluateOperators({
+        input: control[':log'],
+        items,
+        location: 'TODO:'
+    });
+    const logLevel = evaluateOperators({
+        input: control[':level'],
+        items,
+        location: 'TODO:'
+    }) ?? 'info';
+    if (!type.isString(logLevel)) {
+        throw new Error(`Unrecognised type for :level. Received ${logLevel}.`);
+    }
+    if (!logger[logLevel]) {
+        throw new Error(`Invalid log level for :log. Received ${logLevel}.`);
+    }
+    logger[logLevel](log);
+    return {
+        status: 'continue'
+    };
+}
+export default controlLog;

package/dist/routes/endpoints/control/controlParallel.js

@@ -0,0 +1,44 @@
+/*
+  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 runRoutine from '../runRoutine.js';
+async function controlParallel(context, routineContext, { control }) {
+    const { logger } = context;
+    logger.debug({
+        event: 'debug_control_parallel'
+    });
+    const results = await Promise.all(control[':parallel'].map((subRoutine)=>{
+        logger.debug({
+            event: 'debug_control_parallel_start',
+            start: Date.now()
+        });
+        return runRoutine(context, routineContext, {
+            routine: subRoutine
+        });
+    }));
+    const resultsMap = {
+        error: [],
+        reject: [],
+        return: [],
+        continue: []
+    };
+    results.forEach((res)=>resultsMap[res.status] = [
+            ...resultsMap[res.status],
+            res
+        ]);
+    return resultsMap.error?.[0] ?? resultsMap.reject?.[0] ?? resultsMap.return?.[0] ?? {
+        status: 'continue'
+    };
+}
+export default controlParallel;

package/dist/routes/endpoints/control/controlParallelFor.js

@@ -0,0 +1,76 @@
+/*
+  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 runRoutine from '../runRoutine.js';
+async function controlParallelFor(context, routineContext, { control }) {
+    const { logger, evaluateOperators } = context;
+    const { items } = routineContext;
+    const itemName = control[':parallel_for'];
+    if (!itemName) {
+        throw new Error('Invalid :parallel_for - missing variable name in :parallel_for.');
+    }
+    const array = evaluateOperators({
+        input: control[':in'],
+        items,
+        location: 'controlParallelFor'
+    });
+    logger.debug({
+        event: 'debug_control_parallel',
+        array,
+        itemName
+    });
+    if (!Array.isArray(array)) {
+        throw new Error('Invalid :parallel_for - evaluated :in to non-array.');
+    }
+    if (!control[':do']) {
+        throw new Error('Invalid :parallel_for - missing :do.');
+    }
+    const promises = array.map((item, index)=>{
+        const updatedItems = {
+            ...items,
+            [itemName]: item
+        };
+        logger.debug({
+            event: 'debug_control_parallel_iteration',
+            itemName: itemName,
+            value: item,
+            items: updatedItems
+        });
+        return runRoutine(context, {
+            ...routineContext,
+            arrayIndices: [
+                ...routineContext.arrayIndices,
+                index
+            ],
+            items: updatedItems
+        }, {
+            routine: control[':do']
+        });
+    });
+    const results = await Promise.all(promises);
+    const resultsMap = {
+        error: [],
+        reject: [],
+        return: [],
+        continue: []
+    };
+    results.forEach((res)=>resultsMap[res.status] = [
+            ...resultsMap[res.status],
+            res
+        ]);
+    return resultsMap.error?.[0] ?? resultsMap.reject?.[0] ?? resultsMap.return?.[0] ?? {
+        status: 'continue'
+    };
+}
+export default controlParallelFor;

package/dist/routes/endpoints/control/controlReject.js

@@ -0,0 +1,40 @@
+/*
+  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.
+*/ async function controlReject(context, routineContext, { control }) {
+    const { evaluateOperators } = context;
+    const { items } = routineContext;
+    const message = evaluateOperators({
+        input: control[':reject'],
+        items,
+        location: 'TODO'
+    });
+    const cause = evaluateOperators({
+        input: control[':cause'],
+        items,
+        location: 'TODO'
+    });
+    const error = new Error(message, {
+        cause
+    });
+    context.logger.warn({
+        event: 'warn_control_reject',
+        error
+    });
+    return {
+        status: 'reject',
+        error
+    };
+}
+export default controlReject;

package/dist/routes/endpoints/control/controlReturn.js

@@ -0,0 +1,32 @@
+/*
+  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.
+*/ async function controlReturn(context, routineContext, { control }) {
+    const { evaluateOperators } = context;
+    const { items } = routineContext;
+    const response = evaluateOperators({
+        input: control[':return'],
+        items,
+        location: 'TODO'
+    });
+    context.logger.debug({
+        event: 'debug_control_return',
+        response
+    });
+    return {
+        status: 'return',
+        response
+    };
+}
+export default controlReturn;

package/dist/routes/endpoints/control/controlSetState.js

@@ -0,0 +1,22 @@
+import { set } from '@lowdefy/helpers';
+function controlSetState(context, routineContext, { control }) {
+    const { logger, evaluateOperators } = context;
+    const { items } = routineContext;
+    const evaluatedSetState = evaluateOperators({
+        input: control[':set_state'],
+        items,
+        location: 'TODO:'
+    });
+    logger.debug({
+        event: 'debug_control_set_state',
+        input: control[':set_state'],
+        evaluated: evaluatedSetState
+    });
+    Object.entries(evaluatedSetState).forEach(([key, value])=>{
+        set(context.state, key, value);
+    });
+    return {
+        status: 'continue'
+    };
+}
+export default controlSetState;

package/dist/routes/endpoints/control/controlSwitch.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 runRoutine from '../runRoutine.js';
+async function controlSwitch(context, routineContext, { control }) {
+    const { logger, evaluateOperators } = context;
+    const { items } = routineContext;
+    const cases = control[':switch'];
+    logger.debug({
+        event: 'debug_control_switch'
+    });
+    for (const caseObj of cases){
+        const evaluatedCase = evaluateOperators({
+            input: caseObj[':case'],
+            items,
+            location: 'TODO'
+        });
+        logger.debug({
+            event: 'debug_control_switch_case',
+            case: {
+                input: caseObj[':case'],
+                evaluated: evaluatedCase
+            }
+        });
+        if (evaluatedCase) {
+            logger.debug({
+                event: 'debug_control_switch_run_then'
+            });
+            if (!caseObj[':then']) {
+                throw new Error('Invalid switch :case - missing :then');
+            }
+            return runRoutine(context, routineContext, {
+                routine: caseObj[':then']
+            });
+        }
+    }
+    if (control[':default']) {
+        logger.debug({
+            event: 'debug_control_switch_run_default'
+        });
+        return runRoutine(context, routineContext, {
+            routine: control[':default']
+        });
+    }
+    return {
+        status: 'continue'
+    };
+}
+export default controlSwitch;

package/dist/routes/endpoints/control/controlThrow.js

@@ -0,0 +1,40 @@
+/*
+  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.
+*/ async function controlThrow(context, routineContext, { control }) {
+    const { evaluateOperators } = context;
+    const { items } = routineContext;
+    const message = evaluateOperators({
+        input: control[':throw'],
+        items,
+        location: 'TODO'
+    });
+    const cause = evaluateOperators({
+        input: control[':cause'],
+        items,
+        location: 'TODO'
+    });
+    const error = new Error(message, {
+        cause
+    });
+    context.logger.error({
+        event: 'error_control_throw',
+        error
+    });
+    return {
+        status: 'error',
+        error
+    };
+}
+export default controlThrow;

package/dist/routes/endpoints/control/controlTry.js

@@ -0,0 +1,46 @@
+/*
+  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 runRoutine from '../runRoutine.js';
+async function controlTry(context, routineContext, { control }) {
+    context.logger.debug({
+        event: 'debug_control_try'
+    });
+    let res = await runRoutine(context, routineContext, {
+        routine: control[':try']
+    });
+    if (res.status === 'error') {
+        if (control[':catch']) {
+            context.logger.debug({
+                event: 'debug_control_catch'
+            });
+            res = await runRoutine(context, routineContext, {
+                routine: control[':catch']
+            });
+        }
+    }
+    if (control[':finally']) {
+        context.logger.debug({
+            event: 'debug_control_finally'
+        });
+        const finallyRes = await runRoutine(context, routineContext, {
+            routine: control[':finally']
+        });
+        if (finallyRes.status !== 'continue') {
+            res = finallyRes;
+        }
+    }
+    return res;
+}
+export default controlTry;

package/dist/routes/endpoints/control/handleControl.js

@@ -0,0 +1,51 @@
+/*
+  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 controlFor from './controlFor.js';
+import controlIf from './controlIf.js';
+import controlLog from './controlLog.js';
+import controlParallel from './controlParallel.js';
+import controlParallelFor from './controlParallelFor.js';
+import controlReject from './controlReject.js';
+import controlReturn from './controlReturn.js';
+import controlSetState from './controlSetState.js';
+import controlSwitch from './controlSwitch.js';
+import controlThrow from './controlThrow.js';
+import controlTry from './controlTry.js';
+const controlHandlers = {
+    ':for': controlFor,
+    ':if': controlIf,
+    ':log': controlLog,
+    ':parallel_for': controlParallelFor,
+    ':parallel': controlParallel,
+    ':reject': controlReject,
+    ':return': controlReturn,
+    ':set_state': controlSetState,
+    ':switch': controlSwitch,
+    ':throw': controlThrow,
+    ':try': controlTry
+};
+async function handleControl(context, routineContext, { control }) {
+    for (const [key, handler] of Object.entries(controlHandlers)){
+        if (key in control) {
+            return await handler(context, routineContext, {
+                control
+            });
+        }
+    }
+    throw new Error('Unexpected control.', {
+        cause: control
+    });
+}
+export default handleControl;

package/dist/routes/endpoints/getEndpointConfig.js

@@ -0,0 +1,30 @@
+/*
+  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 { ConfigurationError } from '../../context/errors.js';
+async function getEndpointConfig({ logger, readConfigFile }, { endpointId }) {
+    const endpoint = await readConfigFile(`api/${endpointId}.json`);
+    if (!endpoint) {
+        const err = new ConfigurationError(`API Endpoint "${endpointId}" does not exist.`);
+        logger.debug({
+            params: {
+                endpointId
+            },
+            err
+        }, err.message);
+        throw err;
+    }
+    return endpoint;
+}
+export default getEndpointConfig;

package/dist/routes/endpoints/handleRequest.js

@@ -0,0 +1,85 @@
+/*
+  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 addStepResult from './addStepResult.js';
+import callRequestResolver from '../request/callRequestResolver.js';
+import checkConnectionRead from '../request/checkConnectionRead.js';
+import checkConnectionWrite from '../request/checkConnectionWrite.js';
+import evaluateOperators from '../request/evaluateOperators.js';
+import getConnection from '../request/getConnection.js';
+import getConnectionConfig from '../request/getConnectionConfig.js';
+import getRequestResolver from '../request/getRequestResolver.js';
+import validateSchemas from '../request/validateSchemas.js';
+async function handleRequest(context, routineContext, { request }) {
+    const { logger } = context;
+    const { items } = routineContext;
+    logger.debug({
+        event: 'debug_start_request',
+        request
+    });
+    const requestConfig = request;
+    const connectionConfig = await getConnectionConfig(context, {
+        requestConfig
+    });
+    const connection = getConnection(context, {
+        connectionConfig
+    });
+    const requestResolver = getRequestResolver(context, {
+        connection,
+        requestConfig
+    });
+    const { connectionProperties, requestProperties } = evaluateOperators(context, {
+        connectionConfig,
+        items,
+        requestConfig
+    });
+    checkConnectionRead(context, {
+        connectionConfig,
+        connectionProperties,
+        requestConfig,
+        requestResolver
+    });
+    checkConnectionWrite(context, {
+        connectionConfig,
+        connectionProperties,
+        requestConfig,
+        requestResolver
+    });
+    validateSchemas(context, {
+        connection,
+        connectionProperties,
+        requestConfig,
+        requestResolver,
+        requestProperties
+    });
+    const result = await callRequestResolver(context, {
+        connectionProperties,
+        requestConfig,
+        requestProperties,
+        requestResolver
+    });
+    addStepResult(context, routineContext, {
+        result,
+        stepId: request.requestId
+    });
+    context.logger.debug({
+        event: 'debug_end_request',
+        id: requestConfig.id,
+        result
+    });
+    return {
+        status: 'continue'
+    };
+}
+export default handleRequest;