@travetto/config 6.0.1 → 7.0.0-rc.1

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#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.
+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#L21) functionality applies.
 
 ## Resolution
 The configuration information is comprised of:
@@ -24,8 +24,8 @@ Config loading follows a defined resolution path, below is the order in increasi
    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#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.
+   1. [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) [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#L9) - Priority `999` - This is for [@EnvVar](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L37) 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.
 
@@ -176,7 +176,7 @@ At startup, the [ConfigurationService](https://github.com/travetto/travetto/tree
 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. 
+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#L37) 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:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/config",
-  "version": "6.0.1",
+  "version": "7.0.0-rc.1",
   "description": "Configuration support",
   "keywords": [
     "yaml",
@@ -26,8 +26,8 @@
     "directory": "module/config"
   },
   "dependencies": {
-    "@travetto/di": "^6.0.1",
-    "@travetto/schema": "^6.0.1",
+    "@travetto/di": "^7.0.0-rc.1",
+    "@travetto/schema": "^7.0.0-rc.1",
     "yaml": "^2.8.1"
   },
   "travetto": {

package/src/decorator.ts

@@ -1,40 +1,41 @@
-import { Class, ClassInstance } from '@travetto/runtime';
-import { DependencyRegistry } from '@travetto/di';
-import { SchemaRegistry } from '@travetto/schema';
+import { Class, ClassInstance, getClass } from '@travetto/runtime';
+import { DependencyRegistryIndex } from '@travetto/di';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
-import { OverrideConfig, OverrideConfigSymbol } from './source/override.ts';
 import { ConfigurationService, ConfigBaseType } from './service.ts';
+import { ConfigOverrideUtil } from './util.ts';
 
 /**
  * Indicates that the given class should be populated with the configured fields, on instantiation
  * @augments `@travetto/schema:Schema`
- * @augments `@travetto/di:Injectable`
+ * @kind decorator
  */
 export function Config(ns: string) {
-  return <T extends Class>(target: T): T => {
-    const og: Function = target.prototype.postConstruct;
+  return <T extends Class>(cls: T): T => {
     // Declare as part of global config
-    (DependencyRegistry.getOrCreatePending(target).interfaces ??= []).push(ConfigBaseType);
-    const env = SchemaRegistry.getOrCreatePendingMetadata<OverrideConfig>(target, OverrideConfigSymbol, { ns, fields: {} });
-    env.ns = ns;
+    SchemaRegistryIndex.getForRegister(cls).register({ interfaces: [ConfigBaseType] });
 
-    target.prototype.postConstruct = async function (): Promise<void> {
+    ConfigOverrideUtil.setOverrideConfig(cls, ns);
+
+    DependencyRegistryIndex.getForRegister(cls).registerClass();
+
+    const og: Function = cls.prototype.postConstruct;
+    cls.prototype.postConstruct = async function (): Promise<void> {
       // Apply config
-      const cfg = await DependencyRegistry.getInstance(ConfigurationService);
-      await cfg.bindTo(target, this, ns);
+      const cfg = await DependencyRegistryIndex.getInstance(ConfigurationService);
+      await cfg.bindTo(cls, this, ns);
       await og?.call(this);
     };
-    return target;
+    return cls;
   };
 }
 
 /**
  * Allows for binding specific fields to environment variables as a top-level override
+ * @kind decorator
  */
 export function EnvVar(name: string, ...others: string[]) {
-  return (inst: ClassInstance, prop: string): void => {
-    const env = SchemaRegistry.getOrCreatePendingMetadata<OverrideConfig>(inst.constructor, OverrideConfigSymbol, { ns: '', fields: {} });
-    env.fields[prop] = (): string | undefined =>
-      process.env[[name, ...others].find(x => !!process.env[x])!];
+  return (instance: ClassInstance, property: string): void => {
+    ConfigOverrideUtil.setOverrideConfigField(getClass(instance), property, [name, ...others]);
   };
 }

package/src/parser/parser.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { DependencyRegistry, Injectable } from '@travetto/di';
+import { DependencyRegistryIndex, Injectable } from '@travetto/di';
 import { AppError, toConcrete } from '@travetto/runtime';
 
 import { ConfigData, ConfigParser } from './types.ts';
@@ -13,7 +13,7 @@ export class ParserManager {
   #parsers: Record<string, ConfigParser>;
 
   async postConstruct(): Promise<void> {
-    const parsers = await DependencyRegistry.getCandidateInstances(toConcrete<ConfigParser>());
+    const parsers = await DependencyRegistryIndex.getInstances(toConcrete<ConfigParser>());
 
     // Register parsers
     this.#parsers = Object.fromEntries(parsers.flatMap(p => p.ext.map(e => [e, p])));

package/src/service.ts

@@ -1,8 +1,8 @@
 import util from 'node:util';
 
-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 { AppError, toConcrete, castTo, Class, Env, Runtime, RuntimeResources, getClass } from '@travetto/runtime';
+import { DependencyRegistryIndex, getDefaultQualifier, Injectable } from '@travetto/di';
+import { BindUtil, DataUtil, SchemaRegistryIndex, SchemaValidator, ValidationResultError } from '@travetto/schema';
 
 import { ParserManager } from './parser/parser.ts';
 import { ConfigData } from './parser/types.ts';
@@ -50,13 +50,13 @@ export class ConfigurationService {
    *  - If of the same priority, then alpha sort on the source
    */
   async postConstruct(): Promise<void> {
-    const providers = await DependencyRegistry.getCandidateTypes(toConcrete<ConfigSource>());
+    const providers = await DependencyRegistryIndex.getCandidates(toConcrete<ConfigSource>());
 
     const configs = await Promise.all(
-      providers.map(async (el) => await DependencyRegistry.getInstance(el.class, el.qualifier))
+      providers.map(async (el) => await DependencyRegistryIndex.getInstance(el.candidateType, el.qualifier))
     );
 
-    const parser = await DependencyRegistry.getInstance(ParserManager);
+    const parser = await DependencyRegistryIndex.getInstance(ParserManager);
 
     const possible = await Promise.all([
       new FileConfigSource(parser),
@@ -93,22 +93,22 @@ export class ConfigurationService {
    *   - Will not show fields marked as secret
    */
   async exportActive(): Promise<{ sources: ConfigSpecSimple[], active: ConfigData }> {
-    const configTargets = await DependencyRegistry.getCandidateTypes(ConfigBaseType);
+    const configTargets = await DependencyRegistryIndex.getCandidates(ConfigBaseType);
     const configs = await Promise.all(
       configTargets
-        .filter(el => el.qualifier === DependencyRegistry.get(el.class).qualifier) // Is primary?
+        .filter(el => el.qualifier === getDefaultQualifier(el.class)) // Is self targeting?
         .toSorted((a, b) => a.class.name.localeCompare(b.class.name))
         .map(async el => {
-          const inst = await DependencyRegistry.getInstance<ClassInstance>(el.class, el.qualifier);
+          const inst = await DependencyRegistryIndex.getInstance(el.class, el.qualifier);
           return [el, inst] as const;
         })
     );
     const out: Record<string, ConfigData> = {};
     for (const [el, inst] of configs) {
       const data = BindUtil.bindSchemaToObject<ConfigData>(
-        inst.constructor, {}, inst, { filterField: f => !f.secret, filterValue: v => v !== undefined }
+        getClass(inst), {}, inst, { filterInput: f => !('secret' in f) || !f.secret, filterValue: v => v !== undefined }
       );
-      out[el.class.name] = DataUtil.filterByKeys(data, this.#secrets);
+      out[el.candidateType.name] = DataUtil.filterByKeys(data, this.#secrets);
     }
     return { sources: this.#specs, active: out };
   }
@@ -118,7 +118,7 @@ export class ConfigurationService {
    */
   async bindTo<T>(cls: Class<T>, item: T, namespace: string, validate = true): Promise<T> {
     const classId = cls.Ⲑid;
-    if (!SchemaRegistry.has(cls)) {
+    if (!SchemaRegistryIndex.has(cls)) {
       throw new AppError(`${classId} is not a valid schema class, config is not supported`);
     }
     BindUtil.bindSchemaToObject(cls, item, this.#get(namespace));

package/src/source/override.ts

@@ -1,17 +1,6 @@
-import { SchemaRegistry } from '@travetto/schema';
-
 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)>;
-};
+import { ConfigOverrideUtil } from '../util.ts';
 
 /**
  * Overridable config source, provides ability to override field level values, currently used by
@@ -20,12 +9,11 @@ export type OverrideConfig = {
 export class OverrideConfigSource implements ConfigSource {
   #build(): ConfigData {
     const out: ConfigData = {};
-    for (const cls of SchemaRegistry.getClasses()) {
-      const { ns, fields = {} } = SchemaRegistry.getMetadata<OverrideConfig>(cls, OverrideConfigSymbol) ?? {};
+    for (const { namespace, fields } of ConfigOverrideUtil.getAllOverrideConfigs()) {
       for (const [key, value] of Object.entries(fields)) {
         const val = value();
         if (val !== undefined && val !== '') {
-          out[`${ns}.${key}`] = val;
+          out[`${namespace}.${key}`] = val;
         }
       }
     }

package/src/util.ts

@@ -0,0 +1,44 @@
+import { Any, asFull, Class } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
+
+export const OverrideConfigSymbol = Symbol.for('@travetto/config:overrides');
+
+/**
+ * Configuration Override
+ */
+export type OverrideConfig = {
+  namespace?: string;
+  fields?: Record<string, () => (unknown | undefined)>;
+};
+
+/**
+ * Utility for managing override configuration via SchemaRegistryIndex
+ */
+export class ConfigOverrideUtil {
+  static getOverrideConfig(cls: Class<Any>): OverrideConfig | undefined {
+    return SchemaRegistryIndex.get(cls).getMetadata<OverrideConfig>(OverrideConfigSymbol);
+  }
+
+  static getAllOverrideConfigs(): Required<OverrideConfig>[] {
+    const out: Required<OverrideConfig>[] = [];
+    for (const cls of SchemaRegistryIndex.getClasses()) {
+      const cfg = this.getOverrideConfig(cls);
+      if (cfg && cfg.fields && cfg.namespace) {
+        out.push(asFull(cfg));
+      }
+    }
+    return out;
+  }
+
+  static setOverrideConfigField(cls: Class<Any>, field: string, names: string[]): void {
+    const env = SchemaRegistryIndex.getForRegister(cls)
+      .registerMetadata<OverrideConfig>(OverrideConfigSymbol, {});
+
+    (env.fields ??= {})[field] = (): string | undefined =>
+      process.env[names.find(x => !!process.env[x])!];
+  }
+
+  static setOverrideConfig(cls: Class<Any>, namespace: string): void {
+    SchemaRegistryIndex.getForRegister(cls).registerMetadata<OverrideConfig>(OverrideConfigSymbol, { namespace });
+  }
+}