@naman_deep_singh/security 1.5.1 → 1.7.0

package/dist/cjs/core/password/{passwordManager.js → PasswordManager.js}

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PasswordManager = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const errors_utils_1 = require("@naman_deep_singh/errors-utils");
-const utils_1 = require("./utils");
+const errors_1 = require("@naman_deep_singh/errors");
+const utils_js_1 = require("./utils.js");
 class PasswordManager {
     constructor(config = {}) {
         this.defaultConfig = {
@@ -26,7 +26,7 @@ class PasswordManager {
      */
     async hash(password, salt) {
         try {
-            (0, utils_1.ensureValidPassword)(password);
+            (0, utils_js_1.ensureValidPassword)(password);
             this.validate(password);
             const saltRounds = this.defaultConfig.saltRounds;
             let finalSalt = salt;
@@ -37,11 +37,11 @@ class PasswordManager {
             return { hash, salt: finalSalt };
         }
         catch (error) {
-            if (error instanceof errors_utils_1.BadRequestError ||
-                error instanceof errors_utils_1.ValidationError) {
+            if (error instanceof errors_1.BadRequestError ||
+                error instanceof errors_1.ValidationError) {
                 throw error;
             }
-            throw new errors_utils_1.BadRequestError({ reason: 'Failed to hash password' }, error instanceof Error ? error : undefined);
+            throw new errors_1.BadRequestError({ reason: 'Failed to hash password' }, error instanceof Error ? error : undefined);
         }
     }
     /**
@@ -64,7 +64,7 @@ class PasswordManager {
     generate(length = 16, options = {}) {
         const config = { ...this.defaultConfig, ...options };
         if (length < config.minLength || length > config.maxLength) {
-            throw new errors_utils_1.ValidationError({
+            throw new errors_1.ValidationError({
                 reason: `Password length must be between ${config.minLength} and ${config.maxLength}`,
             });
         }
@@ -127,7 +127,7 @@ class PasswordManager {
      * Check password strength
      */
     checkStrength(password) {
-        const entropy = (0, utils_1.estimatePasswordEntropy)(password);
+        const entropy = (0, utils_js_1.estimatePasswordEntropy)(password);
         let score = 0;
         const feedback = [];
         const suggestions = [];

package/dist/cjs/core/password/hash.js

@@ -6,20 +6,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hashPasswordSync = exports.hashPassword = void 0;
 exports.hashPasswordWithPepper = hashPasswordWithPepper;
 exports.hashPasswordWithPepperSync = hashPasswordWithPepperSync;
-const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const errors_1 = require("@naman_deep_singh/errors");
 const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const utils_1 = require("./utils");
+const utils_js_1 = require("./utils.js");
 /**
  * Hash a password asynchronously using bcrypt.
  */
 const hashPassword = async (password, saltRounds = 10) => {
     try {
-        (0, utils_1.ensureValidPassword)(password);
+        (0, utils_js_1.ensureValidPassword)(password);
         const salt = await bcryptjs_1.default.genSalt(saltRounds);
         return bcryptjs_1.default.hash(password, salt);
     }
     catch (error) {
-        throw new errors_utils_1.InternalServerError({ reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
+        throw new errors_1.InternalServerError(undefined, { reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
     }
 };
 exports.hashPassword = hashPassword;
@@ -31,12 +31,12 @@ function hashPasswordWithPepper(password, pepper) {
  */
 const hashPasswordSync = (password, saltRounds = 10) => {
     try {
-        (0, utils_1.ensureValidPassword)(password);
+        (0, utils_js_1.ensureValidPassword)(password);
         const salt = bcryptjs_1.default.genSaltSync(saltRounds);
         return bcryptjs_1.default.hashSync(password, salt);
     }
     catch (error) {
-        throw new errors_utils_1.InternalServerError({ reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
+        throw new errors_1.InternalServerError(undefined, { reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
     }
 };
 exports.hashPasswordSync = hashPasswordSync;

package/dist/cjs/core/password/index.js

@@ -1,19 +1,22 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hash"), exports);
-__exportStar(require("./strength"), exports);
-__exportStar(require("./verify"), exports);
+exports.normalizePassword = exports.estimatePasswordEntropy = exports.safeCompare = exports.ensureValidPassword = exports.PasswordManager = exports.verifyPasswordWithPepperSync = exports.verifyPasswordSync = exports.verifyPasswordWithPepper = exports.verifyPassword = exports.isPasswordStrong = exports.hashPasswordWithPepperSync = exports.hashPasswordSync = exports.hashPasswordWithPepper = exports.hashPassword = void 0;
+var hash_js_1 = require("./hash.js");
+Object.defineProperty(exports, "hashPassword", { enumerable: true, get: function () { return hash_js_1.hashPassword; } });
+Object.defineProperty(exports, "hashPasswordWithPepper", { enumerable: true, get: function () { return hash_js_1.hashPasswordWithPepper; } });
+Object.defineProperty(exports, "hashPasswordSync", { enumerable: true, get: function () { return hash_js_1.hashPasswordSync; } });
+Object.defineProperty(exports, "hashPasswordWithPepperSync", { enumerable: true, get: function () { return hash_js_1.hashPasswordWithPepperSync; } });
+var strength_js_1 = require("./strength.js");
+Object.defineProperty(exports, "isPasswordStrong", { enumerable: true, get: function () { return strength_js_1.isPasswordStrong; } });
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "verifyPassword", { enumerable: true, get: function () { return verify_js_1.verifyPassword; } });
+Object.defineProperty(exports, "verifyPasswordWithPepper", { enumerable: true, get: function () { return verify_js_1.verifyPasswordWithPepper; } });
+Object.defineProperty(exports, "verifyPasswordSync", { enumerable: true, get: function () { return verify_js_1.verifyPasswordSync; } });
+Object.defineProperty(exports, "verifyPasswordWithPepperSync", { enumerable: true, get: function () { return verify_js_1.verifyPasswordWithPepperSync; } });
+var PasswordManager_js_1 = require("./PasswordManager.js");
+Object.defineProperty(exports, "PasswordManager", { enumerable: true, get: function () { return PasswordManager_js_1.PasswordManager; } });
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "ensureValidPassword", { enumerable: true, get: function () { return utils_js_1.ensureValidPassword; } });
+Object.defineProperty(exports, "safeCompare", { enumerable: true, get: function () { return utils_js_1.safeCompare; } });
+Object.defineProperty(exports, "estimatePasswordEntropy", { enumerable: true, get: function () { return utils_js_1.estimatePasswordEntropy; } });
+Object.defineProperty(exports, "normalizePassword", { enumerable: true, get: function () { return utils_js_1.normalizePassword; } });

package/dist/cjs/core/password/strength.js

@@ -1,27 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPasswordStrong = void 0;
-const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const errors_1 = require("@naman_deep_singh/errors");
 const isPasswordStrong = (password, options = {}) => {
     if (!password)
-        throw new errors_utils_1.BadRequestError({ reason: 'Invalid password provided' });
+        throw new errors_1.BadRequestError({ reason: 'Invalid password provided' });
     const { minLength = 8, requireUppercase = true, requireLowercase = true, requireNumbers = true, requireSymbols = false, } = options;
     if (password.length < minLength)
-        throw new errors_utils_1.ValidationError({
+        throw new errors_1.ValidationError({
             reason: `Password must be at least ${minLength} characters long`,
         });
     if (requireUppercase && !/[A-Z]/.test(password))
-        throw new errors_utils_1.ValidationError({
+        throw new errors_1.ValidationError({
             reason: 'Password must include uppercase letters',
         });
     if (requireLowercase && !/[a-z]/.test(password))
-        throw new errors_utils_1.ValidationError({
+        throw new errors_1.ValidationError({
             reason: 'Password must include lowercase letters',
         });
     if (requireNumbers && !/[0-9]/.test(password))
-        throw new errors_utils_1.ValidationError({ reason: 'Password must include numbers' });
+        throw new errors_1.ValidationError({ reason: 'Password must include numbers' });
     if (requireSymbols && !/[^A-Za-z0-9]/.test(password))
-        throw new errors_utils_1.ValidationError({ reason: 'Password must include symbols' });
+        throw new errors_1.ValidationError({ reason: 'Password must include symbols' });
     return true;
 };
 exports.isPasswordStrong = isPasswordStrong;

package/dist/cjs/core/password/utils.js

@@ -8,13 +8,13 @@ exports.safeCompare = safeCompare;
 exports.estimatePasswordEntropy = estimatePasswordEntropy;
 exports.normalizePassword = normalizePassword;
 const crypto_1 = __importDefault(require("crypto"));
-const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const errors_1 = require("@naman_deep_singh/errors");
 /**
  * Ensure password is a valid non-empty string
  */
 function ensureValidPassword(password) {
     if (!password || typeof password !== 'string') {
-        throw new errors_utils_1.BadRequestError({ reason: 'Invalid password provided' });
+        throw new errors_1.BadRequestError({ reason: 'Invalid password provided' });
     }
 }
 /**

package/dist/cjs/core/password/verify.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyPasswordSync = exports.verifyPassword = void 0;
 exports.verifyPasswordWithPepper = verifyPasswordWithPepper;
 exports.verifyPasswordWithPepperSync = verifyPasswordWithPepperSync;
-const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const errors_1 = require("@naman_deep_singh/errors");
 const bcryptjs_1 = __importDefault(require("bcryptjs"));
 /**
  * Compare a password with a stored hash asynchronously.
@@ -15,11 +15,11 @@ const verifyPassword = async (password, hash) => {
     try {
         const result = await bcryptjs_1.default.compare(password, hash);
         if (!result)
-            throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+            throw new errors_1.UnauthorizedError({ reason: 'Password verification failed' });
         return result;
     }
     catch {
-        throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+        throw new errors_1.UnauthorizedError({ reason: 'Password verification failed' });
     }
 };
 exports.verifyPassword = verifyPassword;
@@ -33,11 +33,11 @@ const verifyPasswordSync = (password, hash) => {
     try {
         const result = bcryptjs_1.default.compareSync(password, hash);
         if (!result)
-            throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+            throw new errors_1.UnauthorizedError({ reason: 'Password verification failed' });
         return result;
     }
     catch (_error) {
-        throw new errors_utils_1.UnauthorizedError({ reason: 'Password verification failed' });
+        throw new errors_1.UnauthorizedError({ reason: 'Password verification failed' });
     }
 };
 exports.verifyPasswordSync = verifyPasswordSync;

package/dist/cjs/index.js

@@ -10,47 +10,11 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalServerError = exports.ValidationError = exports.UnauthorizedError = exports.BadRequestError = void 0;
-__exportStar(require("./core/password"), exports);
-__exportStar(require("./core/jwt"), exports);
-__exportStar(require("./core/crypto"), exports);
-// Re-export common errors for convenience
-var errors_utils_1 = require("@naman_deep_singh/errors-utils");
-Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return errors_utils_1.BadRequestError; } });
-Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return errors_utils_1.UnauthorizedError; } });
-Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_utils_1.ValidationError; } });
-Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return errors_utils_1.InternalServerError; } });
-const CryptoUtils = __importStar(require("./core/crypto"));
-const JWTUtils = __importStar(require("./core/jwt"));
-const PasswordUtils = __importStar(require("./core/password"));
-exports.default = {
-    ...PasswordUtils,
-    ...JWTUtils,
-    ...CryptoUtils,
-};
+// Core modules
+__exportStar(require("./core/index.js"), exports);
+// Public interfaces
+// export * from './interfaces/index.js'

package/dist/cjs/interfaces/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/core/crypto/CryptoManger.js

@@ -0,0 +1,100 @@
+import crypto from 'crypto';
+import { BadRequestError } from '@naman_deep_singh/errors';
+import { decrypt } from './decrypt.js';
+import { encrypt } from './encrypt.js';
+import { hmacSign, hmacVerify } from './hmac.js';
+/**
+ * High-level cryptography manager
+ * Wraps encryption, decryption, HMAC, and random utilities
+ */
+export class CryptoManager {
+    constructor(secret) {
+        if (!secret || typeof secret !== 'string' || secret.length < 16) {
+            throw new BadRequestError({
+                reason: 'CryptoManager secret must be a non-empty string (min 16 chars)',
+            });
+        }
+        this.secret = secret;
+    }
+    /**
+     * Encrypt data using AES-256-GCM
+     */
+    encrypt(data) {
+        if (!data || typeof data !== 'string') {
+            throw new BadRequestError({
+                reason: 'Data to encrypt must be a non-empty string',
+            });
+        }
+        return encrypt(data, this.secret);
+    }
+    /**
+     * Decrypt AES-256-GCM encrypted data
+     */
+    decrypt(encrypted) {
+        if (!encrypted || typeof encrypted !== 'string') {
+            throw new BadRequestError({
+                reason: 'Encrypted value must be a non-empty string',
+            });
+        }
+        return decrypt(encrypted, this.secret);
+    }
+    /**
+     * Create HMAC SHA-256 signature
+     */
+    createHMAC(message) {
+        if (!message || typeof message !== 'string') {
+            throw new BadRequestError({
+                reason: 'Message must be a non-empty string',
+            });
+        }
+        return hmacSign(message, this.secret);
+    }
+    /**
+     * Verify HMAC SHA-256 signature
+     */
+    verifyHMAC(message, signature) {
+        if (!message ||
+            typeof message !== 'string' ||
+            !signature ||
+            typeof signature !== 'string') {
+            return false;
+        }
+        return hmacVerify(message, this.secret, signature);
+    }
+    /**
+     * Generate cryptographically secure random bytes
+     */
+    generateRandomBytes(length = 32) {
+        if (!Number.isInteger(length) || length <= 0) {
+            throw new BadRequestError({
+                reason: 'Random byte length must be a positive integer',
+            });
+        }
+        return crypto.randomBytes(length);
+    }
+    /**
+     * Generate secure random hex string
+     */
+    generateRandomHex(length = 32) {
+        if (!Number.isInteger(length) || length <= 0) {
+            throw new BadRequestError({
+                reason: 'Random hex length must be a positive integer',
+            });
+        }
+        return crypto.randomBytes(length).toString('hex');
+    }
+    /**
+     * Generate secure random string (URL-safe base64)
+     */
+    generateRandomString(length = 32) {
+        if (!Number.isInteger(length) || length <= 0) {
+            throw new BadRequestError({
+                reason: 'Random string length must be a positive integer',
+            });
+        }
+        return crypto
+            .randomBytes(Math.ceil((length * 3) / 4))
+            .toString('base64url')
+            .slice(0, length);
+    }
+}

package/dist/esm/core/crypto/index.js

@@ -1,5 +1,5 @@
-export { decrypt } from './decrypt';
-export { encrypt } from './encrypt';
-export { hmacSign, hmacVerify } from './hmac';
-export { randomToken, generateStrongPassword } from './random';
-export * from './cryptoManager';
+export { CryptoManager } from './CryptoManger.js';
+export { encrypt } from './encrypt.js';
+export { decrypt } from './decrypt.js';
+export { hmacSign, hmacVerify } from './hmac.js';
+export { randomToken, generateStrongPassword } from './random.js';

package/dist/esm/core/index.js

@@ -0,0 +1,6 @@
+// Re-export everything from crypto module
+export { CryptoManager, encrypt, decrypt, hmacSign, hmacVerify, randomToken, generateStrongPassword, } from './crypto/index.js';
+// Re-export everything from jwt module
+export { decodeToken, decodeTokenStrict, extractToken, generateTokens, rotateRefreshToken, parseDuration, signToken, validateTokenPayload, isTokenExpired, verifyToken, verifyTokenWithOptions, safeVerifyToken, safeVerifyTokenWithOptions, JWTManager, } from './jwt/index.js';
+// Re-export everything from password module
+export { hashPassword, hashPasswordWithPepper, hashPasswordSync, hashPasswordWithPepperSync, isPasswordStrong, verifyPassword, verifyPasswordWithPepper, verifyPasswordSync, verifyPasswordWithPepperSync, PasswordManager, ensureValidPassword, safeCompare, estimatePasswordEntropy, normalizePassword, } from './password/index.js';

package/dist/esm/core/jwt/{jwtManager.js → JWTManager.js}

@@ -1,8 +1,8 @@
+import { BadRequestError, UnauthorizedError, ValidationError, } from '@naman_deep_singh/errors';
+import { LRUCache } from '@naman_deep_singh/utils';
 import jwt from 'jsonwebtoken';
-import { signToken } from './signToken';
-import { safeVerifyToken } from './verify';
-import { BadRequestError, UnauthorizedError, ValidationError, } from '@naman_deep_singh/errors-utils';
-import { LRUCache } from '@naman_deep_singh/js-extensions';
+import { signToken } from './signToken.js';
+import { safeVerifyToken } from './verify.js';
 export class JWTManager {
     constructor(config) {
         this.accessSecret = config.accessSecret;

package/dist/esm/core/jwt/decode.js

@@ -1,5 +1,4 @@
-import { BadRequestError } from '@naman_deep_singh/errors-utils';
-// src/jwt/decodeToken.ts
+import { BadRequestError } from '@naman_deep_singh/errors';
 import { decode } from 'jsonwebtoken';
 /**
  * Flexible decode

package/dist/esm/core/jwt/generateTokens.js

@@ -1,6 +1,6 @@
-import { TokenMalformedError } from '@naman_deep_singh/errors-utils';
-import { signToken } from './signToken';
-import { verifyToken } from './verify';
+import { TokenMalformedError } from '@naman_deep_singh/errors';
+import { signToken } from './signToken.js';
+import { verifyToken } from './verify.js';
 // Helper function to create branded tokens
 /* const createBrandedToken = <T extends string>(token: string, _brand: T): T => {
     return token as T

package/dist/esm/core/jwt/index.js

@@ -1,8 +1,8 @@
-export * from './decode';
-export * from './extractToken';
-export * from './generateTokens';
-export * from './parseDuration';
-export * from './signToken';
-export * from './types';
-export * from './validateToken';
-export * from './verify';
+export { decodeToken, decodeTokenStrict } from './decode.js';
+export { extractToken } from './extractToken.js';
+export { generateTokens, rotateRefreshToken } from './generateTokens.js';
+export { parseDuration } from './parseDuration.js';
+export { signToken } from './signToken.js';
+export { validateTokenPayload, isTokenExpired, } from './validateToken.js';
+export { verifyToken, verifyTokenWithOptions, safeVerifyToken, safeVerifyTokenWithOptions, } from './verify.js';
+export { JWTManager } from './JWTManager.js';

package/dist/esm/core/jwt/parseDuration.js

@@ -1,4 +1,4 @@
-import { ValidationError } from '@naman_deep_singh/errors-utils';
+import { ValidationError } from '@naman_deep_singh/errors';
 const TIME_UNITS = {
     s: 1,
     m: 60,

package/dist/esm/core/jwt/signToken.js

@@ -1,6 +1,6 @@
-import { ValidationError } from '@naman_deep_singh/errors-utils';
+import { ValidationError } from '@naman_deep_singh/errors';
 import { sign } from 'jsonwebtoken';
-import { parseDuration } from './parseDuration';
+import { parseDuration } from './parseDuration.js';
 function getExpiryTimestamp(seconds) {
     return Math.floor(Date.now() / 1000) + seconds;
 }

package/dist/esm/core/jwt/validateToken.js

@@ -1,4 +1,4 @@
-import { ValidationError } from '@naman_deep_singh/errors-utils';
+import { ValidationError } from '@naman_deep_singh/errors';
 /**
  * Validates a JWT payload according to the provided rules.
  * Throws ValidationError if validation fails.

package/dist/esm/core/jwt/verify.js

@@ -1,4 +1,4 @@
-import { UnauthorizedError } from '@naman_deep_singh/errors-utils';
+import { UnauthorizedError } from '@naman_deep_singh/errors';
 import { verify, } from 'jsonwebtoken';
 /**
  * Verify token (throws UnauthorizedError if invalid or expired)

package/dist/esm/core/password/{passwordManager.js → PasswordManager.js}

@@ -1,7 +1,7 @@
 import crypto from 'crypto';
 import bcrypt from 'bcryptjs';
-import { BadRequestError, ValidationError, } from '@naman_deep_singh/errors-utils';
-import { ensureValidPassword, estimatePasswordEntropy } from './utils';
+import { BadRequestError, ValidationError } from '@naman_deep_singh/errors';
+import { ensureValidPassword, estimatePasswordEntropy } from './utils.js';
 export class PasswordManager {
     constructor(config = {}) {
         this.defaultConfig = {

package/dist/esm/core/password/hash.js

@@ -1,6 +1,6 @@
-import { InternalServerError } from '@naman_deep_singh/errors-utils';
+import { InternalServerError } from '@naman_deep_singh/errors';
 import bcrypt from 'bcryptjs';
-import { ensureValidPassword } from './utils';
+import { ensureValidPassword } from './utils.js';
 /**
  * Hash a password asynchronously using bcrypt.
  */
@@ -11,7 +11,7 @@ export const hashPassword = async (password, saltRounds = 10) => {
         return bcrypt.hash(password, salt);
     }
     catch (error) {
-        throw new InternalServerError({ reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
+        throw new InternalServerError(undefined, { reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
     }
 };
 export function hashPasswordWithPepper(password, pepper) {
@@ -27,7 +27,7 @@ export const hashPasswordSync = (password, saltRounds = 10) => {
         return bcrypt.hashSync(password, salt);
     }
     catch (error) {
-        throw new InternalServerError({ reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
+        throw new InternalServerError(undefined, { reason: 'Password hashing failed' }, error instanceof Error ? error : undefined);
     }
 };
 export function hashPasswordWithPepperSync(password, pepper) {

package/dist/esm/core/password/index.js

@@ -1,3 +1,5 @@
-export * from './hash';
-export * from './strength';
-export * from './verify';
+export { hashPassword, hashPasswordWithPepper, hashPasswordSync, hashPasswordWithPepperSync, } from './hash.js';
+export { isPasswordStrong } from './strength.js';
+export { verifyPassword, verifyPasswordWithPepper, verifyPasswordSync, verifyPasswordWithPepperSync, } from './verify.js';
+export { PasswordManager } from './PasswordManager.js';
+export { ensureValidPassword, safeCompare, estimatePasswordEntropy, normalizePassword, } from './utils.js';

package/dist/esm/core/password/strength.js

@@ -1,4 +1,4 @@
-import { BadRequestError, ValidationError, } from '@naman_deep_singh/errors-utils';
+import { BadRequestError, ValidationError } from '@naman_deep_singh/errors';
 export const isPasswordStrong = (password, options = {}) => {
     if (!password)
         throw new BadRequestError({ reason: 'Invalid password provided' });

package/dist/esm/core/password/utils.js

@@ -1,5 +1,5 @@
 import crypto from 'crypto';
-import { BadRequestError } from '@naman_deep_singh/errors-utils';
+import { BadRequestError } from '@naman_deep_singh/errors';
 /**
  * Ensure password is a valid non-empty string
  */

package/dist/esm/core/password/verify.js

@@ -1,4 +1,4 @@
-import { UnauthorizedError } from '@naman_deep_singh/errors-utils';
+import { UnauthorizedError } from '@naman_deep_singh/errors';
 import bcrypt from 'bcryptjs';
 /**
  * Compare a password with a stored hash asynchronously.

package/dist/esm/index.js

@@ -1,13 +1,4 @@
-export * from './core/password';
-export * from './core/jwt';
-export * from './core/crypto';
-// Re-export common errors for convenience
-export { BadRequestError, UnauthorizedError, ValidationError, InternalServerError, } from '@naman_deep_singh/errors-utils';
-import * as CryptoUtils from './core/crypto';
-import * as JWTUtils from './core/jwt';
-import * as PasswordUtils from './core/password';
-export default {
-    ...PasswordUtils,
-    ...JWTUtils,
-    ...CryptoUtils,
-};
+// Core modules
+export * from './core/index.js';
+// Public interfaces
+// export * from './interfaces/index.js'

package/dist/esm/interfaces/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/core/crypto/CryptoManger.d.ts

@@ -0,0 +1,36 @@
+/**
+ * High-level cryptography manager
+ * Wraps encryption, decryption, HMAC, and random utilities
+ */
+export declare class CryptoManager {
+    private readonly secret;
+    constructor(secret: string);
+    /**
+     * Encrypt data using AES-256-GCM
+     */
+    encrypt(data: string): string;
+    /**
+     * Decrypt AES-256-GCM encrypted data
+     */
+    decrypt(encrypted: string): string;
+    /**
+     * Create HMAC SHA-256 signature
+     */
+    createHMAC(message: string): string;
+    /**
+     * Verify HMAC SHA-256 signature
+     */
+    verifyHMAC(message: string, signature: string): boolean;
+    /**
+     * Generate cryptographically secure random bytes
+     */
+    generateRandomBytes(length?: number): Buffer;
+    /**
+     * Generate secure random hex string
+     */
+    generateRandomHex(length?: number): string;
+    /**
+     * Generate secure random string (URL-safe base64)
+     */
+    generateRandomString(length?: number): string;
+}

package/dist/types/core/crypto/index.d.ts

@@ -1,5 +1,5 @@
-export { decrypt } from './decrypt';
-export { encrypt } from './encrypt';
-export { hmacSign, hmacVerify } from './hmac';
-export { randomToken, generateStrongPassword } from './random';
-export * from './cryptoManager';
+export { CryptoManager } from './CryptoManger.js';
+export { encrypt } from './encrypt.js';
+export { decrypt } from './decrypt.js';
+export { hmacSign, hmacVerify } from './hmac.js';
+export { randomToken, generateStrongPassword } from './random.js';

package/dist/types/core/index.d.ts

@@ -0,0 +1,3 @@
+export { CryptoManager, encrypt, decrypt, hmacSign, hmacVerify, randomToken, generateStrongPassword, } from './crypto/index.js';
+export { decodeToken, decodeTokenStrict, extractToken, generateTokens, rotateRefreshToken, parseDuration, signToken, validateTokenPayload, isTokenExpired, verifyToken, verifyTokenWithOptions, safeVerifyToken, safeVerifyTokenWithOptions, JWTManager, type TokenSources, type AccessToken, type RefreshToken, type TokenPair, type VerificationResult, type TokenValidationOptions, type TokenRequirements, } from './jwt/index.js';
+export { hashPassword, hashPasswordWithPepper, hashPasswordSync, hashPasswordWithPepperSync, isPasswordStrong, verifyPassword, verifyPasswordWithPepper, verifyPasswordSync, verifyPasswordWithPepperSync, PasswordManager, type PasswordStrengthOptions, ensureValidPassword, safeCompare, estimatePasswordEntropy, normalizePassword, } from './password/index.js';