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

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

@@ -1,87 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { SecurityErrorCodes, SecurityErrorArgs, CommonErrorArgs } from '@mudrichenkoevgeny/shared-foundation'
-import { CommonError } from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import type { ErrorId } from "@mudrichenkoevgeny/web-platform-sdk-core-common";
-import { SecurityErrorParser } from '@/error/parser/security-error-parser'
-import { SecurityError } from '@/error/model/security-error'
-import { enSecurityStrings, ruSecurityStrings } from '@/locales/index'
-describe('SecurityErrorParser', () => {
-  const parserEn = new SecurityErrorParser(enSecurityStrings)
-  const parserRu = new SecurityErrorParser(ruSecurityStrings)
-
-  it('parses client password policy validation errors', () => {
-    expect(parserEn.parse(SecurityError.passwordPolicyUnavailable())).toBe(
-      'Failed to load password requirements. Please try again.'
-    )
-    expect(parserEn.parse(SecurityError.passwordTooShort(10))).toBe(
-      'Password must be at least 10 characters long.'
-    )
-    expect(parserEn.parse(SecurityError.passwordNoLetter())).toBe(
-      'Password must contain at least one letter.'
-    )
-    expect(parserEn.parse(SecurityError.passwordNoUpperCase())).toBe(
-      'Password must contain at least one uppercase letter.'
-    )
-    expect(parserEn.parse(SecurityError.passwordNoLowerCase())).toBe(
-      'Password must contain at least one lowercase letter.'
-    )
-    expect(parserEn.parse(SecurityError.passwordNoDigit())).toBe(
-      'Password must contain at least one digit.'
-    )
-    expect(parserEn.parse(SecurityError.passwordNoSpecialChar())).toBe(
-      'Password must contain at least one special character.'
-    )
-    expect(parserEn.parse(SecurityError.passwordTooCommon())).toBe(
-      'Password is too common and insecure.'
-    )
-  })
-
-  it('supports dynamic language getter function for reactive localizations', () => {
-    let currentLanguage = enSecurityStrings
-    const dynamicParser = new SecurityErrorParser(() => currentLanguage)
-
-    expect(dynamicParser.parse(SecurityError.passwordTooShort(8))).toBe(
-      'Password must be at least 8 characters long.'
-    )
-
-    currentLanguage = ruSecurityStrings
-
-    expect(dynamicParser.parse(SecurityError.passwordTooShort(8))).toBe(
-      'Пароль должен содержать не менее 8 символов.'
-    )
-  })
-
-  it('parses shared foundation security error codes', () => {
-    const mfaError = {
-      id: 'err-1' as ErrorId,
-      code: SecurityErrorCodes.MFA_CONFIRMATION_REQUIRED,
-      args: { [SecurityErrorArgs.MFA_TOKEN]: 'token-123' },
-      isRetryable: false
-    } as const
-
-    expect(parserEn.parse(mfaError)).toBe('Authentication confirmation is required. MFA token: token-123')
-    expect(parserRu.parse(mfaError)).toBe('Требуется подтверждение аутентификации. Токен MFA: token-123')
-
-    const otpError = {
-      id: 'err-2' as ErrorId,
-      code: SecurityErrorCodes.OTP_RETRY_TOO_SOON,
-      args: { [CommonErrorArgs.RETRY_AFTER_SECONDS]: '60' },
-      isRetryable: true
-    } as const
-
-    expect(parserEn.parse(otpError)).toBe('Too many attempts. Please try again in 60 seconds.')
-
-    const totpAlreadyEnabled = {
-      id: 'err-3' as ErrorId,
-      code: SecurityErrorCodes.TOTP_ALREADY_ENABLED,
-      args: null,
-      isRetryable: false
-    } as const
-
-    expect(parserEn.parse(totpAlreadyEnabled)).toBe('Two-factor authentication is already enabled for this account.')
-  })
-
-  it('returns null for unhandled non-security error codes', () => {
-    expect(parserEn.parse(CommonError.unknown())).toBeNull()
-  })
-})

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

@@ -1,138 +0,0 @@
-import {
-  SecurityErrorCodes,
-  SecurityErrorArgs,
-  CommonErrorArgs
-} from '@mudrichenkoevgeny/shared-foundation'
-import type { AppError, AppErrorParser } from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import { ClientSecurityErrorCodes } from '@/error/naming/client-security-error-codes'
-import { enSecurityStrings } from '@/locales/index'
-import type { CoreSecurityStrings } from "@/locales/index";
-
-/**
- * AppErrorParser implementation for security-domain error codes.
- */
-export class SecurityErrorParser implements AppErrorParser {
-  private readonly getStrings: () => CoreSecurityStrings
-
-  /**
-   * Constructs a new {@link SecurityErrorParser}.
-   *
-   * @param stringsOrGetter - Core security strings dictionary or dynamic getter function returning current strings
-   */
-  public constructor(
-    stringsOrGetter: CoreSecurityStrings | (() => CoreSecurityStrings) = enSecurityStrings
-  ) {
-    this.getStrings = typeof stringsOrGetter === 'function' ? stringsOrGetter : () => stringsOrGetter
-  }
-
-  /**
-   * Parses security domain errors into localized string messages.
-   *
-   * @param appError - Application error instance
-   * @returns Localized string message or null if code is unhandled by this parser
-   */
-  public parse(appError: AppError): string | null {
-    const args = appError.args ?? {}
-    const strings = this.getStrings()
-
-    switch (appError.code) {
-      case SecurityErrorCodes.MFA_CONFIRMATION_REQUIRED:
-        return this.resolveLocalizedString(
-          args,
-          SecurityErrorArgs.MFA_TOKEN,
-          (mfaToken) => strings.error_security_mfa_confirmation_required_args(mfaToken),
-          strings.error_security_mfa_confirmation_required
-        )
-
-      case SecurityErrorCodes.OTP_RETRY_TOO_SOON:
-        return this.resolveLocalizedString(
-          args,
-          CommonErrorArgs.RETRY_AFTER_SECONDS,
-          (seconds) => strings.error_security_otp_retry_too_soon_args(seconds),
-          strings.error_security_otp_retry_too_soon
-        )
-
-      case SecurityErrorCodes.PASSWORD_TOO_WEAK: {
-        if (Object.keys(args).length === 0) {
-          return strings.error_security_password_too_weak
-        }
-        return strings.error_security_password_too_weak_args(
-          args[SecurityErrorArgs.PASSWORD_FAIL_TOO_SHORT] ?? 'false',
-          args[SecurityErrorArgs.PASSWORD_MIN_LENGTH] ?? '0',
-          args[SecurityErrorArgs.PASSWORD_FAIL_NO_LETTER] ?? 'false',
-          args[SecurityErrorArgs.PASSWORD_FAIL_NO_UPPERCASE] ?? 'false',
-          args[SecurityErrorArgs.PASSWORD_FAIL_NO_LOWERCASE] ?? 'false',
-          args[SecurityErrorArgs.PASSWORD_FAIL_NO_DIGIT] ?? 'false',
-          args[SecurityErrorArgs.PASSWORD_FAIL_NO_SPECIAL_CHAR] ?? 'false',
-          args[SecurityErrorArgs.PASSWORD_FAIL_TOO_COMMON] ?? 'false'
-        )
-      }
-
-      case SecurityErrorCodes.TOTP_ALREADY_ENABLED:
-        return strings.error_security_totp_already_enabled
-
-      case SecurityErrorCodes.TOTP_NOT_ENABLED:
-        return strings.error_security_totp_not_enabled
-
-      case SecurityErrorCodes.MFA_TOKEN_EXPIRED:
-        return strings.error_security_mfa_token_expired
-
-      case SecurityErrorCodes.RECOVERY_CODE_ALREADY_USED:
-        return strings.error_security_recovery_code_used
-
-      case SecurityErrorCodes.INVALID_TOTP_CODE:
-        return strings.error_security_invalid_totp_code
-
-      case SecurityErrorCodes.INVALID_MFA_TOKEN:
-        return strings.error_security_invalid_mfa_token
-
-      case SecurityErrorCodes.IP_NOT_ALLOWED:
-        return strings.error_security_ip_not_allowed
-
-      case ClientSecurityErrorCodes.PASSWORD_POLICY_UNAVAILABLE:
-        return strings.error_security_password_policy_unavailable
-
-      case ClientSecurityErrorCodes.PASSWORD_TOO_SHORT:
-        return this.resolveLocalizedString(
-          args,
-          SecurityErrorArgs.PASSWORD_MIN_LENGTH,
-          (minLength) => strings.error_security_password_too_short_args(minLength),
-          strings.error_security_password_too_short
-        )
-
-      case ClientSecurityErrorCodes.PASSWORD_NO_LETTER:
-        return strings.error_security_password_no_letter
-
-      case ClientSecurityErrorCodes.PASSWORD_NO_UPPERCASE:
-        return strings.error_security_password_no_uppercase
-
-      case ClientSecurityErrorCodes.PASSWORD_NO_LOWERCASE:
-        return strings.error_security_password_no_lowercase
-
-      case ClientSecurityErrorCodes.PASSWORD_NO_DIGIT:
-        return strings.error_security_password_no_digit
-
-      case ClientSecurityErrorCodes.PASSWORD_NO_SPECIAL_CHAR:
-        return strings.error_security_password_no_special_char
-
-      case ClientSecurityErrorCodes.PASSWORD_TOO_COMMON:
-        return strings.error_security_password_too_common
-
-      default:
-        return null
-    }
-  }
-
-  private resolveLocalizedString(
-    args: Record<string, string>,
-    key: string,
-    withArgsFormatter: (value: string) => string,
-    fallback: string
-  ): string {
-    const value = args[key]
-    if (value && value.trim().length > 0) {
-      return withArgsFormatter(value)
-    }
-    return fallback
-  }
-}

package/src/index.ts

@@ -1,24 +0,0 @@
-export * from './locales/index.js'
-export * from './error/naming/client-security-error-codes.js'
-export * from './error/model/security-error.js'
-export * from './error/parser/security-error-parser.js'
-export * from './domain/model/open-security-settings.js'
-export * from './domain/model/password-policy-validator.js'
-export * from './storage/security-settings/open-security-settings-storage.js'
-export * from './storage/security-settings/encrypted-open-security-settings-storage.js'
-export * from './network/security-settings/open-security-settings-api.js'
-export * from './network/security-settings/fetch-open-security-settings-api.js'
-export * from './network/contract/security-web-socket-event-types.js'
-export * from './network/websocket/message-handler/security-web-socket-message-handler.js'
-export * from './repository/open-security-settings-repository.js'
-export * from './repository/open-security-settings-repository-impl.js'
-export * from './usecase/refresh-open-security-settings-use-case.js'
-export * from './usecase/validate-password-use-case.js'
-export * from './di/security-component.js'
-export * from './mock/domain/model/open-security-settings-mock.js'
-export * from './mock/network/model/open-security-settings-payload-mock.js'
-export * from './mock/network/open-security-settings-api-mock.js'
-export * from './mock/repository/open-security-settings-repository-mock.js'
-export * from './mock/storage/open-security-settings-storage-mock.js'
-export * from './mock/usecase/validate-password-use-case-mock.js'
-export * from './mock/di/security-component-mock.js'

package/src/locales/en/strings.ts

@@ -1,67 +0,0 @@
-export interface CoreSecurityStrings {
-  error_security_mfa_confirmation_required: string
-  error_security_mfa_confirmation_required_args: (mfaToken: string) => string
-  error_security_totp_already_enabled: string
-  error_security_totp_not_enabled: string
-  error_security_mfa_token_expired: string
-  error_security_invalid_mfa_token: string
-  error_security_invalid_totp_code: string
-  error_security_recovery_code_used: string
-  error_security_otp_retry_too_soon: string
-  error_security_otp_retry_too_soon_args: (seconds: string | number) => string
-  error_security_password_too_weak: string
-  error_security_password_too_weak_args: (
-    tooShort: boolean | string,
-    minLength: string | number,
-    noLetters: boolean | string,
-    noUppercase: boolean | string,
-    noLowercase: boolean | string,
-    noDigits: boolean | string,
-    noSpecialChars: boolean | string,
-    tooCommon: boolean | string
-  ) => string
-  error_security_password_policy_unavailable: string
-  error_security_password_too_short: string
-  error_security_password_too_short_args: (minLength: string | number) => string
-  error_security_password_no_letter: string
-  error_security_password_no_uppercase: string
-  error_security_password_no_lowercase: string
-  error_security_password_no_digit: string
-  error_security_password_no_special_char: string
-  error_security_password_too_common: string
-  error_security_ip_not_allowed: string
-}
-
-export const enSecurityStrings: CoreSecurityStrings = {
-  error_security_mfa_confirmation_required: 'Authentication confirmation is required.',
-  error_security_mfa_confirmation_required_args: (mfaToken: string) => `Authentication confirmation is required. MFA token: ${mfaToken}`,
-  error_security_totp_already_enabled: 'Two-factor authentication is already enabled for this account.',
-  error_security_totp_not_enabled: 'Two-factor authentication is not enabled for this account.',
-  error_security_mfa_token_expired: 'The MFA token has expired. Please request a new one.',
-  error_security_invalid_mfa_token: 'The MFA token is invalid or malformed.',
-  error_security_invalid_totp_code: 'The provided code is invalid.',
-  error_security_recovery_code_used: 'This recovery code has already been used.',
-  error_security_otp_retry_too_soon: 'Too many attempts. Please try again later.',
-  error_security_otp_retry_too_soon_args: (seconds: string | number) => `Too many attempts. Please try again in ${seconds} seconds.`,
-  error_security_password_too_weak: 'Password is too weak.',
-  error_security_password_too_weak_args: (
-    tooShort: boolean | string,
-    minLength: string | number,
-    noLetters: boolean | string,
-    noUppercase: boolean | string,
-    noLowercase: boolean | string,
-    noDigits: boolean | string,
-    noSpecialChars: boolean | string,
-    tooCommon: boolean | string
-  ) => `Password is too weak. Too short: ${tooShort} (min: ${minLength}), No letters: ${noLetters}, No uppercase: ${noUppercase}, No lowercase: ${noLowercase}, No digits: ${noDigits}, No special chars: ${noSpecialChars}, Too common: ${tooCommon}.`,
-  error_security_password_policy_unavailable: 'Failed to load password requirements. Please try again.',
-  error_security_password_too_short: 'Password is too short.',
-  error_security_password_too_short_args: (minLength: string | number) => `Password must be at least ${minLength} characters long.`,
-  error_security_password_no_letter: 'Password must contain at least one letter.',
-  error_security_password_no_uppercase: 'Password must contain at least one uppercase letter.',
-  error_security_password_no_lowercase: 'Password must contain at least one lowercase letter.',
-  error_security_password_no_digit: 'Password must contain at least one digit.',
-  error_security_password_no_special_char: 'Password must contain at least one special character.',
-  error_security_password_too_common: 'Password is too common and insecure.',
-  error_security_ip_not_allowed: 'Request was rejected because the client IP address is not permitted.'
-}

package/src/locales/index.ts

@@ -1,2 +0,0 @@
-export * from './en/strings.js'
-export * from './ru/strings.js'

package/src/locales/ru/strings.ts

@@ -1,35 +0,0 @@
-import type { CoreSecurityStrings } from '@/locales/en/strings'
-
-export const ruSecurityStrings: CoreSecurityStrings = {
-  error_security_mfa_confirmation_required: 'Требуется подтверждение аутентификации.',
-  error_security_mfa_confirmation_required_args: (mfaToken: string) => `Требуется подтверждение аутентификации. Токен MFA: ${mfaToken}`,
-  error_security_totp_already_enabled: 'Двухфакторная аутентификация уже включена для этого аккаунта.',
-  error_security_totp_not_enabled: 'Двухфакторная аутентификация не включена для этого аккаунта.',
-  error_security_mfa_token_expired: 'Срок действия токена MFA истек. Запросите новый.',
-  error_security_invalid_mfa_token: 'Токен MFA недействителен.',
-  error_security_invalid_totp_code: 'Указанный код недействителен.',
-  error_security_recovery_code_used: 'Этот код восстановления уже был использован.',
-  error_security_otp_retry_too_soon: 'Слишком много попыток. Пожалуйста, попробуйте позже.',
-  error_security_otp_retry_too_soon_args: (seconds: string | number) => `Слишком много попыток. Повторите через ${seconds} сек.`,
-  error_security_password_too_weak: 'Пароль слишком слабый.',
-  error_security_password_too_weak_args: (
-    tooShort: boolean | string,
-    minLength: string | number,
-    noLetters: boolean | string,
-    noUppercase: boolean | string,
-    noLowercase: boolean | string,
-    noDigits: boolean | string,
-    noSpecialChars: boolean | string,
-    tooCommon: boolean | string
-  ) => `Пароль слишком слабый. Слишком короткий: ${tooShort} (мин: ${minLength}), Нет букв: ${noLetters}, Нет заглавных: ${noUppercase}, Нет строчных: ${noLowercase}, Нет цифр: ${noDigits}, Нет спецсимволов: ${noSpecialChars}, Слишком распространенный: ${tooCommon}.`,
-  error_security_password_policy_unavailable: 'Не удалось загрузить требования к паролю.',
-  error_security_password_too_short: 'Пароль слишком короткий.',
-  error_security_password_too_short_args: (minLength: string | number) => `Пароль должен содержать не менее ${minLength} символов.`,
-  error_security_password_no_letter: 'Пароль должен содержать хотя бы одну букву.',
-  error_security_password_no_uppercase: 'Пароль должен содержать хотя бы одну заглавную букву.',
-  error_security_password_no_lowercase: 'Пароль должен содержать хотя бы одну строчную букву.',
-  error_security_password_no_digit: 'Пароль должен содержать хотя бы одну цифру.',
-  error_security_password_no_special_char: 'Пароль должен содержать хотя бы один специальный символ.',
-  error_security_password_too_common: 'Пароль слишком распространен и ненадежен.',
-  error_security_ip_not_allowed: 'Запрос отклонен, так как IP-адрес не разрешен политикой безопасности.'
-}

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

@@ -1,35 +0,0 @@
-import { SecurityComponent } from '@/di/security-component'
-import type { SecurityComponentConfig } from '@/di/security-component'
-import {
-  WebSocketServiceMock,
-  HttpClient,
-  EncryptedSettingsMock,
-  DeviceInfoProviderMock
-} from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import { OpenSecuritySettingsApiMock } from '@/mock/network/open-security-settings-api-mock'
-import { OpenSecuritySettingsStorageMock } from '@/mock/storage/open-security-settings-storage-mock'
-/**
- * Creates a pre-configured {@link SecurityComponent} instance for testing and Storybook preview purposes.
- *
- * @param config - Optional configuration overrides for the mock component
- * @returns Fully initialized {@link SecurityComponent}
- */
-export const createMockSecurityComponent = (
-  config?: Partial<SecurityComponentConfig>
-): SecurityComponent => {
-  const ws = config?.webSocketService ?? new WebSocketServiceMock()
-  const httpClient = config?.httpClient ?? new HttpClient({
-    baseUrl: 'https://api.example.com',
-    deviceInfoProvider: new DeviceInfoProviderMock()
-  })
-  const encryptedSettings = config?.encryptedSettings ?? new EncryptedSettingsMock()
-
-  return new SecurityComponent({
-    webSocketService: ws,
-    httpClient,
-    encryptedSettings,
-    openSecuritySettingsApi: config?.openSecuritySettingsApi ?? new OpenSecuritySettingsApiMock(),
-    openSecuritySettingsStorage: config?.openSecuritySettingsStorage ?? new OpenSecuritySettingsStorageMock(),
-    passwordPolicyValidator: config?.passwordPolicyValidator
-  })
-}

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

@@ -1,52 +0,0 @@
-import type {
-  OpenPasswordPolicy,
-  OtpConfirmation,
-  OpenSecuritySettings
-} from '@/domain/model/open-security-settings'
-
-/**
- * Creates a mock {@link OpenPasswordPolicy} object.
- *
- * @param overrides - Optional property overrides
- * @returns Mock open password policy instance
- */
-export const openPasswordPolicyMock = (
-  overrides?: Partial<OpenPasswordPolicy>
-): OpenPasswordPolicy => ({
-  minLength: 8,
-  requireLetter: true,
-  requireUpperCase: true,
-  requireLowerCase: true,
-  requireDigit: true,
-  requireSpecialChar: true,
-  ...overrides
-})
-
-/**
- * Creates a mock {@link OtpConfirmation} object.
- *
- * @param overrides - Optional property overrides
- * @returns Mock OTP confirmation instance
- */
-export const otpConfirmationMock = (
-  overrides?: Partial<OtpConfirmation>
-): OtpConfirmation => ({
-  retryAfterSeconds: 60,
-  numberOfSymbols: 6,
-  expirationSeconds: 300,
-  ...overrides
-})
-
-/**
- * Creates a mock {@link OpenSecuritySettings} object.
- *
- * @param overrides - Optional property overrides for child objects
- * @returns Mock open security settings instance
- */
-export const openSecuritySettingsMock = (overrides?: {
-  openPasswordPolicy?: Partial<OpenPasswordPolicy>
-  otpConfirmation?: Partial<OtpConfirmation>
-}): OpenSecuritySettings => ({
-  openPasswordPolicy: openPasswordPolicyMock(overrides?.openPasswordPolicy),
-  otpConfirmation: otpConfirmationMock(overrides?.otpConfirmation)
-})

package/src/mock/network/model/open-security-settings-payload-mock.ts

@@ -1,28 +0,0 @@
-import type { OpenSecuritySettingsPayload } from '@mudrichenkoevgeny/shared-foundation'
-
-/**
- * Creates a mock {@link OpenSecuritySettingsPayload} matching server response structures.
- *
- * @param overrides - Optional property overrides
- * @returns Mock open security settings payload
- */
-export const openSecuritySettingsPayloadMock = (
-  overrides?: Partial<OpenSecuritySettingsPayload>
-): OpenSecuritySettingsPayload => ({
-  open_password_policy: {
-    min_length: 8,
-    require_letter: true,
-    require_upper_case: true,
-    require_lower_case: true,
-    require_digit: true,
-    require_special_char: true,
-    ...(overrides?.open_password_policy ?? {})
-  },
-  otp_confirmation: {
-    retry_after_seconds: 60,
-    number_of_symbols: 6,
-    expiration_seconds: 300,
-    ...(overrides?.otp_confirmation ?? {})
-  },
-  ...overrides
-})

package/src/mock/network/open-security-settings-api-mock.ts

@@ -1,38 +0,0 @@
-import type { OpenSecuritySettingsPayload } from '@mudrichenkoevgeny/shared-foundation'
-import { CommonError } from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import type { AppResult, AppError } from "@mudrichenkoevgeny/web-platform-sdk-core-common";
-import type { OpenSecuritySettingsApi } from '@/network/security-settings/open-security-settings-api'
-import { openSecuritySettingsPayloadMock } from '@/mock/network/model/open-security-settings-payload-mock'
-/**
- * Mock implementation of {@link OpenSecuritySettingsApi}.
- */
-export class OpenSecuritySettingsApiMock implements OpenSecuritySettingsApi {
-  public getSecuritySettingsCallCount = 0
-
-  /**
-   * Constructs a new {@link OpenSecuritySettingsApiMock}.
-   *
-   * @param mockPayload - Initial mock payload to return
-   * @param shouldFail - Whether requests should return an error
-   */
-  public constructor(
-    private readonly mockPayload?: OpenSecuritySettingsPayload,
-    private readonly shouldFail: boolean = false
-  ) {}
-
-  /**
-   * Simulates fetching open security settings.
-   *
-   * @returns Configured mock result or error
-   */
-  public async getSecuritySettings(): Promise<AppResult<OpenSecuritySettingsPayload, AppError>> {
-    this.getSecuritySettingsCallCount++
-
-    if (this.shouldFail) {
-      return { success: false, error: CommonError.unknown() }
-    }
-
-    const payload = this.mockPayload ?? openSecuritySettingsPayloadMock()
-    return { success: true, data: payload }
-  }
-}

package/src/mock/repository/open-security-settings-repository-mock.ts

@@ -1,62 +0,0 @@
-import { CommonError } from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import type { AppResult, AppError } from "@mudrichenkoevgeny/web-platform-sdk-core-common";
-import type { OpenSecuritySettingsRepository } from '@/repository/open-security-settings-repository'
-import type { OpenSecuritySettingsObserver } from '@/repository/open-security-settings-repository'
-import type { OpenSecuritySettings } from '@/domain/model/open-security-settings'
-import { openSecuritySettingsMock } from '@/mock/domain/model/open-security-settings-mock'
-/**
- * Configuration options for {@link OpenSecuritySettingsRepositoryMock}.
- */
-export interface OpenSecuritySettingsRepositoryMockConfig {
-  /** Initial settings payload. */
-  initialSettings?: OpenSecuritySettings
-  /** If true, getter and refresh will return AppError. */
-  shouldFailGet?: boolean
-}
-
-/**
- * Mock implementation of {@link OpenSecuritySettingsRepository} for testing and Storybook.
- */
-export class OpenSecuritySettingsRepositoryMock implements OpenSecuritySettingsRepository {
-  public refreshCallCount = 0
-  public updateCallCount = 0
-  private settings: OpenSecuritySettings
-  private shouldFailGet: boolean
-  private readonly observers = new Set<OpenSecuritySettingsObserver>()
-
-  public constructor(config?: OpenSecuritySettingsRepositoryMockConfig) {
-    this.settings = config?.initialSettings ?? openSecuritySettingsMock()
-    this.shouldFailGet = config?.shouldFailGet ?? false
-  }
-
-  public async getOpenSecuritySettings(): Promise<AppResult<OpenSecuritySettings, AppError>> {
-    if (this.shouldFailGet) {
-      return { success: false, error: CommonError.unknown() }
-    }
-    return { success: true, data: this.settings }
-  }
-
-  public async refreshOpenSecuritySettings(): Promise<AppResult<OpenSecuritySettings, AppError>> {
-    this.refreshCallCount++
-    if (this.shouldFailGet) {
-      return { success: false, error: CommonError.unknown() }
-    }
-    return { success: true, data: this.settings }
-  }
-
-  public async updateOpenSecuritySettings(securitySettings: OpenSecuritySettings): Promise<void> {
-    this.updateCallCount++
-    this.settings = securitySettings
-    for (const obs of this.observers) {
-      obs(this.settings)
-    }
-  }
-
-  public observeOpenSecuritySettings(observer: OpenSecuritySettingsObserver): () => void {
-    this.observers.add(observer)
-    observer(this.settings)
-    return () => {
-      this.observers.delete(observer)
-    }
-  }
-}

package/src/mock/storage/open-security-settings-storage-mock.ts

@@ -1,45 +0,0 @@
-import type { OpenSecuritySettingsStorage } from '@/storage/security-settings/open-security-settings-storage'
-import type { OpenSecuritySettings } from '@/domain/model/open-security-settings'
-
-/**
- * Mock in-memory implementation of {@link OpenSecuritySettingsStorage}.
- */
-export class OpenSecuritySettingsStorageMock implements OpenSecuritySettingsStorage {
-  private settings: OpenSecuritySettings | null = null
-
-  /**
-   * Constructs a new {@link OpenSecuritySettingsStorageMock}.
-   *
-   * @param initialSettings - Initial cached settings
-   */
-  public constructor(initialSettings?: OpenSecuritySettings) {
-    if (initialSettings) {
-      this.settings = initialSettings
-    }
-  }
-
-  /**
-   * Retrieves the mock stored settings.
-   *
-   * @returns Mock settings or null
-   */
-  public async getOpenSecuritySettings(): Promise<OpenSecuritySettings | null> {
-    return this.settings
-  }
-
-  /**
-   * Updates the mock stored settings.
-   *
-   * @param securitySettings - New settings
-   */
-  public async updateOpenSecuritySettings(securitySettings: OpenSecuritySettings): Promise<void> {
-    this.settings = securitySettings
-  }
-
-  /**
-   * Clears the mock stored settings.
-   */
-  public async clearOpenSecuritySettings(): Promise<void> {
-    this.settings = null
-  }
-}

package/src/mock/usecase/validate-password-use-case-mock.ts

@@ -1,31 +0,0 @@
-import type { AppResult, AppError } from '@mudrichenkoevgeny/web-platform-sdk-core-common'
-import { ValidatePasswordUseCase } from '@/usecase/validate-password-use-case'
-import { SecurityError } from '@/error/model/security-error'
-
-/**
- * Mock implementation of {@link ValidatePasswordUseCase} for testing UI components.
- */
-export class ValidatePasswordUseCaseMock extends ValidatePasswordUseCase {
-  /**
-   * Constructs a new {@link ValidatePasswordUseCaseMock}.
-   *
-   * @param shouldFail - If true, mock will always fail with passwordTooShort
-   */
-  public constructor(private readonly shouldFail: boolean = false) {
-    // Pass null casts to bypass constructor checks since we override the method
-    super(null as any, null as any)
-  }
-
-  /**
-   * Evaluates the candidate password synchronously.
-   *
-   * @param _password - Candidate password (ignored)
-   * @returns Configured mock result
-   */
-  public async execute(_password: string): Promise<AppResult<void, AppError>> {
-    if (this.shouldFail) {
-      return { success: false, error: SecurityError.passwordTooShort(8) }
-    }
-    return { success: true, data: undefined }
-  }
-}

package/src/network/contract/security-web-socket-event-types.ts

@@ -1,7 +0,0 @@
-/**
- * WebSocket event type constants for security domain.
- */
-export const SecurityWebSocketEventTypes = {
-  /** Event type broadcast when open security settings are updated. */
-  SECURITY_SETTINGS_UPDATED: 'SECURITY_SETTINGS_UPDATED'
-} as const