@lowdefy/build 5.4.0 → 5.5.1

package/dist/build/buildRefs/rebaseModuleRefPaths.js

@@ -0,0 +1,34 @@
+/*
+  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 { type } from '@lowdefy/helpers';
+// Module refs author their path/resolver/transformer relative to the module
+// (e.g. "resolvers/makeActionPages.js"). Rebase those relative paths against the
+// module root so they resolve from the module, not the app config dir. Mutates
+// refDef in place. No-op when moduleRoot is not set or a path is already absolute.
+function rebaseModuleRefPaths({ refDef, moduleRoot }) {
+    if (!moduleRoot) return refDef;
+    for (const field of [
+        'path',
+        'resolver',
+        'transformer'
+    ]){
+        if (type.isString(refDef[field]) && !path.isAbsolute(refDef[field])) {
+            refDef[field] = path.resolve(moduleRoot, refDef[field]);
+        }
+    }
+    return refDef;
+}
+export default rebaseModuleRefPaths;

package/dist/build/buildRefs/walker.js

@@ -17,6 +17,7 @@ import { get, serializer, type } from '@lowdefy/helpers';
 import { ConfigError } from '@lowdefy/errors';
 import { evaluateOperators } from '@lowdefy/operators';
 import makeRefDefinition from './makeRefDefinition.js';
+import rebaseModuleRefPaths from './rebaseModuleRefPaths.js';
 import getRefContent from './getRefContent.js';
 import getModuleRefContent from './getModuleRefContent.js';
 import runTransformer from './runTransformer.js';
@@ -470,17 +471,10 @@ async function resolveRef(node, ctx) {
         refDef.key = await resolve(cloneForResolve(refDef.key), ctx);
     }
     // 4. Module path resolution: resolve relative paths from the module root
-    if (ctx.moduleRoot) {
-        if (type.isString(refDef.path) && !path.isAbsolute(refDef.path)) {
-            refDef.path = path.resolve(ctx.moduleRoot, refDef.path);
-        }
-        if (type.isString(refDef.resolver) && !path.isAbsolute(refDef.resolver)) {
-            refDef.resolver = path.resolve(ctx.moduleRoot, refDef.resolver);
-        }
-        if (type.isString(refDef.transformer) && !path.isAbsolute(refDef.transformer)) {
-            refDef.transformer = path.resolve(ctx.moduleRoot, refDef.transformer);
-        }
-    }
+    rebaseModuleRefPaths({
+        refDef,
+        moduleRoot: ctx.moduleRoot
+    });
     // 5. Update refMap with resolved path; store original for resolver refs
     ctx.refMap[refDef.id].path = refDef.path;
     if (!refDef.path) {

package/dist/build/jit/buildPageJit.js

@@ -31,6 +31,7 @@ import evaluateStaticOperators from '../buildRefs/evaluateStaticOperators.js';
 import getRefContent from '../buildRefs/getRefContent.js';
 import jsMapParser from '../buildJs/jsMapParser.js';
 import makeRefDefinition from '../buildRefs/makeRefDefinition.js';
+import rebaseModuleRefPaths from '../buildRefs/rebaseModuleRefPaths.js';
 import { resolve, WalkContext, cloneForResolve, tagRefDeep } from '../buildRefs/walker.js';
 import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
 import writeMaps from '../writeMaps.js';
@@ -151,6 +152,23 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
             refDef = makeRefDefinition(refDefinition, null, buildContext.refMap);
             buildContext.refMap[refDef.id].path = refDef.path;
         }
+        // Module path resolution: resolve relative path/resolver/transformer from the
+        // module root. The full build does this in walker.js step 4 when an _ref node
+        // is encountered, but the JIT path builds the page refDef directly from
+        // resolverOriginal (the un-rebased authored _ref) and calls getRefContent
+        // without going through the walker — so a module resolver like
+        // "resolvers/makeActionPages.js" would otherwise resolve against the app
+        // config dir instead of the module root. (File-based module pages are
+        // unaffected: their paths are stored already-rebased in refMap.)
+        if (moduleEntry?.moduleRoot) {
+            rebaseModuleRefPaths({
+                refDef,
+                moduleRoot: moduleEntry.moduleRoot
+            });
+            if (type.isString(refDef.path)) {
+                buildContext.refMap[refDef.id].path = refDef.path;
+            }
+        }
         const pageContent = await getRefContent({
             context: buildContext,
             refDef,