eddev 2.0.0-beta.83 → 2.0.0-beta.84

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

@@ -66,14 +66,12 @@ export class ServerContext {
         if (!response.ok) {
             return response;
         }
-        // console.log("Response headers", response.headers)
         const headers = {};
         response.headers.forEach((value, key) => {
             if (filterHeader(key, PROXY_RESPONSE_HEADERS)) {
                 headers[key] = value;
             }
         });
-        // console.log("Returning headers", headers)
         let text = await response.text();
         if (opts?.replaceUrls) {
             text = this.replaceUrls(text, opts.newOrigin);

package/dist/node/cli/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.0.0-beta.83";
+export declare const VERSION = "2.0.0-beta.84";

package/dist/node/cli/version.js

@@ -1 +1 @@
-export const VERSION = "2.0.0-beta.83";
+export const VERSION = "2.0.0-beta.84";

package/dist/node/compiler/vinxi-app.js

@@ -42,6 +42,12 @@ export function createVinxiApp(args) {
                         varies: [],
                     },
                 },
+                "/sitemap.xml": {
+                    cache: {
+                        maxAge: 3600,
+                        swr: true,
+                    },
+                },
                 "/sitemap*.xml": {
                     cache: {
                         maxAge: 3600,

package/dist/node/compiler/vinxi-codegen.js

@@ -181,22 +181,42 @@ export function createVinxiCodegen(opts) {
             name: "handler.bypass.ts",
             generate: code /* tsx */ `
         /// <reference types="vinxi/types/server" />
-        import { createRouter, eventHandler, getRouterParam, getQuery, getWebRequest, getRequestHeaders, getRequestURL, setCookie } from "vinxi/http"
-        import { serverContext } from "./context.js"
+        import { createRouter, eventHandler, getCookie, setCookie } from "vinxi/http"
+
+        const BYPASS_TOKEN = process.env.VERCEL_BYPASS_TOKEN
+        const COOKIE_NAME = "__prerender_bypass"
+
         const router = createRouter()
           .get(
-            "/setBypassCookie/",
+            "/enable",
             eventHandler(async (event) => {
-              const bypassToken = process.env.VERCEL_BYPASS_TOKEN
-              const cookieName = "__prerender_bypass"
+              if (!BYPASS_TOKEN) return false
 
-              setCookie(event, cookieName, bypassToken, {
+              setCookie(event, COOKIE_NAME, BYPASS_TOKEN, {
                 expires: new Date(Date.now() + 1000 * 60 * 60 * 24),
               })
 
-              return {
-                body: bypassToken,
+              return true
+            }),
+          )
+          .get(
+            "/disable",
+            eventHandler(async (event) => {
+              setCookie(event, COOKIE_NAME, "")
+
+              return true
+            }),
+          )
+          .get(
+            "/check",
+            eventHandler(async (event) => {
+              const cookie = getCookie(event, COOKIE_NAME)
+
+              if (cookie === BYPASS_TOKEN) {
+                return true
               }
+
+              return false
             }),
           )
         export default router.handler

package/dist/node/project/config.d.ts

@@ -72,19 +72,77 @@ export declare const EDConfigSchema: z.ZodObject<{
             origins?: string[] | undefined;
         } | undefined;
     }>;
-    cache: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        props: z.ZodNumber;
-        queries: z.ZodNumber;
+    cache: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        wordpress: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodEnum<["always", "ssr-always-fresh"]>;
+            cacheHeaders: z.ZodDefault<z.ZodBoolean>;
+            transients: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        }, {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        }>>>;
+        serverless: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            isr: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            dataCache: z.ZodDefault<z.ZodEnum<["in-memory", "kv", "none"]>>;
+        }, "strip", z.ZodTypeAny, {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        }, {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        }>>>;
+        pageDataTTL: z.ZodDefault<z.ZodNumber>;
+        appDataTTL: z.ZodDefault<z.ZodNumber>;
+        queryHooksTTL: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        props: number;
-        queries: number;
+        wordpress: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
     }, {
-        props: number;
-        queries: number;
+        wordpress?: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
     }>>>;
     devUI: z.ZodDefault<z.ZodEnum<["disabled", "enabled"]>>;
 }, "strip", z.ZodTypeAny, {
     version: "2";
+    cache: Record<string, {
+        wordpress: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders: boolean;
+            transients: boolean;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "none" | "in-memory" | "kv";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
+    }>;
     legacyMetadata: boolean;
     legacyStitches: boolean;
     serverless: {
@@ -102,10 +160,6 @@ export declare const EDConfigSchema: z.ZodObject<{
         } | undefined;
     };
     devUI: "disabled" | "enabled";
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
     $schema?: string | undefined;
     trackers?: ({
         id: string;
@@ -131,8 +185,18 @@ export declare const EDConfigSchema: z.ZodObject<{
         } | undefined;
     };
     cache?: Record<string, {
-        props: number;
-        queries: number;
+        wordpress?: {
+            strategy: "always" | "ssr-always-fresh";
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "none" | "in-memory" | "kv" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
     }> | undefined;
     $schema?: string | undefined;
     legacyMetadata?: boolean | undefined;

package/dist/node/project/config.js

@@ -68,12 +68,41 @@ export const EDConfigSchema = z.object({
             .optional(),
     }),
     cache: z
-        .record(z.string(), z.object({
-        props: z.number(),
-        queries: z.number(),
+        .record(z.object({
+        wordpress: z
+            .object({
+            strategy: z.enum(["always", "ssr-always-fresh"]),
+            cacheHeaders: z.boolean().default(true).describe("Whether to add caching headers to data requests."),
+            transients: z.boolean().default(true).describe("Whether to cache within transients."),
+        })
+            .optional()
+            .default({ strategy: "always", cacheHeaders: true, transients: true }),
+        serverless: z
+            .object({
+            isr: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Whether to use Incremental Static Regeneration for this origin."),
+            dataCache: z
+                .enum(["in-memory", "kv", "none"])
+                .default("in-memory")
+                .describe("The cache strategy to use for page data."),
+        })
+            .optional()
+            .default({ isr: true, dataCache: "in-memory" }),
+        pageDataTTL: z.number().default(300).describe("The number of seconds to cache page data."),
+        appDataTTL: z.number().default(300).describe("The number of seconds to cache global app data."),
+        queryHooksTTL: z.number().default(300).describe("The number of seconds to cache named GraphQL queries."),
     }))
-        .optional()
-        .describe("A map of origin domains -> cache settings. Wildcards can be used for each domain."),
+        .default({
+        "*": {
+            pageDataTTL: 300,
+            appDataTTL: 300,
+            queryHooksTTL: 300,
+        },
+    })
+        .describe("A map of WordPress origin hostnames -> cache settings. Wildcards can be used for each domain."),
     devUI: z.enum(["disabled", "enabled"]).default("enabled"),
 });
 export class Configurator {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eddev",
-  "version": "2.0.0-beta.83",
+  "version": "2.0.0-beta.84",
   "description": "",
   "main": "index.js",
   "type": "module",