eddev 0.2.8 → 0.2.11

package/blocks/ContentBlocks.js

@@ -31,7 +31,39 @@ var blockAttributes_1 = require("./blockAttributes");
 var react_1 = require("react");
 var ErrorBoundaryFrontend_1 = require("./ErrorBoundaryFrontend");
 exports.BlocksContext = (0, react_1.createContext)(undefined);
+function wrapPromise(promise) {
+    var status = "pending";
+    var result;
+    var suspender = promise.then(function (r) {
+        status = "success";
+        result = r;
+    }, function (e) {
+        status = "error";
+        result = e;
+    });
+    return {
+        read: function () {
+            //console.log(status);
+            if (status === "pending") {
+                throw suspender;
+            }
+            else if (status === "error") {
+                throw result;
+            }
+            else if (status === "success") {
+                return result;
+            }
+        },
+    };
+}
+var blockManifestResource = null;
 function ContentBlocks(props) {
+    var blockTypes = blocks_1.default;
+    if (blocks_1.default.then && process.serverless && !blocks_1.default.default) {
+        if (!blockManifestResource)
+            blockManifestResource = wrapPromise(blocks_1.default);
+        blockTypes = blockManifestResource.read().default;
+    }
     if (process.admin) {
         throw new Error("ContentBlocks should only be used on the frontend.");
     }
@@ -44,8 +76,8 @@ function ContentBlocks(props) {
             var ctx = __assign(__assign({}, parentContext), { ancestors: __spreadArray(__spreadArray([], ((parentContext === null || parentContext === void 0 ? void 0 : parentContext.ancestors) || []), true), [parentContext === null || parentContext === void 0 ? void 0 : parentContext.current], false).filter(Boolean), parent: parentContext === null || parentContext === void 0 ? void 0 : parentContext.current, current: block, prev: props.blocks[index - 1], next: props.blocks[index + 1] });
             // Figure out the
             var blockNode;
-            if (block.blockName in blocks_1.default) {
-                var Component = blocks_1.default[block.blockName];
+            if (block.blockName in blockTypes) {
+                var Component = blockTypes[block.blockName];
                 if (!Component)
                     return (0, jsx_runtime_1.jsx)(react_1.Fragment, {}, void 0);
                 blockNode = ((0, jsx_runtime_1.jsx)(blockAttributes_1.InlineEditingContextProvider, __assign({ block: [block.blockName, block.props], values: block.inline, innerBlocks: block.innerBlocks }, { children: (0, jsx_runtime_1.jsx)(Component, __assign({}, block.props, { innerHTML: block.innerHTML, 

package/components/NextRouter.js

@@ -15,10 +15,21 @@ exports.NextRouter = void 0;
 var jsx_runtime_1 = require("react/jsx-runtime");
 var routing_1 = require("../routing");
 var router_1 = require("next/router");
+var react_1 = require("react");
+var hooks_1 = require("../hooks");
 function NextRouter(_a) {
     var children = _a.children, path = _a.path, data = _a.data;
     var nextRoute = (0, router_1.useRouter)();
+    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("routeChangeError", function () { return setIsLoading(false); });
+    }, []);
     return ((0, jsx_runtime_1.jsx)(routing_1.RouterRoot, __assign({ url: nextRoute.asPath, data: data, onNavigateRequest: function (url) {
             route.push(url);
             // setPendingUrl({ popped: false, url })

package/config/config-schema.d.ts

@@ -9,47 +9,75 @@ export declare const EDConfigSchema: z.ZodObject<{
         themeAssets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         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";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         endpoints: Record<string, 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";
+        theme: "proxy" | "remote" | "copy";
         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;
     serverless?: {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }, {
     $schema?: string | undefined;
     serverless?: {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         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

@@ -13,7 +13,15 @@ exports.EDConfigSchema = zod_1.z.object({
         themeAssets: zod_1.z.array(zod_1.z.string()).optional(),
         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

@@ -3,24 +3,36 @@ export declare function getEDConfig(dir?: string): import("zod").SafeParseReturn
     serverless?: {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }, {
     $schema?: string | undefined;
     serverless?: {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }>;
 export declare function getEDConfigUnwrapped(dir?: string): {
@@ -28,12 +40,18 @@ export declare function getEDConfigUnwrapped(dir?: string): {
     serverless?: {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         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

@@ -3,23 +3,35 @@ export declare function parseConfig(config: any): import("zod").SafeParseReturnT
     serverless?: {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         endpoints: Record<string, string>;
     } | undefined;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     devUI: "disabled" | "enabled";
 }, {
     $schema?: string | undefined;
     serverless?: {
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        theme: "proxy" | "remote" | "copy";
         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.8",
+  "version": "0.2.11",
   "main": "./index.js",
   "license": "MIT",
   "bin": {

package/routing/routing.js

@@ -329,7 +329,7 @@ exports.Link = (0, react_1.forwardRef)(function (props, ref) {
     // @ts-ignore
     if (process.serverless) {
         var NextLink = require("next/link").default;
-        return ((0, jsx_runtime_1.jsx)(NextLink, __assign({ href: props.href, passHref: true }, { children: (0, jsx_runtime_1.jsx)("a", __assign({ ref: ref }, props, { href: undefined }), void 0) }), void 0));
+        return ((0, jsx_runtime_1.jsx)(NextLink, __assign({ href: props.href, passHref: true, prefetch: false }, { children: (0, jsx_runtime_1.jsx)("a", __assign({ ref: ref }, props, { href: undefined }), void 0) }), void 0));
     }
     var localRef = (0, react_1.useRef)();
     var router = (0, react_1.useContext)(RouterContext);

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

@@ -8,12 +8,16 @@ export async function fetchWordpressProps(pathname: string) {
   const origin = (process.env.SITE_URL as string).replace(/\/$/, "")
   pathname = pathname.replace(/(^\/|\/$)/g, "")
   const propsURL = origin + ("/" + pathname + "/?_props=all").replace(/\/+/, "/")
+  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/package.json

@@ -16,6 +16,6 @@
   "devDependencies": {
     "@types/react": "17.0.39",
     "typescript": "4.5.5",
-    "next": "^12.1.0"
+    "next": "^12.1.6"
   }
 }

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

@@ -1,4 +1,5 @@
 import { GetStaticPathsResult, GetStaticPropsContext, GetStaticPropsResult } from "next"
+import settings from "_utils/ed-config"
 import { fetchWordpressProps } from "../_utils/fetch-wordpress-props"
 
 export default function Home(props: any) {
@@ -8,13 +9,12 @@ export default function Home(props: any) {
 export async function getStaticPaths(): Promise<GetStaticPathsResult> {
   return {
     paths: [],
-    fallback: true,
+    fallback: "blocking",
   }
 }
 
 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,
@@ -27,7 +27,9 @@ export async function getStaticProps({ params }: GetStaticPropsContext): Promise
       },
     }
   }
+  const revalidate = result.data.revalidate || settings.serverless?.defaultRevalidate || false
   return {
     props: result.data,
+    revalidate: revalidate,
   }
 }

package/serverless-template/pages/_app.tsx

@@ -8,6 +8,7 @@ import { useRouter } from "next/router"
 import { DevUILoader } from "eddev/dev-ui/loader"
 import { PageMeta } from "../_utils/PageMeta"
 import { withTRPC } from "@trpc/next"
+import { Suspense } from "react"
 
 let appData: any
 
@@ -16,10 +17,6 @@ function Root({ Component, pageProps }: AppProps) {
 
   if (!appData) appData = pageProps?.appData?.data
 
-  // const appData = useMemo(() => {
-  //   return pageProps?.appData?.data
-  // }, [])
-
   const viewProps = pageProps?.viewData?.data
 
   const View = manifest[pageProps.view || "404"]
@@ -36,7 +33,9 @@ function Root({ Component, pageProps }: AppProps) {
         {pageProps?.meta?.head && <PageMeta {...pageProps?.meta?.head} />}
         {pageProps?.meta?.footer && <PageMeta {...pageProps?.meta?.footer} />}
         {process.devUI ? <DevUILoader /> : null}
-        <App>{View && <View {...viewProps} />}</App>
+        <App>
+          <Suspense fallback={null}>{View && <View {...viewProps} />}</Suspense>
+        </App>
       </NextRouter>
     </ServerlessAppDataProvider>
   )

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

@@ -17,7 +17,7 @@ const validProxyPaths = {
 
 export default async function (req: any, res: any) {
   // Ensure that the request is for a proxy path
-  const proxyPath = validProxyPaths[req.query.method as keyof typeof validProxyPaths]!
+  const proxyPath = validProxyPaths[req.query.method[0] as keyof typeof validProxyPaths]!
 
   if (!proxyPath) {
     return res.status(404).json({
@@ -27,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)
 }