Merge pull request #149 from launchcodedev/env-options-trio

joelgallant · web-flow · commit 1912747fa71d · 2021-05-01T16:44:59.000-06:00
Env options trio type
diff --git a/app-config-cli/src/validation.ts b/app-config-cli/src/validation.ts
@@ -4,11 +4,19 @@ import { FileSource, EnvironmentAliases, defaultAliases } from '@app-config/node
 import { loadValidatedConfig } from '@app-config/config';
 
 export interface Options {
+  /** Where app-config files are */
   directory?: string;
+  /** Override for aliasing of environments */
   environmentAliases?: EnvironmentAliases;
+  /** If app-config should be validating in a "no current environment" state */
   includeNoEnvironment?: boolean;
 }
 
+/**
+ * Loads and validations app-config values in every environment detectable.
+ *
+ * Uses a hueristic to find which environments are available, because these are arbitrary.
+ */
 export async function validateAllConfigVariants({
   directory = '.',
   environmentAliases = defaultAliases,
@@ -24,9 +32,9 @@ export async function validateAllConfigVariants({
   const appConfigEnvironments = new Set<string>();
 
   for (const filename of appConfigFiles) {
-    const environment = /^\.app-config\.(?:secrets\.)?(.*)\.(?:yml|yaml|json|json5|toml)$/.exec(
-      filename,
-    )?.[1];
+    // extract the environment out, which is the first capture group
+    const regex = /^\.app-config\.(?:secrets\.)?(.*)\.(?:yml|yaml|json|json5|toml)$/;
+    const environment = regex.exec(filename)?.[1];
 
     if (environment && environment !== 'meta' && environment !== 'schema') {
       appConfigEnvironments.add(environmentAliases[environment] ?? environment);
diff --git a/app-config-config/src/index.ts b/app-config-config/src/index.ts
@@ -15,6 +15,7 @@ import {
   defaultAliases,
   EnvironmentAliases,
   EnvironmentSource,
+  asEnvOptions,
 } from '@app-config/node';
 import { markAllValuesAsSecret } from '@app-config/extensions';
 import { defaultExtensions, defaultEnvExtensions } from '@app-config/default-extensions';
@@ -90,6 +91,12 @@ export async function loadUnvalidatedConfig({
   const environmentAliases =
     environmentAliasesArg ?? meta.value.environmentAliases ?? defaultAliases;
 
+  const environmentOptions = asEnvOptions(
+    environmentOverride,
+    environmentAliases,
+    environmentSourceNames,
+  );
+
   const parsingExtensions =
     parsingExtensionsArg ??
     defaultExtensions(environmentAliases, environmentOverride, undefined, environmentSourceNames);
@@ -108,21 +115,11 @@ export async function loadUnvalidatedConfig({
   logger.verbose(`Trying to read files for configuration`);
 
   const [mainConfig, secrets] = await Promise.all([
-    new FlexibleFileSource(
-      join(directory, fileNameBase),
-      environmentOverride,
-      environmentAliases,
-      undefined,
-      environmentSourceNames,
-    ).read(parsingExtensions),
-
-    new FlexibleFileSource(
-      join(directory, secretsFileNameBase),
-      environmentOverride,
-      environmentAliases,
-      undefined,
-      environmentSourceNames,
-    )
+    new FlexibleFileSource(join(directory, fileNameBase), undefined, environmentOptions).read(
+      parsingExtensions,
+    ),
+
+    new FlexibleFileSource(join(directory, secretsFileNameBase), undefined, environmentOptions)
       .read(secretsFileExtensions)
       .catch((error) => {
         // NOTE: secrets are optional, so not finding them is normal
diff --git a/app-config-extensions/src/env-directive.ts b/app-config-extensions/src/env-directive.ts
@@ -1,16 +1,23 @@
 import type { ParsingExtension } from '@app-config/core';
 import { AppConfigError } from '@app-config/core';
 import { named, forKey, keysToPath, validateOptions } from '@app-config/extension-utils';
-import { currentEnvironment, defaultAliases, EnvironmentAliases } from '@app-config/node';
+import {
+  currentEnvironment,
+  defaultAliases,
+  asEnvOptions,
+  EnvironmentAliases,
+} from '@app-config/node';
 
 /** Looks up an environment-specific value ($env) */
 export function envDirective(
   aliases: EnvironmentAliases = defaultAliases,
   environmentOverride?: string,
   environmentSourceNames?: string[] | string,
 ): ParsingExtension {
-  const environment = environmentOverride ?? currentEnvironment(aliases, environmentSourceNames);
   const metadata = { shouldOverride: true };
+  const environment = currentEnvironment(
+    asEnvOptions(environmentOverride, aliases, environmentSourceNames),
+  );
 
   return named(
     '$env',
diff --git a/app-config-extensions/src/env-var-directive.ts b/app-config-extensions/src/env-var-directive.ts
@@ -1,15 +1,22 @@
 import type { ParsingExtension } from '@app-config/core';
 import { named, forKey, validationFunction, ValidationFunction } from '@app-config/extension-utils';
 import { AppConfigError, InObject } from '@app-config/core';
-import { currentEnvironment, defaultAliases, EnvironmentAliases } from '@app-config/node';
+import {
+  asEnvOptions,
+  currentEnvironment,
+  defaultAliases,
+  EnvironmentAliases,
+} from '@app-config/node';
 
 /** Substitutes environment variables */
 export function envVarDirective(
   aliases: EnvironmentAliases = defaultAliases,
   environmentOverride?: string,
   environmentSourceNames?: string[] | string,
 ): ParsingExtension {
-  const envType = environmentOverride ?? currentEnvironment(aliases, environmentSourceNames);
+  const environment = currentEnvironment(
+    asEnvOptions(environmentOverride, aliases, environmentSourceNames),
+  );
 
   return named(
     '$envVar',
@@ -72,7 +79,7 @@ export function envVarDirective(
       let resolvedValue = process.env[name];
 
       if (!resolvedValue && name === 'APP_CONFIG_ENV') {
-        resolvedValue = envType;
+        resolvedValue = environment;
       }
 
       if (resolvedValue) {
diff --git a/app-config-extensions/src/substitute-directive.ts b/app-config-extensions/src/substitute-directive.ts
@@ -1,6 +1,11 @@
 import { named, forKey, validationFunction, ValidationFunction } from '@app-config/extension-utils';
 import { ParsingExtension, AppConfigError, InObject } from '@app-config/core';
-import { currentEnvironment, defaultAliases, EnvironmentAliases } from '@app-config/node';
+import {
+  asEnvOptions,
+  currentEnvironment,
+  defaultAliases,
+  EnvironmentAliases,
+} from '@app-config/node';
 import { logger } from '@app-config/logging';
 
 /** Substitues environment variables found in strings (similar to bash variable substitution) */
@@ -9,13 +14,15 @@ export function substituteDirective(
   environmentOverride?: string,
   environmentSourceNames?: string[] | string,
 ): ParsingExtension {
-  const envType = environmentOverride ?? currentEnvironment(aliases, environmentSourceNames);
+  const environment = currentEnvironment(
+    asEnvOptions(environmentOverride, aliases, environmentSourceNames),
+  );
 
   return named(
     '$substitute',
     forKey(['$substitute', '$subs'], (value, key, ctx) => async (parse) => {
       if (typeof value === 'string') {
-        return parse(performAllSubstitutions(value, envType), { shouldFlatten: true });
+        return parse(performAllSubstitutions(value, environment), { shouldFlatten: true });
       }
 
       validateObject(value, [...ctx, key]);
@@ -71,7 +78,7 @@ export function substituteDirective(
       let resolvedValue = process.env[name];
 
       if (!resolvedValue && name === 'APP_CONFIG_ENV') {
-        resolvedValue = envType;
+        resolvedValue = environment;
       }
 
       if (resolvedValue) {
diff --git a/app-config-node/src/environment.test.ts b/app-config-node/src/environment.test.ts
@@ -0,0 +1,78 @@
+import {
+  currentEnvironment,
+  aliasesFor,
+  asEnvOptions,
+  defaultAliases,
+  defaultEnvVarNames,
+} from './environment';
+
+describe('currentEnvironment', () => {
+  describe('deprecated currentEnvironment', () => {
+    it('uses environmentSourceNames', () => {
+      process.env.NODE_ENV = 'foo';
+      process.env.FOO = 'bar';
+
+      expect(currentEnvironment(undefined, ['FOO', 'BAR'])).toBe('bar');
+      expect(currentEnvironment(undefined, ['BAR'])).toBe(undefined);
+    });
+
+    it('uses environmentAliases', () => {
+      process.env.FOO = 'bar';
+      process.env.NODE_ENV = 'bar';
+
+      expect(currentEnvironment({}, ['FOO'])).toBe('bar');
+      expect(currentEnvironment({ bar: 'foo' })).toBe('foo');
+      expect(currentEnvironment({ bar: 'foo' }, ['FOO'])).toBe('foo');
+    });
+  });
+
+  it('uses envVarNames', () => {
+    process.env.NODE_ENV = 'foo';
+    process.env.FOO = 'bar';
+
+    expect(currentEnvironment({ envVarNames: ['FOO', 'BAR'], aliases: defaultAliases })).toBe(
+      'bar',
+    );
+    expect(currentEnvironment({ envVarNames: ['BAR'], aliases: defaultAliases })).toBe(undefined);
+  });
+
+  it('uses aliases', () => {
+    process.env.FOO = 'bar';
+    process.env.NODE_ENV = 'bar';
+
+    expect(currentEnvironment({ envVarNames: ['FOO'], aliases: defaultAliases })).toBe('bar');
+    expect(currentEnvironment({ aliases: { bar: 'foo' }, envVarNames: defaultEnvVarNames })).toBe(
+      'foo',
+    );
+    expect(currentEnvironment({ aliases: { bar: 'foo' }, envVarNames: ['FOO'] })).toBe('foo');
+  });
+
+  it('uses override', () => {
+    process.env.NODE_ENV = 'foo';
+    expect(currentEnvironment({})).toBe('foo');
+    expect(currentEnvironment({ override: 'bar' })).toBe('bar');
+  });
+});
+
+describe('aliasesFor', () => {
+  it('reverse lookups', () => {
+    expect(aliasesFor('foo', { bar: 'foo', baz: 'qux' })).toEqual(['bar']);
+    expect(aliasesFor('foo', { bar: 'foo', baz: 'foo' })).toEqual(['bar', 'baz']);
+  });
+});
+
+describe('asEnvOptions', () => {
+  it('reads environmentSourceNames string', () => {
+    expect(asEnvOptions(undefined, undefined, 'foo')).toEqual({
+      envVarNames: ['foo'],
+      aliases: defaultAliases,
+    });
+  });
+
+  it('reads environmentSourceNames strings', () => {
+    expect(asEnvOptions(undefined, undefined, ['foo'])).toEqual({
+      envVarNames: ['foo'],
+      aliases: defaultAliases,
+    });
+  });
+});
diff --git a/app-config-node/src/environment.ts b/app-config-node/src/environment.ts
@@ -1,21 +1,109 @@
+import { logger } from '@app-config/logging';
+
+/** A mapping for "alias" names of environments, like "dev" => "development" */
 export interface EnvironmentAliases {
   [alias: string]: string;
 }
 
+/** Options required for calling {@link currentEnvironment} */
+export interface EnvironmentOptions {
+  /** Absolute override for what the current environment is, still abiding by aliases */
+  override?: string;
+  /** A mapping for "alias" names of environments, like "dev" => "development" */
+  aliases: EnvironmentAliases;
+  /** What environment variable(s) define the current environment, if override is not defined */
+  envVarNames: string[];
+}
+
+/** Default aliases that app-config will resolve for you */
 export const defaultAliases: EnvironmentAliases = {
   prod: 'production',
   dev: 'development',
 };
 
+/** Default environment variables that app-config will read */
+export const defaultEnvVarNames = ['APP_CONFIG_ENV', 'NODE_ENV', 'ENV'];
+
+/** Default options for {@link currentEnvironment} */
+export const defaultEnvOptions: EnvironmentOptions = {
+  aliases: defaultAliases,
+  envVarNames: defaultEnvVarNames,
+};
+
+/** Conversion function useful for old usage of the deprecated {@link currentEnvironment} form */
+export function asEnvOptions(
+  override?: string,
+  aliases: EnvironmentAliases = defaultAliases,
+  environmentSourceNames: string[] | string = defaultEnvVarNames,
+): EnvironmentOptions {
+  return {
+    override,
+    aliases,
+    envVarNames:
+      typeof environmentSourceNames === 'string'
+        ? [environmentSourceNames]
+        : environmentSourceNames,
+  };
+}
+
+/** Retrieve what app-config thinks the current deployment environment is (ie QA, dev, staging, production) */
+export function currentEnvironment(options?: EnvironmentOptions): string | undefined;
+
+/** @deprecated use currentEnvironment(EnvironmentOptions) instead */
 export function currentEnvironment(
-  environmentAliases: EnvironmentAliases = defaultAliases,
-  environmentSourceNames: string[] | string = ['APP_CONFIG_ENV', 'NODE_ENV', 'ENV'],
-) {
+  environmentAliases?: EnvironmentAliases,
+  environmentSourceNames?: string[] | string,
+): string | undefined;
+
+export function currentEnvironment(...args: any[]): string | undefined {
+  let environmentSourceNames: string[] = defaultEnvVarNames;
+  let environmentAliases: EnvironmentAliases = defaultAliases;
+  let environmentOverride: string | undefined;
+
+  if (
+    args[0] &&
+    typeof args[0] === 'object' &&
+    ('override' in args[0] || 'aliases' in args[0] || 'envVarNames' in args[0])
+  ) {
+    const options = args[0] as EnvironmentOptions;
+
+    if (options.override) {
+      environmentOverride = options.override;
+    }
+
+    if (options.aliases) {
+      environmentAliases = options.aliases;
+    }
+
+    if (options.envVarNames) {
+      environmentSourceNames = options.envVarNames;
+    }
+  } else {
+    if (args[0]) {
+      environmentAliases = args[0] as EnvironmentAliases;
+      logger.warn('Detected deprecated usage of currentEnvironment');
+    }
+
+    if (Array.isArray(args[1])) {
+      environmentSourceNames = args[1] as string[];
+      logger.warn('Detected deprecated usage of currentEnvironment');
+    } else if (typeof args[1] === 'string') {
+      environmentSourceNames = [args[1]];
+      logger.warn('Detected deprecated usage of currentEnvironment');
+    }
+  }
+
+  if (environmentOverride) {
+    if (environmentAliases[environmentOverride]) {
+      return environmentAliases[environmentOverride];
+    }
+
+    return environmentOverride;
+  }
+
   let value: string | undefined;
 
-  for (const name of Array.isArray(environmentSourceNames)
-    ? environmentSourceNames
-    : [environmentSourceNames]) {
+  for (const name of environmentSourceNames) {
     if (process.env[name]?.length) {
       value = process.env[name];
       break;
@@ -30,3 +118,10 @@ export function currentEnvironment(
 
   return value;
 }
+
+/** Reverse lookup of any aliases for some environment */
+export function aliasesFor(env: string, aliases: EnvironmentAliases): string[] {
+  return Object.entries(aliases)
+    .filter(([, value]) => value === env)
+    .map(([key]) => key);
+}
diff --git a/app-config-node/src/file-source.ts b/app-config-node/src/file-source.ts
diff --git a/app-config-node/src/index.ts b/app-config-node/src/index.ts
diff --git a/app-config-schema/src/index.ts b/app-config-schema/src/index.ts
