key-rotation-manager 1.0.10 → 1.0.11

package/README.md

@@ -521,13 +521,13 @@ const cloned = original.clone({
 
 ## 📖 API Reference
 
-### `create(options?, only?)`
+### `create(options?, singleton?)`
 
 Creates a new KeyManager instance.
 
 **Parameters:**
 - `options` (optional): Partial `TModuleOptions`
-- `only` (optional): `boolean` - If `false`, returns a singleton instance
+- `singleton` (optional): `boolean` - If `true`, returns a shared singleton instance (default: `false`)
 
 **Returns:** `KM` instance
 
@@ -535,7 +535,7 @@ Creates a new KeyManager instance.
 ```typescript
 const km = create({ versionGenerator: () => 'v1' });
 // or
-const km = create({}, false); // Singleton instance
+const km = create({}, true); // Singleton instance
 ```
 
 ### `newKey(options, variables?)`

package/dist/index.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
-var EventEmitter = require('events');
 var promises = require('fs/promises');
 var path = require('path');
 var CryptoJS = require('crypto-js');
+var EventEmitter = require('events');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
 var CryptoJS__default = /*#__PURE__*/_interopDefault(CryptoJS);
+var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
 
 // src/constants/default.constant.ts
 var DEFAULT_CRYPTO_OPTIONS = {
@@ -59,99 +59,6 @@ var EEvent = /* @__PURE__ */ ((EEvent2) => {
   return EEvent2;
 })(EEvent || {});
 
-// src/types/module.types.ts
-var EError = /* @__PURE__ */ ((EError2) => {
-  return EError2;
-})(EError || {});
-
-// src/core/base.core.ts
-var Base = class {
-  logger;
-  bOptions;
-  hooks = /* @__PURE__ */ new Map();
-  constructor(options) {
-    this.bOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
-    this.logger = DEFAULT_BASE_LOGGER;
-  }
-  getLogger() {
-    return this.logger;
-  }
-  setLogger(logger) {
-    this.logger = logger;
-    return this;
-  }
-  async sysLog(...args) {
-    if (!this.bOptions.quiet) await this.logger(...args);
-    return this;
-  }
-  async customLog(logger, ...args) {
-    await logger(...args);
-    return this;
-  }
-  setHooks(hooks) {
-    Object.entries(hooks).forEach(([name, handler]) => {
-      if (this.hooks.has(name)) {
-        this.hooks.get("onHookOverriding")?.call(this, name);
-      }
-      this.hooks.set(name, handler);
-    });
-    return this;
-  }
-  runHook(name, ...args) {
-    if (!this.hooks.has(name)) {
-      this.hooks.get("onHookNotFound")?.call(this, name);
-      return void 0;
-    }
-    return this.hooks.get(name).call(this, ...args);
-  }
-  getHooks() {
-    return Object.fromEntries(this.hooks.entries());
-  }
-};
-
-// src/core/events.core.ts
-var Events = class extends Base {
-  events;
-  eOptions;
-  constructor(options) {
-    super(options);
-    this.eOptions = {
-      ...DEFAULT_EVENTS_OPTIONS,
-      ...options
-    };
-    if (this.eOptions.useEvent) {
-      this.events = new EventEmitter__default.default();
-    }
-  }
-  emit(event, args) {
-    if (!this.events) return this;
-    this.events.emit(event, args);
-    return this;
-  }
-  on(event, listener) {
-    if (!this.events) return this;
-    this.events.on(event, listener);
-    return this;
-  }
-  once(event, listener) {
-    if (!this.events) return this;
-    this.events.once(event, listener);
-    return this;
-  }
-  off(event, listener) {
-    if (!this.events) return this;
-    this.events.off(event, listener);
-    return this;
-  }
-};
-
-// src/core/config-events.core.ts
-var ConfigEvents = class extends Events {
-  constructor(options) {
-    super(options);
-  }
-};
-
 // src/utils/promise.util.ts
 var executePromisably = (promiseOrFn) => {
   try {
@@ -161,35 +68,45 @@ var executePromisably = (promiseOrFn) => {
     return Promise.reject(error);
   }
 };
+var FileUtilError = class extends Error {
+  constructor(message, path, operation, cause) {
+    super(message);
+    this.path = path;
+    this.operation = operation;
+    this.cause = cause;
+    this.name = "FileUtilError";
+  }
+};
 var FileUtil = class {
   async getFolder(path) {
     try {
+      await promises.access(path);
+      return path;
+    } catch {
       try {
-        await promises.access(path);
-      } catch {
         await promises.mkdir(path, { recursive: true });
+        return path;
+      } catch (error) {
+        throw new FileUtilError(`Failed to create folder: ${path}`, path, "mkdir", error);
       }
-      return path;
-    } catch {
-      throw new Error(`Failed to get folder: ${path}`);
     }
   }
-  async read(path, fallback = "") {
+  async read(path, fallback) {
     try {
       const data = await promises.readFile(path, { encoding: "utf8" });
       return data;
     } catch (error) {
-      if (fallback) return fallback;
-      throw error;
+      if (fallback !== void 0) return fallback;
+      throw new FileUtilError(`Failed to read file: ${path}`, path, "read", error);
     }
   }
   async write(path$1, data, flag = "w") {
+    const dir = path.dirname(path$1);
+    await this.getFolder(dir);
     try {
-      const dir = path.dirname(path$1);
-      await this.getFolder(dir);
       await promises.writeFile(path$1, data, { encoding: "utf8", flag });
     } catch (error) {
-      throw new Error(`Failed to write file: ${path$1}`);
+      throw new FileUtilError(`Failed to write file: ${path$1}`, path$1, "write", error);
     }
   }
   async checkExists(path) {
@@ -197,14 +114,14 @@ var FileUtil = class {
       await promises.access(path);
       return true;
     } catch {
-      throw new Error(`Failed to check existence of file: ${path}`);
+      return false;
     }
   }
   async delete(path) {
     try {
       await promises.unlink(path);
-    } catch {
-      throw new Error(`Failed to delete file: ${path}`);
+    } catch (error) {
+      throw new FileUtilError(`Failed to delete file: ${path}`, path, "delete", error);
     }
   }
 };
@@ -476,7 +393,96 @@ var CryptoService = class {
     return hashStr === expectedHashStr;
   }
 };
-var Store = class extends ConfigEvents {
+
+// src/core/base.core.ts
+var Base = class {
+  logger;
+  bOptions;
+  hooks = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.bOptions = { ...DEFAULT_BASE_OPTIONS, ...options };
+    this.logger = DEFAULT_BASE_LOGGER;
+  }
+  getLogger() {
+    return this.logger;
+  }
+  setLogger(logger) {
+    this.logger = logger;
+    return this;
+  }
+  sysLog(...args) {
+    if (!this.bOptions.quiet) {
+      const result = this.logger(...args);
+      if (result && typeof result === "object" && "catch" in result) {
+        result.catch(() => {
+        });
+      }
+    }
+    return this;
+  }
+  async customLog(logger, ...args) {
+    await logger(...args);
+    return this;
+  }
+  setHooks(hooks) {
+    Object.entries(hooks).forEach(([name, handler]) => {
+      if (this.hooks.has(name)) {
+        this.hooks.get("onHookOverriding")?.call(this, name);
+      }
+      this.hooks.set(name, handler);
+    });
+    return this;
+  }
+  runHook(name, ...args) {
+    if (!this.hooks.has(name)) {
+      this.hooks.get("onHookNotFound")?.call(this, name);
+      return void 0;
+    }
+    return this.hooks.get(name).call(this, ...args);
+  }
+  getHooks() {
+    return Object.fromEntries(this.hooks.entries());
+  }
+};
+
+// src/core/events.core.ts
+var Events = class extends Base {
+  events;
+  eOptions;
+  constructor(options) {
+    super(options);
+    this.eOptions = {
+      ...DEFAULT_EVENTS_OPTIONS,
+      ...options
+    };
+    if (this.eOptions.useEvent) {
+      this.events = new EventEmitter__default.default();
+    }
+  }
+  emit(event, args) {
+    if (!this.events) return this;
+    this.events.emit(event, args);
+    return this;
+  }
+  on(event, listener) {
+    if (!this.events) return this;
+    this.events.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    if (!this.events) return this;
+    this.events.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    if (!this.events) return this;
+    this.events.off(event, listener);
+    return this;
+  }
+};
+
+// src/core/store.core.ts
+var Store = class extends Events {
   sOptions;
   fileUtil;
   storePath;
@@ -663,21 +669,21 @@ var KeyManager = class extends Store {
    *   console.log('Key was rotated from version:', expired.version);
    * }
    *
-   * // Use expired.originKey ?? ready.originKey safely
+   * // Use expired?.key ?? ready?.key safely
    * ```
    */
   async getKey(options) {
     const { path, version } = options;
     const key = await this.getKeyByStore(path, String(version));
     if (!key) {
-      await this.runKeyHook("onKeyNotFound", path, version);
+      this.runKeyHook("onKeyNotFound", path, version);
       this.sysLog(`Key not found!`, { path, version });
       return { expired: null, ready: null };
     }
     const { ok, message, isExpired, isRenewable, errorOn } = this.validateKey(key);
     if (!ok && isExpired && isRenewable && key) {
       if (!options.onRotate) {
-        await this.runKeyHook("onKeyMissingRotateOption", key, options);
+        this.runKeyHook("onKeyMissingRotateOption", key, options);
         this.sysLog(`Key missing rotate option!`, { path, version });
         return { expired: null, ready: null };
       }
@@ -686,17 +692,17 @@ var KeyManager = class extends Store {
         ...options.onRotate
       });
       const resGetKey = { expired: key, ready: renew.key };
-      await this.runKeyHook("onKeyRenewed", resGetKey, options);
+      this.runKeyHook("onKeyRenewed", resGetKey, options);
       this.sysLog(`Key renewed!`, { path, version });
       return resGetKey;
     }
     if (!ok && isExpired && !isRenewable && key) {
-      await this.runKeyHook("onKeyExpired", path, key);
+      this.runKeyHook("onKeyExpired", path, key);
       this.sysLog(`Key expired!`, { path, version });
       return { expired: key, ready: null };
     }
     if (!ok) {
-      await this.runKeyHook("onKeyInvalid", key, message, errorOn);
+      this.runKeyHook("onKeyInvalid", key, message, errorOn);
       this.sysLog(`Key invalid!`, { path, version });
       return { expired: null, ready: null };
     }
@@ -743,7 +749,7 @@ var KeyManager = class extends Store {
     const { rotate, duration, type, unit, merge, keyLength } = options;
     const { key, length: kLength } = this.cryptoService.generateKey(keyLength);
     const { salt } = this.cryptoService.generateSalt();
-    await this.sysLog(`Key generated
+    this.sysLog(`Key generated
 Options:`, options);
     const hashedKey = this.cryptoService.hash(key, salt);
     const now = /* @__PURE__ */ new Date();
@@ -758,7 +764,7 @@ Options:`, options);
       rotate: !!rotate
     };
     const path = await this.saveKeyToStore(keyGenerated, !!merge, variables);
-    await this.sysLog(`Key saved!`, {
+    this.sysLog(`Key saved!`, {
       path,
       version: keyGenerated.version,
       type: keyGenerated.type
@@ -788,7 +794,7 @@ Options:`, options);
       hashed: "string",
       rotate: "boolean",
       type: "string",
-      version: "string",
+      version: "stringNumber",
       hashedBytes: "number"
     };
     for (const [field, type] of Object.entries(typeChecks)) {
@@ -883,8 +889,8 @@ var KM = class _KM extends KeyManager {
 
 // src/index.ts
 var instance = null;
-var create = (options = {}, only = true) => {
-  if (only) return new KM(options);
+var create = (options = {}, singleton = false) => {
+  if (!singleton) return new KM(options);
   if (!instance) {
     instance = new KM(options);
   }
@@ -892,7 +898,6 @@ var create = (options = {}, only = true) => {
 };
 var km = create;
 
-exports.EError = EError;
 exports.EEvent = EEvent;
 exports.create = create;
 exports.km = km;