rwsdk 0.0.84 → 0.0.85-test.20250528024240

package/dist/runtime/entries/no-react-server.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("rwsdk: 'react-server' is not supported in this environment");

package/dist/runtime/entries/ssr.d.ts

@@ -0,0 +1 @@
+export * from "../register/ssr";

package/dist/runtime/entries/ssr.js

@@ -0,0 +1 @@
+export * from "../register/ssr";

package/dist/runtime/imports/ssr.d.ts

@@ -0,0 +1,5 @@
+export declare const ssrLoadModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const ssrGetModuleExport: (id: string) => Promise<any>;
+export declare const ssrWebpackRequire: ((id: string) => Promise<{
+    [x: string]: any;
+}>) & import("lodash").MemoizedFunction;

package/dist/runtime/imports/ssr.js

@@ -0,0 +1,20 @@
+import memoize from "lodash/memoize";
+export const ssrLoadModule = memoize(async (id) => {
+    const { useClientLookup } = await import("virtual:use-client-lookup");
+    const moduleFn = useClientLookup[id];
+    if (!moduleFn) {
+        throw new Error(`No module found for '${id}' in module lookup for "use client" directive`);
+    }
+    return await moduleFn();
+});
+export const ssrGetModuleExport = async (id) => {
+    const [file, name] = id.split("#");
+    const module = await ssrLoadModule(file);
+    return module[name];
+};
+// context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
+export const ssrWebpackRequire = memoize(async (id) => {
+    const [file, name] = id.split("#");
+    const module = await ssrLoadModule(file);
+    return { [id]: module[name] };
+});

package/dist/runtime/register/ssr.d.ts

@@ -0,0 +1,2 @@
+export declare const createServerReference: (id: string, name: string) => any;
+export declare const registeredServerFunctions: Map<string, Function>;

package/dist/runtime/register/ssr.js

@@ -0,0 +1,13 @@
+import { createServerReference as baseCreateServerReference } from "react-server-dom-webpack/client.edge";
+const ssrCallServer = (id, args) => {
+    const action = registeredServerFunctions.get(id);
+    if (!action) {
+        throw new Error(`Server function ${id} not found`);
+    }
+    return action(args);
+};
+export const createServerReference = (id, name) => {
+    id = id + "#" + name;
+    return baseCreateServerReference(id, ssrCallServer);
+};
+export const registeredServerFunctions = new Map();

package/dist/runtime/register/worker.js

@@ -1,10 +1,12 @@
 import { registerServerReference as baseRegisterServerReference, registerClientReference as baseRegisterClientReference, decodeReply, } from "react-server-dom-webpack/server.edge";
-import { getModuleExport } from "../imports/worker";
+import { ssrGetModuleExport } from "rwsdk/__ssr_bridge";
 import { IS_DEV } from "../constants";
+import { registeredServerFunctions } from "../ssrBridge";
 export function registerServerReference(action, id, name) {
     if (typeof action !== "function") {
         return action;
     }
+    registeredServerFunctions.set(id, action);
     return baseRegisterServerReference(action, id, name);
 }
 export function registerClientReference(id, exportName, target) {
@@ -30,7 +32,7 @@ export async function rscActionHandler(req) {
     if (IS_DEV && actionId === "__rsc_hot_update") {
         return null;
     }
-    const action = await getModuleExport(actionId);
+    const action = await ssrGetModuleExport(actionId);
     if (typeof action !== "function") {
         throw new Error(`Action ${actionId} is not a function`);
     }

package/dist/runtime/render/renderRscThenableToHtmlStream.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import ReactServerDom from "react-dom/server.edge";
+import { type DocumentProps } from "../lib/router";
+import { type RequestInfo } from "../requestInfo/types";
+export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, }: {
+    thenable: any;
+    Document: React.FC<DocumentProps>;
+    requestInfo: RequestInfo;
+}) => Promise<ReactServerDom.ReactDOMServerReadableStream>;

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import ReactServerDom from "react-dom/server.edge";
+const { use } = React;
+const { renderToReadableStream } = ReactServerDom;
+export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, }) => {
+    const Component = () => {
+        return (_jsx(Document, { ...requestInfo, children: use(thenable).node }));
+    };
+    return await renderToReadableStream(_jsx(Component, {}), {
+        nonce: requestInfo.rw.nonce,
+    });
+};

package/dist/runtime/render/transformRscToHtmlStream.d.ts

@@ -1,7 +1,7 @@
-export declare const transformRscToHtmlStream: ({ stream, Parent, nonce, }: {
+import { DocumentProps } from "../lib/router";
+import { RequestInfo } from "../requestInfo/types";
+export declare const transformRscToHtmlStream: ({ stream, Document, requestInfo, }: {
     stream: ReadableStream;
-    Parent: React.ComponentType<{
-        children: React.ReactNode;
-    }>;
-    nonce?: string;
+    Document: React.FC<DocumentProps>;
+    requestInfo: RequestInfo;
 }) => Promise<import("react-dom/server.js").ReactDOMServerReadableStream>;

package/dist/runtime/render/transformRscToHtmlStream.js

@@ -1,18 +1,17 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { createModuleMap } from "./createModuleMap.js";
-import { createFromReadableStream } from "react-server-dom-webpack/client.edge";
-import { use } from "react";
-import { renderToReadableStream } from "react-dom/server.edge";
-export const transformRscToHtmlStream = ({ stream, Parent = ({ children }) => _jsx(_Fragment, { children: children }), nonce, }) => {
+import ReactServerDom from "react-server-dom-webpack/client.edge";
+import { renderRscThenableToHtmlStream } from "../ssrBridge.js";
+const { createFromReadableStream } = ReactServerDom;
+export const transformRscToHtmlStream = ({ stream, Document, requestInfo, }) => {
     const thenable = createFromReadableStream(stream, {
         serverConsumerManifest: {
             moduleMap: createModuleMap(),
             moduleLoading: null,
         },
     });
-    const Component = () => (_jsx(Parent, { children: use(thenable).node }));
-    const el = _jsx(Component, {});
-    return renderToReadableStream(el, {
-        nonce,
+    return renderRscThenableToHtmlStream({
+        thenable,
+        Document,
+        requestInfo,
     });
 };

package/dist/runtime/ssrBridge.d.ts

@@ -0,0 +1,3 @@
+export { renderRscThenableToHtmlStream } from "./render/renderRscThenableToHtmlStream";
+export { registeredServerFunctions } from "./register/ssr";
+export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";

package/dist/runtime/ssrBridge.js

@@ -0,0 +1,11 @@
+// context(justinvdm, 28 May 2025): This is the "bridge" between the RSC side
+// and and the SSR side, both run inside the same runtime environment. We have
+// this separation so that they can each be processed with their own respective
+// import conditions and bundling logic
+//
+// **NOTE:** Any time we need to import from SSR side in RSC side, we need to
+// import it through this bridge file. We have bundler logic (ssrBridgePlugin)
+// that looks out for imports to this exact file.
+export { renderRscThenableToHtmlStream } from "./render/renderRscThenableToHtmlStream";
+export { registeredServerFunctions } from "./register/ssr";
+export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";

package/dist/runtime/worker.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { transformRscToHtmlStream } from "./render/transformRscToHtmlStream";
 import { renderToRscStream } from "./render/renderToRscStream";
-import { loadModule, ssrWebpackRequire } from "./imports/worker";
+import { ssrLoadModule, ssrWebpackRequire } from "rwsdk/__ssr_bridge";
 import { rscActionHandler } from "./register/worker";
 import { injectRSCPayload } from "rsc-html-stream/server";
 import { ErrorResponse } from "./error";
@@ -102,8 +102,8 @@ export const defineApp = (routes) => {
                     const [rscPayloadStream1, rscPayloadStream2] = rscPayloadStream.tee();
                     const htmlStream = await transformRscToHtmlStream({
                         stream: rscPayloadStream1,
-                        Parent: ({ children }) => (_jsx(rw.Document, { ...requestInfo, children: children })),
-                        nonce: rw.nonce,
+                        Document: rw.Document,
+                        requestInfo: requestInfo,
                     });
                     let html = htmlStream;
                     if (rw.rscPayload) {
@@ -155,7 +155,7 @@ export const defineApp = (routes) => {
     };
 };
 export const SmokeTestWrapper = async ({ children }) => {
-    const smokeTestInfo = await loadModule("/src/app/components/__SmokeTest.tsx");
+    const smokeTestInfo = await ssrLoadModule("/src/app/components/__SmokeTest.tsx");
     const SmokeTestInfo = smokeTestInfo.SmokeTestInfo;
     return (_jsxs(_Fragment, { children: [_jsx(SmokeTestInfo, {}), children] }));
 };

package/dist/vite/checkIsUsingPrisma.d.mts

@@ -1,3 +1,6 @@
-export declare const checkIsUsingPrisma: ({ projectRootDir, }: {
+export type PrismaCheckResult = {
+    isUsingPrisma: boolean;
+};
+export declare const checkPrismaStatus: ({ projectRootDir, }: {
     projectRootDir: string;
-}) => boolean;
+}) => PrismaCheckResult;

package/dist/vite/checkIsUsingPrisma.mjs

@@ -1,9 +1,18 @@
 import enhancedResolve from "enhanced-resolve";
-export const checkIsUsingPrisma = ({ projectRootDir, }) => {
+const isUsingPrisma = ({ projectRootDir }) => {
     try {
-        return Boolean(enhancedResolve.sync(projectRootDir, "@prisma/client"));
+        const prismaClientPath = enhancedResolve.sync(projectRootDir, "@prisma/client");
+        if (!prismaClientPath) {
+            return false;
+        }
+        return true;
     }
     catch {
         return false;
     }
 };
+export const checkPrismaStatus = ({ projectRootDir, }) => {
+    return {
+        isUsingPrisma: isUsingPrisma({ projectRootDir }),
+    };
+};

package/dist/vite/configPlugin.d.mts

@@ -1,9 +1,8 @@
 import { Plugin } from "vite";
-export declare const configPlugin: ({ mode, silent, projectRootDir, clientEntryPathname, workerEntryPathname, isUsingPrisma, }: {
+export declare const configPlugin: ({ mode, silent, projectRootDir, clientEntryPathname, workerEntryPathname, }: {
     mode: "development" | "production";
     silent: boolean;
     projectRootDir: string;
     clientEntryPathname: string;
     workerEntryPathname: string;
-    isUsingPrisma: boolean;
 }) => Plugin;

package/dist/vite/configPlugin.mjs

@@ -8,7 +8,7 @@ const ignoreVirtualModules = {
         });
     },
 };
-export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname, workerEntryPathname, isUsingPrisma, }) => ({
+export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname, workerEntryPathname, }) => ({
     name: "rwsdk:config",
     config: (_, { command }) => {
         const baseConfig = {
@@ -38,6 +38,9 @@ export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname
                         noDiscovery: false,
                         esbuildOptions: {
                             plugins: [ignoreVirtualModules],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
                         },
                     },
                 },
@@ -50,30 +53,10 @@ export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname
                         noDiscovery: false,
                         esbuildOptions: {
                             conditions: ["workerd", "react-server"],
-                            plugins: [
-                                ...(isUsingPrisma
-                                    ? [
-                                        {
-                                            name: "rwsdk:prisma-client-wasm",
-                                            setup(build) {
-                                                build.onResolve({ filter: /.prisma\/client\/default/ }, async (args) => {
-                                                    return {
-                                                        path: resolve(projectRootDir, "node_modules/.prisma/client/wasm.js"),
-                                                    };
-                                                });
-                                            },
-                                        },
-                                    ]
-                                    : []),
-                                ignoreVirtualModules,
-                            ],
+                            plugins: [ignoreVirtualModules],
                         },
-                        include: [
-                            "react/jsx-runtime",
-                            "react/jsx-dev-runtime",
-                            "react-server-dom-webpack/client.edge",
-                            "react-server-dom-webpack/server.edge",
-                        ],
+                        include: [],
+                        exclude: [],
                     },
                     build: {
                         outDir: resolve(projectRootDir, "dist", "worker"),
@@ -95,12 +78,21 @@ export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname
             },
             resolve: {
                 conditions: ["workerd"],
-                alias: {
-                    ...(isUsingPrisma
-                        ? {
-                            ".prisma/client/default": resolve(projectRootDir, "node_modules/.prisma/client/wasm.js"),
-                        }
-                        : {}),
+                alias: [],
+            },
+            builder: {
+                buildApp: async (builder) => {
+                    // note(justinvdm, 27 May 2025): **Ordering is important**:
+                    // * When building, client needs to be build first, so that we have a
+                    //   manifest file to map to when looking at asset references in JSX
+                    //   (e.g. Document.tsx)
+                    // * When bundling, the RSC build imports the SSR build - this way
+                    //   they each can have their own environments (e.g. with their own
+                    //   import conditions), while still having all worker-run code go
+                    //   through the processing done by `@cloudflare/vite-plugin`
+                    await builder.build(builder.environments["client"]);
+                    await builder.build(builder.environments["ssr"]);
+                    await builder.build(builder.environments["rsc"]);
                 },
             },
         };
@@ -110,7 +102,7 @@ export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname
                     worker: {
                         build: {
                             rollupOptions: {
-                                external: ["cloudflare:workers", "node:stream", /\.wasm$/],
+                                external: ["cloudflare:workers", "node:stream"],
                             },
                         },
                     },

package/dist/vite/ensureAliasArray.d.mts

@@ -0,0 +1,2 @@
+import type { Alias, UserConfig } from "vite";
+export declare const ensureAliasArray: (config: UserConfig) => Alias[];

package/dist/vite/ensureAliasArray.mjs

@@ -0,0 +1,11 @@
+export const ensureAliasArray = (config) => {
+    config.resolve ??= {};
+    if (!config.resolve?.alias) {
+        config.resolve.alias = [];
+    }
+    else if (!Array.isArray(config.resolve.alias)) {
+        const existingAlias = config.resolve.alias;
+        config.resolve.alias = Object.entries(existingAlias).map(([find, replacement]) => ({ find, replacement }));
+    }
+    return config.resolve.alias;
+};

package/dist/vite/moveStaticAssetsPlugin.mjs

@@ -6,8 +6,7 @@ export const moveStaticAssetsPlugin = ({ rootDir, }) => ({
         if (this.environment.name === "worker") {
             await $sh({
                 cwd: rootDir,
-            }) `mv dist/worker/assets/* dist/client/assets || true`;
-            await $sh({ cwd: rootDir }) `rmdir dist/worker/assets || true`;
+            }) `mv dist/worker/assets/*.css dist/client/assets/ || true`;
         }
     },
 });

package/dist/vite/prismaPlugin.d.mts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+export declare const prismaPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Promise<Plugin | undefined>;

package/dist/vite/prismaPlugin.mjs

@@ -0,0 +1,43 @@
+import { resolve } from "node:path";
+import { invalidateCacheIfPrismaClientChanged } from "./invalidateCacheIfPrismaClientChanged.mjs";
+import { checkPrismaStatus } from "./checkIsUsingPrisma.mjs";
+import { ensureAliasArray } from "./ensureAliasArray.mjs";
+export const prismaPlugin = async ({ projectRootDir, }) => {
+    if (!checkPrismaStatus({ projectRootDir }).isUsingPrisma) {
+        return;
+    }
+    // context(justinvdm, 10 Mar 2025): We need to use vite optimizeDeps for all deps to work with @cloudflare/vite-plugin.
+    // Thing is, @prisma/client has generated code. So users end up with a stale @prisma/client
+    // when they change their prisma schema and regenerate the client, until clearing out node_modules/.vite
+    // We can't exclude @prisma/client from optimizeDeps since we need it there for @cloudflare/vite-plugin to work.
+    // But we can manually invalidate the cache if the prisma schema changes.
+    await invalidateCacheIfPrismaClientChanged({
+        projectRootDir,
+    });
+    return {
+        name: "rwsdk:prisma",
+        configEnvironment(name, config) {
+            if (name !== "worker") {
+                return;
+            }
+            const wasmPath = resolve(projectRootDir, "node_modules/.prisma/client/wasm.js");
+            config.optimizeDeps ??= {};
+            config.optimizeDeps.esbuildOptions ??= {};
+            config.optimizeDeps.esbuildOptions.plugins ??= [];
+            config.optimizeDeps.esbuildOptions.plugins.push({
+                name: "rwsdk:prisma",
+                setup(build) {
+                    build.onResolve({ filter: /^.prisma\/client\/default/ }, async () => {
+                        return {
+                            path: wasmPath,
+                        };
+                    });
+                },
+            });
+            ensureAliasArray(config).push({
+                find: /^\.prisma\/client\/default/,
+                replacement: wasmPath,
+            });
+        },
+    };
+};

package/dist/vite/reactConditionsResolverPlugin.d.mts

@@ -1,6 +1,18 @@
 import { Plugin } from "vite";
-export declare const reactConditionsResolverPlugin: ({ mode, command, }: {
-    projectRootDir: string;
-    mode?: "development" | "production";
-    command?: "build" | "serve";
-}) => Promise<Plugin>;
+import enhancedResolve from "enhanced-resolve";
+export declare const REACT_IMPORTS: string[];
+export declare const ENV_RESOLVERS: {
+    ssr: enhancedResolve.ResolveFunction;
+    worker: enhancedResolve.ResolveFunction;
+    client: enhancedResolve.ResolveFunction;
+};
+export declare const ENV_IMPORTS: {
+    [k: string]: {
+        aliases: {
+            find: RegExp;
+            replacement: string;
+        }[];
+        optimizeIncludes: string[];
+    };
+};
+export declare const reactConditionsResolverPlugin: () => Promise<Plugin>;