@digitaldefiance/suite-core-lib 3.6.47 → 3.6.49

package/src/errors/direct-challenge-not-enabled.ts

@@ -0,0 +1,22 @@
+/**
+ * Error thrown when direct challenge authentication is not enabled for a user.
+ */
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+
+export class DirectChallengeNotEnabledError extends HandleableError {
+  constructor() {
+    super(
+      new Error(
+        getSuiteCoreTranslation(
+          SuiteCoreStringKey.Error_Login_DirectChallengeNotEnabled,
+        ),
+      ),
+      {
+        statusCode: 403,
+      },
+    );
+    this.name = 'DirectChallengeNotEnabledError';
+  }
+}

package/src/errors/direct-token-used.ts

@@ -0,0 +1,17 @@
+/**
+ * Error thrown when a direct login token has already been used.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class DirectTokenUsedError extends TranslatableSuiteHandleableError {
+  constructor() {
+    super(
+      SuiteCoreStringKey.Error_DirectTokenAlreadyUsed,
+      undefined,
+      undefined,
+      { statusCode: 401 },
+    );
+    this.name = 'DirectTokenUsedError';
+  }
+}

package/src/errors/email-in-use.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an email address is already in use by another account.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class EmailInUseError extends TranslatableSuiteHandleableError {
+  constructor(language?: string, statusCode = 422) {
+    super(SuiteCoreStringKey.Validation_EmailInUse, undefined, language, {
+      statusCode,
+    });
+    this.name = 'EmailInUseError';
+  }
+}

package/src/errors/email-token-expired.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an email token has expired.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class EmailTokenExpiredError extends TranslatableSuiteHandleableError {
+  constructor(language?: string, statusCode = 422) {
+    super(SuiteCoreStringKey.Validation_TokenExpired, undefined, language, {
+      statusCode,
+    });
+    this.name = 'EmailTokenExpiredError';
+  }
+}

package/src/errors/email-token-failed-to-send.ts

@@ -0,0 +1,46 @@
+/**
+ * Error thrown when an email token fails to send.
+ */
+import {
+  CoreLanguageCode,
+  HandleableError,
+  HandleableErrorOptions,
+} from '@digitaldefiance/i18n-lib';
+import { EmailTokenType, SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+
+export class EmailTokenFailedToSendError extends HandleableError {
+  constructor(
+    tokenType: EmailTokenType,
+    language?: CoreLanguageCode,
+    options?: HandleableErrorOptions,
+  ) {
+    const map: Record<EmailTokenType, SuiteCoreStringKey> = {
+      [EmailTokenType.AccountVerification]:
+        SuiteCoreStringKey.TokenType_AccountVerification,
+      [EmailTokenType.PasswordReset]:
+        SuiteCoreStringKey.TokenType_PasswordReset,
+      [EmailTokenType.LoginRequest]: SuiteCoreStringKey.TokenType_LoginRequest,
+      [EmailTokenType.MnemonicRecoveryRequest]:
+        SuiteCoreStringKey.TokenType_MnemonicRecoveryRequest,
+      [EmailTokenType.PrivateKeyRequest]:
+        SuiteCoreStringKey.TokenType_PrivateKeyRequest,
+    };
+    const translate = getSuiteCoreTranslation(
+      map[tokenType],
+      undefined,
+      language,
+    );
+    super(
+      new Error(
+        `${getSuiteCoreTranslation(
+          SuiteCoreStringKey.Email_TokenFailedToSend,
+          undefined,
+          language,
+        )}: ${translate}`,
+      ),
+      options,
+    );
+    this.name = 'EmailTokenFailedToSendError';
+  }
+}

package/src/errors/email-token-sent-too-recently.ts

@@ -0,0 +1,32 @@
+/**
+ * Error thrown when an email token was sent too recently and must wait before resending.
+ */
+import { Constants as AppConstants } from '../constants';
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class EmailTokenSentTooRecentlyError extends TranslatableSuiteHandleableError {
+  public readonly lastSent: Date;
+  public readonly nextAvailableTime: Date;
+
+  constructor(lastSent: Date, statusCode = 429) {
+    const now = Date.now();
+    const nextAvailableTime = new Date(
+      lastSent.getTime() + AppConstants.EmailTokenResendInterval,
+    );
+    const timeRemaining = Math.max(
+      0,
+      Math.ceil((nextAvailableTime.getTime() - now) / 1000),
+    );
+
+    super(
+      SuiteCoreStringKey.Error_EmailSentTooRecentlyTemplate,
+      { timeRemaining: timeRemaining.toString() },
+      undefined,
+      { statusCode },
+    );
+    this.name = 'EmailTokenSentTooRecentlyError';
+    this.lastSent = lastSent;
+    this.nextAvailableTime = nextAvailableTime;
+  }
+}

package/src/errors/email-token-used-or-invalid.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an email token has been used or is invalid.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class EmailTokenUsedOrInvalidError extends TranslatableSuiteHandleableError {
+  constructor(language?: string, statusCode = 422) {
+    super(SuiteCoreStringKey.Validation_TokenInvalid, undefined, language, {
+      statusCode,
+    });
+    this.name = 'EmailTokenUsedOrInvalidError';
+  }
+}

package/src/errors/email-verified.ts

@@ -0,0 +1,19 @@
+/**
+ * Error thrown when attempting to verify an email that is already verified.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class EmailVerifiedError extends TranslatableSuiteHandleableError {
+  constructor(statusCode = 409) {
+    super(
+      SuiteCoreStringKey.EmailVerification_AlreadyVerified,
+      undefined,
+      undefined,
+      {
+        statusCode,
+      },
+    );
+    this.name = 'EmailVerifiedError';
+  }
+}

package/src/errors/failed-to-use-direct-token.ts

@@ -0,0 +1,17 @@
+/**
+ * Error thrown when a direct login token fails to be used.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class FailedToUseDirectTokenError extends TranslatableSuiteHandleableError {
+  constructor() {
+    super(
+      SuiteCoreStringKey.Error_FailedToUseDirectLoginToken,
+      undefined,
+      undefined,
+      { statusCode: 401 },
+    );
+    this.name = 'FailedToUseDirectTokenError';
+  }
+}

package/src/errors/fec-error.ts

@@ -0,0 +1,49 @@
+/**
+ * Error class for Forward Error Correction (FEC) operations.
+ */
+import { PluginTypedError } from '@digitaldefiance/i18n-lib';
+import { FecErrorType, SuiteCoreStringKey } from '../enumerations';
+import { SuiteCoreComponentId } from '../i18n-setup';
+
+export class FecError extends PluginTypedError<
+  typeof FecErrorType,
+  SuiteCoreStringKey
+> {
+  constructor(
+    type: FecErrorType,
+    language?: string,
+    templateParams?: Record<string, string>,
+  ) {
+    super(
+      SuiteCoreComponentId,
+      type,
+      {
+        [FecErrorType.DataRequired]:
+          SuiteCoreStringKey.Error_FecErrorDataRequired,
+        [FecErrorType.InvalidShardCounts]:
+          SuiteCoreStringKey.Error_FecErrorInvalidShardCounts,
+        [FecErrorType.InvalidShardsAvailableArray]:
+          SuiteCoreStringKey.Error_FecErrorInvalidShardsAvailableArray,
+        [FecErrorType.InputDataMustBeUint8Array]:
+          SuiteCoreStringKey.Error_FecErrorInputDataMustBeUint8Array,
+        [FecErrorType.InvalidDataLength]:
+          SuiteCoreStringKey.Error_FecErrorInvalidDataLengthTemplate,
+        [FecErrorType.ShardSizeExceedsMaximum]:
+          SuiteCoreStringKey.Error_FecErrorShardSizeExceedsMaximumTemplate,
+        [FecErrorType.NotEnoughShardsAvailable]:
+          SuiteCoreStringKey.Error_FecErrorNotEnoughShardsAvailableTemplate,
+        [FecErrorType.FecEncodingFailed]:
+          SuiteCoreStringKey.Error_FecErrorFecEncodingFailedTemplate,
+        [FecErrorType.FecDecodingFailed]:
+          SuiteCoreStringKey.Error_FecErrorFecDecodingFailedTemplate,
+        [FecErrorType.ParityDataCountMustBePositive]:
+          SuiteCoreStringKey.Error_FecErrorParityDataCountMustBePositive,
+        [FecErrorType.ParityDataRequired]:
+          SuiteCoreStringKey.Error_FecErrorParityDataRequired,
+      },
+      language,
+      templateParams,
+    );
+    this.name = 'FecError';
+  }
+}

package/src/errors/generic-validation.ts

@@ -0,0 +1,14 @@
+/**
+ * Generic validation error for general validation failures.
+ */
+import {
+  HandleableError,
+  HandleableErrorOptions,
+} from '@digitaldefiance/i18n-lib';
+
+export class GenericValidationError extends HandleableError {
+  constructor(message: string, options?: HandleableErrorOptions) {
+    super(new Error(message), { ...options, statusCode: 422 });
+    this.name = 'GenericValidationError';
+  }
+}

package/src/errors/{index.d.ts → index.ts}

@@ -1,3 +1,6 @@
+/**
+ * Error class exports for the suite-core library.
+ */
 export * from './account-locked';
 export * from './account-status';
 export * from './admin-role-not-found';
@@ -37,4 +40,3 @@ export * from './translatable-suite-handleable';
 export * from './user-not-found';
 export * from './username-email-required';
 export * from './username-in-use';
-//# sourceMappingURL=index.d.ts.map

package/src/errors/invalid-backup-code.ts

@@ -0,0 +1,9 @@
+/**
+ * Error thrown when a backup code is invalid.
+ */
+export class InvalidBackupCodeError extends Error {
+  constructor(message?: string) {
+    super(message ?? 'Invalid backup code');
+    this.name = 'InvalidBackupCodeError';
+  }
+}

package/src/errors/invalid-challenge-response.ts

@@ -0,0 +1,22 @@
+/**
+ * Error thrown when a challenge response is invalid.
+ */
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+
+export class InvalidChallengeResponseError extends HandleableError {
+  constructor() {
+    super(
+      new Error(
+        getSuiteCoreTranslation(
+          SuiteCoreStringKey.Error_InvalidChallengeResponse,
+        ),
+      ),
+      {
+        statusCode: 401,
+      },
+    );
+    this.name = 'InvalidChallengeResponseError';
+  }
+}

package/src/errors/invalid-challenge.ts

@@ -0,0 +1,12 @@
+/**
+ * Error thrown when a challenge is invalid.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteError } from './translatable-suite';
+
+export class InvalidChallengeError extends TranslatableSuiteError {
+  constructor() {
+    super(SuiteCoreStringKey.Error_ChallengeError);
+    this.name = 'InvalidChallengeError';
+  }
+}

package/src/errors/invalid-credentials.ts

@@ -0,0 +1,19 @@
+/**
+ * Error thrown when login credentials are invalid.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class InvalidCredentialsError extends TranslatableSuiteHandleableError {
+  constructor(language?: string) {
+    super(
+      SuiteCoreStringKey.Validation_InvalidCredentials,
+      undefined,
+      language,
+      {
+        statusCode: 401,
+      },
+    );
+    this.name = 'InvalidCredentialsError';
+  }
+}

package/src/errors/invalid-email.ts

@@ -0,0 +1,46 @@
+/**
+ * Error thrown when an email address is invalid.
+ */
+import { InvalidEmailErrorType } from '@digitaldefiance/ecies-lib';
+import {
+  HandleableErrorOptions,
+  TypedHandleableError,
+} from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { SuiteCoreComponentId } from '../i18n-setup';
+
+export class InvalidEmailError extends TypedHandleableError<
+  typeof InvalidEmailErrorType,
+  SuiteCoreStringKey
+> {
+  public readonly email?: string;
+  constructor(
+    type: InvalidEmailErrorType,
+    email?: string,
+    options?: HandleableErrorOptions,
+    language?: string,
+  ) {
+    const source =
+      options?.cause instanceof Error ? options.cause : new Error();
+    const reasonMap: Record<InvalidEmailErrorType, SuiteCoreStringKey> = {
+      [InvalidEmailErrorType.Invalid]: SuiteCoreStringKey.Error_InvalidEmail,
+      [InvalidEmailErrorType.Missing]:
+        SuiteCoreStringKey.Error_InvalidEmailMissing,
+      [InvalidEmailErrorType.Whitespace]:
+        SuiteCoreStringKey.Error_InvalidEmailWhitespace,
+    };
+    super(
+      SuiteCoreComponentId,
+      type,
+      reasonMap,
+      source,
+      { ...options, statusCode: options?.statusCode ?? 422 },
+      language,
+      {
+        email: email ?? '',
+      },
+    );
+    this.email = email;
+    this.name = 'InvalidEmailError';
+  }
+}

package/src/errors/invalid-expired-token.ts

@@ -0,0 +1,21 @@
+/**
+ * Error thrown when a token is invalid or has expired.
+ */
+import {
+  CoreLanguageCode,
+  HandleableErrorOptions,
+} from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class InvalidExpiredTokenError extends TranslatableSuiteHandleableError {
+  constructor(language?: CoreLanguageCode, options?: HandleableErrorOptions) {
+    super(
+      SuiteCoreStringKey.ForgotPassword_InvalidToken,
+      undefined,
+      language,
+      options,
+    );
+    this.name = 'InvalidExpiredTokenError';
+  }
+}

package/src/errors/invalid-token.ts

@@ -0,0 +1,22 @@
+/**
+ * Error thrown when a token is invalid.
+ */
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteError } from './translatable-suite';
+
+export class InvalidTokenError extends HandleableError {
+  constructor(language?: string, statusCode = 422) {
+    super(
+      new TranslatableSuiteError(
+        SuiteCoreStringKey.Validation_InvalidToken,
+        undefined,
+        language,
+      ),
+      {
+        statusCode,
+      },
+    );
+    this.name = 'InvalidTokenError';
+  }
+}

package/src/errors/invalid-userid.ts

@@ -0,0 +1,38 @@
+/**
+ * Error thrown when a user ID is invalid.
+ */
+import { CoreLanguageCode, HandleableError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreI18nEngine, SuiteCoreComponentId } from '../i18n-setup';
+
+export class InvalidUserIdError extends HandleableError {
+  constructor(
+    detail?: SuiteCoreStringKey,
+    language?: CoreLanguageCode,
+    statusCode = 422,
+  ) {
+    const engine = getSuiteCoreI18nEngine();
+    const baseMessage = detail
+      ? engine.translate(
+          SuiteCoreComponentId,
+          SuiteCoreStringKey.Validation_InvalidUserIdTemplate,
+          {
+            detail: engine.translate(
+              SuiteCoreComponentId,
+              detail,
+              undefined,
+              language,
+            ),
+          },
+          language,
+        )
+      : engine.translate(
+          SuiteCoreComponentId,
+          SuiteCoreStringKey.Validation_InvalidUserId,
+          undefined,
+          language,
+        );
+    super(new Error(baseMessage), { statusCode });
+    this.name = 'InvalidUserIdError';
+  }
+}

package/src/errors/invalid-username.ts

@@ -0,0 +1,17 @@
+/**
+ * Error thrown when a username is invalid.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class InvalidUsernameError extends TranslatableSuiteHandleableError {
+  constructor(language?: string, statusCode = 422) {
+    super(
+      SuiteCoreStringKey.Validation_UsernameRegexErrorTemplate,
+      undefined,
+      language,
+      { statusCode },
+    );
+    this.name = 'InvalidUsernameError';
+  }
+}

package/src/errors/last-admin-error.ts

@@ -0,0 +1,15 @@
+/**
+ * Error thrown when attempting to remove the last admin from the system.
+ */
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class LastAdminError extends TranslatableSuiteHandleableError {
+  constructor(language?: CoreLanguageCode) {
+    super(SuiteCoreStringKey.CannotRemoveLastAdmin, undefined, language, {
+      statusCode: 422,
+    });
+    this.name = 'LastAdminError';
+  }
+}

package/src/errors/login-challenge-expired.ts

@@ -0,0 +1,22 @@
+/**
+ * Error thrown when a login challenge has expired.
+ */
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+
+export class LoginChallengeExpiredError extends HandleableError {
+  constructor() {
+    super(
+      new Error(
+        getSuiteCoreTranslation(
+          SuiteCoreStringKey.Error_Login_ChallengeExpiredTemplate,
+        ),
+      ),
+      {
+        statusCode: 401,
+      },
+    );
+    this.name = 'LoginChallengeExpiredError';
+  }
+}

package/src/errors/member-role-not-found.ts

@@ -0,0 +1,15 @@
+/**
+ * Error thrown when the member role cannot be found in the system.
+ */
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class MemberRoleNotFoundError extends TranslatableSuiteHandleableError {
+  constructor(language?: CoreLanguageCode) {
+    super(SuiteCoreStringKey.MemberRoleNotFound, undefined, language, {
+      statusCode: 500,
+    });
+    this.name = 'MemberRoleNotFoundError';
+  }
+}

package/src/errors/password-login-not-enabled.ts

@@ -0,0 +1,22 @@
+/**
+ * Error thrown when password login is not enabled for a user.
+ */
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+
+export class PasswordLoginNotEnabledError extends HandleableError {
+  constructor() {
+    super(
+      new Error(
+        getSuiteCoreTranslation(
+          SuiteCoreStringKey.Error_Login_PasswordLoginNotEnabled,
+        ),
+      ),
+      {
+        statusCode: 403,
+      },
+    );
+    this.name = 'PasswordLoginNotEnabledError';
+  }
+}

package/src/errors/password-login-not-setup.ts

@@ -0,0 +1,22 @@
+/**
+ * Error thrown when password login is not set up for a user.
+ */
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+
+export class PasswordLoginNotSetupError extends HandleableError {
+  constructor() {
+    super(
+      new Error(
+        getSuiteCoreTranslation(
+          SuiteCoreStringKey.Error_Login_PasswordLoginNotSetup,
+        ),
+      ),
+      {
+        statusCode: 403,
+      },
+    );
+    this.name = 'PasswordLoginNotSetupError';
+  }
+}

package/src/errors/pbkdf2-error.ts

@@ -0,0 +1,26 @@
+/**
+ * Error class for PBKDF2 (Password-Based Key Derivation Function 2) operations.
+ */
+import { CompleteReasonMap, PluginTypedError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { Pbkdf2ErrorType } from '../enumerations/pbkdf2-error-type';
+import { SuiteCoreComponentId } from '../i18n-setup';
+
+export class Pbkdf2Error extends PluginTypedError<
+  typeof Pbkdf2ErrorType,
+  SuiteCoreStringKey
+> {
+  constructor(type: Pbkdf2ErrorType, language?: string) {
+    const pbkdf2ErrorMap: CompleteReasonMap<
+      typeof Pbkdf2ErrorType,
+      SuiteCoreStringKey
+    > = {
+      [Pbkdf2ErrorType.InvalidSaltLength]:
+        SuiteCoreStringKey.Error_Pbkdf2InvalidSaltLength,
+      [Pbkdf2ErrorType.InvalidHashLength]:
+        SuiteCoreStringKey.Error_Pbkdf2InvalidHashLength,
+    };
+    super(SuiteCoreComponentId, type, pbkdf2ErrorMap, language);
+    this.name = 'Pbkdf2Error';
+  }
+}

package/src/errors/pending-email-verification.ts

@@ -0,0 +1,12 @@
+/**
+ * Error thrown when an account is pending email verification.
+ */
+import { AccountStatus } from '../enumerations/account-status';
+import { AccountStatusError } from './account-status';
+
+export class PendingEmailVerificationError extends AccountStatusError {
+  constructor(language?: string, statusCode = 403) {
+    super(AccountStatus.PendingEmailVerification, language, statusCode);
+    this.name = 'PendingEmailVerificationError';
+  }
+}

package/src/errors/private-key-required.ts

@@ -0,0 +1,16 @@
+/**
+ * Error thrown when a private key is required but not provided.
+ */
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteError } from './translatable-suite';
+
+export class PrivateKeyRequiredError extends TranslatableSuiteError {
+  constructor(language?: string) {
+    super(
+      SuiteCoreStringKey.Error_MemberErrorMissingPrivateKey,
+      undefined,
+      language,
+    );
+    this.name = 'PrivateKeyRequiredError';
+  }
+}