@graphcommerce/next-config 8.1.0-canary.3 → 8.1.0-canary.6

package/src/interceptors/InterceptorPlugin.ts

@@ -6,48 +6,93 @@ import { findPlugins } from './findPlugins'
 import { generateInterceptors, GenerateInterceptorsReturn } from './generateInterceptors'
 import { writeInterceptors } from './writeInterceptors'
 
-export class InterceptorPlugin {
-  private interceptors: GenerateInterceptorsReturn
+let interceptors: GenerateInterceptorsReturn | undefined
+let interceptorByDepependency: GenerateInterceptorsReturn | undefined
+
+let generating = false
 
-  private interceptorByDepependency: GenerateInterceptorsReturn
+// let totalGenerationTime = 0
 
+export class InterceptorPlugin {
   private resolveDependency: ResolveDependency
 
-  constructor(private config: GraphCommerceConfig) {
+  constructor(
+    private config: GraphCommerceConfig,
+    private regenerate: boolean = false,
+  ) {
     this.resolveDependency = resolveDependency()
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    if (regenerate) this.#generateInterceptors()
+  }
+
+  #generateInterceptors = async () => {
+    if (generating) return {}
+    generating = true
+    const start = Date.now()
+
+    // console.log('Generating interceptors...')
+
     const [plugins, errors] = findPlugins(this.config)
-    this.interceptors = generateInterceptors(plugins, this.resolveDependency, this.config.debug)
-    this.interceptorByDepependency = Object.fromEntries(
-      Object.values(this.interceptors).map((i) => [i.dependency, i]),
+
+    // console.log(errors)
+
+    // const found = Date.now()
+    // console.log('Found plugins in', found - start, 'ms')
+
+    const generatedInterceptors = await generateInterceptors(
+      plugins,
+      this.resolveDependency,
+      this.config.debug,
     )
 
-    writeInterceptors(this.interceptors)
+    // const generated = Date.now()
+    // console.log('Generated interceptors in', generated - found, 'ms')
+
+    await writeInterceptors(generatedInterceptors)
+
+    // const wrote = Date.now()
+    // console.log('Wrote interceptors in', wrote - generated, 'ms')
+
+    interceptors = generatedInterceptors
+
+    interceptorByDepependency = Object.fromEntries(
+      Object.values(interceptors).map((i) => [i.dependency, i]),
+    )
+
+    // totalGenerationTime += Date.now() - start
+    generating = false
+
+    return generatedInterceptors
   }
 
   apply(compiler: Compiler): void {
     const logger = compiler.getInfrastructureLogger('InterceptorPlugin')
 
     // After the compilation has succeeded we watch all possible plugin locations.
-    compiler.hooks.afterCompile.tap('InterceptorPlugin', (compilation) => {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const [plugins, errors] = findPlugins(this.config)
+    if (this.regenerate) {
+      compiler.hooks.afterCompile.tap('InterceptorPlugin', (compilation) => {
+        // console.log('generate interceptors after compile')
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const [plugins, errors] = findPlugins(this.config)
 
-      plugins.forEach((p) => {
-        const absoluteFilePath = `${path.join(
-          process.cwd(),
-          this.resolveDependency(p.plugin).fromRoot,
-        )}.tsx`
-        compilation.fileDependencies.add(absoluteFilePath)
-      })
+        plugins.forEach((p) => {
+          const source = this.resolveDependency(p.sourceModule)
+          if (source) {
+            const absoluteFilePath = `${path.join(process.cwd(), source.fromRoot)}.tsx`
+            compilation.fileDependencies.add(absoluteFilePath)
+          }
+        })
 
-      this.interceptors = generateInterceptors(plugins, this.resolveDependency, this.config.debug)
-      this.interceptorByDepependency = Object.fromEntries(
-        Object.values(this.interceptors).map((i) => [i.dependency, i]),
-      )
-      writeInterceptors(this.interceptors)
-    })
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this.#generateInterceptors().then((i) => {
+          Object.entries(i).forEach(([key, { sourcePath }]) => {
+            const absoluteFilePath = path.join(process.cwd(), sourcePath)
+            compilation.fileDependencies.add(absoluteFilePath)
+          })
+        })
+      })
+    }
 
     compiler.hooks.normalModuleFactory.tap('InterceptorPlugin', (nmf) => {
       nmf.hooks.beforeResolve.tap('InterceptorPlugin', (resource) => {
@@ -58,21 +103,34 @@ export class InterceptorPlugin {
           path.resolve(resource.context, resource.request),
         )
 
-        if (issuer.endsWith('interceptor.tsx') && this.interceptors[requestPath]) {
+        if (!interceptors || !interceptorByDepependency) {
+          // console.log('interceptors not ready')
+          return
+        }
+
+        const split = requestPath.split('/')
+        const targets = [
+          `${split[split.length - 1]}.interceptor.tsx`,
+          `${split[split.length - 1]}.interceptor.ts`,
+        ]
+
+        if (targets.some((target) => issuer.endsWith(target)) && interceptors[requestPath]) {
           logger.log(`Interceptor ${issuer} is requesting the original ${requestPath}`)
           return
         }
 
-        const interceptorForRequest = this.interceptorByDepependency[resource.request]
+        const interceptorForRequest = interceptorByDepependency[resource.request]
         if (interceptorForRequest) {
-          logger.log(`Intercepting dep... ${interceptorForRequest.dependency}`)
-          resource.request = `${interceptorForRequest.denormalized}.interceptor.tsx`
+          const extension = interceptorForRequest.sourcePath.endsWith('.tsx') ? '.tsx' : '.ts'
+          resource.request = `${interceptorForRequest.denormalized}.interceptor${extension}`
+          logger.log(`Intercepting dep... ${interceptorForRequest.dependency}`, resource.request)
         }
 
-        const interceptorForPath = this.interceptors[requestPath]
+        const interceptorForPath = interceptors[requestPath]
         if (interceptorForPath) {
-          logger.log(`Intercepting fromRoot... ${interceptorForPath.fromRoot}`)
-          resource.request = `${resource.request}.interceptor.tsx`
+          const extension = interceptorForPath.sourcePath.endsWith('.tsx') ? '.tsx' : '.ts'
+          resource.request = `${resource.request}.interceptor${extension}`
+          logger.log(`Intercepting fromRoot... ${interceptorForPath.dependency}`, resource.request)
         }
       })
     })

package/src/interceptors/RenameVisitor.ts

@@ -0,0 +1,17 @@
+/* eslint-disable max-classes-per-file */
+import { Identifier } from '@swc/core'
+import { Visitor } from './Visitor'
+
+export class RenameVisitor extends Visitor {
+  constructor(
+    private replace: string[],
+    private suffix: (v: string) => string,
+  ) {
+    super()
+  }
+
+  visitIdentifier(n: Identifier): Identifier {
+    if (this.replace.includes(n.value)) n.value = this.suffix(n.value)
+    return n
+  }
+}