Make generation async

libs/plugin/package.json

@@ -4,7 +4,6 @@
   "license": "Apache-2.0",
   "repository": "https://github.com/leancodepl/contractsgenerator-typescript",
   "dependencies": {
-    "@leancodepl/contractsgenerator-typescript-schema": "1.1.3",
-    "node-cache": "^5.0.0"
+    "@leancodepl/contractsgenerator-typescript-schema": "1.1.3"
   }
 }

libs/plugin/src/lib/generatorPlugin.ts

@@ -1,4 +1,3 @@
-import NodeCache from "node-cache"
 import { GeneratorSchema } from "@leancodepl/contractsgenerator-typescript-schema"
 import { GeneratorPluginInstance } from "./generatorPluginInstance"
 
@@ -14,7 +13,6 @@ export interface GeneratorInput {
 
 export type GeneratorSessionContext = {
   getSchema(input: GeneratorInput): Promise<GeneratorSchema>
-  cache: NodeCache
   metadata: any
 }
 

package.json

@@ -7,7 +7,6 @@
     "lilconfig": "3.1.3",
     "lodash": "^4.0.0",
     "long": "5.3.2",
-    "node-cache": "5.1.2",
     "object-hash": "3.0.0",
     "tslib": "^2.3.0",
     "yaml": "2.8.0",

packages/generator/package.json

@@ -10,7 +10,6 @@
     "@leancodepl/utils": ">=7.2.3",
     "lilconfig": "3.1.3",
     "lodash": "^4.0.0",
-    "node-cache": "5.1.2",
     "object-hash": "3.0.0",
     "yaml": "2.8.0",
     "yargs": "18.0.0",

packages/generator/src/generate.ts

@@ -1,6 +1,5 @@
 import { z } from "zod/v4"
 import { GeneratorSessionContext } from "@leancodepl/contractsgenerator-typescript-plugin"
-import { cache } from "./cache"
 import { generateFile } from "./generateFile"
 import { getSchemaCached } from "./getSchemaCached"
 
@@ -26,19 +25,19 @@ const contractsGeneratorConfigurationSchema = z.object({
 export async function generate(unsafeConfig: unknown) {
   const config = contractsGeneratorConfigurationSchema.parse(unsafeConfig)
 
-  const sessionContext: GeneratorSessionContext = { getSchema: getSchemaCached(cache), metadata: {}, cache }
+  const sessionContext: GeneratorSessionContext = { getSchema: getSchemaCached(), metadata: {} }
 
   const configl1 = config.config
 
   const outputs: Record<string, string> = {}
 
-  for (const file in config.generates) {
-    const configuration = config.generates[file]
+  await Promise.all(
+    Object.entries(config.generates).map(async ([file, configuration]) => {
+      const configl2 = configuration.config ?? {}
 
-    const configl2 = configuration.config ?? {}
-
-    outputs[file] = await generateFile({ ...configl1, ...configl2 }, configuration.plugins, sessionContext)
-  }
+      outputs[file] = await generateFile({ ...configl1, ...configl2 }, configuration.plugins, sessionContext)
+    }),
+  )
 
   return outputs
 }

packages/generator/src/generateFile.ts

@@ -1,3 +1,4 @@
+import { concat } from "lodash"
 import {
   GeneratorFileContext,
   GeneratorPlugin,
@@ -14,36 +15,43 @@ export async function generateFile(
     metadata: {},
   }
 
-  let prepend = ""
-  let fileOutput = ""
-  let append = ""
-
-  for (const pluginConfiguration of plugins) {
-    let configl3, pluginName
-
-    if (typeof pluginConfiguration === "string") {
-      pluginName = pluginConfiguration
-      configl3 = {}
-    } else {
-      pluginName = Object.keys(pluginConfiguration)[0]
-      configl3 = pluginConfiguration[pluginName]
-    }
-
-    const plugin: GeneratorPlugin = await import(`@leancodepl/contractsgenerator-typescript-plugin-${pluginName}`).then(
-      plugin => plugin.default ?? plugin,
-    )
-
-    const pluginInstance = plugin.instance(
-      { ...configl2, ...configl3 },
-      { session: sessionContext, file: fileContext, plugin: fileContext },
-    )
-
-    prepend += (await pluginInstance.beforeAll?.()) ?? ""
-    fileOutput += (await pluginInstance.before?.()) ?? ""
-    fileOutput += (await pluginInstance.generate?.()) ?? ""
-    fileOutput += (await pluginInstance.after?.()) ?? ""
-    append += (await pluginInstance.afterAll?.()) ?? ""
-  }
-
-  return prepend + fileOutput + append
+  const prepend: string[] = []
+  const output: string[] = []
+  const append: string[] = []
+
+  await Promise.all(
+    plugins.map(async (pluginConfiguration, i) => {
+      let configl3, pluginName
+
+      if (typeof pluginConfiguration === "string") {
+        pluginName = pluginConfiguration
+        configl3 = {}
+      } else {
+        pluginName = Object.keys(pluginConfiguration)[0]
+        configl3 = pluginConfiguration[pluginName]
+      }
+
+      const plugin: GeneratorPlugin = await import(
+        `@leancodepl/contractsgenerator-typescript-plugin-${pluginName}`
+      ).then(plugin => plugin.default ?? plugin)
+
+      const pluginInstance = plugin.instance(
+        { ...configl2, ...configl3 },
+        { session: sessionContext, file: fileContext, plugin: fileContext },
+      )
+
+      const [beforeAll = "", before = "", generate = "", after = "", afterAll = ""] = await Promise.all([
+        pluginInstance.beforeAll?.(),
+        pluginInstance.before?.(),
+        pluginInstance.generate?.(),
+        pluginInstance.after?.(),
+        pluginInstance.afterAll?.(),
+      ])
+      prepend[i] = beforeAll
+      output[i] = before + generate + after
+      append[i] = afterAll
+    }),
+  )
+
+  return concat(prepend, output, append).join("")
 }

packages/generator/src/getSchemaCached.ts

@@ -1,21 +1,25 @@
-import NodeCache from "node-cache"
 import hash from "object-hash"
 import { GeneratorInput } from "@leancodepl/contractsgenerator-typescript-plugin"
 import { GeneratorSchema } from "@leancodepl/contractsgenerator-typescript-schema"
 import { getSchema } from "./getSchema"
 
-export function getSchemaCached(cache: NodeCache) {
-  return async (input: GeneratorInput) => {
+export function getSchemaCached() {
+  const promises = new Map<string, Promise<GeneratorSchema>>()
+
+  return (input: GeneratorInput) => {
     const inputHash = hash(input)
 
-    const cachedSchema = cache.get<GeneratorSchema>(inputHash)
+    const existingPromise = promises.get(inputHash)
 
-    if (cachedSchema) return cachedSchema
+    if (existingPromise) return existingPromise
 
-    const schema = await getSchema(input)
+    const promise = getSchema(input).catch(error => {
+      promises.delete(inputHash)
+      throw error
+    })
 
-    cache.set(inputHash, schema)
+    promises.set(inputHash, promise)
 
-    return schema
+    return promise
   }
 }