eddev 0.2.9 → 0.2.12

package/components/NextRouter.js

@@ -23,11 +23,8 @@ function NextRouter(_a) {
     var setIsLoading = (0, hooks_1.usePageLoad)(function (s) { return s.setIsLoading; });
     var route = __assign(__assign({}, nextRoute), { pathname: nextRoute.asPath });
     (0, react_1.useEffect)(function () {
-        router_1.Router.events.on("routeChangeStart", function () {
-            console.log("Loading");
-            setIsLoading(true);
-        });
-        router_1.Router.events.on("routeChangeStart", function () { return setIsLoading(false); });
+        router_1.Router.events.on("routeChangeStart", function () { return setIsLoading(true); });
+        router_1.Router.events.on("routeChangeComplete", function () { return setIsLoading(false); });
         router_1.Router.events.on("routeChangeError", function () { return setIsLoading(false); });
     }, []);
     return ((0, jsx_runtime_1.jsx)(routing_1.RouterRoot, __assign({ url: nextRoute.asPath, data: data, onNavigateRequest: function (url) {

package/config/config-schema.d.ts

@@ -10,10 +10,12 @@ export declare const EDConfigSchema: z.ZodObject<{
         apiOnly: z.ZodOptional<z.ZodBoolean>;
         endpoints: z.ZodRecord<z.ZodString, z.ZodString>;
         defaultRevalidate: z.ZodOptional<z.ZodNumber>;
+        defaultRevalidateQueries: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
@@ -23,12 +25,23 @@ export declare const EDConfigSchema: z.ZodObject<{
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     }>>;
+    cache: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        props: z.ZodNumber;
+        queries: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        props: number;
+        queries: number;
+    }, {
+        props: number;
+        queries: number;
+    }>>>;
     devUI: z.ZodEnum<["disabled", "enabled"]>;
 }, "strip", z.ZodTypeAny, {
     $schema?: string | undefined;
@@ -36,12 +49,17 @@ export declare const EDConfigSchema: z.ZodObject<{
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }, {
     $schema?: string | undefined;
@@ -49,12 +67,17 @@ export declare const EDConfigSchema: z.ZodObject<{
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }>;
 export declare type EDConfig = z.infer<typeof EDConfigSchema>;

package/config/config-schema.js

@@ -14,7 +14,14 @@ exports.EDConfigSchema = zod_1.z.object({
         apiOnly: zod_1.z.boolean().optional(),
         endpoints: zod_1.z.record(zod_1.z.string(), zod_1.z.string()),
         defaultRevalidate: zod_1.z.number().optional(),
+        defaultRevalidateQueries: zod_1.z.number().optional(),
     })
         .optional(),
+    cache: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.object({
+        props: zod_1.z.number(),
+        queries: zod_1.z.number(),
+    }))
+        .optional(),
     devUI: zod_1.z.enum(["disabled", "enabled"]),
 });

package/config/get-config.d.ts

@@ -4,12 +4,17 @@ export declare function getEDConfig(dir?: string): import("zod").SafeParseReturn
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }, {
     $schema?: string | undefined;
@@ -17,12 +22,17 @@ export declare function getEDConfig(dir?: string): import("zod").SafeParseReturn
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }>;
 export declare function getEDConfigUnwrapped(dir?: string): {
@@ -31,12 +41,17 @@ export declare function getEDConfigUnwrapped(dir?: string): {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 };
 export declare function getEDConfigFile(dir?: string): string;

package/config/parse-config.d.ts

@@ -4,12 +4,17 @@ export declare function parseConfig(config: any): import("zod").SafeParseReturnT
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }, {
     $schema?: string | undefined;
@@ -17,11 +22,16 @@ export declare function parseConfig(config: any): import("zod").SafeParseReturnT
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
         theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eddev",
-  "version": "0.2.9",
+  "version": "0.2.12",
   "main": "./index.js",
   "license": "MIT",
   "bin": {

package/serverless-template/_utils/fetch-wordpress-props.ts

@@ -11,10 +11,13 @@ export async function fetchWordpressProps(pathname: string) {
   console.log("Fetching from", propsURL)
 
   // Make the request
-  let response = await fetchWP(propsURL, {})
+  let response = await fetchWP(propsURL, {}, async (response) => ({
+    text: await response.text(),
+    status: response.status,
+  }))
 
   // Convert to text, rather than JSON — so we can do find-and-replace
-  let text = await response.text()
+  let text = response.text
 
   // Convert absolute site URL details to relative paths
   text = text.replace(new RegExp(origin.replace(/(http|https)/, `https?`) + "([a-z0-9-_./]+)", "g"), (url) => {

package/serverless-template/_utils/fetch-wp.ts

@@ -1,17 +1,35 @@
 import { Agent } from "https"
 import { fetch } from "cross-fetch"
+import { callSWR } from "./swr"
 
 // Used to allow self-signed certificates
 const agent = new Agent({
   rejectUnauthorized: false,
 })
 
-export const fetchWP: typeof fetch = async (url, opts) => {
-  // TODO — basic auth via env variable
-  // https://stackoverflow.com/questions/43842793/basic-authentication-with-fetch
-  return fetch(url, {
-    ...opts,
-    // @ts-ignore
-    agent: url.includes("https") ? agent : undefined,
-  })
+export async function fetchWP<T>(url: string, opts: RequestInit, handler: (response: Response) => Promise<T>) {
+  const getData = () => {
+    // TODO — basic auth via env variable
+    // https://stackoverflow.com/questions/43842793/basic-authentication-with-fetch
+    return fetch(url, {
+      ...opts,
+      // @ts-ignore
+      agent: url.includes("https") ? agent : undefined,
+    })
+  }
+
+  const requestIsGET = !opts || !opts.method || opts.method.toUpperCase() === "GET"
+  if (requestIsGET) {
+    return callSWR(url as string, async (setExpiry) => {
+      const response = await getData()
+      const cacheDuration = parseInt(response.headers.get("x-ed-cache-duration") || "") || 0
+      setExpiry(cacheDuration)
+      console.log(`CACHE for ${cacheDuration}: ${url}`)
+      const result = await handler(response)
+      return result
+    })
+  } else {
+    const response = await getData()
+    return handler(response)
+  }
 }

package/serverless-template/_utils/swr.ts

@@ -0,0 +1,43 @@
+type CacheItem = {
+  data: Promise<any>
+  expires: Date
+  pending: boolean
+}
+
+const cache: { [key: string]: CacheItem } = {}
+
+export function callSWR<T>(key: string, func: (setExpiry: (duration: number) => void) => Promise<T>): Promise<T> {
+  if (cache[key]) {
+    if (new Date() < cache[key].expires || cache[key].pending) {
+      // Cache is valid
+      console.log("VALID")
+      return cache[key].data
+    } else {
+      // Cache has expired - serve old one, but reload in background
+      cache[key].pending = true
+      console.log("EXPIRED")
+      setImmediate(async () => {
+        const data = await func((duration) => {
+          cache[key].expires = new Date(Date.now() + duration * 1000)
+          console.log("EXPIRY -> ", cache[key].expires)
+        })
+        cache[key].data = Promise.resolve(data)
+        cache[key].pending = false
+      })
+      return cache[key].data
+    }
+  } else {
+    // Not cached at all, user must wait for the cache to populate
+    console.log("MISS")
+    const item = {
+      data: func((duration) => {
+        item.expires = new Date(Date.now() + duration * 1000)
+        console.log("EXPIRY -> ", item.expires)
+      }),
+      expires: new Date(Date.now() + 10000),
+      pending: false,
+    }
+    cache[key] = item
+    return item.data
+  }
+}

package/serverless-template/next.config.js

@@ -13,6 +13,18 @@ module.exports = (() => {
     rewrites() {
       return {
         afterFiles: [
+          {
+            source: "/sitemap.xml",
+            destination: process.env.SITE_URL + "/sitemap.xml",
+          },
+          {
+            source: "/:path*-sitemap.xml",
+            destination: process.env.SITE_URL + "/:path*-sitemap.xml",
+          },
+          settings.serverless.uploads === "proxy" && {
+            source: "/wp-content/uploads/:path*",
+            destination: process.env.SITE_URL + "/wp-content/uploads/:path*",
+          },
           settings.serverless.uploads === "proxy" && {
             source: "/wp-content/uploads/:path*",
             destination: process.env.SITE_URL + "/wp-content/uploads/:path*",

package/serverless-template/pages/[...slug].tsx

@@ -15,7 +15,6 @@ export async function getStaticPaths(): Promise<GetStaticPathsResult> {
 
 export async function getStaticProps({ params }: GetStaticPropsContext): Promise<GetStaticPropsResult<any>> {
   const result = await fetchWordpressProps((params?.slug as string[]).join("/"))
-  console.log("RESULT", result)
   if (result.status === 404) {
     return {
       notFound: true,
@@ -29,7 +28,6 @@ export async function getStaticProps({ params }: GetStaticPropsContext): Promise
     }
   }
   const revalidate = result.data.revalidate || settings.serverless?.defaultRevalidate || false
-  console.log("REVALIDATE", revalidate)
   return {
     props: result.data,
     revalidate: revalidate,

package/serverless-template/pages/api/rest/[...method].ts

@@ -17,7 +17,6 @@ const validProxyPaths = {
 
 export default async function (req: any, res: any) {
   // Ensure that the request is for a proxy path
-  console.log("METHOD", req.query.method)
   const proxyPath = validProxyPaths[req.query.method[0] as keyof typeof validProxyPaths]!
 
   if (!proxyPath) {
@@ -28,14 +27,18 @@ export default async function (req: any, res: any) {
 
   const finalPath = proxyPath.path.replace("*", req.query.method.slice(1).join("/"))
 
-  const response = await fetchWP(process.env.SITE_URL + finalPath, {
-    method: proxyPath.method,
-    headers: {
-      "Content-Type": "application/json",
+  const response = await fetchWP(
+    process.env.SITE_URL + finalPath,
+    {
+      method: proxyPath.method,
+      headers: {
+        "Content-Type": "application/json",
+      },
     },
-  })
-
-  const payload = await response.json()
+    async (response) => ({
+      payload: await response.json(),
+    })
+  )
 
-  res.status(200).json(payload)
+  res.status(200).json(response.payload)
 }