offload prettier to thread

generators/bootstrap/support/prettier-support.ts

@@ -18,12 +18,10 @@
  */
 import { passthrough } from 'p-transform';
 import { isFileStateModified } from 'mem-fs-editor/state';
-import prettier from 'prettier';
-import prettierPluginJava from 'prettier-plugin-java';
-import prettierPluginProperties from 'prettier-plugin-properties';
-import prettierPluginPackagejson from 'prettier-plugin-packagejson';
+import type prettier from 'prettier';
 import { Minimatch } from 'minimatch';
 import type { MemFsEditorFile, VinylMemFsEditorFile } from 'mem-fs-editor';
+import Tinypool from 'tinypool';
 import type CoreGenerator from '../../base-core/index.js';
 
 const minimatch = new Minimatch('**/{.prettierrc**,.prettierignore}');
@@ -41,62 +39,46 @@ export const createPrettierTransform = async function (
     prettierOptions?: prettier.Options;
   } = {},
 ) {
-  // prettier cache is global, generators may execute more than one commit.
-  // In case prettier config is committed to disk at later commits, the cache may be outdated.
-  await prettier.clearConfigCache();
+  const pool = new Tinypool({
+    runtime: 'child_process',
+    maxThreads: 1,
+    filename: new URL('./prettier-worker.js', import.meta.url).href,
+  });
 
   const { ignoreErrors = false, extensions = '*', prettierPackageJson, prettierJava, prettierProperties, prettierOptions } = options;
   const globExpression = extensions.includes(',') ? `**/*.{${extensions}}` : `**/*.${extensions}`;
   const minimatch = new Minimatch(globExpression, { dot: true });
 
-  return passthrough(async (file: VinylMemFsEditorFile) => {
-    if (!minimatch.match(file.path) || !isFileStateModified(file)) {
-      return;
-    }
-    if (!file.contents) {
-      throw new Error(`File content doesn't exist for ${file.relative}`);
-    }
-    /* resolve from the projects config */
-    let fileContent;
-    try {
-      const resolvedDestinationFileOptions = await prettier.resolveConfig(file.relative);
-      const fileOptions: prettier.Options = {
-        // Config from disk
-        ...resolvedDestinationFileOptions,
-        plugins: [],
-        // for better errors
-        filepath: file.relative,
-        ...prettierOptions,
-      };
-      if (prettierPackageJson && file.path.endsWith('package.json')) {
-        fileOptions.plugins!.push(prettierPluginPackagejson);
-      }
-      if (prettierJava && file.path.endsWith('.java')) {
-        fileOptions.plugins!.push(prettierPluginJava);
+  return passthrough(
+    async (file: VinylMemFsEditorFile) => {
+      if (!minimatch.match(file.path) || !isFileStateModified(file)) {
+        return;
       }
-      if (prettierProperties) {
-        fileOptions.plugins!.push(prettierPluginProperties);
+      if (!file.contents) {
+        throw new Error(`File content doesn't exist for ${file.relative}`);
       }
-      fileContent = file.contents.toString('utf8');
-      const data = await prettier.format(fileContent, fileOptions);
-      file.contents = Buffer.from(data);
-    } catch (error) {
-      let errorMessage;
-      if (fileContent) {
-        errorMessage = `Error parsing file ${file.relative}: ${error}
-
-At: ${fileContent
-          .split('\n')
-          .map((value, idx) => `${idx + 1}: ${value}`)
-          .join('\n')}`;
-      } else {
-        errorMessage = `Unknown prettier error: ${error}`;
+      const result = await pool.run({
+        relativeFilePath: file.relative,
+        filePath: file.path,
+        fileContents: file.contents.toString('utf8'),
+        prettierOptions,
+        prettierPackageJson,
+        prettierJava,
+        prettierProperties,
+        ignoreErrors,
+      });
+      if (result.errorMessage) {
+        if (!ignoreErrors) {
+          throw new Error(result.errorMessage);
+        }
+        this?.log?.warn?.(result.errorMessage);
       }
-      if (ignoreErrors) {
-        this?.log?.warn?.(errorMessage);
-        return;
+      if (result.fileContents) {
+        file.contents = Buffer.from(result.fileContents);
       }
-      throw new Error(errorMessage);
-    }
-  });
+    },
+    () => {
+      pool.destroy();
+    },
+  );
 };

generators/bootstrap/support/prettier-worker.js

@@ -0,0 +1,50 @@
+import prettier from 'prettier';
+import prettierPluginJava from 'prettier-plugin-java';
+import prettierPluginProperties from 'prettier-plugin-properties';
+import prettierPluginPackagejson from 'prettier-plugin-packagejson';
+
+export default async ({
+  relativeFilePath,
+  filePath,
+  fileContents,
+  prettierOptions,
+  prettierPackageJson,
+  prettierJava,
+  prettierProperties,
+}) => {
+  try {
+    const resolvedDestinationFileOptions = await prettier.resolveConfig(relativeFilePath);
+    const fileOptions = {
+      // Config from disk
+      ...resolvedDestinationFileOptions,
+      plugins: [],
+      // for better errors
+      filepath: relativeFilePath,
+      ...prettierOptions,
+    };
+    if (prettierPackageJson && filePath.endsWith('package.json')) {
+      fileOptions.plugins.push(prettierPluginPackagejson);
+    }
+    if (prettierJava && filePath.endsWith('.java')) {
+      fileOptions.plugins.push(prettierPluginJava);
+    }
+    if (prettierProperties) {
+      fileOptions.plugins.push(prettierPluginProperties);
+    }
+    const data = await prettier.format(fileContents, fileOptions);
+    return { fileContents: data };
+  } catch (error) {
+    let errorMessage;
+    if (fileContents) {
+      errorMessage = `Error parsing file ${relativeFilePath}: ${error}
+
+At: ${fileContents
+        .split('\n')
+        .map((value, idx) => `${idx + 1}: ${value}`)
+        .join('\n')}`;
+    } else {
+      errorMessage = `Unknown prettier error: ${error}`;
+    }
+    return { errorMessage };
+  }
+};