@fluojs/config 1.0.0-beta.4 → 1.0.0-beta.6

package/README.ko.md

@@ -91,6 +91,8 @@ class MyService {
 
 `ConfigReloadManager.reload()`는 리로드 작업을 직렬화합니다. 현재 리로드가 listener 알림을 수행하는 동안 다른 리로드가 요청되면 후속 리로드는 큐에 들어가 활성 알림이 끝난 뒤 적용됩니다. 활성 알림이 실패하면 이전 snapshot을 복구하고 큐에 있던 리로드는 폐기합니다. 동일한 직렬화와 rollback 계약은 `createConfigReloader(...).reload()`에도 적용되며, watch로 시작된 알림 중 큐에 들어간 manual reload도 이 계약을 따릅니다.
 
+Module registration과 reloader 생성은 caller-owned options를 저장하기 전에 snapshot으로 분리합니다. `ConfigModule.forRoot(...)`, `ConfigReloadModule.forRoot(...)`, `createConfigReloader(...)`에 넘긴 객체를 나중에 변경해도 bootstrap, manual reload, watch reload 입력은 바뀌지 않습니다. Watch mode에서 시작 시점에 env file이 없으면 빈 file snapshot처럼 취급하고 parent directory를 watch하므로, 나중에 env file을 생성해도 reload가 트리거될 수 있습니다. Watch reload는 reload 전에 최종 env file content를 마지막으로 commit된 watch baseline과 비교하므로, 내용이 바뀌지 않은 저장이나 변경 후 debounce 안에서 원래 내용으로 되돌린 burst는 인프로세스 config snapshot을 교체하지 않습니다.
+
 ## 공개 API
 
 | 클래스/헬퍼 | 설명 |

package/README.md

@@ -95,6 +95,8 @@ The `schema` option accepts a synchronous [Standard Schema](https://standardsche
 
 `ConfigReloadManager.reload()` serializes reload work. If another reload is requested while the current reload is notifying listeners, the follow-up reload is queued and applied after the active notification finishes; if the active notification fails, the previous snapshot is restored and the queued reload is discarded. The same serialization and rollback contract applies to `createConfigReloader(...).reload()`, including manual reloads queued during watch-triggered notifications.
 
+Module registration and reloader creation snapshot caller-owned options before storing them. Later mutations to objects passed to `ConfigModule.forRoot(...)`, `ConfigReloadModule.forRoot(...)`, or `createConfigReloader(...)` do not affect bootstrap, manual reloads, or watch reloads. In watch mode, a missing env file at startup is treated as an empty file snapshot while the parent directory is watched so creating the env file later can still trigger reload. Watch reloads compare the final env file content with the last committed watch baseline before reloading, so unchanged saves and change-then-revert bursts do not replace the in-process config snapshot.
+
 ## Public API
 
 | Class/Helper | Description |

package/dist/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EAEjB,cAAc,EAKf,MAAM,YAAY,CAAC;AA0XpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CA8B/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAEvE"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EAEjB,cAAc,EAKf,MAAM,YAAY,CAAC;AAwZpB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAgC/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAEvE"}

package/dist/load.js

@@ -1,9 +1,11 @@
+import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, watch } from 'node:fs';
-import { join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { FluoError } from '@fluojs/core';
 import { parse as dotenvParse } from 'dotenv';
 import { expand as dotenvExpand } from 'dotenv-expand';
 import { cloneConfigDictionary } from './clone.js';
+import { snapshotConfigLoadOptions } from './options.js';
 const reloadFailureReasons = new WeakMap();
 function markReloadFailure(error, reason) {
   if (typeof error === 'object' && error !== null) {
@@ -179,6 +181,16 @@ function createSubscription(listeners, listener) {
     }
   };
 }
+function hashEnvFileContent(envFile) {
+  try {
+    return createHash('sha256').update(readFileSync(envFile)).digest('hex');
+  } catch (error) {
+    if (typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT') {
+      return undefined;
+    }
+    throw error;
+  }
+}
 function notifyReloadListeners(listeners, snapshot, reason) {
   for (const listener of listeners) {
     listener(cloneConfigDictionary(snapshot), reason);
@@ -226,14 +238,27 @@ function applyReload(normalized, state, listeners, reason) {
   }
 }
 function startReloaderWatcher(normalized, options, state, listeners, errorListeners) {
-  if (!options.watch || !existsSync(normalized.envFile)) {
+  if (!options.watch) {
     return undefined;
   }
-  return watch(normalized.envFile, {
+  const watchTarget = existsSync(normalized.envFile) ? normalized.envFile : dirname(normalized.envFile);
+  const watchedEnvFileName = basename(normalized.envFile);
+  if (!existsSync(watchTarget)) {
+    return undefined;
+  }
+  return watch(watchTarget, {
     persistent: false
-  }, () => {
+  }, (_eventType, filename) => {
+    if (watchTarget !== normalized.envFile && filename !== null && filename.toString() !== watchedEnvFileName) {
+      return;
+    }
     try {
+      const nextEnvFileHash = hashEnvFileContent(normalized.envFile);
+      if (nextEnvFileHash === state.watchedEnvFileHash) {
+        return;
+      }
       applyReload(normalized, state, listeners, 'watch');
+      state.watchedEnvFileHash = nextEnvFileHash;
     } catch (error) {
       notifyReloadErrorListeners(errorListeners, error, getReloadFailureReason(error) ?? 'watch');
     }
@@ -269,16 +294,18 @@ function closeReloader(state, listeners, errorListeners) {
  * ```
  */
 export function createConfigReloader(options) {
-  const normalized = normalizeLoadOptions(options);
+  const loadOptions = snapshotConfigLoadOptions(options);
+  const normalized = normalizeLoadOptions(loadOptions);
   const state = {
     current: resolveConfig(normalized),
     pendingReloadReason: undefined,
     reloading: false,
+    watchedEnvFileHash: hashEnvFileContent(normalized.envFile),
     watcher: undefined
   };
   const listeners = new Set();
   const errorListeners = new Set();
-  state.watcher = startReloaderWatcher(normalized, options, state, listeners, errorListeners);
+  state.watcher = startReloaderWatcher(normalized, loadOptions, state, listeners, errorListeners);
   return {
     close() {
       closeReloader(state, listeners, errorListeners);

package/dist/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;GAEG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,UAAU,YAAY;CAgBtE"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;GAEG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,UAAU,YAAY;CAiBtE"}

package/dist/module.js

@@ -1,5 +1,6 @@
 import { defineModuleMetadata } from '@fluojs/core/internal';
 import { loadConfig } from './load.js';
+import { snapshotConfigModuleOptions } from './options.js';
 import { ConfigService, createConfigServiceFromSnapshot } from './service.js';
 /**
  * Module facade that wires normalized configuration into the application container.
@@ -25,13 +26,14 @@ export class ConfigModule {
    * ```
    */
   static forRoot(options) {
+    const loadOptions = snapshotConfigModuleOptions(options);
     class ConfigModuleImpl extends ConfigModule {}
     defineModuleMetadata(ConfigModuleImpl, {
-      global: options?.isGlobal ?? true,
+      global: loadOptions.isGlobal ?? true,
       exports: [ConfigService],
       providers: [{
         provide: ConfigService,
-        useFactory: () => createConfigServiceFromSnapshot(loadConfig(options ?? {}))
+        useFactory: () => createConfigServiceFromSnapshot(loadConfig(loadOptions))
       }]
     });
     return ConfigModuleImpl;

package/dist/options.d.ts

@@ -0,0 +1,16 @@
+import type { ConfigLoadOptions, ConfigModuleOptions } from './types.js';
+/**
+ * Creates a detached snapshot of config module registration options.
+ *
+ * @param options Caller-owned module options captured at registration time.
+ * @returns Options that cannot observe later caller mutations of config dictionaries.
+ */
+export declare function snapshotConfigModuleOptions(options?: ConfigModuleOptions): ConfigModuleOptions;
+/**
+ * Creates a detached snapshot of config load and reload options.
+ *
+ * @param options Caller-owned load options captured by loaders or reload modules.
+ * @returns Options that preserve registration-time config dictionary inputs.
+ */
+export declare function snapshotConfigLoadOptions(options?: ConfigLoadOptions): ConfigLoadOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAoB,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAsB3F;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,CAU9F;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAWxF"}

package/dist/options.js

@@ -0,0 +1,51 @@
+import { cloneConfigDictionary } from './clone.js';
+function snapshotConfigDictionary(value) {
+  return value === undefined ? undefined : cloneConfigDictionary(value);
+}
+function snapshotProcessEnv(processEnv) {
+  if (processEnv === undefined) {
+    return undefined;
+  }
+  const snapshot = {};
+  for (const [key, value] of Object.entries(processEnv)) {
+    if (value !== undefined) {
+      snapshot[key] = value;
+    }
+  }
+  return Object.freeze(snapshot);
+}
+
+/**
+ * Creates a detached snapshot of config module registration options.
+ *
+ * @param options Caller-owned module options captured at registration time.
+ * @returns Options that cannot observe later caller mutations of config dictionaries.
+ */
+export function snapshotConfigModuleOptions(options) {
+  if (options === undefined) {
+    return {};
+  }
+  return Object.freeze({
+    ...options,
+    defaults: snapshotConfigDictionary(options.defaults),
+    processEnv: snapshotProcessEnv(options.processEnv)
+  });
+}
+
+/**
+ * Creates a detached snapshot of config load and reload options.
+ *
+ * @param options Caller-owned load options captured by loaders or reload modules.
+ * @returns Options that preserve registration-time config dictionary inputs.
+ */
+export function snapshotConfigLoadOptions(options) {
+  if (options === undefined) {
+    return {};
+  }
+  return Object.freeze({
+    ...options,
+    defaults: snapshotConfigDictionary(options.defaults),
+    processEnv: snapshotProcessEnv(options.processEnv),
+    runtimeOverrides: snapshotConfigDictionary(options.runtimeOverrides)
+  });
+}

package/dist/reload-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reload-module.d.ts","sourceRoot":"","sources":["../src/reload-module.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EAEd,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAIpB;;GAEG;AACH,eAAO,MAAM,eAAe,eAAiC,CAAC;AAY9D;;GAEG;AACH,qBACa,mBAAoB,YAAW,cAAc;IAQtD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAR1B,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,eAAe,CAAuC;IAC9D,OAAO,CAAC,cAAc,CAAuC;IAC7D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAmC;IACnE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwC;gBAGpD,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,iBAAiB;IAG7C,OAAO,IAAI,gBAAgB;IAI3B,MAAM,IAAI,gBAAgB;IAI1B,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,wBAAwB;IAInE,cAAc,CAAC,QAAQ,EAAE,yBAAyB,GAAG,wBAAwB;IAI7E,KAAK,IAAI,IAAI;IAeb,sBAAsB,IAAI,IAAI;IAQ9B,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,cAAc;CA8BvB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,UAAU,kBAAkB;CAsB1E"}
+{"version":3,"file":"reload-module.d.ts","sourceRoot":"","sources":["../src/reload-module.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,aAAa,EAEd,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EACzB,cAAc,EACd,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAIpB;;GAEG;AACH,eAAO,MAAM,eAAe,eAAiC,CAAC;AAY9D;;GAEG;AACH,qBACa,mBAAoB,YAAW,cAAc;IAQtD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAR1B,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,eAAe,CAAuC;IAC9D,OAAO,CAAC,cAAc,CAAuC;IAC7D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAmC;IACnE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwC;gBAGpD,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,iBAAiB;IAG7C,OAAO,IAAI,gBAAgB;IAI3B,MAAM,IAAI,gBAAgB;IAI1B,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,wBAAwB;IAInE,cAAc,CAAC,QAAQ,EAAE,yBAAyB,GAAG,wBAAwB;IAI7E,KAAK,IAAI,IAAI;IAeb,sBAAsB,IAAI,IAAI;IAQ9B,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,cAAc;CA8BvB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,UAAU,kBAAkB;CAsB1E"}

package/dist/reload-module.js

@@ -8,6 +8,7 @@ import { Inject } from '@fluojs/core';
 import { defineModuleMetadata } from '@fluojs/core/internal';
 import { cloneConfigDictionary } from './clone.js';
 import { createConfigReloader } from './load.js';
+import { snapshotConfigLoadOptions } from './options.js';
 import { ConfigService, replaceConfigServiceSnapshotUnchecked } from './service.js';
 const CONFIG_RELOAD_OPTIONS = Symbol('fluo.config.reload-options');
 
@@ -110,7 +111,7 @@ class ConfigReloadManager {
 export { _ConfigReloadManager as ConfigReloadManager };
 export class ConfigReloadModule {
   static forRoot(options) {
-    const loadOptions = options ?? {};
+    const loadOptions = snapshotConfigLoadOptions(options);
     class ConfigReloadModuleImpl extends ConfigReloadModule {}
     defineModuleMetadata(ConfigReloadModuleImpl, {
       exports: [CONFIG_RELOADER],

package/package.json

@@ -8,7 +8,7 @@
     "environment",
     "typed-config"
   ],
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -38,7 +38,7 @@
     "@standard-schema/spec": "^1.1.0",
     "dotenv": "^16.0.0",
     "dotenv-expand": "^11.0.0",
-    "@fluojs/core": "^1.0.0-beta.2"
+    "@fluojs/core": "^1.0.0-beta.3"
   },
   "devDependencies": {
     "vitest": "^3.2.4"