Merge branch 'master' into v3

Author: joelgallant

CHANGELOG.md

@@ -1,3 +1,19 @@
+## v2.5.1
+
+Adds `env` option on `$extends` and `$override` directives.
+
+## v2.5.0
+
+Adds some early deprecation warnings in preparation for version 3. See [here](https://github.com/launchcodedev/app-config/issues/130).
+
+Allows default extensions to be used twice without conflicts.
+
+Adds `$parseBool`, `$parseFloat` and `$parseInt` directives.
+
+Adds `allowMissing` option on `$envVar` that's a shorthand for `allowNull` + `fallback: null`.
+
+Creates new calling interface for `currentEnvironment` and `FlexibleFileSource`.
+
 ## v2.4.5
 
 Adds `$hidden` directive mainly for shared properties.

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);

app-config-config/src/index.test.ts

@@ -219,6 +219,35 @@ describe('Configuration Loading', () => {
       },
     );
   });
+
+  it('extends from another file with different environment', async () => {
+    await withTempFiles(
+      {
+        '.app-config.yml': `
+          $extends:
+            path: ./other-file.yml
+            env: production
+          bar:
+            $envVar: APP_CONFIG_ENV
+        `,
+        'other-file.yml': `
+          foo:
+            $env:
+              default: default
+              prod: production
+        `,
+      },
+      async (inDir) => {
+        expect(
+          (await loadUnvalidatedConfig({ directory: inDir('.'), environmentOverride: 'test' }))
+            .fullConfig,
+        ).toEqual({
+          foo: 'production',
+          bar: 'test',
+        });
+      },
+    );
+  });
 });
 
 describe('Configuration Loading Options', () => {

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();
 
   const secretsFileExtensions =
@@ -106,19 +113,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,
-      environmentSourceNames,
-    ).read(parsingExtensions),
-
-    new FlexibleFileSource(
-      join(directory, secretsFileNameBase),
-      environmentOverride,
-      environmentAliases,
-      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

app-config-core/src/common.ts

@@ -3,6 +3,7 @@ import { logger } from '@app-config/logging';
 
 export type KeyFormatter = (key: string, separator: string) => string;
 
+/** Strategy used in 'app-config vars' for variable names */
 export function camelToScreamingCase(key: string, separator: string = '_'): string {
   return key
     .replace(/([^A-Z]+)([A-Z][a-z])/g, `$1${separator}$2`)
@@ -11,6 +12,7 @@ export function camelToScreamingCase(key: string, separator: string = '_'): stri
     .toUpperCase();
 }
 
+/** Strategy used in 'app-config vars' to extract variable names from hierachy */
 export function flattenObjectTree(
   obj: JsonObject,
   prefix: string = '',
@@ -40,6 +42,7 @@ export function flattenObjectTree(
   }, {});
 }
 
+/** Strategy for renaming keys, used for 'app-config vars' */
 export function renameInFlattenedTree(
   flattened: { [key: string]: string },
   renames: string[] = [],

app-config-core/src/config-source.test.ts

@@ -15,7 +15,7 @@ class FailingSource extends ConfigSource {
   }
 }
 
-const flattenExtension: ParsingExtension = (value, [[_, key]]) => {
+const flattenExtension: ParsingExtension = (value, [_, key]) => {
   if (key === '$flatten') {
     return (parse) => parse(value, { shouldFlatten: true });
   }

app-config-core/src/config-source.ts

@@ -7,6 +7,9 @@ import { logger } from '@app-config/logging';
 import { ParsedValue, ParsingContext, ParsingExtension } from './parsed-value';
 import { AppConfigError, NotFoundError, ParsingError, BadFileType } from './errors';
 
+/**
+ * File formats that app-config supports.
+ */
 export enum FileType {
   YAML = 'YAML',
   TOML = 'TOML',
@@ -84,7 +87,7 @@ export class CombinedSource extends ConfigSource {
   // override so that ParsedValue is directly from the originating ConfigSource
   async read(extensions?: ParsingExtension[], context?: ParsingContext): Promise<ParsedValue> {
     const values = await Promise.all(
-      this.sources.map((source) => source.read(extensions, context)),
+      this.sources.map((source) => source.read(extensions, { ...context })),
     );
 
     const merged = values.reduce<ParsedValue | undefined>((acc, parsed) => {
@@ -160,6 +163,9 @@ export class FallbackSource extends ConfigSource {
   }
 }
 
+/**
+ * Converts a JSON object to a string, using specified file type.
+ */
 export function stringify(config: Json, fileType: FileType, minimal: boolean = false): string {
   switch (fileType) {
     case FileType.JSON:
@@ -182,6 +188,9 @@ export function stringify(config: Json, fileType: FileType, minimal: boolean = f
   }
 }
 
+/**
+ * Returns which file type to use, based on the file extension.
+ */
 export function filePathAssumedType(filePath: string): FileType {
   switch (extname(filePath).toLowerCase().slice(1)) {
     case 'yml':
@@ -200,6 +209,9 @@ export function filePathAssumedType(filePath: string): FileType {
   }
 }
 
+/**
+ * Parses string based on a file format.
+ */
 export async function parseRawString(contents: string, fileType: FileType): Promise<Json> {
   switch (fileType) {
     case FileType.JSON:
@@ -215,6 +227,9 @@ export async function parseRawString(contents: string, fileType: FileType): Prom
   }
 }
 
+/**
+ * Try to parse string as different file formats, returning the first that worked.
+ */
 export async function guessFileType(contents: string): Promise<FileType> {
   for (const tryType of [FileType.JSON, FileType.TOML, FileType.JSON5, FileType.YAML]) {
     try {

app-config-core/src/parsed-value.test.ts

@@ -60,7 +60,23 @@ describe('parseValue', () => {
     return false;
   };
 
-  const secretExtension: ParsingExtension = (_, [[keyType, key]]) => {
+  const appendExtension = (suffix: string): ParsingExtension => (value) => {
+    if (typeof value === 'string') {
+      return (parse) => parse(value + suffix);
+    }
+
+    return false;
+  };
+
+  const namedAppendExtension = (suffix: string): ParsingExtension => {
+    const extension = appendExtension(suffix);
+
+    return Object.assign(extension, {
+      extensionName: 'namedAppendExtension',
+    });
+  };
+
+  const secretExtension: ParsingExtension = (_, [keyType, key]) => {
     if (keyType === InObject && key === '$secret') {
       return (parse) => parse('revealed!', { shouldFlatten: true });
     }
@@ -175,11 +191,21 @@ describe('parseValue', () => {
   it('allows the same extension to be applied twice', async () => {
     const source = new LiteralSource('string');
     const parsed = await parseValue(await source.readValue(), source, [
-      uppercaseExtension,
-      uppercaseExtension,
+      appendExtension('-appended'),
+      appendExtension('-appended2'),
+    ]);
+
+    expect(parsed.toJSON()).toEqual('string-appended-appended2');
+  });
+
+  it('respects extensionName', async () => {
+    const source = new LiteralSource('string');
+    const parsed = await parseValue(await source.readValue(), source, [
+      namedAppendExtension('-appended'),
+      namedAppendExtension('-appended2'),
     ]);
 
-    expect(parsed.toJSON()).toEqual('STRING');
+    expect(parsed.toJSON()).toEqual('string-appended');
   });
 
   it('allows the same extension apply at different levels of a tree', async () => {