@digitaldefiance/suite-core-lib 1.1.40 → 1.1.42

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,8 @@
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteHandleableError } from './translatable-suite-handleable';
+
+export class FailedToUseDirectTokenError extends TranslatableSuiteHandleableError {
+  constructor() {
+    super(SuiteCoreStringKey.Error_FailedToUseDirectLoginToken, undefined, undefined, { statusCode: 401 });
+  }
+}

package/src/errors/fec-error.ts

@@ -0,0 +1,35 @@
+
+import { CoreLanguageCode, PluginTypedError } from '@digitaldefiance/i18n-lib';
+import { FecErrorType, SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreI18nEngine, SuiteCoreComponentId } from '../i18n-setup';
+
+export class FecError extends PluginTypedError<typeof FecErrorType, SuiteCoreStringKey, CoreLanguageCode> {
+  constructor(
+    type: FecErrorType,
+    language?: CoreLanguageCode,
+    templateParams?: Record<string, string>,
+  ) {
+    const i18nEngine = getSuiteCoreI18nEngine();
+    super(
+      i18nEngine,
+      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,10 @@
+import {
+  HandleableError,
+  HandleableErrorOptions,
+} from '@digitaldefiance/i18n-lib';
+
+export class GenericValidationError extends HandleableError {
+  constructor(message: string, options?: HandleableErrorOptions) {
+    super(new Error(message), { ...options, statusCode: 422 });
+  }
+}

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

@@ -34,4 +34,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,11 @@
+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,
+    });
+  }
+}

package/src/errors/invalid-challenge.ts

@@ -0,0 +1,8 @@
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteError } from './translatable-suite';
+
+export class InvalidChallengeError extends TranslatableSuiteError {
+  constructor() {
+    super(SuiteCoreStringKey.Error_ChallengeError);
+  }
+}

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,20 @@
+import { InvalidEmailErrorType } from '@digitaldefiance/ecies-lib';
+import { CoreLanguageCode, PluginTypedError } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { getSuiteCoreI18nEngine, SuiteCoreComponentId } from '../i18n-setup';
+
+export class InvalidEmailError extends PluginTypedError<typeof InvalidEmailErrorType, SuiteCoreStringKey, CoreLanguageCode> {
+  constructor(type: InvalidEmailErrorType, language?: CoreLanguageCode) {
+    const engine = getSuiteCoreI18nEngine();
+    const reasonMap: Record<InvalidEmailErrorType, SuiteCoreStringKey> = {
+      [InvalidEmailErrorType.Invalid]: SuiteCoreStringKey.Error_InvalidEmail,
+      [InvalidEmailErrorType.Missing]: SuiteCoreStringKey.Error_InvalidEmailMissing,
+      [InvalidEmailErrorType.Whitespace]:
+        SuiteCoreStringKey.Error_InvalidEmailWhitespace,
+    };
+    super(engine, SuiteCoreComponentId, type, reasonMap, language, {
+      statusCode: 422,
+    });
+    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,11 @@
+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,
+    });
+  }
+}

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

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

package/src/errors/pbkdf2-error.ts

@@ -0,0 +1,19 @@
+import { CompleteReasonMap, CoreLanguageCode, 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, CoreLanguageCode> {
+
+  constructor(type: Pbkdf2ErrorType, language?: CoreLanguageCode) {
+    const engine = getSuiteCoreI18nEngine();
+    const pbkdf2ErrorMap: CompleteReasonMap<typeof Pbkdf2ErrorType, SuiteCoreStringKey> = {
+      [Pbkdf2ErrorType.InvalidSaltLength]:
+        SuiteCoreStringKey.Error_Pbkdf2InvalidSaltLength,
+      [Pbkdf2ErrorType.InvalidHashLength]:
+        SuiteCoreStringKey.Error_Pbkdf2InvalidHashLength,
+    };
+    super(engine, SuiteCoreComponentId, type, pbkdf2ErrorMap, language);
+    this.name = 'Pbkdf2Error';
+  }
+}

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

@@ -0,0 +1,8 @@
+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);
+  }
+}

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 { TranslatableSuiteError } from './translatable-suite';
+import { CoreLanguageCode } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+
+export class SystemEmailRoleNotFoundError extends TranslatableSuiteError {
+  constructor(language?: CoreLanguageCode) {
+    super(SuiteCoreStringKey.SystemRoleNotFound, undefined, language);
+    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,43 @@
+import { IHandleable } from '@digitaldefiance/i18n-lib';
+import { SuiteCoreStringKey } from '../enumerations';
+import { TranslatableSuiteError } from './translatable-suite';
+
+export class TranslatableSuiteHandleableError
+  extends TranslatableSuiteError
+  implements IHandleable
+{
+  public override readonly cause?: Error;
+  public readonly statusCode: number;
+  public readonly sourceData?: unknown;
+  private _handled = false;
+
+  constructor(
+    messageKey: SuiteCoreStringKey,
+    otherVars?: Record<string, string | number>,
+    language?: string,
+    handleableOptions?: {
+      statusCode?: number;
+      cause?: Error;
+      sourceData?: unknown;
+    }
+  ) {
+    super(messageKey, otherVars, language);
+    this.statusCode = handleableOptions?.statusCode ?? 500;
+    this.cause = handleableOptions?.cause;
+    this.sourceData = handleableOptions?.sourceData;
+  }
+  public get handled(): boolean {
+    return this._handled;
+  }
+  public set handled(value: boolean) {
+    this._handled = value;
+  }
+  toJSON(): Record<string, unknown> {
+    return {
+      statusCode: this.statusCode,
+      message: this.message,
+      cause: this.cause,
+      sourceData: this.sourceData,
+    };
+  }
+}

package/src/errors/translatable-suite.ts

@@ -0,0 +1,44 @@
+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 {
+      // Try to find the string key in ExpressSuiteStringKey
+      const expressKey = Object.values(SuiteCoreStringKey).find(
+        key => key === string || string.includes(key)
+      );
+      if (expressKey) {
+        translatedMessage = i18nEngine.translate(
+          SuiteCoreComponentId,
+          expressKey as SuiteCoreStringKey,
+          otherVars,
+          language as any
+        );
+      } else {
+        // Fallback to raw string
+        translatedMessage = string;
+      }
+    } 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';
+  }
+}