eddev 2.0.0-beta.2 → 2.0.0-beta.200

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

@@ -0,0 +1,52 @@
+import { AnyProcedure } from "@trpc/server";
+import { FetchCreateContextFnOptions } from "@trpc/server/adapters/fetch";
+import { ServerContext } from "./server-context";
+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/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;
+}, import("@trpc/server/unstable-core-do-not-import").DecorateCreateRouterOptions<T>>;
+export type InferRPCServerContext<TFunc extends null | ((opts: FetchCreateContextFnOptions) => any)> = {
+    req: Request;
+    searchParams: URLSearchParams;
+    resHeaders: Headers;
+    server: ServerContext;
+} & (TFunc extends (opts: FetchCreateContextFnOptions) => infer T ? T : {});
+export {};
+//# sourceMappingURL=rpc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../src/app/server/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAY,MAAM,cAAc,CAAA;AACrD,OAAO,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAEzE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEhD,eAAO,MAAM,MAAM;;;;;;;;;mCA8BgyD,0CAAU;;;;;;;iDAAqwB,cAAU;;;;;;;;;;;CA5B1kF,CAAA;AAEF,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,YAAY,CAAC,CAAA;AAE/E,eAAO,MAAM,GAAG;;;WAGP,CAAC,SAAS,YAAY,UAAU,CAAC,GAAG,CAAC;CAG7C,CAAA;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,IAAI,EAAE,2BAA2B,KAAK,CAAC,GAC7C,CAAC,IAAI,EAAE,2BAA2B,KAAK,CAAC,CAE1C;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,YAAY,EAAE,MAAM,EAAE,CAAC;;;;;sFAElE;AAED,MAAM,MAAM,qBAAqB,CAAC,KAAK,SAAS,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,2BAA2B,KAAK,GAAG,CAAC,IAAI;IACrG,GAAG,EAAE,OAAO,CAAA;IACZ,YAAY,EAAE,eAAe,CAAA;IAC7B,UAAU,EAAE,OAAO,CAAA;IACnB,MAAM,EAAE,aAAa,CAAA;CACtB,GAAG,CAAC,KAAK,SAAS,CAAC,IAAI,EAAE,2BAA2B,KAAK,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAA"}

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

@@ -0,0 +1,75 @@
+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;
+    _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;
+        headers?: RequestHeaders;
+        newOrigin?: string;
+    }): Promise<Response>;
+    fetchAppData(): Promise<ServerAppData>;
+    extractRequestHeaders(req?: RequestHeaders): Partial<Record<import("vinxi/http").HTTPHeaderName, string | undefined>>;
+    fetchNamedQuery(req: {
+        name: string;
+        params: object;
+        headers: RequestHeaders;
+    }): Promise<Response>;
+    fetchMutation(req: {
+        name: string;
+        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 {};
+//# sourceMappingURL=server-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server-context.d.ts","sourceRoot":"","sources":["../../../src/app/server/server-context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAE5D,OAAO,EAAiC,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAEpF,OAAO,EAAqB,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAE5E,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAKxD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,MAAM,EAAE,QAAQ,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAA;CACxC,CAAA;AAkBD;;GAEG;AACH,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,GAAG,CAAA;IACZ,QAAQ,EAAE,WAAW,CAAA;CACtB,CAAA;AAED,qBAAa,aAAa;IACxB,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IACxD,QAAQ,EAAE,MAAM,EAAE,CAAK;IACvB,MAAM,EAAE,QAAQ,CAAA;IAEhB,MAAM,CAAC,IAAI,EAAE,aAAa,CAAA;gBAEd,IAAI,EAAE,iBAAiB;IAWnC,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAOzC,IAAI,OAAO,yBAEV;IAED,MAAM,CAAC,UAAU,CAAC,EAAE,EAAE,oBAAoB;IAI1C,YAAY,CAAC,GAAG,EAAE,MAAM;IAQlB,WAAW,CACf,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,WAAW,GAAG;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GACjE,OAAO,CAAC,QAAQ,CAAC;IAgCpB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE;IAmFvG,cAAc,CAAC,GAAG,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,cAAc,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAwGtF,YAAY,IAAI,OAAO,CAAC,aAAa,CAAC;IAgC5C,qBAAqB,CAAC,GAAG,CAAC,EAAE,cAAc;IAYpC,eAAe,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,cAAc,CAAA;KAAE;IA+D9E,aAAa,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,cAAc,CAAA;KAAE;IAehF,IAAI,kBAAkB,aAcrB;IAED,aAAa,CAAC,YAAY,EAAE,MAAM;IAUlC,cAAc,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;CAiD9B"}

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

@@ -0,0 +1,417 @@
+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";
+import { QueryMonitor } from "../utils/query-monitor.js";
+import chalk from "chalk";
+import { inspect } from "node:util";
+const PROXY_RESPONSE_HEADERS = ["content-type", "set-cookie", /^x-/, "cache-control", /woocommerce/, "location"];
+const PROXY_REQUEST_HEADERS = [
+    "content-type",
+    "accept",
+    "accept-encoding",
+    "accept-language",
+    "origin",
+    "referer",
+    "user-agent",
+    "authorization",
+    "woocommerce-session",
+];
+const VARIES_HEADERS = ["Authorization", "woocommerce-session"];
+let runtime;
+export class ServerContext {
+    dev;
+    origin;
+    _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._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(this.origin);
+        parsed.host = parsedOrigin.host;
+        parsed.protocol = parsedOrigin.protocol;
+        return stringifyParsedURL(parsed);
+    }
+    async fetchOrigin(url, opts) {
+        url = this.getOriginUrl(url);
+        const fetchOps = { ...opts };
+        delete fetchOps.replaceUrls;
+        delete fetchOps.newOrigin;
+        const response = await fetchWP(url, {
+            ...fetchOps,
+        });
+        if (!response.ok) {
+            return response;
+        }
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            if (filterHeader(key, PROXY_RESPONSE_HEADERS)) {
+                headers[key] = value;
+            }
+        });
+        let text = await response.text();
+        if (opts?.replaceUrls) {
+            text = this.replaceUrls(text, opts.newOrigin);
+        }
+        return new Response(text, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+    debugLogQueryMonitor(kind, uri, monitor) {
+        if (!QueryMonitor.hasLogEntries(monitor))
+            return;
+        let indentLevel = 2;
+        const finalOutput = [];
+        let label = "";
+        if (kind === "props") {
+            label = "While fetching props for route '" + uri + "'";
+        }
+        else if (kind === "query") {
+            label = "While querying " + uri + " via REST API";
+        }
+        else if (kind === "mutation") {
+            label = "While mutating " + uri + " via REST API";
+        }
+        else if (kind === "app") {
+            label = "While fetching app data";
+        }
+        finalOutput.push(chalk.whiteBright("➜ " + label));
+        function printEntry(entry) {
+            finalOutput.push(indent(indentLevel, chalk.whiteBright("➜ " + entry.file) + " " + chalk.gray(entry.label ? `(${entry.label})` : "")));
+            indentLevel += 2;
+            if (entry.log && entry.log.length) {
+                for (let item of entry.log) {
+                    let output = "";
+                    let prefix = "";
+                    let message = item.message;
+                    let stack = [];
+                    if (item.type === "php_error") {
+                        prefix = chalk.red("PHP Error:");
+                    }
+                    else if (item.type === "php_warning") {
+                        prefix = chalk.yellow("PHP Warning:");
+                    }
+                    else if (item.type === "php_notice") {
+                        prefix = chalk.yellow("PHP Notice:");
+                    }
+                    else if (item.type === "GRAPHQL_DEBUG") {
+                        prefix = chalk.cyan("debug:");
+                    }
+                    else if (item.type === "error" && item.extensions?.category === "user") {
+                        prefix = chalk.red("UserError:");
+                    }
+                    else {
+                        prefix = chalk.gray((item.type || "Log") + ":");
+                    }
+                    if (typeof message !== "string") {
+                        message = inspect(message, { depth: 4 });
+                    }
+                    if (item.debugMessage) {
+                        message += "\n" + chalk.gray(item.debugMessage);
+                    }
+                    output += prefix + " " + message;
+                    if (item.path) {
+                        stack.push(chalk.gray(" at path " + JSON.stringify(item.path)));
+                    }
+                    if (item.file) {
+                        stack.push(chalk.gray(`at ${chalk.white(item.file)} line ${item.line || "??"}`));
+                    }
+                    if (item.stack?.length) {
+                        stack.push(item.stack
+                            .filter((line) => {
+                            return line !== item.file + ":" + item.line;
+                        })
+                            .slice(0, 4)
+                            .map((line) => "  " + chalk.gray(line))
+                            .join("\n"));
+                    }
+                    if (stack.length > 0) {
+                        output += indent(2, "\n" + stack.join("\n"));
+                    }
+                    finalOutput.push(indent(indentLevel, "➜ " + output));
+                }
+            }
+            for (let child of entry.children ?? []) {
+                printEntry(child);
+            }
+            indentLevel -= 2;
+        }
+        for (let entry of monitor) {
+            printEntry(entry);
+        }
+    }
+    async fetchRouteData(req) {
+        /**
+         * 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 = new Headers(result.headers);
+                let resultData = {};
+                // Special case for redirects
+                if (result.headers.has("location")) {
+                    let location = result.headers.get("location");
+                    let status = result.status;
+                    if (this.replaceUrls) {
+                        location = this.replaceUrls(location);
+                    }
+                    return {
+                        status: 200,
+                        headers: new Headers({
+                            "Content-Type": "application/json",
+                        }),
+                        data: JSON.stringify({ redirect: location, status: status }),
+                    };
+                }
+                try {
+                    resultData = await result.json();
+                }
+                catch (err) {
+                    console.error(`Invalid JSON response from '${fetchUrl}'. An error page will be displayed.`);
+                    ctx.metadata.ttl = 0;
+                    return {
+                        status: 500,
+                        headers: resultHeaders,
+                        data: JSON.stringify({
+                            view: "_error",
+                            viewData: {
+                                data: {
+                                    statusCode: 500,
+                                    title: "Internal Server Error",
+                                    userMessage: "An internal server error occurred.",
+                                    report: {
+                                        details: "A JSON parsing error occurred while fetching route data.",
+                                        message: err.message,
+                                    },
+                                },
+                            },
+                        }),
+                    };
+                }
+                if (resultData && typeof resultData === "object") {
+                    resultData.__generated = new Date().toISOString();
+                }
+                if (resultData.queryMonitor) {
+                    this.debugLogQueryMonitor("props", req.pathname, resultData.queryMonitor);
+                }
+                return {
+                    status: resultStatus,
+                    headers: resultHeaders,
+                    data: JSON.stringify(resultData),
+                };
+            },
+        });
+        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;
+                }
+                if (result.queryMonitor) {
+                    this.debugLogQueryMonitor("app", "", result.queryMonitor);
+                }
+                result.__generated = new Date().toISOString();
+                return result;
+            },
+            forceFresh: this.dev,
+        });
+        return data;
+    }
+    extractRequestHeaders(req) {
+        const headers = {};
+        if (req) {
+            for (let key of PROXY_REQUEST_HEADERS) {
+                if (req[key]) {
+                    headers[key] = req[key];
+                }
+            }
+        }
+        return headers;
+    }
+    async fetchNamedQuery(req) {
+        const url = `/wp-json/ed/v1/query/${req.name.replace(/^\//, "")}?params=${encodeURIComponent(JSON.stringify(req.params))}`;
+        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();
+            }
+            if (resultData.queryMonitor) {
+                this.debugLogQueryMonitor("query", req.name, resultData.queryMonitor);
+            }
+            resultData.req = req;
+            resultData.key = key;
+            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) {
+        const url = `/wp-json/ed/v1/mutation/${req.name.replace(/^\//, "")}`;
+        return this.fetchOrigin(url, {
+            method: "POST",
+            cache: "no-cache",
+            replaceUrls: true,
+            headers: {
+                ...this.extractRequestHeaders(req.headers),
+                "Content-Type": "application/json",
+                Accept: "application/json",
+            },
+            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.map((origin) => origin.replace(/(https?:\/\/|\/$)/, "")));
+        }
+        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 {};
+    }
+}
+function indent(count, str) {
+    const indent = " ".repeat(count);
+    return str
+        .split("\n")
+        .map((line) => indent + line)
+        .join("\n");
+}
+function indentAllButFirst(count, str) {
+    const indent = " ".repeat(count);
+    return str
+        .split("\n")
+        .map((line, i) => (i === 0 ? line : indent + line))
+        .join("\n");
+}

package/dist/app/server/server-custom-config.d.ts

@@ -0,0 +1,3 @@
+export type ServerConfig = {};
+export declare function defineServerConfig(): void;
+//# sourceMappingURL=server-custom-config.d.ts.map

package/dist/app/server/server-custom-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-custom-config.d.ts","sourceRoot":"","sources":["../../../src/app/server/server-custom-config.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,EAAE,CAAA;AAE7B,wBAAgB,kBAAkB,SAAK"}

package/dist/app/server/server-custom-config.js

@@ -0,0 +1 @@
+export function defineServerConfig() { }

package/dist/app/server/utils/content-security.d.ts

@@ -0,0 +1,26 @@
+import type { EDConfig } from "../../../node/project/config";
+import { RouteMetaTag, TrackerTags } from "../../lib/routing";
+declare const CSP_KEYS: readonly ["childSrc", "connectSrc", "defaultSrc", "fencedFrameSrc", "fontSrc", "frameSrc", "imgSrc", "manifestSrc", "mediaSrc", "objectSrc", "scriptSrc", "scriptSrcElem", "scriptSrcAttr", "styleSrc", "styleSrcElem", "styleSrcAttr", "workerSrc", "baseUri", "formAction", "frameAncestors", "reportTo", "requireTrustedTypesFor", "trustedTypes", "upgradeInsecureRequests"];
+export type CSPKey = (typeof CSP_KEYS)[number];
+export type CSPParams = Record<CSPKey, Set<string>>;
+export type ContentSecurityPolicyRequestContext = {
+    url: string;
+    type: "page";
+    tags: RouteMetaTag[];
+};
+export declare class SecureHeaderBuilder {
+    protected csp: CSPParams;
+    protected headers: Headers;
+    private cspEnabled;
+    private autodetectCspOrigins;
+    private useNonce;
+    private commonCspOrigins;
+    readonly nonce: string | undefined;
+    constructor(config: EDConfig);
+    addTrackingTags(tags: TrackerTags): TrackerTags;
+    addMetaTags(tags: RouteMetaTag[]): RouteMetaTag[];
+    getHeaders(): Headers;
+    getCSPHeaderValue(): string | undefined;
+}
+export {};
+//# sourceMappingURL=content-security.d.ts.map

package/dist/app/server/utils/content-security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-security.d.ts","sourceRoot":"","sources":["../../../../src/app/server/utils/content-security.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAG7D,QAAA,MAAM,QAAQ,kXAyBJ,CAAA;AAEV,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9C,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;AAEnD,MAAM,MAAM,mCAAmC,GAAG;IAChD,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB,CAAA;AAED,qBAAa,mBAAmB;IAC9B,SAAS,CAAC,GAAG,EAAE,SAAS,CAAA;IACxB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAgB;IAE1C,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,oBAAoB,CAAO;IACnC,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,gBAAgB,CAAe;IAEvC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;gBAEtB,MAAM,EAAE,QAAQ;IAgC5B,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,WAAW;IAkB/C,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE;IAkBhC,UAAU,IAAI,OAAO;IAWrB,iBAAiB,IAAI,MAAM,GAAG,SAAS;CAexC"}