@mudrichenkoevgeny/web-platform-sdk-core-security 0.0.1 → 0.1.2

package/src/di/security-component.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  WebSocketServiceMock,
-  HttpClient,
-  EncryptedSettingsMock,
-  DeviceInfoProviderMock
-} from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import { SecurityComponent } from '@/di/security-component'
-
-describe('SecurityComponent', () => {
-  it('initializes all modules and exposes dependencies', () => {
-    const ws = new WebSocketServiceMock()
-    const httpClient = new HttpClient({
-      baseUrl: 'https://api.example.com',
-      deviceInfoProvider: new DeviceInfoProviderMock()
-    })
-    const encryptedSettings = new EncryptedSettingsMock()
-
-    const component = new SecurityComponent({
-      webSocketService: ws,
-      httpClient,
-      encryptedSettings
-    })
-
-    expect(component.securitySettingsStorage).toBeDefined()
-    expect(component.openSecuritySettingsApi).toBeDefined()
-    expect(component.securitySettingsRepository).toBeDefined()
-    expect(component.passwordPolicyValidator).toBeDefined()
-    expect(component.refreshSecuritySettingsUseCase).toBeDefined()
-    expect(component.validatePasswordUseCase).toBeDefined()
-    expect(component.securityWebSocketMessageHandler).toBeDefined()
-  })
-})

package/src/di/security-component.ts

@@ -1,86 +0,0 @@
-import type { EncryptedSettings, HttpClient, WebSocketService } from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import type { OpenSecuritySettingsStorage } from '@/storage/security-settings/open-security-settings-storage'
-import { EncryptedOpenSecuritySettingsStorage } from '@/storage/security-settings/encrypted-open-security-settings-storage'
-import type { OpenSecuritySettingsApi } from '@/network/security-settings/open-security-settings-api'
-import { FetchOpenSecuritySettingsApi } from '@/network/security-settings/fetch-open-security-settings-api'
-import type { OpenSecuritySettingsRepository } from '@/repository/open-security-settings-repository'
-import { OpenSecuritySettingsRepositoryImpl } from '@/repository/open-security-settings-repository-impl'
-import { PasswordPolicyValidator } from '@/domain/model/password-policy-validator'
-import { RefreshOpenSecuritySettingsUseCase } from '@/usecase/refresh-open-security-settings-use-case'
-import { ValidatePasswordUseCase } from '@/usecase/validate-password-use-case'
-import { SecurityWebSocketMessageHandler } from '@/network/websocket/message-handler/security-web-socket-message-handler'
-
-/**
- * Configuration options required to instantiate {@link SecurityComponent}.
- */
-export interface SecurityComponentConfig {
-  /** Global WebSocket service. */
-  webSocketService: WebSocketService
-  /** Pre-configured HTTP client for REST calls. */
-  httpClient: HttpClient
-  /** Encrypted storage backend. */
-  encryptedSettings: EncryptedSettings
-  /** Optional mock overrides for tests. */
-  openSecuritySettingsApi?: OpenSecuritySettingsApi
-  /** Optional mock overrides for tests. */
-  openSecuritySettingsStorage?: OpenSecuritySettingsStorage
-  /** Optional mock overrides for tests. */
-  passwordPolicyValidator?: PasswordPolicyValidator
-}
-
-/**
- * Root dependency injection container for `core-security` module.
- *
- * Assembles storage, networking, repositories, and password policy validation.
- */
-export class SecurityComponent {
-  /** Core persistence interface for open security settings. */
-  public readonly securitySettingsStorage: OpenSecuritySettingsStorage
-  /** HTTP REST client API for open security settings. */
-  public readonly openSecuritySettingsApi: OpenSecuritySettingsApi
-  /** Central repository for open security settings. */
-  public readonly securitySettingsRepository: OpenSecuritySettingsRepository
-  /** Pure domain logic password policy validator. */
-  public readonly passwordPolicyValidator: PasswordPolicyValidator
-  /** Use case for forcing a network refresh of settings. */
-  public readonly refreshSecuritySettingsUseCase: RefreshOpenSecuritySettingsUseCase
-  /** Use case for validating password candidate strings against active policy. */
-  public readonly validatePasswordUseCase: ValidatePasswordUseCase
-  /** Handler offered to the shared WebSocket pipeline. */
-  public readonly securityWebSocketMessageHandler: SecurityWebSocketMessageHandler
-
-  /**
-   * Constructs a new {@link SecurityComponent}.
-   *
-   * @param config - Container configuration holding global SDK dependencies
-   */
-  public constructor(config: SecurityComponentConfig) {
-    this.securitySettingsStorage =
-      config.openSecuritySettingsStorage ??
-      new EncryptedOpenSecuritySettingsStorage(config.encryptedSettings)
-
-    this.passwordPolicyValidator =
-      config.passwordPolicyValidator ?? new PasswordPolicyValidator()
-
-    this.openSecuritySettingsApi =
-      config.openSecuritySettingsApi ??
-      new FetchOpenSecuritySettingsApi(config.httpClient)
-
-    this.securitySettingsRepository = new OpenSecuritySettingsRepositoryImpl(
-      this.openSecuritySettingsApi,
-      this.securitySettingsStorage,
-      config.webSocketService
-    )
-
-    this.refreshSecuritySettingsUseCase = new RefreshOpenSecuritySettingsUseCase(
-      this.securitySettingsRepository
-    )
-
-    this.validatePasswordUseCase = new ValidatePasswordUseCase(
-      this.securitySettingsRepository,
-      this.passwordPolicyValidator
-    )
-
-    this.securityWebSocketMessageHandler = new SecurityWebSocketMessageHandler()
-  }
-}

package/src/domain/model/open-security-settings.ts

@@ -1,79 +0,0 @@
-import type { OpenSecuritySettingsPayload } from '@mudrichenkoevgeny/shared-foundation'
-
-/** Password policy requirement constraints. */
-export interface OpenPasswordPolicy {
-  /** Minimum required password character length. */
-  readonly minLength: number
-  /** Whether password must contain at least one letter. */
-  readonly requireLetter: boolean
-  /** Whether password must contain at least one uppercase letter. */
-  readonly requireUpperCase: boolean
-  /** Whether password must contain at least one lowercase letter. */
-  readonly requireLowerCase: boolean
-  /** Whether password must contain at least one digit character. */
-  readonly requireDigit: boolean
-  /** Whether password must contain at least one special character. */
-  readonly requireSpecialChar: boolean
-}
-
-/** One-time password confirmation constraints. */
-export interface OtpConfirmation {
-  /** Delay duration in seconds before requesting OTP resend. */
-  readonly retryAfterSeconds: number
-  /** Number of digit/symbol characters in OTP code. */
-  readonly numberOfSymbols: number
-  /** Validity duration in seconds before OTP code expires. */
-  readonly expirationSeconds: number
-}
-
-/** Active open security settings domain model. */
-export interface OpenSecuritySettings {
-  /** Password policy validation configuration. */
-  readonly openPasswordPolicy: OpenPasswordPolicy
-  /** OTP code confirmation parameters. */
-  readonly otpConfirmation: OtpConfirmation
-}
-
-/**
- * Maps an {@link OpenSecuritySettingsPayload} server response object into an {@link OpenSecuritySettings} domain model.
- *
- * @param payload - Raw API response payload
- * @returns Mapped domain model
- */
-export const toOpenSecuritySettings = (payload: OpenSecuritySettingsPayload): OpenSecuritySettings => ({
-  openPasswordPolicy: {
-    minLength: payload.open_password_policy.min_length,
-    requireLetter: payload.open_password_policy.require_letter,
-    requireUpperCase: payload.open_password_policy.require_upper_case,
-    requireLowerCase: payload.open_password_policy.require_lower_case,
-    requireDigit: payload.open_password_policy.require_digit,
-    requireSpecialChar: payload.open_password_policy.require_special_char
-  },
-  otpConfirmation: {
-    retryAfterSeconds: payload.otp_confirmation.retry_after_seconds,
-    numberOfSymbols: payload.otp_confirmation.number_of_symbols,
-    expirationSeconds: payload.otp_confirmation.expiration_seconds
-  }
-})
-
-/**
- * Maps an {@link OpenSecuritySettings} domain model into an {@link OpenSecuritySettingsPayload} server payload.
- *
- * @param settings - Security settings domain model
- * @returns Serialized API payload
- */
-export const toOpenSecuritySettingsPayload = (settings: OpenSecuritySettings): OpenSecuritySettingsPayload => ({
-  open_password_policy: {
-    min_length: settings.openPasswordPolicy.minLength,
-    require_letter: settings.openPasswordPolicy.requireLetter,
-    require_upper_case: settings.openPasswordPolicy.requireUpperCase,
-    require_lower_case: settings.openPasswordPolicy.requireLowerCase,
-    require_digit: settings.openPasswordPolicy.requireDigit,
-    require_special_char: settings.openPasswordPolicy.requireSpecialChar
-  },
-  otp_confirmation: {
-    retry_after_seconds: settings.otpConfirmation.retryAfterSeconds,
-    number_of_symbols: settings.otpConfirmation.numberOfSymbols,
-    expiration_seconds: settings.otpConfirmation.expirationSeconds
-  }
-})

package/src/domain/model/password-policy-validator.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { PasswordPolicyValidator } from '@/domain/model/password-policy-validator'
-import type { OpenPasswordPolicy } from '@/domain/model/open-security-settings'
-
-describe('PasswordPolicyValidator', () => {
-  const validator = new PasswordPolicyValidator()
-
-  const strictPolicy: OpenPasswordPolicy = {
-    minLength: 8,
-    requireLetter: true,
-    requireUpperCase: true,
-    requireLowerCase: true,
-    requireDigit: true,
-    requireSpecialChar: true
-  }
-
-  const relaxedPolicy: OpenPasswordPolicy = {
-    minLength: 6,
-    requireLetter: false,
-    requireUpperCase: false,
-    requireLowerCase: false,
-    requireDigit: false,
-    requireSpecialChar: false
-  }
-
-  it('validates successful password', () => {
-    const result = validator.validate(strictPolicy, 'Valid123!')
-    expect(result.success).toBe(true)
-  })
-
-  it('fails TOO_SHORT', () => {
-    const result = validator.validate(strictPolicy, 'Val1!')
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.reasons).toContain('TOO_SHORT')
-    }
-  })
-
-  it('fails NO_LETTER', () => {
-    const result = validator.validate(strictPolicy, '12345678!')
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.reasons).toContain('NO_LETTER')
-      expect(result.reasons).toContain('NO_UPPERCASE')
-      expect(result.reasons).toContain('NO_LOWERCASE')
-    }
-  })
-
-  it('fails NO_UPPERCASE', () => {
-    const result = validator.validate(strictPolicy, 'valid123!')
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.reasons).toContain('NO_UPPERCASE')
-    }
-  })
-
-  it('fails NO_LOWERCASE', () => {
-    const result = validator.validate(strictPolicy, 'VALID123!')
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.reasons).toContain('NO_LOWERCASE')
-    }
-  })
-
-  it('fails NO_DIGIT', () => {
-    const result = validator.validate(strictPolicy, 'ValidPassword!')
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.reasons).toContain('NO_DIGIT')
-    }
-  })
-
-  it('fails NO_SPECIAL_CHAR', () => {
-    const result = validator.validate(strictPolicy, 'Valid123')
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.reasons).toContain('NO_SPECIAL_CHAR')
-    }
-  })
-
-  it('passes relaxed policy with weak password', () => {
-    const result = validator.validate(relaxedPolicy, '123456')
-    expect(result.success).toBe(true)
-  })
-
-  it('returns multiple failure reasons simultaneously', () => {
-    const result = validator.validate(strictPolicy, 'abc')
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.reasons).toContain('TOO_SHORT')
-      expect(result.reasons).toContain('NO_UPPERCASE')
-      expect(result.reasons).toContain('NO_DIGIT')
-      expect(result.reasons).toContain('NO_SPECIAL_CHAR')
-    }
-  })
-})

package/src/domain/model/password-policy-validator.ts

@@ -1,63 +0,0 @@
-import type { OpenPasswordPolicy } from '@/domain/model/open-security-settings'
-
-/** Represents individual reasons why a password might fail policy validation. */
-export type PasswordPolicyFailReason =
-  | 'TOO_SHORT'
-  | 'NO_LETTER'
-  | 'NO_UPPERCASE'
-  | 'NO_LOWERCASE'
-  | 'NO_DIGIT'
-  | 'NO_SPECIAL_CHAR'
-  | 'TOO_COMMON'
-
-/** Result of a password policy validation check. */
-export type PasswordPolicyValidatorResult =
-  | { readonly success: true }
-  | { readonly success: false; readonly reasons: PasswordPolicyFailReason[] }
-
-/**
- * Validates a candidate password string against an {@link OpenPasswordPolicy}.
- */
-export class PasswordPolicyValidator {
-  /**
-   * Evaluates a password string against the rules defined in a policy.
-   *
-   * @param policy - Target password policy
-   * @param password - Candidate string
-   * @returns Validation result indicating success or failure reasons
-   */
-  public validate(policy: OpenPasswordPolicy, password: string): PasswordPolicyValidatorResult {
-    const reasons: PasswordPolicyFailReason[] = []
-
-    if (password.length < policy.minLength) {
-      reasons.push('TOO_SHORT')
-    }
-
-    if (policy.requireLetter && !/[a-zA-Z]/.test(password)) {
-      reasons.push('NO_LETTER')
-    }
-
-    if (policy.requireUpperCase && !/[A-Z]/.test(password)) {
-      reasons.push('NO_UPPERCASE')
-    }
-
-    if (policy.requireLowerCase && !/[a-z]/.test(password)) {
-      reasons.push('NO_LOWERCASE')
-    }
-
-    if (policy.requireDigit && !/[0-9]/.test(password)) {
-      reasons.push('NO_DIGIT')
-    }
-
-    // Special characters include standard symbols; adjust regex based on backend constraints if needed.
-    if (policy.requireSpecialChar && !/[^a-zA-Z0-9]/.test(password)) {
-      reasons.push('NO_SPECIAL_CHAR')
-    }
-
-    if (reasons.length > 0) {
-      return { success: false, reasons }
-    }
-
-    return { success: true }
-  }
-}

package/src/error/model/security-error.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { SecurityError } from '@/error/model/security-error'
-import { ClientSecurityErrorCodes } from '@/error/naming/client-security-error-codes'
-
-describe('SecurityError', () => {
-  it('creates passwordPolicyUnavailable error as a plain object', () => {
-    const error = SecurityError.passwordPolicyUnavailable()
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_POLICY_UNAVAILABLE)
-    expect(error.isRetryable).toBe(true)
-    expect(error.args).toBeNull()
-    expect(error.id).toBeDefined()
-  })
-
-  it('creates passwordTooShort error with arguments', () => {
-    const error = SecurityError.passwordTooShort(8)
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_TOO_SHORT)
-    expect(error.isRetryable).toBe(false)
-    expect(error.args).toEqual({ passwordMinLength: '8' })
-  })
-
-  it('creates passwordTooShort error without minLength', () => {
-    const error = SecurityError.passwordTooShort()
-    expect(error.args).toBeNull()
-  })
-
-  it('creates passwordNoLetter error', () => {
-    const error = SecurityError.passwordNoLetter()
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_NO_LETTER)
-  })
-
-  it('creates passwordNoUpperCase error', () => {
-    const error = SecurityError.passwordNoUpperCase()
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_NO_UPPERCASE)
-  })
-
-  it('creates passwordNoLowerCase error', () => {
-    const error = SecurityError.passwordNoLowerCase()
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_NO_LOWERCASE)
-  })
-
-  it('creates passwordNoDigit error', () => {
-    const error = SecurityError.passwordNoDigit()
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_NO_DIGIT)
-  })
-
-  it('creates passwordNoSpecialChar error', () => {
-    const error = SecurityError.passwordNoSpecialChar()
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_NO_SPECIAL_CHAR)
-  })
-
-  it('creates passwordTooCommon error', () => {
-    const error = SecurityError.passwordTooCommon()
-    expect(error.code).toBe(ClientSecurityErrorCodes.PASSWORD_TOO_COMMON)
-  })
-
-  it('supports JSON serialization / deserialization without losing structure', () => {
-    const original = SecurityError.passwordTooShort(12)
-    const serialized = JSON.stringify(original)
-    const deserialized = JSON.parse(serialized) as typeof original
-
-    expect(deserialized).toEqual(original)
-    expect(deserialized.code).toBe('PASSWORD_TOO_SHORT')
-    expect(deserialized.args).toEqual({ passwordMinLength: '12' })
-  })
-})

package/src/error/model/security-error.ts

@@ -1,182 +0,0 @@
-import { SecurityErrorArgs } from '@mudrichenkoevgeny/shared-foundation'
-import { generateErrorId } from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import type { ErrorId } from "@mudrichenkoevgeny/web-platform-sdk-core-common";
-import { ClientSecurityErrorCodes } from '@/error/naming/client-security-error-codes'
-/** Error indicating security/password policy settings could not be fetched. */
-export type SecurityErrorPasswordPolicyUnavailable = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_POLICY_UNAVAILABLE
-  readonly args: null
-  readonly isRetryable: true
-}
-
-/** Error indicating candidate password is shorter than minimum required length. */
-export type SecurityErrorPasswordTooShort = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_TOO_SHORT
-  readonly args: Record<string, string> | null
-  readonly isRetryable: false
-}
-
-/** Error indicating candidate password contains no letter character. */
-export type SecurityErrorPasswordNoLetter = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_NO_LETTER
-  readonly args: null
-  readonly isRetryable: false
-}
-
-/** Error indicating candidate password contains no uppercase letter. */
-export type SecurityErrorPasswordNoUpperCase = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_NO_UPPERCASE
-  readonly args: null
-  readonly isRetryable: false
-}
-
-/** Error indicating candidate password contains no lowercase letter. */
-export type SecurityErrorPasswordNoLowerCase = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_NO_LOWERCASE
-  readonly args: null
-  readonly isRetryable: false
-}
-
-/** Error indicating candidate password contains no digit character. */
-export type SecurityErrorPasswordNoDigit = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_NO_DIGIT
-  readonly args: null
-  readonly isRetryable: false
-}
-
-/** Error indicating candidate password contains no special character. */
-export type SecurityErrorPasswordNoSpecialChar = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_NO_SPECIAL_CHAR
-  readonly args: null
-  readonly isRetryable: false
-}
-
-/** Error indicating candidate password is on the forbidden common passwords list. */
-export type SecurityErrorPasswordTooCommon = {
-  readonly id: ErrorId
-  readonly code: typeof ClientSecurityErrorCodes.PASSWORD_TOO_COMMON
-  readonly args: null
-  readonly isRetryable: false
-}
-
-/**
- * Discriminated union type representing security domain errors.
- */
-export type SecurityError =
-  | SecurityErrorPasswordPolicyUnavailable
-  | SecurityErrorPasswordTooShort
-  | SecurityErrorPasswordNoLetter
-  | SecurityErrorPasswordNoUpperCase
-  | SecurityErrorPasswordNoLowerCase
-  | SecurityErrorPasswordNoDigit
-  | SecurityErrorPasswordNoSpecialChar
-  | SecurityErrorPasswordTooCommon
-
-/**
- * Factory helper object for constructing {@link SecurityError} plain objects.
- */
-export const SecurityError = {
-  /**
-   * Creates a password policy unavailable error.
-   *
-   * @returns {@link SecurityErrorPasswordPolicyUnavailable}
-   */
-  passwordPolicyUnavailable: (): SecurityErrorPasswordPolicyUnavailable => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_POLICY_UNAVAILABLE,
-    args: null,
-    isRetryable: true
-  }),
-
-  /**
-   * Creates a password too short validation error.
-   *
-   * @param minLength - Optional minimum length requirement
-   * @returns {@link SecurityErrorPasswordTooShort}
-   */
-  passwordTooShort: (minLength?: number | null): SecurityErrorPasswordTooShort => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_TOO_SHORT,
-    args: minLength != null ? { [SecurityErrorArgs.PASSWORD_MIN_LENGTH]: String(minLength) } : null,
-    isRetryable: false
-  }),
-
-  /**
-   * Creates a password missing letter validation error.
-   *
-   * @returns {@link SecurityErrorPasswordNoLetter}
-   */
-  passwordNoLetter: (): SecurityErrorPasswordNoLetter => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_NO_LETTER,
-    args: null,
-    isRetryable: false
-  }),
-
-  /**
-   * Creates a password missing uppercase letter validation error.
-   *
-   * @returns {@link SecurityErrorPasswordNoUpperCase}
-   */
-  passwordNoUpperCase: (): SecurityErrorPasswordNoUpperCase => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_NO_UPPERCASE,
-    args: null,
-    isRetryable: false
-  }),
-
-  /**
-   * Creates a password missing lowercase letter validation error.
-   *
-   * @returns {@link SecurityErrorPasswordNoLowerCase}
-   */
-  passwordNoLowerCase: (): SecurityErrorPasswordNoLowerCase => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_NO_LOWERCASE,
-    args: null,
-    isRetryable: false
-  }),
-
-  /**
-   * Creates a password missing digit validation error.
-   *
-   * @returns {@link SecurityErrorPasswordNoDigit}
-   */
-  passwordNoDigit: (): SecurityErrorPasswordNoDigit => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_NO_DIGIT,
-    args: null,
-    isRetryable: false
-  }),
-
-  /**
-   * Creates a password missing special character validation error.
-   *
-   * @returns {@link SecurityErrorPasswordNoSpecialChar}
-   */
-  passwordNoSpecialChar: (): SecurityErrorPasswordNoSpecialChar => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_NO_SPECIAL_CHAR,
-    args: null,
-    isRetryable: false
-  }),
-
-  /**
-   * Creates a password too common validation error.
-   *
-   * @returns {@link SecurityErrorPasswordTooCommon}
-   */
-  passwordTooCommon: (): SecurityErrorPasswordTooCommon => ({
-    id: generateErrorId(),
-    code: ClientSecurityErrorCodes.PASSWORD_TOO_COMMON,
-    args: null,
-    isRetryable: false
-  })
-}

package/src/error/naming/client-security-error-codes.ts

@@ -1,21 +0,0 @@
-/**
- * Machine-readable error codes for security client errors and password policy validation.
- */
-export const ClientSecurityErrorCodes = {
-  /** Password policy is missing and cannot be fetched. */
-  PASSWORD_POLICY_UNAVAILABLE: 'PASSWORD_POLICY_UNAVAILABLE',
-  /** Password does not meet the minimum length requirement. */
-  PASSWORD_TOO_SHORT: 'PASSWORD_TOO_SHORT',
-  /** Password must contain at least one letter. */
-  PASSWORD_NO_LETTER: 'PASSWORD_NO_LETTER',
-  /** Password must contain at least one uppercase letter. */
-  PASSWORD_NO_UPPERCASE: 'PASSWORD_NO_UPPERCASE',
-  /** Password must contain at least one lowercase letter. */
-  PASSWORD_NO_LOWERCASE: 'PASSWORD_NO_LOWERCASE',
-  /** Password must contain at least one digit. */
-  PASSWORD_NO_DIGIT: 'PASSWORD_NO_DIGIT',
-  /** Password must contain at least one special character. */
-  PASSWORD_NO_SPECIAL_CHAR: 'PASSWORD_NO_SPECIAL_CHAR',
-  /** Password is in the list of forbidden common passwords. */
-  PASSWORD_TOO_COMMON: 'PASSWORD_TOO_COMMON'
-} as const