@graphcommerce/next-config 9.0.0-canary.106 → 9.0.0-canary.108

package/src/commands/copyFiles.ts

@@ -1,19 +1,17 @@
+/* eslint-disable no-await-in-loop */
 import fs from 'fs/promises'
 import path from 'path'
-import { glob } from 'glob'
+import fg from 'fast-glob'
 import { resolveDependenciesSync } from '../utils/resolveDependenciesSync'
 
 // Add debug logging helper
 const debug = (...args: unknown[]) => {
-  if (process.env.DEBUG) console.log('[copyFiles]', ...args)
+  if (process.env.DEBUG) console.log('[copy-files]', ...args)
 }
 
 // Add constants for the magic comments
-type FileManagement = 'graphcommerce' | 'local'
-const createManagementComment = (type: FileManagement) => `// managed by: ${type}`
-
-const MANAGED_BY_GC = createManagementComment('graphcommerce')
-const MANAGED_LOCALLY = createManagementComment('local')
+const MANAGED_BY_GC = '// managed by: graphcommerce'
+const MANAGED_LOCALLY = '// managed by: local'
 
 const GITIGNORE_SECTION_START = '# managed by: graphcommerce'
 const GITIGNORE_SECTION_END = '# end managed by: graphcommerce'
@@ -30,11 +28,9 @@ async function updateGitignore(managedFiles: string[]) {
   const gitignorePath = path.join(process.cwd(), '.gitignore')
   let content: string
 
-  debug('Updating .gitignore with managed files:', managedFiles)
-
   try {
     content = await fs.readFile(gitignorePath, 'utf-8')
-    debug('Existing .gitignore content:', content)
+    debug('Reading existing .gitignore')
   } catch (err) {
     debug('.gitignore not found, creating new file')
     content = ''
@@ -46,7 +42,6 @@ async function updateGitignore(managedFiles: string[]) {
     'g',
   )
   content = content.replace(sectionRegex, '')
-  debug('Content after removing existing section:', content)
 
   // Only add new section if there are files to manage
   if (managedFiles.length > 0) {
@@ -56,23 +51,16 @@ async function updateGitignore(managedFiles: string[]) {
       GITIGNORE_SECTION_END,
       '', // Empty line at the end
     ].join('\n')
-    debug('New section to add:', newSection)
 
     // Append the new section
     content = `${content.trim()}\n\n${newSection}`
+    debug(`Updated .gitignore with ${managedFiles.length} managed files`)
   } else {
-    // Just trim the content when no files to manage
     content = `${content.trim()}\n`
+    debug('Cleaned up .gitignore managed section')
   }
 
-  debug('Final content:', content)
-
-  try {
-    await fs.writeFile(gitignorePath, content)
-    debug('Successfully wrote .gitignore file')
-  } catch (err) {
-    console.error('Error writing .gitignore:', err)
-  }
+  await fs.writeFile(gitignorePath, content)
 }
 
 /** Determines how a file should be managed based on its content */
@@ -97,53 +85,100 @@ function getFileManagement(content: Buffer | undefined): 'local' | 'graphcommerc
  *    4. If the file is managed by graphcommerce: Update if content differs
  */
 export async function copyFiles() {
+  const startTime = performance.now()
   debug('Starting copyFiles')
 
   const cwd = process.cwd()
   const deps = resolveDependenciesSync()
   const packages = [...deps.values()].filter((p) => p !== '.')
-  debug('Found packages:', packages)
 
   // Track files and their source packages to detect conflicts
   const fileMap = new Map<string, { sourcePath: string; packagePath: string }>()
-  // Track which files are managed by GraphCommerce
   const managedFiles = new Set<string>()
+  const existingManagedFiles = new Set<string>()
+
+  // First scan existing files to find GraphCommerce managed ones
+  const scanStart = performance.now()
+  try {
+    // Use only default patterns for testing
+    const gitignorePatterns = [
+      '**/dist/**',
+      '**/build/**',
+      '**/.next/**',
+      '**/.git/**',
+      '**/node_modules/**',
+    ]
+
+    const allFiles = await fg('**/*', {
+      cwd,
+      dot: true,
+      ignore: gitignorePatterns,
+      onlyFiles: true,
+    })
+    debug(
+      `Found ${allFiles.length} project files in ${(performance.now() - scanStart).toFixed(0)}ms`,
+    )
+
+    const readStart = performance.now()
+    await Promise.all(
+      allFiles.map(async (file) => {
+        const filePath = path.join(cwd, file)
+        try {
+          const content = await fs.readFile(filePath)
+          if (getFileManagement(content) === 'graphcommerce') {
+            existingManagedFiles.add(file)
+            debug(`Found existing managed file: ${file}`)
+          }
+        } catch (err) {
+          debug(`Error reading file ${file}:`, err)
+        }
+      }),
+    )
+    debug(
+      `Read ${existingManagedFiles.size} managed files in ${(performance.now() - readStart).toFixed(0)}ms`,
+    )
+  } catch (err) {
+    debug('Error scanning project files:', err)
+  }
 
   // First pass: collect all files and check for conflicts
+  const collectStart = performance.now()
   await Promise.all(
     packages.map(async (pkg) => {
       const copyDir = path.join(pkg, 'copy')
-
       try {
-        const files = await glob('**/*', { cwd: copyDir, nodir: true, dot: true })
-        debug(`Found files in ${pkg}:`, files)
+        const files = await fg('**/*', { cwd: copyDir, dot: true, suppressErrors: true })
+        if (files.length > 0) {
+          debug(`Found files in ${pkg}:`, files)
 
-        for (const file of files) {
-          const sourcePath = path.join(copyDir, file)
-          const existing = fileMap.get(file)
+          for (const file of files) {
+            const sourcePath = path.join(copyDir, file)
+            const existing = fileMap.get(file)
 
-          if (existing) {
-            console.error(`Error: File conflict detected for '${file}'
+            if (existing) {
+              console.error(`Error: File conflict detected for '${file}'
 Found in packages:
   - ${existing.packagePath} -> ${existing.sourcePath}
   - ${pkg} -> ${sourcePath}`)
-            process.exit(1)
-          }
+              process.exit(1)
+            }
 
-          fileMap.set(file, { sourcePath, packagePath: pkg })
+            fileMap.set(file, { sourcePath, packagePath: pkg })
+          }
         }
       } catch (err) {
-        // Skip if copy directory doesn't exist
-        if ((err as { code?: string }).code !== 'ENOENT') {
-          console.error(`Error scanning directory ${copyDir}: ${(err as Error).message}
-Path: ${copyDir}`)
-          process.exit(1)
-        }
+        if ((err as { code?: string }).code === 'ENOENT') return
+        console.error(
+          `Error scanning directory ${copyDir}: ${(err as Error).message}\nPath: ${copyDir}`,
+        )
+        process.exit(1)
       }
     }),
   )
+  debug(`Collected ${fileMap.size} files in ${(performance.now() - collectStart).toFixed(0)}ms`)
 
-  // Second pass: copy files
+  // Second pass: copy files and handle removals
+  const copyStart = performance.now()
   await Promise.all(
     Array.from(fileMap.entries()).map(async ([file, { sourcePath }]) => {
       const targetPath = path.join(cwd, file)
@@ -154,8 +189,9 @@ Path: ${copyDir}`)
 
         const sourceContent = await fs.readFile(sourcePath)
         const contentWithComment = Buffer.concat([
-          Buffer.from(`${MANAGED_BY_GC}\n`),
-          Buffer.from('// to modify this file, change it to managed by: local\n\n'),
+          Buffer.from(
+            `${MANAGED_BY_GC}\n// to modify this file, change it to managed by: local\n\n`,
+          ),
           sourceContent,
         ])
 
@@ -184,8 +220,7 @@ Path: ${copyDir}`)
 Source: ${sourcePath}`)
             process.exit(1)
           }
-          console.log(`Creating new file: ${file}
-Source: ${sourcePath}`)
+          console.log(`Creating new file: ${file}\nSource: ${sourcePath}`)
           debug('File does not exist yet')
         }
 
@@ -215,13 +250,79 @@ Source: ${sourcePath}`)
       }
     }),
   )
+  debug(`Copied ${managedFiles.size} files in ${(performance.now() - copyStart).toFixed(0)}ms`)
+
+  // Remove files that are no longer provided
+  const removeStart = performance.now()
+  const filesToRemove = Array.from(existingManagedFiles).filter((file) => !managedFiles.has(file))
+  debug(`Files to remove: ${filesToRemove.length}`)
+
+  // Helper function to recursively clean up empty directories
+  async function cleanupEmptyDirs(startPath: string) {
+    let currentDir = startPath
+    while (currentDir !== cwd) {
+      try {
+        const dirContents = await fs.readdir(currentDir)
+        if (dirContents.length === 0) {
+          await fs.rmdir(currentDir)
+          debug(`Removed empty directory: ${currentDir}`)
+          currentDir = path.dirname(currentDir)
+        } else {
+          break // Stop if directory is not empty
+        }
+      } catch (err) {
+        if ((err as { code?: string }).code === 'EACCES') {
+          console.error(`Error cleaning up directory ${currentDir}: ${(err as Error).message}`)
+          process.exit(1)
+        }
+        break // Stop on other errors (like ENOENT)
+      }
+    }
+  }
+
+  // Process file removals in parallel
+  await Promise.all(
+    filesToRemove.map(async (file) => {
+      const filePath = path.join(cwd, file)
+      const dirPath = path.dirname(filePath)
+
+      try {
+        // First check if the directory exists and is accessible
+        await fs.readdir(dirPath)
+
+        // Then try to remove the file
+        try {
+          await fs.unlink(filePath)
+          console.log(`Removed managed file: ${file}`)
+          debug(`Removed file: ${file}`)
+        } catch (err) {
+          if ((err as { code?: string }).code !== 'ENOENT') {
+            console.error(`Error removing file ${file}: ${(err as Error).message}`)
+            process.exit(1)
+          }
+        }
+
+        // Finally, try to clean up empty directories
+        await cleanupEmptyDirs(dirPath)
+      } catch (err) {
+        if ((err as { code?: string }).code === 'EACCES') {
+          console.error(`Error accessing directory ${dirPath}: ${(err as Error).message}`)
+          process.exit(1)
+        }
+        // Ignore ENOENT errors for directories that don't exist
+      }
+    }),
+  )
+  debug(`Removed files in ${(performance.now() - removeStart).toFixed(0)}ms`)
 
-  // Update .gitignore with the list of managed files
+  // Update .gitignore with current list of managed files
   if (managedFiles.size > 0) {
     debug('Found managed files:', Array.from(managedFiles))
     await updateGitignore(Array.from(managedFiles))
   } else {
     debug('No managed files found, cleaning up .gitignore section')
-    await updateGitignore([]) // Pass empty array to clean up the section
+    await updateGitignore([])
   }
+
+  debug(`Total execution time: ${(performance.now() - startTime).toFixed(0)}ms`)
 }

package/src/config/utils/mergeEnvIntoConfig.ts

@@ -5,6 +5,7 @@ import { get, set } from 'lodash'
 import snakeCase from 'lodash/snakeCase'
 import type { ZodAny, ZodRawShape, ZodTypeAny } from 'zod'
 import {
+  z,
   ZodArray,
   ZodBoolean,
   ZodDefault,
@@ -15,7 +16,6 @@ import {
   ZodObject,
   ZodOptional,
   ZodString,
-  z,
 } from 'zod'
 import diff from './diff'
 
@@ -207,7 +207,7 @@ export function formatAppliedEnv(applyResult: ApplyResult) {
   const lines = applyResult.map(({ from, to, envValue, envVar, dotVar, error, warning }) => {
     const fromFmt = chalk.red(JSON.stringify(from))
     const toFmt = chalk.green(JSON.stringify(to))
-    const envVariableFmt = `${envVar}='${envValue}'`
+    const envVariableFmt = `${envVar}`
     const dotVariableFmt = chalk.bold.underline(`${dotVar}`)
 
     const baseLog = `${envVariableFmt} => ${dotVariableFmt}`
@@ -223,11 +223,10 @@ export function formatAppliedEnv(applyResult: ApplyResult) {
 
     if (!dotVar) return chalk.red(`${envVariableFmt} => ignored (no matching config)`)
 
-    if (from === undefined && to === undefined)
-      return ` = ${baseLog}: (ignored, no change/wrong format)`
-    if (from === undefined && to !== undefined) return ` ${chalk.green('+')} ${baseLog}: ${toFmt}`
-    if (from !== undefined && to === undefined) return ` ${chalk.red('-')} ${baseLog}: ${fromFmt}`
-    return ` ${chalk.yellowBright('~')} ${baseLog}: ${fromFmt} => ${toFmt}`
+    if (from === undefined && to === undefined) return ` = ${baseLog}: (ignored)`
+    if (from === undefined && to !== undefined) return ` ${chalk.green('+')} ${baseLog}`
+    if (from !== undefined && to === undefined) return ` ${chalk.red('-')} ${baseLog}`
+    return ` ${chalk.yellowBright('~')} ${baseLog}`
   })
 
   let header = chalk.blueBright('info')

package/src/generated/config.ts

@@ -215,6 +215,8 @@ export type GraphCommerceConfig = {
    * To override the value for a specific locale, configure in i18n config.
    */
   googleAnalyticsId?: InputMaybe<Scalars['String']['input']>;
+  /** To create an assetlinks.json file for the Android app. */
+  googlePlaystore?: InputMaybe<GraphCommerceGooglePlaystoreConfig>;
   /**
    * Google reCAPTCHA site key.
    * When using reCAPTCHA, this value is required, even if you are configuring different values for each locale.
@@ -369,6 +371,14 @@ export type GraphCommerceDebugConfig = {
   webpackDuplicatesPlugin?: InputMaybe<Scalars['Boolean']['input']>;
 };
 
+/** See https://developer.android.com/training/app-links/verify-android-applinks#web-assoc */
+export type GraphCommerceGooglePlaystoreConfig = {
+  /** The package name of the Android app. */
+  packageName: Scalars['String']['input'];
+  /** The sha256 certificate fingerprint of the Android app. */
+  sha256CertificateFingerprint: Scalars['String']['input'];
+};
+
 /** Permissions input */
 export type GraphCommercePermissions = {
   /** Changes the availability of the add to cart buttons and the cart page to either customer only or completely disables it. */
@@ -546,6 +556,7 @@ export function GraphCommerceConfigSchema(): z.ZodObject<Properties<GraphCommerc
     demoMode: z.boolean().default(true).nullish(),
     enableGuestCheckoutLogin: z.boolean().nullish(),
     googleAnalyticsId: z.string().nullish(),
+    googlePlaystore: GraphCommerceGooglePlaystoreConfigSchema().nullish(),
     googleRecaptchaKey: z.string().nullish(),
     googleTagmanagerId: z.string().nullish(),
     hygraphEndpoint: z.string().min(1),
@@ -579,6 +590,13 @@ export function GraphCommerceDebugConfigSchema(): z.ZodObject<Properties<GraphCo
   })
 }
 
+export function GraphCommerceGooglePlaystoreConfigSchema(): z.ZodObject<Properties<GraphCommerceGooglePlaystoreConfig>> {
+  return z.object({
+    packageName: z.string().min(1),
+    sha256CertificateFingerprint: z.string().min(1)
+  })
+}
+
 export function GraphCommercePermissionsSchema(): z.ZodObject<Properties<GraphCommercePermissions>> {
   return z.object({
     cart: CartPermissionsSchema.nullish(),

package/src/index.ts

@@ -10,7 +10,6 @@ export * from './utils/sig'
 export * from './withGraphCommerce'
 export * from './generated/config'
 export * from './config'
-export * from './runtimeCachingOptimizations'
 export * from './interceptors/commands/codegenInterceptors'
 export * from './commands/copyFiles'
 export * from './commands/codegen'

package/src/interceptors/generateInterceptor.ts

@@ -67,8 +67,8 @@ export type Interceptor = ResolveDependencyReturn & {
 
 export type MaterializedPlugin = Interceptor & { template: string }
 
-export const SOURCE_START = '/** Original source starts here (do not modify!): **/'
-export const SOURCE_END = '/** Original source ends here (do not modify!) **/'
+export const SOURCE_START = '/** SOURCE_START */'
+export const SOURCE_END = '/** SOURCE_END */'
 
 const originalSuffix = 'Original'
 const interceptorSuffix = 'Interceptor'
@@ -103,9 +103,7 @@ const generateIdentifyer = (s: string) =>
     }, 0),
   ).toString()
 
-/**
- * The is on the first line, with the format: \/* hash:${identifer} *\/
- */
+/** The is on the first line, with the format: /* hash:${identifer} */
 function extractIdentifier(source: string | undefined) {
   if (!source) return null
   const match = source.match(/\/\* hash:(\d+) \*\//)

package/src/utils/isMonorepo.ts

@@ -1,8 +1,83 @@
+import fs from 'node:fs'
 import path from 'node:path'
 
+const debug = process.env.DEBUG === '1'
+// eslint-disable-next-line no-console
+const log = (message: string) => debug && console.log(`isMonorepo: ${message}`)
+
+function findPackageJson(directory: string): { name: string } | null {
+  try {
+    const packageJsonPath = path.join(directory, 'package.json')
+    const content = fs.readFileSync(packageJsonPath, 'utf8')
+    return JSON.parse(content)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Determines if we're running in a monorepo context and how to handle postinstall scripts.
+ *
+ * If there is a parent `@graphcommerce/*` package, we're in a monorepo.
+ */
 export function isMonorepo() {
-  const root = process.cwd()
-  const meshDir = path.dirname(require.resolve('@graphcommerce/graphql-mesh'))
-  const relativePath = path.join(path.relative(meshDir, root), '/')
-  return relativePath.startsWith(`..${path.sep}..${path.sep}examples`)
+  let currentDir = process.cwd()
+  log(`Starting directory: ${currentDir}`)
+
+  // Start from the parent directory to find a parent @graphcommerce package
+  currentDir = path.dirname(currentDir)
+  log(`Looking for parent packages starting from: ${currentDir}`)
+
+  // Keep going up until we find a root package or hit the filesystem root
+  while (currentDir !== path.parse(currentDir).root) {
+    const packageJson = findPackageJson(currentDir)
+
+    if (packageJson) {
+      log(`Found package.json in: ${currentDir}`)
+      log(`Package name: ${packageJson.name}`)
+
+      if (packageJson.name.startsWith('@graphcommerce/')) {
+        log('isMonorepo result: true (found parent @graphcommerce package)')
+        return true
+      }
+    }
+
+    currentDir = path.dirname(currentDir)
+  }
+
+  log('isMonorepo result: false (no parent @graphcommerce package found)')
+  return false
+}
+
+/**
+ * Finds the path of the parent @graphcommerce package if it exists Returns null if no parent
+ * package is found
+ */
+export function findParentPath(directory: string): string | null {
+  let currentDir = directory
+  log(`Starting directory: ${currentDir}`)
+
+  // Start from the parent directory
+  currentDir = path.dirname(currentDir)
+  log(`Looking for parent packages starting from: ${currentDir}`)
+
+  // Keep going up until we find a root package or hit the filesystem root
+  while (currentDir !== path.parse(currentDir).root) {
+    const packageJson = findPackageJson(currentDir)
+
+    if (packageJson) {
+      log(`Found package.json in: ${currentDir}`)
+      log(`Package name: ${packageJson.name}`)
+
+      if (packageJson.name.startsWith('@graphcommerce/')) {
+        log(`Found parent @graphcommerce package at: ${currentDir}`)
+        return currentDir
+      }
+    }
+
+    currentDir = path.dirname(currentDir)
+  }
+
+  log('No parent @graphcommerce package found')
+  return null
 }

package/src/withGraphCommerce.ts

@@ -41,7 +41,7 @@ function domains(config: GraphCommerceConfig): DomainLocale[] {
  * module.exports = withGraphCommerce(nextConfig)
  * ```
  */
-export function withGraphCommerce(nextConfig: NextConfig, cwd: string): NextConfig {
+export function withGraphCommerce(nextConfig: NextConfig, cwd: string = process.cwd()): NextConfig {
   graphcommerceConfig ??= loadConfig(cwd)
   const importMetaPaths = configToImportMeta(graphcommerceConfig)
 
@@ -54,10 +54,10 @@ export function withGraphCommerce(nextConfig: NextConfig, cwd: string): NextConf
 
   return {
     ...nextConfig,
+    bundlePagesRouterDependencies: true,
     experimental: {
       ...nextConfig.experimental,
       scrollRestoration: true,
-      bundlePagesExternals: true,
       swcPlugins: [...(nextConfig.experimental?.swcPlugins ?? []), ['@lingui/swc-plugin', {}]],
     },
     i18n: {

package/dist/runtimeCachingOptimizations.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runtimeCachingOptimizations = void 0;
-exports.runtimeCachingOptimizations = [
-    {
-        urlPattern: /\/_next\/image\?url=.+$/i,
-        handler: 'StaleWhileRevalidate',
-        options: {
-            cacheName: 'next-image',
-            expiration: {
-                maxEntries: 1000, // 1000 images
-                maxAgeSeconds: 168 * 60 * 60, // 1 week
-                matchOptions: { ignoreVary: true },
-            },
-        },
-    },
-    {
-        urlPattern: /\/_next\/data\/.+\/.+\.json$/i,
-        handler: 'NetworkFirst',
-        options: {
-            cacheName: 'next-data',
-            expiration: {
-                maxEntries: 32,
-                maxAgeSeconds: 24 * 60 * 60, // 24 hours
-            },
-        },
-    },
-];

package/src/runtimeCachingOptimizations.ts

@@ -1,27 +0,0 @@
-import type { RuntimeCaching } from 'workbox-build'
-
-export const runtimeCachingOptimizations: RuntimeCaching[] = [
-  {
-    urlPattern: /\/_next\/image\?url=.+$/i,
-    handler: 'StaleWhileRevalidate',
-    options: {
-      cacheName: 'next-image',
-      expiration: {
-        maxEntries: 1000, // 1000 images
-        maxAgeSeconds: 168 * 60 * 60, // 1 week
-        matchOptions: { ignoreVary: true },
-      },
-    },
-  },
-  {
-    urlPattern: /\/_next\/data\/.+\/.+\.json$/i,
-    handler: 'NetworkFirst',
-    options: {
-      cacheName: 'next-data',
-      expiration: {
-        maxEntries: 32,
-        maxAgeSeconds: 24 * 60 * 60, // 24 hours
-      },
-    },
-  },
-]