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

package/dist/index.js

@@ -1,4 +1,4 @@
-/*
+/* eslint-disable no-console */ /*
   Copyright 2020-2024 Lowdefy, Inc
 
   Licensed under the Apache License, Version 2.0 (the "License");
@@ -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 createBuildProfiler from './utils/createBuildProfiler.js';
-import createContext from './createContext.js';
+*/ import createContext from './createContext.js';
 import createPluginTypesMap from './utils/createPluginTypesMap.js';
+import tryBuildStep from './utils/tryBuildStep.js';
 import addDefaultPages from './build/addDefaultPages/addDefaultPages.js';
 import addKeys from './build/addKeys.js';
 import buildApp from './build/buildApp.js';
@@ -23,6 +23,7 @@ import buildConnections from './build/buildConnections.js';
 import buildApi from './build/buildApi/buildApi.js';
 import buildImports from './build/buildImports/buildImports.js';
 import buildJs from './build/buildJs/buildJs.js';
+import buildLogger from './build/buildLogger.js';
 import buildMenu from './build/buildMenu.js';
 import buildPages from './build/buildPages/buildPages.js';
 import buildRefs from './build/buildRefs/buildRefs.js';
@@ -39,6 +40,7 @@ import writeConnections from './build/writeConnections.js';
 import writeApi from './build/writeApi.js';
 import writeGlobal from './build/writeGlobal.js';
 import writeJs from './build/buildJs/writeJs.js';
+import writeLogger from './build/writeLogger.js';
 import writeMaps from './build/writeMaps.js';
 import writeMenus from './build/writeMenus.js';
 import writePages from './build/writePages.js';
@@ -47,128 +49,139 @@ import writeRequests from './build/writeRequests.js';
 import writeTypes from './build/writeTypes.js';
 async function build(options) {
     const context = createContext(options);
-    const { time, printSummary } = createBuildProfiler({
-        logger: context.logger
-    });
-    const components = await time('buildRefs', ()=>buildRefs({
-            context
-        }));
-    await time('testSchema', ()=>testSchema({
-            components,
-            context
-        }));
-    await time('buildApp', ()=>buildApp({
-            components,
-            context
-        }));
-    await time('validateConfig', ()=>validateConfig({
-            components,
-            context
-        }));
-    await time('addDefaultPages', ()=>addDefaultPages({
-            components,
-            context
-        }));
-    await time('buildAuth', ()=>buildAuth({
-            components,
-            context
-        }));
-    await time('buildConnections', ()=>buildConnections({
-            components,
-            context
-        }));
-    await time('buildApi', ()=>buildApi({
-            components,
-            context
-        }));
-    await time('buildPages', ()=>buildPages({
-            components,
-            context
-        }));
-    await time('buildMenu', ()=>buildMenu({
-            components,
-            context
-        }));
-    await time('buildJs', ()=>buildJs({
-            components,
-            context
-        }));
-    await time('addKeys', ()=>addKeys({
-            components,
-            context
-        }));
-    await time('buildTypes', ()=>buildTypes({
-            components,
-            context
-        }));
-    await time('buildImports', ()=>buildImports({
-            components,
-            context
-        }));
-    await time('cleanBuildDirectory', ()=>cleanBuildDirectory({
-            context
-        }));
-    await time('writeApp', ()=>writeApp({
-            components,
-            context
-        }));
-    await time('writeAuth', ()=>writeAuth({
-            components,
-            context
-        }));
-    await time('writeConnections', ()=>writeConnections({
-            components,
-            context
-        }));
-    await time('writeApi', ()=>writeApi({
-            components,
-            context
-        }));
-    await time('writeRequests', ()=>writeRequests({
-            components,
-            context
-        }));
-    await time('writePages', ()=>writePages({
-            components,
-            context
-        }));
-    await time('writeConfig', ()=>writeConfig({
-            components,
-            context
-        }));
-    await time('writeGlobal', ()=>writeGlobal({
-            components,
-            context
-        }));
-    await time('writeMaps', ()=>writeMaps({
-            components,
-            context
-        }));
-    await time('writeMenus', ()=>writeMenus({
-            components,
-            context
-        }));
-    await time('writeTypes', ()=>writeTypes({
-            components,
-            context
-        }));
-    await time('writePluginImports', ()=>writePluginImports({
-            components,
-            context
-        }));
-    await time('writeJs', ()=>writeJs({
-            components,
-            context
-        }));
-    await time('updateServerPackageJson', ()=>updateServerPackageJson({
-            components,
-            context
-        }));
-    await time('copyPublicFolder', ()=>copyPublicFolder({
-            components,
-            context
-        }));
-    printSummary();
+    const components = await buildRefs({
+        context
+    });
+    // Build steps - collect all errors before stopping
+    tryBuildStep(testSchema, 'testSchema', {
+        components,
+        context
+    });
+    tryBuildStep(buildApp, 'buildApp', {
+        components,
+        context
+    });
+    tryBuildStep(buildLogger, 'buildLogger', {
+        components,
+        context
+    });
+    tryBuildStep(validateConfig, 'validateConfig', {
+        components,
+        context
+    });
+    tryBuildStep(addDefaultPages, 'addDefaultPages', {
+        components,
+        context
+    });
+    tryBuildStep(addKeys, 'addKeys', {
+        components,
+        context
+    });
+    tryBuildStep(buildAuth, 'buildAuth', {
+        components,
+        context
+    });
+    tryBuildStep(buildConnections, 'buildConnections', {
+        components,
+        context
+    });
+    tryBuildStep(buildApi, 'buildApi', {
+        components,
+        context
+    });
+    tryBuildStep(buildPages, 'buildPages', {
+        components,
+        context
+    });
+    tryBuildStep(buildMenu, 'buildMenu', {
+        components,
+        context
+    });
+    tryBuildStep(buildJs, 'buildJs', {
+        components,
+        context
+    });
+    tryBuildStep(buildTypes, 'buildTypes', {
+        components,
+        context
+    });
+    tryBuildStep(buildImports, 'buildImports', {
+        components,
+        context
+    });
+    // Check if there are any collected errors before writing
+    if (context.errors.length > 0) {
+        context.logger.error(`\nBuild failed with ${context.errors.length} error(s):\n`);
+        throw new Error(`Build failed with ${context.errors.length} error(s). See above for details.`);
+    }
+    // Write steps - only if no errors
+    await cleanBuildDirectory({
+        context
+    });
+    await writeApp({
+        components,
+        context
+    });
+    await writeAuth({
+        components,
+        context
+    });
+    await writeConnections({
+        components,
+        context
+    });
+    await writeApi({
+        components,
+        context
+    });
+    await writeRequests({
+        components,
+        context
+    });
+    await writePages({
+        components,
+        context
+    });
+    await writeConfig({
+        components,
+        context
+    });
+    await writeGlobal({
+        components,
+        context
+    });
+    await writeLogger({
+        components,
+        context
+    });
+    await writeMaps({
+        components,
+        context
+    });
+    await writeMenus({
+        components,
+        context
+    });
+    await writeTypes({
+        components,
+        context
+    });
+    await writePluginImports({
+        components,
+        context
+    });
+    await writeJs({
+        components,
+        context
+    });
+    await updateServerPackageJson({
+        components,
+        context
+    });
+    await copyPublicFolder({
+        components,
+        context
+    });
 }
 export { createPluginTypesMap };
 export default build;

package/dist/lowdefySchema.js

@@ -967,6 +967,81 @@ export default {
             errorMessage: {
                 type: 'App "pages" should be an array.'
             }
+        },
+        logger: {
+            type: 'object',
+            additionalProperties: false,
+            errorMessage: {
+                type: 'App "logger" should be an object.'
+            },
+            properties: {
+                sentry: {
+                    type: 'object',
+                    additionalProperties: false,
+                    errorMessage: {
+                        type: 'App "logger.sentry" should be an object.'
+                    },
+                    properties: {
+                        client: {
+                            type: 'boolean',
+                            errorMessage: {
+                                type: 'App "logger.sentry.client" should be a boolean.'
+                            }
+                        },
+                        server: {
+                            type: 'boolean',
+                            errorMessage: {
+                                type: 'App "logger.sentry.server" should be a boolean.'
+                            }
+                        },
+                        tracesSampleRate: {
+                            type: 'number',
+                            minimum: 0,
+                            maximum: 1,
+                            errorMessage: {
+                                type: 'App "logger.sentry.tracesSampleRate" should be a number between 0 and 1.'
+                            }
+                        },
+                        replaysSessionSampleRate: {
+                            type: 'number',
+                            minimum: 0,
+                            maximum: 1,
+                            errorMessage: {
+                                type: 'App "logger.sentry.replaysSessionSampleRate" should be a number between 0 and 1.'
+                            }
+                        },
+                        replaysOnErrorSampleRate: {
+                            type: 'number',
+                            minimum: 0,
+                            maximum: 1,
+                            errorMessage: {
+                                type: 'App "logger.sentry.replaysOnErrorSampleRate" should be a number between 0 and 1.'
+                            }
+                        },
+                        feedback: {
+                            type: 'boolean',
+                            errorMessage: {
+                                type: 'App "logger.sentry.feedback" should be a boolean.'
+                            }
+                        },
+                        environment: {
+                            type: 'string',
+                            errorMessage: {
+                                type: 'App "logger.sentry.environment" should be a string.'
+                            }
+                        },
+                        userFields: {
+                            type: 'array',
+                            items: {
+                                type: 'string'
+                            },
+                            errorMessage: {
+                                type: 'App "logger.sentry.userFields" should be an array of strings.'
+                            }
+                        }
+                    }
+                }
+            }
         }
     },
     errorMessage: {

package/dist/test/testContext.js

@@ -47,7 +47,8 @@ function testContext({ writeBuildArtifact, configDirectory, readConfigFile, logg
         readConfigFile: readConfigFile || (()=>{}),
         refMap: {},
         keyMap: {},
-        jsMap: {}
+        jsMap: {},
+        connectionIds: new Set()
     };
     context.logger = {
         ...defaultLogger,

package/dist/utils/collectConfigError.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.
+*/ import formatConfigError from './formatConfigError.js';
+/**
+ * Collects a config error instead of throwing immediately.
+ * Allows the build to continue and collect all errors before stopping.
+ *
+ * @param {Object} params
+ * @param {string} params.message - Error message
+ * @param {string} params.configKey - Config key (~k) for location tracking
+ * @param {Object} params.context - Build context
+ */ function collectConfigError({ message, configKey, context }) {
+    const errorMessage = formatConfigError({
+        message,
+        configKey,
+        context
+    });
+    if (!context.errors) {
+        // If no error collection array, throw immediately (fallback for tests)
+        throw new Error(errorMessage);
+    }
+    // Collect error to show all errors at once
+    context.errors.push(errorMessage);
+    if (context.logger && context.logger.error) {
+        context.logger.error(errorMessage);
+    }
+}
+export default collectConfigError;

package/dist/utils/countOperators.js

@@ -13,18 +13,31 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-function countOperators(obj, { counter }) {
-    function getOperatorsReviver(_, value) {
-        if (type.isObject(value) && Object.keys(value).length === 1) {
-            const key = Object.keys(value)[0];
-            const [op] = key.split('.');
-            const operator = op.replace(/^(_+)/gm, '_');
-            if (operator.length > 1 && operator[0] === '_') {
-                counter.increment(operator);
-            }
+function walkAndCount(value, counter, parentConfigKey) {
+    if (type.isArray(value)) {
+        value.forEach((item)=>walkAndCount(item, counter, parentConfigKey));
+        return;
+    }
+    if (!type.isObject(value)) {
+        return;
+    }
+    const configKey = value['~k'] || parentConfigKey;
+    const keys = Object.keys(value);
+    // Check if this object is an operator (single key starting with _)
+    if (keys.length === 1) {
+        const key = keys[0];
+        const [op] = key.split('.');
+        const operator = op.replace(/^(_+)/gm, '_');
+        if (operator.length > 1 && operator[0] === '_') {
+            counter.increment(operator, configKey);
         }
-        return value;
     }
-    JSON.parse(JSON.stringify(obj), getOperatorsReviver);
+    // Recurse into all values
+    keys.forEach((key)=>{
+        walkAndCount(value[key], counter, configKey);
+    });
+}
+function countOperators(obj, { counter }) {
+    walkAndCount(obj, counter, null);
 }
 export default countOperators;

package/dist/utils/createCheckDuplicateId.js

@@ -13,17 +13,38 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { nunjucksFunction } from '@lowdefy/nunjucks';
-function createCheckDuplicateId({ message }) {
+import { resolveConfigLocation } from '@lowdefy/helpers';
+function createCheckDuplicateId({ message, context }) {
     const template = nunjucksFunction(message);
     const ids = new Set();
-    function checkDuplicateId({ id, blockId, eventId, menuId, pageId }) {
-        if (ids.has(id.toLowerCase())) throw new Error(template({
-            id,
-            blockId,
-            eventId,
-            menuId,
-            pageId
-        }));
+    function checkDuplicateId({ id, blockId, configKey, eventId, menuId, pageId }) {
+        if (ids.has(id.toLowerCase())) {
+            let errorMessage = template({
+                id,
+                blockId,
+                eventId,
+                menuId,
+                pageId
+            });
+            if (configKey && context) {
+                const location = resolveConfigLocation({
+                    configKey,
+                    keyMap: context.keyMap,
+                    refMap: context.refMap,
+                    configDirectory: context.directories.config
+                });
+                if (location) {
+                    const source = location.source ? `${location.source} at ${location.config}` : '';
+                    const link = location.link || '';
+                    errorMessage = `[Config Error] ${errorMessage}\n  ${source}\n  ${link}`;
+                } else {
+                    errorMessage = `[Config Error] ${errorMessage}`;
+                }
+            } else {
+                errorMessage = `[Config Error] ${errorMessage}`;
+            }
+            throw new Error(errorMessage);
+        }
         ids.add(id.toLowerCase());
     }
     return checkDuplicateId;

package/dist/utils/createCounter.js

@@ -14,9 +14,14 @@
   limitations under the License.
 */ function createCounter() {
     const counts = new Map();
-    function increment(key) {
+    const locations = new Map();
+    function increment(key, configKey) {
         const count = counts.get(key) || 0;
         counts.set(key, count + 1);
+        // Store first occurrence location for error reporting
+        if (configKey && !locations.has(key)) {
+            locations.set(key, configKey);
+        }
     }
     function getCount(key) {
         return counts.get(key) || 0;
@@ -24,10 +29,18 @@
     function getCounts() {
         return Object.fromEntries(counts);
     }
+    function getLocation(key) {
+        return locations.get(key) || null;
+    }
+    function getLocations() {
+        return Object.fromEntries(locations);
+    }
     return {
         increment,
         getCount,
-        getCounts
+        getCounts,
+        getLocation,
+        getLocations
     };
 }
 export default createCounter;

package/dist/utils/extractOperatorKey.js

@@ -0,0 +1,36 @@
+/*
+  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';
+/**
+ * Extracts the top-level key from an operator reference value.
+ *
+ * Handles both string and object forms of operator references:
+ * - String: "_state: 'user.name'" -> 'user'
+ * - Object: "_state: { key: 'user.name' }" -> 'user'
+ * - Object: "_state: { path: 'user[0].name' }" -> 'user'
+ *
+ * @param {Object} params
+ * @param {string|Object} params.operatorValue - The value of the operator (e.g., obj._state)
+ * @returns {string|null} The top-level key, or null if not extractable
+ */ function extractOperatorKey({ operatorValue }) {
+    const value = type.isString(operatorValue) ? operatorValue : type.isObject(operatorValue) ? operatorValue.key || operatorValue.path : null;
+    if (!value) {
+        return null;
+    }
+    // Extract first segment before any '.' or '['
+    const topLevelKey = value.split(/[.[]/)[0];
+    return topLevelKey || null;
+}
+export default extractOperatorKey;

package/dist/utils/findSimilarString.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.
+*/ function levenshteinDistance(a, b) {
+    const matrix = [];
+    for(let i = 0; i <= b.length; i++){
+        matrix[i] = [
+            i
+        ];
+    }
+    for(let j = 0; j <= a.length; j++){
+        matrix[0][j] = j;
+    }
+    for(let i = 1; i <= b.length; i++){
+        for(let j = 1; j <= a.length; j++){
+            if (b[i - 1] === a[j - 1]) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            } else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+function findSimilarString({ input, candidates, maxDistance = 3 }) {
+    if (!input || !candidates || candidates.length === 0) {
+        return null;
+    }
+    const inputLower = input.toLowerCase();
+    let bestMatch = null;
+    let bestDistance = Infinity;
+    for (const candidate of candidates){
+        const candidateLower = candidate.toLowerCase();
+        const distance = levenshteinDistance(inputLower, candidateLower);
+        if (distance < bestDistance && distance <= maxDistance) {
+            bestDistance = distance;
+            bestMatch = candidate;
+        }
+    }
+    return bestMatch;
+}
+export default findSimilarString;