@graphcommerce/next-config 9.0.0-canary.105 → 9.0.0-canary.107

package/src/commands/copyFiles.ts

@@ -0,0 +1,329 @@
+/* eslint-disable no-await-in-loop */
+import fs from 'fs/promises'
+import path from 'path'
+import fg from 'fast-glob'
+import { resolveDependenciesSync } from '../utils/resolveDependenciesSync'
+
+// Add debug logging helper
+const debug = (...args: unknown[]) => {
+  if (process.env.DEBUG) console.log('[copy-files]', ...args)
+}
+
+// Add constants for the magic comments
+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'
+
+/**
+ * Updates the .gitignore file with a list of GraphCommerce managed files
+ *
+ * - Removes any existing GraphCommerce managed files section
+ * - If managedFiles is not empty, adds a new section with the files
+ * - If managedFiles is empty, just cleans up the existing section
+ * - Ensures the file ends with a newline
+ */
+async function updateGitignore(managedFiles: string[]) {
+  const gitignorePath = path.join(process.cwd(), '.gitignore')
+  let content: string
+
+  try {
+    content = await fs.readFile(gitignorePath, 'utf-8')
+    debug('Reading existing .gitignore')
+  } catch (err) {
+    debug('.gitignore not found, creating new file')
+    content = ''
+  }
+
+  // Remove existing GraphCommerce section if it exists
+  const sectionRegex = new RegExp(
+    `${GITIGNORE_SECTION_START}[\\s\\S]*?${GITIGNORE_SECTION_END}\\n?`,
+    'g',
+  )
+  content = content.replace(sectionRegex, '')
+
+  // Only add new section if there are files to manage
+  if (managedFiles.length > 0) {
+    const newSection = [
+      GITIGNORE_SECTION_START,
+      ...managedFiles.sort(),
+      GITIGNORE_SECTION_END,
+      '', // Empty line at the end
+    ].join('\n')
+
+    // Append the new section
+    content = `${content.trim()}\n\n${newSection}`
+    debug(`Updated .gitignore with ${managedFiles.length} managed files`)
+  } else {
+    content = `${content.trim()}\n`
+    debug('Cleaned up .gitignore managed section')
+  }
+
+  await fs.writeFile(gitignorePath, content)
+}
+
+/** Determines how a file should be managed based on its content */
+function getFileManagement(content: Buffer | undefined): 'local' | 'graphcommerce' | 'unmanaged' {
+  if (!content) return 'graphcommerce'
+  const contentStr = content.toString()
+  if (contentStr.startsWith(MANAGED_LOCALLY)) return 'local'
+  if (contentStr.startsWith(MANAGED_BY_GC)) return 'graphcommerce'
+  return 'unmanaged'
+}
+
+/**
+ * The packages are @graphcommerce/* packages and have special treatment.
+ *
+ * 1. Glob the `copy/**` directory for each package and generate a list of files that need to be
+ *    copied. Error if a file with the same path exists in another package.
+ * 2. Copy the files to the project directory (cwd).
+ *
+ *    1. If the file doesn't exist: Create directories and the file with "managed by: graphcommerce"
+ *    2. If the file exists and starts with "managed by: local": Skip the file
+ *    3. If the file exists but doesn't have a management comment: Suggest adding "managed by: local"
+ *    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 !== '.')
+
+  // Track files and their source packages to detect conflicts
+  const fileMap = new Map<string, { sourcePath: string; packagePath: string }>()
+  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 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)
+
+            if (existing) {
+              console.error(`Error: File conflict detected for '${file}'
+Found in packages:
+  - ${existing.packagePath} -> ${existing.sourcePath}
+  - ${pkg} -> ${sourcePath}`)
+              process.exit(1)
+            }
+
+            fileMap.set(file, { sourcePath, packagePath: pkg })
+          }
+        }
+      } catch (err) {
+        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 and handle removals
+  const copyStart = performance.now()
+  await Promise.all(
+    Array.from(fileMap.entries()).map(async ([file, { sourcePath }]) => {
+      const targetPath = path.join(cwd, file)
+      debug(`Processing file: ${file}`)
+
+      try {
+        await fs.mkdir(path.dirname(targetPath), { recursive: true })
+
+        const sourceContent = await fs.readFile(sourcePath)
+        const contentWithComment = Buffer.concat([
+          Buffer.from(
+            `${MANAGED_BY_GC}\n// to modify this file, change it to managed by: local\n\n`,
+          ),
+          sourceContent,
+        ])
+
+        let targetContent: Buffer | undefined
+
+        try {
+          targetContent = await fs.readFile(targetPath)
+
+          const management = getFileManagement(targetContent)
+          if (management === 'local') {
+            debug(`File ${file} is managed locally, skipping`)
+            return
+          }
+          if (management === 'unmanaged') {
+            console.log(
+              `Note: File ${file} has been modified. Add '${MANAGED_LOCALLY.trim()}' at the top to manage it locally.`,
+            )
+            debug(`File ${file} doesn't have management comment, skipping`)
+            return
+          }
+
+          debug(`File ${file} is managed by graphcommerce, will update if needed`)
+        } catch (err) {
+          if ((err as { code?: string }).code !== 'ENOENT') {
+            console.error(`Error reading file ${file}: ${(err as Error).message}
+Source: ${sourcePath}`)
+            process.exit(1)
+          }
+          console.log(`Creating new file: ${file}
+Source: ${sourcePath}`)
+          debug('File does not exist yet')
+        }
+
+        // Skip if content is identical (including magic comment)
+        if (targetContent && Buffer.compare(contentWithComment, targetContent) === 0) {
+          debug(`File ${file} content is identical to source, skipping`)
+          managedFiles.add(file)
+          return
+        }
+
+        // Copy the file with magic comment
+        await fs.writeFile(targetPath, contentWithComment)
+        if (targetContent) {
+          console.log(`Updated managed file: ${file}`)
+          debug(`Overwrote existing file: ${file}`)
+        }
+
+        // If the file is managed by GraphCommerce (new or updated), add it to managedFiles
+        if (!targetContent || targetContent.toString().startsWith(MANAGED_BY_GC)) {
+          managedFiles.add(file)
+          debug('Added managed file:', file)
+        }
+      } catch (err) {
+        console.error(`Error copying file ${file}: ${(err as Error).message}
+Source: ${sourcePath}`)
+        process.exit(1)
+      }
+    }),
+  )
+  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 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([])
+  }
+
+  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

@@ -6,11 +6,14 @@ import type { GraphCommerceConfig } from './generated/config'
 export * from './utils/isMonorepo'
 export * from './utils/resolveDependenciesSync'
 export * from './utils/packageRoots'
+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'
 
 export type PluginProps<P extends Record<string, unknown> = Record<string, unknown>> = P & {
   Prev: React.FC<P>
@@ -21,9 +24,7 @@ export type FunctionPlugin<T extends (...args: any[]) => any> = (
   ...args: Parameters<T>
 ) => ReturnType<T>
 
-/**
- * @deprecated use FunctionPlugin instead
- */
+/** @deprecated Use FunctionPlugin instead */
 export type MethodPlugin<T extends (...args: any[]) => any> = (
   prev: T,
   ...args: Parameters<T>

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/resolveDependenciesSync.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import type { PackageJson } from 'type-fest'
 import { PackagesSort } from './PackagesSort'
+import { g, sig } from './sig'
 
 type PackageNames = Map<string, string>
 type DependencyStructure = Record<string, { dirName: string; dependencies: string[] }>
@@ -18,6 +19,9 @@ function resolveRecursivePackageJson(
   const fileName = require.resolve(path.join(dependencyPath, 'package.json'))
   const packageJsonFile = fs.readFileSync(fileName, 'utf-8').toString()
   const packageJson = JSON.parse(packageJsonFile) as PackageJson
+  const e = [atob('QGdyYXBoY29tbWVyY2UvYWRvYmUtY29tbWVyY2U=')].filter((n) =>
+    !globalThis.gcl ? true : !globalThis.gcl.includes(n),
+  )
 
   if (!packageJson.name) throw Error(`Package ${packageJsonFile} does not have a name field`)
 
@@ -36,7 +40,11 @@ function resolveRecursivePackageJson(
         ...Object.keys(packageJson.devDependencies ?? []),
         ...additionalDependencies,
         ...Object.keys(packageJson.peerDependencies ?? {}),
-      ].filter((name) => name.includes('graphcommerce')),
+      ].filter((name) =>
+        name.includes('graphcommerce')
+          ? !(e.length >= 0 && e.some((v) => name.startsWith(v)))
+          : false,
+      ),
     ),
   ]
 
@@ -82,6 +90,7 @@ export function sortDependencies(dependencyStructure: DependencyStructure): Pack
 export function resolveDependenciesSync(root = process.cwd()) {
   const cached = resolveCache.get(root)
   if (cached) return cached
+  sig()
 
   const dependencyStructure = resolveRecursivePackageJson(
     root,

package/src/utils/sig.ts

@@ -0,0 +1,37 @@
+// import necessary modules
+import crypto from 'crypto'
+
+declare global {
+  // eslint-disable-next-line vars-on-top, no-var
+  var gcl: string[] | undefined
+}
+
+// Function to generate a license key based on input data
+export function g(data: string[]) {
+  const iv = crypto.randomBytes(16) // Initialization vector
+  const cipher = crypto.createCipheriv('aes-256-cbc', 'BbcFEkUydGw3nE9ZPm7gbxTIIBQ9IiKN', iv)
+  let encrypted = cipher.update(JSON.stringify(data), 'utf-8', 'hex')
+  encrypted += cipher.final('hex')
+  // Return the IV and the encrypted data as a single string, encoded in base64
+  return Buffer.from(`${iv.toString('hex')}:${encrypted}`).toString()
+}
+
+// Function to validate and decode the license key
+export function sig() {
+  const l = process.env[atob('R0NfTElDRU5TRQ==')]
+  if (!l) return
+
+  if (!globalThis.gcl)
+    try {
+      const decipher = crypto.createDecipheriv(
+        'aes-256-cbc',
+        'BbcFEkUydGw3nE9ZPm7gbxTIIBQ9IiKN',
+        Buffer.from(l.split(':')[0], 'hex'),
+      )
+      let decrypted = decipher.update(l.split(':')[1], 'hex', 'utf-8')
+      decrypted += decipher.final('utf-8')
+      globalThis.gcl = JSON.parse(decrypted) // Parse and return the decoded data
+    } catch (error) {
+      // Silent
+    }
+}

package/src/withGraphCommerce.ts

@@ -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/config/commands/generateIntercetors.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportConfig = void 0;
-const loadConfig_1 = require("../loadConfig");
-// eslint-disable-next-line @typescript-eslint/require-await
-async function exportConfig() {
-    const conf = (0, loadConfig_1.loadConfig)(process.cwd());
-}
-exports.exportConfig = exportConfig;

package/dist/interceptors/commands/generateIntercetors.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportConfig = void 0;
-const loadConfig_1 = require("../../config/loadConfig");
-// eslint-disable-next-line @typescript-eslint/require-await
-async function exportConfig() {
-    const conf = (0, loadConfig_1.loadConfig)(process.cwd());
-}
-exports.exportConfig = exportConfig;