@codingfactory/socialkit-vue 0.1.0 → 0.3.0

package/src/services/identity.ts

@@ -0,0 +1,281 @@
+/**
+ * Configurable identity service for SocialKit-powered frontends.
+ */
+
+import type { AxiosInstance } from 'axios'
+import type { TokenStorage } from '../utils/tokenStorage.js'
+import { extractTokenFromResponse } from '../utils/tokenStorage.js'
+import type {
+  AccountDeletionConfirmationResult,
+  AccountDeletionRequestResult,
+  ChangePasswordPayload,
+  ChangePasswordResult,
+  TwoFactorDisablePayload,
+  TwoFactorEnableResult,
+  TwoFactorEnrollment,
+  TwoFactorStatus
+} from '../types/identity.js'
+import type { IdentityUser } from '../types/user.js'
+
+interface IdentityUserResponse {
+  id: string
+  handle?: string
+  name: string
+  avatar?: string | { url: string; thumb_url?: string } | null
+  avatar_url?: string | null
+  cover_photo?: string | null
+  bio?: string | null
+  email?: string
+  created_at?: string
+  updated_at?: string
+}
+
+interface DataEnvelope<T> {
+  data?: T
+  message?: string
+}
+
+interface TwoFactorStatusPayload {
+  enabled?: unknown
+}
+
+interface TwoFactorEnrollmentPayload {
+  qr_code_url?: unknown
+  secret_base32?: unknown
+}
+
+interface RecoveryCodesPayload {
+  recovery_codes?: unknown
+}
+
+interface AccountDeletionRequestPayload {
+  id?: unknown
+  status?: unknown
+  confirmation_token?: unknown
+  dev_token?: unknown
+}
+
+interface AccountDeletionConfirmationPayload {
+  status?: unknown
+}
+
+export interface IdentityServiceConfig {
+  client: AxiosInstance
+  tokenStorage: TokenStorage
+}
+
+export interface IdentityServiceInstance {
+  getCurrentUser(): Promise<IdentityUser>
+  getUser(userId: string): Promise<IdentityUser>
+  updateUser(userId: string, payload: Partial<IdentityUser>): Promise<IdentityUser>
+  uploadAvatar(file: File): Promise<{ url: string }>
+  changePassword(payload: ChangePasswordPayload): Promise<ChangePasswordResult>
+  getTwoFactorStatus(): Promise<TwoFactorStatus>
+  startTwoFactorEnrollment(currentPassword: string): Promise<TwoFactorEnrollment>
+  enableTwoFactor(code: string): Promise<TwoFactorEnableResult>
+  regenerateTwoFactorRecoveryCodes(code: string): Promise<TwoFactorEnableResult>
+  disableTwoFactor(payload: TwoFactorDisablePayload): Promise<void>
+  requestAccountDeletion(): Promise<AccountDeletionRequestResult>
+  confirmAccountDeletion(
+    requestId: string,
+    confirmationToken: string
+  ): Promise<AccountDeletionConfirmationResult>
+}
+
+class IdentityService implements IdentityServiceInstance {
+  public constructor(
+    private readonly client: AxiosInstance,
+    private readonly tokenStorage: TokenStorage
+  ) {}
+
+  public async getCurrentUser(): Promise<IdentityUser> {
+    const response = await this.client.get<DataEnvelope<unknown>>('/v1/me')
+    return this.normalizeUser(response.data.data)
+  }
+
+  public async getUser(userId: string): Promise<IdentityUser> {
+    const response = await this.client.get<DataEnvelope<unknown>>('/v1/identity/users/by-ids', {
+      params: {
+        ids: userId
+      }
+    })
+
+    const users = Array.isArray(response.data?.data) ? response.data.data : []
+    const user = users.find((candidate: unknown) => {
+      if (!candidate || typeof candidate !== 'object') {
+        return false
+      }
+
+      const candidateWithId = candidate as { id?: unknown }
+
+      return candidateWithId.id === userId
+    })
+
+    if (!user) {
+      throw new Error('User not found')
+    }
+
+    return this.normalizeUser(user)
+  }
+
+  public async updateUser(
+    _userId: string,
+    payload: Partial<IdentityUser>
+  ): Promise<IdentityUser> {
+    const response = await this.client.patch<DataEnvelope<unknown>>('/v1/me', payload)
+    return this.normalizeUser(response.data.data)
+  }
+
+  public async uploadAvatar(file: File): Promise<{ url: string }> {
+    const formData = new FormData()
+    formData.append('file', file)
+
+    const response = await this.client.post<{ url: string }>('/v1/media/upload', formData)
+    return response.data
+  }
+
+  public async changePassword(payload: ChangePasswordPayload): Promise<ChangePasswordResult> {
+    const response = await this.client.patch<DataEnvelope<unknown>>('/v1/me/password', {
+      current_password: payload.currentPassword,
+      password: payload.newPassword,
+      password_confirmation: payload.confirmPassword
+    })
+
+    const rotatedToken = extractTokenFromResponse(response.data)
+    if (rotatedToken) {
+      this.tokenStorage.setToken(rotatedToken)
+    }
+
+    const message = typeof response.data?.message === 'string' && response.data.message.trim() !== ''
+      ? response.data.message
+      : 'Password updated successfully'
+
+    return { message }
+  }
+
+  public async getTwoFactorStatus(): Promise<TwoFactorStatus> {
+    const response = await this.client.get<DataEnvelope<TwoFactorStatusPayload>>('/v1/security/2fa/status')
+
+    return {
+      enabled: response.data?.data?.enabled === true
+    }
+  }
+
+  public async startTwoFactorEnrollment(currentPassword: string): Promise<TwoFactorEnrollment> {
+    const response = await this.client.post<DataEnvelope<TwoFactorEnrollmentPayload>>(
+      '/v1/security/2fa/start',
+      {
+        current_password: currentPassword
+      }
+    )
+
+    const qrCodeUrl = response.data?.data?.qr_code_url
+    const secretBase32 = response.data?.data?.secret_base32
+
+    if (typeof qrCodeUrl !== 'string' || typeof secretBase32 !== 'string') {
+      throw new Error('Invalid two-factor enrollment response payload')
+    }
+
+    return {
+      qrCodeUrl,
+      secretBase32
+    }
+  }
+
+  public async enableTwoFactor(code: string): Promise<TwoFactorEnableResult> {
+    const response = await this.client.post<DataEnvelope<RecoveryCodesPayload>>(
+      '/v1/security/2fa/enable',
+      { code }
+    )
+
+    return {
+      recoveryCodes: this.normalizeRecoveryCodes(response.data?.data?.recovery_codes)
+    }
+  }
+
+  public async regenerateTwoFactorRecoveryCodes(code: string): Promise<TwoFactorEnableResult> {
+    const response = await this.client.post<DataEnvelope<RecoveryCodesPayload>>(
+      '/v1/security/2fa/recovery-codes/regenerate',
+      { code }
+    )
+
+    return {
+      recoveryCodes: this.normalizeRecoveryCodes(response.data?.data?.recovery_codes)
+    }
+  }
+
+  public async disableTwoFactor(payload: TwoFactorDisablePayload): Promise<void> {
+    await this.client.post('/v1/security/2fa/disable', {
+      password: payload.password,
+      code: payload.code
+    })
+  }
+
+  public async requestAccountDeletion(): Promise<AccountDeletionRequestResult> {
+    const response = await this.client.post<DataEnvelope<AccountDeletionRequestPayload>>('/v1/compliance/dsar/erase')
+    const id = response.data?.data?.id
+    const status = response.data?.data?.status
+    const confirmationToken = response.data?.data?.confirmation_token
+    const devToken = response.data?.data?.dev_token
+
+    if (typeof id !== 'string' || typeof status !== 'string') {
+      throw new Error('Invalid account deletion request payload')
+    }
+
+    return {
+      requestId: id,
+      status,
+      confirmationToken: typeof confirmationToken === 'string'
+        ? confirmationToken
+        : typeof devToken === 'string'
+          ? devToken
+          : null
+    }
+  }
+
+  public async confirmAccountDeletion(
+    requestId: string,
+    confirmationToken: string
+  ): Promise<AccountDeletionConfirmationResult> {
+    const response = await this.client.post<DataEnvelope<AccountDeletionConfirmationPayload>>(
+      `/v1/compliance/dsar/${encodeURIComponent(requestId)}/confirm`,
+      {
+        token: confirmationToken
+      }
+    )
+    const status = response.data?.data?.status
+
+    if (typeof status !== 'string') {
+      throw new Error('Invalid account deletion confirmation payload')
+    }
+
+    return { status }
+  }
+
+  private normalizeUser(user: unknown): IdentityUser {
+    if (!user || typeof user !== 'object') {
+      throw new Error('Invalid user data')
+    }
+
+    const userData = user as IdentityUserResponse
+    const avatarUrl = typeof userData.avatar === 'string'
+      ? userData.avatar
+      : userData.avatar?.url ?? userData.avatar_url ?? null
+
+    return {
+      ...userData,
+      avatar: avatarUrl,
+      ...(avatarUrl ? { avatar_url: avatarUrl } : {})
+    }
+  }
+
+  private normalizeRecoveryCodes(recoveryCodesRaw: unknown): string[] {
+    return Array.isArray(recoveryCodesRaw)
+      ? recoveryCodesRaw.filter((value: unknown): value is string => typeof value === 'string')
+      : []
+  }
+}
+
+export function createIdentityService(config: IdentityServiceConfig): IdentityServiceInstance {
+  return new IdentityService(config.client, config.tokenStorage)
+}