eddev 2.0.0-beta.12 → 2.0.0-beta.121

package/dist/app/server/proxy-wp-admin.js

@@ -1,22 +1,46 @@
 /// <reference types="vinxi/types/server" />
 import { splitSetCookieString } from "cookie-es";
 import { getProxyRequestHeaders, getRequestURL, getWebRequest } from "vinxi/http";
-import { getManifest } from "vinxi/manifest";
-export async function proxyWpAdmin(event, serverContext) {
-    const replaceUrls = serverContext.replaceUrls;
+import { ServerContext } from "./server-context.js";
+import { renderErrorPage } from "./render-ssr-page.js";
+export async function proxyWpAdmin(event) {
+    const serverContext = ServerContext.main;
     const req = getWebRequest(event);
-    const proxyUrl = serverContext.getOriginUrl(getRequestURL(event).href);
+    const reqUrl = getRequestURL(event);
+    const serverlessConfig = serverContext.config.serverless;
+    if (!serverContext.dev) {
+        if (reqUrl.pathname.toLowerCase().match(/\/+(graphql|xmlrpc|index\.php|wp\-(admin|login|json))/)) {
+            if (serverlessConfig.admin === "hide") {
+                return renderErrorPage({
+                    code: 404,
+                    pathname: reqUrl.pathname,
+                    title: "Not Found",
+                });
+            }
+        }
+    }
+    const proxyUrl = serverContext.getOriginUrl(reqUrl.href);
     // Prepare request headers to be sent to the origin server
     const proxyHeaders = getProxyRequestHeaders(event);
     proxyHeaders["X-ED-Dev-Proxy"] = "true";
+    const followRedirects = !reqUrl.pathname.match(/\.[a-z0-9]$/) && !reqUrl.pathname.match(/(^\/wp-|\.php$)/);
     // Forward the request to the origin server
+    // console.log("Proxying request", proxyUrl, {
+    //   method: req.method,
+    //   referrer: req.referrer,
+    //   referrerPolicy: req.referrerPolicy,
+    //   headers: proxyHeaders,
+    //   // body: req.method.match(/get|head|options/i) ? undefined : await req.blob(),
+    //   redirect: followRedirects ? "follow" : "manual",
+    //   cache: "no-cache",
+    // })
     const response = await fetch(proxyUrl, {
         method: req.method,
         referrer: req.referrer,
         referrerPolicy: req.referrerPolicy,
         headers: proxyHeaders,
         body: req.method.match(/get|head|options/i) ? undefined : await req.blob(),
-        redirect: "manual",
+        redirect: followRedirects ? "follow" : "manual",
         cache: "no-cache",
     });
     const contentType = response.headers.get("content-type");
@@ -31,8 +55,8 @@ export async function proxyWpAdmin(event, serverContext) {
             cookies.push(...splitSetCookieString(value));
             return;
         }
-        if (key === "location" && replaceUrls) {
-            value = replaceUrls(value);
+        if (key === "location") {
+            value = serverContext.replaceUrls(value);
         }
         res.headers.set(key, value);
     });
@@ -46,22 +70,25 @@ export async function proxyWpAdmin(event, serverContext) {
     // Replace URLs pointing to the origin server from the response itself
     // This is only done for text-based content types, like application/json, text/plain, text/html etc
     if (contentType?.match(/(application|text)\//)) {
-        if (replaceUrls) {
-            body = replaceUrls((await response.text()) ?? "");
-        }
+        body = serverContext.replaceUrls((await response.text()) ?? "", reqUrl.origin);
         // If the content type is text/html, inject the Vite assets into the response — assuming the placeholder comments are found
         if (contentType.startsWith("text/html")) {
-            const clientManifest = getManifest("admin");
+            const clientManifest = serverContext.runtime.getManifest("admin");
             const assets = await clientManifest.inputs[clientManifest.handler].assets();
-            body = body.replace("<!---VITE_HEADER--->", () => assets.map((asset) => renderAsset(asset)).join("\n"));
-            body = body.replace("<!---VITE_FOOTER--->", () => renderAsset({
+            const getViteHeader = () => assets.map((asset) => renderAsset(asset)).join("\n");
+            const getViteFooter = () => renderAsset({
                 tag: "script",
                 attrs: {
                     type: "module",
                     src: clientManifest.inputs[clientManifest.handler].output.path,
                 },
                 children: "",
-            }));
+            });
+            const encodeForJSON = (str) => JSON.stringify(str).slice(1, -1).replaceAll("/", "\\/");
+            body = body.replaceAll("<!---VITE_HEADER--->", getViteHeader());
+            body = body.replaceAll("<!---VITE_FOOTER--->", getViteFooter());
+            body = body.replaceAll("<script id='vite-iframe-header'><\\/script>", encodeForJSON(getViteHeader()));
+            body = body.replaceAll("<script id='vite-iframe-footer'><\\/script>", encodeForJSON(getViteFooter()));
         }
     }
     else {

package/dist/app/server/render-ssr-page.d.ts

@@ -1,2 +1,27 @@
-import type { RouteData } from "../lib/routing/types.js";
-export declare function renderPageToSSRStream(pathname: string, initialData: RouteData): Promise<unknown>;
+import type { RouteDataWithTrackers } from "../lib/routing/types.js";
+type SSRArgs = {
+    pathname: string;
+    initialData: RouteDataWithTrackers;
+};
+export declare function getSsrStream(args: SSRArgs): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+type RenderArgs = {
+    pathname: string;
+    statusCode?: number;
+    newOrigin?: string;
+};
+export declare function renderPage(args: RenderArgs): Promise<Response>;
+type RenderErrorPageArgs = {
+    pathname: string;
+    code: number;
+    title: string;
+    newOrigin?: string;
+    realError?: Error;
+};
+export declare function renderErrorPage(args: RenderErrorPageArgs): Promise<Response>;
+type Asset = {
+    tag: string;
+    attrs: Record<string, string | boolean>;
+    children?: string;
+};
+export declare function renderAsset({ tag, attrs, children }: Asset): string;
+export {};

package/dist/app/server/render-ssr-page.js

@@ -1,22 +1,202 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { renderAsset } from "@vinxi/react";
-import { Suspense } from "react";
-import { renderToPipeableStream } from "react-dom/server";
-import { getManifest } from "vinxi/manifest";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { renderToPipeableStream, renderToString } from "react-dom/server";
+import { Writable } from "stream";
+import { MetaTags } from "../entry/MetaTags.js";
 import { SSRRoot } from "../entry/ssr-root.js";
 import { RouteLoader } from "../lib/routing/loader.js";
-export async function renderPageToSSRStream(pathname, initialData) {
-    const clientManifest = getManifest("client");
-    const assets = await clientManifest.inputs[clientManifest.handler].assets();
-    const jsx = (_jsx(SSRRoot, { assets: _jsx(Suspense, { children: assets.map((m) => renderAsset(m)) }), pathname: pathname, initialData: initialData, loader: new RouteLoader() }));
-    const stream = await new Promise(async (resolve) => {
+import { AssetCaptureContext } from "../utils/asset-capture.js";
+import { ServerContext } from "./server-context.js";
+import { Suspense } from "react";
+export async function getSsrStream(args) {
+    const clientManifest = ServerContext.main.runtime.getManifest("client");
+    const preloadAssets = new Set([clientManifest.handler]);
+    const includedAssets = new Set();
+    const jsx = (_jsx(Suspense, { children: _jsx(AssetCaptureContext.Provider, { value: preloadAssets, children: _jsx(SSRRoot, { metaTags: args.initialData?.meta?.head || [], pathname: args.pathname, initialData: args.initialData, loader: new RouteLoader() }) }) }));
+    const stream = await new Promise(async (resolve, reject) => {
+        // console.log("Rendering to pipable")
         const stream = renderToPipeableStream(jsx, {
+            identifierPrefix: "ed",
             onShellReady() {
+                // console.log("Shell ready")
                 resolve(stream);
             },
+            onShellError(err) {
+                console.log("onShellError", err);
+                reject(err);
+            },
+            onError(err, errInfo) {
+                console.log("Error occurred after shell ready", err, errInfo);
+                console.error(err);
+            },
             bootstrapModules: [clientManifest.inputs[clientManifest.handler].output.path],
-            bootstrapScriptContent: `window.manifest = ${JSON.stringify(await clientManifest.json())}; window._PAGE_DATA = ${JSON.stringify(initialData)}`,
+            bootstrapScriptContent: `\nwindow.manifest = ${JSON.stringify(await clientManifest.json())};\nwindow._PAGE_DATA = ${JSON.stringify({
+                ...args.initialData,
+                trackers: undefined,
+            })};\n`,
+        });
+    });
+    const [initial, middle, end] = renderToString(_jsxs("html", { lang: "en", children: [_jsxs("head", { children: ["%%$%%", _jsx(MetaTags, { tags: args.initialData.meta?.head ?? [] }), "%%trackers_head%%"] }), _jsxs("body", { children: ["%%trackers_body%%", _jsx("div", { id: "root", children: "%%$%%" }), "%%trackers_footer%%"] })] }))
+        .replace(/%%trackers_(head|body|footer)%%/g, (_, name) => {
+        return args.initialData.trackers?.[name] || "";
+    })
+        .split("%%$%%");
+    return new ReadableStream({
+        async start(controller) {
+            controller.enqueue(new TextEncoder().encode(initial));
+            const inner = await new Promise((resolve, reject) => {
+                let buffer = [];
+                const writableStream = new Writable({
+                    emitClose: true,
+                    write(chunk, encoding, callback) {
+                        buffer.push(chunk);
+                        // controller.enqueue(chunk)
+                        callback();
+                    },
+                    final(callback) {
+                        resolve(buffer);
+                        // controller.close()
+                        callback();
+                    },
+                });
+                stream.pipe(writableStream);
+            });
+            for (const input of preloadAssets) {
+                const assets = await clientManifest.inputs[input].assets();
+                // controller.enqueue(new TextEncoder().encode(`\n<!-- for ${input} -->`))
+                for (const _asset of assets) {
+                    const asset = _asset;
+                    // Ensure that each asset is only included once
+                    const key = asset?.attrs?.key;
+                    if (!key) {
+                        throw new Error("Asset must have a key: " + JSON.stringify(asset));
+                    }
+                    if (includedAssets.has(key))
+                        continue;
+                    includedAssets.add(key);
+                    // Render the asset
+                    try {
+                        const tag = renderAsset(asset);
+                        controller.enqueue(new TextEncoder().encode(tag + "\n"));
+                    }
+                    catch (err) {
+                        controller.enqueue(new TextEncoder().encode(`\n<!-- ${JSON.stringify(err)} -->\n`));
+                    }
+                }
+            }
+            // console.log("ASSETS", await clientManifest)
+            controller.enqueue(new TextEncoder().encode(middle));
+            for (const chunk of inner) {
+                controller.enqueue(chunk);
+            }
+            controller.enqueue(new TextEncoder().encode(end));
+            // console.log("Assets", dynamicAssets)
+            controller.close();
+        },
+    });
+}
+export async function renderPage(args) {
+    const serverContext = ServerContext.main;
+    let headers = new Headers();
+    let responseInit = {
+        headers,
+    };
+    try {
+        const [{ appData, trackers }, response] = await Promise.all([
+            serverContext.fetchAppData(),
+            serverContext.fetchRouteData({
+                pathname: args.pathname,
+                newOrigin: args.newOrigin,
+            }),
+        ]);
+        let data;
+        try {
+            data = await response.json();
+            data.appData = appData;
+            data.trackers = trackers;
+            responseInit.status = response.status;
+        }
+        catch (err) {
+            console.error(err);
+            return renderErrorPage({
+                pathname: args.pathname,
+                code: 500,
+                newOrigin: args.newOrigin,
+                realError: err,
+                title: "Internal Server Error",
+            });
+        }
+        if (data.redirect) {
+            return new Response(null, {
+                status: data.status || 302,
+                headers: {
+                    Location: data.redirect,
+                },
+            });
+        }
+        headers.set("Content-Type", "text/html; charset=utf-8");
+        const stream = await getSsrStream({
+            ...args,
+            initialData: data,
+        });
+        return new Response(stream, responseInit);
+    }
+    catch (err) {
+        console.error(err);
+        if (args.statusCode !== 500) {
+            return renderErrorPage({
+                pathname: args.pathname,
+                code: 500,
+                newOrigin: args.newOrigin,
+                realError: err,
+                title: "Internal Server Error",
+            });
+        }
+        return new Response('<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1>500 Internal Server Error</h1><p>"' +
+            String(err) +
+            '"</p></body></html>', {
+            status: 500,
+            statusText: "Internal Server Error",
+            headers: {
+                "Content-Type": "text/html; charset=utf-8",
+            },
         });
+    }
+}
+export async function renderErrorPage(args) {
+    return renderPage({
+        pathname: "/_error",
+        statusCode: args.code,
+        newOrigin: args.newOrigin,
     });
-    return stream;
+}
+export function renderAsset({ tag, attrs, children }) {
+    const formatAttributes = (attributes) => {
+        return Object.entries(attributes)
+            .map(([attr, value]) => {
+            if (value === true) {
+                return attr;
+            }
+            else if (value !== false && value != null) {
+                return `${attr}="${String(value).replace(/"/g, "&quot;")}"`;
+            }
+            return "";
+        })
+            .filter(Boolean)
+            .join(" ");
+    };
+    switch (tag) {
+        case "script":
+            if (attrs.src) {
+                return `<script ${formatAttributes(attrs)}></script>`;
+            }
+            else {
+                return `<script ${formatAttributes(attrs)}>${children ?? ""}</script>`;
+            }
+        case "link":
+            return `<link ${formatAttributes(attrs)} />`;
+        case "style":
+            return `<style ${formatAttributes(attrs)}>${children ?? ""}</style>`;
+        default:
+            return "";
+    }
 }

package/dist/app/server/rpc.d.ts

@@ -0,0 +1,56 @@
+import { AnyProcedure } from "@trpc/server";
+import { FetchCreateContextFnOptions } from "@trpc/server/adapters/fetch";
+export declare const rpcApi: {
+    _config: import("@trpc/server/unstable-core-do-not-import").RootConfig<{
+        ctx: RPCContext;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: true;
+    }>;
+    procedure: import("@trpc/server/unstable-core-do-not-import").ProcedureBuilder<RPCContext, object, object, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, false>;
+    middleware: <$ContextOverrides>(fn: import("@trpc/server/unstable-core-do-not-import").MiddlewareFunction<RPCContext, object, object, $ContextOverrides, unknown>) => import("@trpc/server/unstable-core-do-not-import").MiddlewareBuilder<RPCContext, object, $ContextOverrides, unknown>;
+    router: {
+        <TInput extends import("@trpc/server").RouterRecord>(input: TInput): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+            ctx: RPCContext;
+            meta: object;
+            errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: true;
+        }, TInput>;
+        <TInput extends import("@trpc/server/unstable-core-do-not-import").CreateRouterOptions>(input: TInput): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+            ctx: RPCContext;
+            meta: object;
+            errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+            transformer: true;
+        }, import("@trpc/server/unstable-core-do-not-import").DecorateCreateRouterOptions<TInput>>;
+    };
+    mergeRouters: typeof import("@trpc/server/unstable-core-do-not-import").mergeRouters;
+    createCallerFactory: <TRecord extends import("@trpc/server").RouterRecord>(router: Pick<import("@trpc/server/unstable-core-do-not-import").Router<{
+        ctx: RPCContext;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: true;
+    }, TRecord>, "_def">) => import("@trpc/server/unstable-core-do-not-import").RouterCaller<{
+        ctx: RPCContext;
+        meta: object;
+        errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+        transformer: true;
+    }, TRecord>;
+};
+type RouterSchema = Record<string, Record<string, AnyProcedure> | AnyProcedure>;
+export declare const rpc: {
+    middleware: <$ContextOverrides>(fn: import("@trpc/server/unstable-core-do-not-import").MiddlewareFunction<RPCContext, object, object, $ContextOverrides, unknown>) => import("@trpc/server/unstable-core-do-not-import").MiddlewareBuilder<RPCContext, object, $ContextOverrides, unknown>;
+    procedure: import("@trpc/server/unstable-core-do-not-import").ProcedureBuilder<RPCContext, object, object, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, typeof import("@trpc/server/unstable-core-do-not-import").unsetMarker, false>;
+    router<T extends RouterSchema>(routes: T): T;
+};
+export declare function defineServerContext<T>(func: (opts: FetchCreateContextFnOptions) => T): (opts: FetchCreateContextFnOptions) => T;
+export declare function instantiateRouter<T extends RouterSchema>(routes: T): import("@trpc/server/unstable-core-do-not-import").BuiltRouter<{
+    ctx: RPCContext;
+    meta: object;
+    errorShape: import("@trpc/server/unstable-core-do-not-import").DefaultErrorShape;
+    transformer: true;
+}, T>;
+export type InferRPCServerContext<TFunc extends null | ((opts: FetchCreateContextFnOptions) => any)> = {
+    req: Request;
+    resHeaders: Headers;
+} & (TFunc extends (opts: FetchCreateContextFnOptions) => infer T ? T : {});
+export {};

package/dist/app/server/rpc.js

@@ -0,0 +1,18 @@
+import { initTRPC } from "@trpc/server";
+import superjson from "superjson";
+export const rpcApi = initTRPC.context().create({
+    transformer: superjson,
+});
+export const rpc = {
+    middleware: rpcApi.middleware,
+    procedure: rpcApi.procedure,
+    router(routes) {
+        return routes;
+    },
+};
+export function defineServerContext(func) {
+    return func;
+}
+export function instantiateRouter(routes) {
+    return rpcApi.router(routes);
+}

package/dist/app/server/server-context.d.ts

@@ -1,25 +1,49 @@
-import { UrlReplacerConf } from "./utils/replace-host.js";
+import { Manifest } from "vinxi/dist/types/types/manifest";
 import { RequestHeaders } from "vinxi/http";
+import type { EDConfig } from "../../node/project/config.js";
+import { TrackerTags } from "../lib/routing/types.js";
+import { UrlReplacerConf } from "./utils/replace-host.js";
+import { QueryMonitor } from "../utils/query-monitor.js";
 export type ServerContextArgs = {
     dev: boolean;
     origin: string;
     replaceUrls?: UrlReplacerConf;
+    rpcBases?: string[];
+    config: EDConfig;
+};
+export type ServerContextRuntime = {
+    getManifest: (name: string) => Manifest;
+};
+/**
+ * Data returned from WordPress origin /_appdata route
+ */
+type ServerAppData = {
+    appData: any;
+    trackers: TrackerTags;
 };
 export declare class ServerContext {
     dev: boolean;
     origin: string;
-    replaceUrls?: (text: string) => string;
+    _urlReplacer?: (text: string, origin?: string) => string;
+    rpcBases: string[];
+    config: EDConfig;
+    static main: ServerContext;
     constructor(conf: ServerContextArgs);
+    replaceUrls(text: string, origin?: string): string;
+    get runtime(): ServerContextRuntime;
+    static setRuntime(rt: ServerContextRuntime): void;
     getOriginUrl(url: string): string;
     fetchOrigin(url: string, opts?: RequestInit & {
         replaceUrls?: boolean;
+        newOrigin?: string;
     }): Promise<Response>;
+    debugLogQueryMonitor(kind: "props" | "mutation" | "query" | "app", uri: string, monitor: QueryMonitor.Entry[]): void;
     fetchRouteData(req: {
         pathname: string;
-        query?: Record<string, any>;
         headers?: RequestHeaders;
-        withAppData?: boolean;
+        newOrigin?: string;
     }): Promise<Response>;
+    fetchAppData(): Promise<ServerAppData>;
     extractRequestHeaders(req?: RequestHeaders): Partial<Record<import("vinxi/http").HTTPHeaderName, string | undefined>>;
     fetchNamedQuery(req: {
         name: string;
@@ -31,4 +55,20 @@ export declare class ServerContext {
         body: object;
         headers: RequestHeaders;
     }): Promise<Response>;
+    get allowedCorsOrigins(): string[];
+    getCorsOrigin(originHeader: string): string | undefined;
+    getCorsHeaders(origin: string): {
+        "Access-Control-Allow-Methods"?: undefined;
+        "Access-Control-Allow-Origin"?: undefined;
+        "Access-Control-Allow-Credentials"?: undefined;
+        "Access-Control-Allow-Headers"?: undefined;
+        "Access-Control-Expose-Headers"?: undefined;
+    } | {
+        "Access-Control-Allow-Methods": string;
+        "Access-Control-Allow-Origin": string;
+        "Access-Control-Allow-Credentials": string;
+        "Access-Control-Allow-Headers": string;
+        "Access-Control-Expose-Headers": string;
+    };
 }
+export {};