@travetto/config 7.0.0-rc.1 → 7.0.0-rc.3

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#L21) 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#L23) functionality applies.
 
 ## Resolution
 The configuration information is comprised of:
@@ -104,27 +104,28 @@ The framework provides two simple base classes that assist with existing pattern
 **Code: Memory Provider**
 ```typescript
 import { ConfigData } from '../parser/types.ts';
-import { ConfigSource, ConfigSpec } from './types.ts';
+import { ConfigSource, ConfigPayload } from './types.ts';
 
 /**
  * Meant to be instantiated and provided as a unique config source
  */
 export class MemoryConfigSource implements ConfigSource {
-  #spec: ConfigSpec;
+  #payload: ConfigPayload;
 
   constructor(key: string, data: ConfigData, priority: number = 500) {
-    this.#spec = { data, priority, source: `memory://${key}` };
+    this.#payload = { data, priority, source: `memory://${key}` };
   }
 
-  get(): ConfigSpec {
-    return this.#spec;
+  get(): ConfigPayload {
+    return this.#payload;
   }
 }
 ```
 
 **Code: Environment JSON Provider**
 ```typescript
-import { ConfigSource, ConfigSpec } from './types.ts';
+import { JSONUtil } from '@travetto/runtime';
+import { ConfigSource, ConfigPayload } from './types.ts';
 
 /**
  * Represents the environment mapped data as a JSON blob
@@ -138,9 +139,9 @@ export class EnvConfigSource implements ConfigSource {
     this.#priority = priority;
   }
 
-  get(): ConfigSpec | undefined {
+  get(): ConfigPayload | undefined {
     try {
-      const data = JSON.parse(process.env[this.#envKey] || '{}');
+      const data: Record<string, unknown> = JSONUtil.parseSafe(process.env[this.#envKey] || '{}');
       return { data, priority: this.#priority, source: `env://${this.#envKey}` };
     } catch {
       console.error(`env.${this.#envKey} is an invalid format`, { text: process.env[this.#envKey] });
@@ -154,12 +155,12 @@ In addition to files and environment variables, configuration sources can also b
 
 **Code: Custom Configuration Source**
 ```typescript
-import { ConfigSource, ConfigSpec } from '@travetto/config';
+import { ConfigSource, ConfigPayload } from '@travetto/config';
 import { Injectable } from '@travetto/di';
 
 @Injectable()
 export class CustomConfigSource implements ConfigSource {
-  async get(): Promise<ConfigSpec> {
+  async get(): Promise<ConfigPayload> {
     return {
       data: { user: { name: 'bob' } },
       source: 'custom://override',

package/package.json

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

package/src/decorator.ts

@@ -10,21 +10,21 @@ import { ConfigOverrideUtil } from './util.ts';
  * @augments `@travetto/schema:Schema`
  * @kind decorator
  */
-export function Config(ns: string) {
+export function Config(namespace: string) {
   return <T extends Class>(cls: T): T => {
     // Declare as part of global config
     SchemaRegistryIndex.getForRegister(cls).register({ interfaces: [ConfigBaseType] });
 
-    ConfigOverrideUtil.setOverrideConfig(cls, ns);
+    ConfigOverrideUtil.setOverrideConfig(cls, namespace);
 
     DependencyRegistryIndex.getForRegister(cls).registerClass();
 
-    const og: Function = cls.prototype.postConstruct;
+    const handle: Function = cls.prototype.postConstruct;
     cls.prototype.postConstruct = async function (): Promise<void> {
       // Apply config
-      const cfg = await DependencyRegistryIndex.getInstance(ConfigurationService);
-      await cfg.bindTo(cls, this, ns);
-      await og?.call(this);
+      const config = await DependencyRegistryIndex.getInstance(ConfigurationService);
+      await config.bindTo(cls, this, namespace);
+      await handle?.call(this);
     };
     return cls;
   };

package/src/parser/json.ts

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

package/src/parser/parser.ts

@@ -16,7 +16,7 @@ export class ParserManager {
     const parsers = await DependencyRegistryIndex.getInstances(toConcrete<ConfigParser>());
 
     // Register parsers
-    this.#parsers = Object.fromEntries(parsers.flatMap(p => p.ext.map(e => [e, p])));
+    this.#parsers = Object.fromEntries(parsers.flatMap(parser => parser.ext.map(ext => [ext, parser])));
     this.#extMatch = parsers.length ? new RegExp(`(${Object.keys(this.#parsers).join('|').replaceAll('.', '[.]')})`) : /^$/;
   }
 

package/src/service.ts

@@ -6,11 +6,11 @@ import { BindUtil, DataUtil, SchemaRegistryIndex, SchemaValidator, ValidationRes
 
 import { ParserManager } from './parser/parser.ts';
 import { ConfigData } from './parser/types.ts';
-import { ConfigSource, ConfigSpec } from './source/types.ts';
+import { ConfigSource, ConfigPayload } from './source/types.ts';
 import { FileConfigSource } from './source/file.ts';
 import { OverrideConfigSource } from './source/override.ts';
 
-type ConfigSpecSimple = Omit<ConfigSpec, 'data'>;
+type ConfigSpecSimple = Omit<ConfigPayload, 'data'>;
 
 /**
  * Common Type for all configuration classes
@@ -24,15 +24,15 @@ export class ConfigBaseType { }
 export class ConfigurationService {
 
   #storage: Record<string, unknown> = {};   // Lowered, and flattened
-  #specs: ConfigSpecSimple[] = [];
+  #payloads: ConfigSpecSimple[] = [];
   #secrets: (RegExp | string)[] = [/secure(-|_|[a-z])|password|private|secret|salt|(\bkey|key\b)|serviceAccount|(api(-|_)?key)/i];
 
   /**
    * 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
+   * @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>>(ns?: string): T {
-    const parts = (ns ? ns.split('.') : []);
+  #get<T extends Record<string, unknown> = Record<string, unknown>>(namespace?: string): T {
+    const parts = (namespace ? namespace.split('.') : []);
     let sub: Record<string, unknown> = this.#storage;
 
     while (parts.length && sub) {
@@ -53,7 +53,7 @@ export class ConfigurationService {
     const providers = await DependencyRegistryIndex.getCandidates(toConcrete<ConfigSource>());
 
     const configs = await Promise.all(
-      providers.map(async (el) => await DependencyRegistryIndex.getInstance(el.candidateType, el.qualifier))
+      providers.map(async (candidate) => await DependencyRegistryIndex.getInstance<ConfigSource>(candidate.candidateType, candidate.qualifier))
     );
 
     const parser = await DependencyRegistryIndex.getInstance(ParserManager);
@@ -62,27 +62,27 @@ export class ConfigurationService {
       new FileConfigSource(parser),
       ...configs,
       new OverrideConfigSource()
-    ].map(src => src.get()));
+    ].map(source => source.get()));
 
-    const specs = possible
+    const payloads = possible
       .flat()
-      .filter(x => !!x)
+      .filter(data => !!data)
       .toSorted((a, b) => a.priority - b.priority);
 
-    for (const spec of specs) {
-      DataUtil.deepAssign(this.#storage, BindUtil.expandPaths(spec.data), 'coerce');
+    for (const payload of payloads) {
+      DataUtil.deepAssign(this.#storage, BindUtil.expandPaths(payload.data), 'coerce');
     }
 
-    this.#specs = specs.map(({ data: _, ...v }) => v);
+    this.#payloads = payloads.map(({ data: _, ...payload }) => payload);
 
     // Initialize Secrets
     const { secrets = [] } = this.#get<{ secrets?: string | string[] }>('config') ?? {};
-    for (const el of [secrets].flat()) {
-      if (typeof el === 'string') {
-        if (el.startsWith('/')) {
-          this.#secrets.push(DataUtil.coerceType(el, RegExp, true));
+    for (const value of [secrets].flat()) {
+      if (typeof value === 'string') {
+        if (value.startsWith('/')) {
+          this.#secrets.push(DataUtil.coerceType(value, RegExp, true));
         } else {
-          this.#secrets.push(DataUtil.coerceType(el, String, true));
+          this.#secrets.push(DataUtil.coerceType(value, String, true));
         }
       }
     }
@@ -96,21 +96,21 @@ export class ConfigurationService {
     const configTargets = await DependencyRegistryIndex.getCandidates(ConfigBaseType);
     const configs = await Promise.all(
       configTargets
-        .filter(el => el.qualifier === getDefaultQualifier(el.class)) // Is self targeting?
+        .filter(candidate => candidate.qualifier === getDefaultQualifier(candidate.class)) // Is self targeting?
         .toSorted((a, b) => a.class.name.localeCompare(b.class.name))
-        .map(async el => {
-          const inst = await DependencyRegistryIndex.getInstance(el.class, el.qualifier);
-          return [el, inst] as const;
+        .map(async candidate => {
+          const inst = await DependencyRegistryIndex.getInstance(candidate.class, candidate.qualifier);
+          return [candidate, inst] as const;
         })
     );
     const out: Record<string, ConfigData> = {};
-    for (const [el, inst] of configs) {
+    for (const [candidate, inst] of configs) {
       const data = BindUtil.bindSchemaToObject<ConfigData>(
-        getClass(inst), {}, inst, { filterInput: f => !('secret' in f) || !f.secret, filterValue: v => v !== undefined }
+        getClass(inst), {}, inst, { filterInput: field => !('secret' in field) || !field.secret, filterValue: value => value !== undefined }
       );
-      out[el.candidateType.name] = DataUtil.filterByKeys(data, this.#secrets);
+      out[candidate.candidateType.name] = DataUtil.filterByKeys(data, this.#secrets);
     }
-    return { sources: this.#specs, active: out };
+    return { sources: this.#payloads, active: out };
   }
 
   /**
@@ -125,15 +125,15 @@ export class ConfigurationService {
     if (validate) {
       try {
         await SchemaValidator.validate(cls, item);
-      } catch (err) {
-        if (err instanceof ValidationResultError) {
-          const ogMessage = err.message;
-          err.message = `Failed to construct ${classId} as validation errors have occurred`;
-          err.stack = err.stack?.replace(ogMessage, err.message);
+      } catch (error) {
+        if (error instanceof ValidationResultError) {
+          const originalMessage = error.message;
+          error.message = `Failed to construct ${classId} as validation errors have occurred`;
+          error.stack = error.stack?.replace(originalMessage, error.message);
           const imp = Runtime.getImport(cls);
-          Object.defineProperty(err, 'details', { value: { class: classId, import: imp, ...(err.details ?? {}) } });
+          Object.defineProperty(error, 'details', { value: { class: classId, import: imp, ...(error.details ?? {}) } });
         }
-        throw err;
+        throw error;
       }
     }
     return item;
@@ -152,7 +152,6 @@ export class ConfigurationService {
         env: Runtime.env,
         debug: Runtime.debug,
         production: Runtime.production,
-        dynamic: Runtime.dynamic,
         resourcePaths: RuntimeResources.searchPaths,
         profiles: Env.TRV_PROFILES.list ?? []
       },

package/src/source/env.ts

@@ -1,4 +1,5 @@
-import { ConfigSource, ConfigSpec } from './types.ts';
+import { JSONUtil } from '@travetto/runtime';
+import { ConfigSource, ConfigPayload } from './types.ts';
 
 /**
  * Represents the environment mapped data as a JSON blob
@@ -12,9 +13,9 @@ export class EnvConfigSource implements ConfigSource {
     this.#priority = priority;
   }
 
-  get(): ConfigSpec | undefined {
+  get(): ConfigPayload | undefined {
     try {
-      const data = JSON.parse(process.env[this.#envKey] || '{}');
+      const data: Record<string, unknown> = JSONUtil.parseSafe(process.env[this.#envKey] || '{}');
       return { data, priority: this.#priority, source: `env://${this.#envKey}` };
     } catch {
       console.error(`env.${this.#envKey} is an invalid format`, { text: process.env[this.#envKey] });

package/src/source/file.ts

@@ -3,7 +3,7 @@ import path from 'node:path';
 
 import { Env, Runtime, RuntimeResources } from '@travetto/runtime';
 
-import { ConfigSource, ConfigSpec } from './types.ts';
+import { ConfigSource, ConfigPayload } from './types.ts';
 import { ParserManager } from '../parser/parser.ts';
 
 type Profile = [string, number] | readonly [string, number];
@@ -24,13 +24,13 @@ export class FileConfigSource implements ConfigSource {
       ['application', 100],
       [Runtime.env!, 200],
       ...(Env.TRV_PROFILES.list ?? [])
-        .map((p, i) => [p, 300 + i * 10] as const)
-    ] as const).filter(x => !!x[0]);
+        .map((profile, i) => [profile, 300 + i * 10] as const)
+    ] as const).filter(entry => !!entry[0]);
   }
 
-  async get(): Promise<ConfigSpec[]> {
+  async get(): Promise<ConfigPayload[]> {
     const cache: Record<string, Promise<string[]>> = {};
-    const configs: Promise<ConfigSpec>[] = [];
+    const configs: Promise<ConfigPayload>[] = [];
 
     for (const [profile, priority] of this.#profiles) {
       let i = priority;

package/src/source/memory.ts

@@ -1,17 +1,17 @@
 import { ConfigData } from '../parser/types.ts';
-import { ConfigSource, ConfigSpec } from './types.ts';
+import { ConfigSource, ConfigPayload } from './types.ts';
 
 /**
  * Meant to be instantiated and provided as a unique config source
  */
 export class MemoryConfigSource implements ConfigSource {
-  #spec: ConfigSpec;
+  #payload: ConfigPayload;
 
   constructor(key: string, data: ConfigData, priority: number = 500) {
-    this.#spec = { data, priority, source: `memory://${key}` };
+    this.#payload = { data, priority, source: `memory://${key}` };
   }
 
-  get(): ConfigSpec {
-    return this.#spec;
+  get(): ConfigPayload {
+    return this.#payload;
   }
 }

package/src/source/override.ts

@@ -1,5 +1,5 @@
 import { ConfigData } from '../parser/types.ts';
-import { ConfigSource, ConfigSpec } from './types.ts';
+import { ConfigSource, ConfigPayload } from './types.ts';
 import { ConfigOverrideUtil } from '../util.ts';
 
 /**
@@ -11,16 +11,16 @@ export class OverrideConfigSource implements ConfigSource {
     const out: ConfigData = {};
     for (const { namespace, fields } of ConfigOverrideUtil.getAllOverrideConfigs()) {
       for (const [key, value] of Object.entries(fields)) {
-        const val = value();
-        if (val !== undefined && val !== '') {
-          out[`${namespace}.${key}`] = val;
+        const data = value();
+        if (data !== undefined && data !== '') {
+          out[`${namespace}.${key}`] = data;
         }
       }
     }
     return out;
   }
 
-  get(): ConfigSpec {
+  get(): ConfigPayload {
     return { data: this.#build(), priority: 999, source: 'memory://override' };
   }
 }

package/src/source/types.ts

@@ -3,11 +3,11 @@ import { ConfigData } from '../parser/types.ts';
 type OrProm<T> = T | Promise<T>;
 type OneOf<T> = T[] | T | undefined;
 
-export type ConfigSpec = { 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<ConfigSpec>>;
+  get(): OrProm<OneOf<ConfigPayload>>;
 }

package/src/util.ts

@@ -22,9 +22,9 @@ export class ConfigOverrideUtil {
   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));
+      const config = this.getOverrideConfig(cls);
+      if (config && config.fields && config.namespace) {
+        out.push(asFull(config));
       }
     }
     return out;
@@ -35,7 +35,7 @@ export class ConfigOverrideUtil {
       .registerMetadata<OverrideConfig>(OverrideConfigSymbol, {});
 
     (env.fields ??= {})[field] = (): string | undefined =>
-      process.env[names.find(x => !!process.env[x])!];
+      process.env[names.find(name => !!process.env[name])!];
   }
 
   static setOverrideConfig(cls: Class<Any>, namespace: string): void {