eddev 2.0.0-beta.9 → 2.0.0-beta.91

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

@@ -1,22 +1,154 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } 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 { RouteLoader } from "../lib/routing/loader";
-import { SSRRoot } from "../entry/ssr-root";
-export async function renderPageToSSRStream(pathname, initialData) {
-    const clientManifest = getManifest("client");
+import { renderToPipeableStream, renderToString } from "react-dom/server";
+import { SSRRoot } from "../entry/ssr-root.js";
+import { RouteLoader } from "../lib/routing/loader.js";
+import { ServerContext } from "./server-context.js";
+import { Writable } from "stream";
+import { MetaTags } from "../entry/MetaTags.js";
+import { AssetCaptureContext } from "../utils/asset-capture.js";
+export async function getSsrStream(args) {
+    const clientManifest = ServerContext.main.runtime.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) => {
+    // console.log(
+    //   "M",
+    //   assets.filter((f) => (f as any).tag === "script"),
+    //   clientManifest.inputs[clientManifest.handler],
+    // )
+    // for (let k in clientManifest.chunks) {
+    //   console.log(k)
+    // }
+    const dynamicAssets = new Set([]);
+    const jsx = (_jsx(AssetCaptureContext.Provider, { value: dynamicAssets, children: _jsx(SSRRoot, { assets: _jsx(Suspense, { children: assets.map((m) => renderAsset(m)) }), 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, {
             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: `window.manifest = ${JSON.stringify(await clientManifest.json())};\nwindow._PAGE_DATA = ${JSON.stringify(args.initialData)};\nwindow._TRACKERS = ${JSON.stringify(args.initialData.trackers)};`,
         });
     });
-    return stream;
+    const [initial, middle, end] = renderToString(_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx(MetaTags, { tags: args.initialData.meta?.head ?? [] }), _jsx(MetaTags, { tags: args.initialData.trackers?.head ?? [] }), assets.map((m) => renderAsset(m)), "%%%%"] }), _jsxs("body", { children: [_jsx(MetaTags, { tags: args.initialData.trackers?.body ?? [] }), _jsx("div", { id: "_root", children: "%%%%" }), _jsx(MetaTags, { tags: args.initialData.trackers?.footer ?? [] })] })] })).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);
+            });
+            console.log(clientManifest.json());
+            for (const asset of dynamicAssets) {
+                // const assets = await clientManifest.inputs["/" + asset].assets()
+                // console.log(assets)
+                // console.log("A", assets.output, (await assets.assets())?.[0])
+                // const assets = await clientManifest.inputs[assets.output.path!]?.assets()
+                // console.log("F?", inputs)
+                controller.enqueue(new TextEncoder().encode(`\n<!-- for ${asset} -->`));
+                // controller.enqueue(new TextEncoder().encode(`\n<script>${JSON.stringify(assets)}</script>`))
+                // controller.enqueue(
+                //   new TextEncoder().encode(renderToString(<>{assets.map((a) => renderAsset(asset as any))}</>)),
+                // )
+            }
+            // 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",
+            });
+        }
+        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,
+    });
 }

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,47 @@
-import { UrlReplacerConf } from "./utils/replace-host";
+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";
 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>;
     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 +53,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 {};

package/dist/app/server/server-context.js

@@ -1,7 +1,9 @@
-import { parseURL, stringifyParsedURL, withQuery } from "ufo";
-import { filterHeader } from "./utils/headers";
-import { createUrlReplacer } from "./utils/replace-host";
-const PROXY_RESPONSE_HEADERS = ["content-type", "set-cookie", /^x-/, "cache-control"];
+import { parseURL, stringifyParsedURL, withQuery, withTrailingSlash } from "ufo";
+import { fetchWP } from "../../node/utils/fetch-wp.js";
+import { filterHeader } from "./utils/headers.js";
+import { createUrlReplacer } from "./utils/replace-host.js";
+import { pageCache, queryCache, swr } from "./utils/swr-cache.js";
+const PROXY_RESPONSE_HEADERS = ["content-type", "set-cookie", /^x-/, "cache-control", /woocommerce/];
 const PROXY_REQUEST_HEADERS = [
     "content-type",
     "accept",
@@ -11,28 +13,49 @@ const PROXY_REQUEST_HEADERS = [
     "referer",
     "user-agent",
     "authorization",
+    "woocommerce-session",
 ];
+const VARIES_HEADERS = ["Authorization", "woocommerce-session"];
+let runtime;
 export class ServerContext {
     dev;
     origin;
-    replaceUrls;
+    _urlReplacer;
+    rpcBases = [];
+    config;
+    static main;
     constructor(conf) {
         this.dev = conf.dev;
         this.origin = conf.origin;
+        this.rpcBases = conf.rpcBases ?? [];
+        this.config = conf.config;
         if (conf.replaceUrls) {
-            this.replaceUrls = createUrlReplacer(conf.replaceUrls);
+            this._urlReplacer = createUrlReplacer(conf.replaceUrls);
         }
+        ServerContext.main = this;
+    }
+    replaceUrls(text, origin) {
+        if (this._urlReplacer) {
+            return this._urlReplacer(text, origin);
+        }
+        return text;
+    }
+    get runtime() {
+        return runtime;
+    }
+    static setRuntime(rt) {
+        runtime = rt;
     }
     getOriginUrl(url) {
         const parsed = parseURL(url);
-        const parsedOrigin = parseURL(env.origin);
+        const parsedOrigin = parseURL(this.origin);
         parsed.host = parsedOrigin.host;
         parsed.protocol = parsedOrigin.protocol;
         return stringifyParsedURL(parsed);
     }
     async fetchOrigin(url, opts) {
         url = this.getOriginUrl(url);
-        const response = await fetch(url, {
+        const response = await fetchWP(url, {
             ...opts,
             headers: {
                 "Content-Type": "application/json",
@@ -50,8 +73,8 @@ export class ServerContext {
             }
         });
         let text = await response.text();
-        if (opts?.replaceUrls && this.replaceUrls) {
-            text = this.replaceUrls(text);
+        if (opts?.replaceUrls) {
+            text = this.replaceUrls(text, opts.newOrigin);
         }
         return new Response(text, {
             status: response.status,
@@ -60,21 +83,93 @@ export class ServerContext {
         });
     }
     async fetchRouteData(req) {
-        const fetchUrl = withQuery(req.pathname, {
-            ...req.query,
-            _props: req.withAppData ? "all" : "1",
-            _ssr: "1",
-            _debug: this.dev ? "1" : undefined,
+        /**
+         * Calculcate the cache key.
+         * For route data, the cache key is the pathname.
+         * TODO: Potential support for Vercel draft mode.
+         */
+        let cacheKey = "fetchRouteData:" + req.pathname;
+        const result = await swr({
+            key: cacheKey,
+            cache: pageCache,
+            forceFresh: this.dev,
+            getFreshValue: async (ctx) => {
+                ctx.metadata.createdTime;
+                const fetchUrl = withQuery(withTrailingSlash(req.pathname), {
+                    _props: "1",
+                    _ssr: "1",
+                    _debug: this.dev ? "1" : undefined,
+                });
+                const result = await this.fetchOrigin(fetchUrl, {
+                    cache: "no-cache",
+                    replaceUrls: true,
+                    newOrigin: req.newOrigin,
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                    redirect: "manual",
+                });
+                const preferredCacheDuration = parseInt(result.headers.get("x-ed-cache-duration") ?? "");
+                if (isFinite(preferredCacheDuration)) {
+                    ctx.metadata.ttl = preferredCacheDuration * 1000;
+                }
+                let resultStatus = result.status;
+                let resultHeaders = result.headers;
+                let resultData = await result.json();
+                // Special case for redirects
+                if (result.headers.get("location")) {
+                    let location = result.headers.get("location");
+                    let status = result.status;
+                    if (this.replaceUrls) {
+                        location = this.replaceUrls(location);
+                    }
+                    resultHeaders.delete("location");
+                    resultData = {
+                        redirect: location,
+                        status: status,
+                        data: "",
+                    };
+                }
+                if (resultData && typeof resultData === "object") {
+                    resultData.__generated = new Date().toISOString();
+                }
+                return {
+                    status: resultStatus,
+                    headers: resultHeaders,
+                    data: JSON.stringify(resultData),
+                };
+            },
         });
-        return this.fetchOrigin(fetchUrl, {
-            cache: "no-cache",
-            replaceUrls: true,
-            headers: {
-                "Content-Type": "application/json",
-                Accept: "application/json",
-                ...this.extractRequestHeaders(req.headers),
+        return new Response(result.data, {
+            status: result.status,
+            headers: result.headers,
+        });
+    }
+    async fetchAppData() {
+        const data = await swr({
+            key: "fetchAppData",
+            cache: pageCache,
+            getFreshValue: async (ctx) => {
+                const response = await this.fetchOrigin("/_appdata", {
+                    cache: "no-cache",
+                    replaceUrls: true,
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "application/json",
+                    },
+                });
+                const result = await response.json();
+                const preferredCacheDuration = parseInt(response.headers.get("x-ed-cache-duration") ?? "");
+                if (isFinite(preferredCacheDuration)) {
+                    ctx.metadata.ttl = preferredCacheDuration * 1000;
+                }
+                result.__generated = new Date().toISOString();
+                return result;
             },
+            forceFresh: this.dev,
         });
+        return data;
     }
     extractRequestHeaders(req) {
         const headers = {};
@@ -89,14 +184,49 @@ export class ServerContext {
     }
     async fetchNamedQuery(req) {
         const url = `/wp-json/ed/v1/query/${req.name}?params=${encodeURIComponent(JSON.stringify(req.params))}`;
-        return this.fetchOrigin(url, {
-            cache: "no-cache",
-            replaceUrls: true,
-            headers: {
-                ...this.extractRequestHeaders(req.headers),
-                "Content-Type": "application/json",
-                Accept: "application/json",
-            },
+        const key = `fetchNamedQuery:${req.name}:${JSON.stringify(req.params)}`;
+        const fetch = async () => {
+            const result = await this.fetchOrigin(url, {
+                cache: "no-cache",
+                replaceUrls: true,
+                headers: {
+                    ...this.extractRequestHeaders(req.headers),
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                },
+            });
+            const preferredCacheDuration = parseInt(result.headers.get("x-ed-cache-duration") ?? "");
+            let resultStatus = result.status;
+            let resultHeaders = result.headers;
+            let resultData = await result.json();
+            if (resultData && typeof resultData === "object") {
+                resultData.__generated = new Date().toISOString();
+            }
+            return {
+                status: resultStatus,
+                headers: resultHeaders,
+                data: JSON.stringify(resultData),
+                cacheTime: isFinite(preferredCacheDuration) ? preferredCacheDuration * 1000 : undefined,
+            };
+        };
+        // If headers like 'Authorization' are set, then we shouldn't cache.
+        const hasVariedHeaders = VARIES_HEADERS.some((key) => !!req.headers[key]);
+        // Get the result, either from cache or by fetching.
+        const result = hasVariedHeaders
+            ? await fetch()
+            : await swr({
+                key,
+                cache: queryCache,
+                forceFresh: this.dev,
+                getFreshValue: async (ctx) => {
+                    const result = await fetch();
+                    ctx.metadata.ttl = result.cacheTime;
+                    return result;
+                },
+            });
+        return new Response(result.data, {
+            status: result.status,
+            headers: result.headers,
         });
     }
     async fetchMutation(req) {
@@ -113,4 +243,40 @@ export class ServerContext {
             body: JSON.stringify(req.body),
         });
     }
+    get allowedCorsOrigins() {
+        let result = [];
+        if (this.config.serverless.endpoints) {
+            result.push(...Object.keys(this.config.serverless.endpoints));
+            result.push(...Object.values(this.config.serverless.endpoints));
+            result = result.filter((origin) => origin !== "*");
+        }
+        if (this.config.serverless.cors?.origins) {
+            result.push(...this.config.serverless.cors.origins);
+        }
+        return result;
+    }
+    getCorsOrigin(originHeader) {
+        const parsed = parseURL(originHeader);
+        if (this.allowedCorsOrigins.includes(parsed.host)) {
+            return originHeader;
+        }
+        if (this.allowedCorsOrigins.includes("*")) {
+            return "*";
+        }
+    }
+    getCorsHeaders(origin) {
+        if (!origin)
+            return {};
+        const allowedOrigin = this.getCorsOrigin(origin);
+        if (allowedOrigin) {
+            return {
+                "Access-Control-Allow-Methods": "OPTIONS,GET,HEAD,PUT,PATCH,POST,DELETE",
+                "Access-Control-Allow-Origin": allowedOrigin,
+                "Access-Control-Allow-Credentials": "true",
+                "Access-Control-Allow-Headers": "*",
+                "Access-Control-Expose-Headers": "*",
+            };
+        }
+        return {};
+    }
 }

package/dist/app/server/utils/replace-host.d.ts

@@ -7,4 +7,4 @@ export type UrlReplacerConf = {
         replace: boolean;
     }[];
 };
-export declare function createUrlReplacer(conf: UrlReplacerConf): (text: string) => string;
+export declare function createUrlReplacer(conf: UrlReplacerConf): (text: string, newOrigin?: string) => string;

package/dist/app/server/utils/replace-host.js

@@ -2,7 +2,7 @@ export function createUrlReplacer(conf) {
     // Create a regular expression to match the URL
     // Note that that the regex doesn't necessarily match the entire URL
     const lookup = new RegExp(conf.from.replace(/https?[:\\\/]+/, "https?[:\\/\\\\]+") + "([a-z0-9\\-_/\\\\]+)", "ig");
-    return (text) => {
+    return (text, newOrigin) => {
         return text.replace(lookup, (url) => {
             // Strip out the origin, to create a relative path
             const path = url.replace(/https?:[\/\\]+[^\/\\]+/, "");
@@ -18,10 +18,18 @@ export function createUrlReplacer(conf) {
                         return url;
                     }
                     else {
-                        return path;
+                        break;
                     }
                 }
             }
+            if (newOrigin) {
+                if (isEscaped) {
+                    return newOrigin.replace(/\//g, "\\/") + path;
+                }
+                else {
+                    return newOrigin + path;
+                }
+            }
             return path;
             // if (path.startsWith("/wp-content/uploads/")) {
             //   if (!conf.ignoreUploads) {

package/dist/app/server/utils/swr-cache.d.ts

@@ -0,0 +1,4 @@
+import { Cache, CachifiedOptions } from "@epic-web/cachified";
+export declare const pageCache: Cache<any>;
+export declare const queryCache: Cache<any>;
+export declare function swr<T>(args: CachifiedOptions<T>): Promise<T>;

package/dist/app/server/utils/swr-cache.js

@@ -0,0 +1,31 @@
+import { LRUCache } from "lru-cache";
+import { cachified, totalTtl } from "@epic-web/cachified";
+function createCache() {
+    const lruInstance = new LRUCache({ max: 1000 });
+    const lru = {
+        set(key, value) {
+            const ttl = totalTtl(value?.metadata);
+            return lruInstance.set(key, value, {
+                ttl: ttl === Infinity ? undefined : ttl,
+                start: value?.metadata?.createdTime,
+            });
+        },
+        get(key) {
+            return lruInstance.get(key);
+        },
+        delete(key) {
+            return lruInstance.delete(key);
+        },
+    };
+    return lru;
+}
+export const pageCache = createCache();
+export const queryCache = createCache();
+export function swr(args) {
+    return cachified({
+        ttl: args.ttl ?? 10_000,
+        swr: 3600_000,
+        fallbackToCache: 15_000,
+        ...args,
+    });
+}