@travetto/config 3.0.0-rc.4 → 3.0.0-rc.7

package/README.md

@@ -1,15 +1,15 @@
 <!-- This file was generated by @travetto/doc and should not be modified directly -->
-<!-- Please modify https://github.com/travetto/travetto/tree/main/module/config/doc.ts and execute "npx trv doc" to rebuild -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/config/DOC.ts and execute "npx trv doc" to rebuild -->
 # Configuration
-## Environment-aware config management using yaml files
+## Configuration support
 
 **Install: @travetto/config**
 ```bash
 npm install @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/travetto/travetto/tree/main/module/yaml#readme "Simple YAML support, provides only clean subset of 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#L9) classes are -based classes, all the standard  and  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/travetto/travetto/tree/main/module/yaml#readme "Simple YAML support, provides only clean subset of 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#L38) functionality applies.
 
 ## Resolution
 
@@ -66,32 +66,40 @@ At runtime the resolved config would be:
 
 **Terminal: Runtime Resolution**
 ```bash
-$ node @travetto/boot/bin/main ./doc/resolve.ts 
+$ trv main support/main.resolve.ts
 
 Config {
-  database: {
-    host: 'localhost',
-    port: 1234,
-    creds: { user: 'test', password: '**********' }
+  sources: [
+    'application.1 - file://application.yml',
+    'override.3 - memory://override'
+  ],
+  active: {
+    DBConfig: {
+      host: 'localhost',
+      port: 2000,
+      creds: creds_7_45Ⲑsyn { user: 'test', password: 'test' }
+    }
   }
 }
+
 ```
 
 ## Secrets
 By default, when in production mode, the application startup will request redacted secrets to log out.  These secrets follow a standard set of rules, but can be amended by listing regular expressions under `config.redacted`.
 
 ## Consuming
-The [ConfigManager](https://github.com/travetto/travetto/tree/main/module/config/src/manager.ts) service provides direct access to all of the loaded configuration. For simplicity, a decorator, [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L9) 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 [Configuration](https://github.com/travetto/travetto/tree/main/module/config/src/configuration.ts#L14) 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 decorator takes in a namespace, of what part of the resolved configuration you want to bind to your class. Given the following class:
 
 **Code: Database config object**
 ```typescript
-import { Config } from '@travetto/config';
+import { Config, EnvVar } from '@travetto/config';
 
 @Config('database')
 export class DBConfig {
   host: string;
+  @EnvVar('DATABASE_PORT')
   port: number;
   creds: {
     user: string;
@@ -104,25 +112,9 @@ Using the above config files, you'll notice that the port is not specified (its
 
 **Terminal: Resolved database config**
 ```bash
-$ node @travetto/boot/bin/main ./doc/dbconfig-run.ts 
-
-{
-  message: 'Failed to construct @trv:config/doc/dbconfig￮DBConfig as validation errors have occurred',
-  category: 'data',
-  type: 'ValidationResultError',
-  at: 2022-03-14T04:00:00.618Z,
-  class: '@trv:config/doc/dbconfig￮DBConfig',
-  file: '@trv:config/doc/dbconfig.ts',
-  errors: [
-    {
-      kind: 'required',
-      value: undefined,
-      message: 'port is required',
-      path: 'port',
-      type: undefined
-    }
-  ]
-}
+$ trv main support/main.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.
@@ -131,13 +123,20 @@ By passing in the port via the environment variable, the config will construct p
 
 **Terminal: Resolved database config**
 ```bash
-$ node @travetto/boot/bin/main ./doc/dbconfig-run.ts 
+$ trv main support/main.dbconfig-run.ts
 
 Config {
-  database: {
-    host: 'localhost',
-    port: 200,
-    creds: { user: 'test', password: 'test' }
+  sources: [
+    'application.1 - file://application.yml',
+    'override.3 - memory://override'
+  ],
+  active: {
+    DBConfig: {
+      host: 'localhost',
+      port: 200,
+      creds: creds_7_45Ⲑsyn { user: 'test', password: 'test' }
+    }
   }
 }
+
 ```

package/__index__.ts

@@ -0,0 +1,10 @@
+export * from './src/decorator';
+export * from './src/configuration';
+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';

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@travetto/config",
-  "displayName": "Configuration",
-  "version": "3.0.0-rc.4",
-  "description": "Environment-aware config management using yaml files",
+  "version": "3.0.0-rc.7",
+  "description": "Configuration support",
   "keywords": [
     "yaml",
     "decorators",
@@ -18,22 +17,21 @@
     "name": "Travetto Framework"
   },
   "files": [
-    "index.ts",
-    "src",
-    "support"
+    "__index__.ts",
+    "src"
   ],
-  "main": "index.ts",
+  "main": "__index__.ts",
   "repository": {
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/config"
   },
   "dependencies": {
-    "@travetto/schema": "^3.0.0-rc.4",
-    "@travetto/transformer": "^3.0.0-rc.4",
-    "@travetto/yaml": "^3.0.0-rc.2"
+    "@travetto/di": "^3.0.0-rc.7",
+    "@travetto/schema": "^3.0.0-rc.7",
+    "@travetto/yaml": "^3.0.0-rc.5"
   },
-  "devDependencies": {
-    "@travetto/di": "^3.0.0-rc.4"
+  "travetto": {
+    "displayName": "Configuration"
   },
   "publishConfig": {
     "access": "public"

package/src/configuration.ts

@@ -0,0 +1,119 @@
+import { AppError, Class, ClassInstance, GlobalEnv, DataUtil } from '@travetto/base';
+import { DependencyRegistry, Injectable } from '@travetto/di';
+import { RootIndex } from '@travetto/manifest';
+import { BindUtil, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
+
+import { ConfigSourceTarget, ConfigTarget } from './internal/types';
+import { ConfigData } from './parser/types';
+import { ConfigSource, ConfigValue } from './source/types';
+
+/**
+ * Manager for application configuration
+ */
+@Injectable()
+export class Configuration {
+
+  private static getSorted(configs: ConfigValue[], profiles: string[]): ConfigValue[] {
+    const order = Object.fromEntries(Object.entries(profiles).map(([k, v]) => [v, +k] as const));
+
+    return configs.sort((left, right) =>
+      (order[left.profile] - order[right.profile]) ||
+      left.priority - right.priority ||
+      left.source.localeCompare(right.source)
+    );
+  }
+
+  #storage: Record<string, unknown> = {};   // Lowered, and flattened
+  #profiles: string[] = ['application', ...GlobalEnv.profiles, 'override'];
+  #sources: string[] = [];
+
+  /**
+   * Get a sub tree of the config, or everything if namespace is not passed
+   * @param ns The namespace of the config to search for, can be dotted for accessing sub namespaces
+   */
+  #get(ns?: string): Record<string, unknown> {
+    const parts = (ns ? ns.split('.') : []);
+    let sub: Record<string, unknown> = this.#storage;
+
+    while (parts.length && sub) {
+      const next = parts.shift()!;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      sub = sub[next] as Record<string, unknown>;
+    }
+
+    return sub;
+  }
+
+  /**
+   * Load configurations for active profiles.  Load order is defined by:
+   *  - First in order of profile names (application, ...specified, override)
+   *  - When dealing with two profiles of the same name, they are then sorted by priority
+   *  - If of the same priority, then alpha sort on the source
+   */
+  async postConstruct(): Promise<void> {
+    const providers = await DependencyRegistry.getCandidateTypes(ConfigSourceTarget);
+
+    const configs = await Promise.all(
+      providers.map(async (el) => {
+        const inst = await DependencyRegistry.getInstance<ConfigSource>(el.class, el.qualifier);
+        return inst.getValues(this.#profiles);
+      })
+    );
+
+    const sorted = Configuration.getSorted(configs.flat(), this.#profiles);
+
+    this.#sources = sorted.map(x => `${x.profile}.${x.priority} - ${x.source}`);
+
+    for (const { config: element } of sorted) {
+      DataUtil.deepAssign(this.#storage, BindUtil.expandPaths(element), 'coerce');
+    }
+  }
+
+  /**
+   * Export all active configuration, useful for displaying active state
+   *   - Will not show fields marked as secret
+   */
+  async exportActive(): Promise<{ sources: string[], active: ConfigData }> {
+    const configTargets = await DependencyRegistry.getCandidateTypes(ConfigTarget);
+    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))
+        .map(async el => {
+          const inst = await DependencyRegistry.getInstance<ClassInstance>(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 }
+      );
+      out[el.class.name] = data;
+    }
+    return { sources: this.#sources, active: out };
+  }
+
+  /**
+   * Bind and validate configuration into class instance
+   */
+  async bindTo<T>(cls: Class<T>, item: T, namespace: string, validate = true): Promise<T> {
+    if (!SchemaRegistry.has(cls)) {
+      throw new AppError(`${cls.Ⲑid} is not a valid schema class, config is not supported`);
+    }
+    const out = BindUtil.bindSchemaToObject(cls, item, this.#get(namespace));
+    if (validate) {
+      try {
+        await SchemaValidator.validate(cls, out);
+      } catch (err) {
+        if (err instanceof ValidationResultError) {
+          err.message = `Failed to construct ${cls.Ⲑid} as validation errors have occurred`;
+          const file = RootIndex.getFunctionMetadata(cls)!.source;
+          err.payload = { class: cls.Ⲑid, file, ...(err.payload ?? {}) };
+        }
+        throw err;
+      }
+    }
+    return out;
+  }
+}

package/src/decorator.ts

@@ -1,22 +1,39 @@
-import { Class } from '@travetto/base';
-import { ConfigManager } from './manager';
+import { Class, ClassInstance } from '@travetto/base';
+import { DependencyRegistry } from '@travetto/di';
+import { SchemaRegistry } from '@travetto/schema';
+
+import { Configuration } from './configuration';
+import { ConfigTarget, ConfigOverrides, CONFIG_OVERRIDES } from './internal/types';
 
 /**
  * Indicates that the given class should be populated with the configured fields, on instantiation
- * @augments `@trv:schema/Schema`
- * @augments `@trv:di/Injectable`
+ * @augments `@travetto/schema:Schema`
+ * @augments `@travetto/di:Injectable`
  */
-export function Config(ns: string, params?: { internal?: boolean }) {
+export function Config(ns: string) {
   return <T extends Class>(target: T): T => {
-    const og = target.prototype.postConstruct;
+    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: {} });
+    env.ns = ns;
 
     target.prototype.postConstruct = async function (): Promise<void> {
       // Apply config
-      await ConfigManager.install(target, this, ns, params?.internal);
-      if (og) {
-        await og.call(this);
-      }
+      const cfg = await DependencyRegistry.getInstance(Configuration);
+      await cfg.bindTo(target, this, ns);
+      await og?.call(this);
     };
     return target;
   };
+}
+
+/**
+ * Allows for binding specific fields to environment variables as a top-level override
+ */
+export function EnvVar(name: 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];
+  };
 }

package/src/internal/types.ts

@@ -0,0 +1,10 @@
+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)>;
+};

package/src/parser/json.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@travetto/di';
+
+import { ConfigParser } from './types';
+
+@Injectable()
+export class JSONConfigParser implements ConfigParser {
+  ext = ['json'];
+  parse = JSON.parse.bind(JSON);
+}

package/src/parser/properties.ts

@@ -0,0 +1,54 @@
+import { Injectable } from '@travetto/di';
+
+import { ConfigData, ConfigParser } from './types';
+
+const BACKSLASH = '\\'.charCodeAt(0);
+const EQUALS = '='.charCodeAt(0);
+const COLON = ':'.charCodeAt(0);
+const HASH = '#'.charCodeAt(0);
+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;
+    }
+    const key: number[] = [];
+    let value: string | undefined;
+    for (let i = 0; i < text.length; i += 1) {
+      const ch = text.charCodeAt(i);
+      if (ch === EQUALS || ch === COLON) { // Break
+        value = text.substring(i + 1).trimStart();
+        break;
+      } else if (ch === BACKSLASH) {
+        key.push(text.charCodeAt(i += 1));
+      } else {
+        key.push(ch);
+      }
+    }
+    if (value) {
+      return [String.fromCharCode(...key).trimEnd(), value];
+    }
+  }
+
+  ext = ['properties'];
+
+  parse(text: string): ConfigData {
+    const out: ConfigData = {};
+    const lines = text.split(/\n/g);
+
+    for (let i = 0; i < lines.length; i++) {
+      let line = lines[i];
+      while (i < text.length && line.endsWith('\\')) {
+        line = `${line.replace(/\\$/, '')}${lines[i += 1].trimStart()}`;
+      }
+      const entry = PropertiesConfigParser.parseLine(line);
+      if (entry) {
+        out[entry[0]] = entry[1];
+      }
+    }
+    return out;
+  }
+}

package/src/parser/types.ts

@@ -0,0 +1,9 @@
+export type ConfigData = Record<string, unknown>;
+
+/**
+ * @concrete ../internal/types:ConfigParserTarget
+ */
+export interface ConfigParser {
+  ext: string[];
+  parse(input: string): Promise<ConfigData> | ConfigData;
+}

package/src/parser/yaml.ts

@@ -0,0 +1,10 @@
+import { Injectable } from '@travetto/di';
+import { YamlUtil } from '@travetto/yaml';
+
+import { ConfigParser } from './types';
+
+@Injectable()
+export class YAMLConfigParser implements ConfigParser {
+  ext = ['yaml', 'yml'];
+  parse = YamlUtil.parse;
+}

package/src/source/file.ts

@@ -0,0 +1,61 @@
+import { FileQueryProvider } from '@travetto/base';
+import { DependencyRegistry, InjectableFactory } from '@travetto/di';
+
+import { ConfigParserTarget } from '../internal/types';
+import { ConfigParser } from '../parser/types';
+import { ConfigSource, ConfigValue } from './types';
+
+/**
+ * File-base config source, builds on common file resource provider
+ */
+export class FileConfigSource extends FileQueryProvider implements ConfigSource {
+
+  @InjectableFactory()
+  static getInstance(): ConfigSource {
+    return new FileConfigSource();
+  }
+
+  depth = 1;
+  extMatch: RegExp;
+  parsers: Record<string, ConfigParser>;
+  priority = 1;
+
+  constructor(paths: string[] = []) {
+    super({ includeCommon: true, paths });
+  }
+
+  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)));
+
+    // Register parsers
+    this.parsers = {};
+    for (const par of parsers) {
+      for (const ext of par.ext) {
+        this.parsers[ext] = par;
+      }
+    }
+
+    this.extMatch = parsers.length ? new RegExp(`[.](${Object.keys(this.parsers).join('|')})`) : /^$/;
+  }
+
+  async getValues(profiles: string[]): Promise<ConfigValue[]> {
+    const out: ConfigValue[] = [];
+
+    for await (const file of this.query(f => this.extMatch.test(f))) {
+      const ext = file.split('.')[1];
+      const profile = file.replace(`.${ext}`, '');
+      if (!profiles.includes(profile) || !this.parsers[ext]) {
+        continue;
+      }
+      const content = await this.read(file);
+      out.push({
+        profile,
+        config: await this.parsers[ext].parse(content),
+        source: `file://${file}`,
+        priority: this.priority
+      });
+    }
+    return out;
+  }
+}

package/src/source/memory.ts

@@ -0,0 +1,26 @@
+import { ConfigData } from '../parser/types';
+import { ConfigSource, ConfigValue } from './types';
+
+/**
+ * Meant to be instantiated and provided as a unique config source
+ */
+export class MemoryConfigSource implements ConfigSource {
+  priority = 1;
+  data: Record<string, ConfigData>;
+  name = 'memory';
+
+  constructor(data: Record<string, ConfigData>, priority: number = 1) {
+    this.data = data;
+    this.priority = priority;
+  }
+
+  getValues(profiles: string[]): ConfigValue[] {
+    const out: ConfigValue[] = [];
+    for (const profile of profiles) {
+      if (this.data[profile]) {
+        out.push({ profile, config: this.data[profile], source: `${this.name}://${profile}`, priority: this.priority });
+      }
+    }
+    return out;
+  }
+}

package/src/source/override.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@travetto/di';
+import { SchemaRegistry } from '@travetto/schema';
+
+import { ConfigOverrides, CONFIG_OVERRIDES } from '../internal/types';
+import { ConfigData } from '../parser/types';
+import { ConfigSource, ConfigValue } from './types';
+
+/**
+ * Overridable config source, provides ability to override field level values, currently used by
+ * - @EnvVar as a means to allow environment specific overrides
+ */
+@Injectable()
+export class OverrideConfigSource implements ConfigSource {
+  priority = 3;
+  name = 'override';
+
+  #build(): ConfigData {
+    const out: ConfigData = {};
+    for (const cls of SchemaRegistry.getClasses()) {
+      const { ns, fields = {} } = SchemaRegistry.getMetadata<ConfigOverrides>(cls, CONFIG_OVERRIDES) ?? {};
+      for (const [key, value] of Object.entries(fields)) {
+        const val = value();
+        if (val !== undefined && val !== '') {
+          out[`${ns}.${key}`] = val;
+        }
+      }
+    }
+    return out;
+  }
+
+  getValues(profiles: string[]): [ConfigValue] {
+    return [{
+      config: this.#build(),
+      profile: 'override',
+      source: 'memory://override',
+      priority: this.priority
+    }];
+  }
+}

package/src/source/types.ts

@@ -0,0 +1,11 @@
+import { ConfigData } from '../parser/types';
+
+export type ConfigValue = { config: ConfigData, source: string, profile: string, priority: number };
+
+/**
+ * @concrete ../internal/types:ConfigSourceTarget
+ */
+export interface ConfigSource {
+  priority: number;
+  getValues(profiles: string[]): Promise<ConfigValue[]> | ConfigValue[];
+}

package/index.ts

@@ -1,2 +0,0 @@
-export * from './src/decorator';
-export * from './src/manager';

package/src/internal/util.ts

@@ -1,129 +0,0 @@
-import { Class, ResourceManager, Util } from '@travetto/base';
-import { YamlUtil } from '@travetto/yaml';
-import { BindUtil, SchemaRegistry, ViewConfig } from '@travetto/schema';
-
-/**
- * Simple Config Utilities
- */
-export class ConfigUtil {
-
-  /**
-   * Find the key using case insensitive search
-   */
-  static #getKeyName(key: string, fields: string[]): string | undefined {
-    key = key.trim();
-    const match = new RegExp(key, 'i');
-    const next = fields.find(x => match.test(x));
-    return next;
-  }
-
-  /**
-   * Takes a env var, and produces a partial object against a schema definition.  Does not support arrays, only objects.
-   */
-  static #expandEnvEntry(cls: Class, key: string, value: unknown): Record<string, unknown> | undefined {
-    const parts = key.split('_');
-
-    const lastPart = parts.pop()!;
-
-    if (!lastPart) {
-      return;
-    }
-
-    let cfg: ViewConfig | undefined = SchemaRegistry.getViewSchema(cls);
-    let data: Record<string, unknown> = {};
-    const root = data;
-
-    while (parts.length) {
-      let part = parts.shift();
-      if (cfg) {
-        part = this.#getKeyName(part!, cfg.fields);
-        if (!part) {
-          return;
-        }
-        const subType: Class = cfg.schema[part].type;
-        if (SchemaRegistry.has(subType)) {
-          cfg = SchemaRegistry.getViewSchema(subType);
-        } else if (subType === Object) { // wildcard
-          cfg = undefined;
-        } else {
-          break;
-        }
-      }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      data = ((data[part!] ??= {}) as Record<string, unknown>); // Recurse
-    }
-
-    const lastKey = (cfg ? this.#getKeyName(lastPart, cfg.fields) : undefined) ?? (/^[A-Z_0-9]+$/.test(lastPart) ? lastPart.toLowerCase() : lastPart);
-    if (typeof value === 'string' && value.includes(',')) {
-      value = value.trim().split(/\s*,\s*/);
-    }
-    data[lastKey] = value;
-
-    return root;
-  }
-
-  /**
-   * Bind the environment variables onto an object structure when they match by name.
-   * Will split on _ to handle nesting appropriately
-   */
-  static getEnvOverlay(cls: Class, ns: string): Record<string, unknown> {
-    // Handle process.env on bind as the structure we need may not
-    // fully exist until the config has been created
-    const nsRe = new RegExp(`^${ns.replace(/[.]/g, '_')}`, 'i'); // Check is case insensitive
-    const data: Record<string, unknown> = {};
-    for (const [k, v] of Object.entries(process.env)) { // Find all keys that match ns
-      if (k.includes('_') && nsRe.test(k)) { // Require at least one level (nothing should be at the top level as all configs are namespaced)
-        Util.deepAssign(data, this.#expandEnvEntry(cls, ns ? k.substring(ns.length + 1) : k, v), 'coerce');
-      }
-    }
-    return data;
-  }
-
-  /**
-   * Parse config file from YAML into JSON
-   */
-  static async getConfigFileAsData(file: string, ns: string = ''): Promise<Record<string, unknown>> {
-    const data = await ResourceManager.read(file, 'utf8');
-    const doc = YamlUtil.parse<Record<string, unknown>>(data);
-    return ns ? { [ns]: doc } : doc;
-  }
-
-  /**
-   * Looks up root object by namespace
-   * @param src
-   * @param ns
-   * @returns
-   */
-  static lookupRoot(src: Record<string, unknown>, ns?: string, createIfMissing = false): Record<string, unknown> {
-    const parts = (ns ? ns.split('.') : []);
-    let sub: Record<string, unknown> = src;
-
-    while (parts.length && sub) {
-      const next = parts.shift()!;
-      if (createIfMissing && !sub[next]) {
-        sub[next] = {};
-      }
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      sub = sub[next] as Record<string, unknown>;
-    }
-
-    return sub;
-  }
-
-  /**
-   * Sanitize payload
-   */
-  static sanitizeValuesByKey<T extends Record<string, unknown>>(obj: T, patterns: string[]): T {
-    // Support custom redacted keys
-    const regex = new RegExp(`(${patterns.filter(x => !!x).join('|')})`, 'i');
-
-    const full = BindUtil.flattenPaths(obj);
-    for (const [k, value] of Object.entries(full)) {
-      if (typeof value === 'string' && regex.test(k)) {
-        full[k] = '*'.repeat(10);
-      }
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return BindUtil.expandPaths(full) as T;
-  }
-}

package/src/manager.ts

@@ -1,133 +0,0 @@
-import * as path from 'path';
-
-import { AppError, AppManifest, Class, ResourceManager, Util } from '@travetto/base';
-import { EnvUtil } from '@travetto/boot';
-import { BindUtil, SchemaRegistry, SchemaValidator, ValidationResultError } from '@travetto/schema';
-
-import { ConfigUtil } from './internal/util';
-
-/**
- * Manager for application configuration
- */
-class $ConfigManager {
-
-  #initialized?: boolean = false;
-  #storage: Record<string, unknown> = {};   // Lowered, and flattened
-  #active: Record<string, Record<string, unknown>> = {}; // All active configs
-  #redactedKeys = [
-    'passphrase.*',
-    'password.*',
-    'credential.*',
-    '.*secret.*',
-    '.*key',
-    '.*token',
-    'pw',
-  ];
-
-  protected getStorage(): Record<string, unknown> {
-    return this.#storage;
-  }
-
-  /**
-   * Load all config files
-   */
-  async #load(): Promise<void> {
-    const profileIndex = Object.fromEntries(Object.entries(AppManifest.env.profiles).map(([k, v]) => [v, +k] as const));
-
-    const files = (await ResourceManager.findAll(/[.]ya?ml$/))
-      .map(file => ({ file, profile: path.basename(file).replace(/[.]ya?ml$/, '') }))
-      .filter(({ profile }) => profile in profileIndex)
-      .sort((a, b) => profileIndex[a.profile] - profileIndex[b.profile]);
-
-    if (files.length) {
-      console.debug('Found configurations for', { files: files.map(x => x.profile) });
-    }
-
-    for (const f of files) {
-      const data = await ConfigUtil.getConfigFileAsData(f.file);
-      Util.deepAssign(this.#storage, BindUtil.expandPaths(data), 'coerce');
-    }
-  }
-
-  /**
-   * Get a sub tree of the config, or everything if namespace is not passed
-   * @param ns The namespace of the config to search for, can be dotted for accessing sub namespaces
-   */
-  #get(ns?: string): Record<string, unknown> {
-    return ConfigUtil.lookupRoot(this.#storage, ns);
-  }
-
-  /**
-   * Order of specificity (least to most)
-   *   - Resource application.yml
-   *   - Resource {profile}.yml
-   *   - Resource {env}.yml
-   *   - Environment vars -> Overrides everything (happens at bind time)
-   */
-  async init(): Promise<void> {
-    if (!this.#initialized) {
-      this.#initialized = true;
-      await this.#load();
-    }
-  }
-
-  /**
-   * Output to JSON
-   * @param namespace If only a portion of the config should be exported
-   * @param secure Determines if secrets should be redacted, defaults to true in prod, false otherwise
-   */
-  toJSON(secure: boolean = EnvUtil.isProd()): Record<string, unknown> {
-    const copy = JSON.parse(JSON.stringify(this.#active));
-    return secure ?
-      ConfigUtil.sanitizeValuesByKey(copy, [
-        ...this.#redactedKeys,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        ...(this.#get('config')?.redacted ?? []) as string[]
-      ]) :
-      copy;
-  }
-
-  /**
-   * Bind config to a schema class
-   * @param cls
-   * @param item
-   * @param namespace
-   */
-  bindTo<T>(cls: Class<T>, item: T, namespace: string): T {
-    if (!SchemaRegistry.has(cls)) {
-      throw new AppError(`${cls.ᚕid} is not a valid schema class, config is not supported`);
-    }
-
-    const cfg = Util.deepAssign({}, this.#get(namespace));
-    Util.deepAssign(cfg, ConfigUtil.getEnvOverlay(cls, namespace));
-
-    return BindUtil.bindSchemaToObject(cls, item, cfg);
-  }
-
-  async install<T>(cls: Class<T>, item: T, namespace: string, internal?: boolean): Promise<T> {
-    const out = await this.bindTo(cls, item, namespace);
-    try {
-      await SchemaValidator.validate(cls, out);
-    } catch (err) {
-      if (err instanceof ValidationResultError) {
-        err.message = `Failed to construct ${cls.ᚕid} as validation errors have occurred`;
-        err.payload = { class: cls.ᚕid, file: cls.ᚕfile, ...(err.payload ?? {}) };
-      }
-      throw err;
-    }
-    if (out && !internal) {
-      Util.deepAssign(ConfigUtil.lookupRoot(this.#active, namespace, true), out, 'coerce');
-    }
-    return out;
-  }
-
-  /**
-   * Reset
-   */
-  reset(): void {
-    this.#storage = {};
-    this.#initialized = false;
-  }
-}
-
-export const ConfigManager = new $ConfigManager();

package/support/phase.init.ts

@@ -1,11 +0,0 @@
-/**
- * Initializes the config source
- */
-export const init = {
-  key: '@trv:config/init',
-  before: ['@trv:registry/init'],
-  async action(): Promise<void> {
-    const { ConfigManager } = await import('../src/manager');
-    await ConfigManager.init();
-  }
-};