@lowdefy/build 0.0.0-experimental-20251203205559 → 0.0.0-experimental-20260113081624

package/dist/build/addKeys.js

@@ -49,6 +49,7 @@ function recAddKeys({ object, key, keyMap, parentKeyMapId }) {
     keyMap[keyMapId] = {
         key,
         '~r': object['~r'],
+        '~l': object['~l'],
         '~k_parent': parentKeyMapId
     };
     Object.defineProperty(object, '~k', {
@@ -58,6 +59,7 @@ function recAddKeys({ object, key, keyMap, parentKeyMapId }) {
         configurable: true
     });
     delete object['~r'];
+    delete object['~l'];
     Object.keys(object).forEach((nextKey)=>{
         if (type.isObject(object[nextKey])) {
             recAddKeys({

package/dist/build/buildApi/buildEndpoint.js

@@ -14,6 +14,7 @@
   limitations under the License.
 */ import buildRoutine from './buildRoutine/buildRoutine.js';
 import validateEndpoint from './validateEndpoint.js';
+import validateStepReferences from './validateStepReferences.js';
 function buildEndpoint({ endpoint, index, context, checkDuplicateEndpointId }) {
     validateEndpoint({
         endpoint,
@@ -25,6 +26,11 @@ function buildEndpoint({ endpoint, index, context, checkDuplicateEndpointId }) {
         endpointId: endpoint.endpointId,
         typeCounters: context.typeCounters
     });
+    // Validate that _step references point to defined step IDs
+    validateStepReferences({
+        endpoint,
+        context
+    });
     endpoint.id = `endpoint:${endpoint.endpointId}`;
 }
 export default buildEndpoint;

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

@@ -13,6 +13,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ function countStepTypes(step, { typeCounters }) {
-    typeCounters.requests.increment(step.type);
+    typeCounters.requests.increment(step.type, step['~k']);
 }
 export default countStepTypes;

package/dist/build/buildApi/validateStepReferences.js

@@ -0,0 +1,65 @@
+/*
+  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 extractOperatorKey from '../../utils/extractOperatorKey.js';
+import formatConfigWarning from '../../utils/formatConfigWarning.js';
+import traverseConfig from '../../utils/traverseConfig.js';
+// Collect all step IDs from a routine (including nested control structures)
+// Note: After buildRoutine, steps have requestId (original id) and id is modified
+function collectStepIds(routine, stepIds) {
+    if (type.isArray(routine)) {
+        routine.forEach((item)=>collectStepIds(item, stepIds));
+        return;
+    }
+    if (type.isObject(routine)) {
+        // Check if this is a step (has requestId after build, or id before build)
+        if (routine.requestId) {
+            stepIds.add(routine.requestId);
+        }
+        // Recurse into all values (handles control structures like :then, :else, :try, :catch)
+        Object.values(routine).forEach((value)=>collectStepIds(value, stepIds));
+    }
+}
+function validateStepReferences({ endpoint, context }) {
+    // Collect all step IDs defined in the routine
+    const stepIds = new Set();
+    collectStepIds(endpoint.routine, stepIds);
+    // Find _step references in the routine
+    const stepRefs = new Map(); // topLevelKey -> configKey (first occurrence)
+    traverseConfig({
+        config: endpoint.routine,
+        visitor: (obj)=>{
+            if (obj._step !== undefined) {
+                const stepId = extractOperatorKey({
+                    operatorValue: obj._step
+                });
+                if (stepId && !stepRefs.has(stepId)) {
+                    stepRefs.set(stepId, obj['~k']);
+                }
+            }
+        }
+    });
+    // Warn for undefined step references
+    stepRefs.forEach((configKey, stepId)=>{
+        if (stepIds.has(stepId)) return;
+        const message = `_step references "${stepId}" in endpoint "${endpoint.endpointId}", ` + `but no step with id "${stepId}" exists in the routine. ` + `Step IDs are defined by the "id" property of each step. ` + `Check for typos or add a step with this id.`;
+        context.logger.warn(formatConfigWarning({
+            message,
+            configKey,
+            context
+        }));
+    });
+}
+export default validateStepReferences;

package/dist/build/buildAuth/buildAuthPlugins.js

@@ -13,19 +13,33 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-function buildAuthPlugin({ counter, pluginConfig, typeClass }) {
+import formatConfigError from '../../utils/formatConfigError.js';
+function buildAuthPlugin({ counter, pluginConfig, typeClass, context }) {
     if (type.isArray(pluginConfig)) {
         pluginConfig.forEach((plugin)=>{
+            const configKey = plugin['~k'];
             if (type.isUndefined(plugin.id)) {
-                throw new Error(`Auth ${typeClass} id missing.`);
+                throw new Error(formatConfigError({
+                    message: `Auth ${typeClass} id missing.`,
+                    configKey,
+                    context
+                }));
             }
             if (!type.isString(plugin.id)) {
-                throw new Error(`Auth ${typeClass} id is not a string. Received ${JSON.stringify(plugin.id)}.`);
+                throw new Error(formatConfigError({
+                    message: `Auth ${typeClass} id is not a string. Received ${JSON.stringify(plugin.id)}.`,
+                    configKey,
+                    context
+                }));
             }
             if (!type.isString(plugin.type)) {
-                throw new Error(`Auth ${typeClass} type is not a string at ${typeClass} "${plugin.id}". Received ${JSON.stringify(plugin.type)}.`);
+                throw new Error(formatConfigError({
+                    message: `Auth ${typeClass} type is not a string at ${typeClass} "${plugin.id}". Received ${JSON.stringify(plugin.type)}.`,
+                    configKey,
+                    context
+                }));
             }
-            counter.increment(plugin.type);
+            counter.increment(plugin.type, plugin['~k']);
         });
     }
 }
@@ -34,16 +48,29 @@ function buildAdapter({ components, context }) {
     if (type.isNone(adapter)) {
         return;
     }
+    const configKey = adapter['~k'];
     if (type.isUndefined(adapter.id)) {
-        throw new Error(`Auth adapter id missing.`);
+        throw new Error(formatConfigError({
+            message: 'Auth adapter id missing.',
+            configKey,
+            context
+        }));
     }
     if (!type.isString(adapter.id)) {
-        throw new Error(`Auth adapter id is not a string. Received ${JSON.stringify(adapter.id)}.`);
+        throw new Error(formatConfigError({
+            message: `Auth adapter id is not a string. Received ${JSON.stringify(adapter.id)}.`,
+            configKey,
+            context
+        }));
     }
     if (!type.isString(adapter.type)) {
-        throw new Error(`Auth adapter type is not a string at adapter "${adapter.id}". Received ${JSON.stringify(adapter.type)}.`);
+        throw new Error(formatConfigError({
+            message: `Auth adapter type is not a string at adapter "${adapter.id}". Received ${JSON.stringify(adapter.type)}.`,
+            configKey,
+            context
+        }));
     }
-    context.typeCounters.auth.adapters.increment(adapter.type);
+    context.typeCounters.auth.adapters.increment(adapter.type, adapter['~k']);
 }
 function buildAuthPlugins({ components, context }) {
     const counters = context.typeCounters.auth;
@@ -55,17 +82,20 @@ function buildAuthPlugins({ components, context }) {
     buildAuthPlugin({
         counter: counters.callbacks,
         pluginConfig: authConfig.callbacks,
-        typeClass: 'callback'
+        typeClass: 'callback',
+        context
     });
     buildAuthPlugin({
         counter: counters.events,
         pluginConfig: authConfig.events,
-        typeClass: 'event'
+        typeClass: 'event',
+        context
     });
     buildAuthPlugin({
         counter: counters.providers,
         pluginConfig: authConfig.providers,
-        typeClass: 'provider'
+        typeClass: 'provider',
+        context
     });
 }
 export default buildAuthPlugins;

package/dist/build/buildAuth/validateAuthConfig.js

@@ -15,13 +15,19 @@
 */ import { type } from '@lowdefy/helpers';
 import { validate } from '@lowdefy/ajv';
 import lowdefySchema from '../../lowdefySchema.js';
+import formatConfigError from '../../utils/formatConfigError.js';
 import validateMutualExclusivity from './validateMutualExclusivity.js';
-async function validateAuthConfig({ components }) {
+async function validateAuthConfig({ components, context }) {
     if (type.isNone(components.auth)) {
         components.auth = {};
     }
     if (!type.isObject(components.auth)) {
-        throw new Error('lowdefy.auth is not an object.');
+        const configKey = components.auth?.['~k'];
+        throw new Error(formatConfigError({
+            message: 'lowdefy.auth is not an object.',
+            configKey,
+            context
+        }));
     }
     if (type.isNone(components.auth.api)) {
         components.auth.api = {};
@@ -59,10 +65,12 @@ async function validateAuthConfig({ components }) {
     });
     validateMutualExclusivity({
         components,
+        context,
         entity: 'api'
     });
     validateMutualExclusivity({
         components,
+        context,
         entity: 'pages'
     });
     return components;

package/dist/build/buildAuth/validateMutualExclusivity.js

@@ -13,15 +13,29 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-function validateMutualExclusivity({ components, entity }) {
+import formatConfigError from '../../utils/formatConfigError.js';
+function validateMutualExclusivity({ components, context, entity }) {
+    const configKey = components.auth[entity]?.['~k'] || components.auth?.['~k'];
     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.`);
+        throw new Error(formatConfigError({
+            message: `Protected and public ${entity} are mutually exclusive. When protected ${entity} are listed, all unlisted ${entity} are public by default and vice versa.`,
+            configKey,
+            context
+        }));
     }
     if (components.auth[entity].protected === false) {
-        throw new Error(`Protected ${entity} can not be set to false.`);
+        throw new Error(formatConfigError({
+            message: `Protected ${entity} can not be set to false.`,
+            configKey,
+            context
+        }));
     }
     if (components.auth[entity].public === false) {
-        throw new Error(`Public ${entity} can not be set to false.`);
+        throw new Error(formatConfigError({
+            message: `Public ${entity} can not be set to false.`,
+            configKey,
+            context
+        }));
     }
 }
 export default validateMutualExclusivity;

package/dist/build/buildConnections.js

@@ -13,28 +13,47 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import collectConfigError from '../utils/collectConfigError.js';
 import countOperators from '../utils/countOperators.js';
 import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
 function buildConnections({ components, context }) {
+    // Store connection IDs for validation in buildRequests
+    context.connectionIds = new Set();
     const checkDuplicateConnectionId = createCheckDuplicateId({
-        message: 'Duplicate connectionId "{{ id }}".'
+        message: 'Duplicate connectionId "{{ id }}".',
+        context
     });
     if (type.isArray(components.connections)) {
         components.connections.forEach((connection)=>{
+            const configKey = connection['~k'];
             if (type.isUndefined(connection.id)) {
-                throw new Error(`Connection id missing.`);
+                collectConfigError({
+                    message: 'Connection id missing.',
+                    configKey,
+                    context
+                });
             }
             if (!type.isString(connection.id)) {
-                throw new Error(`Connection id is not a string. Received ${JSON.stringify(connection.id)}.`);
+                collectConfigError({
+                    message: `Connection id is not a string. Received ${JSON.stringify(connection.id)}.`,
+                    configKey,
+                    context
+                });
             }
             checkDuplicateConnectionId({
-                id: connection.id
+                id: connection.id,
+                configKey
             });
             if (!type.isString(connection.type)) {
-                throw new Error(`Connection type is not a string at connection "${connection.id}". Received ${JSON.stringify(connection.type)}.`);
+                collectConfigError({
+                    message: `Connection type is not a string at connection "${connection.id}". Received ${JSON.stringify(connection.type)}.`,
+                    configKey,
+                    context
+                });
             }
-            context.typeCounters.connections.increment(connection.type);
+            context.typeCounters.connections.increment(connection.type, connection['~k']);
             connection.connectionId = connection.id;
+            context.connectionIds.add(connection.connectionId);
             connection.id = `connection:${connection.id}`;
             countOperators(connection.properties || {}, {
                 counter: context.typeCounters.operators.server

package/dist/build/buildImports/buildIconImports.js

@@ -12,8 +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 createBuildProfiler from '../../utils/createBuildProfiler.js';
-const iconPackages = {
+*/ const iconPackages = {
     'react-icons/ai': /"(Ai[A-Z0-9]\w*)"/gm,
     'react-icons/bi': /"(Bi[A-Z0-9]\w*)"/gm,
     'react-icons/bs': /"(Bs[A-Z0-9]\w*)"/gm,
@@ -43,40 +42,27 @@ const iconPackages = {
     'react-icons/vsc': /"(Vsc[A-Z0-9]\w*)"/gm,
     'react-icons/wi': /"(Wi[A-Z0-9]\w*)"/gm
 };
-function getConfigIcons({ components, icons, regex, timeSync }) {
-    timeSync('stringify:global', ()=>{
-        [
-            ...JSON.stringify(components.global || {}).matchAll(regex)
-        ].map((match)=>icons.add(match[1]));
-    });
-    timeSync('stringify:menus', ()=>{
-        [
-            ...JSON.stringify(components.menus || []).matchAll(regex)
-        ].map((match)=>icons.add(match[1]));
-    });
-    timeSync('stringify:pages', ()=>{
-        [
-            ...JSON.stringify(components.pages || []).matchAll(regex)
-        ].map((match)=>icons.add(match[1]));
-    });
+function getConfigIcons({ components, icons, regex }) {
+    [
+        ...JSON.stringify(components.global || {}).matchAll(regex)
+    ].map((match)=>icons.add(match[1]));
+    [
+        ...JSON.stringify(components.menus || []).matchAll(regex)
+    ].map((match)=>icons.add(match[1]));
+    [
+        ...JSON.stringify(components.pages || []).matchAll(regex)
+    ].map((match)=>icons.add(match[1]));
 }
-function getBlockDefaultIcons({ blocks, context, icons, regex, timeSync }) {
-    timeSync('blockDefaultIcons', ()=>{
-        blocks.forEach((block)=>{
-            (context.typesMap.icons[block.typeName] || []).forEach((icon)=>{
-                [
-                    ...JSON.stringify(icon).matchAll(regex)
-                ].map((match)=>icons.add(match[1]));
-            });
+function getBlockDefaultIcons({ blocks, context, icons, regex }) {
+    blocks.forEach((block)=>{
+        (context.typesMap.icons[block.typeName] || []).forEach((icon)=>{
+            [
+                ...JSON.stringify(icon).matchAll(regex)
+            ].map((match)=>icons.add(match[1]));
         });
     });
 }
 function buildIconImports({ blocks, components, context, defaults = {} }) {
-    const profiler = createBuildProfiler({
-        logger: context.logger,
-        prefix: 'buildIconImports'
-    });
-    const timeSync = profiler.timeSync;
     const iconImports = [];
     Object.entries(iconPackages).forEach(([iconPackage, regex])=>{
         defaults;
@@ -84,15 +70,13 @@ function buildIconImports({ blocks, components, context, defaults = {} }) {
         getConfigIcons({
             components,
             icons,
-            regex,
-            timeSync
+            regex
         });
         getBlockDefaultIcons({
             blocks,
             context,
             icons,
-            regex,
-            timeSync
+            regex
         });
         iconImports.push({
             icons: [
@@ -101,7 +85,6 @@ function buildIconImports({ blocks, components, context, defaults = {} }) {
             package: iconPackage
         });
     });
-    profiler.printSummary();
     return iconImports;
 }
 export default buildIconImports;

package/dist/build/buildLogger.js

@@ -0,0 +1,41 @@
+/*
+  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';
+const sentryDefaults = {
+    client: true,
+    server: true,
+    tracesSampleRate: 0.1,
+    replaysSessionSampleRate: 0,
+    replaysOnErrorSampleRate: 0.1,
+    feedback: false,
+    userFields: [
+        'id',
+        '_id'
+    ]
+};
+function buildLogger({ components }) {
+    if (type.isNone(components.logger)) {
+        components.logger = {};
+    }
+    // Only apply defaults if sentry is explicitly configured
+    if (!type.isNone(components.logger.sentry)) {
+        components.logger.sentry = {
+            ...sentryDefaults,
+            ...components.logger.sentry
+        };
+    }
+    return components;
+}
+export default buildLogger;

package/dist/build/buildMenu.js

@@ -12,8 +12,9 @@
   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 { type, resolveConfigLocation } from '@lowdefy/helpers';
 import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
+import formatConfigError from '../utils/formatConfigError.js';
 function buildDefaultMenu({ components, context }) {
     context.logger.warn('No menus found. Building default menu.');
     const pages = type.isArray(components.pages) ? components.pages : [];
@@ -30,16 +31,18 @@ function buildDefaultMenu({ components, context }) {
     ];
     return menus;
 }
-function loopItems({ parent, menuId, pages, missingPageWarnings, checkDuplicateMenuItemId }) {
+function loopItems({ parent, menuId, pages, missingPageWarnings, checkDuplicateMenuItemId, context }) {
     if (type.isArray(parent.links)) {
         parent.links.forEach((menuItem)=>{
+            const configKey = menuItem['~k'];
             if (menuItem.type === 'MenuLink') {
                 if (type.isString(menuItem.pageId)) {
                     const page = pages.find((pg)=>pg.pageId === menuItem.pageId);
                     if (!page) {
                         missingPageWarnings.push({
                             menuItemId: menuItem.id,
-                            pageId: menuItem.pageId
+                            pageId: menuItem.pageId,
+                            configKey
                         });
                         // remove menuItem from menu
                         menuItem.remove = true;
@@ -60,7 +63,8 @@ function loopItems({ parent, menuId, pages, missingPageWarnings, checkDuplicateM
             }
             checkDuplicateMenuItemId({
                 id: menuItem.id,
-                menuId
+                menuId,
+                configKey
             });
             menuItem.menuItemId = menuItem.id;
             menuItem.id = `menuitem:${menuId}:${menuItem.id}`;
@@ -69,7 +73,8 @@ function loopItems({ parent, menuId, pages, missingPageWarnings, checkDuplicateM
                 menuId,
                 pages,
                 missingPageWarnings,
-                checkDuplicateMenuItemId
+                checkDuplicateMenuItemId,
+                context
             });
         });
         parent.links = parent.links.filter((item)=>item.remove !== true);
@@ -85,33 +90,55 @@ function buildMenu({ components, context }) {
     }
     const missingPageWarnings = [];
     const checkDuplicateMenuId = createCheckDuplicateId({
-        message: 'Duplicate menuId "{{ id }}".'
+        message: 'Duplicate menuId "{{ id }}".',
+        context
     });
     components.menus.forEach((menu)=>{
+        const configKey = menu['~k'];
         if (type.isUndefined(menu.id)) {
-            throw new Error(`Menu id missing.`);
+            throw new Error(formatConfigError({
+                message: 'Menu id missing.',
+                configKey,
+                context
+            }));
         }
         if (!type.isString(menu.id)) {
-            throw new Error(`Menu id is not a string. Received ${JSON.stringify(menu.id)}.`);
+            throw new Error(formatConfigError({
+                message: `Menu id is not a string. Received ${JSON.stringify(menu.id)}.`,
+                configKey,
+                context
+            }));
         }
         checkDuplicateMenuId({
-            id: menu.id
+            id: menu.id,
+            configKey
         });
         menu.menuId = menu.id;
         menu.id = `menu:${menu.id}`;
         const checkDuplicateMenuItemId = createCheckDuplicateId({
-            message: 'Duplicate menuItemId "{{ id }}" on menu "{{ menuId }}".'
+            message: 'Duplicate menuItemId "{{ id }}" on menu "{{ menuId }}".',
+            context
         });
         loopItems({
             parent: menu,
             menuId: menu.menuId,
             pages,
             missingPageWarnings,
-            checkDuplicateMenuItemId
+            checkDuplicateMenuItemId,
+            context
         });
     });
-    missingPageWarnings.map(async (warning)=>{
-        context.logger.warn(`Page "${warning.pageId}" referenced in menu link "${warning.menuItemId}" not found.`);
+    missingPageWarnings.forEach((warning)=>{
+        const location = resolveConfigLocation({
+            configKey: warning.configKey,
+            keyMap: context.keyMap,
+            refMap: context.refMap,
+            configDirectory: context.directories.config
+        });
+        const source = location?.source ? `${location.source} at ${location.config}` : '';
+        const link = location?.link || '';
+        const message = `Page "${warning.pageId}" referenced in menu link "${warning.menuItemId}" not found.`;
+        context.logger.warn(`[Config Error] ${message}\n  ${source}\n  ${link}`);
     });
     return components;
 }