[PM-24030] Migrate abstract services in libs/common strict TS (#15727)

Migrates the abstract classes in libs/common to be strict ts compatible. Primarily by adding abstract to every field and converting it to a function syntax instead of lambda.

libs/common/src/auth/abstractions/account.service.ts

@@ -1,5 +1,3 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { Observable } from "rxjs";
 
 import { UserId } from "../../types/guid";
@@ -35,20 +33,20 @@ export function accountInfoEqual(a: AccountInfo, b: AccountInfo) {
 }
 
 export abstract class AccountService {
-  accounts$: Observable<Record<UserId, AccountInfo>>;
+  abstract accounts$: Observable<Record<UserId, AccountInfo>>;
 
-  activeAccount$: Observable<Account | null>;
+  abstract activeAccount$: Observable<Account | null>;
 
   /**
    * Observable of the last activity time for each account.
    */
-  accountActivity$: Observable<Record<UserId, Date>>;
+  abstract accountActivity$: Observable<Record<UserId, Date>>;
   /** Observable of the new device login verification property for the account. */
-  accountVerifyNewDeviceLogin$: Observable<boolean>;
+  abstract accountVerifyNewDeviceLogin$: Observable<boolean>;
   /** Account list in order of descending recency */
-  sortedUserIds$: Observable<UserId[]>;
+  abstract sortedUserIds$: Observable<UserId[]>;
   /** Next account that is not the current active account */
-  nextUpAccount$: Observable<Account>;
+  abstract nextUpAccount$: Observable<Account>;
   /**
    * Updates the `accounts$` observable with the new account data.
    *

libs/common/src/auth/abstractions/anonymous-hub.service.ts

@@ -1,6 +1,4 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 export abstract class AnonymousHubService {
-  createHubConnection: (token: string) => Promise<void>;
-  stopHubConnection: () => Promise<void>;
+  abstract createHubConnection(token: string): Promise<void>;
+  abstract stopHubConnection(): Promise<void>;
 }

libs/common/src/auth/abstractions/avatar.service.ts

@@ -1,5 +1,3 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { Observable } from "rxjs";
 
 import { UserId } from "../../types/guid";
@@ -9,7 +7,7 @@ export abstract class AvatarService {
    * An observable monitoring the active user's avatar color.
    * The observable updates when the avatar color changes.
    */
-  avatarColor$: Observable<string | null>;
+  abstract avatarColor$: Observable<string | null>;
   /**
    * Sets the avatar color of the active user
    *

libs/common/src/auth/abstractions/devices-api.service.abstraction.ts

@@ -1,47 +1,45 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { ListResponse } from "../../models/response/list.response";
 import { DeviceResponse } from "../abstractions/devices/responses/device.response";
 import { UpdateDevicesTrustRequest } from "../models/request/update-devices-trust.request";
 import { ProtectedDeviceResponse } from "../models/response/protected-device.response";
 
 export abstract class DevicesApiServiceAbstraction {
-  getKnownDevice: (email: string, deviceIdentifier: string) => Promise<boolean>;
+  abstract getKnownDevice(email: string, deviceIdentifier: string): Promise<boolean>;
 
-  getDeviceByIdentifier: (deviceIdentifier: string) => Promise<DeviceResponse>;
+  abstract getDeviceByIdentifier(deviceIdentifier: string): Promise<DeviceResponse>;
 
-  getDevices: () => Promise<ListResponse<DeviceResponse>>;
+  abstract getDevices(): Promise<ListResponse<DeviceResponse>>;
 
-  updateTrustedDeviceKeys: (
+  abstract updateTrustedDeviceKeys(
     deviceIdentifier: string,
     devicePublicKeyEncryptedUserKey: string,
     userKeyEncryptedDevicePublicKey: string,
     deviceKeyEncryptedDevicePrivateKey: string,
-  ) => Promise<DeviceResponse>;
+  ): Promise<DeviceResponse>;
 
-  updateTrust: (
+  abstract updateTrust(
     updateDevicesTrustRequestModel: UpdateDevicesTrustRequest,
     deviceIdentifier: string,
-  ) => Promise<void>;
+  ): Promise<void>;
 
-  getDeviceKeys: (deviceIdentifier: string) => Promise<ProtectedDeviceResponse>;
+  abstract getDeviceKeys(deviceIdentifier: string): Promise<ProtectedDeviceResponse>;
 
   /**
    * Notifies the server that the device has a device key, but didn't receive any associated decryption keys.
    * Note: For debugging purposes only.
    * @param deviceIdentifier - current device identifier
    */
-  postDeviceTrustLoss: (deviceIdentifier: string) => Promise<void>;
+  abstract postDeviceTrustLoss(deviceIdentifier: string): Promise<void>;
 
   /**
    * Deactivates a device
    * @param deviceId - The device ID
    */
-  deactivateDevice: (deviceId: string) => Promise<void>;
+  abstract deactivateDevice(deviceId: string): Promise<void>;
 
   /**
    * Removes trust from a list of devices
    * @param deviceIds - The device IDs to be untrusted
    */
-  untrustDevices: (deviceIds: string[]) => Promise<void>;
+  abstract untrustDevices(deviceIds: string[]): Promise<void>;
 }

libs/common/src/auth/abstractions/token.service.ts

@@ -1,5 +1,3 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { Observable } from "rxjs";
 
 import { VaultTimeout, VaultTimeoutAction } from "../../key-management/vault-timeout";
@@ -27,20 +25,20 @@ export abstract class TokenService {
    *
    * @returns A promise that resolves with the SetTokensResult containing the tokens that were set.
    */
-  setTokens: (
+  abstract setTokens(
     accessToken: string,
     vaultTimeoutAction: VaultTimeoutAction,
     vaultTimeout: VaultTimeout,
     refreshToken?: string,
     clientIdClientSecret?: [string, string],
-  ) => Promise<SetTokensResult>;
+  ): Promise<SetTokensResult>;
 
   /**
    * Clears the access token, refresh token, API Key Client ID, and API Key Client Secret out of memory, disk, and secure storage if supported.
    * @param userId The optional user id to clear the tokens for; if not provided, the active user id is used.
    * @returns A promise that resolves when the tokens have been cleared.
    */
-  clearTokens: (userId?: UserId) => Promise<void>;
+  abstract clearTokens(userId?: UserId): Promise<void>;
 
   /**
    * Sets the access token in memory or disk based on the given vaultTimeoutAction and vaultTimeout
@@ -51,11 +49,11 @@ export abstract class TokenService {
    * @param vaultTimeout The timeout for the vault.
    * @returns A promise that resolves with the access token that has been set.
    */
-  setAccessToken: (
+  abstract setAccessToken(
     accessToken: string,
     vaultTimeoutAction: VaultTimeoutAction,
     vaultTimeout: VaultTimeout,
-  ) => Promise<string>;
+  ): Promise<string>;
 
   // TODO: revisit having this public clear method approach once the state service is fully deprecated.
   /**
@@ -67,21 +65,21 @@ export abstract class TokenService {
    * pass in the vaultTimeoutAction and vaultTimeout.
    * This avoids a circular dependency between the StateService, TokenService, and VaultTimeoutSettingsService.
    */
-  clearAccessToken: (userId?: UserId) => Promise<void>;
+  abstract clearAccessToken(userId?: UserId): Promise<void>;
 
   /**
    * Gets the access token
    * @param userId - The optional user id to get the access token for; if not provided, the active user is used.
    * @returns A promise that resolves with the access token or null.
    */
-  getAccessToken: (userId?: UserId) => Promise<string | null>;
+  abstract getAccessToken(userId?: UserId): Promise<string | null>;
 
   /**
    * Gets the refresh token.
    * @param userId - The optional user id to get the refresh token for; if not provided, the active user is used.
    * @returns A promise that resolves with the refresh token or null.
    */
-  getRefreshToken: (userId?: UserId) => Promise<string | null>;
+  abstract getRefreshToken(userId?: UserId): Promise<string | null>;
 
   /**
    * Sets the API Key Client ID for the active user id in memory or disk based on the given vaultTimeoutAction and vaultTimeout.
@@ -90,18 +88,18 @@ export abstract class TokenService {
    * @param vaultTimeout The timeout for the vault.
    * @returns A promise that resolves with the API Key Client ID that has been set.
    */
-  setClientId: (
+  abstract setClientId(
     clientId: string,
     vaultTimeoutAction: VaultTimeoutAction,
     vaultTimeout: VaultTimeout,
     userId?: UserId,
-  ) => Promise<string>;
+  ): Promise<string>;
 
   /**
    * Gets the API Key Client ID for the active user.
    * @returns A promise that resolves with the API Key Client ID or undefined
    */
-  getClientId: (userId?: UserId) => Promise<string | undefined>;
+  abstract getClientId(userId?: UserId): Promise<string | undefined>;
 
   /**
    * Sets the API Key Client Secret for the active user id in memory or disk based on the given vaultTimeoutAction and vaultTimeout.
@@ -110,18 +108,18 @@ export abstract class TokenService {
    * @param vaultTimeout The timeout for the vault.
    * @returns A promise that resolves with the client secret that has been set.
    */
-  setClientSecret: (
+  abstract setClientSecret(
     clientSecret: string,
     vaultTimeoutAction: VaultTimeoutAction,
     vaultTimeout: VaultTimeout,
     userId?: UserId,
-  ) => Promise<string>;
+  ): Promise<string>;
 
   /**
    * Gets the API Key Client Secret for the active user.
    * @returns A promise that resolves with the API Key Client Secret or undefined
    */
-  getClientSecret: (userId?: UserId) => Promise<string | undefined>;
+  abstract getClientSecret(userId?: UserId): Promise<string | undefined>;
 
   /**
    * Sets the two factor token for the given email in global state.
@@ -131,21 +129,21 @@ export abstract class TokenService {
    * @param twoFactorToken The two factor token to set.
    * @returns A promise that resolves when the two factor token has been set.
    */
-  setTwoFactorToken: (email: string, twoFactorToken: string) => Promise<void>;
+  abstract setTwoFactorToken(email: string, twoFactorToken: string): Promise<void>;
 
   /**
    * Gets the two factor token for the given email.
    * @param email The email to get the two factor token for.
    * @returns A promise that resolves with the two factor token for the given email or null if it isn't found.
    */
-  getTwoFactorToken: (email: string) => Promise<string | null>;
+  abstract getTwoFactorToken(email: string): Promise<string | null>;
 
   /**
    * Clears the two factor token for the given email out of global state.
    * @param email The email to clear the two factor token for.
    * @returns A promise that resolves when the two factor token has been cleared.
    */
-  clearTwoFactorToken: (email: string) => Promise<void>;
+  abstract clearTwoFactorToken(email: string): Promise<void>;
 
   /**
    * Decodes the access token.
@@ -153,13 +151,13 @@ export abstract class TokenService {
    * If null, the currently active user's token is used.
    * @returns A promise that resolves with the decoded access token.
    */
-  decodeAccessToken: (tokenOrUserId?: string | UserId) => Promise<DecodedAccessToken>;
+  abstract decodeAccessToken(tokenOrUserId?: string | UserId): Promise<DecodedAccessToken>;
 
   /**
    * Gets the expiration date for the access token. Returns if token can't be decoded or has no expiration
    * @returns A promise that resolves with the expiration date for the access token.
    */
-  getTokenExpirationDate: () => Promise<Date | null>;
+  abstract getTokenExpirationDate(): Promise<Date | null>;
 
   /**
    * Calculates the adjusted time in seconds until the access token expires, considering an optional offset.
@@ -170,58 +168,58 @@ export abstract class TokenService {
    * based on the actual expiration.
    * @returns {Promise<number>} Promise resolving to the adjusted seconds remaining.
    */
-  tokenSecondsRemaining: (offsetSeconds?: number) => Promise<number>;
+  abstract tokenSecondsRemaining(offsetSeconds?: number): Promise<number>;
 
   /**
    * Checks if the access token needs to be refreshed.
    * @param {number} [minutes=5] - Optional number of minutes before the access token expires to consider refreshing it.
    * @returns A promise that resolves with a boolean indicating if the access token needs to be refreshed.
    */
-  tokenNeedsRefresh: (minutes?: number) => Promise<boolean>;
+  abstract tokenNeedsRefresh(minutes?: number): Promise<boolean>;
 
   /**
    * Gets the user id for the active user from the access token.
    * @returns A promise that resolves with the user id for the active user.
    * @deprecated Use AccountService.activeAccount$ instead.
    */
-  getUserId: () => Promise<UserId>;
+  abstract getUserId(): Promise<UserId>;
 
   /**
    * Gets the email for the active user from the access token.
    * @returns A promise that resolves with the email for the active user.
    * @deprecated Use AccountService.activeAccount$ instead.
    */
-  getEmail: () => Promise<string>;
+  abstract getEmail(): Promise<string>;
 
   /**
    * Gets the email verified status for the active user from the access token.
    * @returns A promise that resolves with the email verified status for the active user.
    */
-  getEmailVerified: () => Promise<boolean>;
+  abstract getEmailVerified(): Promise<boolean>;
 
   /**
    * Gets the name for the active user from the access token.
    * @returns A promise that resolves with the name for the active user.
    * @deprecated Use AccountService.activeAccount$ instead.
    */
-  getName: () => Promise<string>;
+  abstract getName(): Promise<string>;
 
   /**
    * Gets the issuer for the active user from the access token.
    * @returns A promise that resolves with the issuer for the active user.
    */
-  getIssuer: () => Promise<string>;
+  abstract getIssuer(): Promise<string>;
 
   /**
    * Gets whether or not the user authenticated via an external mechanism.
    * @param userId The optional user id to check for external authN status; if not provided, the active user is used.
    * @returns A promise that resolves with a boolean representing the user's external authN status.
    */
-  getIsExternal: (userId: UserId) => Promise<boolean>;
+  abstract getIsExternal(userId: UserId): Promise<boolean>;
 
   /** Gets the active or passed in user's security stamp */
-  getSecurityStamp: (userId?: UserId) => Promise<string | null>;
+  abstract getSecurityStamp(userId?: UserId): Promise<string | null>;
 
   /** Sets the security stamp for the active or passed in user */
-  setSecurityStamp: (securityStamp: string, userId?: UserId) => Promise<void>;
+  abstract setSecurityStamp(securityStamp: string, userId?: UserId): Promise<void>;
 }

libs/common/src/auth/abstractions/user-verification/user-verification-api.service.abstraction.ts

@@ -1,13 +1,11 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { SecretVerificationRequest } from "../../models/request/secret-verification.request";
 import { VerifyOTPRequest } from "../../models/request/verify-otp.request";
 import { MasterPasswordPolicyResponse } from "../../models/response/master-password-policy.response";
 
 export abstract class UserVerificationApiServiceAbstraction {
-  postAccountVerifyOTP: (request: VerifyOTPRequest) => Promise<void>;
-  postAccountRequestOTP: () => Promise<void>;
-  postAccountVerifyPassword: (
+  abstract postAccountVerifyOTP(request: VerifyOTPRequest): Promise<void>;
+  abstract postAccountRequestOTP(): Promise<void>;
+  abstract postAccountVerifyPassword(
     request: SecretVerificationRequest,
-  ) => Promise<MasterPasswordPolicyResponse>;
+  ): Promise<MasterPasswordPolicyResponse>;
 }

libs/common/src/auth/abstractions/user-verification/user-verification.service.abstraction.ts

@@ -1,5 +1,3 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { UserId } from "../../../types/guid";
 import { SecretVerificationRequest } from "../../models/request/secret-verification.request";
 import { UserVerificationOptions } from "../../types/user-verification-options";
@@ -16,9 +14,9 @@ export abstract class UserVerificationService {
    * @param verificationType Type of verification to restrict the options to
    * @returns Available verification options for the user
    */
-  getAvailableVerificationOptions: (
+  abstract getAvailableVerificationOptions(
     verificationType: keyof UserVerificationOptions,
-  ) => Promise<UserVerificationOptions>;
+  ): Promise<UserVerificationOptions>;
   /**
    * Create a new request model to be used for server-side verification
    * @param verification User-supplied verification data (Master Password or OTP)
@@ -26,11 +24,11 @@ export abstract class UserVerificationService {
    * @param alreadyHashed Whether the master password is already hashed
    * @throws Error if the verification data is invalid
    */
-  buildRequest: <T extends SecretVerificationRequest>(
+  abstract buildRequest<T extends SecretVerificationRequest>(
     verification: Verification,
     requestClass?: new () => T,
     alreadyHashed?: boolean,
-  ) => Promise<T>;
+  ): Promise<T>;
   /**
    * Verifies the user using the provided verification data.
    * PIN or biometrics are verified client-side.
@@ -39,11 +37,11 @@ export abstract class UserVerificationService {
    * @param verification User-supplied verification data (OTP, MP, PIN, or biometrics)
    * @throws Error if the verification data is invalid or the verification fails
    */
-  verifyUser: (verification: Verification) => Promise<boolean>;
+  abstract verifyUser(verification: Verification): Promise<boolean>;
   /**
    * Request a one-time password (OTP) to be sent to the user's email
    */
-  requestOTP: () => Promise<void>;
+  abstract requestOTP(): Promise<void>;
   /**
    * Check if user has master password or can only use passwordless technologies to log in
    * Note: This only checks the server, not the local state
@@ -51,13 +49,13 @@ export abstract class UserVerificationService {
    * @returns True if the user has a master password
    * @deprecated Use UserDecryptionOptionsService.hasMasterPassword$ instead
    */
-  hasMasterPassword: (userId?: string) => Promise<boolean>;
+  abstract hasMasterPassword(userId?: string): Promise<boolean>;
   /**
    * Check if the user has a master password and has used it during their current session
    * @param userId The user id to check. If not provided, the current user id used
    * @returns True if the user has a master password and has used it in the current session
    */
-  hasMasterPasswordAndMasterKeyHash: (userId?: string) => Promise<boolean>;
+  abstract hasMasterPasswordAndMasterKeyHash(userId?: string): Promise<boolean>;
   /**
    * Verifies the user using the provided master password.
    * Attempts to verify client-side first, then server-side if necessary.
@@ -68,9 +66,9 @@ export abstract class UserVerificationService {
    * @throws Error if the master password is invalid
    * @returns An object containing the master key, and master password policy options if verified on server.
    */
-  verifyUserByMasterPassword: (
+  abstract verifyUserByMasterPassword(
     verification: MasterPasswordVerification,
     userId: UserId,
     email: string,
-  ) => Promise<MasterPasswordVerificationResponse>;
+  ): Promise<MasterPasswordVerificationResponse>;
 }

libs/common/src/auth/abstractions/webauthn/webauthn-login-api.service.abstraction.ts

@@ -1,7 +1,5 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { CredentialAssertionOptionsResponse } from "../../services/webauthn-login/response/credential-assertion-options.response";
 
-export class WebAuthnLoginApiServiceAbstraction {
-  getCredentialAssertionOptions: () => Promise<CredentialAssertionOptionsResponse>;
+export abstract class WebAuthnLoginApiServiceAbstraction {
+  abstract getCredentialAssertionOptions(): Promise<CredentialAssertionOptionsResponse>;
 }

libs/common/src/auth/abstractions/webauthn/webauthn-login-prf-key.service.abstraction.ts

@@ -1,5 +1,3 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { PrfKey } from "../../../types/key";
 
 /**
@@ -9,11 +7,11 @@ export abstract class WebAuthnLoginPrfKeyServiceAbstraction {
   /**
    * Get the salt used to generate the PRF-output used when logging in with WebAuthn.
    */
-  getLoginWithPrfSalt: () => Promise<ArrayBuffer>;
+  abstract getLoginWithPrfSalt(): Promise<ArrayBuffer>;
 
   /**
    * Create a symmetric key from the PRF-output by stretching it.
    * This should be used as `ExternalKey` with `RotateableKeySet`.
    */
-  createSymmetricKeyFromPrf: (prf: ArrayBuffer) => Promise<PrfKey>;
+  abstract createSymmetricKeyFromPrf(prf: ArrayBuffer): Promise<PrfKey>;
 }

libs/common/src/auth/abstractions/webauthn/webauthn-login.service.abstraction.ts

@@ -1,5 +1,3 @@
-// FIXME: Update this file to be type safe and remove this and next line
-// @ts-strict-ignore
 import { AuthResult } from "../../models/domain/auth-result";
 import { WebAuthnLoginCredentialAssertionOptionsView } from "../../models/view/webauthn-login/webauthn-login-credential-assertion-options.view";
 import { WebAuthnLoginCredentialAssertionView } from "../../models/view/webauthn-login/webauthn-login-credential-assertion.view";
@@ -14,7 +12,7 @@ export abstract class WebAuthnLoginServiceAbstraction {
    * (whether FIDO2 user verification is required, the relying party id, timeout duration for the process to complete, etc.)
    * for the authenticator.
    */
-  getCredentialAssertionOptions: () => Promise<WebAuthnLoginCredentialAssertionOptionsView>;
+  abstract getCredentialAssertionOptions(): Promise<WebAuthnLoginCredentialAssertionOptionsView>;
 
   /**
    * Asserts the credential. This involves user interaction with the authenticator
@@ -27,9 +25,9 @@ export abstract class WebAuthnLoginServiceAbstraction {
    * @returns {WebAuthnLoginCredentialAssertionView} The assertion obtained from the authenticator.
    * If the assertion is not successfully obtained, it returns undefined.
    */
-  assertCredential: (
+  abstract assertCredential(
     credentialAssertionOptions: WebAuthnLoginCredentialAssertionOptionsView,
-  ) => Promise<WebAuthnLoginCredentialAssertionView | undefined>;
+  ): Promise<WebAuthnLoginCredentialAssertionView | undefined>;
 
   /**
    * Logs the user in using the assertion obtained from the authenticator.
@@ -39,5 +37,5 @@ export abstract class WebAuthnLoginServiceAbstraction {
    * @param {WebAuthnLoginCredentialAssertionView} assertion - The assertion obtained from the authenticator
    * that needs to be validated for login.
    */
-  logIn: (assertion: WebAuthnLoginCredentialAssertionView) => Promise<AuthResult>;
+  abstract logIn(assertion: WebAuthnLoginCredentialAssertionView): Promise<AuthResult>;
 }