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

package/dist/build/validateOperatorsDynamic.js

@@ -0,0 +1,28 @@
+/*
+  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';
+function validateOperatorsDynamic({ operators }) {
+    const missingDynamic = [];
+    Object.entries(operators).forEach(([operatorName, operatorFn])=>{
+        if (!type.isFunction(operatorFn)) return;
+        if (!type.isBoolean(operatorFn.dynamic)) {
+            missingDynamic.push(operatorName);
+        }
+    });
+    if (missingDynamic.length > 0) {
+        throw new Error(`Operator validation failed: The following operators are missing the 'dynamic' property: ${missingDynamic.join(', ')}. ` + `All operators must have a 'dynamic' boolean property (true for runtime-only, false for build-time safe).`);
+    }
+}
+export default validateOperatorsDynamic;

package/dist/build/writeRequests.js

@@ -13,15 +13,15 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer, type } from '@lowdefy/helpers';
-import formatConfigError from '../utils/formatConfigError.js';
+import { ConfigError } from '@lowdefy/node-utils';
 async function writeRequestsOnPage({ page, context }) {
     const requests = page.requests ?? [];
     if (!type.isArray(requests)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Page requests must be an array. Received ${JSON.stringify(requests)}.`,
             configKey: page['~k'],
             context
-        }));
+        });
     }
     return Promise.all(requests.map(async (request)=>{
         await context.writeBuildArtifact(`pages/${page.pageId}/requests/${request.requestId}.json`, serializer.serializeToString(request ?? {}));

package/dist/createContext.js

@@ -13,18 +13,20 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { mergeObjects } from '@lowdefy/helpers';
+import { ConfigError, ConfigWarning } from '@lowdefy/node-utils';
 import createCounter from './utils/createCounter.js';
 import createReadConfigFile from './utils/readConfigFile.js';
 import createWriteBuildArtifact from './utils/writeBuildArtifact.js';
 import defaultTypesMap from './defaultTypesMap.js';
 function createContext({ customTypesMap, directories, logger, refResolver, stage = 'prod' }) {
+    // Create context object first (needed for logger methods)
     const context = {
         connectionIds: new Set(),
         directories,
         errors: [],
         jsMap: {},
         keyMap: {},
-        logger,
+        logger: null,
         readConfigFile: createReadConfigFile({
             directories
         }),
@@ -56,6 +58,45 @@ function createContext({ customTypesMap, directories, logger, refResolver, stage
             directories
         })
     };
+    // Add config-aware methods to logger (don't spread - pino uses Symbol-keyed internals)
+    logger.configWarning = ({ message, configKey, operatorLocation, prodError })=>{
+        try {
+            // ConfigWarning.format throws ConfigError in prod mode when prodError is true
+            const formatted = ConfigWarning.format({
+                message,
+                configKey,
+                operatorLocation,
+                context,
+                prodError
+            });
+            if (formatted) {
+                logger.warn(formatted);
+            }
+        } catch (err) {
+            // ConfigError thrown in prod mode - collect instead of throwing
+            // This allows validation to continue and report all errors
+            if (err instanceof ConfigError) {
+                // Skip suppressed errors (empty message means ~ignoreBuildCheck: true)
+                if (!err.suppressed) {
+                    context.errors.push(err.message);
+                }
+            } else {
+                throw err;
+            }
+        }
+    };
+    logger.configError = ({ message, configKey, operatorLocation })=>{
+        const formatted = ConfigError.format({
+            message,
+            configKey,
+            operatorLocation,
+            context
+        });
+        if (formatted) {
+            logger.error(formatted);
+        }
+    };
+    context.logger = logger;
     return context;
 }
 export default createContext;