@friggframework/devtools 2.0.0--canary.549.70ef06a.0 → 2.0.0--canary.545.ccb5010.0

package/frigg-cli/init-command/backend-first-handler.js

@@ -1,7 +1,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
-const { select, confirm, multiselect } = require('@inquirer/prompts');
+const { select, confirm, checkbox } = require('@inquirer/prompts');
 const { execSync } = require('child_process');
 const spawn = require('cross-spawn');
 const npmRegistry = require('../utils/npm-registry');
@@ -35,15 +35,15 @@ class BackendFirstHandler {
         await this.createProject(deploymentMode, config);
 
         console.log(chalk.green('\n✅ Frigg application created successfully!'));
-        
-        // If user needs custom API module, prompt to create it
-        if (config.needsCustomApiModule) {
+
+        // If user needs custom API module, prompt to create it (skip in --yes mode)
+        if (config.needsCustomApiModule && !this.options.yes) {
             console.log(chalk.cyan('\n🔧 Now let\'s create your custom API module...'));
             const createModule = await confirm({
                 message: 'Would you like to create your custom API module now?',
                 default: true
             });
-            
+
             if (createModule) {
                 console.log(chalk.gray('\n   Run this command after setup:'));
                 console.log(chalk.cyan(`   cd ${path.relative(process.cwd(), this.targetPath)}`));
@@ -62,6 +62,11 @@ class BackendFirstHandler {
             return this.options.mode;
         }
 
+        // If --yes flag is set, use default
+        if (this.options.yes) {
+            return 'standalone';
+        }
+
         const mode = await select({
             message: 'How will you deploy this Frigg application?',
             choices: [
@@ -88,6 +93,21 @@ class BackendFirstHandler {
     async getProjectConfiguration(deploymentMode) {
         const config = { deploymentMode };
 
+        // If --yes flag is set, use all defaults
+        if (this.options.yes) {
+            return {
+                deploymentMode,
+                appPurpose: 'exploring',
+                needsCustomApiModule: false,
+                includeIntegrations: false,
+                starterIntegrations: [],
+                includeDemoFrontend: false,
+                serverlessProvider: deploymentMode === 'standalone' ? 'aws' : undefined,
+                installDependencies: true,
+                initializeGit: true,
+            };
+        }
+
         // Ask about the purpose of this Frigg application
         config.appPurpose = await select({
             message: 'What are you building with Frigg?',
@@ -158,7 +178,7 @@ class BackendFirstHandler {
                     }
                 });
 
-                config.starterIntegrations = await multiselect({
+                config.starterIntegrations = await checkbox({
                     message: 'Select API modules to integrate (space to select, enter to confirm):',
                     choices,
                     instructions: '\n  Press <space> to select, <a> to toggle all, <enter> to confirm\n',
@@ -266,63 +286,115 @@ class BackendFirstHandler {
 
     /**
      * Create standalone Frigg service
+     *
+     * Structure:
+     * my-app/
+     * ├── package.json          # Root - delegates to backend with "cd backend &&"
+     * ├── backend/              # Actual Frigg app with its own package.json & node_modules
+     * │   ├── index.js
+     * │   ├── infrastructure.js
+     * │   ├── package.json
+     * │   └── src/
+     * └── ui-extensions/        # Platform-specific UI extensions
+     *     └── README.md
      */
     async createStandaloneProject(config) {
-        // Copy backend template
+        const backendPath = path.join(this.targetPath, 'backend');
+        const uiExtensionsPath = path.join(this.targetPath, 'ui-extensions');
+
+        // Copy backend template to backend/ subdirectory
         const backendTemplate = path.join(this.templatesDir, 'backend');
-        await fs.copy(backendTemplate, this.targetPath);
+        await fs.copy(backendTemplate, backendPath);
 
-        // Create package.json for standalone mode
-        const packageJson = {
-            name: this.appName,
+        // Read template package.json
+        const templatePackageJsonPath = path.join(backendPath, 'package.json');
+        let templatePackageJson = {};
+        if (await fs.pathExists(templatePackageJsonPath)) {
+            templatePackageJson = await fs.readJSON(templatePackageJsonPath);
+        }
+
+        // Create backend package.json with all dependencies
+        const backendPackageJson = {
+            name: `${this.appName}-backend`,
             version: '0.1.0',
             private: true,
+            prettier: templatePackageJson.prettier || '@friggframework/prettier-config',
             scripts: {
+                ...templatePackageJson.scripts,
                 "backend-start": "node infrastructure.js start",
                 "start": "npm run backend-start",
                 "build": "node infrastructure.js package",
                 "deploy": "node infrastructure.js deploy",
-                "test": "jest"
             },
             dependencies: {
-                "@friggframework/core": "^2.0.0"
+                ...templatePackageJson.dependencies,
+                "@friggframework/core": "2.0.0-next.58"
+            },
+            devDependencies: {
+                ...templatePackageJson.devDependencies
             }
         };
 
-        // Add demo frontend if requested
-        if (config.includeDemoFrontend) {
-            packageJson.workspaces = ['backend', 'frontend'];
-            packageJson.scripts['dev'] = 'concurrently "npm run backend-start" "npm run frontend:dev"';
-            packageJson.scripts['frontend:dev'] = 'cd frontend && npm run dev';
-            
-            await this.createDemoFrontend(config);
-        }
-
-        // Add selected integrations as dependencies
+        // Add selected integrations as dependencies to backend
         if (config.starterIntegrations && config.starterIntegrations.length > 0) {
             for (const integration of config.starterIntegrations) {
-                packageJson.dependencies[`@friggframework/api-module-${integration}`] = '^2.0.0';
+                backendPackageJson.dependencies[`@friggframework/api-module-${integration}`] = '^2.0.0';
             }
         }
 
+        await fs.writeJSON(templatePackageJsonPath, backendPackageJson, { spaces: 2 });
+
+        // Create root package.json that delegates to backend
+        const rootPackageJson = {
+            name: this.appName,
+            version: '0.1.0',
+            private: true,
+            scripts: {
+                "start": "cd backend && npm run frigg:start",
+                "docker:start": "cd backend && npm run docker:start",
+                "docker:stop": "cd backend && npm run docker:stop",
+                "test": "cd backend && npm test",
+                "build": "cd backend && npm run build",
+                "deploy": "cd backend && npm run deploy",
+                "lint": "cd backend && npm run lint",
+                "format": "cd backend && npm run format"
+            }
+        };
+
+        // Add demo frontend if requested
+        if (config.includeDemoFrontend) {
+            rootPackageJson.scripts['dev'] = 'concurrently "cd backend && npm run backend-start" "cd frontend && npm run dev"';
+            rootPackageJson.scripts['frontend:dev'] = 'cd frontend && npm run dev';
+            rootPackageJson.devDependencies = { concurrently: '^8.2.2' };
+
+            await this.createDemoFrontend(config);
+        }
+
         await fs.writeJSON(
             path.join(this.targetPath, 'package.json'),
-            packageJson,
+            rootPackageJson,
             { spaces: 2 }
         );
 
+        // Create ui-extensions directory with README
+        await fs.ensureDir(uiExtensionsPath);
+        const uiExtensionsReadme = path.join(this.templatesDir, 'backend', 'ui-extensions', 'README.md');
+        if (await fs.pathExists(uiExtensionsReadme)) {
+            await fs.copy(uiExtensionsReadme, path.join(uiExtensionsPath, 'README.md'));
+        }
+
         // Update index.js with selected integrations
         if (config.starterIntegrations && config.starterIntegrations.length > 0) {
-            await this.updateAppDefinition(config.starterIntegrations);
+            await this.updateAppDefinition(config.starterIntegrations, backendPath);
         }
 
         // Validate generated app definition against schema
-        const appDefPath = path.join(this.targetPath, 'index.js');
+        const appDefPath = path.join(backendPath, 'index.js');
         await this.validateGeneratedAppDefinition(appDefPath);
 
         // Update serverless.yml based on provider
         if (config.serverlessProvider === 'aws') {
-            await this.configureAWSServerless();
+            await this.configureAWSServerless(backendPath);
         }
     }
 
@@ -506,9 +578,9 @@ To integrate Frigg into your production application:
     /**
      * Configure AWS serverless
      */
-    async configureAWSServerless() {
+    async configureAWSServerless(targetDir = this.targetPath) {
         // Update serverless.yml for AWS
-        const serverlessPath = path.join(this.targetPath, 'serverless.yml');
+        const serverlessPath = path.join(targetDir, 'serverless.yml');
         if (await fs.pathExists(serverlessPath)) {
             // Keep existing AWS configuration
             console.log(chalk.gray('AWS Lambda configuration ready'));
@@ -533,23 +605,25 @@ To integrate Frigg into your production application:
     }
 
     /**
-     * Install dependencies
+     * Install dependencies in the backend directory
      */
     async installDependencies(config) {
-        console.log(chalk.blue('\n📦 Installing dependencies...'));
-        
+        console.log(chalk.blue('\n📦 Installing dependencies in backend...'));
+
         const useYarn = this.isUsingYarn();
         const command = useYarn ? 'yarn' : 'npm';
         const args = useYarn ? [] : ['install'];
 
+        // Install in backend directory where package.json with dependencies lives
+        const backendPath = path.join(this.targetPath, 'backend');
         const proc = spawn.sync(command, args, {
-            cwd: this.targetPath,
+            cwd: backendPath,
             stdio: 'inherit'
         });
 
         if (proc.status !== 0) {
             console.log(chalk.yellow('\n⚠️  Dependency installation failed'));
-            console.log(chalk.gray(`You can install manually with: ${command} install`));
+            console.log(chalk.gray(`You can install manually with: cd backend && ${command} install`));
         }
     }
 
@@ -577,7 +651,7 @@ To integrate Frigg into your production application:
      * Select from default integrations when npm is unavailable
      */
     async selectDefaultIntegrations() {
-        return await multiselect({
+        return await checkbox({
             message: 'Select starter integrations (space to select, enter to confirm):',
             choices: [
                 { name: 'Salesforce - CRM integration', value: 'salesforce' },
@@ -596,8 +670,8 @@ To integrate Frigg into your production application:
     /**
      * Update index.js with selected integrations
      */
-    async updateAppDefinition(integrations) {
-        const appDefPath = path.join(this.targetPath, 'index.js');
+    async updateAppDefinition(integrations, targetDir = this.targetPath) {
+        const appDefPath = path.join(targetDir, 'index.js');
         if (await fs.pathExists(appDefPath)) {
             let content = await fs.readFile(appDefPath, 'utf8');
             
@@ -720,14 +794,18 @@ To integrate Frigg into your production application:
         console.log(chalk.cyan(`   cd ${cdPath}\n`));
 
         if (deploymentMode === 'standalone') {
-            console.log(`2. Start the development server:`);
+            console.log(`2. Install backend dependencies:`);
+            console.log(chalk.cyan(`   cd backend && npm install\n`));
+
+            console.log(`3. Start the development server:`);
             console.log(chalk.cyan(`   npm start\n`));
+            console.log(chalk.gray(`   (or from backend: npm run frigg:start)\n`));
 
-            console.log(`3. Open the Frigg UI for development:`);
+            console.log(`4. Open the Frigg UI for development:`);
             console.log(chalk.cyan(`   frigg ui\n`));
 
             if (config.serverlessProvider === 'aws') {
-                console.log(`4. Deploy to AWS Lambda:`);
+                console.log(`5. Deploy to AWS Lambda:`);
                 console.log(chalk.cyan(`   npm run deploy\n`));
             }
         } else {
@@ -747,8 +825,12 @@ To integrate Frigg into your production application:
             console.log(chalk.gray('   See frontend/README.md for integration guidance.'));
         }
 
+        console.log(chalk.gray('\n📁 Project Structure:'));
+        console.log(chalk.gray('   backend/         - Frigg app (run npm install here)'));
+        console.log(chalk.gray('   ui-extensions/   - Platform-specific UI extensions'));
+
         console.log(chalk.green('\n🎉 Happy integrating with Frigg!\n'));
-        console.log(chalk.gray('Documentation: https://docs.frigg.dev'));
+        console.log(chalk.gray('Documentation: https://docs.friggframework.org'));
         console.log(chalk.gray('Support: https://github.com/friggframework/frigg/issues'));
     }
 }

package/frigg-cli/init-command/index.js

@@ -68,7 +68,8 @@ async function initCommand(projectName, options) {
                 force,
                 verbose,
                 mode: options.mode,
-                frontend: options.frontend
+                frontend: options.frontend,
+                yes: options.yes
             });
             
             await handler.initialize();

package/frigg-cli/init-command/template-handler.js

@@ -75,6 +75,16 @@ class TemplateHandler {
                 return !['node_modules', '.serverless', 'dist', 'build'].includes(basename);
             }
         });
+
+        // Rename .env.default to .env if it exists and .env doesn't already exist
+        const envDefaultPath = path.join(target, '.env.default');
+        const envPath = path.join(target, '.env');
+        if (fs.existsSync(envDefaultPath) && !fs.existsSync(envPath)) {
+            await fs.rename(envDefaultPath, envPath);
+        } else if (fs.existsSync(envDefaultPath)) {
+            // Remove the .env.default if .env already exists
+            await fs.remove(envDefaultPath);
+        }
     }
 
     /**
@@ -100,14 +110,14 @@ class TemplateHandler {
     async updateServerlessConfig() {
         const serverlessPath = path.join(this.targetPath, 'serverless.yml');
         let serverlessContent = await fs.readFile(serverlessPath, 'utf8');
-        
+
         // Update service name based on directory name
         const projectName = path.basename(this.targetPath);
         serverlessContent = serverlessContent.replace(
-            /^service: create-frigg-app$/m,
+            /^service: frigg-app$/m,
             `service: ${projectName}`
         );
-        
+
         await fs.writeFile(serverlessPath, serverlessContent);
     }
 

package/frigg-cli/install-command/backend-js.js

@@ -1,12 +1,12 @@
 const fs = require('fs-extra');
 const path = require('path');
-const { logInfo } = require('./logger');
+const output = require('../utils/output');
 const INTEGRATIONS_DIR = 'src/integrations';
 const BACKEND_JS = 'backend.js';
 
 function updateBackendJsFile(backendPath, apiModuleName) {
     const backendJsPath = path.join(path.dirname(backendPath), BACKEND_JS);
-    logInfo(`Updating backend.js: ${backendJsPath}`);
+    output.debug(`Updating backend.js: ${backendJsPath}`);
     updateBackendJs(backendJsPath, apiModuleName);
 }
 
@@ -21,7 +21,7 @@ function updateBackendJs(backendJsPath, apiModuleName) {
         );
         fs.writeFileSync(backendJsPath, importStatement + updatedContent);
     } else {
-        logInfo(
+        output.debug(
             `Import statement for ${apiModuleName}Integration already exists in backend.js`
         );
     }

package/frigg-cli/install-command/environment-variables.js

@@ -1,9 +1,8 @@
 const fs = require('fs');
 const dotenv = require('dotenv');
 const { readFileSync, writeFileSync, existsSync } = require('fs');
-const { logInfo } = require('./logger');
+const output = require('../utils/output');
 const { resolve } = require('node:path');
-const { confirm, input } = require('@inquirer/prompts');
 const { parse } = require('@babel/parser');
 const traverse = require('@babel/traverse').default;
 
@@ -43,15 +42,14 @@ const extractRawEnvVariables = (modulePath) => {
     return envVariables;
 };
 const handleEnvVariables = async (backendPath, modulePath) => {
-    logInfo('Searching for missing environment variables...');
+    output.info('Searching for missing environment variables...');
     const Definition = { env: extractRawEnvVariables(modulePath) };
     if (Definition && Definition.env) {
-        console.log('Here is Definition.env:', Definition.env);
+        output.debug('Definition.env:', JSON.stringify(Definition.env));
         const envVars = Object.values(Definition.env);
 
-        console.log(
-            'Found the following environment variables in the API module:',
-            envVars
+        output.info(
+            `Found environment variables in API module: ${envVars.join(', ')}`
         );
 
         const localEnvPath = resolve(backendPath, '../.env');
@@ -78,23 +76,19 @@ const handleEnvVariables = async (backendPath, modulePath) => {
             (envVar) => !localEnvVars[envVar] && !localDevConfig[envVar]
         );
 
-        logInfo(`Missing environment variables: ${missingEnvVars.join(', ')}`);
-
         if (missingEnvVars.length > 0) {
-            const addEnvVars = await confirm({
-                message: `The following environment variables are required: ${missingEnvVars.join(
+            output.warn(`Missing environment variables: ${missingEnvVars.join(', ')}`);
+
+            const addEnvVars = await output.confirm(
+                `The following environment variables are required: ${missingEnvVars.join(
                     ', '
-                )}. Do you want to add them now?`,
-            });
+                )}. Do you want to add them now?`
+            );
 
             if (addEnvVars) {
                 const envValues = {};
                 for (const envVar of missingEnvVars) {
-                    const value = await input({
-                        type: 'input',
-                        name: 'value',
-                        message: `Enter value for ${envVar}:`,
-                    });
+                    const value = await output.input(`Enter value for ${envVar}:`);
                     envValues[envVar] = value;
                 }
 
@@ -117,9 +111,12 @@ const handleEnvVariables = async (backendPath, modulePath) => {
                         JSON.stringify(updatedDevConfig, null, 2)
                     );
                 }
+                output.success('Environment variables added successfully');
             } else {
-                logInfo("Edit whenever you're able, safe travels friend!");
+                output.info("Edit whenever you're able, safe travels friend!");
             }
+        } else {
+            output.success('All required environment variables are already configured');
         }
     }
 };

package/frigg-cli/install-command/environment-variables.test.js

@@ -1,16 +1,14 @@
 const { handleEnvVariables } = require('./environment-variables');
-const { logInfo } = require('./logger');
-const inquirer = require('inquirer');
+const output = require('../utils/output');
 const fs = require('fs');
 const dotenv = require('dotenv');
 const { resolve } = require('node:path');
 const { parse } = require('@babel/parser');
 const traverse = require('@babel/traverse');
 
-jest.mock('inquirer');
+jest.mock('../utils/output');
 jest.mock('fs');
 jest.mock('dotenv');
-jest.mock('./logger');
 jest.mock('@babel/parser');
 jest.mock('@babel/traverse');
 
@@ -99,22 +97,23 @@ describe('handleEnvVariables', () => {
             return '';
         });
 
-        inquirer.prompt
-            .mockResolvedValueOnce({ addEnvVars: true })
-            .mockResolvedValueOnce({ value: 'client_id_value' })
-            .mockResolvedValueOnce({ value: 'client_secret_value' })
-            .mockResolvedValueOnce({ value: 'redirect_uri_value' })
-            .mockResolvedValueOnce({ value: 'scope_value' });
+        output.confirm.mockResolvedValueOnce(true);
+        output.input
+            .mockResolvedValueOnce('client_id_value')
+            .mockResolvedValueOnce('client_secret_value')
+            .mockResolvedValueOnce('redirect_uri_value')
+            .mockResolvedValueOnce('scope_value');
 
         await handleEnvVariables(backendPath, modulePath);
 
-        expect(logInfo).toHaveBeenCalledWith(
+        expect(output.info).toHaveBeenCalledWith(
             'Searching for missing environment variables...'
         );
-        expect(logInfo).toHaveBeenCalledWith(
+        expect(output.warn).toHaveBeenCalledWith(
             'Missing environment variables: GOOGLE_CALENDAR_CLIENT_ID, GOOGLE_CALENDAR_CLIENT_SECRET, REDIRECT_URI, GOOGLE_CALENDAR_SCOPE'
         );
-        expect(inquirer.prompt).toHaveBeenCalledTimes(5);
+        expect(output.confirm).toHaveBeenCalledTimes(1);
+        expect(output.input).toHaveBeenCalledTimes(4);
         expect(fs.appendFileSync).toHaveBeenCalledWith(
             localEnvPath,
             '\nGOOGLE_CALENDAR_CLIENT_ID=client_id_value\nGOOGLE_CALENDAR_CLIENT_SECRET=client_secret_value\nREDIRECT_URI=redirect_uri_value\nGOOGLE_CALENDAR_SCOPE=scope_value'

package/frigg-cli/install-command/index.js

@@ -2,7 +2,7 @@ const { installPackage } = require('./install-package');
 const { createIntegrationFile } = require('./integration-file');
 const { resolve } = require('node:path');
 const { updateBackendJsFile } = require('./backend-js');
-const { logInfo, logError } = require('./logger');
+const output = require('../utils/output');
 const { commitChanges } = require('./commit-changes');
 const { handleEnvVariables } = require('./environment-variables');
 const {
@@ -35,18 +35,23 @@ const installCommand = async (apiModuleName) => {
             const sanitizedLabel = label.replace(
                 /[<>:"/\\|?*\x00-\x1F\s]/g,
                 ''
-            ); // Remove invalid characters and spaces            console.log('Installing integration for:', sanitizedLabel);
-            createIntegrationFile(backendPath, sanitizedLabel, ApiClass);
-            updateBackendJsFile(backendPath, sanitizedLabel);
-            commitChanges(backendPath, sanitizedLabel);
-            logInfo(
-                `Successfully installed ${packageName} and updated the project.`
-            );
+            ); // Remove invalid characters and spaces
+
+            const spinner = output.spinner(`Installing integration for ${sanitizedLabel}...`);
+            try {
+                createIntegrationFile(backendPath, sanitizedLabel, ApiClass);
+                updateBackendJsFile(backendPath, sanitizedLabel);
+                commitChanges(backendPath, sanitizedLabel);
+                spinner.succeed(`Successfully installed ${packageName} and updated the project.`);
+            } catch (innerError) {
+                spinner.fail(`Failed to install ${packageName}`);
+                throw innerError;
+            }
 
             await handleEnvVariables(backendPath, modulePath);
         }
     } catch (error) {
-        logError('An error occurred:', error);
+        output.error('An error occurred:', error);
         process.exit(1);
     }
 };

package/frigg-cli/install-command/integration-file.js

@@ -1,6 +1,6 @@
 const fs = require('fs-extra');
 const path = require('path');
-const { logInfo } = require('./logger');
+const output = require('../utils/output');
 const { getIntegrationTemplate } = require('./template');
 const INTEGRATIONS_DIR = 'src/integrations';
 
@@ -9,14 +9,14 @@ function createIntegrationFile(backendPath, apiModuleName, ApiClass) {
         path.dirname(backendPath),
         INTEGRATIONS_DIR
     );
-    logInfo(`Ensuring directory exists: ${integrationDir}`);
+    output.debug(`Ensuring directory exists: ${integrationDir}`);
     fs.ensureDirSync(integrationDir);
 
     const integrationFilePath = path.join(
         integrationDir,
         `${apiModuleName}Integration.js`
     );
-    logInfo(`Writing integration file: ${integrationFilePath}`);
+    output.debug(`Writing integration file: ${integrationFilePath}`);
     const integrationTemplate = getIntegrationTemplate(
         apiModuleName,
         backendPath,

package/frigg-cli/install-command/validate-package.js

@@ -1,7 +1,6 @@
 const { execSync } = require('child_process');
 const axios = require('axios');
-const { logError } = require('./logger');
-const { checkbox } = require('@inquirer/prompts');
+const output = require('../utils/output');
 
 async function searchPackages(apiModuleName) {
     const searchCommand = `npm search @friggframework/api-module-${apiModuleName} --json`;
@@ -31,7 +30,7 @@ const searchAndSelectPackage = async (apiModuleName) => {
     const searchResults = await searchPackages(apiModuleName || '');
 
     if (searchResults.length === 0) {
-        logError(`No packages found matching ${apiModuleName}`);
+        output.error(`No packages found matching ${apiModuleName}`);
         process.exit(1);
     }
 
@@ -44,7 +43,7 @@ const searchAndSelectPackage = async (apiModuleName) => {
         const earlierVersions = searchResults
             .map((pkg) => `${pkg.name} (${pkg.version})`)
             .join(', ');
-        logError(
+        output.error(
             `No packages found with version 1.0.0 or above for ${apiModuleName}. Found earlier versions: ${earlierVersions}`
         );
         process.exit(1);
@@ -58,11 +57,8 @@ const searchAndSelectPackage = async (apiModuleName) => {
         };
     });
 
-    const selectedPackages = await checkbox({
-        message: 'Select the packages to install:',
-        choices,
-    });
-    console.log('Selected packages:', selectedPackages);
+    const selectedPackages = await output.checkbox('Select the packages to install:', choices);
+    output.info(`Selected packages: ${selectedPackages.join(', ')}`);
 
     return selectedPackages.map((choice) => choice.split(' ')[0]);
 };

package/frigg-cli/jest.config.js

@@ -1,5 +1,8 @@
+const path = require('path');
+
 module.exports = {
   displayName: 'Frigg CLI Tests',
+  rootDir: __dirname,
   testMatch: [
     '<rootDir>/__tests__/**/*.test.js',
     '<rootDir>/__tests__/**/*.spec.js',
@@ -93,7 +96,7 @@ module.exports = {
     }
   },
   setupFilesAfterEnv: [
-    '<rootDir>/__tests__/utils/test-setup.js'
+    path.join(__dirname, '__tests__', 'utils', 'test-setup.js')
   ],
   testTimeout: 10000,
   maxWorkers: '50%',