@lowdefy/build 0.0.0-experimental-20260114142524 → 0.0.0-experimental-20260122074446

package/dist/build/addKeys.js

@@ -45,26 +45,39 @@ function recArray({ array, nextKey, key, keyMap, keyMapId }) {
     });
 }
 function recAddKeys({ object, key, keyMap, parentKeyMapId }) {
-    const keyMapId = makeId();
-    keyMap[keyMapId] = {
-        key,
-        '~r': object['~r'],
-        '~l': object['~l'],
-        '~k_parent': parentKeyMapId
-    };
-    Object.defineProperty(object, '~k', {
-        value: keyMapId,
-        enumerable: false,
-        writable: true,
-        configurable: true
-    });
-    delete object['~r'];
-    delete object['~l'];
+    let keyMapId;
+    let storedKey = key;
+    // Skip objects that already have a ~k (already processed)
+    if (object['~k']) {
+        keyMapId = object['~k'];
+        // Use the stored key from keyMap for correct child paths
+        storedKey = keyMap[keyMapId]?.key ?? key;
+    } else {
+        keyMapId = makeId.next();
+        const entry = {
+            key,
+            '~k_parent': parentKeyMapId
+        };
+        if (object['~r'] !== undefined) entry['~r'] = object['~r'];
+        if (object['~l'] !== undefined) entry['~l'] = object['~l'];
+        if (object['~ignoreBuildCheck'] !== undefined) entry['~ignoreBuildCheck'] = object['~ignoreBuildCheck'];
+        keyMap[keyMapId] = entry;
+        Object.defineProperty(object, '~k', {
+            value: keyMapId,
+            enumerable: false,
+            writable: true,
+            configurable: true
+        });
+        delete object['~r'];
+        delete object['~l'];
+        delete object['~ignoreBuildCheck'];
+    }
+    // Always recurse into children (they may be new objects without keys)
     Object.keys(object).forEach((nextKey)=>{
         if (type.isObject(object[nextKey])) {
             recAddKeys({
                 object: object[nextKey],
-                key: `${key}.${nextKey}`,
+                key: `${storedKey}.${nextKey}`,
                 keyMap: keyMap,
                 parentKeyMapId: keyMapId
             });
@@ -73,7 +86,7 @@ function recAddKeys({ object, key, keyMap, parentKeyMapId }) {
             recArray({
                 array: object[nextKey],
                 nextKey,
-                key,
+                key: storedKey,
                 keyMap,
                 keyMapId
             });
@@ -81,7 +94,7 @@ function recAddKeys({ object, key, keyMap, parentKeyMapId }) {
     });
 }
 function addKeys({ components, context }) {
-    const keyMapId = makeId(true);
+    const keyMapId = makeId.next();
     recAddKeys({
         object: components,
         key: 'root',

package/dist/build/buildApi/validateStepReferences.js

@@ -14,7 +14,6 @@
   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
@@ -55,11 +54,11 @@ function validateStepReferences({ endpoint, context }) {
     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({
+        context.logger.configWarning({
             message,
             configKey,
-            context
-        }));
+            prodError: true
+        });
     });
 }
 export default validateStepReferences;

package/dist/build/buildAuth/buildAuth.js

@@ -20,7 +20,8 @@ import validateAuthConfig from './validateAuthConfig.js';
 function buildAuth({ components, context }) {
     const configured = !type.isNone(components.auth);
     validateAuthConfig({
-        components
+        components,
+        context
     });
     components.auth.configured = configured;
     buildApiAuth({

package/dist/build/buildAuth/buildAuthPlugins.js

@@ -13,31 +13,31 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-import formatConfigError from '../../utils/formatConfigError.js';
+import { ConfigError } from '@lowdefy/node-utils';
 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(formatConfigError({
+                throw new ConfigError({
                     message: `Auth ${typeClass} id missing.`,
                     configKey,
                     context
-                }));
+                });
             }
             if (!type.isString(plugin.id)) {
-                throw new Error(formatConfigError({
+                throw new ConfigError({
                     message: `Auth ${typeClass} id is not a string. Received ${JSON.stringify(plugin.id)}.`,
                     configKey,
                     context
-                }));
+                });
             }
             if (!type.isString(plugin.type)) {
-                throw new Error(formatConfigError({
+                throw new ConfigError({
                     message: `Auth ${typeClass} type is not a string at ${typeClass} "${plugin.id}". Received ${JSON.stringify(plugin.type)}.`,
                     configKey,
                     context
-                }));
+                });
             }
             counter.increment(plugin.type, plugin['~k']);
         });
@@ -50,25 +50,25 @@ function buildAdapter({ components, context }) {
     }
     const configKey = adapter['~k'];
     if (type.isUndefined(adapter.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: 'Auth adapter id missing.',
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(adapter.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Auth adapter id is not a string. Received ${JSON.stringify(adapter.id)}.`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(adapter.type)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             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, adapter['~k']);
 }

package/dist/build/buildAuth/validateAuthConfig.js

@@ -14,20 +14,19 @@
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
 import { validate } from '@lowdefy/ajv';
+import { ConfigError } from '@lowdefy/node-utils';
 import lowdefySchema from '../../lowdefySchema.js';
-import formatConfigError from '../../utils/formatConfigError.js';
 import validateMutualExclusivity from './validateMutualExclusivity.js';
-async function validateAuthConfig({ components, context }) {
+function validateAuthConfig({ components, context }) {
     if (type.isNone(components.auth)) {
         components.auth = {};
     }
     if (!type.isObject(components.auth)) {
-        const configKey = components.auth?.['~k'];
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: 'lowdefy.auth is not an object.',
-            configKey,
+            configKey: components['~k'],
             context
-        }));
+        });
     }
     if (type.isNone(components.auth.api)) {
         components.auth.api = {};
@@ -59,10 +58,35 @@ async function validateAuthConfig({ components, context }) {
     if (type.isNone(components.auth.theme)) {
         components.auth.theme = {};
     }
-    validate({
+    const { valid, errors } = validate({
         schema: lowdefySchema.definitions.authConfig,
-        data: components.auth
+        data: components.auth,
+        returnErrors: true
     });
+    if (!valid) {
+        errors.forEach((error)=>{
+            // Try to get configKey from the item in the error path
+            const instancePath = error.instancePath.split('/').filter(Boolean);
+            let configKey = components.auth['~k'];
+            let currentData = components.auth;
+            for (const part of instancePath){
+                if (type.isArray(currentData)) {
+                    const index = parseInt(part, 10);
+                    currentData = currentData[index];
+                } else {
+                    currentData = currentData?.[part];
+                }
+                if (currentData?.['~k']) {
+                    configKey = currentData['~k'];
+                }
+            }
+            throw new ConfigError({
+                message: `Auth ${error.message}.`,
+                configKey,
+                context
+            });
+        });
+    }
     validateMutualExclusivity({
         components,
         context,
@@ -73,6 +97,14 @@ async function validateAuthConfig({ components, context }) {
         context,
         entity: 'pages'
     });
+    // Validate NEXTAUTH_SECRET is set when auth providers are configured
+    if (components.auth.providers.length > 0 && type.isNone(process.env.NEXTAUTH_SECRET)) {
+        throw new ConfigError({
+            message: 'Auth providers are configured but NEXTAUTH_SECRET environment variable is not set. ' + 'Set NEXTAUTH_SECRET to a secure random string (e.g., generate with `openssl rand -base64 32`).',
+            configKey: components.auth.providers['~k'] ?? components.auth['~k'],
+            context
+        });
+    }
     return components;
 }
 export default validateAuthConfig;

package/dist/build/buildAuth/validateMutualExclusivity.js

@@ -13,29 +13,29 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-import formatConfigError from '../../utils/formatConfigError.js';
+import { ConfigError } from '@lowdefy/node-utils';
 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(formatConfigError({
+        throw new ConfigError({
             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(formatConfigError({
+        throw new ConfigError({
             message: `Protected ${entity} can not be set to false.`,
             configKey,
             context
-        }));
+        });
     }
     if (components.auth[entity].public === false) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Public ${entity} can not be set to false.`,
             configKey,
             context
-        }));
+        });
     }
 }
 export default validateMutualExclusivity;

package/dist/build/buildConnections.js

@@ -12,54 +12,35 @@
   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 collectConfigError from '../utils/collectConfigError.js';
-import countOperators from '../utils/countOperators.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();
+    // Schema validates: id required, id is string, type is string
+    // Only check for duplicates here (schema can't do that)
     const checkDuplicateConnectionId = createCheckDuplicateId({
         message: 'Duplicate connectionId "{{ id }}".',
         context
     });
-    if (type.isArray(components.connections)) {
-        components.connections.forEach((connection)=>{
-            const configKey = connection['~k'];
-            if (type.isUndefined(connection.id)) {
-                collectConfigError({
-                    message: 'Connection id missing.',
-                    configKey,
-                    context
-                });
-            }
-            if (!type.isString(connection.id)) {
-                collectConfigError({
-                    message: `Connection id is not a string. Received ${JSON.stringify(connection.id)}.`,
-                    configKey,
-                    context
-                });
-            }
-            checkDuplicateConnectionId({
-                id: connection.id,
-                configKey
-            });
-            if (!type.isString(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, connection['~k']);
-            connection.connectionId = connection.id;
-            context.connectionIds.add(connection.connectionId);
-            connection.id = `connection:${connection.id}`;
-            countOperators(connection.properties || {}, {
-                counter: context.typeCounters.operators.server
-            });
+    (components.connections ?? []).forEach((connection)=>{
+        const configKey = connection['~k'];
+        // Check duplicates (schema can't validate this)
+        checkDuplicateConnectionId({
+            id: connection.id,
+            configKey
         });
-    }
+        // Track type usage for buildTypes validation
+        context.typeCounters.connections.increment(connection.type, configKey);
+        // Store connectionId for request validation and rename id
+        connection.connectionId = connection.id;
+        context.connectionIds.add(connection.connectionId);
+        connection.id = `connection:${connection.id}`;
+        // Count operators in connection properties
+        countOperators(connection.properties ?? {}, {
+            counter: context.typeCounters.operators.server
+        });
+    });
     return components;
 }
 export default buildConnections;

package/dist/build/buildMenu.js

@@ -12,9 +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, resolveConfigLocation } from '@lowdefy/helpers';
+*/ import { type } from '@lowdefy/helpers';
+import { ConfigError, resolveConfigLocation } from '@lowdefy/node-utils';
 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 : [];
@@ -96,18 +96,18 @@ function buildMenu({ components, context }) {
     components.menus.forEach((menu)=>{
         const configKey = menu['~k'];
         if (type.isUndefined(menu.id)) {
-            throw new Error(formatConfigError({
+            throw new ConfigError({
                 message: 'Menu id missing.',
                 configKey,
                 context
-            }));
+            });
         }
         if (!type.isString(menu.id)) {
-            throw new Error(formatConfigError({
+            throw new ConfigError({
                 message: `Menu id is not a string. Received ${JSON.stringify(menu.id)}.`,
                 configKey,
                 context
-            }));
+            });
         }
         checkDuplicateMenuId({
             id: menu.id,
@@ -129,16 +129,11 @@ function buildMenu({ components, context }) {
         });
     });
     missingPageWarnings.forEach((warning)=>{
-        const location = resolveConfigLocation({
+        context.logger.configWarning({
+            message: `Page "${warning.pageId}" referenced in menu link "${warning.menuItemId}" not found.`,
             configKey: warning.configKey,
-            keyMap: context.keyMap,
-            refMap: context.refMap,
-            configDirectory: context.directories.config
+            prodError: true
         });
-        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;
 }

package/dist/build/buildPages/buildBlock/buildEvents.js

@@ -13,23 +13,23 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 import createCheckDuplicateId from '../../../utils/createCheckDuplicateId.js';
-import formatConfigError from '../../../utils/formatConfigError.js';
 function checkAction(action, { blockId, checkDuplicateActionId, context, eventId, linkActionRefs, pageId, requestActionRefs, typeCounters }) {
     const configKey = action['~k'];
     if (type.isUndefined(action.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Action id missing on event "${eventId}" on block "${blockId}" on page "${pageId}".`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(action.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Action id is not a string on event "${eventId}" on block "${blockId}" on page "${pageId}". Received ${JSON.stringify(action.id)}.`,
             configKey,
             context
-        }));
+        });
     }
     checkDuplicateActionId({
         id: action.id,
@@ -39,11 +39,11 @@ function checkAction(action, { blockId, checkDuplicateActionId, context, eventId
         pageId
     });
     if (!type.isString(action.type)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Action type is not a string on action "${action.id}" on event "${eventId}" on block "${blockId}" on page "${pageId}". Received ${JSON.stringify(action.type)}.`,
             configKey,
             context
-        }));
+        });
     }
     typeCounters.actions.increment(action.type, configKey);
     // Collect static Request action references for validation
@@ -98,11 +98,11 @@ function buildEvents(block, pageContext) {
         Object.keys(block.events).map((key)=>{
             const eventConfigKey = block.events[key]?.['~k'] || block['~k'];
             if (!type.isArray(block.events[key]) && !type.isObject(block.events[key]) || type.isObject(block.events[key]) && type.isNone(block.events[key].try)) {
-                throw new Error(formatConfigError({
+                throw new ConfigError({
                     message: `Actions must be an array at "${block.blockId}" in event "${key}" on page "${pageContext.pageId}". Received ${JSON.stringify(block.events[key]?.try)}`,
                     configKey: eventConfigKey,
                     context
-                }));
+                });
             }
             if (type.isArray(block.events[key])) {
                 block.events[key] = {
@@ -111,21 +111,21 @@ function buildEvents(block, pageContext) {
                 };
             }
             if (!type.isArray(block.events[key].try)) {
-                throw new Error(formatConfigError({
+                throw new ConfigError({
                     message: `Try actions must be an array at "${block.blockId}" in event "${key}.try" on page "${pageContext.pageId}". Received ${JSON.stringify(block.events[key].try)}`,
                     configKey: eventConfigKey,
                     context
-                }));
+                });
             }
             if (type.isNone(block.events[key].catch)) {
                 block.events[key].catch = [];
             }
             if (!type.isArray(block.events[key].catch)) {
-                throw new Error(formatConfigError({
+                throw new ConfigError({
                     message: `Catch actions must be an array at "${block.blockId}" in event "${key}.catch" on page "${pageContext.pageId}". Received ${JSON.stringify(block.events[key].catch)}`,
                     configKey: eventConfigKey,
                     context
-                }));
+                });
             }
             const checkDuplicateActionId = createCheckDuplicateId({
                 message: 'Duplicate actionId "{{ id }}" on event "{{ eventId }}" on block "{{ blockId }}" on page "{{ pageId }}".',

package/dist/build/buildPages/buildBlock/buildRequests.js

@@ -13,23 +13,23 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-import formatConfigError from '../../../utils/formatConfigError.js';
+import { ConfigError } from '@lowdefy/node-utils';
 function buildRequest(request, pageContext) {
     const { auth, checkDuplicateRequestId, context, pageId, typeCounters } = pageContext;
     const configKey = request['~k'];
     if (type.isUndefined(request.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Request id missing at page "${pageId}".`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(request.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Request id is not a string at page "${pageId}". Received ${JSON.stringify(request.id)}.`,
             configKey,
             context
-        }));
+        });
     }
     checkDuplicateRequestId({
         id: request.id,
@@ -37,44 +37,44 @@ function buildRequest(request, pageContext) {
         pageId
     });
     if (request.id.includes('.')) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Request id "${request.id}" at page "${pageId}" should not include a period (".").`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(request.type)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Request type is not a string at request "${request.id}" at page "${pageId}". Received ${JSON.stringify(request.type)}.`,
             configKey,
             context
-        }));
+        });
     }
     typeCounters.requests.increment(request.type, configKey);
     // Validate connectionId references an existing connection
     if (!type.isNone(request.connectionId)) {
         if (!type.isString(request.connectionId)) {
-            throw new Error(formatConfigError({
+            throw new ConfigError({
                 message: `Request "${request.id}" at page "${pageId}" connectionId is not a string. Received ${JSON.stringify(request.connectionId)}.`,
                 configKey,
                 context
-            }));
+            });
         }
         if (!context.connectionIds.has(request.connectionId)) {
-            throw new Error(formatConfigError({
+            throw new ConfigError({
                 message: `Request "${request.id}" at page "${pageId}" references non-existent connection "${request.connectionId}".`,
                 configKey,
                 context
-            }));
+            });
         }
     }
     if (type.isUndefined(request.payload)) request.payload = {};
     if (!type.isObject(request.payload)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Request "${request.id}" at page "${pageId}" payload should be an object.`,
             configKey,
             context
-        }));
+        });
     }
     request.auth = auth;
     request.requestId = request.id;

package/dist/build/buildPages/buildBlock/validateBlock.js

@@ -13,51 +13,51 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-import formatConfigError from '../../../utils/formatConfigError.js';
+import { ConfigError } from '@lowdefy/node-utils';
 function validateBlock(block, { pageId, context }) {
     const configKey = block?.['~k'];
     if (!type.isObject(block)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Expected block to be an object on page "${pageId}". Received ${JSON.stringify(block)}.`,
             configKey,
             context
-        }));
+        });
     }
     if (type.isUndefined(block.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Block id missing at page "${pageId}".`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(block.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Block id is not a string at page "${pageId}". Received ${JSON.stringify(block.id)}.`,
             configKey,
             context
-        }));
+        });
     }
     if (type.isNone(block.type)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Block type is not defined at "${block.id}" on page "${pageId}".`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(block.type)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Block type is not a string at "${block.id}" on page "${pageId}". Received ${JSON.stringify(block.type)}.`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isNone(block.requests)) {
         if (!type.isArray(block.requests)) {
-            throw new Error(formatConfigError({
+            throw new ConfigError({
                 message: `Requests is not an array at "${block.id}" on page "${pageId}". Received ${JSON.stringify(block.requests)}`,
                 configKey,
                 context
-            }));
+            });
         }
     }
 }