@lowdefy/build 5.1.0 → 5.2.0

package/dist/build/registerModules.js

@@ -0,0 +1,242 @@
+/*
+  Copyright 2020-2026 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 path from 'path';
+import semver from 'semver';
+import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
+import operators from '@lowdefy/operators-js/operators/build';
+import { resolve, WalkContext } from './buildRefs/walker.js';
+import getRefContent from './buildRefs/getRefContent.js';
+import makeRefDefinition from './buildRefs/makeRefDefinition.js';
+import evaluateStaticOperators from './buildRefs/evaluateStaticOperators.js';
+import collectDynamicIdentifiers from './collectDynamicIdentifiers.js';
+import validateOperatorsDynamic from './validateOperatorsDynamic.js';
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
+function validateRequiredVars(varDefs, consumerVars, entryId, source, prefix = '') {
+    for (const [varName, varDef] of Object.entries(varDefs)){
+        const fullName = prefix ? `${prefix}.${varName}` : varName;
+        if (varDef.properties) {
+            if (!type.isNone(consumerVars[varName]) && !type.isObject(consumerVars[varName])) {
+                throw new ConfigError(`Module "${entryId}" (${source}) var "${fullName}" must be type "object" ` + `(has properties) but got "${type.typeOf(consumerVars[varName])}".`);
+            }
+            const consumerObj = type.isObject(consumerVars[varName]) ? consumerVars[varName] : {};
+            for (const key of Object.keys(consumerObj)){
+                if (!varDef.properties[key]) {
+                    throw new ConfigError(`Module "${entryId}" (${source}) var "${fullName}" has undeclared ` + `property "${key}". Declared properties: ${Object.keys(varDef.properties).join(', ')}.`);
+                }
+            }
+            validateRequiredVars(varDef.properties, consumerObj, entryId, source, fullName);
+        } else if (varDef.required && type.isUndefined(varDef.default) && type.isNone(consumerVars[varName])) {
+            throw new ConfigError(`Module "${entryId}" (${source}) requires var "${fullName}"` + (varDef.description ? `\n  - ${varDef.description}` : '') + `\n  - Define it in lowdefy.yaml under modules[id=${entryId}].vars.${fullName}`);
+        }
+    }
+}
+function validateVarTypes(varDefs, resolvedVarCache, entryId, source, prefix = '') {
+    for (const [varName, varDef] of Object.entries(varDefs)){
+        const fullName = prefix ? `${prefix}.${varName}` : varName;
+        const value = resolvedVarCache[fullName];
+        if (varDef.type && !type.isNone(value)) {
+            if (type.typeOf(value) !== varDef.type) {
+                throw new ConfigError(`Module "${entryId}" (${source}) var "${fullName}" must be type ` + `"${varDef.type}" but got "${type.typeOf(value)}".` + (varDef.description ? `\n  - ${varDef.description}` : ''));
+            }
+        }
+        if (varDef.properties) {
+            validateVarTypes(varDef.properties, resolvedVarCache, entryId, source, fullName);
+        }
+    }
+}
+async function resolveLocalManifest({ entry, resolvedPaths, context }) {
+    if (!entry.id || !type.isString(entry.id)) {
+        throw new ConfigError("Module entry 'id' is required and must be a string.");
+    }
+    if (entry.id.includes('/')) {
+        throw new ConfigError(`Module entry id "${entry.id}" must not contain '/'. ` + `Use a flat identifier like "team-users".`);
+    }
+    if (entry.id === '__proto__' || entry.id === 'constructor' || entry.id === 'prototype') {
+        throw new ConfigError(`Module entry id "${entry.id}" is a reserved name.`);
+    }
+    if (!entry.source || !type.isString(entry.source)) {
+        throw new ConfigError(`Module entry "${entry.id}": 'source' is required and must be a string.`);
+    }
+    if (Object.hasOwn(context.modules, entry.id)) {
+        throw new ConfigError(`Duplicate module entry id "${entry.id}".`);
+    }
+    const { packageRoot, moduleRoot, isLocal } = resolvedPaths;
+    const moduleYamlPath = path.join(moduleRoot, 'module.lowdefy.yaml');
+    // Use makeRefDefinition + getRefContent to read and parse module.lowdefy.yaml.
+    // The absolute path works because path.resolve(configDir, absolutePath) = absolutePath.
+    const refDef = makeRefDefinition(moduleYamlPath, null, context.refMap);
+    const content = await getRefContent({
+        context,
+        refDef,
+        referencedFrom: null
+    });
+    // Run walker with shouldStop preserving content that may contain cross-module refs
+    const ctx = new WalkContext({
+        buildContext: context,
+        refId: refDef.id,
+        sourceRefId: null,
+        vars: {},
+        moduleRoot,
+        packageRoot,
+        path: '',
+        currentFile: moduleYamlPath,
+        refChain: new Set(refDef.path ? [
+            refDef.path
+        ] : []),
+        operators,
+        env: process.env,
+        dynamicIdentifiers,
+        shouldStop: (childPath)=>{
+            if (/^vars(\.[^.]+\.properties)*\.[^.]+\.default(\..*)?$/.test(childPath)) return 'preserve';
+            if (/^components\.\d+\.component$/.test(childPath)) return 'preserve';
+            if (/^pages(\..*)?$/.test(childPath)) return 'preserve';
+            if (/^api(\..*)?$/.test(childPath)) return 'preserve';
+            if (/^connections(\..*)?$/.test(childPath)) return 'preserve';
+            if (/^menus\.\d+\.links$/.test(childPath)) return 'preserve';
+            return false;
+        }
+    });
+    const manifest = await resolve(content, ctx);
+    // Parse dependencies array from manifest
+    const dependencies = manifest.dependencies ?? [];
+    for (const dep of dependencies){
+        if (!type.isString(dep.id)) {
+            throw new ConfigError(`Module "${entry.id}": each item in "dependencies" must have a string "id".`);
+        }
+    }
+    // Parse exports object from manifest
+    const rawExports = manifest.exports ?? {};
+    const exportSections = [
+        'pages',
+        'components',
+        'menus',
+        'connections',
+        'api'
+    ];
+    const exports = {};
+    for (const section of exportSections){
+        const items = rawExports[section] ?? [];
+        if (!type.isArray(items)) {
+            throw new ConfigError(`Module "${entry.id}": exports.${section} must be an array.`);
+        }
+        for (const item of items){
+            if (!type.isString(item.id)) {
+                throw new ConfigError(`Module "${entry.id}": each item in exports.${section} must have a string "id".`);
+            }
+        }
+        exports[section] = items;
+    }
+    // Reject unknown keys in exports
+    for (const key of Object.keys(rawExports)){
+        if (!exportSections.includes(key)) {
+            throw new ConfigError(`Module "${entry.id}": unknown exports section "${key}". ` + `Valid sections: ${exportSections.join(', ')}.`);
+        }
+    }
+    // Validate required vars without defaults (needs raw defs + consumer values only).
+    // Type validation moves to after Phase 2 because defaults are resolved lazily.
+    const varDefs = manifest.vars ?? {};
+    validateRequiredVars(varDefs, entry.vars ?? {}, entry.id, entry.source);
+    // Validate plugin dependencies against app's declared plugins
+    const requiredPlugins = manifest.plugins ?? [];
+    const appPlugins = (context.plugins ?? []).reduce((map, p)=>map.set(p.name, p.version), new Map());
+    for (const plugin of requiredPlugins){
+        if (context.defaultPackageNames.has(plugin.name)) {
+            continue;
+        }
+        const appVersion = appPlugins.get(plugin.name);
+        if (!appVersion) {
+            throw new ConfigError(`Module "${entry.id}" requires plugin "${plugin.name}" version "${plugin.version}".\n` + `Add it to your app's plugins array in lowdefy.yaml:\n\n` + `  plugins:\n` + `    - name: "${plugin.name}"\n` + `      version: "${semver.minVersion(plugin.version)}"`);
+        }
+        if (appVersion.startsWith('workspace:')) {
+            continue;
+        }
+        if (!semver.satisfies(appVersion, plugin.version)) {
+            throw new ConfigError(`Module "${entry.id}" requires plugin "${plugin.name}" version "${plugin.version}" ` + `but the app has version "${appVersion}" installed. ` + `Update the plugin to a compatible version.`);
+        }
+    }
+    context.modules[entry.id] = {
+        id: entry.id,
+        source: entry.source,
+        packageRoot,
+        moduleRoot,
+        isLocal,
+        consumerVars: entry.vars ?? {},
+        varDefs,
+        resolvedVarCache: {},
+        connections: entry.connections ?? {},
+        manifest,
+        dependencies,
+        exports,
+        moduleDependencies: entry.dependencies ?? {},
+        refDef
+    };
+}
+async function resolveFullManifest({ entryId, context }) {
+    const moduleEntry = context.modules[entryId];
+    const { manifest, packageRoot, moduleRoot, moduleDependencies, refDef } = moduleEntry;
+    const moduleYamlPath = path.join(moduleRoot, 'module.lowdefy.yaml');
+    const ctx = new WalkContext({
+        buildContext: context,
+        refId: refDef.id,
+        sourceRefId: null,
+        vars: {},
+        moduleDependencies,
+        moduleEntry,
+        moduleRoot,
+        packageRoot,
+        path: '',
+        currentFile: moduleYamlPath,
+        refChain: new Set(refDef.path ? [
+            refDef.path
+        ] : []),
+        operators,
+        env: process.env,
+        dynamicIdentifiers,
+        shouldStop: (childPath)=>{
+            if (/^vars(\.[^.]+\.properties)*\.[^.]+\.default(\..*)?$/.test(childPath)) return 'preserve';
+            if (/^components\.\d+\.component$/.test(childPath)) return 'preserve';
+            return false;
+        }
+    });
+    let resolved = await resolve(manifest, ctx);
+    resolved = evaluateStaticOperators({
+        context,
+        input: resolved,
+        refDef
+    });
+    // Filter null entries produced by _ref resolution failures
+    for (const key of [
+        'pages',
+        'connections',
+        'api'
+    ]){
+        if (type.isArray(resolved[key])) {
+            resolved[key] = resolved[key].filter((item)=>!type.isNone(item));
+        }
+    }
+    moduleEntry.manifest = resolved;
+    // Validate var types against lazily-resolved values
+    const varDefs = moduleEntry.varDefs;
+    if (Object.keys(varDefs).length > 0) {
+        validateVarTypes(varDefs, moduleEntry.resolvedVarCache, entryId, moduleEntry.source);
+    }
+}
+export { resolveLocalManifest, resolveFullManifest };

package/dist/build/resolveDepTarget.js

@@ -0,0 +1,43 @@
+/*
+  Copyright 2020-2026 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 { ConfigError } from '@lowdefy/errors';
+function resolveDepTarget({ moduleEntry, depName, context, configKey, usage }) {
+    const prefix = usage ? `${usage} ` : '';
+    // App-level: module name IS the entry ID (no dependency mapping)
+    if (!moduleEntry) {
+        const targetEntry = context.modules[depName];
+        if (!targetEntry) {
+            throw new ConfigError(`${prefix}references module "${depName}" but no module with that entry id was registered.`, {
+                configKey
+            });
+        }
+        return targetEntry;
+    }
+    const wiring = moduleEntry.moduleDependencies ?? {};
+    const targetEntryId = wiring[depName];
+    if (!targetEntryId) {
+        throw new ConfigError(`${prefix}in module "${moduleEntry.id}" references dependency "${depName}" but no mapping exists. ` + `Add dependencies.${depName} to module "${moduleEntry.id}".`, {
+            configKey
+        });
+    }
+    const targetEntry = context.modules[targetEntryId];
+    if (!targetEntry) {
+        throw new ConfigError(`${prefix}in module "${moduleEntry.id}" references dependency "${depName}" which maps to "${targetEntryId}", ` + `but no module with entry id "${targetEntryId}" was registered.`, {
+            configKey
+        });
+    }
+    return targetEntry;
+}
+export default resolveDepTarget;

package/dist/build/resolveModuleDependencies.js

@@ -0,0 +1,60 @@
+/*
+  Copyright 2020-2026 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 { ConfigError } from '@lowdefy/errors';
+import { type } from '@lowdefy/helpers';
+function resolveModuleDependencies({ context }) {
+    for (const [entryId, moduleEntry] of Object.entries(context.modules)){
+        const dependencies = moduleEntry.dependencies;
+        const wiring = moduleEntry.moduleDependencies;
+        // Auto-wire: for each declared dependency without an explicit mapping,
+        // look for a module entry whose ID matches the dependency name
+        for (const dep of dependencies){
+            if (type.isUndefined(wiring[dep.id])) {
+                if (context.modules[dep.id]) {
+                    wiring[dep.id] = dep.id;
+                }
+            }
+        }
+        // Validate the wiring
+        const declaredIds = new Set(dependencies.map((r)=>r.id));
+        // 1. Every declared dependency must be mapped (after auto-wire)
+        for (const dep of dependencies){
+            if (type.isUndefined(wiring[dep.id])) {
+                throw new ConfigError(`Module "${entryId}" declares dependency "${dep.id}" but no mapping provided ` + `and no module entry "${dep.id}" exists.` + (dep.description ? `\n  ${dep.id}: ${dep.description}` : '') + `\n  Add dependencies.${dep.id} to the "${entryId}" entry in lowdefy.yaml, ` + `or add a module entry with id "${dep.id}".`);
+            }
+        }
+        // 2. No unknown keys in the wiring map
+        for (const key of Object.keys(wiring)){
+            if (!declaredIds.has(key)) {
+                throw new ConfigError(`Module "${entryId}" does not declare dependency "${key}". ` + `Check dependencies in lowdefy.yaml.` + `\n  Declared dependencies: ${[
+                    ...declaredIds
+                ].join(', ') || '(none)'}`);
+            }
+        }
+        // 3. All target entry IDs exist
+        for (const [depName, targetEntryId] of Object.entries(wiring)){
+            if (!context.modules[targetEntryId]) {
+                throw new ConfigError(`dependencies.${depName} references "${targetEntryId}" ` + `but no module entry "${targetEntryId}" exists.`);
+            }
+        }
+        // 4. No self-referencing dependencies
+        for (const [depName, targetEntryId] of Object.entries(wiring)){
+            if (targetEntryId === entryId) {
+                throw new ConfigError(`Module "${entryId}" dependency "${depName}" maps to itself. ` + `A module cannot depend on its own entry.`);
+            }
+        }
+    }
+}
+export default resolveModuleDependencies;

package/dist/build/resolveModuleOperators.js

@@ -0,0 +1,27 @@
+/*
+  Copyright 2020-2026 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 scopeMenuItemIds(links, entryId) {
+    if (!Array.isArray(links)) return;
+    for (const item of links){
+        if (!item) continue;
+        if (item.id) {
+            item.id = `${entryId}/${item.id}`;
+        }
+        if (Array.isArray(item.links)) {
+            scopeMenuItemIds(item.links, entryId);
+        }
+    }
+}
+export { scopeMenuItemIds };

package/dist/build/testSchema.js

@@ -13,9 +13,23 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { validate } from '@lowdefy/ajv';
-import { ConfigError, shouldSuppressBuildCheck } from '@lowdefy/errors';
+import { type } from '@lowdefy/helpers';
+import { ConfigWarning, shouldSuppressBuildCheck } from '@lowdefy/errors';
 import findConfigKey from '../utils/findConfigKey.js';
 import lowdefySchema from '../lowdefySchema.js';
+function getValueAtPath(obj, pathParts) {
+    let current = obj;
+    for (const part of pathParts){
+        if (type.isNone(current)) return undefined;
+        current = type.isArray(current) ? current[parseInt(part, 10)] : current[part];
+    }
+    return current;
+}
+// Schema validation emits warnings rather than errors. Focused validations
+// in each build step (validateBlock, buildConnections, buildEvents, etc.)
+// provide better error messages with full context (pageId, blockId, etc.).
+// Schema warnings still surface useful hints like typos caught by
+// additionalProperties and property type mismatches.
 function testSchema({ components, context }) {
     const { valid, errors } = validate({
         schema: lowdefySchema,
@@ -52,20 +66,17 @@ function testSchema({ components, context }) {
             let message = error.message;
             if (error.params?.additionalProperty) {
                 message = `${message} - "${error.params.additionalProperty}"`;
-            } else if (propertyName) {
+            } else if (propertyName && error.keyword !== 'errorMessage') {
                 message = `"${propertyName}" ${message}`;
             }
-            const configError = new ConfigError(message, {
+            const received = getValueAtPath(components, instancePath);
+            const warning = new ConfigWarning(message, {
                 configKey,
-                checkSlug: 'schema'
+                checkSlug: 'schema',
+                received
             });
-            if (!shouldSuppressBuildCheck(configError, context.keyMap)) {
-                if (!context.errors) {
-                    // If no error collection array, throw immediately (fallback for tests)
-                    throw configError;
-                }
-                // Collect error object - logging happens at checkpoints in index.js
-                context.errors.push(configError);
+            if (!shouldSuppressBuildCheck(warning, context.keyMap)) {
+                context.handleWarning(warning);
             }
         });
     }

package/dist/build/writePluginImports/writeGlobalsCss.js

@@ -139,7 +139,7 @@ ${themeVars}
     await context.writeBuildArtifact('layer-order.css', '/* Generated by Lowdefy build */\n@layer theme, base, antd, components, utilities;\n');
     await context.writeBuildArtifact('tailwind-candidates.css', '/* Generated by Lowdefy build — rewritten on page changes to trigger CSS recompilation */\n');
     for (const [pageId, content] of context.tailwindContentMap ?? []){
-        await writeFile(path.join(context.directories.server, 'lowdefy-build', 'tailwind', `${pageId}.html`), '<!-- Generated by Lowdefy build -->\n' + content);
+        await writeFile(path.join(context.directories.server, 'lowdefy-build', 'tailwind', `${encodeURIComponent(pageId)}.html`), '<!-- Generated by Lowdefy build -->\n' + content);
     }
     // Collect Tailwind class candidates from block plugin JS source files.
     // Resolves from the server directory so block packages are reachable regardless

package/dist/createContext.js

@@ -18,9 +18,11 @@ import createCounter from './utils/createCounter.js';
 import createHandleWarning from './utils/createHandleWarning.js';
 import createReadConfigFile from './utils/readConfigFile.js';
 import createWriteBuildArtifact from './utils/writeBuildArtifact.js';
+import defaultPackages from './defaultPackages.js';
 import defaultTypesMap from './defaultTypesMap.js';
 function createContext({ customTypesMap, directories, logger, refResolver, stage = 'prod' }) {
     const context = {
+        defaultPackageNames: new Set(defaultPackages),
         connectionIds: new Set(),
         directories,
         errors: [],
@@ -28,6 +30,8 @@ function createContext({ customTypesMap, directories, logger, refResolver, stage
         warnings: [],
         keyMap: {},
         logger,
+        // Null prototype prevents pollution via attacker-controlled entry.id.
+        modules: Object.create(null),
         readConfigFile: createReadConfigFile({
             directories
         }),

package/dist/defaultPackages.js

@@ -0,0 +1,51 @@
+/*
+  Copyright 2020-2026 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.
+*/ const defaultPackages = [
+    '@lowdefy/actions-core',
+    '@lowdefy/actions-pdf-make',
+    '@lowdefy/blocks-aggrid',
+    '@lowdefy/blocks-antd',
+    '@lowdefy/blocks-basic',
+    '@lowdefy/blocks-diff',
+    '@lowdefy/blocks-echarts',
+    '@lowdefy/blocks-google-maps',
+    '@lowdefy/blocks-loaders',
+    '@lowdefy/blocks-markdown',
+    '@lowdefy/blocks-qr',
+    '@lowdefy/blocks-tiptap',
+    '@lowdefy/connection-axios-http',
+    '@lowdefy/connection-elasticsearch',
+    '@lowdefy/connection-test',
+    '@lowdefy/connection-google-sheets',
+    '@lowdefy/connection-knex',
+    '@lowdefy/connection-mongodb',
+    '@lowdefy/connection-redis',
+    '@lowdefy/connection-sendgrid',
+    '@lowdefy/connection-stripe',
+    '@lowdefy/operators-change-case',
+    '@lowdefy/operators-diff',
+    '@lowdefy/operators-js',
+    '@lowdefy/operators-jsonata',
+    '@lowdefy/operators-dayjs',
+    '@lowdefy/operators-mql',
+    '@lowdefy/operators-nunjucks',
+    '@lowdefy/operators-uuid',
+    '@lowdefy/operators-yaml',
+    '@lowdefy/plugin-auth0',
+    '@lowdefy/plugin-aws',
+    '@lowdefy/plugin-csv',
+    '@lowdefy/plugin-next-auth'
+];
+export default defaultPackages;