@graphcommerce/next-config 8.1.0-canary.2 → 8.1.0-canary.5

package/src/interceptors/writeInterceptors.ts

@@ -1,23 +1,34 @@
-import fs from 'node:fs'
+import fs from 'node:fs/promises'
 import path from 'path'
 // eslint-disable-next-line import/no-extraneous-dependencies
-import glob from 'glob'
+import { sync as globSync } from 'glob'
 import { resolveDependenciesSync } from '../utils/resolveDependenciesSync'
 import { GenerateInterceptorsReturn } from './generateInterceptors'
 
-export function writeInterceptors(
+function checkFileExists(file: string) {
+  return fs
+    .access(file, fs.constants.F_OK)
+    .then(() => true)
+    .catch(() => false)
+}
+
+export async function writeInterceptors(
   interceptors: GenerateInterceptorsReturn,
   cwd: string = process.cwd(),
 ) {
   const dependencies = resolveDependenciesSync(cwd)
   const existing: string[] = []
   dependencies.forEach((dependency) => {
-    const files = glob.sync(`${dependency}/**/*.interceptor.tsx`, { cwd })
+    const files = globSync(
+      [`${dependency}/**/*.interceptor.tsx`, `${dependency}/**/*.interceptor.ts`],
+      { cwd },
+    )
     existing.push(...files)
   })
 
-  Object.entries(interceptors).forEach(([, plugin]) => {
-    const relativeFile = `${plugin.fromRoot}.interceptor.tsx`
+  const written = Object.entries(interceptors).map(async ([, plugin]) => {
+    const extension = plugin.sourcePath.endsWith('.tsx') ? '.tsx' : '.ts'
+    const relativeFile = `${plugin.fromRoot}.interceptor${extension}`
 
     if (existing.includes(relativeFile)) {
       delete existing[existing.indexOf(relativeFile)]
@@ -29,12 +40,17 @@ export function writeInterceptors(
     const fileToWrite = path.join(cwd, relativeFile)
 
     const isSame =
-      fs.existsSync(fileToWrite) &&
-      fs.readFileSync(fileToWrite, 'utf8').toString() === plugin.template
+      (await checkFileExists(fileToWrite)) &&
+      (await fs.readFile(fileToWrite, 'utf8')).toString() === plugin.template
 
-    if (!isSame) fs.writeFileSync(fileToWrite, plugin.template)
+    if (!isSame) await fs.writeFile(fileToWrite, plugin.template)
   })
 
   // Cleanup unused interceptors
-  existing.forEach((file) => fs.existsSync(file) && fs.unlinkSync(file))
+  const cleaned = existing.map(
+    async (file) => (await checkFileExists(file)) && (await fs.unlink(file)),
+  )
+
+  await Promise.all(written)
+  await Promise.all(cleaned)
 }

package/src/utils/resolveDependency.ts

@@ -1,21 +1,36 @@
 import fs from 'node:fs'
 import { resolveDependenciesSync } from './resolveDependenciesSync'
 
-export type ResolveDependencyReturn = {
-  dependency: string
-  denormalized: string
-  root: string
-  fromRoot: string
-  fromModule: string
-}
+export type ResolveDependencyReturn =
+  | undefined
+  | {
+      dependency: string
+      denormalized: string
+      root: string
+      fromRoot: string
+      fromModule: string
+      source: string
+      sourcePath: string
+    }
 
-export type ResolveDependency = (req: string) => ResolveDependencyReturn
+export type ResolveDependency = (
+  req: string,
+  options?: { includeSources?: boolean; optional?: boolean },
+) => ResolveDependencyReturn
 
 export const resolveDependency = (cwd: string = process.cwd()) => {
   const dependencies = resolveDependenciesSync(cwd)
-  return (dependency: string): ResolveDependencyReturn => {
+
+  function resolve(
+    dependency: string,
+    options: { includeSources?: boolean } = {},
+  ): ResolveDependencyReturn {
+    const { includeSources = false } = options
+
     let dependencyPaths = {
       root: '.',
+      source: '',
+      sourcePath: '',
       dependency,
       fromRoot: dependency,
       fromModule: dependency,
@@ -27,15 +42,29 @@ export const resolveDependency = (cwd: string = process.cwd()) => {
         const relative = dependency.replace(depCandidate, '')
 
         const rootCandidate = dependency.replace(depCandidate, root)
+
+        let source = ''
+        let sourcePath = ''
+
         const fromRoot = [
           `${rootCandidate}`,
           `${rootCandidate}/index`,
           `${rootCandidate}/src/index`,
         ].find((location) =>
-          ['ts', 'tsx'].find((extension) => fs.existsSync(`${location}.${extension}`)),
+          ['ts', 'tsx'].find((extension) => {
+            const candidatePath = `${location}.${extension}`
+            const exists = fs.existsSync(candidatePath)
+
+            if (includeSources && exists) {
+              source = fs.readFileSync(candidatePath, 'utf-8')
+              sourcePath = candidatePath
+            }
+            return exists
+          }),
         )
+
         if (!fromRoot) {
-          throw Error(`Can't find plugin ${dependency}`)
+          return
         }
 
         const denormalized = fromRoot.replace(root, depCandidate)
@@ -46,9 +75,19 @@ export const resolveDependency = (cwd: string = process.cwd()) => {
 
         if (dependency.startsWith('./')) fromModule = `.${relative}`
 
-        dependencyPaths = { root, dependency, denormalized, fromRoot, fromModule }
+        dependencyPaths = {
+          root,
+          dependency,
+          denormalized,
+          fromRoot,
+          fromModule,
+          source,
+          sourcePath,
+        }
       }
     })
     return dependencyPaths
   }
+
+  return resolve
 }

package/src/withGraphCommerce.ts

@@ -56,6 +56,7 @@ export function withGraphCommerce(nextConfig: NextConfig, cwd: string): NextConf
     experimental: {
       ...nextConfig.experimental,
       scrollRestoration: true,
+      bundlePagesExternals: true,
       swcPlugins: [...(nextConfig.experimental?.swcPlugins ?? []), ['@lingui/swc-plugin', {}]],
     },
     i18n: {
@@ -177,7 +178,7 @@ export function withGraphCommerce(nextConfig: NextConfig, cwd: string): NextConf
         }
       }
 
-      config.plugins.push(new InterceptorPlugin(graphcommerceConfig))
+      config.plugins.push(new InterceptorPlugin(graphcommerceConfig, !options.isServer))
 
       return typeof nextConfig.webpack === 'function' ? nextConfig.webpack(config, options) : config
     },