@travetto/config 6.0.0-rc.1 → 6.0.0

package/README.md

@@ -13,18 +13,20 @@ 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#L14)-based classes, all the standard [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L14) and [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L25) 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#L13)-based classes, all the standard [@Schema](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/schema.ts#L13) and [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L25) functionality applies.
 
 ## Resolution
 The configuration information is comprised of:
    *  configuration files - [YAML](https://en.wikipedia.org/wiki/YAML), [JSON](https://www.json.org), and basic properties file
    *  configuration classes
+
 Config loading follows a defined resolution path, below is the order in increasing specificity (`ext` can be `yaml`, `yml`, `json`, `properties`):
    1. `resources/application.<ext>` - Priority `100` - Load the default `application.<ext>` if available.
    1. `resources/{env}.<ext>` - Priority `200` - Load environment specific profile configurations as defined by the values of `process.env.TRV_ENV`.
    1. `resources/*.<ext>` - Priority `300` - Load profile specific configurations as defined by the values in `process.env.TRV_PROFILES`
    1. [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) [ConfigSource](https://github.com/travetto/travetto/tree/main/module/config/src/source/types.ts#L11) - Priority `???` - These are custom config sources provided by the module, and are able to define their own priorities
-   1. [OverrideConfigSource](https://github.com/travetto/travetto/tree/main/module/config/src/source/override.ts#L11) - Priority `999` - This is for [EnvVar](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L34) overrides, and is at the top priority for all built-in config sources.
+   1. [OverrideConfigSource](https://github.com/travetto/travetto/tree/main/module/config/src/source/override.ts#L20) - Priority `999` - This is for [EnvVar](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L34) overrides, and is at the top priority for all built-in config sources.
+
 By default all configuration data is inert, and will only be applied when constructing an instance of a configuration class.
 
 ### Mono Repo Support
@@ -101,8 +103,8 @@ The framework provides two simple base classes that assist with existing pattern
 
 **Code: Memory Provider**
 ```typescript
-import { ConfigData } from '../parser/types';
-import { ConfigSource, ConfigSpec } from './types';
+import { ConfigData } from '../parser/types.ts';
+import { ConfigSource, ConfigSpec } from './types.ts';
 
 /**
  * Meant to be instantiated and provided as a unique config source
@@ -122,7 +124,7 @@ export class MemoryConfigSource implements ConfigSource {
 
 **Code: Environment JSON Provider**
 ```typescript
-import { ConfigSource, ConfigSpec } from './types';
+import { ConfigSource, ConfigSpec } from './types.ts';
 
 /**
  * Represents the environment mapped data as a JSON blob
@@ -148,29 +150,30 @@ 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#L20) 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 { ConfigData, ConfigSource } from '@travetto/config';
+import { ConfigSource, ConfigSpec } from '@travetto/config';
 import { Injectable } from '@travetto/di';
 
 @Injectable()
 export class CustomConfigSource implements ConfigSource {
-  priority = 2000;
-  source = 'custom://override';
-
-  async getData(): Promise<ConfigData> {
-    return { user: { name: 'bob' } };
+  async get(): Promise<ConfigSpec> {
+    return {
+      data: { user: { name: 'bob' } },
+      source: 'custom://override',
+      priority: 2000
+    };
   }
 }
 ```
 
 ## Startup
-At startup, the [ConfigurationService](https://github.com/travetto/travetto/tree/main/module/config/src/service.ts#L20) 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#L20) 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#L34) supports override configuration values when environment variables are present. 

package/__index__.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/config",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0",
   "description": "Configuration support",
   "keywords": [
     "yaml",
@@ -26,9 +26,9 @@
     "directory": "module/config"
   },
   "dependencies": {
-    "@travetto/di": "^6.0.0-rc.1",
-    "@travetto/schema": "^6.0.0-rc.1",
-    "yaml": "^2.7.0"
+    "@travetto/di": "^6.0.0",
+    "@travetto/schema": "^6.0.0",
+    "yaml": "^2.7.1"
   },
   "travetto": {
     "displayName": "Configuration"

package/src/decorator.ts

@@ -2,8 +2,8 @@ import { Class, ClassInstance } from '@travetto/runtime';
 import { DependencyRegistry } from '@travetto/di';
 import { SchemaRegistry } from '@travetto/schema';
 
-import { ConfigurationService } from './service';
-import { ConfigTarget, ConfigOverrides, CONFIG_OVERRIDES } from './internal/types';
+import { OverrideConfig, OverrideConfigSymbol } from './source/override.ts';
+import { ConfigurationService, ConfigBaseType } from './service.ts';
 
 /**
  * Indicates that the given class should be populated with the configured fields, on instantiation
@@ -14,8 +14,8 @@ export function Config(ns: string) {
   return <T extends Class>(target: T): T => {
     const og: Function = target.prototype.postConstruct;
     // Declare as part of global config
-    (DependencyRegistry.getOrCreatePending(target).interfaces ??= []).push(ConfigTarget);
-    const env = SchemaRegistry.getOrCreatePendingMetadata<ConfigOverrides>(target, CONFIG_OVERRIDES, { ns, fields: {} });
+    (DependencyRegistry.getOrCreatePending(target).interfaces ??= []).push(ConfigBaseType);
+    const env = SchemaRegistry.getOrCreatePendingMetadata<OverrideConfig>(target, OverrideConfigSymbol, { ns, fields: {} });
     env.ns = ns;
 
     target.prototype.postConstruct = async function (): Promise<void> {
@@ -31,9 +31,10 @@ export function Config(ns: string) {
 /**
  * Allows for binding specific fields to environment variables as a top-level override
  */
-export function EnvVar(name: string) {
+export function EnvVar(name: string, ...others: string[]) {
   return (inst: ClassInstance, prop: string): void => {
-    const env = SchemaRegistry.getOrCreatePendingMetadata<ConfigOverrides>(inst.constructor, CONFIG_OVERRIDES, { ns: '', fields: {} });
-    env.fields[prop] = (): string | undefined => process.env[name];
+    const env = SchemaRegistry.getOrCreatePendingMetadata<OverrideConfig>(inst.constructor, OverrideConfigSymbol, { ns: '', fields: {} });
+    env.fields[prop] = (): string | undefined =>
+      process.env[[name, ...others].find(x => !!process.env[x])!];
   };
 }

package/src/parser/json.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@travetto/di';
 
-import { ConfigParser } from './types';
+import { ConfigParser } from './types.ts';
 
 @Injectable()
 export class JSONConfigParser implements ConfigParser {

package/src/parser/parser.ts

@@ -2,10 +2,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 import { DependencyRegistry, Injectable } from '@travetto/di';
-import { AppError } from '@travetto/runtime';
+import { AppError, toConcrete } from '@travetto/runtime';
 
-import { ConfigParserTarget } from '../internal/types';
-import { ConfigData, ConfigParser } from './types';
+import { ConfigData, ConfigParser } from './types.ts';
 
 @Injectable()
 export class ParserManager {
@@ -14,8 +13,7 @@ export class ParserManager {
   #parsers: Record<string, ConfigParser>;
 
   async postConstruct(): Promise<void> {
-    const parserClasses = await DependencyRegistry.getCandidateTypes(ConfigParserTarget);
-    const parsers = await Promise.all(parserClasses.map(x => DependencyRegistry.getInstance<ConfigParser>(x.class, x.qualifier)));
+    const parsers = await DependencyRegistry.getCandidateInstances(toConcrete<ConfigParser>());
 
     // Register parsers
     this.#parsers = Object.fromEntries(parsers.flatMap(p => p.ext.map(e => [e, p])));

package/src/parser/properties.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@travetto/di';
 
-import { ConfigData, ConfigParser } from './types';
+import { ConfigData, ConfigParser } from './types.ts';
 
 const BACKSLASH = '\\'.charCodeAt(0);
 const EQUALS = '='.charCodeAt(0);

package/src/parser/types.ts

@@ -1,7 +1,7 @@
 export type ConfigData = Record<string, unknown>;
 
 /**
- * @concrete ../internal/types#ConfigParserTarget
+ * @concrete
  */
 export interface ConfigParser {
   ext: string[];

package/src/parser/yaml.ts

@@ -1,6 +1,6 @@
 import { parse as parseYaml } from 'yaml';
 import { Injectable } from '@travetto/di';
-import { ConfigData, ConfigParser } from './types';
+import { ConfigData, ConfigParser } from './types.ts';
 
 @Injectable()
 export class YAMLConfigParser implements ConfigParser {

package/src/service.ts

@@ -1,18 +1,22 @@
 import util from 'node:util';
 
-import { AppError, castTo, Class, ClassInstance, Env, Runtime, RuntimeResources } from '@travetto/runtime';
+import { AppError, toConcrete, castTo, Class, ClassInstance, Env, Runtime, RuntimeResources } from '@travetto/runtime';
 import { DependencyRegistry, Injectable } from '@travetto/di';
 import { BindUtil, DataUtil, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
 
-import { ConfigSourceTarget, ConfigTarget } from './internal/types';
-import { ParserManager } from './parser/parser';
-import { ConfigData } from './parser/types';
-import { ConfigSource, ConfigSpec } from './source/types';
-import { FileConfigSource } from './source/file';
-import { OverrideConfigSource } from './source/override';
+import { ParserManager } from './parser/parser.ts';
+import { ConfigData } from './parser/types.ts';
+import { ConfigSource, ConfigSpec } from './source/types.ts';
+import { FileConfigSource } from './source/file.ts';
+import { OverrideConfigSource } from './source/override.ts';
 
 type ConfigSpecSimple = Omit<ConfigSpec, 'data'>;
 
+/**
+ * Common Type for all configuration classes
+ */
+export class ConfigBaseType { }
+
 /**
  * Manager for application configuration
  */
@@ -46,10 +50,10 @@ export class ConfigurationService {
    *  - If of the same priority, then alpha sort on the source
    */
   async postConstruct(): Promise<void> {
-    const providers = await DependencyRegistry.getCandidateTypes(ConfigSourceTarget);
+    const providers = await DependencyRegistry.getCandidateTypes(toConcrete<ConfigSource>());
 
     const configs = await Promise.all(
-      providers.map(async (el) => await DependencyRegistry.getInstance<ConfigSource>(el.class, el.qualifier))
+      providers.map(async (el) => await DependencyRegistry.getInstance(el.class, el.qualifier))
     );
 
     const parser = await DependencyRegistry.getInstance(ParserManager);
@@ -63,13 +67,13 @@ export class ConfigurationService {
     const specs = possible
       .flat()
       .filter(x => !!x)
-      .sort((a, b) => a.priority - b.priority);
+      .toSorted((a, b) => a.priority - b.priority);
 
     for (const spec of specs) {
       DataUtil.deepAssign(this.#storage, BindUtil.expandPaths(spec.data), 'coerce');
     }
 
-    this.#specs = specs.map(({ data, ...v }) => v);
+    this.#specs = specs.map(({ data: _, ...v }) => v);
 
     // Initialize Secrets
     const userSpecified = (this.#get('config')?.secrets ?? []);
@@ -89,11 +93,11 @@ export class ConfigurationService {
    *   - Will not show fields marked as secret
    */
   async exportActive(): Promise<{ sources: ConfigSpecSimple[], active: ConfigData }> {
-    const configTargets = await DependencyRegistry.getCandidateTypes(ConfigTarget);
+    const configTargets = await DependencyRegistry.getCandidateTypes(ConfigBaseType);
     const configs = await Promise.all(
       configTargets
         .filter(el => el.qualifier === DependencyRegistry.get(el.class).qualifier) // Is primary?
-        .sort((a, b) => a.class.name.localeCompare(b.class.name))
+        .toSorted((a, b) => a.class.name.localeCompare(b.class.name))
         .map(async el => {
           const inst = await DependencyRegistry.getInstance<ClassInstance>(el.class, el.qualifier);
           return [el, inst] as const;

package/src/source/env.ts

@@ -1,4 +1,4 @@
-import { ConfigSource, ConfigSpec } from './types';
+import { ConfigSource, ConfigSpec } from './types.ts';
 
 /**
  * Represents the environment mapped data as a JSON blob

package/src/source/file.ts

@@ -3,8 +3,8 @@ import path from 'node:path';
 
 import { Env, Runtime, RuntimeResources } from '@travetto/runtime';
 
-import { ConfigSource, ConfigSpec } from './types';
-import { ParserManager } from '../parser/parser';
+import { ConfigSource, ConfigSpec } from './types.ts';
+import { ParserManager } from '../parser/parser.ts';
 
 type Profile = [string, number] | readonly [string, number];
 
@@ -19,7 +19,7 @@ export class FileConfigSource implements ConfigSource {
 
   constructor(parser: ParserManager) {
     this.#parser = parser;
-    this.#searchPaths = RuntimeResources.searchPaths.slice().reverse();
+    this.#searchPaths = RuntimeResources.searchPaths.toReversed();
     this.#profiles = ([
       ['application', 100],
       [Runtime.env!, 200],

package/src/source/memory.ts

@@ -1,5 +1,5 @@
-import { ConfigData } from '../parser/types';
-import { ConfigSource, ConfigSpec } from './types';
+import { ConfigData } from '../parser/types.ts';
+import { ConfigSource, ConfigSpec } from './types.ts';
 
 /**
  * Meant to be instantiated and provided as a unique config source

package/src/source/override.ts

@@ -1,8 +1,17 @@
 import { SchemaRegistry } from '@travetto/schema';
 
-import { ConfigOverrides, CONFIG_OVERRIDES } from '../internal/types';
-import { ConfigData } from '../parser/types';
-import { ConfigSource, ConfigSpec } from './types';
+import { ConfigData } from '../parser/types.ts';
+import { ConfigSource, ConfigSpec } from './types.ts';
+
+export const OverrideConfigSymbol = Symbol.for('@travetto/config:overrides');
+
+/**
+ * Configuration Override
+ */
+export type OverrideConfig = {
+  ns: string;
+  fields: Record<string, () => (unknown | undefined)>;
+};
 
 /**
  * Overridable config source, provides ability to override field level values, currently used by
@@ -12,7 +21,7 @@ export class OverrideConfigSource implements ConfigSource {
   #build(): ConfigData {
     const out: ConfigData = {};
     for (const cls of SchemaRegistry.getClasses()) {
-      const { ns, fields = {} } = SchemaRegistry.getMetadata<ConfigOverrides>(cls, CONFIG_OVERRIDES) ?? {};
+      const { ns, fields = {} } = SchemaRegistry.getMetadata<OverrideConfig>(cls, OverrideConfigSymbol) ?? {};
       for (const [key, value] of Object.entries(fields)) {
         const val = value();
         if (val !== undefined && val !== '') {

package/src/source/types.ts

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

package/src/internal/types.ts

@@ -1,10 +0,0 @@
-export abstract class ConfigSourceTarget { }
-export abstract class ConfigTarget { }
-export abstract class ConfigParserTarget { }
-
-export const CONFIG_OVERRIDES = Symbol.for('@travetto/config:field-override');
-
-export type ConfigOverrides = {
-  ns: string;
-  fields: Record<string, () => (unknown | undefined)>;
-};