@lowdefy/build 4.4.0 → 4.5.0

package/dist/build/buildApi/buildRoutine/controlTypes.js

@@ -0,0 +1,214 @@
+/*
+  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 buildRoutine from './buildRoutine.js';
+import countControl from './countControl.js';
+import countOperators from '../../../utils/countOperators.js';
+const controlTypes = {
+    ':for': {
+        required: [
+            ':for',
+            ':in',
+            ':do'
+        ],
+        routine: [
+            ':do'
+        ],
+        optional: []
+    },
+    ':if': {
+        required: [
+            ':if',
+            ':then'
+        ],
+        routine: [
+            ':then',
+            ':else'
+        ],
+        optional: [
+            ':else'
+        ]
+    },
+    ':log': {
+        required: [
+            ':log'
+        ],
+        routine: [],
+        optional: [
+            ':level'
+        ]
+    },
+    ':parallel': {
+        required: [
+            ':parallel'
+        ],
+        routine: [
+            ':parallel'
+        ],
+        optional: []
+    },
+    ':parallel_for': {
+        required: [
+            ':parallel_for',
+            ':in',
+            ':do'
+        ],
+        routine: [
+            ':do'
+        ],
+        optional: []
+    },
+    ':reject': {
+        required: [
+            ':reject'
+        ],
+        routine: [],
+        optional: [
+            ':cause'
+        ]
+    },
+    ':return': {
+        required: [
+            ':return'
+        ],
+        routine: [],
+        optional: []
+    },
+    ':set_state': {
+        required: [
+            ':set_state'
+        ],
+        routine: [],
+        optional: []
+    },
+    ':switch': {
+        required: [
+            ':switch',
+            ':case',
+            ':then'
+        ],
+        routine: [
+            ':default',
+            ':then'
+        ],
+        optional: [
+            ':default'
+        ]
+    },
+    ':throw': {
+        required: [
+            ':throw'
+        ],
+        routine: [],
+        optional: [
+            ':cause'
+        ]
+    },
+    ':try': {
+        required: [
+            ':try'
+        ],
+        routine: [
+            ':try',
+            ':catch',
+            ':finally'
+        ],
+        optional: [
+            ':catch',
+            ':finally'
+        ]
+    },
+    ':while': {
+        required: [
+            ':while',
+            ':do'
+        ],
+        routine: [
+            ':do'
+        ],
+        optional: []
+    }
+};
+function getAdditionalKeys(controlType, keys) {
+    return keys.filter((item)=>!controlTypes[controlType].required.includes(item));
+}
+function checkMissingRequiredControls({ controlType, keys }, { endpointId }) {
+    const missingControls = controlTypes[controlType].required.filter((item)=>!keys.includes(item));
+    if (missingControls.length > 0) {
+        throw new Error(`Missing required control type(s) for endpoint ${endpointId}. Missing ${JSON.stringify(missingControls)}`);
+    }
+}
+function checkInvalidControls({ controlType, keys }, { endpointId }) {
+    const additionalControls = getAdditionalKeys(controlType, keys);
+    const invalidControls = additionalControls.filter((item)=>!controlTypes[controlType].optional.includes(item));
+    if (invalidControls.length > 0) {
+        throw new Error(`Invalid control type(s) for endpoint ${endpointId}. Received ${JSON.stringify(invalidControls)}`);
+    }
+}
+function handleSwitch(control, endpointContext) {
+    const switchArray = control[':switch'];
+    if (!type.isArray(control[':switch'])) {
+        throw new Error(`Type given for :switch control is invalid at endpoint ${endpointContext.endpointId}. Received ${JSON.stringify(control[':switch'])}`);
+    }
+    switchArray.forEach((caseObj)=>{
+        const input = {
+            controlType: ':switch',
+            keys: [
+                ':switch',
+                ...Object.keys(caseObj)
+            ]
+        };
+        checkMissingRequiredControls(input, endpointContext);
+        checkInvalidControls(input, endpointContext);
+        Object.keys(caseObj).forEach((key)=>{
+            if (routineKey(':switch', key)) {
+                buildRoutine(caseObj[key], endpointContext);
+            } else {
+                countOperators(caseObj[key], {
+                    counter: endpointContext.typeCounters.operators.server
+                });
+                countControl(key, endpointContext);
+            }
+        });
+    });
+}
+function validateControl(control, endpointContext) {
+    const keys = Object.keys(control);
+    const intersection = keys.filter((item)=>Object.keys(controlTypes).includes(item));
+    if (intersection.length === 0) {
+        throw new Error(`Invalid control type(s) for endpoint ${endpointContext.endpointId}. Received "${JSON.stringify(keys)}"`);
+    }
+    if (intersection.length > 1) {
+        throw new Error(`More than one control type found for endpoint ${endpointContext.endpointId}. Received ${JSON.stringify(intersection)}`);
+    }
+    const controlType = intersection[0];
+    if (controlType === ':switch') {
+        handleSwitch(control, endpointContext);
+        return controlType;
+    }
+    checkMissingRequiredControls({
+        controlType,
+        keys
+    }, endpointContext);
+    checkInvalidControls({
+        controlType,
+        keys
+    }, endpointContext);
+    return controlType;
+}
+function routineKey(controlType, key) {
+    return controlTypes[controlType]?.routine.includes(key);
+}
+export { routineKey, validateControl };

package/dist/build/buildApi/buildRoutine/countControl.js

@@ -0,0 +1,18 @@
+/*
+  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.
+*/ function countControl(control, { typeCounters }) {
+    typeCounters.controls.increment(control);
+}
+export default countControl;

package/dist/build/buildApi/buildRoutine/countStepTypes.js

@@ -0,0 +1,18 @@
+/*
+  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.
+*/ function countStepTypes(step, { typeCounters }) {
+    typeCounters.requests.increment(step.type);
+}
+export default countStepTypes;

package/dist/build/buildApi/buildRoutine/setStepId.js

@@ -0,0 +1,20 @@
+/*
+  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.
+*/ function setStepId(step, { endpointId }) {
+    step.requestId = step.id;
+    step.endpointId = endpointId;
+    step.id = `request:${endpointId}:${step.requestId}`;
+}
+export default setStepId;

package/dist/build/buildApi/buildRoutine/validateStep.js

@@ -0,0 +1,42 @@
+/*
+  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';
+function validateStep(step, { endpointId }) {
+    if (Object.keys(step).length === 0) {
+        throw new Error(`Step is not defined at endpoint "${endpointId}"`);
+    }
+    if (type.isUndefined(step.id)) {
+        throw new Error(`Step id missing at endpoint "${endpointId}".`);
+    }
+    if (!type.isString(step.id)) {
+        throw new Error(`Step id is not a string at endpoint "${endpointId}". Received ${JSON.stringify(step.id)}.`);
+    }
+    if (step.id.includes('.')) {
+        throw new Error(`Step id "${step.id}" at api "${endpointId}" should not include a period (".").`);
+    }
+    if (type.isNone(step.type)) {
+        throw new Error(`Step type is not defined at "${step.id}" on endpoint "${endpointId}".`);
+    }
+    if (!type.isString(step.type)) {
+        throw new Error(`Step type is not a string at "${step.id}" on endpoint "${endpointId}". Received ${JSON.stringify(step.type)}.`);
+    }
+    if (type.isUndefined(step.connectionId)) {
+        throw new Error(`Step connectionId missing at endpoint "${endpointId}".`);
+    }
+    if (!type.isString(step.connectionId)) {
+        throw new Error(`Step connectionId is not a string at endpoint "${endpointId}". Received ${JSON.stringify(step.connectionId)}.`);
+    }
+}
+export default validateStep;

package/dist/build/buildApi/validateEndpoint.js

@@ -0,0 +1,22 @@
+import { type } from '@lowdefy/helpers';
+function validateEndpoint({ endpoint, index, checkDuplicateEndpointId }) {
+    if (type.isUndefined(endpoint.id)) {
+        throw new Error(`Endpoint id missing at endpoint ${index}.`);
+    }
+    if (!type.isString(endpoint.id)) {
+        throw new Error(`Endpoint id is not a string at endpoint ${index}. Received ${JSON.stringify(endpoint.id)}.`);
+    }
+    if (endpoint.id.includes('.')) {
+        throw new Error(`Endpoint id "${endpoint.id}" at endpoint "${endpoint.id}" should not include a period (".").`);
+    }
+    if (type.isUndefined(endpoint.type)) {
+        throw new Error(`Endpoint type is not defined at "${endpoint.id}" on endpoint "${endpoint.id}".`);
+    }
+    if (!type.isString(endpoint.type)) {
+        throw new Error(`Endpoint type is not a string at "${endpoint.id}" on endpoint "${endpoint.id}". Received ${JSON.stringify(endpoint.type)}.`);
+    }
+    checkDuplicateEndpointId({
+        id: endpoint.id
+    });
+}
+export default validateEndpoint;

package/dist/build/buildAuth/buildApiAuth.js

@@ -0,0 +1,50 @@
+/* eslint-disable no-param-reassign */ /*
+  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 getApiRoles from './getApiRoles.js';
+import getProtectedApi from './getProtectedApi.js';
+function buildApiAuth({ components }) {
+    const protectedApiEndpoints = getProtectedApi({
+        components
+    });
+    const apiRoles = getApiRoles({
+        components
+    });
+    let configPublicApi = [];
+    if (type.isArray(components.auth.api.public)) {
+        configPublicApi = components.auth.api.public;
+    }
+    (components.api || []).forEach((endpoint)=>{
+        if (apiRoles[endpoint.id]) {
+            if (configPublicApi.includes(endpoint.id)) {
+                throw new Error(`Page "${endpoint.id}" is both protected by roles ${JSON.stringify(apiRoles[endpoint.id])} and public.`);
+            }
+            endpoint.auth = {
+                public: false,
+                roles: apiRoles[endpoint.id]
+            };
+        } else if (protectedApiEndpoints.includes(endpoint.id)) {
+            endpoint.auth = {
+                public: false
+            };
+        } else {
+            endpoint.auth = {
+                public: true
+            };
+        }
+    });
+    return components;
+}
+export default buildApiAuth;

package/dist/build/buildAuth/buildAuth.js

@@ -14,29 +14,18 @@
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
 import buildAuthPlugins from './buildAuthPlugins.js';
+import buildApiAuth from './buildApiAuth.js';
 import buildPageAuth from './buildPageAuth.js';
 import validateAuthConfig from './validateAuthConfig.js';
-let warningLogged = false;
 function buildAuth({ components, context }) {
     const configured = !type.isNone(components.auth);
-    if (configured && !context.entitlements.includes('AUTH')) {
-        if (!warningLogged) {
-            context.logger.warn(`
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
-┃ Authentication configured without a license key. ┃
-┠──────────────────────────────────────────────────┨
-┃ Paid features can not be used in production      ┃
-┃ without a valid license.                         ┃
-┃                                                  ┃
-┃ See https://docs.lowdefy.com/licenses.            ┃
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛`);
-            warningLogged = true;
-        }
-    }
     validateAuthConfig({
         components
     });
     components.auth.configured = configured;
+    buildApiAuth({
+        components
+    });
     buildPageAuth({
         components
     });

package/dist/build/buildAuth/getApiRoles.js

@@ -0,0 +1,33 @@
+/*
+  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.
+*/ function getApiRoles({ components }) {
+    const roles = components.auth.api.roles;
+    const apiRoles = {};
+    Object.keys(roles).forEach((roleName)=>{
+        roles[roleName].forEach((endpointId)=>{
+            if (!apiRoles[endpointId]) {
+                apiRoles[endpointId] = new Set();
+            }
+            apiRoles[endpointId].add(roleName);
+        });
+    });
+    Object.keys(apiRoles).forEach((endpointId)=>{
+        apiRoles[endpointId] = [
+            ...apiRoles[endpointId]
+        ];
+    });
+    return apiRoles;
+}
+export default getApiRoles;

package/dist/build/buildAuth/getProtectedApi.js

@@ -0,0 +1,28 @@
+/*
+  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';
+function getProtectedApi({ components }) {
+    const endpointIds = (components.api || []).map((endpoint)=>endpoint.id);
+    let protectedApi = [];
+    if (type.isArray(components.auth.api.public)) {
+        protectedApi = endpointIds.filter((endpointId)=>!components.auth.api.public.includes(endpointId));
+    } else if (components.auth.api.protected === true) {
+        protectedApi = endpointIds;
+    } else if (type.isArray(components.auth.api.protected)) {
+        protectedApi = components.auth.api.protected;
+    }
+    return protectedApi;
+}
+export default getProtectedApi;

package/dist/build/buildAuth/validateAuthConfig.js

@@ -15,6 +15,7 @@
 */ import { type } from '@lowdefy/helpers';
 import { validate } from '@lowdefy/ajv';
 import lowdefySchema from '../../lowdefySchema.js';
+import validateMutualExclusivity from './validateMutualExclusivity.js';
 async function validateAuthConfig({ components }) {
     if (type.isNone(components.auth)) {
         components.auth = {};
@@ -22,6 +23,12 @@ async function validateAuthConfig({ components }) {
     if (!type.isObject(components.auth)) {
         throw new Error('lowdefy.auth is not an object.');
     }
+    if (type.isNone(components.auth.api)) {
+        components.auth.api = {};
+    }
+    if (type.isNone(components.auth.api.roles)) {
+        components.auth.api.roles = {};
+    }
     if (type.isNone(components.auth.authPages)) {
         components.auth.authPages = {};
     }
@@ -50,15 +57,14 @@ async function validateAuthConfig({ components }) {
         schema: lowdefySchema.definitions.authConfig,
         data: components.auth
     });
-    if (components.auth.pages.protected === true && components.auth.pages.public === true || type.isArray(components.auth.pages.protected) && type.isArray(components.auth.pages.public)) {
-        throw new Error('Protected and public pages are mutually exclusive. When protected pages are listed, all unlisted pages are public by default and visa versa.');
-    }
-    if (components.auth.pages.protected === false) {
-        throw new Error('Protected pages can not be set to false.');
-    }
-    if (components.auth.pages.public === false) {
-        throw new Error('Public pages can not be set to false.');
-    }
+    validateMutualExclusivity({
+        components,
+        entity: 'api'
+    });
+    validateMutualExclusivity({
+        components,
+        entity: 'pages'
+    });
     return components;
 }
 export default validateAuthConfig;

package/dist/build/buildAuth/validateMutualExclusivity.js

@@ -0,0 +1,27 @@
+/* eslint-disable no-param-reassign */ /*
+  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';
+function validateMutualExclusivity({ components, entity }) {
+    if (components.auth[entity].protected === true && components.auth[entity].public === true || type.isArray(components.auth[entity].protected) && type.isArray(components.auth[entity].public)) {
+        throw new Error(`Protected and public ${entity} are mutually exclusive. When protected ${entity} are listed, all unlisted ${entity} are public by default and vice versa.`);
+    }
+    if (components.auth[entity].protected === false) {
+        throw new Error(`Protected ${entity} can not be set to false.`);
+    }
+    if (components.auth[entity].public === false) {
+        throw new Error(`Public ${entity} can not be set to false.`);
+    }
+}
+export default validateMutualExclusivity;

package/dist/build/buildJs/buildJs.js

@@ -34,6 +34,11 @@ function buildJs({ components, context }) {
             requests: cleanRequests
         };
     });
+    components.api = jsMapParser({
+        input: components.api,
+        jsMap: context.jsMap,
+        env: 'server'
+    });
     components.connections = jsMapParser({
         input: components.connections,
         jsMap: context.jsMap,

package/dist/build/buildJs/writeJs.js

@@ -20,7 +20,7 @@ async function writeJs({ context }) {
     }));
     await context.writeBuildArtifact('plugins/operators/serverJsMap.js', generateJsFile({
         map: context.jsMap.server,
-        functionPrototype: `{ payload, secrets, user }`
+        functionPrototype: `{ item, payload, secrets, state, step, user }`
     }));
 }
 export default writeJs;

package/dist/build/buildTypes.js

@@ -46,10 +46,6 @@ function buildTypes({ components, context }) {
     loaderTypes.blocks.forEach((block)=>typeCounters.blocks.increment(block));
     // Used for DisplayMessage in @lowdefy/client
     typeCounters.blocks.increment('Message');
-    // Used by license-invalid page
-    typeCounters.blocks.increment('Button');
-    typeCounters.blocks.increment('Result');
-    typeCounters.operators.client.increment('_get');
     components.types = {
         actions: {},
         auth: {
@@ -61,6 +57,7 @@ function buildTypes({ components, context }) {
         blocks: {},
         connections: {},
         requests: {},
+        api: {},
         operators: {
             client: {},
             server: {}

package/dist/build/writeApi.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 { type, serializer } from '@lowdefy/helpers';
+async function writeEndpoint({ endpoint, context }) {
+    await context.writeBuildArtifact(`api/${endpoint.endpointId}.json`, serializer.serializeToString(endpoint ?? {}));
+}
+async function writeApi({ components, context }) {
+    if (type.isNone(components.api)) return;
+    if (!type.isArray(components.api)) {
+        throw new Error(`Api is not an array.`);
+    }
+    const writePromises = components.api.map((endpoint)=>writeEndpoint({
+            endpoint,
+            context
+        }));
+    return Promise.all(writePromises);
+}
+export default writeApi;

package/dist/createContext.js

@@ -17,10 +17,9 @@ import createCounter from './utils/createCounter.js';
 import createReadConfigFile from './utils/readConfigFile.js';
 import createWriteBuildArtifact from './utils/writeBuildArtifact.js';
 import defaultTypesMap from './defaultTypesMap.js';
-function createContext({ customTypesMap, directories, entitlements = [], logger, refResolver, stage = 'prod' }) {
+function createContext({ customTypesMap, directories, logger, refResolver, stage = 'prod' }) {
     const context = {
         directories,
-        entitlements,
         jsMap: {},
         keyMap: {},
         logger,
@@ -41,6 +40,7 @@ function createContext({ customTypesMap, directories, entitlements = [], logger,
             blocks: createCounter(),
             connections: createCounter(),
             requests: createCounter(),
+            controls: createCounter(),
             operators: {
                 client: createCounter(),
                 server: createCounter()