rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -0,0 +1,315 @@
+import { Project, Node, SyntaxKind } from "ts-morph";
+import { readFile } from "node:fs/promises";
+import { pathExists } from "fs-extra";
+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"));
+    }
+    return manifestCache;
+};
+function hasJsxFunctions(text) {
+    return (text.includes('jsx("script"') ||
+        text.includes("jsx('script'") ||
+        text.includes('jsx("link"') ||
+        text.includes("jsx('link'") ||
+        text.includes('jsxs("script"') ||
+        text.includes("jsxs('script'") ||
+        text.includes('jsxs("link"') ||
+        text.includes("jsxs('link'") ||
+        text.includes('jsxDEV("script"') ||
+        text.includes("jsxDEV('script'") ||
+        text.includes('jsxDEV("link"') ||
+        text.includes("jsxDEV('link'"));
+}
+// Transform import statements in script content using ts-morph
+function transformScriptImports(scriptContent, manifest) {
+    const scriptProject = new Project({ useInMemoryFileSystem: true });
+    try {
+        // Wrap in a function to make it valid JavaScript
+        const wrappedContent = `function __wrapper() {${scriptContent}}`;
+        const scriptFile = scriptProject.createSourceFile("script.js", wrappedContent);
+        let hasChanges = false;
+        // Find all CallExpressions that look like import("path")
+        scriptFile
+            .getDescendantsOfKind(SyntaxKind.CallExpression)
+            .forEach((callExpr) => {
+            const expr = callExpr.getExpression();
+            // Check for both "import()" and "await import()" patterns
+            const isImport = expr.getText() === "import";
+            // Check for await import pattern
+            const isAwaitImport = expr.getKind() === SyntaxKind.PropertyAccessExpression &&
+                expr.getText().endsWith(".import");
+            if (isImport || isAwaitImport) {
+                const args = callExpr.getArguments();
+                if (args.length > 0 && Node.isStringLiteral(args[0])) {
+                    const importPath = args[0].getLiteralValue();
+                    if (importPath.startsWith("/")) {
+                        const path = importPath.slice(1); // Remove leading slash
+                        if (manifest[path]) {
+                            const transformedPath = manifest[path].file;
+                            args[0].replaceWithText(`"/${transformedPath}"`);
+                            hasChanges = true;
+                        }
+                    }
+                }
+            }
+        });
+        if (hasChanges) {
+            // Extract the transformed content from inside the wrapper function
+            const fullText = scriptFile.getFullText();
+            // Find content between the first { and the last }
+            const startPos = fullText.indexOf("{") + 1;
+            const endPos = fullText.lastIndexOf("}");
+            const transformedContent = fullText.substring(startPos, endPos);
+            return { content: transformedContent, hasChanges: true };
+        }
+        // Return the original content when no changes are made
+        return { content: scriptContent, hasChanges: false };
+    }
+    catch (error) {
+        // If parsing fails, fall back to the original content
+        console.warn("Failed to parse inline script content:", error);
+        return { content: undefined, hasChanges: false };
+    }
+}
+export async function transformJsxScriptTagsCode(code, manifest = {}) {
+    // context(justinvdm, 15 Jun 2025): Optimization to exit early
+    // to avoidunnecessary ts-morph parsing
+    if (!hasJsxFunctions(code)) {
+        return;
+    }
+    const project = new Project({ useInMemoryFileSystem: true });
+    const sourceFile = project.createSourceFile("temp.tsx", code);
+    let hasModifications = false;
+    let needsRequestInfoImport = false;
+    // Check for existing imports up front
+    let hasRequestInfoImport = false;
+    let sdkWorkerImportDecl;
+    // Scan for imports only once
+    sourceFile.getImportDeclarations().forEach((importDecl) => {
+        const moduleSpecifier = importDecl.getModuleSpecifierValue();
+        if (moduleSpecifier === "rwsdk/worker") {
+            sdkWorkerImportDecl = importDecl;
+            // Check if requestInfo is already imported
+            if (importDecl
+                .getNamedImports()
+                .some((namedImport) => namedImport.getName() === "requestInfo")) {
+                hasRequestInfoImport = true;
+            }
+        }
+    });
+    // Look for jsx function calls (jsx, jsxs, jsxDEV)
+    sourceFile
+        .getDescendantsOfKind(SyntaxKind.CallExpression)
+        .forEach((callExpr) => {
+        const expression = callExpr.getExpression();
+        const expressionText = expression.getText();
+        // Only process jsx/jsxs/jsxDEV calls
+        if (expressionText !== "jsx" &&
+            expressionText !== "jsxs" &&
+            expressionText !== "jsxDEV") {
+            return;
+        }
+        // Get arguments of the jsx call
+        const args = callExpr.getArguments();
+        if (args.length < 2)
+            return;
+        // First argument should be the element type
+        const elementType = args[0];
+        if (!Node.isStringLiteral(elementType))
+            return;
+        const tagName = elementType.getLiteralValue();
+        // Process script and link tags
+        if (tagName === "script" || tagName === "link") {
+            // Second argument should be the props object
+            const propsArg = args[1];
+            // Handle object literals with properties
+            if (Node.isObjectLiteralExpression(propsArg)) {
+                const properties = propsArg.getProperties();
+                // Variables to track script attributes
+                let hasDangerouslySetInnerHTML = false;
+                let hasNonce = false;
+                let hasStringLiteralChildren = false;
+                let hasSrc = false;
+                // Variables to track link attributes
+                let isPreload = false;
+                let hrefValue = null;
+                for (const prop of properties) {
+                    if (Node.isPropertyAssignment(prop)) {
+                        const propName = prop.getName();
+                        const initializer = prop.getInitializer();
+                        // Check for existing nonce
+                        if (propName === "nonce") {
+                            hasNonce = true;
+                        }
+                        // Check for dangerouslySetInnerHTML
+                        if (propName === "dangerouslySetInnerHTML") {
+                            hasDangerouslySetInnerHTML = true;
+                        }
+                        // Check for src attribute
+                        if (tagName === "script" && propName === "src") {
+                            hasSrc = true;
+                            // Also process src for manifest transformation if needed
+                            if (Node.isStringLiteral(initializer) ||
+                                Node.isNoSubstitutionTemplateLiteral(initializer)) {
+                                const srcValue = initializer.getLiteralValue();
+                                if (srcValue.startsWith("/") && manifest[srcValue.slice(1)]) {
+                                    const path = srcValue.slice(1); // Remove leading slash
+                                    const transformedSrc = manifest[path].file;
+                                    const originalText = initializer.getText();
+                                    const isTemplateLiteral = Node.isNoSubstitutionTemplateLiteral(initializer);
+                                    const quote = isTemplateLiteral
+                                        ? "`"
+                                        : originalText.charAt(0);
+                                    // Preserve the original quote style
+                                    if (isTemplateLiteral) {
+                                        initializer.replaceWithText(`\`/${transformedSrc}\``);
+                                    }
+                                    else if (quote === '"') {
+                                        initializer.replaceWithText(`"/${transformedSrc}"`);
+                                    }
+                                    else {
+                                        initializer.replaceWithText(`'/${transformedSrc}'`);
+                                    }
+                                    hasModifications = true;
+                                }
+                            }
+                        }
+                        // Check for string literal children
+                        if (tagName === "script" &&
+                            propName === "children" &&
+                            (Node.isStringLiteral(initializer) ||
+                                Node.isNoSubstitutionTemplateLiteral(initializer))) {
+                            hasStringLiteralChildren = true;
+                            const scriptContent = initializer.getLiteralValue();
+                            // Transform import statements in script content using ts-morph
+                            const { content: transformedContent, hasChanges } = transformScriptImports(scriptContent, manifest);
+                            if (hasChanges && transformedContent) {
+                                // Get the raw text with quotes to determine the exact format
+                                const isTemplateLiteral = Node.isNoSubstitutionTemplateLiteral(initializer);
+                                if (isTemplateLiteral) {
+                                    // Simply wrap the transformed content in backticks
+                                    initializer.replaceWithText("`" + transformedContent + "`");
+                                }
+                                else {
+                                    initializer.replaceWithText(JSON.stringify(transformedContent));
+                                }
+                                hasModifications = true;
+                            }
+                        }
+                        // For link tags, first check if it's a preload/modulepreload
+                        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();
+                            }
+                        }
+                    }
+                }
+                // Add nonce to script tags if needed
+                if (tagName === "script" &&
+                    !hasNonce &&
+                    !hasDangerouslySetInnerHTML &&
+                    (hasStringLiteralChildren || hasSrc)) {
+                    // Add nonce property to the props object
+                    propsArg.addPropertyAssignment({
+                        name: "nonce",
+                        initializer: "requestInfo.rw.nonce",
+                    });
+                    if (!hasRequestInfoImport) {
+                        needsRequestInfoImport = true;
+                    }
+                    hasModifications = true;
+                }
+                // Transform href if this is a preload link
+                if (tagName === "link" &&
+                    isPreload &&
+                    hrefValue &&
+                    hrefValue.startsWith("/") &&
+                    manifest[hrefValue.slice(1)]) {
+                    const path = hrefValue.slice(1); // Remove leading slash
+                    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);
+                                // Preserve the original quote style
+                                if (isTemplateLiteral) {
+                                    initializer.replaceWithText(`\`/${transformedHref}\``);
+                                }
+                                else if (quote === '"') {
+                                    initializer.replaceWithText(`"/${transformedHref}"`);
+                                }
+                                else {
+                                    initializer.replaceWithText(`'/${transformedHref}'`);
+                                }
+                                hasModifications = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    });
+    // Add requestInfo import if needed and not already imported
+    if (needsRequestInfoImport && hasModifications) {
+        if (sdkWorkerImportDecl) {
+            // Module is imported but need to add requestInfo
+            if (!hasRequestInfoImport) {
+                sdkWorkerImportDecl.addNamedImport("requestInfo");
+            }
+        }
+        else {
+            // Add new import declaration
+            sourceFile.addImportDeclaration({
+                moduleSpecifier: "rwsdk/worker",
+                namedImports: ["requestInfo"],
+            });
+        }
+    }
+    // Return the transformed code only if modifications were made
+    if (hasModifications) {
+        return {
+            code: sourceFile.getFullText(),
+            map: null,
+        };
+    }
+    return;
+}
+export const transformJsxScriptTagsPlugin = ({ manifestPath, }) => {
+    let isBuild = false;
+    return {
+        name: "rwsdk:transform-jsx-script-tags",
+        configResolved(config) {
+            isBuild = config.command === "build";
+        },
+        async transform(code) {
+            if (this.environment.name !== "worker") {
+                return;
+            }
+            const manifest = isBuild ? await readManifest(manifestPath) : {};
+            return transformJsxScriptTagsCode(code, manifest);
+        },
+    };
+};

package/dist/vite/transformJsxScriptTagsPlugin.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/vite/transformJsxScriptTagsPlugin.test.mjs

@@ -0,0 +1,334 @@
+import { describe, it, expect } from "vitest";
+import { transformJsxScriptTagsCode } from "./transformJsxScriptTagsPlugin.mjs";
+describe("transformJsxScriptTagsCode", () => {
+    const mockManifest = {
+        "src/client.tsx": { file: "assets/client-a1b2c3d4.js" },
+        "src/entry.js": { file: "assets/entry-e5f6g7h8.js" },
+        "src/styles.css": { file: "assets/styles-i9j0k1l2.css" },
+    };
+    it("transforms script src attributes in JSX", async () => {
+        const code = `
+      jsx("script", {
+        src: "/src/client.tsx",
+        type: "module"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        src: "/assets/client-a1b2c3d4.js",
+        type: "module",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("transforms inline scripts with dynamic imports", async () => {
+        const code = `
+      jsx("script", {
+        type: "module",
+        children: "import('/src/client.tsx').then(module => { console.log(module); })"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        type: "module",
+        children: "import(\\"\/assets\/client-a1b2c3d4.js\\").then(module => { console.log(module); })",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("transforms inline scripts with type=module", async () => {
+        const code = `
+      jsx("script", { type: "module", children: "import('/src/client.tsx')" })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", { type: "module", children: "import(\\"\/assets\/client-a1b2c3d4.js\\")",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("transforms inline scripts with multiline content", async () => {
+        const code = `
+      jsx("script", {
+        type: "module",
+        children: \`
+          // Some comments here
+          const init = async () => {
+            await import('/src/entry.js');
+            console.log('initialized');
+          };
+          init();
+        \`
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        type: "module",
+        children: \`
+          // Some comments here
+          const init = async () => {
+            await import("/assets/entry-e5f6g7h8.js");
+            console.log('initialized');
+          };
+          init();
+        \`,
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("transforms multiple imports in the same inline script", async () => {
+        const code = `
+      jsx("script", {
+        type: "module",
+        children: \`
+          import('/src/client.tsx');
+          import('/src/entry.js');
+        \`
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        type: "module",
+        children: \`
+          import("/assets/client-a1b2c3d4.js");
+          import("/assets/entry-e5f6g7h8.js");
+        \`,
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("transforms link href attributes with preload rel", async () => {
+        const code = `
+      jsx("link", {
+        rel: "preload",
+        href: "/src/client.tsx",
+        as: "script"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`
+      jsx("link", {
+        rel: "preload",
+        href: "/assets/client-a1b2c3d4.js",
+        as: "script"
+      })
+    `);
+    });
+    it("transforms link href attributes with modulepreload rel", async () => {
+        const code = `
+      jsx("link", {
+        href: "/src/client.tsx",
+        rel: "modulepreload"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`
+      jsx("link", {
+        href: "/assets/client-a1b2c3d4.js",
+        rel: "modulepreload"
+      })
+    `);
+    });
+    it("transforms real-world Document component example", async () => {
+        const code = `
+      jsx("html", {
+        lang: "en",
+        children: [
+          jsx("head", {
+            children: [
+              jsx("meta", { charSet: "utf-8" }),
+              jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+              jsx("title", { children: "@redwoodjs/starter-standard" }),
+              jsx("link", { rel: "modulepreload", href: "/src/client.tsx", as: "script" })
+            ]
+          }),
+          jsx("body", {
+            children: [
+              jsx("div", { id: "root", children: props.children }),
+              jsx("script", { children: 'import("/src/client.tsx")' })
+            ]
+          })
+        ]
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("html", {
+        lang: "en",
+        children: [
+          jsx("head", {
+            children: [
+              jsx("meta", { charSet: "utf-8" }),
+              jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+              jsx("title", { children: "@redwoodjs/starter-standard" }),
+              jsx("link", { rel: "modulepreload", href: "/assets/client-a1b2c3d4.js", as: "script" })
+            ]
+          }),
+          jsx("body", {
+            children: [
+              jsx("div", { id: "root", children: props.children }),
+              jsx("script", { children: "import(\\"\/assets\/client-a1b2c3d4.js\\")",
+                  nonce: requestInfo.rw.nonce
+            })
+            ]
+          })
+        ]
+      })
+    `);
+    });
+    it("returns null when no transformations are needed", async () => {
+        const code = `
+      jsx("div", { children: "No scripts or links here" })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result).toBeUndefined();
+    });
+    it("handles paths not found in manifest", async () => {
+        const code = `
+      jsx("script", {
+        src: "/src/non-existent.js",
+        type: "module"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        src: "/src/non-existent.js",
+        type: "module",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("adds nonce to script tags with src attribute and imports requestInfo", async () => {
+        const code = `
+      jsx("script", {
+        src: "/src/client.tsx",
+        type: "module"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, mockManifest);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        src: "/assets/client-a1b2c3d4.js",
+        type: "module",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("adds nonce to script tags with string literal children", async () => {
+        const code = `
+      jsx("script", {
+        type: "module",
+        children: "console.log('hello world')"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, {});
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        type: "module",
+        children: "console.log('hello world')",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("does not add nonce to script tags with dangerouslySetInnerHTML", async () => {
+        const code = `
+      jsx("script", {
+        type: "module",
+        dangerouslySetInnerHTML: { __html: "console.log('hello world')" }
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, {});
+        expect(result?.code).toEqual(undefined);
+    });
+    it("does not add nonce to script tags that already have nonce", async () => {
+        const code = `
+      jsx("script", {
+        type: "module",
+        children: "console.log('hello world')",
+        nonce: "existing-nonce"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, {});
+        expect(result?.code).toEqual(undefined);
+    });
+    it("uses existing requestInfo import if already present", async () => {
+        const code = `
+      import { foo } from 'bar';
+      import { requestInfo, someOtherThing } from "rwsdk/worker";
+      
+      jsx("script", {
+        type: "module",
+        children: "console.log('hello world')"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, {});
+        expect(result?.code).toEqual(`
+      import { foo } from 'bar';
+      import { requestInfo, someOtherThing } from "rwsdk/worker";
+      
+      jsx("script", {
+        type: "module",
+        children: "console.log('hello world')",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+        // Ensure we didn't duplicate the import
+        const importCount = (result?.code.match(/from "rwsdk\/worker"/g) || [])
+            .length;
+        expect(importCount).toBe(1);
+    });
+    it("adds requestInfo to existing SDK import if module already imported", async () => {
+        const code = `
+      import { foo } from 'bar';
+      import { someOtherThing } from "rwsdk/worker";
+      
+      jsx("script", {
+        type: "module",
+        children: "console.log('hello world')"
+      })
+    `;
+        const result = await transformJsxScriptTagsCode(code, {});
+        expect(result?.code).toEqual(`
+      import { foo } from 'bar';
+      import { someOtherThing, requestInfo } from "rwsdk/worker";
+      
+      jsx("script", {
+        type: "module",
+        children: "console.log('hello world')",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+    it("works in development mode without a manifest", async () => {
+        const code = `
+      jsx("script", {
+        src: "/src/client.tsx",
+        type: "module"
+      })
+    `;
+        // Call without providing manifest (simulating dev mode)
+        const result = await transformJsxScriptTagsCode(code);
+        expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
+
+      jsx("script", {
+        src: "/src/client.tsx",
+        type: "module",
+          nonce: requestInfo.rw.nonce
+    })
+    `);
+    });
+});

package/dist/vite/transformServerFunctions.d.mts

@@ -0,0 +1,16 @@
+interface TransformResult {
+    code: string;
+    map?: any;
+}
+type ExportInfoCompat = {
+    localFunctions: Set<string>;
+    reExports: Array<{
+        localName: string;
+        originalName: string;
+        moduleSpecifier: string;
+    }>;
+};
+export declare const findExportedFunctions: (code: string, normalizedId?: string) => Set<string>;
+export declare const findExportInfo: (code: string, normalizedId?: string) => ExportInfoCompat;
+export declare const transformServerFunctions: (code: string, normalizedId: string, environment: "client" | "worker" | "ssr", serverFiles?: Set<string>, addServerModule?: (environment: string, id: string) => void) => TransformResult | undefined;
+export type { TransformResult };