@umituz/web-dashboard 3.2.4 → 4.1.0

package/src/domains/auth/types/index.ts

@@ -21,4 +21,5 @@ export type {
   RegisterFormProps,
   ForgotPasswordFormProps,
   ResetPasswordFormProps,
+  Translate,
 } from "./auth";

package/src/domains/auth/utils/auth.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Tests for pure auth utility functions.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  isValidEmail,
+  isValidPassword,
+  validateLogin,
+  validateRegister,
+  validateResetPassword,
+  getUserDisplayName,
+  getUserInitials,
+  calculatePasswordStrength,
+  getPasswordStrengthBand,
+  maskEmail,
+  sanitizeInput,
+} from "./auth";
+import { generateResetToken } from "./secureToken";
+import { AUTH_VALIDATION_KEYS } from "./validationKeys";
+
+describe("isValidEmail", () => {
+  it("accepts plain addresses", () => {
+    expect(isValidEmail("user@example.com")).toBe(true);
+  });
+
+  it("rejects missing local part, domain, or TLD", () => {
+    expect(isValidEmail("@example.com")).toBe(false);
+    expect(isValidEmail("user@")).toBe(false);
+    expect(isValidEmail("user@example")).toBe(false);
+    expect(isValidEmail("user example.com")).toBe(false);
+  });
+});
+
+describe("isValidPassword", () => {
+  it("enforces the minimum length", () => {
+    expect(isValidPassword("short")).toBe(false);
+    expect(isValidPassword("longenough")).toBe(true);
+  });
+
+  it("honors a custom minimum", () => {
+    expect(isValidPassword("12345678", 12)).toBe(false);
+    expect(isValidPassword("123456789012", 12)).toBe(true);
+  });
+});
+
+describe("validateLogin", () => {
+  it("passes valid credentials", () => {
+    expect(validateLogin({ email: "a@b.co", password: "x".repeat(8) })).toEqual({ valid: true });
+  });
+
+  it("requires an email first", () => {
+    expect(validateLogin({ email: "", password: "x" })).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.emailRequired,
+    });
+  });
+
+  it("rejects a malformed email", () => {
+    expect(validateLogin({ email: "nope", password: "x" })).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.emailInvalid,
+    });
+  });
+
+  it("requires a password", () => {
+    expect(validateLogin({ email: "a@b.co", password: "" })).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.passwordRequired,
+    });
+  });
+});
+
+describe("validateRegister", () => {
+  const base = { email: "a@b.co", password: "longenough1" };
+
+  it("passes with minimal data", () => {
+    expect(validateRegister(base)).toEqual({ valid: true });
+  });
+
+  it("requires a name when asked to", () => {
+    expect(validateRegister(base, true)).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.nameRequired,
+    });
+  });
+
+  it("enforces password length", () => {
+    expect(validateRegister({ ...base, password: "short" })).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.passwordTooShort,
+    });
+  });
+
+  it("checks confirmation when required", () => {
+    expect(
+      validateRegister({ ...base, confirmPassword: "different" }, false, true),
+    ).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch,
+    });
+  });
+});
+
+describe("validateResetPassword", () => {
+  const base = { token: "tok", password: "longenough", confirmPassword: "longenough" };
+
+  it("passes matching valid data", () => {
+    expect(validateResetPassword(base)).toEqual({ valid: true });
+  });
+
+  it("requires a token", () => {
+    expect(validateResetPassword({ ...base, token: "" })).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.invalidResetToken,
+    });
+  });
+
+  it("rejects mismatched confirmation", () => {
+    expect(validateResetPassword({ ...base, confirmPassword: "other" })).toEqual({
+      valid: false,
+      error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch,
+    });
+  });
+});
+
+describe("display helpers", () => {
+  it("getUserDisplayName prefers name, then email, then null", () => {
+    expect(getUserDisplayName({ id: "1", name: "Ada", email: "a@b.co" } as never)).toBe("Ada");
+    expect(getUserDisplayName({ id: "1", email: "a@b.co" } as never)).toBe("a@b.co");
+    expect(getUserDisplayName(null)).toBeNull();
+  });
+
+  it("getUserInitials uses first and last name parts", () => {
+    expect(getUserInitials({ id: "1", name: "Ada Lovelace" } as never)).toBe("AL");
+    expect(getUserInitials({ id: "1", name: "ada" } as never)).toBe("AD");
+    expect(getUserInitials(null)).toBeNull();
+  });
+});
+
+describe("password strength", () => {
+  it("scores a strong password at 100", () => {
+    expect(calculatePasswordStrength("Str0ng!Password")).toBe(100);
+    expect(getPasswordStrengthBand("Str0ng!Password")).toBe("strong");
+  });
+
+  it("scores a weak password low", () => {
+    expect(getPasswordStrengthBand("abc")).toBe("weak");
+  });
+
+  it("never exceeds 100", () => {
+    expect(calculatePasswordStrength("aaaaaaaaaaaaaaaaaaaa!A1")).toBeLessThanOrEqual(100);
+  });
+});
+
+describe("maskEmail", () => {
+  it("masks the local part", () => {
+    expect(maskEmail("umit@example.com")).toBe("u***@example.com");
+  });
+
+  it("returns null for invalid input", () => {
+    expect(maskEmail("not-an-email")).toBeNull();
+  });
+});
+
+describe("sanitizeInput", () => {
+  it("trims and truncates", () => {
+    expect(sanitizeInput("  hello  ")).toBe("hello");
+    expect(sanitizeInput("abcdef", 3)).toBe("abc");
+  });
+});
+
+describe("generateResetToken", () => {
+  it("produces a hex string of 2 * length chars", () => {
+    const token = generateResetToken(16);
+    expect(token).toMatch(/^[0-9a-f]{32}$/);
+  });
+
+  it("produces different tokens on each call", () => {
+    expect(generateResetToken()).not.toBe(generateResetToken());
+  });
+});

package/src/domains/auth/utils/auth.ts

@@ -1,16 +1,27 @@
 /**
  * Auth Utilities
  *
- * Utility functions for authentication operations
+ * Validation and helper functions for authentication.
+ * Validation messages are i18n keys, not hardcoded strings —
+ * the consumer renders the localized text in its UI layer.
  */
 
 import type { LoginCredentials, RegisterData, User } from "../types/auth";
+import { AUTH_VALIDATION_KEYS } from './validationKeys';
+
+export { generateResetToken } from './secureToken';
+export { AUTH_VALIDATION_KEYS } from './validationKeys';
+export type { AuthValidationKey } from './validationKeys';
+
+/**
+ * Validation result type — error is now an i18n key.
+ */
+export type ValidationResult =
+  | { valid: true }
+  | { valid: false; error: string };
 
 /**
  * Validate email format
- *
- * @param email - Email address
- * @returns Whether email is valid
  */
 export function isValidEmail(email: string): boolean {
   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -18,11 +29,7 @@ export function isValidEmail(email: string): boolean {
 }
 
 /**
- * Validate password strength
- *
- * @param password - Password
- * @param minLength - Minimum length (default: 8)
- * @returns Whether password meets requirements
+ * Validate password length
  */
 export function isValidPassword(password: string, minLength: number = 8): boolean {
   return password.length >= minLength;
@@ -30,148 +37,108 @@ export function isValidPassword(password: string, minLength: number = 8): boolea
 
 /**
  * Validate login credentials
- *
- * @param credentials - Login credentials
- * @returns Validation result with error message
  */
-export function validateLogin(credentials: LoginCredentials): {
-  valid: boolean;
-  error?: string;
-} {
+export function validateLogin(credentials: LoginCredentials): ValidationResult {
   if (!credentials.email) {
-    return { valid: false, error: "Email is required" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
   }
-
   if (!isValidEmail(credentials.email)) {
-    return { valid: false, error: "Invalid email format" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
   }
-
   if (!credentials.password) {
-    return { valid: false, error: "Password is required" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
   }
-
   return { valid: true };
 }
 
 /**
  * Validate registration data
- *
- * @param data - Registration data
- * @param requireName - Whether name is required (default: false)
- * @param requirePasswordConfirm - Whether password confirmation is required
- * @returns Validation result with error message
  */
 export function validateRegister(
   data: RegisterData & { confirmPassword?: string },
   requireName: boolean = false,
-  requirePasswordConfirm?: boolean
-): {
-  valid: boolean;
-  error?: string;
-} {
+  requirePasswordConfirm?: boolean,
+): ValidationResult {
   if (!data.email) {
-    return { valid: false, error: "Email is required" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
   }
-
   if (!isValidEmail(data.email)) {
-    return { valid: false, error: "Invalid email format" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
   }
-
   if (requireName && !data.name) {
-    return { valid: false, error: "Name is required" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.nameRequired };
   }
-
   if (!data.password) {
-    return { valid: false, error: "Password is required" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
   }
-
   if (!isValidPassword(data.password)) {
-    return { valid: false, error: "Password must be at least 8 characters" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordTooShort };
   }
-
   if (requirePasswordConfirm && data.password !== data.confirmPassword) {
-    return { valid: false, error: "Passwords do not match" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch };
   }
-
   return { valid: true };
 }
 
 /**
- * Validate password reset request
- *
- * @param data - Forgot password data
- * @returns Validation result with error message
+ * Validate forgot-password request
  */
-export function validateForgotPassword(data: { email: string }): {
-  valid: boolean;
-  error?: string;
-} {
+export function validateForgotPassword(data: { email: string }): ValidationResult {
   if (!data.email) {
-    return { valid: false, error: "Email is required" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
   }
-
   if (!isValidEmail(data.email)) {
-    return { valid: false, error: "Invalid email format" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
   }
-
   return { valid: true };
 }
 
 /**
  * Validate password reset confirmation
- *
- * @param data - Reset password data
- * @returns Validation result with error message
  */
 export function validateResetPassword(data: {
   token: string;
   password: string;
   confirmPassword: string;
-}): {
-  valid: boolean;
-  error?: string;
-} {
+}): ValidationResult {
   if (!data.token) {
-    return { valid: false, error: "Invalid reset token" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.invalidResetToken };
   }
-
   if (!data.password) {
-    return { valid: false, error: "Password is required" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
   }
-
   if (!isValidPassword(data.password)) {
-    return { valid: false, error: "Password must be at least 8 characters" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordTooShort };
   }
-
   if (data.password !== data.confirmPassword) {
-    return { valid: false, error: "Passwords do not match" };
+    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch };
   }
-
   return { valid: true };
 }
 
 /**
  * Get user display name
  *
- * @param user - User object
- * @returns Display name or email fallback
+ * Returns null when no usable identifier exists, letting the caller
+ * decide on a localized fallback. Avoids hardcoded "Guest"/"User" strings.
  */
-export function getUserDisplayName(user: User | null): string {
-  if (!user) return "Guest";
-  return user.name || user.email || "User";
+export function getUserDisplayName(user: User | null): string | null {
+  if (!user) return null;
+  return user.name || user.email || null;
 }
 
 /**
  * Get user initials
  *
- * @param user - User object
- * @returns User initials (up to 2 characters)
+ * Returns null when no name is available, so the caller can decide
+ * whether to render a placeholder or hide the avatar.
  */
-export function getUserInitials(user: User | null): string {
-  if (!user) return "G";
+export function getUserInitials(user: User | null): string | null {
+  if (!user) return null;
   const name = user.name || user.email || "";
+  if (!name) return null;
   const parts = name.trim().split(" ");
-  if (parts.length >= 2) {
+  if (parts.length >= 2 && parts[0] && parts[parts.length - 1]) {
     return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
   }
   return name.slice(0, 2).toUpperCase();
@@ -179,9 +146,6 @@ export function getUserInitials(user: User | null): string {
 
 /**
  * Check if user has verified email
- *
- * @param user - User object
- * @returns Whether email is verified
  */
 export function isEmailVerified(user: User | null): boolean {
   return user?.emailVerified === true;
@@ -190,12 +154,14 @@ export function isEmailVerified(user: User | null): boolean {
 /**
  * Format user creation date
  *
- * @param user - User object
- * @param locale - Locale for formatting (default: en-US)
- * @returns Formatted date string or empty string
+ * Returns null when the user has no createdAt; the caller decides
+ * whether to display "—" or hide the field.
  */
-export function formatUserCreatedAt(user: User | null, locale: string = "en-US"): string {
-  if (!user || !user.createdAt) return "";
+export function formatUserCreatedAt(
+  user: User | null,
+  locale: string = "en-US",
+): string | null {
+  if (!user?.createdAt) return null;
   return new Date(user.createdAt).toLocaleDateString(locale, {
     year: "numeric",
     month: "long",
@@ -206,47 +172,25 @@ export function formatUserCreatedAt(user: User | null, locale: string = "en-US")
 /**
  * Mask email for privacy (e.g., u***@example.com)
  *
- * @param email - Email address
- * @returns Masked email
+ * Returns null when the email is invalid so the caller can show
+ * a "—" placeholder rather than the raw input.
  */
-export function maskEmail(email: string): string {
+export function maskEmail(email: string): string | null {
   const [local, domain] = email.split("@");
-  if (!local || !domain) return email;
-
+  if (!local || !domain) return null;
   const maskedLocal = local[0] + "***";
   return `${maskedLocal}@${domain}`;
 }
 
 /**
- * Generate secure random token (for demo purposes)
- * In production, use a proper crypto library
- *
- * @param length - Token length in bytes (default: 32)
- * @returns Random hex token
- */
-export function generateResetToken(length: number = 32): string {
-  const chars = "0123456789abcdef";
-  let token = "";
-  for (let i = 0; i < length * 2; i++) {
-    token += chars[Math.floor(Math.random() * chars.length)];
-  }
-  return token;
-}
-
-/**
- * Calculate password strength score (0-100)
- *
- * @param password - Password to evaluate
- * @returns Strength score
+ * Password strength score (0-100)
  */
 export function calculatePasswordStrength(password: string): number {
   let score = 0;
 
-  // Length
   if (password.length >= 8) score += 25;
   if (password.length >= 12) score += 25;
 
-  // Variety
   if (/[a-z]/.test(password)) score += 12.5;
   if (/[A-Z]/.test(password)) score += 12.5;
   if (/[0-9]/.test(password)) score += 12.5;
@@ -256,25 +200,22 @@ export function calculatePasswordStrength(password: string): number {
 }
 
 /**
- * Get password strength label
- *
- * @param password - Password to evaluate
- * @returns Strength label
+ * Password strength band. Numeric so the UI can map it to a label
+ * via its own translation catalog.
  */
-export function getPasswordStrengthLabel(password: string): string {
+export type PasswordStrengthBand = 'weak' | 'fair' | 'good' | 'strong';
+
+export function getPasswordStrengthBand(password: string): PasswordStrengthBand {
   const score = calculatePasswordStrength(password);
-  if (score < 25) return "Weak";
-  if (score < 50) return "Fair";
-  if (score < 75) return "Good";
-  return "Strong";
+  if (score < 25) return 'weak';
+  if (score < 50) return 'fair';
+  if (score < 75) return 'good';
+  return 'strong';
 }
 
 /**
  * Sanitize user input for display
- *
- * @param input - User input string
- * @returns Sanitized string
  */
-export function sanitizeInput(input: string): string {
-  return input.trim().slice(0, 1000);
+export function sanitizeInput(input: string, maxLength: number = 1000): string {
+  return input.trim().slice(0, maxLength);
 }

package/src/domains/auth/utils/i18nKeys.ts

@@ -0,0 +1,127 @@
+/**
+ * Auth Domain i18n Keys
+ *
+ * Centralized catalog of i18n keys used across auth components.
+ * Components stay free of hardcoded strings and consume these
+ * constants — the consumer app provides the actual translations.
+ */
+
+export const AUTH_KEYS = {
+  // Login screen
+  login: {
+    welcomeBack: 'auth.login.welcomeBack',
+    signInTo: 'auth.login.signInTo',
+    submit: 'auth.login.submit',
+    submitting: 'auth.login.submitting',
+    rememberMe: 'auth.login.rememberMe',
+    forgotPassword: 'auth.login.forgotPassword',
+    noAccount: 'auth.login.noAccount',
+    signUp: 'auth.login.signUp',
+    orContinueWith: 'auth.login.orContinueWith',
+  },
+
+  // Register screen
+  register: {
+    createAccount: 'auth.register.createAccount',
+    join: 'auth.register.join',
+    fullName: 'auth.register.fullName',
+    fullNamePlaceholder: 'auth.placeholders.fullName',
+    confirmPassword: 'auth.register.confirmPassword',
+    confirmPasswordPlaceholder: 'auth.placeholders.confirmPassword',
+    acceptTerms: 'auth.register.acceptTerms',
+    termsOfService: 'auth.register.termsOfService',
+    privacyPolicy: 'auth.register.privacyPolicy',
+    submit: 'auth.register.submit',
+    submitting: 'auth.register.submitting',
+    haveAccount: 'auth.register.haveAccount',
+    signIn: 'auth.register.signIn',
+    mustAcceptTerms: 'auth.register.mustAcceptTerms',
+    passwordsDoNotMatch: 'auth.register.passwordsDoNotMatch',
+  },
+
+  // Forgot password
+  forgotPassword: {
+    title: 'auth.forgotPassword.title',
+    description: 'auth.forgotPassword.description',
+    submit: 'auth.forgotPassword.submit',
+    submitting: 'auth.forgotPassword.submitting',
+    backToSignIn: 'auth.forgotPassword.backToSignIn',
+    successTitle: 'auth.forgotPassword.successTitle',
+    successMessage: 'auth.forgotPassword.successMessage',
+    sentTo: 'auth.forgotPassword.sentTo',
+    checkEmail: 'auth.forgotPassword.checkEmail',
+    step1: 'auth.forgotPassword.steps.step1',
+    step2: 'auth.forgotPassword.steps.step2',
+    step3: 'auth.forgotPassword.steps.step3',
+  },
+
+  // Reset password
+  resetPassword: {
+    title: 'auth.resetPassword.title',
+    description: 'auth.resetPassword.description',
+    newPassword: 'auth.resetPassword.newPassword',
+    confirmNewPassword: 'auth.resetPassword.confirmNewPassword',
+    submit: 'auth.resetPassword.submit',
+    submitting: 'auth.resetPassword.submitting',
+    successTitle: 'auth.resetPassword.successTitle',
+    successMessage: 'auth.resetPassword.successMessage',
+    goToSignIn: 'auth.resetPassword.goToSignIn',
+  },
+
+  // Shared fields
+  fields: {
+    email: 'auth.fields.email',
+    password: 'auth.fields.password',
+    name: 'auth.fields.name',
+  },
+
+  placeholders: {
+    emailExample: 'auth.placeholders.emailExample',
+    password: 'auth.placeholders.password',
+    fullName: 'auth.placeholders.fullName',
+  },
+
+  // Errors
+  errors: {
+    invalidCredentials: 'auth.errors.invalidCredentials',
+    loginFailed: 'auth.errors.loginFailed',
+    noAuthProvider: 'auth.errors.noAuthProvider',
+    registrationFailed: 'auth.errors.registrationFailed',
+    emailRequired: 'auth.errors.emailRequired',
+    emailInvalid: 'auth.errors.emailInvalid',
+    passwordRequired: 'auth.errors.passwordRequired',
+    passwordTooShort: 'auth.errors.passwordTooShort',
+    passwordsDoNotMatch: 'auth.errors.passwordsDoNotMatch',
+    sendResetFailed: 'auth.errors.sendResetFailed',
+    resetFailed: 'auth.errors.resetFailed',
+  },
+
+  // Password strength
+  passwordStrength: {
+    weak: 'auth.passwordStrength.weak',
+    fair: 'auth.passwordStrength.fair',
+    good: 'auth.passwordStrength.good',
+    strong: 'auth.passwordStrength.strong',
+  },
+
+  // Social
+  social: {
+    continueWithGoogle: 'auth.social.continueWithGoogle',
+    continueWithApple: 'auth.social.continueWithApple',
+  },
+
+  // Layout shell
+  layout: {
+    backToHome: 'auth.layout.backToHome',
+    orContinueWith: 'auth.layout.orContinueWith',
+    allRightsReserved: 'auth.layout.allRightsReserved',
+  },
+
+  // Accessibility
+  a11y: {
+    showPassword: 'auth.a11y.showPassword',
+    hidePassword: 'auth.a11y.hidePassword',
+  },
+} as const;
+
+export type AuthI18nKey = string;

package/src/domains/auth/utils/index.ts

@@ -18,6 +18,12 @@ export {
   maskEmail,
   generateResetToken,
   calculatePasswordStrength,
-  getPasswordStrengthLabel,
+  getPasswordStrengthBand,
   sanitizeInput,
+  type ValidationResult,
+  type PasswordStrengthBand,
 } from "./auth";
+
+export { AUTH_KEYS } from "./i18nKeys";
+export { AUTH_VALIDATION_KEYS } from "./validationKeys";
+export type { AuthValidationKey } from "./validationKeys";