@grest-ts/config 0.0.6 → 0.0.8

package/src/keys/GGSecret.ts

@@ -1,20 +1,20 @@
-import {GGConfigKey} from "../GGConfigKey";
-import {GGValidator} from "@grest-ts/schema";
-
-export class GGSecret<T> extends GGConfigKey<T> {
-
-    public static readonly NAME = "[GGSecret]";
-
-    constructor(name: string, schema: GGValidator<T>, description: string) {
-        super(name, schema, description);
-    }
-
-    public getStoreKey(): string {
-        return GGSecret.NAME
-    }
-
-    public reveal(): T {
-        return this.getValue();
-    }
-
-}
+import {GGConfigKey} from "../GGConfigKey";
+import {GGValidator} from "@grest-ts/schema";
+
+export class GGSecret<T> extends GGConfigKey<T> {
+
+    public static readonly NAME = "[GGSecret]";
+
+    constructor(name: string, schema: GGValidator<T>, description: string) {
+        super(name, schema, description);
+    }
+
+    public getStoreKey(): string {
+        return GGSecret.NAME
+    }
+
+    public reveal(): T {
+        return this.getValue();
+    }
+
+}

package/src/keys/GGSetting.ts

@@ -1,28 +1,28 @@
-import {GGConfigKey, Widen} from "../GGConfigKey";
-import {deepFreeze} from "@grest-ts/common";
-import {GGValidator} from "@grest-ts/schema";
-
-export class GGSetting<T> extends GGConfigKey<T> {
-
-    public static readonly NAME = "[GGSetting]";
-
-    readonly #default: T;
-
-    constructor(name: string, schema: GGValidator<T>, defaultValue: Widen<T>, description: string) {
-        super(name, schema, description);
-        this.#default = deepFreeze(defaultValue as T);
-    }
-
-    public override getDefault(): T {
-        return this.#default;
-    }
-
-    public getStoreKey(): string {
-        return GGSetting.NAME
-    }
-
-    public get(): T {
-        return this.getValue();
-    }
-
-}
+import {GGConfigKey, Widen} from "../GGConfigKey";
+import {deepFreeze} from "@grest-ts/common";
+import {GGValidator} from "@grest-ts/schema";
+
+export class GGSetting<T> extends GGConfigKey<T> {
+
+    public static readonly NAME = "[GGSetting]";
+
+    readonly #default: T;
+
+    constructor(name: string, schema: GGValidator<T>, defaultValue: Widen<T>, description: string) {
+        super(name, schema, description);
+        this.#default = deepFreeze(defaultValue as T);
+    }
+
+    public override getDefault(): T {
+        return this.#default;
+    }
+
+    public getStoreKey(): string {
+        return GGSetting.NAME
+    }
+
+    public get(): T {
+        return this.getValue();
+    }
+
+}

package/src/stores/GGConfigStoreFile.ts

@@ -1,69 +1,69 @@
-import * as fs from 'fs';
-import {GGConfigStore} from "../GGConfigStore";
-import {GGConfigKey} from "../GGConfigKey";
-import {dirname, join} from "node:path";
-import {fileURLToPath} from "node:url";
-
-/**
- * Local file-based settings strategy.
- * Reads settings from settings.json in the config directory.
- * Watches file for changes and automatically reloads.
- */
-export class GGConfigStoreFile<Key extends GGConfigKey> extends GGConfigStore<Key> {
-
-    private readonly file: string;
-    #watcher: fs.FSWatcher | null = null;
-    #debounceTimer: NodeJS.Timeout | null = null;
-    #valuesCache: Map<GGConfigKey, unknown> = new Map();
-
-    constructor(file: string, moduleUrl?: string) {
-        super();
-        const prefix = moduleUrl ? dirname(fileURLToPath(moduleUrl)) : "";
-        this.file = join(prefix, file);
-    }
-
-    public override async start(): Promise<void> {
-        await super.start();
-        await this.refresh(true);
-        this.#watcher = fs.watch(this.file, (eventType) => {
-            if (eventType === 'change') {
-                if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
-                // Adding debounce so file writes would have time to correctly complete.
-                this.#debounceTimer = setTimeout(() => this.refresh(false), 100);
-            }
-        });
-    }
-
-    public override async teardown(): Promise<void> {
-        if (this.#watcher) {
-            this.#watcher.close();
-            this.#watcher = null;
-        }
-        await super.teardown();
-    }
-
-    public async refresh(isInitialLoad: boolean): Promise<void> {
-        const fileContent = fs.readFileSync(this.file, 'utf-8');
-        if (!fileContent) {
-            throw new Error("Settings file is empty! Why is that?")
-        }
-        const fileJson = JSON.parse(fileContent);
-        this.#valuesCache.clear();
-        this.keys.forEach(key => {
-            const path = key.name.split("/");
-            let val: any = undefined;
-            if (path.length > 1) {
-                val = fileJson;
-                for (let i = 1; i < path.length; i++) {
-                    val = val?.[path[i]]
-                }
-            }
-            this.#valuesCache.set(key, this.resolveValue(key, val, isInitialLoad));
-        });
-    }
-
-    public getValue<T>(key: GGConfigKey<T>): T {
-        return this.#valuesCache.get(key) as T;
-    }
-
-}
+import * as fs from 'fs';
+import {GGConfigStore} from "../GGConfigStore";
+import {GGConfigKey} from "../GGConfigKey";
+import {dirname, join} from "node:path";
+import {fileURLToPath} from "node:url";
+
+/**
+ * Local file-based settings strategy.
+ * Reads settings from settings.json in the config directory.
+ * Watches file for changes and automatically reloads.
+ */
+export class GGConfigStoreFile<Key extends GGConfigKey> extends GGConfigStore<Key> {
+
+    private readonly file: string;
+    #watcher: fs.FSWatcher | null = null;
+    #debounceTimer: NodeJS.Timeout | null = null;
+    #valuesCache: Map<GGConfigKey, unknown> = new Map();
+
+    constructor(file: string, moduleUrl?: string) {
+        super();
+        const prefix = moduleUrl ? dirname(fileURLToPath(moduleUrl)) : "";
+        this.file = join(prefix, file);
+    }
+
+    public override async start(): Promise<void> {
+        await super.start();
+        await this.refresh(true);
+        this.#watcher = fs.watch(this.file, (eventType) => {
+            if (eventType === 'change') {
+                if (this.#debounceTimer) clearTimeout(this.#debounceTimer);
+                // Adding debounce so file writes would have time to correctly complete.
+                this.#debounceTimer = setTimeout(() => this.refresh(false), 100);
+            }
+        });
+    }
+
+    public override async teardown(): Promise<void> {
+        if (this.#watcher) {
+            this.#watcher.close();
+            this.#watcher = null;
+        }
+        await super.teardown();
+    }
+
+    public async refresh(isInitialLoad: boolean): Promise<void> {
+        const fileContent = fs.readFileSync(this.file, 'utf-8');
+        if (!fileContent) {
+            throw new Error("Settings file is empty! Why is that?")
+        }
+        const fileJson = JSON.parse(fileContent);
+        this.#valuesCache.clear();
+        this.keys.forEach(key => {
+            const path = key.name.split("/");
+            let val: any = undefined;
+            if (path.length > 1) {
+                val = fileJson;
+                for (let i = 1; i < path.length; i++) {
+                    val = val?.[path[i]]
+                }
+            }
+            this.#valuesCache.set(key, this.resolveValue(key, val, isInitialLoad));
+        });
+    }
+
+    public getValue<T>(key: GGConfigKey<T>): T {
+        return this.#valuesCache.get(key) as T;
+    }
+
+}

package/src/stores/GGConfigStoreLocal.ts

@@ -1,110 +1,110 @@
-import {GGConfigStore} from "../GGConfigStore";
-import {GGConfigKey, Widen} from "../GGConfigKey";
-import {deepFreeze} from "@grest-ts/common";
-
-/**
- * Extracts the keys from T that are GGConfigKey instances or objects containing them.
- * Uses a depth limit (D) to prevent infinite recursion on circular types (e.g. GGSchema).
- */
-type ConfigKeyOf<T, D extends 1[] = []> = D['length'] extends 5 ? never : {
-    [K in keyof T]: [T[K]] extends [never] ? never :
-        T[K] extends GGConfigKey<any> ? K :
-            T[K] extends Function ? never :
-                T[K] extends object ? (ConfigKeyOf<T[K], [...D, 1]> extends never ? never : K) : never
-}[keyof T];
-
-/**
- * Maps a config definition to the shape of values it expects.
- * GGConfigKey<V> → V, objects with config keys → recurse, everything else → excluded.
- */
-export type ConfigValues<T, D extends 1[] = []> =
-    D['length'] extends 5 ? never :
-        T extends GGConfigKey<infer V> ? Widen<V> :
-            T extends object ? (
-                ConfigKeyOf<T, D> extends never ? never : { [K in ConfigKeyOf<T, D>]: ConfigValues<T[K], [...D, 1]> }
-                ) : never;
-
-/**
- * Type-checks a local config values object against a config definition.
- * Returns the values object as-is — this is a compile-time helper, not a store.
- *
- * Use with GGConfigStoreLocal in your runtime's compose():
- * @example
- * ```typescript
- * // config/local.ts — just data:
- * export default createLocalConfig(MyConfig, {
- *     mysql: {
- *         host: { host: "localhost", port: 3306, database: "mydb" },
- *         user: { username: "root", password: "root" },
- *     },
- *     jwtSecret: "dev-secret",
- * })
- *
- * // runtime.ts — fresh store per compose():
- * import localConfig from "./config/local.js";
- * new GGConfigLocator(MyConfig)
- *     .add([GGResource, GGSecret], new GGConfigStoreLocal(MyConfig, localConfig))
- * ```
- */
-export function createLocalConfig<T extends object>(_config: T, values: ConfigValues<T>): ConfigValues<T> {
-    deepFreeze(values)
-    return values;
-}
-
-/**
- * Type-safe local development config store.
- * Refuses to start in production — crashes immediately if NODE_ENV is "production".
- * Use createLocalConfig() for the best DX, or .set() for manual control.
- */
-export class GGConfigStoreLocal<Struct extends object, Key extends GGConfigKey = GGConfigKey> extends GGConfigStore<Key> {
-
-    readonly #values = new Map<GGConfigKey, unknown>();
-    readonly #valuesCache = new Map<GGConfigKey, unknown>();
-
-    constructor(config: Struct, values: ConfigValues<Struct>) {
-        super();
-        walkAndSet(this, config, values);
-    }
-
-    public set<T>(key: GGConfigKey<T>, value: T): this {
-        this.#values.set(key, value);
-        return this;
-    }
-
-    public override async start(): Promise<void> {
-        if (process.env.NODE_ENV === "production") {
-            throw new Error(
-                "GGConfigStoreLocal cannot be used in production. " +
-                "Use GGConfigStoreAwsSecretsManager or another production-safe store."
-            );
-        }
-
-        this.keys.forEach(key => {
-            this.#valuesCache.set(key, this.resolveValue(key, this.#values.get(key), true));
-        });
-
-        await super.start();
-    }
-
-    public override async teardown(): Promise<void> {
-        this.#valuesCache.clear();
-        await super.teardown();
-    }
-
-    public getValue<T>(key: GGConfigKey<T>): T {
-        return this.#valuesCache.get(key) as T;
-    }
-
-}
-
-function walkAndSet(store: GGConfigStoreLocal<any>, config: any, values: any) {
-    for (const prop of Object.keys(values)) {
-        const configEntry = config[prop];
-        const value = values[prop];
-        if (configEntry instanceof GGConfigKey) {
-            store.set(configEntry, value);
-        } else if (configEntry != null && typeof configEntry === 'object' && value != null && typeof value === 'object') {
-            walkAndSet(store, configEntry, value);
-        }
-    }
+import {GGConfigStore} from "../GGConfigStore";
+import {GGConfigKey, Widen} from "../GGConfigKey";
+import {deepFreeze} from "@grest-ts/common";
+
+/**
+ * Extracts the keys from T that are GGConfigKey instances or objects containing them.
+ * Uses a depth limit (D) to prevent infinite recursion on circular types (e.g. GGSchema).
+ */
+type ConfigKeyOf<T, D extends 1[] = []> = D['length'] extends 5 ? never : {
+    [K in keyof T]: [T[K]] extends [never] ? never :
+        T[K] extends GGConfigKey<any> ? K :
+            T[K] extends Function ? never :
+                T[K] extends object ? (ConfigKeyOf<T[K], [...D, 1]> extends never ? never : K) : never
+}[keyof T];
+
+/**
+ * Maps a config definition to the shape of values it expects.
+ * GGConfigKey<V> → V, objects with config keys → recurse, everything else → excluded.
+ */
+export type ConfigValues<T, D extends 1[] = []> =
+    D['length'] extends 5 ? never :
+        T extends GGConfigKey<infer V> ? Widen<V> :
+            T extends object ? (
+                ConfigKeyOf<T, D> extends never ? never : { [K in ConfigKeyOf<T, D>]: ConfigValues<T[K], [...D, 1]> }
+                ) : never;
+
+/**
+ * Type-checks a local config values object against a config definition.
+ * Returns the values object as-is — this is a compile-time helper, not a store.
+ *
+ * Use with GGConfigStoreLocal in your runtime's compose():
+ * @example
+ * ```typescript
+ * // config/local.ts — just data:
+ * export default createLocalConfig(MyConfig, {
+ *     mysql: {
+ *         host: { host: "localhost", port: 3306, database: "mydb" },
+ *         user: { username: "root", password: "root" },
+ *     },
+ *     jwtSecret: "dev-secret",
+ * })
+ *
+ * // runtime.ts — fresh store per compose():
+ * import localConfig from "./config/local.js";
+ * new GGConfigLocator(MyConfig)
+ *     .add([GGResource, GGSecret], new GGConfigStoreLocal(MyConfig, localConfig))
+ * ```
+ */
+export function createLocalConfig<T extends object>(_config: T, values: ConfigValues<T>): ConfigValues<T> {
+    deepFreeze(values)
+    return values;
+}
+
+/**
+ * Type-safe local development config store.
+ * Refuses to start in production — crashes immediately if NODE_ENV is "production".
+ * Use createLocalConfig() for the best DX, or .set() for manual control.
+ */
+export class GGConfigStoreLocal<Struct extends object, Key extends GGConfigKey = GGConfigKey> extends GGConfigStore<Key> {
+
+    readonly #values = new Map<GGConfigKey, unknown>();
+    readonly #valuesCache = new Map<GGConfigKey, unknown>();
+
+    constructor(config: Struct, values: ConfigValues<Struct>) {
+        super();
+        walkAndSet(this, config, values);
+    }
+
+    public set<T>(key: GGConfigKey<T>, value: T): this {
+        this.#values.set(key, value);
+        return this;
+    }
+
+    public override async start(): Promise<void> {
+        if (process.env.NODE_ENV === "production") {
+            throw new Error(
+                "GGConfigStoreLocal cannot be used in production. " +
+                "Use GGConfigStoreAwsSecretsManager or another production-safe store."
+            );
+        }
+
+        this.keys.forEach(key => {
+            this.#valuesCache.set(key, this.resolveValue(key, this.#values.get(key), true));
+        });
+
+        await super.start();
+    }
+
+    public override async teardown(): Promise<void> {
+        this.#valuesCache.clear();
+        await super.teardown();
+    }
+
+    public getValue<T>(key: GGConfigKey<T>): T {
+        return this.#valuesCache.get(key) as T;
+    }
+
+}
+
+function walkAndSet(store: GGConfigStoreLocal<any>, config: any, values: any) {
+    for (const prop of Object.keys(values)) {
+        const configEntry = config[prop];
+        const value = values[prop];
+        if (configEntry instanceof GGConfigKey) {
+            store.set(configEntry, value);
+        } else if (configEntry != null && typeof configEntry === 'object' && value != null && typeof value === 'object') {
+            walkAndSet(store, configEntry, value);
+        }
+    }
 }