@umituz/web-dashboard 5.0.1 → 6.0.0

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

@@ -1,188 +0,0 @@
-/**
- * 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,
-    });
-  });
-
-  it("accepts matching confirmation when required (the RegisterForm call shape)", () => {
-    expect(
-      validateRegister({ ...base, name: "A", confirmPassword: base.password }, false, true),
-    ).toEqual({ valid: true });
-  });
-});
-
-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,221 +0,0 @@
-/**
- * Auth Utilities
- *
- * 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
- */
-export function isValidEmail(email: string): boolean {
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(email);
-}
-
-/**
- * Validate password length
- */
-export function isValidPassword(password: string, minLength: number = 8): boolean {
-  return password.length >= minLength;
-}
-
-/**
- * Validate login credentials
- */
-export function validateLogin(credentials: LoginCredentials): ValidationResult {
-  if (!credentials.email) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
-  }
-  if (!isValidEmail(credentials.email)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
-  }
-  if (!credentials.password) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
-  }
-  return { valid: true };
-}
-
-/**
- * Validate registration data
- */
-export function validateRegister(
-  data: RegisterData & { confirmPassword?: string },
-  requireName: boolean = false,
-  requirePasswordConfirm?: boolean,
-): ValidationResult {
-  if (!data.email) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
-  }
-  if (!isValidEmail(data.email)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
-  }
-  if (requireName && !data.name) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.nameRequired };
-  }
-  if (!data.password) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
-  }
-  if (!isValidPassword(data.password)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordTooShort };
-  }
-  if (requirePasswordConfirm && data.password !== data.confirmPassword) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch };
-  }
-  return { valid: true };
-}
-
-/**
- * Validate forgot-password request
- */
-export function validateForgotPassword(data: { email: string }): ValidationResult {
-  if (!data.email) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
-  }
-  if (!isValidEmail(data.email)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
-  }
-  return { valid: true };
-}
-
-/**
- * Validate password reset confirmation
- */
-export function validateResetPassword(data: {
-  token: string;
-  password: string;
-  confirmPassword: string;
-}): ValidationResult {
-  if (!data.token) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.invalidResetToken };
-  }
-  if (!data.password) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
-  }
-  if (!isValidPassword(data.password)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordTooShort };
-  }
-  if (data.password !== data.confirmPassword) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch };
-  }
-  return { valid: true };
-}
-
-/**
- * Get user display name
- *
- * 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 | null {
-  if (!user) return null;
-  return user.name || user.email || null;
-}
-
-/**
- * Get user initials
- *
- * 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 | null {
-  if (!user) return null;
-  const name = user.name || user.email || "";
-  if (!name) return null;
-  const parts = name.trim().split(" ");
-  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();
-}
-
-/**
- * Check if user has verified email
- */
-export function isEmailVerified(user: User | null): boolean {
-  return user?.emailVerified === true;
-}
-
-/**
- * Format user creation date
- *
- * 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 | null {
-  if (!user?.createdAt) return null;
-  return new Date(user.createdAt).toLocaleDateString(locale, {
-    year: "numeric",
-    month: "long",
-    day: "numeric",
-  });
-}
-
-/**
- * Mask email for privacy (e.g., u***@example.com)
- *
- * 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 | null {
-  const [local, domain] = email.split("@");
-  if (!local || !domain) return null;
-  const maskedLocal = local[0] + "***";
-  return `${maskedLocal}@${domain}`;
-}
-
-/**
- * Password strength score (0-100)
- */
-export function calculatePasswordStrength(password: string): number {
-  let score = 0;
-
-  if (password.length >= 8) score += 25;
-  if (password.length >= 12) score += 25;
-
-  if (/[a-z]/.test(password)) score += 12.5;
-  if (/[A-Z]/.test(password)) score += 12.5;
-  if (/[0-9]/.test(password)) score += 12.5;
-  if (/[^a-zA-Z0-9]/.test(password)) score += 12.5;
-
-  return Math.min(score, 100);
-}
-
-/**
- * Password strength band. Numeric so the UI can map it to a label
- * via its own translation catalog.
- */
-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';
-}
-
-/**
- * Sanitize user input for display
- */
-export function sanitizeInput(input: string, maxLength: number = 1000): string {
-  return input.trim().slice(0, maxLength);
-}

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

@@ -1,109 +0,0 @@
-export const AUTH_KEYS = {
-  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: {
-    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',
-  },
-
-  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',
-  },
-
-  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',
-  },
-
-  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: {
-    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',
-  },
-
-  passwordStrength: {
-    weak: 'auth.passwordStrength.weak',
-    fair: 'auth.passwordStrength.fair',
-    good: 'auth.passwordStrength.good',
-    strong: 'auth.passwordStrength.strong',
-  },
-
-  social: {
-    continueWithGoogle: 'auth.social.continueWithGoogle',
-    continueWithApple: 'auth.social.continueWithApple',
-  },
-
-  layout: {
-    backToHome: 'auth.layout.backToHome',
-    orContinueWith: 'auth.layout.orContinueWith',
-    allRightsReserved: 'auth.layout.allRightsReserved',
-  },
-
-  a11y: {
-    showPassword: 'auth.a11y.showPassword',
-    hidePassword: 'auth.a11y.hidePassword',
-  },
-} as const;
-
-export type AuthI18nKey = string;

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

@@ -1,29 +0,0 @@
-/**
- * Auth Utilities
- *
- * Export all auth utilities
- */
-
-export {
-  isValidEmail,
-  isValidPassword,
-  validateLogin,
-  validateRegister,
-  validateForgotPassword,
-  validateResetPassword,
-  getUserDisplayName,
-  getUserInitials,
-  isEmailVerified,
-  formatUserCreatedAt,
-  maskEmail,
-  generateResetToken,
-  calculatePasswordStrength,
-  getPasswordStrengthBand,
-  sanitizeInput,
-  type ValidationResult,
-  type PasswordStrengthBand,
-} from "./auth";
-
-export { AUTH_KEYS } from "./i18nKeys";
-export { AUTH_VALIDATION_KEYS } from "./validationKeys";
-export type { AuthValidationKey } from "./validationKeys";

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

@@ -1,33 +0,0 @@
-/**
- * Auth Utilities - Secure Token
- *
- * Cryptographically secure token generation utilities
- */
-
-/**
- * Generate a cryptographically secure random token.
- *
- * Requires the Web Crypto API (`crypto.getRandomValues`), available in
- * all modern browsers, Node.js >= 19 (and >= 15 via `globalThis.crypto`),
- * and React Native with a crypto polyfill. Throws instead of silently
- * degrading to an insecure PRNG — predictable tokens are worse than
- * a loud failure.
- *
- * @param length - Token length in bytes (default: 32)
- * @returns Hex-encoded random token
- * @throws Error when no CSPRNG is available in the runtime
- */
-export function generateResetToken(length: number = 32): string {
-  if (typeof crypto === 'undefined' || typeof crypto.getRandomValues !== 'function') {
-    throw new Error(
-      'generateResetToken: no cryptographic random source available in this runtime ' +
-        '(requires crypto.getRandomValues — Web Crypto, Node >= 19, or a polyfill)',
-    );
-  }
-
-  const byteLength = Math.max(1, Math.floor(length));
-  const bytes = new Uint8Array(byteLength);
-  crypto.getRandomValues(bytes);
-
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
-}

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

@@ -1,23 +0,0 @@
-/**
- * Auth Validation Error Keys
- *
- * Stable i18n keys for validation errors. The auth UI maps these to
- * localized messages via the consumer's translation system.
- *
- * Why keys instead of literal strings:
- *   - No hardcoded user-facing strings in source code
- *   - Centralized catalog: easier to audit and translate
- *   - Validators stay pure and testable
- */
-
-export const AUTH_VALIDATION_KEYS = {
-  emailRequired: 'auth.validation.emailRequired',
-  emailInvalid: 'auth.validation.emailInvalid',
-  passwordRequired: 'auth.validation.passwordRequired',
-  passwordTooShort: 'auth.validation.passwordTooShort',
-  passwordsDoNotMatch: 'auth.validation.passwordsDoNotMatch',
-  nameRequired: 'auth.validation.nameRequired',
-  invalidResetToken: 'auth.validation.invalidResetToken',
-} as const;
-
-export type AuthValidationKey = (typeof AUTH_VALIDATION_KEYS)[keyof typeof AUTH_VALIDATION_KEYS];

package/src/domains/session/DemoLogin.tsx

@@ -1,42 +0,0 @@
-import { UserRound } from "lucide-react";
-import { Button } from "@umituz/web-design-system/atoms";
-import { useT } from "@umituz/web-localization/react";
-import { SESSION_KEYS } from "./utils/i18nKeys";
-
-export interface DemoLoginProps {
-  onDemo: (userId: string) => void | Promise<void>;
-  userId: string;
-  label?: string;
-  variant?: "default" | "outline" | "ghost";
-  size?: "default" | "sm";
-  disabled?: boolean;
-  className?: string;
-}
-
-export const DemoLogin = ({
-  onDemo,
-  userId,
-  label,
-  variant = "outline",
-  size = "default",
-  disabled = false,
-  className,
-}: DemoLoginProps) => {
-  const t = useT();
-
-  return (
-    <Button
-      type="button"
-      variant={variant}
-      size={size}
-      disabled={disabled}
-      className={className}
-      onClick={() => void onDemo(userId)}
-    >
-      <UserRound aria-hidden="true" />
-      {label ?? t(SESSION_KEYS.demoLogin.action)}
-    </Button>
-  );
-};
-
-export default DemoLogin;