@lowdefy/build 5.5.1 → 6.0.0

package/dist/scripts/generateDefaultTypes.js

@@ -26,17 +26,20 @@ async function generateDefaultTypesMap() {
             adapters: {},
             callbacks: {},
             events: {},
-            providers: {}
+            providers: {},
+            strategies: {}
         },
         blockMetas: {},
         blocks: {},
         connections: {},
         icons: {},
+        notifications: {},
         operators: {
             client: {},
             server: {}
         },
-        requests: {}
+        requests: {},
+        websockets: {}
     };
     for (const packageName of defaultPackages){
         const { default: types } = await import(`${packageName}/types`);

package/dist/test-utils/expectTerminates.js

@@ -0,0 +1,33 @@
+/*
+  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.
+*/ // Termination guard for cycle-sensitive tests: a cycle-detection regression
+// that deadlocks should fail fast with an actionable message, not an opaque
+// CI timeout. Passes the promise's settlement (value or rejection) through
+// unchanged when it settles in time.
+async function expectTerminates(promise, ms, hint) {
+    let timer;
+    const timeout = new Promise((_, reject)=>{
+        timer = setTimeout(()=>reject(new Error(`promise did not settle within ${ms}ms — ${hint}`)), ms);
+    });
+    try {
+        return await Promise.race([
+            promise,
+            timeout
+        ]);
+    } finally{
+        clearTimeout(timer);
+    }
+}
+export default expectTerminates;

package/dist/test-utils/runBuild.js

@@ -57,6 +57,9 @@ import createTestLogger from './createTestLogger.js';
         DangerousHtml: {
             package: '@lowdefy/blocks-basic'
         },
+        Dynamic: {
+            package: '@lowdefy/blocks-basic'
+        },
         Html: {
             package: '@lowdefy/blocks-basic'
         },
@@ -112,7 +115,15 @@ import createTestLogger from './createTestLogger.js';
             package: '@lowdefy/blocks-basic'
         }
     },
+    agents: {
+        ClaudeAgent: {
+            package: '@lowdefy/connection-anthropic'
+        }
+    },
     connections: {
+        Anthropic: {
+            package: '@lowdefy/connection-anthropic'
+        },
         AxiosHttp: {
             package: '@lowdefy/connection-axios-http'
         },
@@ -134,7 +145,15 @@ import createTestLogger from './createTestLogger.js';
         events: {},
         providers: {
             GoogleProvider: {
-                package: 'next-auth'
+                package: '@lowdefy/plugin-next-auth'
+            }
+        },
+        strategies: {
+            apiKey: {
+                package: '@lowdefy/plugin-next-auth'
+            },
+            jwt: {
+                package: '@lowdefy/plugin-next-auth'
             }
         }
     },

package/dist/test-utils/runBuildForSnapshots.js

@@ -90,6 +90,9 @@ import path from 'path';
         DangerousHtml: {
             package: '@lowdefy/blocks-basic'
         },
+        Dynamic: {
+            package: '@lowdefy/blocks-basic'
+        },
         Html: {
             package: '@lowdefy/blocks-basic'
         },
@@ -280,6 +283,9 @@ import path from 'path';
         }
     },
     connections: {
+        Anthropic: {
+            package: '@lowdefy/connection-anthropic'
+        },
         AxiosHttp: {
             package: '@lowdefy/connection-axios-http'
         },
@@ -312,6 +318,12 @@ import path from 'path';
         AxiosHttp: {
             package: '@lowdefy/connection-axios-http'
         },
+        GenerateObject: {
+            package: '@lowdefy/connection-anthropic'
+        },
+        GenerateText: {
+            package: '@lowdefy/connection-anthropic'
+        },
         MongoDBFind: {
             package: '@lowdefy/connection-mongodb'
         },
@@ -370,6 +382,16 @@ import path from 'path';
             package: '@lowdefy/plugin-aws'
         }
     },
+    agents: {
+        ClaudeAgent: {
+            package: '@lowdefy/connection-anthropic'
+        }
+    },
+    notifications: {
+        NotificationEmail: {
+            package: '@lowdefy/email-templates'
+        }
+    },
     auth: {
         adapters: {
             MongoDBAdapter: {
@@ -415,16 +437,24 @@ import path from 'path';
                 package: '@lowdefy/plugin-auth0'
             },
             GoogleProvider: {
-                package: 'next-auth'
+                package: '@lowdefy/plugin-next-auth'
             },
             GitHubProvider: {
-                package: 'next-auth'
+                package: '@lowdefy/plugin-next-auth'
             },
             CredentialsProvider: {
-                package: 'next-auth'
+                package: '@lowdefy/plugin-next-auth'
             },
             EmailProvider: {
-                package: 'next-auth'
+                package: '@lowdefy/plugin-next-auth'
+            }
+        },
+        strategies: {
+            apiKey: {
+                package: '@lowdefy/plugin-next-auth'
+            },
+            jwt: {
+                package: '@lowdefy/plugin-next-auth'
             }
         }
     },

package/dist/test-utils/testContext.js

@@ -34,11 +34,13 @@ function testContext({ writeBuildArtifact, configDirectory, readConfigFile, logg
                 adapters: createCounter(),
                 callbacks: createCounter(),
                 events: createCounter(),
-                providers: createCounter()
+                providers: createCounter(),
+                strategies: createCounter()
             },
             blocks: createCounter(),
             connections: createCounter(),
             requests: createCounter(),
+            websockets: createCounter(),
             controls: createCounter(),
             operators: {
                 client: createCounter(),
@@ -51,7 +53,8 @@ function testContext({ writeBuildArtifact, configDirectory, readConfigFile, logg
         keyMap: {},
         jsMap: {},
         agentIds: new Set(),
-        connectionIds: new Set()
+        connectionIds: new Set(),
+        websocketIds: new Set()
     };
     context.logger = {
         ...defaultLogger,
@@ -66,6 +69,9 @@ function testContext({ writeBuildArtifact, configDirectory, readConfigFile, logg
     };
     // handleError delegates to logger.error
     context.handleError = context.logger.error;
+    // No-op stub for demand-driven module entry resolution used by resolveModuleConnectionId.
+    // In tests, module entries are already in their final state so no resolution is needed.
+    context.ensureEntryConfigResolved = ()=>Promise.resolve();
     return context;
 }
 export default testContext;

package/dist/utils/countOperators.js

@@ -12,11 +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 { type } from '@lowdefy/helpers';
-// Keys that look like operators (single key starting with _) but are not.
-const KNOWN_NON_OPERATORS = new Set([
-    '_id'
-]);
+*/ import { getOperatorType, type } from '@lowdefy/helpers';
 function walkAndCount(value, counter, parentConfigKey) {
     if (type.isArray(value)) {
         value.forEach((item)=>walkAndCount(item, counter, parentConfigKey));
@@ -26,20 +22,12 @@ function walkAndCount(value, counter, parentConfigKey) {
         return;
     }
     const configKey = value['~k'] || parentConfigKey;
-    const keys = Object.keys(value);
-    // Check if this object is an operator (single key starting with _, ignoring ~ prefixed keys)
-    // This allows ~ignoreBuildCheck to be on the same object as an operator
-    const nonTildeKeys = keys.filter((k)=>!k.startsWith('~'));
-    if (nonTildeKeys.length === 1) {
-        const key = nonTildeKeys[0];
-        const [op] = key.split('.');
-        const operator = op.replace(/^(_+)/gm, '_');
-        if (operator.length > 1 && operator[0] === '_' && !KNOWN_NON_OPERATORS.has(operator)) {
-            counter.increment(operator, configKey);
-        }
+    const operator = getOperatorType(value);
+    if (operator) {
+        counter.increment(operator, configKey);
     }
     // Recurse into all values
-    keys.forEach((key)=>{
+    Object.keys(value).forEach((key)=>{
         walkAndCount(value[key], counter, configKey);
     });
 }

package/dist/utils/createPluginTypesMap.js

@@ -67,6 +67,13 @@ function createPluginTypesMap({ packageName, packageTypes, typePrefix = '', type
         typePrefix,
         version
     });
+    createTypeDefinitions({
+        typeNames: type.isObject(packageTypes.auth) ? packageTypes.auth.strategies : [],
+        store: typesMap.auth.strategies,
+        packageName,
+        typePrefix,
+        version
+    });
     createTypeDefinitions({
         typeNames: packageTypes.blocks,
         store: typesMap.blocks,
@@ -95,6 +102,13 @@ function createPluginTypesMap({ packageName, packageTypes, typePrefix = '', type
         typePrefix,
         version
     });
+    createTypeDefinitions({
+        typeNames: packageTypes.notifications,
+        store: typesMap.notifications,
+        packageName,
+        typePrefix,
+        version
+    });
     createTypeDefinitions({
         typeNames: packageTypes.requests,
         store: typesMap.requests,
@@ -102,6 +116,13 @@ function createPluginTypesMap({ packageName, packageTypes, typePrefix = '', type
         typePrefix,
         version
     });
+    createTypeDefinitions({
+        typeNames: packageTypes.websockets,
+        store: typesMap.websockets,
+        packageName,
+        typePrefix,
+        version
+    });
     if (type.isObject(packageTypes.icons)) {
         Object.entries(packageTypes.icons).forEach(([blockType, icons])=>{
             typesMap.icons[`${typePrefix}${blockType}`] = icons;

package/dist/utils/getCronEnvironmentNames.js

@@ -0,0 +1,25 @@
+/*
+  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.
+*/ // The declared environment names in config.cron.environments. Build key markers (~k, ~r, ~l) live
+// on the same object as the environments, so they are skipped rather than treated as names.
+const markerKeys = new Set([
+    '~k',
+    '~r',
+    '~l'
+]);
+function getCronEnvironmentNames(environments) {
+    return Object.keys(environments ?? {}).filter((key)=>!markerKeys.has(key));
+}
+export default getCronEnvironmentNames;

package/dist/utils/logCollectedErrors.js

@@ -12,19 +12,53 @@
   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 { BuildError, LowdefyInternalError } from '@lowdefy/errors';
+*/ import { BuildError, LowdefyInternalError, resolveErrorLocation } from '@lowdefy/errors';
+import serializeBuildException from './serializeBuildException.js';
 function logCollectedErrors(context) {
     if (context.errors.length === 0) return;
-    context.errors.forEach((err)=>{
-        if (err.isLowdefyError) {
-            context.handleError(err);
-        } else {
-            const lowdefyErr = new LowdefyInternalError(err.message, {
-                cause: err
+    // handleError mutates each error in place (resolves source/config), so
+    // capture the handled instance (not the original) for serialization below.
+    const handledErrors = [];
+    const seenSourceMessages = new Set();
+    for (const err of context.errors){
+        const lowdefyErr = err.isLowdefyError ? err : new LowdefyInternalError(err.message, {
+            cause: err
+        });
+        // handleError resolves the location and logs in one step, so the location
+        // has to be resolved here to decide whether the entry is worth logging at
+        // all. Resolution is pure, so handleError repeating it yields the same
+        // location. Resolution reads author-supplied data (keyMap entries, refMap
+        // paths), so a malformed entry can throw; the whole error report is worth
+        // more than one error's source line, so a failure leaves the error
+        // unlocated here and handleError logs it with its own guarded resolution.
+        let location = null;
+        try {
+            location = resolveErrorLocation(lowdefyErr, {
+                keyMap: context.keyMap,
+                refMap: context.refMap,
+                configDirectory: context.directories?.config
             });
-            context.handleError(lowdefyErr);
+        } catch  {
+            location = null;
         }
-    });
-    throw new BuildError(`Build failed with ${context.errors.length} error(s). See above for details.`);
+        // Two build steps can report the same config line: buildAuth reaches page,
+        // endpoint and websocket ids before validateId does, and both gates give
+        // the same message. Two genuinely distinct errors never share both a
+        // resolved source line and a message, so that pair is safe to collapse.
+        // Without a resolved source line there is no such evidence — the message
+        // alone would collapse distinct internal errors, and under-count the
+        // failures — so unlocated errors are always reported.
+        if (location?.source) {
+            const dedupKey = `${location.source}\n${lowdefyErr.message}`;
+            if (seenSourceMessages.has(dedupKey)) continue;
+            seenSourceMessages.add(dedupKey);
+        }
+        context.handleError(lowdefyErr);
+        handledErrors.push(lowdefyErr);
+    }
+    const buildError = new BuildError(`Build failed with ${handledErrors.length} error(s). See above for details.`);
+    buildError.errors = handledErrors.map(serializeBuildException);
+    buildError.warnings = (context.warnings ?? []).map(serializeBuildException);
+    throw buildError;
 }
 export default logCollectedErrors;

package/dist/utils/serializeBuildException.js

@@ -0,0 +1,29 @@
+/*
+  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.
+*/ // Error.prototype.message is non-enumerable, so JSON.stringify(error) drops it
+// (while enumerable fields like configKey/source survive). Build a plain,
+// JSON-serializable summary instead - no stack, no cause, no `received`
+// (arbitrary config values that may be huge or circular).
+function serializeBuildException(exception) {
+    return {
+        message: exception.message,
+        name: exception.name,
+        source: exception.source ?? null,
+        config: exception.config ?? null,
+        configKey: exception.configKey ?? null,
+        checkSlug: exception.checkSlug ?? null
+    };
+}
+export default serializeBuildException;

package/dist/utils/validateCronExpression.js

@@ -0,0 +1,131 @@
+/*
+  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.
+*/ // Validates a cron expression against the restricted subset Vercel Cron Jobs accept, so an invalid
+// schedule fails at build instead of during the Vercel deployment. Vercel rules:
+//   - Exactly 5 fields: minute hour day-of-month month day-of-week.
+//   - Numeric values only — named values like MON or JAN are not supported.
+//   - Day-of-month and day-of-week are mutually exclusive: when one is set the other must be "*".
+// Returns null when valid, otherwise a human-readable reason string.
+const FIELDS = [
+    {
+        name: 'minute',
+        min: 0,
+        max: 59
+    },
+    {
+        name: 'hour',
+        min: 0,
+        max: 23
+    },
+    {
+        name: 'day-of-month',
+        min: 1,
+        max: 31
+    },
+    {
+        name: 'month',
+        min: 1,
+        max: 12
+    },
+    {
+        name: 'day-of-week',
+        min: 0,
+        max: 6
+    }
+];
+function validateInt(value, { min, max }) {
+    if (!/^[0-9]+$/.test(value)) {
+        return `contains non-numeric value "${value}" (named values like MON/JAN are not supported)`;
+    }
+    const n = Number(value);
+    if (n < min || n > max) {
+        return `value "${value}" is out of range (${min}-${max})`;
+    }
+    return null;
+}
+function validatePart(part, { min, max }) {
+    let range = part;
+    if (part.includes('/')) {
+        const stepSplit = part.split('/');
+        if (stepSplit.length !== 2) {
+            return `has an invalid step in "${part}"`;
+        }
+        const [rangePart, stepPart] = stepSplit;
+        if (!/^[1-9][0-9]*$/.test(stepPart)) {
+            return `has an invalid step in "${part}"`;
+        }
+        range = rangePart;
+    }
+    if (range === '*') {
+        return null;
+    }
+    if (range.includes('-')) {
+        const rangeSplit = range.split('-');
+        if (rangeSplit.length !== 2) {
+            return `has an invalid range in "${part}"`;
+        }
+        const [startStr, endStr] = rangeSplit;
+        const startReason = validateInt(startStr, {
+            min,
+            max
+        });
+        if (startReason) return startReason;
+        const endReason = validateInt(endStr, {
+            min,
+            max
+        });
+        if (endReason) return endReason;
+        if (Number(startStr) > Number(endStr)) {
+            return `has a descending range in "${part}"`;
+        }
+        return null;
+    }
+    return validateInt(range, {
+        min,
+        max
+    });
+}
+function validateField(field, spec) {
+    if (field === '') {
+        return `${spec.name} field is empty`;
+    }
+    const parts = field.split(',');
+    for (const part of parts){
+        const reason = validatePart(part, spec);
+        if (reason) {
+            return `${spec.name} field "${field}" ${reason}`;
+        }
+    }
+    return null;
+}
+function validateCronExpression(expression) {
+    if (typeof expression !== 'string') {
+        return 'cron expression must be a string';
+    }
+    const fields = expression.trim().split(/\s+/);
+    if (fields.length !== 5) {
+        return 'cron expression must have exactly 5 fields (minute hour day-of-month month day-of-week)';
+    }
+    for(let i = 0; i < FIELDS.length; i += 1){
+        const reason = validateField(fields[i], FIELDS[i]);
+        if (reason) return reason;
+    }
+    const [, , dayOfMonth, , dayOfWeek] = fields;
+    if (dayOfMonth !== '*' && dayOfWeek !== '*') {
+        return 'cannot specify both day-of-month and day-of-week; one must be "*"';
+    }
+    return null;
+}
+export default validateCronExpression;

package/dist/utils/validateId.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
+import { isReserved } from '@lowdefy/helpers';
 const validIdPattern = /^[A-Za-z0-9\-_/:]+$/;
 function validateId({ id, field, location, configKey }) {
     if (!validIdPattern.test(id)) {
@@ -20,5 +21,15 @@ function validateId({ id, field, location, configKey }) {
             configKey
         });
     }
+    // The pattern above admits every reserved name - underscores and letters are in its allowed set.
+    // A reserved id re-parents the plain-object registries that key on it - the engine's `requests`
+    // and `requestConfig` maps, and the connection/websocket/notification/endpoint maps - so reject
+    // it here where the config location is still in hand. Block ids do not reach this gate: they are
+    // dot-paths, so the pattern above excludes them and they carry their own per-segment check.
+    if (isReserved(id)) {
+        throw new ConfigError(`${field} "${id}"${location ? ` at ${location}` : ''} is a reserved name and cannot be used as an id.`, {
+            configKey
+        });
+    }
 }
 export default validateId;

package/dist/utils/writeBuildArtifact.js

@@ -13,10 +13,13 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import path from 'path';
-import { writeFile } from '@lowdefy/node-utils';
+import { writeFileIfChanged } from '@lowdefy/node-utils';
 function createWriteBuildArtifact({ directories }) {
+    // Skipping byte-identical writes keeps artifact mtimes stable so Vite does
+    // not invalidate modules (clientJsMap → Routing HMR, serverJsMap → SSR
+    // reload) on JIT page builds that changed nothing.
     async function writeBuildArtifact(filePath, content) {
-        await writeFile(path.join(directories.build, filePath), content);
+        await writeFileIfChanged(path.join(directories.build, filePath), content);
     }
     return writeBuildArtifact;
 }