@kumix/utils 0.1.0

package/dist/server.js

@@ -0,0 +1,555 @@
+import { t as logger } from "./logger-BOB35dQN.js";
+import { randomBytes, randomInt } from "node:crypto";
+import jwt from "jsonwebtoken";
+import bcrypt from "bcryptjs";
+import * as chrono from "chrono-node";
+//#region src/functions/crypto/generate-random-string.ts
+/**
+* Utility function for generating cryptographically secure random strings
+* Provides secure random string generation for tokens, IDs, and other security-sensitive uses
+*/
+/**
+* Generates a cryptographically secure random string of specified length
+* Uses Node.js crypto module for secure random number generation
+*
+* @param length - The length of the random string to generate
+* @returns A random string consisting of uppercase letters and numbers
+*
+* @example
+* ```ts
+* import { generateRandomString } from '@/utils/functions';
+*
+* // Generate a 6-character random string
+* const verificationCode = generateRandomString(6);
+* // Example output: "A7B3C9"
+*
+* // Generate a longer random string for tokens
+* const apiToken = generateRandomString(32);
+* // Example output: "X7F9A2B5C8D1E4F7G0H3I6J9K2L5M8N1"
+*
+* // Use as unique identifiers
+* const uniqueId = generateRandomString(12);
+* // Example output: "B7C9D1E3F5G7"
+* ```
+*/
+function generateRandomString(length) {
+	const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+	const randomBytesArray = randomBytes(length);
+	let result = "";
+	for (let i = 0; i < length; i++) {
+		const randomIndex = randomBytesArray[i] % 36;
+		result += charset[randomIndex];
+	}
+	return result;
+}
+//#endregion
+//#region src/functions/crypto/jwt.ts
+/**
+* JWT (JSON Web Token) utilities for SaaS applications
+* Provides secure token generation, verification, and management
+* Includes validation and error handling for production use
+*/
+/**
+* Generates a JWT token with the provided payload
+*
+* @param payload - The data to encode in the token
+* @param secret - The secret key for signing the token
+* @param options - Token generation options
+* @returns The generated JWT token or null if failed
+*
+* @example
+* ```typescript
+* import { generateJWT } from '@kumix/utils';
+*
+* // Basic usage
+* const token = generateJWT(
+*   { userId: '123', email: 'user@example.com' },
+*   process.env.JWT_SECRET
+* );
+*
+* // With custom expiration
+* const token = generateJWT(
+*   { userId: '123', email: 'user@example.com', role: 'admin' },
+*   process.env.JWT_SECRET,
+*   { expiresIn: '1h' }
+* );
+*
+* // For API authentication
+* const authToken = generateJWT(
+*   { userId: user.id, email: user.email, workspaceId: workspace.id },
+*   process.env.JWT_SECRET,
+*   { expiresIn: '24h', issuer: 'myapp.com' }
+* );
+* ```
+*/
+function generateJWT(payload, secret, options = {}) {
+	if (!payload || typeof payload !== "object") {
+		logger.warn("JWT generation: Payload must be a valid object");
+		return null;
+	}
+	if (!payload.userId || typeof payload.userId !== "string") {
+		logger.warn("JWT generation: userId is required in payload");
+		return null;
+	}
+	if (!payload.email || typeof payload.email !== "string") {
+		logger.warn("JWT generation: email is required in payload");
+		return null;
+	}
+	if (!secret || typeof secret !== "string") {
+		logger.warn("JWT generation: Secret must be a non-empty string");
+		return null;
+	}
+	const { expiresIn = "7d", issuer, audience } = options;
+	const { exp, ...cleanPayload } = payload;
+	try {
+		const signOptions = {
+			...typeof exp === "undefined" ? { expiresIn } : {},
+			...issuer && { issuer },
+			...audience && { audience }
+		};
+		return jwt.sign(cleanPayload, secret, signOptions);
+	} catch (error) {
+		logger.error("JWT generation: Failed to generate token", { error });
+		return null;
+	}
+}
+/**
+* Verifies and decodes a JWT token
+*
+* @param token - The JWT token to verify
+* @param secret - The secret key used to sign the token
+* @param options - Verification options
+* @returns Verification result with payload if valid
+*
+* @example
+* ```typescript
+* import { verifyJWT } from '@kumix/utils';
+*
+* // Basic usage
+* const result = verifyJWT(token, process.env.JWT_SECRET);
+* if (result.isValid && result.payload) {
+*   const { userId, email } = result.payload;
+*   // Proceed with authenticated user
+* }
+*
+* // With issuer verification
+* const result = verifyJWT(token, process.env.JWT_SECRET, {
+*   issuer: 'myapp.com'
+* });
+*
+* // In authentication middleware
+* async function authenticateRequest(req, res, next) {
+*   const token = req.headers.authorization?.replace('Bearer ', '');
+*   const result = verifyJWT(token, process.env.JWT_SECRET);
+*
+*   if (!result.isValid) {
+*     return res.status(401).json({ error: 'Invalid token' });
+*   }
+*
+*   req.user = result.payload;
+*   next();
+* }
+* ```
+*/
+function verifyJWT(token, secret, options = {}) {
+	if (!token || typeof token !== "string") return {
+		isValid: false,
+		error: "Token must be a non-empty string"
+	};
+	if (!secret || typeof secret !== "string") return {
+		isValid: false,
+		error: "Secret must be a non-empty string"
+	};
+	const { issuer, audience } = options;
+	try {
+		return {
+			isValid: true,
+			payload: jwt.verify(token, secret, {
+				...issuer && { issuer },
+				...audience && { audience }
+			})
+		};
+	} catch (error) {
+		logger.warn("JWT verification: Token verification failed", { error });
+		if (error instanceof jwt.TokenExpiredError) return {
+			isValid: false,
+			error: "Token has expired"
+		};
+		if (error instanceof jwt.JsonWebTokenError) return {
+			isValid: false,
+			error: "Invalid token format"
+		};
+		return {
+			isValid: false,
+			error: "Token verification failed"
+		};
+	}
+}
+/**
+* Decodes a JWT token without verification (for debugging/inspection)
+*
+* @param token - The JWT token to decode
+* @returns Decoded payload or null if failed
+*
+* @example
+* ```typescript
+* import { decodeJWT } from '@kumix/utils';
+*
+* // Inspect token contents without verification
+* const payload = decodeJWT(token);
+* if (payload) {
+*   console.log('Token expires at:', new Date(payload.exp * 1000));
+*   console.log('User ID:', payload.userId);
+* }
+*
+* // For debugging purposes
+* function debugToken(token: string) {
+*   const payload = decodeJWT(token);
+*   if (payload) {
+*     console.log('Token payload:', payload);
+*   } else {
+*     console.log('Invalid token format');
+*   }
+* }
+* ```
+*/
+function decodeJWT(token) {
+	if (!token || typeof token !== "string") return null;
+	try {
+		return jwt.decode(token);
+	} catch (error) {
+		logger.warn("JWT decode: Failed to decode token", { error });
+		return null;
+	}
+}
+/**
+* Checks if a JWT token is expired
+*
+* @param token - The JWT token to check
+* @returns True if token is expired, false otherwise
+*
+* @example
+* ```typescript
+* import { isJWTExpired } from '@kumix/utils';
+*
+* // Check if token needs refresh
+* if (isJWTExpired(userToken)) {
+*   // Redirect to login or refresh token
+*   await refreshUserToken();
+* }
+*
+* // In token refresh logic
+* function shouldRefreshToken(token: string): boolean {
+*   return isJWTExpired(token);
+* }
+* ```
+*/
+function isJWTExpired(token) {
+	const payload = decodeJWT(token);
+	if (!payload?.exp) return true;
+	const currentTime = Math.floor(Date.now() / 1e3);
+	return payload.exp < currentTime;
+}
+/**
+* Gets the remaining time until token expiration
+*
+* @param token - The JWT token to check
+* @returns Remaining time in seconds, or 0 if expired/invalid
+*
+* @example
+* ```typescript
+* import { getJWTTimeRemaining } from '@kumix/utils';
+*
+* // Check how much time is left
+* const timeLeft = getJWTTimeRemaining(userToken);
+* if (timeLeft < 300) { // Less than 5 minutes
+*   // Show warning about token expiration
+*   showTokenExpirationWarning();
+* }
+*
+* // Format time remaining for display
+* function formatTimeRemaining(token: string): string {
+*   const seconds = getJWTTimeRemaining(token);
+*   const minutes = Math.floor(seconds / 60);
+*   const hours = Math.floor(minutes / 60);
+*
+*   if (hours > 0) return `${hours}h ${minutes % 60}m`;
+*   if (minutes > 0) return `${minutes}m`;
+*   return `${seconds}s`;
+* }
+* ```
+*/
+function getJWTTimeRemaining(token) {
+	const payload = decodeJWT(token);
+	if (!payload?.exp) return 0;
+	const currentTime = Math.floor(Date.now() / 1e3);
+	const timeRemaining = payload.exp - currentTime;
+	return Math.max(0, timeRemaining);
+}
+//#endregion
+//#region src/functions/crypto/password.ts
+/**
+* Password hashing and verification utilities for SaaS applications
+* Provides secure password handling using bcrypt with proper salt rounds
+* Includes validation and error handling for production use
+*/
+/**
+* Default salt rounds for bcrypt hashing
+* 12 rounds provides good security while maintaining reasonable performance
+* Higher values increase security but also increase computation time
+*/
+const DEFAULT_SALT_ROUNDS = 12;
+/**
+* Hashes a password using bcrypt with salt
+*
+* @param password - The plain text password to hash
+* @param options - Hashing options
+* @returns Promise that resolves to the hashed password or null if failed
+*
+* @example
+* ```typescript
+* import { hashPassword } from '@kumix/utils';
+*
+* // Basic usage
+* const hashedPassword = await hashPassword('userPassword123');
+* if (hashedPassword) {
+*   // Store hashedPassword in database
+*   await saveUser({ email, password: hashedPassword });
+* }
+*
+* // With custom salt rounds
+* const hashedPassword = await hashPassword('userPassword123', {
+*   saltRounds: 14
+* });
+*
+* // Error handling
+* const hashedPassword = await hashPassword('userPassword123');
+* if (!hashedPassword) {
+*   throw new Error('Failed to hash password');
+* }
+* ```
+*/
+async function hashPassword(password, options = {}) {
+	if (!password || typeof password !== "string") {
+		logger.warn("Password hashing: Password must be a non-empty string");
+		return null;
+	}
+	if (password.length < 1) {
+		logger.warn("Password hashing: Password cannot be empty");
+		return null;
+	}
+	const { saltRounds = DEFAULT_SALT_ROUNDS } = options;
+	if (typeof saltRounds !== "number" || saltRounds < 4 || saltRounds > 20) {
+		logger.warn("Password hashing: Salt rounds must be between 4 and 20");
+		return null;
+	}
+	try {
+		const salt = await bcrypt.genSalt(saltRounds);
+		return await bcrypt.hash(password, salt);
+	} catch (error) {
+		logger.error("Password hashing: Failed to hash password", { error });
+		return null;
+	}
+}
+/**
+* Verifies a password against its hash
+*
+* @param password - The plain text password to verify
+* @param hashedPassword - The hashed password to compare against
+* @returns Promise that resolves to verification result
+*
+* @example
+* ```typescript
+* import { verifyPassword } from '@kumix/utils';
+*
+* // Basic usage
+* const result = await verifyPassword('userPassword123', storedHashedPassword);
+* if (result.isValid) {
+*   // Password is correct, proceed with login
+*   await loginUser(user);
+* } else {
+*   // Password is incorrect
+*   throw new Error('Invalid credentials');
+* }
+*
+* // With error handling
+* const result = await verifyPassword('userPassword123', storedHashedPassword);
+* if (result.error) {
+*   logger.error('Password verification failed:', result.error);
+*   throw new Error('Authentication error');
+* }
+*
+* // In authentication middleware
+* async function authenticateUser(email: string, password: string) {
+*   const user = await getUserByEmail(email);
+*   if (!user) {
+*     return { success: false, error: 'User not found' };
+*   }
+*
+*   const result = await verifyPassword(password, user.hashedPassword);
+*   if (!result.isValid) {
+*     return { success: false, error: 'Invalid password' };
+*   }
+*
+*   return { success: true, user };
+* }
+* ```
+*/
+async function verifyPassword(password, hashedPassword) {
+	if (!password || typeof password !== "string") return {
+		isValid: false,
+		error: "Password must be a non-empty string"
+	};
+	if (!hashedPassword || typeof hashedPassword !== "string") return {
+		isValid: false,
+		error: "Hashed password must be a non-empty string"
+	};
+	if (!hashedPassword.startsWith("$2a$") && !hashedPassword.startsWith("$2b$") && !hashedPassword.startsWith("$2y$")) return {
+		isValid: false,
+		error: "Invalid hash format"
+	};
+	try {
+		return { isValid: await bcrypt.compare(password, hashedPassword) };
+	} catch (error) {
+		logger.error("Password verification: Failed to verify password", { error });
+		return {
+			isValid: false,
+			error: "Password verification failed"
+		};
+	}
+}
+/**
+* Checks if a password needs to be rehashed (e.g., due to updated salt rounds)
+*
+* @param hashedPassword - The current hashed password
+* @param targetSaltRounds - The target salt rounds (default: 12)
+* @returns Whether the password needs to be rehashed
+*
+* @example
+* ```typescript
+* import { needsRehash, hashPassword } from '@kumix/utils';
+*
+* // Check if password needs rehashing during login
+* async function loginUser(email: string, password: string) {
+*   const user = await getUserByEmail(email);
+*   const result = await verifyPassword(password, user.hashedPassword);
+*
+*   if (result.isValid) {
+*     // Check if we need to rehash with updated salt rounds
+*     if (needsRehash(user.hashedPassword, 14)) {
+*       const newHash = await hashPassword(password, { saltRounds: 14 });
+*       if (newHash) {
+*         await updateUserPassword(user.id, newHash);
+*       }
+*     }
+*
+*     return { success: true, user };
+*   }
+*
+*   return { success: false, error: 'Invalid credentials' };
+* }
+* ```
+*/
+function needsRehash(hashedPassword, targetSaltRounds = DEFAULT_SALT_ROUNDS) {
+	if (!hashedPassword || typeof hashedPassword !== "string") return true;
+	try {
+		const parts = hashedPassword.split("$");
+		if (parts.length < 4) return true;
+		return parseInt(parts[2], 10) !== targetSaltRounds;
+	} catch (error) {
+		logger.warn("Password rehash check: Failed to parse hash", { error });
+		return true;
+	}
+}
+/**
+* Generates a secure random password
+*
+* @param length - Length of the password (default: 16, min: 8, max: 128)
+* @param options - Password generation options
+* @returns Generated password string
+*
+* @example
+* ```typescript
+* import { generateSecurePassword } from '@kumix/utils';
+*
+* // Generate default password (16 characters)
+* const password = generateSecurePassword();
+*
+* // Generate longer password
+* const longPassword = generateSecurePassword(24);
+*
+* // Generate password without symbols
+* const simplePassword = generateSecurePassword(12, {
+*   includeSymbols: false
+* });
+*
+* // For temporary passwords
+* const tempPassword = generateSecurePassword(12);
+* await sendPasswordResetEmail(user.email, tempPassword);
+* ```
+*/
+function generateSecurePassword(length = 16, options = {}) {
+	const { includeUppercase = true, includeLowercase = true, includeNumbers = true, includeSymbols = true } = options;
+	const validLength = Math.max(8, Math.min(128, length));
+	let charset = "";
+	if (includeUppercase) charset += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	if (includeLowercase) charset += "abcdefghijklmnopqrstuvwxyz";
+	if (includeNumbers) charset += "0123456789";
+	if (includeSymbols) charset += "!@#$%^&*()_+-=[]{}|;:,.<>?";
+	if (charset.length === 0) charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	let password = "";
+	for (let i = 0; i < validLength; i++) {
+		const randomIndex = randomInt(0, charset.length);
+		password += charset[randomIndex];
+	}
+	return password;
+}
+//#endregion
+//#region src/functions/datetime/parse-datetime.ts
+/**
+* Utility function for parsing date strings into Date objects
+* Provides natural language date parsing capabilities
+*/
+/**
+* Parses a date string into a Date object using natural language processing
+* Passes through Date objects unchanged
+*
+* @param str - The date string to parse or a Date object to pass through
+* @returns A Date object, or null if parsing fails
+*
+* @example
+* ```ts
+* // Parse natural language date strings
+* parseDateTime('tomorrow at 3pm')
+* // Returns a Date object for tomorrow at 3:00 PM
+*
+* // Parse formal date strings
+* parseDateTime('2023-06-15')
+* // Returns a Date object for June 15, 2023
+*
+* // Parse relative dates
+* parseDateTime('next Friday')
+* // Returns a Date object for next Friday
+*
+* // Pass through existing Date objects
+* const date = new Date('2023-06-15')
+* parseDateTime(date)
+* // Returns the same Date object
+*
+* // Parse time strings
+* parseDateTime('3:30pm')
+* // Returns a Date object for today at 3:30 PM
+*
+* // Parse complex date expressions
+* parseDateTime('3 days after next Monday')
+* // Returns the appropriate Date object
+* ```
+*/
+const parseDateTime = (str) => {
+	if (str instanceof Date) return str;
+	return chrono.parseDate(str);
+};
+//#endregion
+export { decodeJWT, generateJWT, generateRandomString, generateSecurePassword, getJWTTimeRemaining, hashPassword, isJWTExpired, jwt, needsRehash, parseDateTime, verifyJWT, verifyPassword };
+
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":[],"sources":["../src/functions/crypto/generate-random-string.ts","../src/functions/crypto/jwt.ts","../src/functions/crypto/password.ts","../src/functions/datetime/parse-datetime.ts"],"sourcesContent":["/**\n * Utility function for generating cryptographically secure random strings\n * Provides secure random string generation for tokens, IDs, and other security-sensitive uses\n */\n\nimport { randomBytes } from \"node:crypto\";\n\n/**\n * Generates a cryptographically secure random string of specified length\n * Uses Node.js crypto module for secure random number generation\n *\n * @param length - The length of the random string to generate\n * @returns A random string consisting of uppercase letters and numbers\n *\n * @example\n * ```ts\n * import { generateRandomString } from '@/utils/functions';\n *\n * // Generate a 6-character random string\n * const verificationCode = generateRandomString(6);\n * // Example output: \"A7B3C9\"\n *\n * // Generate a longer random string for tokens\n * const apiToken = generateRandomString(32);\n * // Example output: \"X7F9A2B5C8D1E4F7G0H3I6J9K2L5M8N1\"\n *\n * // Use as unique identifiers\n * const uniqueId = generateRandomString(12);\n * // Example output: \"B7C9D1E3F5G7\"\n * ```\n */\nexport function generateRandomString(length: number): string {\n  const charset = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\";\n  const randomBytesArray = randomBytes(length);\n  let result = \"\";\n\n  for (let i = 0; i < length; i++) {\n    const randomIndex = randomBytesArray[i] % charset.length;\n    result += charset[randomIndex];\n  }\n\n  return result;\n}\n","/**\n * JWT (JSON Web Token) utilities for SaaS applications\n * Provides secure token generation, verification, and management\n * Includes validation and error handling for production use\n */\n\nimport jwt from \"jsonwebtoken\";\n\nimport { logger } from \"../logging/logger\";\n\nexport { jwt };\n\n/**\n * Interface for JWT payload data\n */\ninterface JWTPayload {\n  /** User ID */\n  userId: string;\n  /** User email */\n  email: string;\n  /** User role */\n  role?: string;\n  /** Workspace ID */\n  workspaceId?: string;\n  /** Token expiration time (Unix timestamp) */\n  exp?: number;\n  /** Token issued at time (Unix timestamp) */\n  iat?: number;\n  /** Additional custom claims */\n  [key: string]: unknown;\n  /** For Supabase */\n  aud?: string;\n  sub?: string;\n}\n\n/**\n * Interface for JWT options\n */\ninterface JWTOptions {\n  /** Token expiration time (default: '7d') */\n  expiresIn?: string;\n  /** Token issuer */\n  issuer?: string;\n  /** Token audience */\n  audience?: string;\n}\n\n/**\n * Interface for JWT verification result\n */\ninterface JWTVerificationResult {\n  /** Whether the token is valid */\n  isValid: boolean;\n  /** Decoded payload if valid */\n  payload?: JWTPayload;\n  /** Error message if verification failed */\n  error?: string;\n}\n\n/**\n * Generates a JWT token with the provided payload\n *\n * @param payload - The data to encode in the token\n * @param secret - The secret key for signing the token\n * @param options - Token generation options\n * @returns The generated JWT token or null if failed\n *\n * @example\n * ```typescript\n * import { generateJWT } from '@kumix/utils';\n *\n * // Basic usage\n * const token = generateJWT(\n *   { userId: '123', email: 'user@example.com' },\n *   process.env.JWT_SECRET\n * );\n *\n * // With custom expiration\n * const token = generateJWT(\n *   { userId: '123', email: 'user@example.com', role: 'admin' },\n *   process.env.JWT_SECRET,\n *   { expiresIn: '1h' }\n * );\n *\n * // For API authentication\n * const authToken = generateJWT(\n *   { userId: user.id, email: user.email, workspaceId: workspace.id },\n *   process.env.JWT_SECRET,\n *   { expiresIn: '24h', issuer: 'myapp.com' }\n * );\n * ```\n */\nexport function generateJWT(\n  payload: JWTPayload,\n  secret: string,\n  options: JWTOptions = {},\n): string | null {\n  // Validate inputs\n  if (!payload || typeof payload !== \"object\") {\n    logger.warn(\"JWT generation: Payload must be a valid object\");\n    return null;\n  }\n\n  if (!payload.userId || typeof payload.userId !== \"string\") {\n    logger.warn(\"JWT generation: userId is required in payload\");\n    return null;\n  }\n\n  if (!payload.email || typeof payload.email !== \"string\") {\n    logger.warn(\"JWT generation: email is required in payload\");\n    return null;\n  }\n\n  if (!secret || typeof secret !== \"string\") {\n    logger.warn(\"JWT generation: Secret must be a non-empty string\");\n    return null;\n  }\n\n  const { expiresIn = \"7d\", issuer, audience } = options;\n\n  const { exp, ...cleanPayload } = payload;\n\n  try {\n    const signOptions = {\n      ...(typeof exp === \"undefined\" ? { expiresIn } : {}),\n      ...(issuer && { issuer }),\n      ...(audience && { audience }),\n    } as jwt.SignOptions;\n\n    const token = jwt.sign(cleanPayload, secret, signOptions);\n\n    return token;\n  } catch (error) {\n    logger.error(\"JWT generation: Failed to generate token\", { error });\n    return null;\n  }\n}\n\n/**\n * Verifies and decodes a JWT token\n *\n * @param token - The JWT token to verify\n * @param secret - The secret key used to sign the token\n * @param options - Verification options\n * @returns Verification result with payload if valid\n *\n * @example\n * ```typescript\n * import { verifyJWT } from '@kumix/utils';\n *\n * // Basic usage\n * const result = verifyJWT(token, process.env.JWT_SECRET);\n * if (result.isValid && result.payload) {\n *   const { userId, email } = result.payload;\n *   // Proceed with authenticated user\n * }\n *\n * // With issuer verification\n * const result = verifyJWT(token, process.env.JWT_SECRET, {\n *   issuer: 'myapp.com'\n * });\n *\n * // In authentication middleware\n * async function authenticateRequest(req, res, next) {\n *   const token = req.headers.authorization?.replace('Bearer ', '');\n *   const result = verifyJWT(token, process.env.JWT_SECRET);\n *\n *   if (!result.isValid) {\n *     return res.status(401).json({ error: 'Invalid token' });\n *   }\n *\n *   req.user = result.payload;\n *   next();\n * }\n * ```\n */\nexport function verifyJWT(\n  token: string,\n  secret: string,\n  options: { issuer?: string; audience?: string } = {},\n): JWTVerificationResult {\n  // Validate inputs\n  if (!token || typeof token !== \"string\") {\n    return {\n      isValid: false,\n      error: \"Token must be a non-empty string\",\n    };\n  }\n\n  if (!secret || typeof secret !== \"string\") {\n    return {\n      isValid: false,\n      error: \"Secret must be a non-empty string\",\n    };\n  }\n\n  const { issuer, audience } = options;\n\n  try {\n    const decoded = jwt.verify(token, secret, {\n      ...(issuer && { issuer }),\n      ...(audience && { audience }),\n    }) as JWTPayload;\n\n    return {\n      isValid: true,\n      payload: decoded,\n    };\n  } catch (error) {\n    logger.warn(\"JWT verification: Token verification failed\", { error });\n\n    if (error instanceof jwt.TokenExpiredError) {\n      return {\n        isValid: false,\n        error: \"Token has expired\",\n      };\n    }\n\n    if (error instanceof jwt.JsonWebTokenError) {\n      return {\n        isValid: false,\n        error: \"Invalid token format\",\n      };\n    }\n\n    return {\n      isValid: false,\n      error: \"Token verification failed\",\n    };\n  }\n}\n\n/**\n * Decodes a JWT token without verification (for debugging/inspection)\n *\n * @param token - The JWT token to decode\n * @returns Decoded payload or null if failed\n *\n * @example\n * ```typescript\n * import { decodeJWT } from '@kumix/utils';\n *\n * // Inspect token contents without verification\n * const payload = decodeJWT(token);\n * if (payload) {\n *   console.log('Token expires at:', new Date(payload.exp * 1000));\n *   console.log('User ID:', payload.userId);\n * }\n *\n * // For debugging purposes\n * function debugToken(token: string) {\n *   const payload = decodeJWT(token);\n *   if (payload) {\n *     console.log('Token payload:', payload);\n *   } else {\n *     console.log('Invalid token format');\n *   }\n * }\n * ```\n */\nexport function decodeJWT(token: string): JWTPayload | null {\n  if (!token || typeof token !== \"string\") {\n    return null;\n  }\n\n  try {\n    const decoded = jwt.decode(token) as JWTPayload;\n    return decoded;\n  } catch (error) {\n    logger.warn(\"JWT decode: Failed to decode token\", { error });\n    return null;\n  }\n}\n\n/**\n * Checks if a JWT token is expired\n *\n * @param token - The JWT token to check\n * @returns True if token is expired, false otherwise\n *\n * @example\n * ```typescript\n * import { isJWTExpired } from '@kumix/utils';\n *\n * // Check if token needs refresh\n * if (isJWTExpired(userToken)) {\n *   // Redirect to login or refresh token\n *   await refreshUserToken();\n * }\n *\n * // In token refresh logic\n * function shouldRefreshToken(token: string): boolean {\n *   return isJWTExpired(token);\n * }\n * ```\n */\nexport function isJWTExpired(token: string): boolean {\n  const payload = decodeJWT(token);\n  if (!payload?.exp) {\n    return true; // Consider invalid tokens as expired\n  }\n\n  const currentTime = Math.floor(Date.now() / 1000);\n  return payload.exp < currentTime;\n}\n\n/**\n * Gets the remaining time until token expiration\n *\n * @param token - The JWT token to check\n * @returns Remaining time in seconds, or 0 if expired/invalid\n *\n * @example\n * ```typescript\n * import { getJWTTimeRemaining } from '@kumix/utils';\n *\n * // Check how much time is left\n * const timeLeft = getJWTTimeRemaining(userToken);\n * if (timeLeft < 300) { // Less than 5 minutes\n *   // Show warning about token expiration\n *   showTokenExpirationWarning();\n * }\n *\n * // Format time remaining for display\n * function formatTimeRemaining(token: string): string {\n *   const seconds = getJWTTimeRemaining(token);\n *   const minutes = Math.floor(seconds / 60);\n *   const hours = Math.floor(minutes / 60);\n *\n *   if (hours > 0) return `${hours}h ${minutes % 60}m`;\n *   if (minutes > 0) return `${minutes}m`;\n *   return `${seconds}s`;\n * }\n * ```\n */\nexport function getJWTTimeRemaining(token: string): number {\n  const payload = decodeJWT(token);\n  if (!payload?.exp) {\n    return 0;\n  }\n\n  const currentTime = Math.floor(Date.now() / 1000);\n  const timeRemaining = payload.exp - currentTime;\n\n  return Math.max(0, timeRemaining);\n}\n","/**\n * Password hashing and verification utilities for SaaS applications\n * Provides secure password handling using bcrypt with proper salt rounds\n * Includes validation and error handling for production use\n */\n\nimport { randomInt } from \"node:crypto\";\n\nimport bcrypt from \"bcryptjs\";\n\nimport { logger } from \"../logging/logger\";\n\n/**\n * Default salt rounds for bcrypt hashing\n * 12 rounds provides good security while maintaining reasonable performance\n * Higher values increase security but also increase computation time\n */\nconst DEFAULT_SALT_ROUNDS = 12;\n\n/**\n * Interface for password hashing options\n */\ninterface HashPasswordOptions {\n  /** Number of salt rounds for bcrypt (default: 12) */\n  saltRounds?: number;\n}\n\n/**\n * Interface for password verification result\n */\ninterface VerifyPasswordResult {\n  /** Whether the password is valid */\n  isValid: boolean;\n  /** Error message if verification failed */\n  error?: string;\n}\n\n/**\n * Hashes a password using bcrypt with salt\n *\n * @param password - The plain text password to hash\n * @param options - Hashing options\n * @returns Promise that resolves to the hashed password or null if failed\n *\n * @example\n * ```typescript\n * import { hashPassword } from '@kumix/utils';\n *\n * // Basic usage\n * const hashedPassword = await hashPassword('userPassword123');\n * if (hashedPassword) {\n *   // Store hashedPassword in database\n *   await saveUser({ email, password: hashedPassword });\n * }\n *\n * // With custom salt rounds\n * const hashedPassword = await hashPassword('userPassword123', {\n *   saltRounds: 14\n * });\n *\n * // Error handling\n * const hashedPassword = await hashPassword('userPassword123');\n * if (!hashedPassword) {\n *   throw new Error('Failed to hash password');\n * }\n * ```\n */\nexport async function hashPassword(\n  password: string,\n  options: HashPasswordOptions = {},\n): Promise<string | null> {\n  // Validate input\n  if (!password || typeof password !== \"string\") {\n    logger.warn(\"Password hashing: Password must be a non-empty string\");\n    return null;\n  }\n\n  if (password.length < 1) {\n    logger.warn(\"Password hashing: Password cannot be empty\");\n    return null;\n  }\n\n  const { saltRounds = DEFAULT_SALT_ROUNDS } = options;\n\n  // Validate salt rounds\n  if (typeof saltRounds !== \"number\" || saltRounds < 4 || saltRounds > 20) {\n    logger.warn(\"Password hashing: Salt rounds must be between 4 and 20\");\n    return null;\n  }\n\n  try {\n    // Generate salt and hash password\n    const salt = await bcrypt.genSalt(saltRounds);\n    const hashedPassword = await bcrypt.hash(password, salt);\n\n    return hashedPassword;\n  } catch (error) {\n    logger.error(\"Password hashing: Failed to hash password\", { error });\n    return null;\n  }\n}\n\n/**\n * Verifies a password against its hash\n *\n * @param password - The plain text password to verify\n * @param hashedPassword - The hashed password to compare against\n * @returns Promise that resolves to verification result\n *\n * @example\n * ```typescript\n * import { verifyPassword } from '@kumix/utils';\n *\n * // Basic usage\n * const result = await verifyPassword('userPassword123', storedHashedPassword);\n * if (result.isValid) {\n *   // Password is correct, proceed with login\n *   await loginUser(user);\n * } else {\n *   // Password is incorrect\n *   throw new Error('Invalid credentials');\n * }\n *\n * // With error handling\n * const result = await verifyPassword('userPassword123', storedHashedPassword);\n * if (result.error) {\n *   logger.error('Password verification failed:', result.error);\n *   throw new Error('Authentication error');\n * }\n *\n * // In authentication middleware\n * async function authenticateUser(email: string, password: string) {\n *   const user = await getUserByEmail(email);\n *   if (!user) {\n *     return { success: false, error: 'User not found' };\n *   }\n *\n *   const result = await verifyPassword(password, user.hashedPassword);\n *   if (!result.isValid) {\n *     return { success: false, error: 'Invalid password' };\n *   }\n *\n *   return { success: true, user };\n * }\n * ```\n */\nexport async function verifyPassword(\n  password: string,\n  hashedPassword: string,\n): Promise<VerifyPasswordResult> {\n  // Validate inputs\n  if (!password || typeof password !== \"string\") {\n    return {\n      isValid: false,\n      error: \"Password must be a non-empty string\",\n    };\n  }\n\n  if (!hashedPassword || typeof hashedPassword !== \"string\") {\n    return {\n      isValid: false,\n      error: \"Hashed password must be a non-empty string\",\n    };\n  }\n\n  // Basic bcrypt hash format validation\n  if (\n    !hashedPassword.startsWith(\"$2a$\") &&\n    !hashedPassword.startsWith(\"$2b$\") &&\n    !hashedPassword.startsWith(\"$2y$\")\n  ) {\n    return {\n      isValid: false,\n      error: \"Invalid hash format\",\n    };\n  }\n\n  try {\n    const isValid = await bcrypt.compare(password, hashedPassword);\n    return { isValid };\n  } catch (error) {\n    logger.error(\"Password verification: Failed to verify password\", { error });\n    return {\n      isValid: false,\n      error: \"Password verification failed\",\n    };\n  }\n}\n\n/**\n * Checks if a password needs to be rehashed (e.g., due to updated salt rounds)\n *\n * @param hashedPassword - The current hashed password\n * @param targetSaltRounds - The target salt rounds (default: 12)\n * @returns Whether the password needs to be rehashed\n *\n * @example\n * ```typescript\n * import { needsRehash, hashPassword } from '@kumix/utils';\n *\n * // Check if password needs rehashing during login\n * async function loginUser(email: string, password: string) {\n *   const user = await getUserByEmail(email);\n *   const result = await verifyPassword(password, user.hashedPassword);\n *\n *   if (result.isValid) {\n *     // Check if we need to rehash with updated salt rounds\n *     if (needsRehash(user.hashedPassword, 14)) {\n *       const newHash = await hashPassword(password, { saltRounds: 14 });\n *       if (newHash) {\n *         await updateUserPassword(user.id, newHash);\n *       }\n *     }\n *\n *     return { success: true, user };\n *   }\n *\n *   return { success: false, error: 'Invalid credentials' };\n * }\n * ```\n */\nexport function needsRehash(\n  hashedPassword: string,\n  targetSaltRounds: number = DEFAULT_SALT_ROUNDS,\n): boolean {\n  if (!hashedPassword || typeof hashedPassword !== \"string\") {\n    return true; // Invalid hash should be rehashed\n  }\n\n  try {\n    // Extract salt rounds from hash\n    const parts = hashedPassword.split(\"$\");\n    if (parts.length < 4) {\n      return true; // Invalid format\n    }\n\n    const currentSaltRounds = parseInt(parts[2], 10);\n    return currentSaltRounds !== targetSaltRounds;\n  } catch (error) {\n    logger.warn(\"Password rehash check: Failed to parse hash\", { error });\n    return true; // If we can't parse, assume it needs rehashing\n  }\n}\n\n/**\n * Generates a secure random password\n *\n * @param length - Length of the password (default: 16, min: 8, max: 128)\n * @param options - Password generation options\n * @returns Generated password string\n *\n * @example\n * ```typescript\n * import { generateSecurePassword } from '@kumix/utils';\n *\n * // Generate default password (16 characters)\n * const password = generateSecurePassword();\n *\n * // Generate longer password\n * const longPassword = generateSecurePassword(24);\n *\n * // Generate password without symbols\n * const simplePassword = generateSecurePassword(12, {\n *   includeSymbols: false\n * });\n *\n * // For temporary passwords\n * const tempPassword = generateSecurePassword(12);\n * await sendPasswordResetEmail(user.email, tempPassword);\n * ```\n */\nexport function generateSecurePassword(\n  length: number = 16,\n  options: {\n    includeUppercase?: boolean;\n    includeLowercase?: boolean;\n    includeNumbers?: boolean;\n    includeSymbols?: boolean;\n  } = {},\n): string {\n  const {\n    includeUppercase = true,\n    includeLowercase = true,\n    includeNumbers = true,\n    includeSymbols = true,\n  } = options;\n\n  // Validate length\n  const validLength = Math.max(8, Math.min(128, length));\n\n  let charset = \"\";\n  if (includeUppercase) charset += \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n  if (includeLowercase) charset += \"abcdefghijklmnopqrstuvwxyz\";\n  if (includeNumbers) charset += \"0123456789\";\n  if (includeSymbols) charset += \"!@#$%^&*()_+-=[]{}|;:,.<>?\";\n\n  if (charset.length === 0) {\n    // Fallback to alphanumeric if no character sets selected\n    charset = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\";\n  }\n\n  let password = \"\";\n  for (let i = 0; i < validLength; i++) {\n    // Use a cryptographically secure RNG to avoid bias and predictability\n    const randomIndex = randomInt(0, charset.length);\n    password += charset[randomIndex];\n  }\n\n  return password;\n}\n","/**\n * Utility function for parsing date strings into Date objects\n * Provides natural language date parsing capabilities\n */\n\nimport * as chrono from \"chrono-node\";\n\n/**\n * Parses a date string into a Date object using natural language processing\n * Passes through Date objects unchanged\n *\n * @param str - The date string to parse or a Date object to pass through\n * @returns A Date object, or null if parsing fails\n *\n * @example\n * ```ts\n * // Parse natural language date strings\n * parseDateTime('tomorrow at 3pm')\n * // Returns a Date object for tomorrow at 3:00 PM\n *\n * // Parse formal date strings\n * parseDateTime('2023-06-15')\n * // Returns a Date object for June 15, 2023\n *\n * // Parse relative dates\n * parseDateTime('next Friday')\n * // Returns a Date object for next Friday\n *\n * // Pass through existing Date objects\n * const date = new Date('2023-06-15')\n * parseDateTime(date)\n * // Returns the same Date object\n *\n * // Parse time strings\n * parseDateTime('3:30pm')\n * // Returns a Date object for today at 3:30 PM\n *\n * // Parse complex date expressions\n * parseDateTime('3 days after next Monday')\n * // Returns the appropriate Date object\n * ```\n */\nexport const parseDateTime = (str: Date | string): Date | null => {\n  if (str instanceof Date) return str;\n  return chrono.parseDate(str);\n};\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@kumix/utils",
+  "version": "0.1.0",
+  "description": "A comprehensive library of utility functions for building modern SaaS applications.",
+  "author": "Kumix Labs <hai@kumix.io>",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "clean:all": "rimraf .turbo coverage dist node_modules",
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "types:check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "homepage": "https://github.com/kumixlabs/toolkits",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kumixlabs/toolkits.git",
+    "directory": "packages/utils"
+  },
+  "bugs": {
+    "url": "https://github.com/kumixlabs/toolkits/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "kumix",
+    "utils"
+  ],
+  "dependencies": {
+    "@paralleldrive/cuid2": "^3.3.0",
+    "@sindresorhus/slugify": "^3.0.0",
+    "base-x": "^5.0.1",
+    "bcryptjs": "^3.0.3",
+    "chrono-node": "2.9.1",
+    "clsx": "^2.1.1",
+    "consola": "^3.4.2",
+    "jsonwebtoken": "^9.0.3",
+    "ms": "^2.1.3",
+    "nanoid": "^5.1.16",
+    "tailwind-merge": "^3.6.0"
+  },
+  "devDependencies": {
+    "@kumix/tsconfig": "^0.1.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^26.1.0",
+    "tsdown": "^0.22.3",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}