rwsdk 0.2.0 → 0.3.0

package/dist/vite/runDirectivesScan.mjs

@@ -0,0 +1,152 @@
+import fsp from "node:fs/promises";
+import { hasDirective } from "./hasDirective.mjs";
+import path from "node:path";
+import debug from "debug";
+import { ensureAliasArray } from "./ensureAliasArray.mjs";
+import { getViteEsbuild } from "./getViteEsbuild.mjs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:run-directives-scan");
+// Copied from Vite's source code.
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/shared/utils.ts
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+// Copied from Vite's source code.
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/utils.ts
+const externalRE = /^(https?:)?\/\//;
+const isExternalUrl = (url) => externalRE.test(url);
+function createEsbuildScanPlugin({ clientFiles, serverFiles, aliases, projectRootDir, }) {
+    return {
+        name: "rwsdk:esbuild-scan-plugin",
+        setup(build) {
+            // Match Vite's behavior by externalizing assets and special queries.
+            // This prevents esbuild from trying to bundle them, which would fail.
+            const scriptFilter = /\.(c|m)?[jt]sx?$/;
+            const specialQueryFilter = /[?&](?:url|raw|worker|sharedworker|inline)\b/;
+            // This regex is used to identify if a path has any file extension.
+            const hasExtensionRegex = /\.[^/]+$/;
+            build.onResolve({ filter: specialQueryFilter }, (args) => {
+                log("Externalizing special query:", args.path);
+                return { external: true };
+            });
+            build.onResolve({ filter: /.*/, namespace: "file" }, (args) => {
+                // Externalize if the path has an extension AND that extension is not a
+                // script extension. Extensionless paths are assumed to be scripts and
+                // are allowed to pass through for resolution.
+                if (hasExtensionRegex.test(args.path) &&
+                    !scriptFilter.test(args.path)) {
+                    log("Externalizing non-script import:", args.path);
+                    return { external: true };
+                }
+            });
+            build.onResolve({ filter: /.*/ }, async (args) => {
+                // Prevent infinite recursion.
+                if (args.pluginData?.rwsdkScanResolver) {
+                    return null;
+                }
+                // 1. First, try to resolve aliases.
+                for (const { find, replacement } of aliases) {
+                    const findPattern = find instanceof RegExp ? find : new RegExp(`^${find}(\\/.*)?$`);
+                    if (findPattern.test(args.path)) {
+                        const newPath = args.path.replace(findPattern, (_match, rest) => {
+                            // `rest` is the captured group `(\\/.*)?` from the regex.
+                            return replacement + (rest || "");
+                        });
+                        const resolved = await build.resolve(newPath, {
+                            importer: args.importer,
+                            resolveDir: args.resolveDir,
+                            kind: args.kind,
+                            pluginData: { rwsdkScanResolver: true },
+                        });
+                        if (resolved.errors.length === 0) {
+                            return resolved;
+                        }
+                        log("Could not resolve aliased path '%s' (from '%s'). Marking as external. Errors: %s", newPath, args.path, resolved.errors.map((e) => e.text).join(", "));
+                        return { external: true };
+                    }
+                }
+                // 2. If no alias matches, try esbuild's default resolver.
+                const resolved = await build.resolve(args.path, {
+                    importer: args.importer,
+                    resolveDir: args.resolveDir,
+                    kind: args.kind,
+                    pluginData: { rwsdkScanResolver: true },
+                });
+                // If it fails, mark as external but don't crash.
+                if (resolved.errors.length > 0) {
+                    log("Could not resolve '%s'. Marking as external. Errors: %s", args.path, resolved.errors.map((e) => e.text).join(", "));
+                    return { external: true };
+                }
+                return resolved;
+            });
+            build.onLoad({ filter: /\.(m|c)?[jt]sx?$/ }, async (args) => {
+                if (!args.path.startsWith("/") ||
+                    args.path.includes("virtual:") ||
+                    isExternalUrl(args.path)) {
+                    return null;
+                }
+                try {
+                    const contents = await fsp.readFile(args.path, "utf-8");
+                    if (hasDirective(contents, "use client")) {
+                        log("Discovered 'use client' in:", args.path);
+                        clientFiles.add(normalizeModulePath(args.path, projectRootDir));
+                    }
+                    if (hasDirective(contents, "use server")) {
+                        log("Discovered 'use server' in:", args.path);
+                        serverFiles.add(normalizeModulePath(args.path, projectRootDir));
+                    }
+                    return { contents, loader: "default" };
+                }
+                catch (e) {
+                    log("Could not read file during scan, skipping:", args.path, e);
+                    return null;
+                }
+            });
+        },
+    };
+}
+export async function runDirectivesScan({ rootConfig, envName, clientFiles, serverFiles, }) {
+    const esbuild = await getViteEsbuild(rootConfig.root);
+    const env = rootConfig.environments[envName];
+    const input = env.build.rollupOptions?.input;
+    let entries;
+    if (Array.isArray(input)) {
+        entries = input;
+    }
+    else if (typeof input === "string") {
+        entries = [input];
+    }
+    else if (isObject(input)) {
+        entries = Object.values(input);
+    }
+    else {
+        entries = [];
+    }
+    if (entries.length === 0) {
+        log("No entries found for directives scan in environment '%s', skipping.", envName);
+        return;
+    }
+    const absoluteEntries = entries.map((entry) => path.resolve(rootConfig.root, entry));
+    log("Starting directives scan for environment '%s' with entries:", envName, absoluteEntries);
+    try {
+        const result = await esbuild.build({
+            entryPoints: absoluteEntries,
+            bundle: true,
+            write: false,
+            platform: "node",
+            format: "esm",
+            logLevel: "silent",
+            metafile: true,
+            plugins: [
+                createEsbuildScanPlugin({
+                    clientFiles,
+                    serverFiles,
+                    aliases: ensureAliasArray(env),
+                    projectRootDir: rootConfig.root,
+                }),
+            ],
+        });
+        return result.metafile;
+    }
+    catch (e) {
+        throw new Error(`RWSDK directive scan failed:\n${e.message}`);
+    }
+}

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,11 +1,10 @@
 import debug from "debug";
-import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
+import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import MagicString from "magic-string";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
 export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
 export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
-    log("Initializing SSR bridge plugin with SSR_BRIDGE_PATH=%s", SSR_BRIDGE_PATH);
     let devServer;
     let isDev = false;
     const ssrBridgePlugin = {
@@ -49,8 +48,6 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
         },
         async resolveId(id) {
-            process.env.VERBOSE &&
-                log("Resolving id=%s, environment=%s, isDev=%s", id, this.environment?.name, isDev);
             if (isDev) {
                 // context(justinvdm, 27 May 2025): In dev, we need to dynamically load
                 // SSR modules, so we return the virtual id so that the dynamic loading
@@ -75,20 +72,23 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 }
             }
             else {
-                // context(justinvdm, 27 May 2025): In builds, since all SSR import chains
-                // originate at SSR bridge module, we return the path to the already built
-                // SSR bridge bundle - SSR env builds it, worker build tries to resolve it
-                // here and uses it
+                // In build mode, the behavior depends on the build pass
                 if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
-                    log("Bridge module case (build): id=%s matches rwsdk/__ssr_bridge in worker environment, returning SSR_BRIDGE_PATH=%s", id, SSR_BRIDGE_PATH);
-                    return SSR_BRIDGE_PATH;
+                    if (process.env.RWSDK_BUILD_PASS === "worker") {
+                        // First pass: resolve to a temporary, external path
+                        log("Bridge module case (build-worker pass): resolving to external path");
+                        return { id: INTERMEDIATE_SSR_BRIDGE_PATH, external: true };
+                    }
+                    else if (process.env.RWSDK_BUILD_PASS === "linker") {
+                        // Second pass (linker): resolve to the real intermediate build
+                        // artifact so it can be bundled in.
+                        log("Bridge module case (build-linker pass): resolving to bundleable path");
+                        return { id: INTERMEDIATE_SSR_BRIDGE_PATH, external: false };
+                    }
                 }
             }
-            process.env.VERBOSE && log("No resolution for id=%s", id);
         },
         async load(id) {
-            process.env.VERBOSE &&
-                log("Loading id=%s, isDev=%s, environment=%s", id, isDev, this.environment.name);
             if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
                 this.environment.name === "worker") {
                 const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
@@ -132,7 +132,6 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                     return out;
                 }
             }
-            process.env.VERBOSE && log("No load handling for id=%s", id);
         },
     };
     return ssrBridgePlugin;

package/dist/vite/transformClientComponents.d.mts

@@ -2,7 +2,6 @@ interface TransformContext {
     environmentName: string;
     clientFiles?: Set<string>;
     isEsbuild?: boolean;
-    addClientModule?: (environment: string, id: string) => void;
 }
 interface TransformResult {
     code: string;

package/dist/vite/transformClientComponents.mjs

@@ -5,16 +5,10 @@ import { findExports } from "./findSpecifiers.mjs";
 const logVite = debug("rwsdk:vite:transform-client-components:vite");
 const logEsbuild = debug("rwsdk:vite:transform-client-components:esbuild");
 export async function transformClientComponents(code, normalizedId, ctx) {
-    const log = ctx.isEsbuild ? logEsbuild : logVite;
-    log("Called transformClientComponents for id: id=%s", normalizedId);
     if (!hasDirective(code, "use client")) {
-        log("Skipping: no 'use client' directive in id=%s", normalizedId);
-        process.env.VERBOSE &&
-            log(":VERBOSE: Returning code unchanged for id=%s:\n%s", normalizedId, code);
         return;
     }
-    log("Processing 'use client' module: id=%s", normalizedId);
-    ctx.addClientModule?.(ctx.environmentName, normalizedId);
+    const log = ctx.isEsbuild ? logEsbuild : logVite;
     // Parse exports using the findExports helper
     const exportInfos = findExports(normalizedId, code, log);
     const processedExports = [];
@@ -85,7 +79,6 @@ export async function transformClientComponents(code, normalizedId, ctx) {
     const computedLocalNames = new Map(processedExports.map((info) => [getComputedLocalName(info), info]));
     // Add registerClientReference assignments for unique names
     for (const [computedLocalName, correspondingInfo] of computedLocalNames) {
-        log(":isEsbuild=%s: Registering client reference for named export: %s as %s", !!ctx.isEsbuild, correspondingInfo.local, correspondingInfo.exported);
         s.append(`const ${computedLocalName} = registerClientReference("${normalizedId}", "${correspondingInfo.exported}");\n`);
     }
     // Add grouped export statement for named exports (preserving order and alias)
@@ -93,7 +86,6 @@ export async function transformClientComponents(code, normalizedId, ctx) {
         const exportNames = Array.from(computedLocalNames.entries()).map(([computedLocalName, correspondingInfo]) => correspondingInfo.local === correspondingInfo.exported
             ? computedLocalName
             : `${computedLocalName} as ${correspondingInfo.exported}`);
-        log(":isEsbuild=%s: Exporting named exports: %O", !!ctx.isEsbuild, exportNames);
         s.append(`export { ${exportNames.join(", ")} };\n`);
     }
     // Add default export if present

package/dist/vite/transformJsxScriptTagsPlugin.d.mts

@@ -1,8 +1,9 @@
 import { type Plugin } from "vite";
-export declare function transformJsxScriptTagsCode(code: string, manifest?: Record<string, any>): Promise<{
+export declare function transformJsxScriptTagsCode(code: string, clientEntryPoints: Set<string>, manifest: Record<string, any> | undefined, projectRootDir: string): Promise<{
     code: string;
     map: null;
 } | undefined>;
-export declare const transformJsxScriptTagsPlugin: ({ manifestPath, }: {
-    manifestPath: string;
+export declare const transformJsxScriptTagsPlugin: ({ clientEntryPoints, projectRootDir, }: {
+    clientEntryPoints: Set<string>;
+    projectRootDir: string;
 }) => Plugin;

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -1,19 +1,16 @@
 import { Project, Node, SyntaxKind, } from "ts-morph";
-import { readFile } from "node:fs/promises";
-import { pathExists } from "fs-extra";
 import debug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:transform-jsx-script-tags");
-let manifestCache;
-const readManifest = async (manifestPath) => {
-    if (manifestCache === undefined) {
-        const exists = await pathExists(manifestPath);
-        if (!exists) {
-            throw new Error(`RedwoodSDK expected client manifest to exist at ${manifestPath}. This is likely a bug. Please report it at https://github.com/redwoodjs/sdk/issues/new`);
-        }
-        manifestCache = JSON.parse(await readFile(manifestPath, "utf-8"));
+function transformAssetPath(importPath, projectRootDir) {
+    if (process.env.VITE_IS_DEV_SERVER === "1") {
+        return importPath;
     }
-    return manifestCache;
-};
+    const normalizedImportPath = normalizeModulePath(importPath, projectRootDir);
+    return `rwsdk_asset:${normalizedImportPath}`;
+}
+// Note: This plugin only runs during discovery phase (Phase 1)
+// Manifest reading and asset linking happens later in Phase 5
 function hasJsxFunctions(text) {
     return (text.includes('jsx("script"') ||
         text.includes("jsx('script'") ||
@@ -28,7 +25,7 @@ function hasJsxFunctions(text) {
         text.includes('jsxDEV("link"') ||
         text.includes("jsxDEV('link'"));
 }
-function transformScriptImports(scriptContent, manifest) {
+function transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir) {
     const scriptProject = new Project({ useInMemoryFileSystem: true });
     try {
         const wrappedContent = `function __wrapper() {${scriptContent}}`;
@@ -49,12 +46,10 @@ function transformScriptImports(scriptContent, manifest) {
                     if (importPath.startsWith("/")) {
                         log("Found dynamic import with root-relative path: %s", importPath);
                         entryPoints.push(importPath);
-                        const path = importPath.slice(1);
-                        if (manifest[path]) {
-                            const transformedSrc = `/${manifest[path].file}`;
-                            args[0].setLiteralValue(transformedSrc);
-                            hasChanges = true;
-                        }
+                        clientEntryPoints.add(importPath);
+                        const transformedImportPath = transformAssetPath(importPath, projectRootDir);
+                        args[0].setLiteralValue(transformedImportPath);
+                        hasChanges = true;
                     }
                 }
             }
@@ -73,7 +68,7 @@ function transformScriptImports(scriptContent, manifest) {
         return { content: undefined, hasChanges: false, entryPoints: [] };
     }
 }
-export async function transformJsxScriptTagsCode(code, manifest = {}) {
+export async function transformJsxScriptTagsCode(code, clientEntryPoints, manifest = {}, projectRootDir) {
     // context(justinvdm, 15 Jun 2025): Optimization to exit early
     // to avoidunnecessary ts-morph parsing
     if (!hasJsxFunctions(code)) {
@@ -124,7 +119,7 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
                 let hasStringLiteralChildren = false;
                 let hasSrc = false;
                 let isPreload = false;
-                let hrefValue = null;
+                let hrefProp;
                 for (const prop of properties) {
                     if (Node.isPropertyAssignment(prop)) {
                         const propName = prop.getName();
@@ -142,15 +137,13 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
                                 const srcValue = initializer.getLiteralValue();
                                 if (srcValue.startsWith("/")) {
                                     entryPoints.push(srcValue);
-                                    const path = srcValue.slice(1);
-                                    if (manifest[path]) {
-                                        const transformedSrc = `/${manifest[path].file}`;
-                                        modifications.push({
-                                            type: "literalValue",
-                                            node: initializer,
-                                            value: transformedSrc,
-                                        });
-                                    }
+                                    clientEntryPoints.add(srcValue);
+                                    const transformedSrc = transformAssetPath(srcValue, projectRootDir);
+                                    modifications.push({
+                                        type: "literalValue",
+                                        node: initializer,
+                                        value: transformedSrc,
+                                    });
                                 }
                             }
                         }
@@ -160,7 +153,7 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
                                 Node.isNoSubstitutionTemplateLiteral(initializer))) {
                             hasStringLiteralChildren = true;
                             const scriptContent = initializer.getLiteralValue();
-                            const { content: transformedContent, hasChanges: contentHasChanges, entryPoints: dynamicEntryPoints, } = transformScriptImports(scriptContent, manifest);
+                            const { content: transformedContent, hasChanges: contentHasChanges, entryPoints: dynamicEntryPoints, } = transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir);
                             entryPoints.push(...dynamicEntryPoints);
                             if (contentHasChanges && transformedContent) {
                                 const isTemplateLiteral = Node.isNoSubstitutionTemplateLiteral(initializer);
@@ -174,21 +167,35 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
                                 });
                             }
                         }
-                        if (tagName === "link") {
-                            if (propName === "rel" &&
-                                (Node.isStringLiteral(initializer) ||
-                                    Node.isNoSubstitutionTemplateLiteral(initializer))) {
-                                const relValue = initializer.getLiteralValue();
-                                if (relValue === "preload" || relValue === "modulepreload") {
-                                    isPreload = true;
-                                }
-                            }
-                            if (propName === "href" &&
-                                (Node.isStringLiteral(initializer) ||
-                                    Node.isNoSubstitutionTemplateLiteral(initializer))) {
-                                hrefValue = initializer.getLiteralValue();
+                        if (tagName === "link" &&
+                            propName === "rel" &&
+                            initializer &&
+                            (Node.isStringLiteral(initializer) ||
+                                Node.isNoSubstitutionTemplateLiteral(initializer))) {
+                            const relValue = initializer.getLiteralValue();
+                            if (relValue === "preload" || relValue === "modulepreload") {
+                                isPreload = true;
                             }
                         }
+                        if (tagName === "link" && propName === "href") {
+                            hrefProp = prop;
+                        }
+                    }
+                }
+                if (isPreload && hrefProp) {
+                    const initializer = hrefProp.getInitializer();
+                    if (initializer &&
+                        (Node.isStringLiteral(initializer) ||
+                            Node.isNoSubstitutionTemplateLiteral(initializer))) {
+                        const hrefValue = initializer.getLiteralValue();
+                        if (hrefValue.startsWith("/")) {
+                            const transformedHref = transformAssetPath(hrefValue, projectRootDir);
+                            modifications.push({
+                                type: "literalValue",
+                                node: initializer,
+                                value: transformedHref,
+                            });
+                        }
                     }
                 }
                 if (tagName === "script" &&
@@ -205,43 +212,8 @@ export async function transformJsxScriptTagsCode(code, manifest = {}) {
                         needsRequestInfoImportRef.value = true;
                     }
                 }
-                if (tagName === "link" &&
-                    isPreload &&
-                    hrefValue &&
-                    hrefValue.startsWith("/") &&
-                    manifest[hrefValue.slice(1)]) {
-                    const path = hrefValue.slice(1);
-                    for (const prop of properties) {
-                        if (Node.isPropertyAssignment(prop) &&
-                            prop.getName() === "href") {
-                            const initializer = prop.getInitializer();
-                            if (Node.isStringLiteral(initializer) ||
-                                Node.isNoSubstitutionTemplateLiteral(initializer)) {
-                                const transformedHref = manifest[path].file;
-                                const originalText = initializer.getText();
-                                const isTemplateLiteral = Node.isNoSubstitutionTemplateLiteral(initializer);
-                                const quote = isTemplateLiteral
-                                    ? "`"
-                                    : originalText.charAt(0);
-                                let replacementText;
-                                if (isTemplateLiteral) {
-                                    replacementText = `\`/${transformedHref}\``;
-                                }
-                                else if (quote === '"') {
-                                    replacementText = `"/${transformedHref}"`;
-                                }
-                                else {
-                                    replacementText = `'/${transformedHref}'`;
-                                }
-                                modifications.push({
-                                    type: "replaceText",
-                                    node: initializer,
-                                    text: replacementText,
-                                });
-                            }
-                        }
-                    }
-                }
+                // Note: Link preload href transformations happen in Phase 5 (Asset Linking)
+                // During discovery phase, we only transform script tags
             }
         }
         if (entryPoints.length > 0) {
@@ -339,7 +311,7 @@ ${mod.callExprText}
     }
     return;
 }
-export const transformJsxScriptTagsPlugin = ({ manifestPath, }) => {
+export const transformJsxScriptTagsPlugin = ({ clientEntryPoints, projectRootDir, }) => {
     let isBuild = false;
     return {
         name: "rwsdk:vite:transform-jsx-script-tags",
@@ -347,14 +319,20 @@ export const transformJsxScriptTagsPlugin = ({ manifestPath, }) => {
             isBuild = config.command === "build";
         },
         async transform(code, id) {
+            if (isBuild &&
+                this.environment?.name === "worker" &&
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return null;
+            }
             if (this.environment?.name === "worker" &&
                 id.endsWith(".tsx") &&
                 !id.includes("node_modules") &&
                 hasJsxFunctions(code)) {
                 log("Transforming JSX script tags in %s", id);
                 process.env.VERBOSE && log("Code:\n%s", code);
-                const manifest = isBuild ? await readManifest(manifestPath) : {};
-                const result = await transformJsxScriptTagsCode(code, manifest);
+                // During discovery phase, never use manifest - it doesn't exist yet
+                const result = await transformJsxScriptTagsCode(code, clientEntryPoints, {}, // Empty manifest during discovery
+                projectRootDir);
                 if (result) {
                     log("Transformed JSX script tags in %s", id);
                     process.env.VERBOSE &&