@graphcommerce/next-config 9.1.0-canary.55 → 10.0.0-canary.57

package/dist/loadConfig-nJiCKeL1.js

@@ -0,0 +1,311 @@
+import { cosmiconfigSync } from 'cosmiconfig';
+import { GraphCommerceConfigSchema } from './generated/config.js';
+import { cloneDeep, mergeDeep } from '@apollo/client/utilities/index.js';
+import chalk from 'chalk';
+import lodash from 'lodash';
+import { z, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodLazy, ZodObject, ZodArray, ZodNumber, ZodString, ZodEnum, ZodBoolean } from 'zod';
+
+const demoConfig = {
+  canonicalBaseUrl: "https://graphcommerce.vercel.app",
+  hygraphEndpoint: "https://eu-central-1.cdn.hygraph.com/content/ckhx7xadya6xs01yxdujt8i80/master",
+  magentoEndpoint: "https://configurator.reachdigital.dev/graphql",
+  magentoVersion: 247,
+  storefront: [
+    { locale: "en", magentoStoreCode: "en_US", defaultLocale: true },
+    {
+      locale: "nl",
+      magentoStoreCode: "nl_NL",
+      hygraphLocales: ["nl", "en_us"],
+      cartDisplayPricesInclTax: true
+    },
+    {
+      locale: "fr-be",
+      magentoStoreCode: "fr_BE",
+      cartDisplayPricesInclTax: true,
+      linguiLocale: "fr"
+    },
+    {
+      locale: "nl-be",
+      magentoStoreCode: "nl_BE",
+      cartDisplayPricesInclTax: true,
+      linguiLocale: "nl"
+    },
+    {
+      locale: "en-gb",
+      magentoStoreCode: "en_GB",
+      cartDisplayPricesInclTax: true,
+      linguiLocale: "en"
+    },
+    { locale: "en-ca", magentoStoreCode: "en_CA", linguiLocale: "en" }
+  ],
+  productFiltersPro: true,
+  productFiltersLayout: "DEFAULT",
+  productListPaginationVariant: "COMPACT",
+  compareVariant: "ICON",
+  robotsAllow: false,
+  demoMode: true,
+  limitSsg: true,
+  compare: true,
+  sidebarGallery: { paginationVariant: "DOTS" },
+  configurableVariantForSimple: true,
+  configurableVariantValues: { url: true, content: true, gallery: true },
+  recentlyViewedProducts: { enabled: true, maxCount: 20 },
+  breadcrumbs: false,
+  customerDeleteEnabled: true,
+  previewSecret: "SECRET"
+};
+
+function isObject(val) {
+  return typeof val === "object" && val !== null;
+}
+function isArray(val) {
+  return Array.isArray(val);
+}
+function diff(item1, item2) {
+  const item1Type = typeof item2;
+  const item2Type = typeof item2;
+  const isSame = item1Type === item2Type;
+  if (!isSame) return item2;
+  if (isArray(item1) && isArray(item2)) {
+    const res = item1.map((val, idx) => diff(val, item2[idx])).filter((val) => !!val);
+    return res.length ? res : void 0;
+  }
+  if (isObject(item1) && isObject(item2)) {
+    const entriesRight = Object.fromEntries(
+      Object.entries(item1).map(([key, val]) => [key, diff(val, item2[key])]).filter((entry) => !!entry[1])
+    );
+    const entriesLeft = Object.fromEntries(
+      Object.entries(item2).map(([key, val]) => [key, diff(item1[key], val)]).filter((entry) => !!entry[1])
+    );
+    const entries = { ...entriesRight, ...entriesLeft };
+    return Object.keys(entries).length ? entries : void 0;
+  }
+  return item2 === item1 ? void 0 : item2;
+}
+
+const fmt = (s) => s.split(/(\d+)/).map((v) => lodash.snakeCase(v)).join("");
+const toEnvStr = (path) => ["GC", ...path].map(fmt).join("_").toUpperCase();
+const dotNotation = (pathParts) => pathParts.map((v) => {
+  const idx = Number(v);
+  return !Number.isNaN(idx) ? `[${idx}]` : v;
+}).join(".");
+function isJSON(str) {
+  if (!str) return true;
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+function configToEnvSchema(schema) {
+  const envSchema = {};
+  const envToDot = {};
+  function walk(incomming, path = []) {
+    let node = incomming;
+    while (true) {
+      if (node instanceof ZodEffects) {
+        node = node.innerType();
+        continue;
+      }
+      if (node instanceof ZodOptional) {
+        node = node.unwrap();
+        continue;
+      }
+      if (node instanceof ZodNullable) {
+        node = node.unwrap();
+        continue;
+      }
+      if (node instanceof ZodDefault) {
+        node = node.removeDefault();
+        continue;
+      }
+      if (node instanceof ZodLazy) {
+        node = node.schema;
+        continue;
+      }
+      break;
+    }
+    if (node instanceof ZodObject) {
+      if (path.length > 0) {
+        envSchema[toEnvStr(path)] = z.string().optional().refine(isJSON, { message: "Invalid JSON" }).transform((val) => val ? JSON.parse(val) : val);
+        envToDot[toEnvStr(path)] = dotNotation(path);
+      }
+      const typeNode = node;
+      Object.keys(typeNode.shape).forEach((key) => {
+        walk(typeNode.shape[key], [...path, key]);
+      });
+      return;
+    }
+    if (node instanceof ZodArray) {
+      const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+      if (path.length > 0) {
+        envSchema[toEnvStr(path)] = z.string().optional().refine(isJSON, { message: "Invalid JSON" }).transform((val) => val ? JSON.parse(val) : val);
+        envToDot[toEnvStr(path)] = dotNotation(path);
+      }
+      arr.forEach((key) => {
+        walk(node.element, [...path, String(key)]);
+      });
+      return;
+    }
+    if (node instanceof ZodNumber) {
+      envSchema[toEnvStr(path)] = z.coerce.number().optional();
+      envToDot[toEnvStr(path)] = dotNotation(path);
+      return;
+    }
+    if (node instanceof ZodString || node instanceof ZodEnum) {
+      envSchema[toEnvStr(path)] = node.optional();
+      envToDot[toEnvStr(path)] = dotNotation(path);
+      return;
+    }
+    if (node instanceof ZodBoolean) {
+      envSchema[toEnvStr(path)] = z.enum(["true", "1", "false", "0"]).optional().transform((v) => {
+        if (v === "true" || v === "1") return true;
+        if (v === "false" || v === "0") return false;
+        return v;
+      });
+      envToDot[toEnvStr(path)] = dotNotation(path);
+      return;
+    }
+    throw Error(
+      `[@graphcommerce/next-config] Unknown type in schema ${node.constructor.name}. This is probably a bug please create an issue.`
+    );
+  }
+  walk(schema);
+  return [z.object(envSchema), envToDot];
+}
+const filterEnv = (env) => Object.fromEntries(Object.entries(env).filter(([key]) => key.startsWith("GC_")));
+function mergeEnvIntoConfig(schema, config, env) {
+  const filteredEnv = filterEnv(env);
+  const newConfig = cloneDeep(config);
+  const [envSchema, envToDot] = configToEnvSchema(schema);
+  const result = envSchema.safeParse(filteredEnv);
+  const applyResult = [];
+  if (!result.success) {
+    Object.entries(result.error.flatten().fieldErrors).forEach(([envVar, error]) => {
+      const dotVar = envToDot[envVar];
+      const envValue = filteredEnv[envVar];
+      applyResult.push({ envVar, envValue, dotVar, error });
+    });
+    return [void 0, applyResult];
+  }
+  Object.entries(result.data).forEach(([envVar, value]) => {
+    const dotVar = envToDot[envVar];
+    const envValue = filteredEnv[envVar];
+    if (!dotVar) {
+      applyResult.push({ envVar, envValue });
+      return;
+    }
+    const dotValue = lodash.get(newConfig, dotVar);
+    const merged = mergeDeep(dotValue, value);
+    const from = diff(merged, dotValue);
+    const to = diff(dotValue, merged);
+    applyResult.push({ envVar, envValue, dotVar, from, to });
+    lodash.set(newConfig, dotVar, merged);
+  });
+  return [newConfig, applyResult];
+}
+function formatAppliedEnv(applyResult) {
+  let hasError = false;
+  let hasWarning = false;
+  const lines = applyResult.map(({ from, to, envVar, dotVar, error, warning }) => {
+    const envVariableFmt = `${envVar}`;
+    const dotVariableFmt = chalk.bold.underline(`${dotVar}`);
+    const baseLog = `${envVariableFmt} => ${dotVariableFmt}`;
+    if (error) {
+      hasError = true;
+      return `${chalk.red(` \u2A09 ${envVariableFmt}`)} => ${error.join(", ")}`;
+    }
+    if (warning) {
+      hasWarning = true;
+      return `${chalk.yellowBright(` \u203C ${envVariableFmt}`)} => ${warning.join(", ")}`;
+    }
+    if (!dotVar) return chalk.red(`${envVariableFmt} => ignored (no matching config)`);
+    if (from === void 0 && to === void 0) return ` = ${baseLog}`;
+    if (from === void 0 && to !== void 0) return ` ${chalk.green("+")} ${baseLog}`;
+    if (from !== void 0 && to === void 0) return ` ${chalk.red("-")} ${baseLog}`;
+    return ` ${chalk.yellowBright("~")} ${baseLog}`;
+  });
+  let header = chalk.blueBright("info");
+  if (hasWarning) header = chalk.yellowBright("warning");
+  if (hasError) header = chalk.yellowBright("error");
+  header += "   - Loaded GraphCommerce env variables";
+  return [header, ...lines].join("\n");
+}
+
+function flattenKeys(value, initialPathPrefix, stringify) {
+  if (value === null || value === void 0 || typeof value === "number") {
+    return { [initialPathPrefix]: value };
+  }
+  if (typeof value === "string") {
+    return { [initialPathPrefix]: stringify ? JSON.stringify(value) : value };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {
+      [initialPathPrefix]: stringify || Array.isArray(value) ? JSON.stringify(value) : value
+    };
+  }
+  if (typeof value === "object") {
+    let outputValue = value;
+    if (stringify)
+      outputValue = process.env.NODE_ENV !== "production" ? `{ __debug: "'${initialPathPrefix}' can not be destructured, please access deeper properties directly" }` : "{}";
+    return {
+      [initialPathPrefix]: outputValue,
+      ...Object.keys(value).map((key) => {
+        const deep = value[key];
+        return {
+          ...flattenKeys(deep, `${initialPathPrefix}.${key}`, stringify),
+          ...flattenKeys(deep, `${initialPathPrefix}?.${key}`, stringify)
+        };
+      }).reduce((acc, path) => ({ ...acc, ...path }), {})
+    };
+  }
+  throw Error(`Unexpected value: ${value}`);
+}
+function configToImportMeta(config, path = "import.meta.graphCommerce", stringify = true) {
+  return flattenKeys(config, path, stringify);
+}
+
+function replaceConfigInString(str, config) {
+  let result = str;
+  const replacers = configToImportMeta(config, "graphCommerce", false);
+  Object.entries(replacers).forEach(([from, to]) => {
+    result = result.replace(new RegExp(`{${from}}`, "g"), to);
+  });
+  return result;
+}
+
+const moduleName = "graphcommerce";
+const loader = cosmiconfigSync(moduleName);
+function loadConfig(cwd) {
+  const isMainProcess = !process.send;
+  try {
+    const result = loader.search(cwd);
+    let confFile = result?.config;
+    if (!confFile) {
+      if (isMainProcess)
+        console.warn("No graphcommerce.config.js found in the project, using demo config");
+      confFile = demoConfig;
+    }
+    confFile ||= {};
+    const schema = GraphCommerceConfigSchema();
+    const [mergedConfig, applyResult] = mergeEnvIntoConfig(schema, confFile, process.env);
+    if (applyResult.length > 0 && isMainProcess) console.log(formatAppliedEnv(applyResult));
+    const finalParse = schema.parse(mergedConfig);
+    if (process.env.DEBUG && isMainProcess) {
+      console.log("Parsed configuration");
+      console.log(finalParse);
+    }
+    return finalParse;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (isMainProcess) {
+        console.log("Error while parsing graphcommerce.config.js", error.message);
+        process.exit(1);
+      }
+    }
+    throw error;
+  }
+}
+
+export { loadConfig as l, replaceConfigInString as r, toEnvStr as t };

package/dist/utils/findParentPath.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import path from 'path';
+
+const debug = process.env.DEBUG === "1";
+const log = (message) => debug && console.log(`isMonorepo: ${message}`);
+function findPackageJson(directory) {
+  try {
+    const packageJsonPath = path.join(directory, "package.json");
+    const content = fs.readFileSync(packageJsonPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function findParentPath(directory) {
+  let currentDir = directory;
+  log(`Starting directory: ${currentDir}`);
+  currentDir = path.dirname(currentDir);
+  log(`Looking for parent packages starting from: ${currentDir}`);
+  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;
+}
+
+export { findParentPath };

package/package.json

@@ -2,15 +2,39 @@
   "name": "@graphcommerce/next-config",
   "homepage": "https://www.graphcommerce.org/",
   "repository": "github:graphcommerce-org/graphcommerce",
-  "version": "9.1.0-canary.55",
+  "version": "10.0.0-canary.57",
   "type": "module",
   "types": "./src/index.ts",
   "exports": {
     ".": {
+      "types": "./src/index.ts",
       "default": "./dist/index.js"
     },
-    "./config": {
+    "./schema": {
+      "types": "./src/generated/config.ts",
       "default": "./dist/generated/config.js"
+    },
+    "./config": {
+      "types": "./src/generated/configValues/index.ts",
+      "default": "./dist/generated/configValues/index.js"
+    },
+    "./loadConfig": {
+      "types": "./src/config/loadConfig.ts",
+      "default": "./dist/config/loadConfig.js"
+    },
+    "./findParentPath": {
+      "types": "./src/utils/findParentPath.ts",
+      "default": "./dist/utils/findParentPath.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "schema": [
+        "src/generated/config.ts"
+      ],
+      "config": [
+        "src/generated/configValues/index.ts"
+      ]
     }
   },
   "scripts": {
@@ -19,31 +43,28 @@
     "prepack": "pkgroll --clean-dist"
   },
   "dependencies": {
-    "@graphql-codegen/cli": "5.0.5",
-    "@swc/core": "1.10.1",
-    "@swc/wasm-web": "^1.10.1",
-    "@types/circular-dependency-plugin": "^5.0.8",
-    "@types/js-yaml": "^4",
-    "@types/lodash": "^4.17.13",
-    "babel-plugin-macros": "^3.1.0",
-    "chalk": "^4",
-    "circular-dependency-plugin": "^5.2.2",
+    "@graphql-codegen/cli": "6.1.0",
+    "@swc/core": "1.15.3",
+    "@swc/wasm-web": "^1.15.3",
+    "@types/js-yaml": "^4.0.9",
+    "@types/lodash": "^4.17.21",
+    "chalk": "^4.1.2",
     "cosmiconfig": "^8.3.6",
-    "fast-glob": "^3.3.2",
+    "fast-glob": "^3.3.3",
     "glob": "^10.4.5",
-    "graphql": "^16.10.0",
+    "graphql": "^16.12.0",
     "inspectpack": "^4.7.1",
-    "js-yaml": "^4.1.0",
+    "js-yaml": "^4.1.1",
     "js-yaml-loader": "^1.2.2",
     "lodash": "^4.17.21",
-    "react": "^18.3.1",
-    "typescript": "5.7.2",
-    "webpack": "^5.97.1",
+    "react": "^19.2.0",
+    "typescript": "5.9.3",
     "znv": "^0.4.0",
-    "zod": "^3.24.1"
+    "zod": "^3.25.76"
   },
   "peerDependencies": {
-    "@graphcommerce/prettier-config-pwa": "^9.1.0-canary.55",
+    "@apollo/client": "*",
+    "@graphcommerce/prettier-config-pwa": "^10.0.0-canary.57",
     "@lingui/loader": "*",
     "@lingui/macro": "*",
     "@lingui/react": "*",
@@ -62,6 +83,6 @@
     }
   },
   "devDependencies": {
-    "pkgroll": "^2.5.1"
+    "pkgroll": "^2.21.4"
   }
 }

package/src/commands/cleanupInterceptors.ts

@@ -0,0 +1,26 @@
+import dotenv from 'dotenv'
+import { findDotOriginalFiles, restoreOriginalFile } from '../interceptors/writeInterceptors'
+
+dotenv.config({ quiet: true })
+
+export async function cleanupInterceptors(cwd: string = process.cwd()) {
+  console.info('🧹 Starting interceptor cleanup...')
+
+  let restoredCount = 0
+  let removedCount = 0
+
+  const originalFiles = await findDotOriginalFiles(cwd)
+  console.info(`📂 Found ${originalFiles.length} .original files to restore`)
+
+  for (const originalFile of originalFiles) {
+    try {
+      await restoreOriginalFile(originalFile)
+      removedCount++
+    } catch (error) {
+      console.error(`❌ Failed to restore ${originalFile}:`, error)
+    }
+  }
+
+  console.info('✅ Interceptor cleanup completed!')
+  console.info(`📊 ${restoredCount} files restored from .original`)
+}

package/src/commands/codegen.ts

@@ -1,18 +1,16 @@
-import { generateConfig } from '../config/commands/generateConfig'
-import { codegenInterceptors } from '../interceptors/commands/codegenInterceptors'
-import { copyFiles } from './copyFiles'
+import { spawn } from 'child_process'
 
-/** Run all code generation steps in sequence */
-export async function codegen() {
-  // Copy files from packages to project
-  console.info('🔄 Copying files from packages to project...')
-  await copyFiles()
-
-  // Generate GraphCommerce config types
-  console.info('⚙️  Generating GraphCommerce config types...')
-  await generateConfig()
+function run(cmd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, { stdio: 'inherit', cwd: process.cwd(), shell: true })
+    child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} failed`))))
+  })
+}
 
-  // Generate interceptors
-  console.info('🔌 Generating interceptors...')
-  await codegenInterceptors()
+/** Run all code generation steps in sequence using separate processes */
+export async function codegen() {
+  await run('graphcommerce copy-files')
+  await run('graphcommerce codegen-config')
+  await run('graphcommerce codegen-config-values')
+  await run('graphcommerce codegen-interceptors')
 }

package/src/commands/codegenInterceptors.ts

@@ -0,0 +1,31 @@
+import dotenv from 'dotenv'
+import { loadConfig } from '../config/loadConfig'
+import { findPlugins } from '../interceptors/findPlugins'
+import { generateInterceptors } from '../interceptors/generateInterceptors'
+import { updatePackageExports } from '../interceptors/updatePackageExports'
+import { writeInterceptors } from '../interceptors/writeInterceptors'
+import { resolveDependency } from '../utils/resolveDependency'
+
+dotenv.config({ quiet: true })
+
+// eslint-disable-next-line @typescript-eslint/require-await
+export async function codegenInterceptors() {
+  const conf = loadConfig(process.cwd())
+
+  const [plugins] = findPlugins(conf)
+
+  // Update package.json exports before generating interceptors
+  console.info('🔄 Updating package.json exports for plugins...')
+  await updatePackageExports(plugins)
+
+  const generatedInterceptors = await generateInterceptors(
+    plugins,
+    resolveDependency(),
+    conf.debug,
+    true,
+  )
+
+  await writeInterceptors(generatedInterceptors)
+
+  console.info('✅ Generated interceptors and moved original files')
+}

package/src/{config/commands → commands}/exportConfig.ts

@@ -1,8 +1,8 @@
 import dotenv from 'dotenv'
-import { loadConfig } from '../loadConfig'
-import { exportConfigToEnv } from '../utils/exportConfigToEnv'
+import { loadConfig } from '../config/loadConfig'
+import { exportConfigToEnv } from '../config/utils/exportConfigToEnv'
 
-dotenv.config()
+dotenv.config({ quiet: true })
 
 // eslint-disable-next-line @typescript-eslint/require-await
 export async function exportConfig() {

package/src/{config/commands → commands}/generateConfig.ts

@@ -4,17 +4,14 @@ import { generate } from '@graphql-codegen/cli'
 import { transformFileSync } from '@swc/core'
 import dotenv from 'dotenv'
 import prettier from 'prettier'
-import { findParentPath } from '../../utils/isMonorepo'
-import { resolveDependenciesSync } from '../../utils/resolveDependenciesSync'
-import { resolveDependency } from '../../utils/resolveDependency'
-
-dotenv.config()
+import { findParentPath } from '../utils/findParentPath'
+import { resolveDependenciesSync } from '../utils/resolveDependenciesSync'
+import { resolveDependency } from '../utils/resolveDependency'
 
 const packages = [...resolveDependenciesSync().values()].filter((p) => p !== '.')
-
 const resolve = resolveDependency()
 
-const schemaLocations = packages.map((p) => `${p}/**/Config.graphqls`)
+dotenv.config({ quiet: true })
 
 export async function generateConfig() {
   const resolved = resolve('@graphcommerce/next-config')
@@ -23,9 +20,15 @@ export async function generateConfig() {
   const targetTs = `${resolved.root}/src/generated/config.ts`
   const targetJs = `${resolved.root}/dist/generated/config.js`
 
+  // Use specific patterns instead of ** to avoid expensive directory traversal
+  const schemaLocations = [
+    'graphql/Config.graphqls',
+    ...packages.flatMap((p) => [`${p}/Config.graphqls`, `${p}/graphql/Config.graphqls`]),
+  ]
+
   await generate({
     silent: true,
-    schema: ['graphql/**/Config.graphqls', ...schemaLocations],
+    schema: schemaLocations,
     generates: {
       [targetTs]: {
         plugins: ['typescript', 'typescript-validation-schema'],
@@ -63,7 +66,7 @@ export async function generateConfig() {
 
   const result = transformFileSync(targetTs, {
     module: { type: 'nodenext' },
-    env: { targets: { node: '18' } },
+    env: { targets: { node: '20' } },
   })
 
   writeFileSync(targetJs, result.code)