refactor:environment via parsing extension context

Author: joelgallant

app-config-config/src/index.ts

@@ -90,9 +90,7 @@ export async function loadUnvalidatedConfig({
   const environmentAliases =
     environmentAliasesArg ?? meta.value.environmentAliases ?? defaultAliases;
 
-  const parsingExtensions =
-    parsingExtensionsArg ??
-    defaultExtensions(environmentAliases, environmentOverride, undefined, environmentSourceNames);
+  const parsingExtensions = parsingExtensionsArg ?? defaultExtensions();
 
   const secretsFileExtensions =
     secretsFileExtensionsArg ?? parsingExtensions.concat(markAllValuesAsSecret());
@@ -112,15 +110,13 @@ export async function loadUnvalidatedConfig({
       join(directory, fileNameBase),
       environmentOverride,
       environmentAliases,
-      undefined,
       environmentSourceNames,
     ).read(parsingExtensions),
 
     new FlexibleFileSource(
       join(directory, secretsFileNameBase),
       environmentOverride,
       environmentAliases,
-      undefined,
       environmentSourceNames,
     )
       .read(secretsFileExtensions)
@@ -210,6 +206,7 @@ export async function loadValidatedConfig(
         : undefined,
       environmentOverride: options?.environmentOverride,
       environmentAliases: options?.environmentAliases,
+      environmentSourceNames: options?.environmentSourceNames,
       ...schemaOptions,
     }),
     loadUnvalidatedConfig(options),

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

@@ -4,7 +4,7 @@ import { safeLoad as parseYAML, safeDump as stringifyYAML } from 'js-yaml';
 import { parse as parseJSON5, stringify as stringifyJSON5 } from 'json5';
 import { Json, JsonObject } from '@app-config/utils';
 import { logger } from '@app-config/logging';
-import { ParsedValue, ParsingExtension } from './parsed-value';
+import { ParsedValue, ParsingContext, ParsingExtension } from './parsed-value';
 import { AppConfigError, NotFoundError, ParsingError, BadFileType } from './errors';
 
 export enum FileType {
@@ -30,15 +30,15 @@ export abstract class ConfigSource {
   }
 
   /** Reads the contents of the source into a full ParsedValue (not the raw JSON, like readValue) */
-  async read(extensions?: ParsingExtension[]): Promise<ParsedValue> {
+  async read(extensions?: ParsingExtension[], context?: ParsingContext): Promise<ParsedValue> {
     const rawValue = await this.readValue();
 
-    return ParsedValue.parse(rawValue, this, extensions);
+    return ParsedValue.parse(rawValue, this, extensions, undefined, context);
   }
 
   /** Ergonomic helper for chaining `source.read(extensions).then(v => v.toJSON())` */
-  async readToJSON(extensions?: ParsingExtension[]): Promise<Json> {
-    const parsed = await this.read(extensions);
+  async readToJSON(extensions?: ParsingExtension[], context?: ParsingContext): Promise<Json> {
+    const parsed = await this.read(extensions, context);
 
     return parsed.toJSON();
   }
@@ -82,8 +82,10 @@ export class CombinedSource extends ConfigSource {
   }
 
   // override so that ParsedValue is directly from the originating ConfigSource
-  async read(extensions?: ParsingExtension[]): Promise<ParsedValue> {
-    const values = await Promise.all(this.sources.map((source) => source.read(extensions)));
+  async read(extensions?: ParsingExtension[], context?: ParsingContext): Promise<ParsedValue> {
+    const values = await Promise.all(
+      this.sources.map((source) => source.read(extensions, context)),
+    );
 
     const merged = values.reduce<ParsedValue | undefined>((acc, parsed) => {
       if (!acc) return parsed;
@@ -137,11 +139,11 @@ export class FallbackSource extends ConfigSource {
   }
 
   // override so that ParsedValue is directly from the originating ConfigSource
-  async read(extensions?: ParsingExtension[]): Promise<ParsedValue> {
+  async read(extensions?: ParsingExtension[], context?: ParsingContext): Promise<ParsedValue> {
     // take the first value that comes back without an error
     for (const source of this.sources) {
       try {
-        const value = await source.read(extensions);
+        const value = await source.read(extensions, context);
         logger.verbose(`FallbackSource found successful source`);
 
         return value;

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

@@ -17,7 +17,9 @@ export type ParsingExtensionKey =
   | [typeof InArray, number]
   | [typeof Root];
 
-export type ParsingContext = Record<string, string | Record<string, string>>;
+export interface ParsingContext {
+  [k: string]: string | Record<string, string> | string[] | undefined;
+}
 
 export type ParsingExtension<T extends Json = Json> = (
   value: T,
@@ -69,8 +71,9 @@ export class ParsedValue {
     source: ConfigSource,
     extensions?: ParsingExtension[],
     metadata?: ParsedValueMetadata,
+    context?: ParsingContext,
   ): Promise<ParsedValue> {
-    return parseValue(raw, source, extensions, metadata);
+    return parseValue(raw, source, extensions, metadata, context);
   }
 
   /** Parses (with extensions) from a plain JSON object */

app-config-default-extensions/index.js

@@ -4,7 +4,6 @@
 
 // NOTE: Also, we don't require modules up-front - lazy load them instead.
 // This avoids circular dependency chains.
-const { defaultAliases } = require('@app-config/node');
 
 module.exports = {
   defaultExtensions() {

app-config-extensions/src/index.ts

@@ -534,7 +534,7 @@ function getEnv(context: ParsingContext) {
 
   return (
     (environmentOverride as string) ??
-    currentEnvironment(getAliases(context), environmentSourceNames as string)
+    currentEnvironment(getAliases(context), environmentSourceNames as string | string[])
   );
 }
 

app-config-node/src/file-source.ts

@@ -8,6 +8,7 @@ import {
   ParsingExtension,
   AppConfigError,
   NotFoundError,
+  ParsingContext,
 } from '@app-config/core';
 import { logger } from '@app-config/logging';
 import { currentEnvironment, defaultAliases, EnvironmentAliases } from './environment';
@@ -46,8 +47,8 @@ export class FlexibleFileSource extends ConfigSource {
     private readonly filePath: string,
     private readonly environmentOverride?: string,
     private readonly environmentAliases: EnvironmentAliases = defaultAliases,
-    private readonly fileExtensions: string[] = ['yml', 'yaml', 'toml', 'json', 'json5'],
     private readonly environmentSourceNames?: string[] | string,
+    private readonly fileExtensions: string[] = ['yml', 'yaml', 'toml', 'json', 'json5'],
   ) {
     super();
   }
@@ -90,10 +91,15 @@ export class FlexibleFileSource extends ConfigSource {
     return this.resolveSource().then((source) => source.readContents());
   }
 
-  async read(extensions?: ParsingExtension[]): Promise<ParsedValue> {
+  async read(extensions?: ParsingExtension[], context?: ParsingContext): Promise<ParsedValue> {
     const source = await this.resolveSource();
 
-    return source.read(extensions);
+    return source.read(extensions, {
+      environmentOverride: this.environmentOverride,
+      environmentAliases: this.environmentAliases,
+      environmentSourceNames: this.environmentSourceNames,
+      ...context,
+    });
   }
 }
 

app-config-schema/src/index.ts

@@ -15,7 +15,6 @@ import {
 } from '@app-config/core';
 import { logger } from '@app-config/logging';
 import {
-  defaultAliases,
   EnvironmentAliases,
   EnvironmentSource,
   FileSource,
@@ -30,6 +29,7 @@ export interface SchemaLoadingOptions {
   environmentVariableName?: string;
   environmentOverride?: string;
   environmentAliases?: EnvironmentAliases;
+  environmentSourceNames?: string[] | string;
   parsingExtensions?: ParsingExtension[];
 }
 
@@ -48,7 +48,8 @@ export async function loadSchema({
   fileNameBase = '.app-config.schema',
   environmentVariableName = 'APP_CONFIG_SCHEMA',
   environmentOverride,
-  environmentAliases = defaultAliases,
+  environmentAliases,
+  environmentSourceNames,
   parsingExtensions = [],
 }: SchemaLoadingOptions = {}): Promise<Schema> {
   const env = new EnvironmentSource(environmentVariableName);
@@ -72,6 +73,7 @@ export async function loadSchema({
       join(directory, fileNameBase),
       environmentOverride,
       environmentAliases,
+      environmentSourceNames,
     );
 
     parsed = await source.read(parsingExtensions);

tests/parsing-extensions/eval-package/main.js

@@ -1,4 +1,4 @@
-module.exports = (options) => (value, [, key]) => {
+module.exports = (options) => (value, [[, key]]) => {
   if (key === '$eval') {
     if (typeof value === 'string') {
       return (parse) => parse(eval(value), { shouldFlatten: true });

tests/parsing-extensions/random-package/main.js

@@ -1,4 +1,4 @@
-module.exports = (options) => (value, [, key]) => {
+module.exports = (options) => (value, [[, key]]) => {
   const rng = require('seedrandom')(options.seed);
 
   if (key === '$random') {