enhancement/issue 823 ensure greenwood cli and plugins are favoring idiomatic usages of async

packages/cli/src/commands/build.js

@@ -38,13 +38,7 @@ const runProductionBuild = async (compilation) => {
       });
     }
 
-    await Promise.all(
-      servers.map(async (server) => {
-        await server.start();
-
-        return Promise.resolve(server);
-      }),
-    );
+    await Promise.all(servers.map((server) => server.start()));
 
     if (prerenderPlugin.executeModuleUrl) {
       await preRenderCompilationWorker(compilation, prerenderPlugin);

packages/cli/src/lib/async-utils.js

@@ -14,14 +14,15 @@ async function asyncFilter(arr, cb) {
 }
 
 // https://stackoverflow.com/a/71278238/417806
+// Constraint: mapper functions must not depend on each other
 async function asyncMap(items, mapper) {
-  const mappedItems = [];
+  const promises = [];
 
   for (const item of items) {
-    mappedItems.push(await mapper(item));
+    promises.push(mapper(item));
   }
 
-  return mappedItems;
+  return Promise.all(promises);
 }
 
 export { asyncFilter, asyncMap };

packages/cli/src/lifecycles/bundle.js

@@ -16,6 +16,7 @@ import {
 import path from "node:path";
 import { rollup } from "rollup";
 import { pruneGraph } from "../lib/content-utils.js";
+import { asyncMap } from "../lib/async-utils.js";
 
 async function interceptPage(url, request, plugins, body) {
   let response = new Response(body, {
@@ -115,45 +116,41 @@ async function cleanUpResources(compilation) {
 async function optimizeStaticPages(compilation, plugins) {
   const { scratchDir, outputDir } = compilation.context;
 
-  return Promise.all(
-    compilation.graph
-      .filter(
-        (page) =>
-          !page.isSSR ||
-          (page.isSSR && page.prerender) ||
-          (page.isSSR && compilation.config.prerender),
-      )
-      .map(async (page) => {
-        const { route, outputHref } = page;
-        const outputDirUrl = new URL(outputHref.replace("index.html", "").replace("404.html", ""));
-        const url = new URL(`http://localhost:${compilation.config.port}${route}`);
-        const contents = await fs.readFile(
-          new URL(`./${outputHref.replace(outputDir.href, "")}`, scratchDir),
-          "utf-8",
-        );
-        const headers = new Headers({ "Content-Type": "text/html" });
-        let response = new Response(contents, { headers });
-
-        if (!(await checkResourceExists(outputDirUrl))) {
-          await fs.mkdir(outputDirUrl, {
-            recursive: true,
-          });
-        }
+  const pages = compilation.graph.filter(
+    (page) =>
+      !page.isSSR || (page.isSSR && page.prerender) || (page.isSSR && compilation.config.prerender),
+  );
 
-        for (const plugin of plugins) {
-          if (plugin.shouldOptimize && (await plugin.shouldOptimize(url, response.clone()))) {
-            const currentResponse = await plugin.optimize(url, response.clone());
+  await asyncMap(pages, async (page) => {
+    const { route, outputHref } = page;
+    const outputDirUrl = new URL(outputHref.replace("index.html", "").replace("404.html", ""));
+    const url = new URL(`http://localhost:${compilation.config.port}${route}`);
+    const contents = await fs.readFile(
+      new URL(`./${outputHref.replace(outputDir.href, "")}`, scratchDir),
+      "utf-8",
+    );
+    const headers = new Headers({ "Content-Type": "text/html" });
+    let response = new Response(contents, { headers });
+
+    if (!(await checkResourceExists(outputDirUrl))) {
+      await fs.mkdir(outputDirUrl, {
+        recursive: true,
+      });
+    }
 
-            response = mergeResponse(response.clone(), currentResponse.clone());
-          }
-        }
+    for (const plugin of plugins) {
+      if (plugin.shouldOptimize && (await plugin.shouldOptimize(url, response.clone()))) {
+        const currentResponse = await plugin.optimize(url, response.clone());
 
-        // clean up optimization markers
-        const body = (await response.text()).replace(/data-gwd-opt=".*?[a-z]"/g, "");
+        response = mergeResponse(response.clone(), currentResponse.clone());
+      }
+    }
 
-        await fs.writeFile(new URL(outputHref), body);
-      }),
-  );
+    // clean up optimization markers
+    const body = (await response.text()).replace(/data-gwd-opt=".*?[a-z]"/g, "");
+
+    await fs.writeFile(new URL(outputHref), body);
+  });
 }
 
 async function bundleStyleResources(compilation, resourcePlugins) {
@@ -202,84 +199,58 @@ async function bundleStyleResources(compilation, resourcePlugins) {
       const request = new Request(url, { headers });
       const initResponse = new Response(contents, { headers });
 
-      let response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
-        const intermediateResponse = await responsePromise;
+      let response = initResponse;
+
+      for (const plugin of resourcePlugins) {
         const shouldServe = plugin.shouldServe && (await plugin.shouldServe(url, request));
 
         if (shouldServe) {
           const currentResponse = await plugin.serve(url, request);
-          const mergedResponse = mergeResponse(
-            intermediateResponse.clone(),
-            currentResponse.clone(),
-          );
+          const mergedResponse = mergeResponse(response.clone(), currentResponse.clone());
 
           if (mergedResponse.headers.get("Content-Type").indexOf(contentType) >= 0) {
-            return Promise.resolve(mergedResponse.clone());
+            response = mergedResponse.clone();
           }
         }
+      }
 
-        return Promise.resolve(responsePromise);
-      }, Promise.resolve(initResponse));
-
-      response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
-        const intermediateResponse = await responsePromise;
+      for (const plugin of resourcePlugins) {
         const shouldPreIntercept =
           plugin.shouldPreIntercept &&
-          (await plugin.shouldPreIntercept(url, request, intermediateResponse.clone()));
+          (await plugin.shouldPreIntercept(url, request, response.clone()));
 
         if (shouldPreIntercept) {
-          const currentResponse = await plugin.preIntercept(
-            url,
-            request,
-            intermediateResponse.clone(),
-          );
-          const mergedResponse = mergeResponse(
-            intermediateResponse.clone(),
-            currentResponse.clone(),
-          );
+          const currentResponse = await plugin.preIntercept(url, request, response.clone());
+          const mergedResponse = mergeResponse(response.clone(), currentResponse.clone());
 
           if (mergedResponse.headers.get("Content-Type").indexOf(contentType) >= 0) {
-            return Promise.resolve(mergedResponse.clone());
+            response = mergedResponse.clone();
           }
         }
+      }
 
-        return Promise.resolve(responsePromise);
-      }, Promise.resolve(response.clone()));
-
-      response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
-        const intermediateResponse = await responsePromise;
+      for (const plugin of resourcePlugins) {
         const shouldIntercept =
-          plugin.shouldIntercept &&
-          (await plugin.shouldIntercept(url, request, intermediateResponse.clone()));
+          plugin.shouldIntercept && (await plugin.shouldIntercept(url, request, response.clone()));
 
         if (shouldIntercept) {
-          const currentResponse = await plugin.intercept(
-            url,
-            request,
-            intermediateResponse.clone(),
-          );
-          const mergedResponse = mergeResponse(
-            intermediateResponse.clone(),
-            currentResponse.clone(),
-          );
+          const currentResponse = await plugin.intercept(url, request, response.clone());
+          const mergedResponse = mergeResponse(response.clone(), currentResponse.clone());
 
           if (mergedResponse.headers.get("Content-Type").indexOf(contentType) >= 0) {
-            return Promise.resolve(mergedResponse.clone());
+            response = mergedResponse.clone();
           }
         }
+      }
 
-        return Promise.resolve(responsePromise);
-      }, Promise.resolve(response.clone()));
-
-      response = await resourcePlugins.reduce(async (responsePromise, plugin) => {
-        const intermediateResponse = await responsePromise;
+      for (const plugin of resourcePlugins) {
         const shouldOptimize =
-          plugin.shouldOptimize && (await plugin.shouldOptimize(url, intermediateResponse.clone()));
+          plugin.shouldOptimize && (await plugin.shouldOptimize(url, response.clone()));
 
-        return shouldOptimize
-          ? Promise.resolve(await plugin.optimize(url, intermediateResponse.clone()))
-          : Promise.resolve(responsePromise);
-      }, Promise.resolve(response.clone()));
+        if (shouldOptimize) {
+          response = await plugin.optimize(url, response.clone());
+        }
+      }
 
       optimizedFileContents = await response.text();
 

packages/cli/src/lifecycles/compile.js

@@ -59,7 +59,7 @@ const generateCompilation = async () => {
 
     if (!(await checkResourceExists(new URL("./graph.json", outputDir)))) {
       return Promise.reject(
-        new Error("No build output detected.  Make sure you have run greenwood build"),
+        new Error("No build output detected. Make sure you have run greenwood build"),
       );
     }
 

packages/cli/src/lifecycles/config.js

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import fs from "node:fs/promises";
 import { checkResourceExists } from "../lib/resource-utils.js";
+import { asyncMap } from "../lib/async-utils.js";
 
 const cwd = new URL(`file://${process.cwd()}/`);
 const greenwoodPluginsDirectoryUrl = new URL("../plugins/", import.meta.url);
@@ -9,26 +10,25 @@ const PLUGINS_FLATTENED_DEPTH = 2;
 // get and "tag" all plugins provided / maintained by the @greenwood/cli
 // and include as the default set, with all user plugins getting appended
 const greenwoodPlugins = (
-  await Promise.all(
+  await asyncMap(
     [
       new URL("./copy/", greenwoodPluginsDirectoryUrl),
       new URL("./renderer/", greenwoodPluginsDirectoryUrl),
       new URL("./resource/", greenwoodPluginsDirectoryUrl),
       new URL("./server/", greenwoodPluginsDirectoryUrl),
-    ].map(async (pluginDirectoryUrl) => {
+    ],
+    async (pluginDirectoryUrl) => {
       const files = await fs.readdir(pluginDirectoryUrl);
 
-      return await Promise.all(
-        files.map(async (file) => {
-          const importUrl = new URL(`./${file}`, pluginDirectoryUrl);
-          // @ts-expect-error see https://github.com/microsoft/TypeScript/issues/42866
-          const pluginImport = await import(importUrl);
-          const plugin = pluginImport[Object.keys(pluginImport)[0]];
+      return asyncMap(files, async (file) => {
+        const importUrl = new URL(`./${file}`, pluginDirectoryUrl);
+        // @ts-expect-error see https://github.com/microsoft/TypeScript/issues/42866
+        const pluginImport = await import(importUrl);
+        const plugin = pluginImport[Object.keys(pluginImport)[0]];
 
-          return Array.isArray(plugin) ? plugin : [plugin];
-        }),
-      );
-    }),
+        return Array.isArray(plugin) ? plugin : [plugin];
+      });
+    },
   )
 )
   .flat(PLUGINS_FLATTENED_DEPTH)

packages/cli/src/lifecycles/copy.js

@@ -1,17 +1,17 @@
 import fs from "node:fs/promises";
 import { checkResourceExists } from "../lib/resource-utils.js";
+import { asyncMap } from "../lib/async-utils.js";
 
 async function rreaddir(dir, allFiles = []) {
   const files = (await fs.readdir(dir)).map((f) => new URL(`./${f}`, dir));
 
   allFiles.push(...files);
 
-  await Promise.all(
-    files.map(
-      async (f) =>
-        (await fs.stat(f)).isDirectory() &&
-        (await rreaddir(new URL(`file://${f.pathname}/`), allFiles)),
-    ),
+  await asyncMap(
+    files,
+    async (f) =>
+      (await fs.stat(f)).isDirectory() &&
+      (await rreaddir(new URL(`file://${f.pathname}/`), allFiles)),
   );
 
   return allFiles;

packages/cli/src/lifecycles/prerender.js

@@ -6,6 +6,7 @@ import {
 } from "../lib/resource-utils.js";
 import os from "node:os";
 import { WorkerPool } from "../lib/threadpool.js";
+import { asyncMap } from "../lib/async-utils.js";
 
 async function createOutputDirectory(route, outputDir) {
   if (!route.endsWith("/404/") && !(await checkResourceExists(outputDir))) {
@@ -186,25 +187,23 @@ async function staticRenderCompilation(compilation) {
 
   console.info("pages to generate", `\n ${pages.map((page) => page.route).join("\n ")}`);
 
-  await Promise.all(
-    pages.map(async (page) => {
-      const { route, outputHref } = page;
-      const scratchUrl = toScratchUrl(outputHref, context);
-      const url = new URL(`http://localhost:${config.port}${route}`);
-      const request = new Request(url);
+  await asyncMap(pages, async (page) => {
+    const { route, outputHref } = page;
+    const scratchUrl = toScratchUrl(outputHref, context);
+    const url = new URL(`http://localhost:${config.port}${route}`);
+    const request = new Request(url);
 
-      let body = await (await servePage(url, request, plugins)).text();
-      body = await (await interceptPage(url, request, plugins, body)).text();
+    let body = await (await servePage(url, request, plugins)).text();
+    body = await (await interceptPage(url, request, plugins, body)).text();
 
-      await trackResourcesForRoute(body, compilation, route);
-      await createOutputDirectory(route, new URL(scratchUrl.href.replace("index.html", "")));
-      await fs.writeFile(scratchUrl, body);
+    await trackResourcesForRoute(body, compilation, route);
+    await createOutputDirectory(route, new URL(scratchUrl.href.replace("index.html", "")));
+    await fs.writeFile(scratchUrl, body);
 
-      console.info("generated page...", route);
+    console.info("generated page...", route);
 
-      return Promise.resolve();
-    }),
-  );
+    return Promise.resolve();
+  });
 }
 
 export { preRenderCompilationWorker, preRenderCompilationCustom, staticRenderCompilation };