Allow partial configs in environment overrides

packages/create-gasket-app/lib/commands/create.js

@@ -118,7 +118,7 @@ createCommand.action = async function run(appname, options, command) {
 
     const pluginGasket = makeGasket({
       ...context.presetConfig,
-      plugins: context.presets.concat(context.presetConfig.plugins)
+      plugins: context.presetConfig.plugins.concat(context.presets)
     });
 
     await promptHooks({ gasket: pluginGasket, context });

packages/gasket-core/CHANGELOG.md

@@ -1,5 +1,7 @@
 # `@gasket/core`
 
+- Fix configuration options so they allow partial environment overrides ([#1026])
+
 ### 7.2.0
 
 - Adjust types GasketTrace

packages/gasket-core/lib/gasket.js

@@ -38,7 +38,7 @@ export class Gasket {
     // prune nullish and/or empty plugins
     config.plugins = config.plugins
       .filter(Boolean)
-      .map(plugin => plugin.default || plugin) // quality of life for cjs apps
+      .map(plugin => 'default' in plugin ? plugin.default : plugin) // quality of life for cjs apps
       .filter(plugin => Boolean(plugin.name) || Boolean(plugin.hooks));
 
     // start the engine

packages/gasket-core/lib/index.d.ts

@@ -70,6 +70,10 @@ declare module '@gasket/core' {
     env: string;
   }
 
+  export type PreNormalizedGasketConfig = Omit<GasketConfig, 'plugins'> & {
+    plugins: Array<Plugin | { default: Plugin }>;
+  }
+
   export class GasketEngine {
     constructor(plugins: Array<Plugin>);
 
@@ -133,11 +137,17 @@ declare module '@gasket/core' {
     ? { [K in keyof T]?: PartialRecursive<T[K]> } | undefined
     : T | undefined;
 
-  export type GasketConfigDefinition = Omit<GasketConfig, 'root' | 'env' | 'command'> & {
+  // Allow nested merging of most config
+  type ConfigKeysRequiringFullEnvConfig = 'plugins';
+  type GasketConfigOverrides =
+    & PartialRecursive<Omit<GasketConfigDefinition, ConfigKeysRequiringFullEnvConfig>>
+    & Partial<Pick<GasketConfigDefinition, ConfigKeysRequiringFullEnvConfig>>;
+
+  export type GasketConfigDefinition = Omit<PreNormalizedGasketConfig, 'root' | 'env' | 'command'> & {
     root?: string
     env?: string
-    environments?: Record<string, Partial<GasketConfigDefinition>>
-    commands?: Record<string, Partial<GasketConfigDefinition>>
+    environments?: Record<string, GasketConfigOverrides>
+    commands?: Record<string, GasketConfigOverrides>
   }
 
   /**

packages/gasket-typescript-tests/test/engine.spec.ts → packages/gasket-typescript-tests/test/core.spec.ts

@@ -5,6 +5,13 @@ declare module '@gasket/core' {
   interface HookExecTypes {
     example(str: string, num: number, bool: boolean): MaybeAsync<boolean>
   }
+
+  interface GasketConfig {
+    someConfigSection?: {
+      foo: string;
+      bar: number;
+    }
+  }
 }
 
 const PluginExample = {
@@ -21,19 +28,35 @@ const PluginExample = {
 describe('@gasket/core', () => {
   it('exposes the constructor interface', () => {
     // eslint-disable-next-line no-new
-    makeGasket({ plugins: [PluginExample] });
+    makeGasket({
+      plugins: [PluginExample],
+      someConfigSection: {
+        foo: 'foo',
+        bar: 123
+      }
+    });
   });
 
   it('checks constructor arguments', () => {
     // eslint-disable-next-line no-new
     makeGasket({
-      plugins: [PluginExample]
+      plugins: [PluginExample],
+      someConfigSection: {
+        foo: 'foo',
+        bar: 123
+      }
     // @ts-expect-error
     }, 'extra');
   });
 
   it('should infer the types of lifecycle parameters', async function () {
-    const gasket = makeGasket({ plugins: [PluginExample] });
+    const gasket = makeGasket({
+      plugins: [PluginExample],
+      someConfigSection: {
+        foo: 'foo',
+        bar: 123
+      }
+    });
 
     await gasket.execApply('example', async function (plugin, handler) {
       handler('a string', 123, true);
@@ -60,7 +83,13 @@ describe('@gasket/core', () => {
   });
 
   it('type checks the hook method', () => {
-    const gasket = makeGasket({ plugins: [PluginExample] });
+    const gasket = makeGasket({
+      plugins: [PluginExample],
+      someConfigSection: {
+        foo: 'foo',
+        bar: 123
+      }
+    });
 
     // Valid
     gasket.hook({
@@ -89,7 +118,13 @@ describe('@gasket/core', () => {
   });
 
   it('exposes the running command on the Gasket interface', () => {
-    const gasket = makeGasket({ plugins: [PluginExample] });
+    const gasket = makeGasket({
+      plugins: [PluginExample],
+      someConfigSection: {
+        foo: 'foo',
+        bar: 123
+      }
+    });
 
     // Valid
     gasket.hook({
@@ -116,4 +151,21 @@ describe('@gasket/core', () => {
       }
     };
   });
+
+  it('allows partial environment config overrides', () => {
+    const config: GasketConfigDefinition = {
+      plugins: [PluginExample],
+      someConfigSection: {
+        foo: 'foo',
+        bar: 123
+      },
+      environments: {
+        dev: {
+          someConfigSection: {
+            foo: 'dev-foo'
+          }
+        }
+      }
+    };
+  });
 });

packages/gasket-typescript-tests/test/utils.spec.ts

@@ -1,19 +1,19 @@
 import { applyConfigOverrides, runShellCommand } from '@gasket/utils';
-import { GasketConfig, GasketConfigDefinition } from '@gasket/core';
+import { GasketConfig } from '@gasket/core';
 
 describe('@gasket/utils', function () {
   const perform = false;
 
   describe('applyConfigOverrides', function () {
-    const config: GasketConfigDefinition = {
+    const config: GasketConfig = {
       plugins: [{ name: 'example', version: '', description: '', hooks: {} }],
       root: '/',
       env: 'debug'
     };
 
     it('has expected API', function () {
       if (perform) {
-        let result:GasketConfig;
+        let result: GasketConfig;
         result = applyConfigOverrides(config, { env: 'test' });
         result = applyConfigOverrides(config, { env: 'test', commandId: 'test' });
 

packages/gasket-utils/CHANGELOG.md

@@ -1,5 +1,7 @@
 # `@gasket/utils`
 
+- Fix type of environment overrides ([#1026])
+
 ### 7.1.2
 
 - Ensure non-plain objects are copied instead of merge ([#1002])

packages/gasket-utils/lib/config.d.ts

@@ -7,33 +7,37 @@ interface ConfigContext {
   commandId?: string;
 }
 
-interface ConfigDefinition extends Record<string, any> {
-  environments?: Record<string, Partial<ConfigDefinition>>;
-  commands?: Record<string, Partial<ConfigDefinition>>;
-  [key: string]: any;
+// TODO: switch @gasket/core to re-exporting this type once this change is
+// published and we can update its dependency to this version
+export type PartialRecursive<T> = T extends Object
+  ? { [K in keyof T]?: PartialRecursive<T[K]> } | undefined
+  : T | undefined;
+
+type ConfigDefinition<T> = T & {
+  environments?: Record<string, PartialRecursive<T>>;
+  commands?: Record<string, PartialRecursive<T>>;
 }
 
-type ConfigOutput = Omit<ConfigDefinition, 'environments' | 'commands'>;
-type ConfigPartial = Partial<ConfigDefinition> | undefined | void | unknown;
+type ConfigPartial<T extends ConfigDefinition> = PartialRecursive<T> | undefined | void | unknown;
 
 export function getPotentialConfigs(
   config: ConfigDefinition,
   configContext: ConfigContext
 ): Array<ConfigPartial>;
 
 export function getCommandOverrides(
-  commands: Record<string, Partial<ConfigDefinition>>,
+  commands: Record<string, PartialRecursive<ConfigDefinition>>,
   commandId: string
 ): Array<ConfigPartial>;
 
 export function getSubEnvironmentOverrides(
   env: string,
-  environments: Record<string, Partial<ConfigDefinition>>
+  environments: Record<string, PartialRecursive<ConfigDefinition>>
 ): Array<ConfigPartial>;
 
 export function getDevOverrides(
   isLocalEnv: boolean,
-  environments: Record<string, Partial<ConfigDefinition>>
+  environments: Record<string, PartialRecursive<ConfigDefinition>>
 ): Array<ConfigPartial>;
 
 export async function getLatestVersion(
@@ -51,7 +55,7 @@ export function getLocalOverrides(
 
 // Normalize the config by applying any overrides for environments, commands, or
 // local-only config file.
-export function applyConfigOverrides<
-  Def extends ConfigDefinition,
-  Out extends ConfigOutput
->(config: Def, configContext: ConfigContext): Out;
+export function applyConfigOverrides<Config>(
+  config: ConfigDefinition<Config>,
+  configContext: ConfigContext
+): Config;