@digitaldefiance/suite-core-lib 3.6.6 → 3.6.7

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

@@ -0,0 +1,12 @@
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+import { SuiteCoreStringKey } from '../enumerations';
+
+
+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,20 @@
+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,29 @@
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+import { Constants as AppConstants } from '../constants';
+
+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,12 @@
+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,11 @@
+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,9 @@
+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,33 @@
+
+import { PluginTypedError } from '@digitaldefiance/i18n-lib';
+import { FecErrorType, SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreI18nEngine, 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,11 @@
+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}

@@ -37,4 +37,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,6 @@
+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,12 @@
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+import { SuiteCoreStringKey } from '../enumerations';
+
+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,9 @@
+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,14 @@
+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,22 @@
+import { InvalidEmailErrorType } from '@digitaldefiance/ecies-lib';
+import { HandleableErrorOptions, TypedError, 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,11 @@
+import { HandleableErrorOptions } from '@digitaldefiance/i18n-lib';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+import { SuiteCoreStringKey } from '../enumerations';
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+
+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,13 @@
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteError } from './translatable-suite';
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+
+
+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,21 @@
+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,14 @@
+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,12 @@
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+import { SuiteCoreStringKey } from '../enumerations';
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+
+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,12 @@
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+import { SuiteCoreStringKey } from '../enumerations';
+
+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,10 @@
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+import { SuiteCoreStringKey } from '../enumerations';
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+
+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,12 @@
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+import { SuiteCoreStringKey } from '../enumerations';
+
+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,12 @@
+import { HandleableError } from '@digitaldefiance/i18n-lib';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+import { SuiteCoreStringKey } from '../enumerations';
+
+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,19 @@
+import { CompleteReasonMap, PluginTypedError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { Pbkdf2ErrorType } from '../enumerations/pbkdf2-error-type';
+import { getSuiteCoreI18nEngine, SuiteCoreComponentId } from '../i18n-setup';
+
+export class Pbkdf2Error extends PluginTypedError<typeof Pbkdf2ErrorType, SuiteCoreStringKey> {
+
+  constructor(type: Pbkdf2ErrorType, language?: string) {
+    const engine = getSuiteCoreI18nEngine();
+    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,9 @@
+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,13 @@
+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';
+  }
+}

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

@@ -0,0 +1,10 @@
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+
+export class SystemRoleNotFoundError extends TranslatableSuiteHandleableError {
+  constructor(language?: CoreLanguageCode) {
+    super(SuiteCoreStringKey.SystemRoleNotFound, undefined, language, { statusCode: 500 });
+    this.name = 'SystemRoleNotFoundError';
+  }
+}

package/src/errors/token-not-found.ts

@@ -0,0 +1,26 @@
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+
+export class TokenNotFoundError extends TranslatableSuiteHandleableError {
+  public readonly token: string;
+  constructor(
+    token: string,
+    language?: CoreLanguageCode,
+    statusCode = 404,
+  ) {
+    super(
+      SuiteCoreStringKey.TokenNotFoundTemplate,
+      {
+        TOKEN: token,
+      },
+      language,
+      {
+        statusCode,
+      },
+    );
+    this.token = token;
+    this.name = 'TokenNotFoundError';
+  }
+}

package/src/errors/translatable-suite-handleable.ts

@@ -0,0 +1,27 @@
+import { TranslatableHandleableGenericError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { SuiteCoreComponentId } from '../i18n-setup';
+
+export class TranslatableSuiteHandleableError extends TranslatableHandleableGenericError<SuiteCoreStringKey> {
+  constructor(
+    messageKey: SuiteCoreStringKey,
+    otherVars?: Record<string, string | number>,
+    language?: string,
+    handleableOptions?: {
+      statusCode?: number;
+      cause?: Error;
+      sourceData?: unknown;
+    }
+  ) {
+    super(
+      SuiteCoreComponentId,
+      messageKey,
+      otherVars,
+      language,
+      undefined, // metadata
+      'default', // instanceKey
+      handleableOptions
+    );
+    this.name = 'TranslatableSuiteHandleableError';
+  }
+}

package/src/errors/translatable-suite.ts

@@ -0,0 +1,34 @@
+import { SuiteCoreStringKey } from '../enumerations/suite-core-string-key';
+import { getSuiteCoreI18nEngine, SuiteCoreComponentId } from '../i18n-setup';
+
+export class TranslatableSuiteError extends Error {
+  public readonly StringName: SuiteCoreStringKey;
+  /**
+   * @param string The translation key or raw string
+   * @param otherVars Variables for interpolation
+   * @param language Optional language override
+   * @param options Error options
+   * @param engine Optional i18n engine override (defaults to node-express-suite component)
+   */
+  constructor(
+    string: SuiteCoreStringKey,
+    otherVars?: Record<string, string | number>,
+    language?: string
+  ) {
+    const i18nEngine = getSuiteCoreI18nEngine();
+    let translatedMessage: string;
+    try {
+      translatedMessage = i18nEngine.translate(
+        SuiteCoreComponentId,
+        string,
+        otherVars,
+        language
+      );
+    } catch (error) {
+      translatedMessage = string;
+    }
+    super(translatedMessage);
+    this.name = 'TranslatableSuiteError';
+    this.StringName = string;
+  }
+}

package/src/errors/user-not-found.ts

@@ -0,0 +1,14 @@
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class UserNotFoundError extends TranslatableSuiteHandleableError {
+  constructor(language?: string, statusCode = 404) {
+    super(
+      SuiteCoreStringKey.Auth_UserNotFound,
+      undefined,
+      language,
+      { statusCode },
+    );
+    this.name = 'UserNotFoundError';
+  }
+}

package/src/errors/username-email-required.ts

@@ -0,0 +1,20 @@
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreTranslation } from '../i18n-setup';
+import { GenericValidationError } from './generic-validation';
+
+export class UsernameOrEmailRequiredError extends GenericValidationError {
+  constructor(language?: CoreLanguageCode, statusCode = 422) {
+    super(
+      getSuiteCoreTranslation(
+        SuiteCoreStringKey.Validation_UsernameOrEmailRequired,
+        undefined,
+        language,
+      ),
+      {
+        statusCode,
+      },
+    );
+    this.name = 'UsernameOrEmailRequiredError';
+  }
+}

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

@@ -0,0 +1,14 @@
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class UsernameInUseError extends TranslatableSuiteHandleableError {
+  constructor(language?: string, statusCode = 422) {
+    super(
+      SuiteCoreStringKey.Validation_UsernameInUse,
+      undefined,
+      language,
+      { statusCode },
+    );
+    this.name = 'UsernameInUseError';
+  }
+}