@travetto/config 8.0.0-alpha.20 → 8.0.0-alpha.22

package/README.md

@@ -13,7 +13,7 @@ npm install @travetto/config
 yarn add @travetto/config
 ```
 
-The config module provides support for loading application config on startup. Configuration values support the common [YAML](https://en.wikipedia.org/wiki/YAML) constructs as defined in [yaml](https://github.com/eemeli/yaml).  Additionally, the configuration is built upon the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") module, to enforce type correctness, and allow for validation of configuration as an entrypoint into the application.  Given that all [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) classes are [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19)-based classes, all the standard [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) and [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L24) functionality applies.
+The config module provides support for loading application config on startup. Configuration values support the common [YAML](https://en.wikipedia.org/wiki/YAML) constructs as defined in [yaml](https://github.com/eemeli/yaml). Additionally, the configuration is built upon the [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") module, to enforce type correctness, and allow for validation of configuration as an entrypoint into the application. Given that all [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) classes are [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19)-based classes, all the standard [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L19) and [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L26) functionality applies.
 
 ## Resolution
 The configuration information is comprised of:
@@ -30,7 +30,7 @@ Config loading follows a defined resolution path, below is the order in increasi
 By default all configuration data is inert, and will only be applied when constructing an instance of a configuration class.
 
 ### Mono Repo Support
-When working in a monorepo, the parent resources folder will also be searched with a lower priority than the the module's specific resources.  This allows for shared-global configuration that can be overridden at the module level. The general priority is:
+When working in a monorepo, the parent resources folder will also be searched with a lower priority than the the module's specific resources. This allows for shared-global configuration that can be overridden at the module level. The general priority is:
    1. Mono-repo root
    1. Module root
    1. Folders for `TRV_RESOURCES`, in order
@@ -104,12 +104,12 @@ Config {
 ```
 
 ### Standard Configuration Extension
-The framework provides two simple base classes that assist with existing patterns of usage to make adding in new configuration sources as easy as possible.  The goal here is for the developer to either instantiate or extend these classes and produce a configuration source unique to their needs:
+The framework provides two simple base classes that assist with existing patterns of usage to make adding in new configuration sources as easy as possible. The goal here is for the developer to either instantiate or extend these classes and produce a configuration source unique to their needs:
 
 **Code: Memory Provider**
 ```typescript
 import type { ConfigData } from '../parser/types.ts';
-import type { ConfigSource, ConfigPayload } from './types.ts';
+import type { ConfigPayload, ConfigSource } from './types.ts';
 
 /**
  * Meant to be instantiated and provided as a unique config source
@@ -130,7 +130,8 @@ export class MemoryConfigSource implements ConfigSource {
 **Code: Environment JSON Provider**
 ```typescript
 import { JSONUtil } from '@travetto/runtime';
-import type { ConfigSource, ConfigPayload } from './types.ts';
+
+import type { ConfigPayload, ConfigSource } from './types.ts';
 
 /**
  * Represents the environment mapped data as a JSON blob
@@ -156,11 +157,11 @@ export class EnvConfigSource implements ConfigSource {
 ```
 
 ### Custom Configuration Provider
-In addition to files and environment variables, configuration sources can also be provided via the class itself.  This is useful for reading remote configurations, or dealing with complex configuration normalization.  The only caveat to this pattern, is that the these configuration sources cannot rely on the [ConfigurationService](https://github.com/travetto/travetto/tree/main/module/config/src/service.ts#L24) service for input.  This means any needed configuration will need to be accessed via specific patterns.
+In addition to files and environment variables, configuration sources can also be provided via the class itself. This is useful for reading remote configurations, or dealing with complex configuration normalization. The only caveat to this pattern, is that the these configuration sources cannot rely on the [ConfigurationService](https://github.com/travetto/travetto/tree/main/module/config/src/service.ts#L24) service for input. This means any needed configuration will need to be accessed via specific patterns.
 
 **Code: Custom Configuration Source**
 ```typescript
-import type { ConfigSource, ConfigPayload } from '@travetto/config';
+import type { ConfigPayload, ConfigSource } from '@travetto/config';
 import { Injectable } from '@travetto/di';
 
 @Injectable()
@@ -176,13 +177,13 @@ export class CustomConfigSource implements ConfigSource {
 ```
 
 ## Startup
-At startup, the [ConfigurationService](https://github.com/travetto/travetto/tree/main/module/config/src/service.ts#L24) service will log out all the registered configuration objects.  The configuration state output is useful to determine if everything is configured properly when diagnosing runtime errors.  This service will find all configurations, and output a redacted version with all secrets removed.  The default pattern for secrets is `/password|private|secret/i`.  More values can be added in your configuration under the path `config.secrets`.  These values can either be simple strings (for exact match), or `/pattern/` to create a regular expression.
+At startup, the [ConfigurationService](https://github.com/travetto/travetto/tree/main/module/config/src/service.ts#L24) service will log out all the registered configuration objects. The configuration state output is useful to determine if everything is configured properly when diagnosing runtime errors. This service will find all configurations, and output a redacted version with all secrets removed. The default pattern for secrets is `/password|private|secret/i`. More values can be added in your configuration under the path `config.secrets`. These values can either be simple strings (for exact match), or `/pattern/` to create a regular expression.
 
 ## Consuming
-The [ConfigurationService](https://github.com/travetto/travetto/tree/main/module/config/src/service.ts#L24) service provides injectable access to all of the loaded configuration. For simplicity, a decorator, [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) allows for classes to automatically be bound with config information on post construction via the [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.") module. The decorator will install a `postConstruct` method if not already defined, that performs the binding of configuration.  This is due to the fact that we cannot rewrite the constructor, and order of operation matters.
+The [ConfigurationService](https://github.com/travetto/travetto/tree/main/module/config/src/service.ts#L24) service provides injectable access to all of the loaded configuration. For simplicity, a decorator, [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L13) allows for classes to automatically be bound with config information on post construction via the [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.") module. The decorator will install a `postConstruct` method if not already defined, that performs the binding of configuration. This is due to the fact that we cannot rewrite the constructor, and order of operation matters.
 
 ### Environment Variables
-Additionally there are times in which you may want to also support configuration via environment variables.  [@EnvVar](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L36) supports override configuration values when environment variables are present. 
+Additionally there are times in which you may want to also support configuration via environment variables. [@EnvVar](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L36) supports override configuration values when environment variables are present. 
 
 The decorator takes in a namespace, of what part of the resolved configuration you want to bind to your class. Given the following class:
 
@@ -231,7 +232,7 @@ $ trv main doc/dbconfig-run.ts
 }
 ```
 
-What you see, is that the configuration structure must be honored and the application will fail to start if the constraints do not hold true.  This helps to ensure that the configuration, as input to the system, is verified and correct. 
+What you see, is that the configuration structure must be honored and the application will fail to start if the constraints do not hold true. This helps to ensure that the configuration, as input to the system, is verified and correct. 
 
 By passing in the port via the environment variable, the config will construct properly, and the application will startup correctly:
 

package/__index__.ts

@@ -1,12 +1,13 @@
-import type { } from './src/trv.d.ts';
+import type {} from './src/trv.d.ts';
+
 export * from './src/decorator.ts';
+export * from './src/parser/json.ts';
+export * from './src/parser/properties.ts';
+export * from './src/parser/types.ts';
+export * from './src/parser/yaml.ts';
 export * from './src/service.ts';
 export * from './src/source/env.ts';
 export * from './src/source/file.ts';
-export * from './src/parser/json.ts';
-export * from './src/parser/types.ts';
-export * from './src/parser/properties.ts';
-export * from './src/source/override.ts';
 export * from './src/source/memory.ts';
+export * from './src/source/override.ts';
 export * from './src/source/types.ts';
-export * from './src/parser/yaml.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/config",
-  "version": "8.0.0-alpha.20",
+  "version": "8.0.0-alpha.22",
   "type": "module",
   "description": "Configuration support",
   "keywords": [
@@ -27,8 +27,8 @@
     "directory": "module/config"
   },
   "dependencies": {
-    "@travetto/di": "^8.0.0-alpha.19",
-    "@travetto/schema": "^8.0.0-alpha.20",
+    "@travetto/di": "^8.0.0-alpha.20",
+    "@travetto/schema": "^8.0.0-alpha.22",
     "yaml": "^2.9.0"
   },
   "travetto": {

package/src/decorator.ts

@@ -1,9 +1,9 @@
-import { type Class, type ClassInstance, getClass } from '@travetto/runtime';
 import { DependencyRegistryIndex } from '@travetto/di';
+import { type Class, type ClassInstance, getClass } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
-import { ConfigurationService, ConfigBaseType } from './service.ts';
 import { ConfigOverrideUtil } from './override.ts';
+import { ConfigBaseType, ConfigurationService } from './service.ts';
 
 /**
  * Indicates that the given class should be populated with the configured fields, on instantiation
@@ -37,4 +37,4 @@ export function EnvVar(name: string, ...others: string[]) {
   return (instance: ClassInstance, property: string): void => {
     ConfigOverrideUtil.setOverrideConfigField(getClass(instance), property, [name, ...others]);
   };
-}
+}

package/src/override.ts

@@ -8,7 +8,7 @@ export const OverrideConfigSymbol = Symbol.for('@travetto/config:overrides');
  */
 export type OverrideConfig = {
   namespace?: string;
-  fields?: Record<string, () => (unknown | undefined)>;
+  fields?: Record<string, () => unknown | undefined>;
 };
 
 /**
@@ -23,7 +23,7 @@ export class ConfigOverrideUtil {
     const out: Required<OverrideConfig>[] = [];
     for (const cls of SchemaRegistryIndex.getClasses()) {
       const config = this.getOverrideConfig(cls);
-      if (config && config.fields && config.namespace) {
+      if (config?.fields && config.namespace) {
         out.push(asFull(config));
       }
     }
@@ -31,14 +31,12 @@ export class ConfigOverrideUtil {
   }
 
   static setOverrideConfigField(cls: Class<Any>, field: string, names: string[]): void {
-    const env = SchemaRegistryIndex.getForRegister(cls)
-      .registerMetadata<OverrideConfig>(OverrideConfigSymbol, {});
+    const env = SchemaRegistryIndex.getForRegister(cls).registerMetadata<OverrideConfig>(OverrideConfigSymbol, {});
 
-    (env.fields ??= {})[field] = (): string | undefined =>
-      process.env[names.find(name => !!process.env[name])!];
+    (env.fields ??= {})[field] = (): string | undefined => process.env[names.find(name => !!process.env[name])!];
   }
 
   static setOverrideConfig(cls: Class<Any>, namespace: string): void {
     SchemaRegistryIndex.getForRegister(cls).registerMetadata<OverrideConfig>(OverrideConfigSymbol, { namespace });
   }
-}
+}

package/src/parser/json.ts

@@ -7,4 +7,4 @@ import type { ConfigParser } from './types.ts';
 export class JSONConfigParser implements ConfigParser {
   ext = ['.json'];
   parse = JSONUtil.fromUTF8;
-}
+}

package/src/parser/parser.ts

@@ -8,7 +8,6 @@ import type { ConfigData, ConfigParser } from './types.ts';
 
 @Injectable()
 export class ParserManager {
-
   #extMatch: RegExp;
   #parsers: Record<string, ConfigParser>;
 
@@ -38,4 +37,4 @@ export class ParserManager {
   matches(file: string): boolean {
     return this.#extMatch.test(file);
   }
-}
+}

package/src/parser/properties.ts

@@ -10,7 +10,6 @@ const EXCL = '!'.charCodeAt(0);
 
 @Injectable()
 export class PropertiesConfigParser implements ConfigParser {
-
   static parseLine(text: string): [key: string, value: string] | undefined {
     if (text.charCodeAt(0) === HASH || text.charCodeAt(0) === EXCL) {
       return;
@@ -19,11 +18,12 @@ export class PropertiesConfigParser implements ConfigParser {
     let value: string | undefined;
     for (let i = 0; i < text.length; i += 1) {
       const ch = text.charCodeAt(i);
-      if (ch === EQUALS || ch === COLON) { // Break
+      if (ch === EQUALS || ch === COLON) {
+        // Break
         value = text.substring(i + 1).trimStart();
         break;
       } else if (ch === BACKSLASH) {
-        key.push(text.charCodeAt(i += 1));
+        key.push(text.charCodeAt((i += 1)));
       } else {
         key.push(ch);
       }
@@ -42,7 +42,7 @@ export class PropertiesConfigParser implements ConfigParser {
     for (let i = 0; i < lines.length; i++) {
       let line = lines[i];
       while (i < lines.length && line.endsWith('\\')) {
-        line = `${line.replace(/[\\]$/, '')}${lines[i += 1].trimStart()}`;
+        line = `${line.replace(/[\\]$/, '')}${lines[(i += 1)].trimStart()}`;
       }
       const entry = PropertiesConfigParser.parseLine(line);
       if (entry) {
@@ -51,4 +51,4 @@ export class PropertiesConfigParser implements ConfigParser {
     }
     return out;
   }
-}
+}

package/src/parser/yaml.ts

@@ -1,9 +1,11 @@
 import { parse as parseYaml } from 'yaml';
+
 import { Injectable } from '@travetto/di';
+
 import type { ConfigData, ConfigParser } from './types.ts';
 
 @Injectable()
 export class YAMLConfigParser implements ConfigParser {
   ext = ['.yaml', '.yml'];
   parse = (input: string): ConfigData => parseYaml(input) ?? {};
-}
+}

package/src/service.ts

@@ -1,29 +1,28 @@
 import util from 'node:util';
 
-import { RuntimeError, toConcrete, castTo, type Class, Env, Runtime, RuntimeResources, getClass } from '@travetto/runtime';
 import { DependencyRegistryIndex, getDefaultQualifier, Injectable, PostConstruct } from '@travetto/di';
+import { type Class, castTo, Env, getClass, Runtime, RuntimeError, RuntimeResources, toConcrete } from '@travetto/runtime';
 import { BindUtil, DataUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError } from '@travetto/schema';
 
 import { ParserManager } from './parser/parser.ts';
 import type { ConfigData } from './parser/types.ts';
-import type { ConfigSource, ConfigPayload } from './source/types.ts';
 import { FileConfigSource } from './source/file.ts';
 import { OverrideConfigSource } from './source/override.ts';
+import type { ConfigPayload, ConfigSource } from './source/types.ts';
 
 type ConfigSpecSimple = Omit<ConfigPayload, 'data'>;
 
 /**
  * Common Type for all configuration classes
  */
-export class ConfigBaseType { }
+export class ConfigBaseType {}
 
 /**
  * Manager for application configuration
  */
 @Injectable()
 export class ConfigurationService {
-
-  #storage: Record<string, unknown> = {};   // Lowered, and flattened
+  #storage: Record<string, unknown> = {}; // Lowered, and flattened
   #payloads: ConfigSpecSimple[] = [];
   #secrets: (RegExp | string)[] = [/secure(-|_|[a-z])|password|private|secret|salt|(\bkey|key\b)|serviceAccount|(api(-|_)?key)/i];
 
@@ -32,7 +31,7 @@ export class ConfigurationService {
    * @param namespace The namespace of the config to search for, can be dotted for accessing sub namespaces
    */
   #get<T extends Record<string, unknown> = Record<string, unknown>>(namespace?: string): T {
-    const parts = (namespace ? namespace.split('.') : []);
+    const parts = namespace ? namespace.split('.') : [];
     let sub: Record<string, unknown> = this.#storage;
 
     while (parts.length && sub) {
@@ -54,16 +53,16 @@ export class ConfigurationService {
     const providers = DependencyRegistryIndex.getCandidates(toConcrete<ConfigSource>());
 
     const configs = await Promise.all(
-      providers.map(async (candidate) => await DependencyRegistryIndex.getInstance<ConfigSource>(candidate.candidateType, candidate.qualifier))
+      providers.map(
+        async candidate => await DependencyRegistryIndex.getInstance<ConfigSource>(candidate.candidateType, candidate.qualifier)
+      )
     );
 
     const parser = await DependencyRegistryIndex.getInstance(ParserManager);
 
-    const possible = await Promise.all([
-      new FileConfigSource(parser),
-      ...configs,
-      new OverrideConfigSource()
-    ].map(async source => source.get()));
+    const possible = await Promise.all(
+      [new FileConfigSource(parser), ...configs, new OverrideConfigSource()].map(async source => source.get())
+    );
 
     const payloads = possible
       .flat()
@@ -93,7 +92,7 @@ export class ConfigurationService {
    * Export all active configuration, useful for displaying active state
    *   - Will not show fields marked as secret
    */
-  async exportActive(): Promise<{ sources: ConfigSpecSimple[], active: ConfigData }> {
+  async exportActive(): Promise<{ sources: ConfigSpecSimple[]; active: ConfigData }> {
     const configTargets = DependencyRegistryIndex.getCandidates(ConfigBaseType);
     const configs = await Promise.all(
       configTargets
@@ -106,9 +105,10 @@ export class ConfigurationService {
     );
     const out: Record<string, ConfigData> = {};
     for (const [candidate, inst] of configs) {
-      const data = BindUtil.bindSchemaToObject<ConfigData>(
-        getClass(inst), {}, inst, { filterInput: field => !('secret' in field) || !field.secret, filterValue: value => value !== undefined }
-      );
+      const data = BindUtil.bindSchemaToObject<ConfigData>(getClass(inst), {}, inst, {
+        filterInput: field => !('secret' in field) || !field.secret,
+        filterValue: value => value !== undefined
+      });
       out[candidate.candidateType.name] = DataUtil.filterByKeys(data, this.#secrets);
     }
     return { sources: this.#payloads, active: out };
@@ -144,23 +144,26 @@ export class ConfigurationService {
    * Produce the visible configuration state and runtime information
    */
   async initBanner(): Promise<string> {
-    return util.inspect({
-      manifest: {
-        main: Runtime.main,
-        workspace: Runtime.workspace
-      },
-      runtime: {
-        production: Runtime.production,
-        role: Runtime.role,
-        debug: Runtime.debug,
-        resourcePaths: RuntimeResources.searchPaths,
-        profiles: Env.TRV_PROFILES.list ?? []
+    return util.inspect(
+      {
+        manifest: {
+          main: Runtime.main,
+          workspace: Runtime.workspace
+        },
+        runtime: {
+          production: Runtime.production,
+          role: Runtime.role,
+          debug: Runtime.debug,
+          resourcePaths: RuntimeResources.searchPaths,
+          profiles: Env.TRV_PROFILES.list ?? []
+        },
+        config: await this.exportActive()
       },
-      config: await this.exportActive()
-    }, {
-      ...util.inspect.defaultOptions,
-      depth: 100,
-      colors: false, // Colors are not useful in logs
-    });
+      {
+        ...util.inspect.defaultOptions,
+        depth: 100,
+        colors: false // Colors are not useful in logs
+      }
+    );
   }
-}
+}

package/src/source/env.ts

@@ -1,5 +1,6 @@
 import { JSONUtil } from '@travetto/runtime';
-import type { ConfigSource, ConfigPayload } from './types.ts';
+
+import type { ConfigPayload, ConfigSource } from './types.ts';
 
 /**
  * Represents the environment mapped data as a JSON blob
@@ -21,4 +22,4 @@ export class EnvConfigSource implements ConfigSource {
       console.error(`env.${this.#envKey} is an invalid format`, { text: process.env[this.#envKey] });
     }
   }
-}
+}

package/src/source/file.ts

@@ -3,8 +3,8 @@ import path from 'node:path';
 
 import { Env, Runtime, RuntimeResources } from '@travetto/runtime';
 
-import type { ConfigSource, ConfigPayload } from './types.ts';
 import type { ParserManager } from '../parser/parser.ts';
+import type { ConfigPayload, ConfigSource } from './types.ts';
 
 type Profile = [string, number] | readonly [string, number];
 
@@ -12,11 +12,8 @@ type Profile = [string, number] | readonly [string, number];
  * File-based config source, relies on resource search paths for finding files
  */
 export class FileConfigSource implements ConfigSource {
-
   static getProfiles(): Profile[] {
-    const profiles: Profile[] = [
-      ['application', 100]
-    ];
+    const profiles: Profile[] = [['application', 100]];
     if (Runtime.role === 'std') {
       if (Runtime.localDevelopment) {
         profiles.push(['local', 200]);
@@ -24,8 +21,7 @@ export class FileConfigSource implements ConfigSource {
     } else {
       profiles.push([Runtime.role, 200]);
     }
-    profiles.push(...(Env.TRV_PROFILES.list ?? [])
-      .map((profile, i) => [profile, 300 + i * 10] as const));
+    profiles.push(...(Env.TRV_PROFILES.list ?? []).map((profile, i) => [profile, 300 + i * 10] as const));
     return profiles;
   }
 
@@ -51,16 +47,18 @@ export class FileConfigSource implements ConfigSource {
           if (this.#parser.matches(file) && path.basename(file, path.extname(file)) === profile) {
             const full = path.resolve(folder, file);
             const configPriority = i++;
-            configs.push(this.#parser.parse(full).then(data => ({
-              data,
-              priority: configPriority,
-              source: `file://${profile}`,
-              detail: Runtime.stripWorkspacePath(full)
-            })));
+            configs.push(
+              this.#parser.parse(full).then(data => ({
+                data,
+                priority: configPriority,
+                source: `file://${profile}`,
+                detail: Runtime.stripWorkspacePath(full)
+              }))
+            );
           }
         }
       }
     }
     return Promise.all(configs);
   }
-}
+}

package/src/source/memory.ts

@@ -1,5 +1,5 @@
 import type { ConfigData } from '../parser/types.ts';
-import type { ConfigSource, ConfigPayload } from './types.ts';
+import type { ConfigPayload, ConfigSource } from './types.ts';
 
 /**
  * Meant to be instantiated and provided as a unique config source
@@ -14,4 +14,4 @@ export class MemoryConfigSource implements ConfigSource {
   get(): ConfigPayload {
     return this.#payload;
   }
-}
+}

package/src/source/override.ts

@@ -1,6 +1,6 @@
-import type { ConfigData } from '../parser/types.ts';
-import type { ConfigSource, ConfigPayload } from './types.ts';
 import { ConfigOverrideUtil } from '../override.ts';
+import type { ConfigData } from '../parser/types.ts';
+import type { ConfigPayload, ConfigSource } from './types.ts';
 
 /**
  * Overridable config source, provides ability to override field level values, currently used by
@@ -23,4 +23,4 @@ export class OverrideConfigSource implements ConfigSource {
   get(): ConfigPayload {
     return { data: this.#build(), priority: 999, source: 'memory://override' };
   }
-}
+}

package/src/source/types.ts

@@ -3,11 +3,11 @@ import type { ConfigData } from '../parser/types.ts';
 type OrProm<T> = T | Promise<T>;
 type OneOf<T> = T[] | T | undefined;
 
-export type ConfigPayload = { data: ConfigData, priority: number, source: string, detail?: string };
+export type ConfigPayload = { data: ConfigData; priority: number; source: string; detail?: string };
 
 /**
  * @concrete
  */
 export interface ConfigSource {
   get(): OrProm<OneOf<ConfigPayload>>;
-}
+}