feat: added addEnvironment to ConfigBuilder

packages/create-gasket-app/lib/index.d.ts

@@ -136,6 +136,25 @@ export interface ConfigBuilder<Config> {
    */
   addPlugin(pluginImport: string, pluginName: string): void;
 
+  /**
+   * addEnvironment - Add environments to the gasket file and use the value in the plugins array
+   * @param {string} key - name of the environment - `local.analyze`
+   * @param {object} value - configuration for the environment - `{
+   *   dynamicPlugins: [
+   *     '@gasket/plugin-analyze',
+   *   ]
+   * }`
+   * @example
+   *   environments: {
+   *    'local.analyze': {
+   *      dynamicPlugins: [
+   *        '@gasket/plugin-analyze',
+   *      ]
+   *     }
+   *   },
+   */
+  addEnvironment(key:string, value: object): void;
+
   /**
    * addImport - Add a non-plugin import to the gasket file
    * @param {string} importName - name of the import used as a value - `import fs...`

packages/create-gasket-app/lib/scaffold/config-builder.js

@@ -238,6 +238,37 @@ export class ConfigBuilder {
     this.add('pluginImports', { [pluginImport]: pluginName });
   }
 
+  /**
+   * addEnvironment - Add environments to the gasket file
+   * @param {string} key - name of the environment - `local.analyze`
+   * @param {object} value - configuration for the environment - `{
+   *   dynamicPlugins: [
+   *     '@gasket/plugin-analyze',
+   *   ]
+   * }`
+   * @example
+   *   environments: {
+   *    'local.analyze': {
+   *      dynamicPlugins: [
+   *        '@gasket/plugin-analyze',
+   *      ]
+   *     }
+   *   },
+   */
+  addEnvironment(key, value) {
+    this.add('environments', {
+      [key]: value
+    });
+  }
+
+  /**
+   * addDynamicPlugin - Add plugin to the the dynamicPlugins array
+   * @param {string} pluginName - Name of the plugin to add to the dynamicPlugins array - `@gasket/plugin-example`
+   */
+  addDynamicPlugin(pluginName) {
+    this.add('dynamicPlugins', [`${pluginName}`]);
+  }
+
   /**
    * addImport - Add a non-plugin import to the gasket file
    * @param {string} importName - name of the import used as a value - `import fs...`

packages/create-gasket-app/lib/scaffold/create-context.js

@@ -90,7 +90,7 @@ export function makeCreateContext(argv = [], options = {}) {
   /**
    * Input context which will be appended by prompts and passed to create hooks
    * @type {import('../internal').PartialCreateContext}
-  */
+   */
   const context = new CreateContext({
     destOverride: true,
     cwd,

packages/create-gasket-app/test/unit/scaffold/config-builder.test.js

@@ -511,4 +511,46 @@ describe('ConfigBuilder', () => {
       expect(warnings).toHaveLength(1);
     });
   });
+
+  describe('gasketConfig', () => {
+    let gasketConfig;
+    beforeEach(() => {
+      gasketConfig = new ConfigBuilder();
+    });
+
+    describe('.addDynamicPlugin', () => {
+      it('adds a dynamic plugin to gasketConfig', () => {
+        gasketConfig.addDynamicPlugin('pluginOne');
+        expect(gasketConfig.fields.dynamicPlugins).toEqual(['pluginOne']);
+      });
+
+      it('adds multiple dynamic plugins to gasketConfig', () => {
+        gasketConfig.addDynamicPlugin('pluginOne');
+        gasketConfig.addDynamicPlugin('pluginTwo');
+        expect(gasketConfig.fields.dynamicPlugins).toEqual(['pluginOne', 'pluginTwo']);
+      });
+    });
+
+    describe('.addEnvironment', () => {
+      it('adds an environment to gasketConfig', () => {
+        gasketConfig.addEnvironment('test.env', { test: 'config ' });
+        expect(gasketConfig.fields.environments).toEqual({ 'test.env': { test: 'config ' } });
+      });
+
+      it('adds values to an environment in gasketConfig', () => {
+        gasketConfig.addEnvironment('test.env', { test: 'config ' });
+        gasketConfig.addEnvironment('test.env', { test2: 'config 2' });
+        expect(gasketConfig.fields.environments).toEqual({ 'test.env': { test: 'config ', test2: 'config 2' } });
+      });
+
+      it('adds multiple environments to gasketConfig', () => {
+        gasketConfig.addEnvironment('test.env', { test: 'config ' });
+        gasketConfig.addEnvironment('prod.env', { prod: 'config ' });
+        expect(gasketConfig.fields.environments).toEqual({
+          'test.env': { test: 'config ' },
+          'prod.env': { prod: 'config ' }
+        });
+      });
+    });
+  });
 });

packages/gasket-plugin-analyze/lib/create.js

@@ -6,13 +6,17 @@ const { name, version } = require('../package.json');
  * @type {import('@gasket/core').HookHandler<'create'>}
  */
 module.exports = function create(gasket, { pkg, gasketConfig }) {
-  gasketConfig.addPlugin('pluginAnalyze', name);
+  gasketConfig.addEnvironment('local.analyze', {
+    dynamicPlugins: [
+      '@gasket/plugin-analyze'
+    ]
+  });
 
   pkg.add('devDependencies', {
     [name]: `^${version}`
   });
 
   pkg.add('scripts', {
-    analyze: 'ANALYZE=true next build'
+    analyze: 'GASKET_ENV=local.analyze ANALYZE=1 next build'
   });
 };

packages/gasket-plugin-analyze/lib/webpack-config.js

@@ -9,8 +9,12 @@ module.exports = function webpackConfigHook(gasket, webpackConfig, context) {
     config: { bundleAnalyzerConfig: userConfig = {} }
   } = gasket;
 
-  // Only add the analyzer plugin if ANALYZE flag is true
   if (process.env.ANALYZE === 'true') {
+    console.warn("Deprecation Warning: Using 'true' for the ANALYZE environment variable is deprecated. Please use '1' instead.");
+  }
+  // Run the analyzer plugin if the ANALYZE flag is true or 1
+  // @deprecated: 'true' will be removed in a future release
+  if (process.env.ANALYZE === 'true' || process.env.ANALYZE === '1') {
     const merge = require('deepmerge');
     const { BundleAnalyzerPlugin } = require('webpack-bundle-analyzer');
     const defaultConfig = require('./default-config');

packages/gasket-plugin-analyze/test/create.spec.js

@@ -5,14 +5,18 @@ describe('create', () => {
 
   it('adds the analyze script and adds the plugin', async () => {
     const add = jest.fn();
-    const addPlugin = jest.fn();
-    await create({}, { pkg: { add }, gasketConfig: { addPlugin } });
+    const addEnvironment = jest.fn();
+    await create({}, { pkg: { add }, gasketConfig: { addEnvironment } });
     expect(add.mock.calls[0]).toEqual(['devDependencies', {
       [name]: `^${version}`
     }]);
     expect(add.mock.calls[1]).toEqual(['scripts', {
-      analyze: 'ANALYZE=true next build'
+      analyze: 'GASKET_ENV=local.analyze ANALYZE=1 next build'
     }]);
-    expect(addPlugin.mock.calls[0]).toEqual(['pluginAnalyze', name]);
+    expect(addEnvironment).toHaveBeenCalledWith('local.analyze', {
+      dynamicPlugins: [
+        '@gasket/plugin-analyze'
+      ]
+    });
   });
 });