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

package/dist/commands/copyFiles.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyFiles = copyFiles;
+/* eslint-disable no-await-in-loop */
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const resolveDependenciesSync_1 = require("../utils/resolveDependenciesSync");
+// Add debug logging helper
+const debug = (...args) => {
+    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) {
+    const gitignorePath = path_1.default.join(process.cwd(), '.gitignore');
+    let content;
+    try {
+        content = await promises_1.default.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 promises_1.default.writeFile(gitignorePath, content);
+}
+/** Determines how a file should be managed based on its content */
+function getFileManagement(content) {
+    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
+ */
+async function copyFiles() {
+    const startTime = performance.now();
+    debug('Starting copyFiles');
+    const cwd = process.cwd();
+    const deps = (0, resolveDependenciesSync_1.resolveDependenciesSync)();
+    const packages = [...deps.values()].filter((p) => p !== '.');
+    // Track files and their source packages to detect conflicts
+    const fileMap = new Map();
+    const managedFiles = new Set();
+    const existingManagedFiles = new Set();
+    // 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 (0, fast_glob_1.default)('**/*', {
+            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_1.default.join(cwd, file);
+            try {
+                const content = await promises_1.default.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_1.default.join(pkg, 'copy');
+        try {
+            const files = await (0, fast_glob_1.default)('**/*', { cwd: copyDir, dot: true, suppressErrors: true });
+            if (files.length > 0) {
+                debug(`Found files in ${pkg}:`, files);
+                for (const file of files) {
+                    const sourcePath = path_1.default.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.code === 'ENOENT')
+                return;
+            console.error(`Error scanning directory ${copyDir}: ${err.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_1.default.join(cwd, file);
+        debug(`Processing file: ${file}`);
+        try {
+            await promises_1.default.mkdir(path_1.default.dirname(targetPath), { recursive: true });
+            const sourceContent = await promises_1.default.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;
+            try {
+                targetContent = await promises_1.default.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.code !== 'ENOENT') {
+                    console.error(`Error reading file ${file}: ${err.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 promises_1.default.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.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) {
+        let currentDir = startPath;
+        while (currentDir !== cwd) {
+            try {
+                const dirContents = await promises_1.default.readdir(currentDir);
+                if (dirContents.length === 0) {
+                    await promises_1.default.rmdir(currentDir);
+                    debug(`Removed empty directory: ${currentDir}`);
+                    currentDir = path_1.default.dirname(currentDir);
+                }
+                else {
+                    break; // Stop if directory is not empty
+                }
+            }
+            catch (err) {
+                if (err.code === 'EACCES') {
+                    console.error(`Error cleaning up directory ${currentDir}: ${err.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_1.default.join(cwd, file);
+        const dirPath = path_1.default.dirname(filePath);
+        try {
+            // First check if the directory exists and is accessible
+            await promises_1.default.readdir(dirPath);
+            // Then try to remove the file
+            try {
+                await promises_1.default.unlink(filePath);
+                console.log(`Removed managed file: ${file}`);
+                debug(`Removed file: ${file}`);
+            }
+            catch (err) {
+                if (err.code !== 'ENOENT') {
+                    console.error(`Error removing file ${file}: ${err.message}`);
+                    process.exit(1);
+                }
+            }
+            // Finally, try to clean up empty directories
+            await cleanupEmptyDirs(dirPath);
+        }
+        catch (err) {
+            if (err.code === 'EACCES') {
+                console.error(`Error accessing directory ${dirPath}: ${err.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/dist/commands/copyRoutes.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("fs/promises"));
+// ... earlier code remains the same ...
+try {
+    targetContent = await promises_1.default.readFile(targetPath);
+}
+catch (err) {
+    if (err.code !== 'ENOENT')
+        throw err;
+    // File doesn't exist, log that we're creating it
+    console.log(`Creating new file: ${file}`);
+}
+// Skip if content is identical
+if (targetContent && Buffer.compare(sourceContent, targetContent) === 0)
+    return;
+// ... rest of the code remains the same ...

package/dist/config/utils/mergeEnvIntoConfig.js

@@ -155,7 +155,7 @@ function formatAppliedEnv(applyResult) {
     const lines = applyResult.map(({ from, to, envValue, envVar, dotVar, error, warning }) => {
         const fromFmt = chalk_1.default.red(JSON.stringify(from));
         const toFmt = chalk_1.default.green(JSON.stringify(to));
-        const envVariableFmt = `${envVar}='${envValue}'`;
+        const envVariableFmt = `${envVar}`;
         const dotVariableFmt = chalk_1.default.bold.underline(`${dotVar}`);
         const baseLog = `${envVariableFmt} => ${dotVariableFmt}`;
         if (error) {
@@ -169,12 +169,12 @@ function formatAppliedEnv(applyResult) {
         if (!dotVar)
             return chalk_1.default.red(`${envVariableFmt} => ignored (no matching config)`);
         if (from === undefined && to === undefined)
-            return ` = ${baseLog}: (ignored, no change/wrong format)`;
+            return ` = ${baseLog}: (ignored)`;
         if (from === undefined && to !== undefined)
-            return ` ${chalk_1.default.green('+')} ${baseLog}: ${toFmt}`;
+            return ` ${chalk_1.default.green('+')} ${baseLog}`;
         if (from !== undefined && to === undefined)
-            return ` ${chalk_1.default.red('-')} ${baseLog}: ${fromFmt}`;
-        return ` ${chalk_1.default.yellowBright('~')} ${baseLog}: ${fromFmt} => ${toFmt}`;
+            return ` ${chalk_1.default.red('-')} ${baseLog}`;
+        return ` ${chalk_1.default.yellowBright('~')} ${baseLog}`;
     });
     let header = chalk_1.default.blueBright('info');
     if (hasWarning)

package/dist/generated/config.js

@@ -4,6 +4,7 @@ exports.WebsitePermissionsSchema = exports.SidebarGalleryPaginationVariantSchema
 exports.DatalayerConfigSchema = DatalayerConfigSchema;
 exports.GraphCommerceConfigSchema = GraphCommerceConfigSchema;
 exports.GraphCommerceDebugConfigSchema = GraphCommerceDebugConfigSchema;
+exports.GraphCommerceGooglePlaystoreConfigSchema = GraphCommerceGooglePlaystoreConfigSchema;
 exports.GraphCommercePermissionsSchema = GraphCommercePermissionsSchema;
 exports.GraphCommerceStorefrontConfigSchema = GraphCommerceStorefrontConfigSchema;
 exports.MagentoConfigurableVariantValuesSchema = MagentoConfigurableVariantValuesSchema;
@@ -46,6 +47,7 @@ function GraphCommerceConfigSchema() {
         demoMode: zod_1.z.boolean().default(true).nullish(),
         enableGuestCheckoutLogin: zod_1.z.boolean().nullish(),
         googleAnalyticsId: zod_1.z.string().nullish(),
+        googlePlaystore: GraphCommerceGooglePlaystoreConfigSchema().nullish(),
         googleRecaptchaKey: zod_1.z.string().nullish(),
         googleTagmanagerId: zod_1.z.string().nullish(),
         hygraphEndpoint: zod_1.z.string().min(1),
@@ -77,6 +79,12 @@ function GraphCommerceDebugConfigSchema() {
         webpackDuplicatesPlugin: zod_1.z.boolean().nullish()
     });
 }
+function GraphCommerceGooglePlaystoreConfigSchema() {
+    return zod_1.z.object({
+        packageName: zod_1.z.string().min(1),
+        sha256CertificateFingerprint: zod_1.z.string().min(1)
+    });
+}
 function GraphCommercePermissionsSchema() {
     return zod_1.z.object({
         cart: exports.CartPermissionsSchema.nullish(),

package/dist/index.js

@@ -17,8 +17,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils/isMonorepo"), exports);
 __exportStar(require("./utils/resolveDependenciesSync"), exports);
 __exportStar(require("./utils/packageRoots"), exports);
+__exportStar(require("./utils/sig"), exports);
 __exportStar(require("./withGraphCommerce"), exports);
 __exportStar(require("./generated/config"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./runtimeCachingOptimizations"), exports);
 __exportStar(require("./interceptors/commands/codegenInterceptors"), exports);
+__exportStar(require("./commands/copyFiles"), exports);
+__exportStar(require("./commands/codegen"), exports);

package/dist/interceptors/generateInterceptor.js

@@ -41,8 +41,8 @@ function isReplacePluginConfig(plugin) {
 function isPluginConfig(plugin) {
     return isPluginBaseConfig(plugin);
 }
-exports.SOURCE_START = '/** Original source starts here (do not modify!): **/';
-exports.SOURCE_END = '/** Original source ends here (do not modify!) **/';
+exports.SOURCE_START = '/** SOURCE_START */';
+exports.SOURCE_END = '/** SOURCE_END */';
 const originalSuffix = 'Original';
 const interceptorSuffix = 'Interceptor';
 const disabledSuffix = 'Disabled';
@@ -68,9 +68,7 @@ const generateIdentifyer = (s) => Math.abs(s.split('').reduce((a, b) => {
     // eslint-disable-next-line no-bitwise
     return a & a;
 }, 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) {
     if (!source)
         return null;

package/dist/utils/resolveDependenciesSync.js

@@ -8,12 +8,14 @@ exports.resolveDependenciesSync = resolveDependenciesSync;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const PackagesSort_1 = require("./PackagesSort");
+const sig_1 = require("./sig");
 const resolveCache = new Map();
 function resolveRecursivePackageJson(dependencyPath, dependencyStructure, root, additionalDependencies = []) {
     const isRoot = dependencyPath === root;
     const fileName = require.resolve(node_path_1.default.join(dependencyPath, 'package.json'));
     const packageJsonFile = node_fs_1.default.readFileSync(fileName, 'utf-8').toString();
     const packageJson = JSON.parse(packageJsonFile);
+    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`);
     // Previously processed
@@ -29,7 +31,9 @@ function resolveRecursivePackageJson(dependencyPath, dependencyStructure, root,
             ...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)),
     ];
     const name = isRoot ? '.' : packageJson.name;
     dependencyStructure[name] = {
@@ -66,6 +70,7 @@ function resolveDependenciesSync(root = process.cwd()) {
     const cached = resolveCache.get(root);
     if (cached)
         return cached;
+    (0, sig_1.sig)();
     const dependencyStructure = resolveRecursivePackageJson(root, {}, root, process.env.PRIVATE_ADDITIONAL_DEPENDENCIES?.split(',') ?? []);
     const sorted = sortDependencies(dependencyStructure);
     resolveCache.set(root, sorted);

package/dist/utils/sig.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.g = g;
+exports.sig = sig;
+// import necessary modules
+const crypto_1 = __importDefault(require("crypto"));
+// Function to generate a license key based on input data
+function g(data) {
+    const iv = crypto_1.default.randomBytes(16); // Initialization vector
+    const cipher = crypto_1.default.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
+function sig() {
+    const l = process.env[atob('R0NfTElDRU5TRQ==')];
+    if (!l)
+        return;
+    if (!globalThis.gcl)
+        try {
+            const decipher = crypto_1.default.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/dist/withGraphCommerce.js

@@ -41,10 +41,10 @@ function withGraphCommerce(nextConfig, cwd) {
     ];
     return {
         ...nextConfig,
+        bundlePagesRouterDependencies: true,
         experimental: {
             ...nextConfig.experimental,
             scrollRestoration: true,
-            bundlePagesExternals: true,
             swcPlugins: [...(nextConfig.experimental?.swcPlugins ?? []), ['@lingui/swc-plugin', {}]],
         },
         i18n: {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@graphcommerce/next-config",
   "homepage": "https://www.graphcommerce.org/",
   "repository": "github:graphcommerce-org/graphcommerce",
-  "version": "9.0.0-canary.105",
+  "version": "9.0.0-canary.107",
   "type": "commonjs",
   "main": "dist/index.js",
   "types": "src/index.ts",
@@ -13,23 +13,24 @@
   },
   "dependencies": {
     "@graphql-mesh/cli": "latest",
-    "@lingui/loader": "4.11.4",
-    "@lingui/macro": "4.11.4",
-    "@lingui/react": "4.11.4",
-    "@lingui/swc-plugin": "4.0.8",
-    "@swc/core": "1.7.26",
-    "@swc/wasm-web": "^1.7.28",
+    "@lingui/loader": "4.14.0",
+    "@lingui/macro": "4.14.0",
+    "@lingui/react": "4.14.0",
+    "@lingui/swc-plugin": "4.1.0",
+    "@swc/core": "1.9.3",
+    "@swc/wasm-web": "^1.9.3",
     "@types/circular-dependency-plugin": "^5.0.8",
-    "@types/lodash": "^4.17.10",
+    "@types/lodash": "^4.17.13",
     "babel-plugin-macros": "^3.1.0",
     "circular-dependency-plugin": "^5.2.2",
+    "fast-glob": "^3.3.2",
     "glob": "^10.4.5",
     "graphql": "^16",
     "inspectpack": "^4.7.1",
     "js-yaml-loader": "^1.2.2",
     "lodash": "^4.17.21",
     "react": "^18.3.1",
-    "typescript": "5.6.2",
+    "typescript": "5.7.2",
     "webpack": "^5.96.1",
     "znv": "^0.4.0",
     "zod": "^3.23.8"

package/src/commands/codegen.ts

@@ -0,0 +1,18 @@
+import { generateConfig } from '../config/commands/generateConfig'
+import { codegenInterceptors } from '../interceptors/commands/codegenInterceptors'
+import { copyFiles } from './copyFiles'
+
+/** Run all code generation steps in sequence */
+export async function codegen() {
+  // Copy files from packages to project
+  console.log('🔄 Copying files from packages to project...')
+  await copyFiles()
+
+  // Generate GraphCommerce config types
+  console.log('⚙️  Generating GraphCommerce config types...')
+  await generateConfig()
+
+  // Generate interceptors
+  console.log('🔌 Generating interceptors...')
+  await codegenInterceptors()
+}