@digitaldefiance/node-express-suite 1.0.22 → 1.0.23

package/dist/utils.js

@@ -1,786 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TRANSACTION_LOCK_REQUEST_TIMEOUT = exports.DEFAULT_TRANSACTION_TIMEOUT = exports.DEFAULT_RETRY_ATTEMPTS = void 0;
-exports.debugLog = debugLog;
-exports.getValueAtPath = getValueAtPath;
-exports.mapZodIssuesToValidationErrors = mapZodIssuesToValidationErrors;
-exports.requireValidatedFieldsAsync = requireValidatedFieldsAsync;
-exports.requireOneOfValidatedFieldsAsync = requireOneOfValidatedFieldsAsync;
-exports.requireValidatedFieldsOrThrow = requireValidatedFieldsOrThrow;
-exports.isValidStringId = isValidStringId;
-exports.getDefaultBaseDelay = getDefaultBaseDelay;
-exports.withTransaction = withTransaction;
-exports.sendApiMessageResponse = sendApiMessageResponse;
-exports.sendApiErrorResponse = sendApiErrorResponse;
-exports.sendApiExpressValidationErrorResponse = sendApiExpressValidationErrorResponse;
-exports.sendApiMongoValidationErrorResponse = sendApiMongoValidationErrorResponse;
-exports.sendRawJsonResponse = sendRawJsonResponse;
-exports.handleError = handleError;
-exports.locatePEMRoot = locatePEMRoot;
-exports.lengthEncodeData = lengthEncodeData;
-exports.decodeLengthEncodedData = decodeLengthEncodedData;
-exports.isValidTimezone = isValidTimezone;
-exports.omit = omit;
-exports.validateEnumCollection = validateEnumCollection;
-exports.uint8ArrayToBase64 = uint8ArrayToBase64;
-exports.base64ToUint8Array = base64ToUint8Array;
-exports.uint8ArrayToHex = uint8ArrayToHex;
-exports.hexToUint8Array = hexToUint8Array;
-exports.crc16 = crc16;
-exports.stringToUint8Array = stringToUint8Array;
-exports.uint8ArrayToString = uint8ArrayToString;
-exports.randomBytes = randomBytes;
-exports.arraysEqual = arraysEqual;
-exports.concatUint8Arrays = concatUint8Arrays;
-exports.getLengthEncodingTypeForLength = getLengthEncodingTypeForLength;
-exports.getLengthEncodingTypeFromValue = getLengthEncodingTypeFromValue;
-exports.getLengthForLengthType = getLengthForLengthType;
-exports.parseBackupCodes = parseBackupCodes;
-/// <reference path="./types.d.ts" />
-const i18n_lib_1 = require("@digitaldefiance/i18n-lib");
-const express_validator_1 = require("express-validator");
-const fs_1 = require("fs");
-const mongoose_1 = require("mongoose");
-const path_1 = require("path");
-const zod_1 = require("zod");
-const express_validation_1 = require("./errors/express-validation");
-const mongoose_validation_1 = require("./errors/mongoose-validation");
-/**
- * Optionally prints certain debug messages
- * @param debug Whether to print debug messages
- * @param type What type of message to print
- * @param args Any args to print
- */
-function debugLog(debug, type = 'log', ...args) {
-    if (debug && type === 'error') {
-        console.error(...args);
-    }
-    else if (debug && type === 'warn') {
-        console.warn(...args);
-    }
-    else if (debug && type === 'log') {
-        console.log(...args);
-    }
-}
-// Helper: get value at a dotted path from an object
-function getValueAtPath(obj, path) {
-    return path.reduce((acc, key) => {
-        if (acc == null)
-            return undefined;
-        try {
-            return acc[key];
-        }
-        catch {
-            return undefined;
-        }
-    }, obj);
-}
-// Helper: map Zod issues to express-validator ValidationError[]
-function mapZodIssuesToValidationErrors(issues, source, location = 'body') {
-    return issues.map((issue) => ({
-        type: 'field',
-        location,
-        path: issue.path
-            .filter((p) => typeof p === 'string' || typeof p === 'number')
-            .join('.'),
-        value: getValueAtPath(source, issue.path),
-        msg: issue.message,
-    }));
-}
-/**
- * Verifies the required fields were validated by express-validator and sends an error response if not or calls the callback if they are
- * @param req The request object
- * @param fields The fields to check
- * @param callback The callback to call if the fields are valid
- * @returns The result of the callback
- */
-async function requireValidatedFieldsAsync(req, schema, callback) {
-    if (req.validatedBody === undefined) {
-        throw new errors_1.MissingValidatedDataError();
-    }
-    try {
-        const validatedData = schema.parse(req.validatedBody);
-        return await callback(validatedData);
-    }
-    catch (error) {
-        if (error instanceof zod_1.z.ZodError) {
-            throw new express_validation_1.ExpressValidationError(mapZodIssuesToValidationErrors(error.issues, req.validatedBody ?? {}, 'body'));
-        }
-        throw error;
-    }
-}
-/**
- * Verifies at least one of the required fields were validated by express-validator and sends an error response if not or calls the callback if they are
- * @param req The request object
- * @param fields The fields to check
- * @param callback The callback to call if the fields are valid
- * @returns The result of the callback
- */
-async function requireOneOfValidatedFieldsAsync(req, fields, callback) {
-    if (req.validatedBody === undefined) {
-        throw new errors_1.MissingValidatedDataError();
-    }
-    const validatedBody = req.validatedBody;
-    if (!fields.some((field) => validatedBody?.[field] !== undefined)) {
-        throw new errors_1.MissingValidatedDataError(fields);
-    }
-    return await callback();
-}
-/**
- * Verifies the required fields were validated by express-validator and throws an error if not or calls the callback if they are
- * @param req The request object
- * @param fields The fields to check
- * @param callback The callback to call if the fields are valid
- * @returns The result of the callback
- */
-function requireValidatedFieldsOrThrow(req, fields, callback) {
-    if (req.validatedBody === undefined) {
-        throw new errors_1.MissingValidatedDataError();
-    }
-    const validatedBody = req.validatedBody;
-    fields.forEach((field) => {
-        if (validatedBody[field] === undefined) {
-            throw new errors_1.MissingValidatedDataError(field);
-        }
-    });
-    return callback();
-}
-/**
- * Checks if the given id is a valid string id
- * @param id The id to check
- * @returns True if the id is a valid string id
- */
-function isValidStringId(id) {
-    return typeof id === 'string' && mongoose_1.Types.ObjectId.isValid(id);
-}
-/**
- * The default number of retry attempts for transactions
- * Use fewer retries in test environment for faster feedback
- */
-exports.DEFAULT_RETRY_ATTEMPTS = process.env['NODE_ENV'] === 'test' ? 2 : 3;
-/**
- * The default transaction timeout in milliseconds
- * Use shorter timeout in test environment for faster failure detection
- */
-exports.DEFAULT_TRANSACTION_TIMEOUT = process.env['NODE_ENV'] === 'test' ? 15000 : 60000;
-/**
- * The default transaction lock request timeout in milliseconds
- */
-exports.DEFAULT_TRANSACTION_LOCK_REQUEST_TIMEOUT = process.env['NODE_ENV'] === 'test' ? 10000 : 30000;
-/**
- * Gets the default base delay for transaction retries from environment variables
- * @returns The base delay in milliseconds
- */
-function getDefaultBaseDelay() {
-    const envValue = process.env['MONGO_TRANSACTION_RETRY_BASE_DELAY'];
-    if (envValue) {
-        const parsed = parseInt(envValue);
-        if (!isNaN(parsed) && parsed > 0) {
-            return parsed;
-        }
-    }
-    // Fallback to hardcoded values if environment variable is not set or invalid
-    return process.env['NODE_ENV'] === 'test' ? 25 : 100;
-}
-/**
- * Wraps a callback in a transaction if necessary
- * @param connection The mongoose connection
- * @param useTransaction Whether to use a transaction
- * @param session The session to use
- * @param callback The callback to wrap
- * @param options Transaction options including timeout and retry attempts
- * @param args The arguments to pass to the callback
- * @returns The result of the callback
- */
-async function withTransaction(connection, useTransaction, session, callback, options = {}, ...args) {
-    const engine = (0, suite_core_lib_1.getSuiteCoreI18nEngine)();
-    const isTestEnvironment = process.env['NODE_ENV'] === 'test';
-    const { timeoutMs = exports.DEFAULT_TRANSACTION_TIMEOUT, retryAttempts = exports.DEFAULT_RETRY_ATTEMPTS, // Use consistent retry attempts
-    baseDelay = getDefaultBaseDelay(), debugLogEnabled, } = options;
-    if (!useTransaction) {
-        return await callback(session, undefined, ...args);
-    }
-    const needSession = useTransaction && session === undefined;
-    const client = connection.getClient();
-    if (!client) {
-        // If no client is available, fall back to non-transactional execution
-        debugLog(debugLogEnabled === true, 'warn', engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_NoMongoDbClientFoundFallingBack));
-        return await callback(session, undefined, ...args);
-    }
-    let attempt = 0;
-    while (attempt < retryAttempts) {
-        const s = needSession ? await client.startSession() : session;
-        try {
-            if (needSession && s !== undefined) {
-                await s.startTransaction({
-                    maxCommitTimeMS: timeoutMs,
-                });
-            }
-            // Race the callback against the timeout
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => {
-                    reject(new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_TransactionTimeoutTemplate, { timeMs: timeoutMs })));
-                }, timeoutMs);
-            });
-            const result = await Promise.race([callback(s, ...args), timeoutPromise]);
-            if (needSession && s !== undefined)
-                await s.commitTransaction();
-            return result;
-        }
-        catch (error) {
-            if (needSession && s !== undefined && s.inTransaction())
-                await s.abortTransaction();
-            // Check if this is a transient transaction error that can be retried
-            const isTransientError = error?.errorLabelSet?.has('TransientTransactionError') ||
-                error?.errorLabelSet?.has('UnknownTransactionCommitResult') ||
-                error?.code === 251 || // NoSuchTransaction
-                error?.code === 112 || // WriteConflict
-                error?.code === 11000 || // DuplicateKey - very common in concurrent initialization
-                error?.code === 16500 || // TransactionAborted
-                error?.code === 244 || // TransactionTooOld
-                error?.code === 246 || // ExceededTimeLimit
-                error?.code === 13436 || // TransactionTooLargeForCache
-                error?.code === 50 || // MaxTimeMSExpired
-                error?.message?.includes('Transaction') ||
-                error?.message?.includes('aborted') ||
-                error?.message?.includes('WriteConflict') ||
-                error?.message?.includes('NoSuchTransaction') ||
-                error?.message?.includes('TransactionTooOld') ||
-                error?.message?.includes('ExceededTimeLimit') ||
-                error?.message?.includes('duplicate key error') ||
-                error?.message?.includes('E11000') ||
-                (error?.code === 11000 && error?.message?.includes('duplicate')); // More specific duplicate key handling
-            if (isTransientError && attempt < retryAttempts - 1) {
-                attempt++;
-                const jitter = Math.random() * 0.3; // Reduced jitter
-                const actualBaseDelay = isTestEnvironment
-                    ? Math.floor(baseDelay * 0.5)
-                    : baseDelay; // Shorter base delay in tests
-                const delay = Math.floor(actualBaseDelay * (1 + attempt * 0.5) * (1 + jitter)); // Linear backoff instead of exponential
-                debugLog(debugLogEnabled === true, 'warn', engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_TransactionFailedTransientTemplate, {
-                    delayMs: delay,
-                    attempt,
-                    attempts: retryAttempts,
-                }, undefined));
-                await new Promise((resolve) => setTimeout(resolve, delay));
-                continue;
-            }
-            throw error;
-        }
-        finally {
-            if (needSession && s !== undefined)
-                await s.endSession();
-        }
-    }
-    const jitter = Math.random() * 0.3; // Reduced jitter
-    const actualBaseDelay = isTestEnvironment
-        ? Math.floor(baseDelay * 0.5)
-        : baseDelay; // Shorter base delay in tests
-    const delay = Math.floor(actualBaseDelay * (1 + attempt * 0.5) * (1 + jitter)); // Linear backoff instead of exponential
-    throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Admin_TransactionFailedTransientTemplate, {
-        delayMs: delay,
-        attempt,
-        attempts: retryAttempts,
-    });
-}
-/**
- * Sends an API response with the given status and response object.
- * @param status
- * @param response
- * @param res
- */
-function sendApiMessageResponse(status, response, res) {
-    res.status(status).json(response);
-}
-/**
- * Sends an API response with the given status, message, and error.
- * @param status
- * @param message
- * @param error
- * @param res
- */
-function sendApiErrorResponse(status, message, error, res) {
-    sendApiMessageResponse(status, { message, error }, res);
-}
-/**
- * Sends an API response with the given status and validation errors.
- * @param status
- * @param errors
- * @param res
- */
-function sendApiExpressValidationErrorResponse(status, errors, res) {
-    const engine = (0, suite_core_lib_1.getSuiteCoreI18nEngine)();
-    sendApiMessageResponse(status, {
-        message: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.ValidationError),
-        errors,
-    }, res);
-}
-/**
- * Sends an API response with the given status, message, and MongoDB validation errors.
- * @param status
- * @param message
- * @param errors
- * @param res
- */
-function sendApiMongoValidationErrorResponse(status, message, errors, res) {
-    sendApiMessageResponse(status, { message, errors }, res);
-}
-/**
- * Sends a raw JSON response with the given status and response object.
- * @param status The status code
- * @param response The response data
- * @param res The response object
- */
-function sendRawJsonResponse(status, response, res) {
-    res.status(status).json(response);
-}
-function isRecursiveError(error) {
-    return (error !== null &&
-        typeof error === 'object' &&
-        '_handlingInProgress' in error &&
-        !!error._handlingInProgress);
-}
-function markErrorAsHandling(error) {
-    if (error && typeof error === 'object') {
-        error._handlingInProgress = true;
-    }
-}
-function getSafeErrorMessage(message) {
-    if (message && typeof message === 'string' && message.trim() !== '') {
-        return message;
-    }
-    const engine = (0, suite_core_lib_1.getSuiteCoreI18nEngine)();
-    try {
-        const translated = engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_UnexpectedError);
-        return translated &&
-            typeof translated === 'string' &&
-            translated.trim() !== ''
-            ? translated
-            : 'An unexpected error occurred';
-    }
-    catch {
-        return 'An unexpected error occurred';
-    }
-}
-function convertToHandleableError(error) {
-    if (error instanceof i18n_lib_2.HandleableError) {
-        return {
-            handleableError: error,
-            alreadyHandled: error.handled,
-            errorType: error.name,
-        };
-    }
-    if (error instanceof Error) {
-        return {
-            handleableError: new i18n_lib_2.HandleableError(error),
-            alreadyHandled: false,
-            errorType: error.name,
-        };
-    }
-    const unknownMessage = getSafeErrorMessage(typeof error === 'object' &&
-        error !== null &&
-        'message' in error
-        ? error['message']
-        : undefined);
-    const unknownError = new Error(unknownMessage);
-    return {
-        handleableError: new i18n_lib_2.HandleableError(unknownError, { sourceData: error }),
-        alreadyHandled: false,
-        errorType: 'UnexpectedError',
-    };
-}
-function sendErrorResponse(error, handleableError, errorType, send, res) {
-    const engine = i18n_lib_1.I18nEngine.getInstance();
-    if (error instanceof express_validation_1.ExpressValidationError) {
-        // amazonq-ignore-next-line false positive
-        send(handleableError.statusCode, {
-            message: engine.translate('ValidationError'),
-            errors: error.errors instanceof express_validator_1.Result ? error.errors.array() : error.errors,
-            errorType: 'ExpressValidationError',
-        }, res);
-    }
-    else if (error instanceof mongoose_validation_1.MongooseValidationError) {
-        // amazonq-ignore-next-line false positive
-        send(handleableError.statusCode, {
-            message: engine.translate('ValidationError'),
-            errors: error.errors,
-            errorType: 'MongooseValidationError',
-        }, res);
-    }
-    else {
-        // amazonq-ignore-next-line false positive
-        send(handleableError.statusCode, {
-            message: handleableError.message,
-            error: handleableError,
-            errorType: errorType,
-        }, res);
-    }
-}
-function handleError(error, res, send, next) {
-    if (isRecursiveError(error)) {
-        const fallbackError = new i18n_lib_2.HandleableError(new Error('Recursive error handling detected'));
-        // amazonq-ignore-next-line false positive
-        send(fallbackError.statusCode, {
-            message: fallbackError.message,
-            error: fallbackError,
-            errorType: 'RecursiveError',
-        }, res);
-        return;
-    }
-    markErrorAsHandling(error);
-    const { handleableError, alreadyHandled, errorType } = convertToHandleableError(error);
-    if (!(error instanceof express_validation_1.ExpressValidationError)) {
-        console.error('[handleError]', 'type=' + errorType.replace(/[\r\n]/g, ''), 'status=' + String(handleableError.statusCode).replace(/[\r\n]/g, ''), 'message=' +
-            (handleableError.message || '')
-                .replace(/[\r\n]/g, ''));
-    }
-    if (!res.headersSent) {
-        sendErrorResponse(error, handleableError, errorType, send, res);
-        handleableError.handled = true;
-    }
-    if (!alreadyHandled) {
-        handleableError.handled = true;
-        next(handleableError);
-    }
-}
-function locatePEMRoot(devRootDir) {
-    try {
-        const normalizedDir = (0, path_1.resolve)(devRootDir);
-        if (normalizedDir.includes('..') || !normalizedDir.startsWith((0, path_1.resolve)('.'))) {
-            return undefined;
-        }
-        const files = (0, fs_1.readdirSync)(normalizedDir);
-        const pemFiles = files.filter((file) => 
-        // Prevent path traversal by rejecting files with path separators
-        !file.includes('/') &&
-            !file.includes('\\') &&
-            !file.includes('..') &&
-            (file.match(/localhost\+\d+-key\.pem$/) ||
-                file.match(/localhost\+\d+\.pem$/)));
-        if (pemFiles.length < 2) {
-            return undefined;
-        }
-        const roots = pemFiles.map((file) => {
-            const resolved = (0, path_1.resolve)(normalizedDir, file);
-            if (!resolved.startsWith(normalizedDir)) {
-                return undefined;
-            }
-            const result = /(.*)\/(localhost\+\d+)(.*)\.pem/.exec(resolved);
-            return result ? `${result[1]}/${result[2]}` : undefined;
-        });
-        if (roots.some((root) => root !== roots[0])) {
-            return undefined;
-        }
-        if (!(0, fs_1.existsSync)(roots[0] + '.pem') || !(0, fs_1.existsSync)(roots[0] + '-key.pem')) {
-            return undefined;
-        }
-        return roots[0];
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Encodes the length of the data in the buffer
- * @param buffer The buffer to encode
- * @returns The encoded buffer
- */
-function lengthEncodeData(buffer) {
-    const lengthType = getLengthEncodingTypeForLength(buffer.length);
-    const lengthTypeSize = getLengthForLengthType(lengthType);
-    const result = Buffer.alloc(1 + lengthTypeSize + buffer.length);
-    result.writeUInt8(lengthType, 0);
-    switch (lengthType) {
-        case length_encoding_type_1.LengthEncodingType.UInt8:
-            result.writeUInt8(buffer.length, 1);
-            break;
-        case length_encoding_type_1.LengthEncodingType.UInt16:
-            result.writeUInt16BE(buffer.length, 1);
-            break;
-        case length_encoding_type_1.LengthEncodingType.UInt32:
-            result.writeUInt32BE(buffer.length, 1);
-            break;
-        case length_encoding_type_1.LengthEncodingType.UInt64:
-            result.writeBigUInt64BE(BigInt(buffer.length), 1);
-            break;
-    }
-    buffer.copy(result, 1 + lengthTypeSize);
-    return result;
-}
-function decodeLengthEncodedData(buffer) {
-    if (buffer.length < 1) {
-        throw new RangeError('Buffer is too short to read length type.');
-    }
-    const lengthType = getLengthEncodingTypeFromValue(buffer.readUint8(0));
-    const lengthTypeSize = getLengthForLengthType(lengthType);
-    if (buffer.length < 1 + lengthTypeSize) {
-        throw new RangeError('Buffer is too short to read the full length value.');
-    }
-    let length;
-    switch (lengthType) {
-        case length_encoding_type_1.LengthEncodingType.UInt8:
-            length = buffer.readUint8(1);
-            break;
-        case length_encoding_type_1.LengthEncodingType.UInt16:
-            length = buffer.readUint16BE(1);
-            break;
-        case length_encoding_type_1.LengthEncodingType.UInt32:
-            length = buffer.readUint32BE(1);
-            break;
-        case length_encoding_type_1.LengthEncodingType.UInt64:
-            length = buffer.readBigUInt64BE(1);
-            if (Number(length) > Number.MAX_SAFE_INTEGER) {
-                throw new RangeError('Length exceeds maximum safe integer value');
-            }
-            break;
-        default:
-            throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_LengthIsInvalidType);
-    }
-    const totalLength = 1 + lengthTypeSize + Number(length);
-    if (totalLength > buffer.length) {
-        throw new RangeError('Buffer is too short for declared data length');
-    }
-    return {
-        data: buffer.subarray(1 + lengthTypeSize, totalLength),
-        totalLength,
-    };
-}
-const i18n_lib_2 = require("@digitaldefiance/i18n-lib");
-const suite_core_lib_1 = require("@digitaldefiance/suite-core-lib");
-const moment_timezone_1 = __importDefault(require("moment-timezone"));
-const backup_code_1 = require("./backup-code");
-const length_encoding_type_1 = require("./enumerations/length-encoding-type");
-const errors_1 = require("./errors");
-function isValidTimezone(timezone) {
-    return moment_timezone_1.default.tz.zone(timezone) !== null;
-}
-/**
- * Omits keys from an object
- */
-function omit(obj, keys) {
-    const keysToOmit = new Set(keys);
-    return Object.keys(obj).reduce((result, key) => {
-        if (!keysToOmit.has(key)) {
-            result[key] = obj[key];
-        }
-        return result;
-    }, {});
-}
-/**
- * Validates that a collection contains exactly the keys from an enum
- * @param collection The collection to validate
- * @param enumObject The enum object to validate against
- * @param collectionName Optional name for the collection (for better error messages)
- * @param enumName Optional name for the enum (for better error messages)
- * @throws Error if collection has missing, extra, or invalid keys
- */
-function validateEnumCollection(collection, enumObject, collectionName, enumName) {
-    // For numeric enums, filter out reverse mappings (number -> string)
-    const enumKeys = Object.keys(enumObject).filter((key) => isNaN(Number(key)));
-    const allEnumValues = enumKeys.map((key) => enumObject[key]);
-    const collectionKeys = Object.keys(collection);
-    const collectionLabel = collectionName || 'Collection';
-    const enumLabel = enumName || `enum with keys [${enumKeys.join(', ')}]`;
-    if (collectionKeys.length !== allEnumValues.length) {
-        throw new Error(`${collectionLabel} must contain exactly ${allEnumValues.length} keys to match ${enumLabel}. Found ${collectionKeys.length} keys: [${collectionKeys.join(', ')}]`);
-    }
-    const invalidKeys = collectionKeys.filter((key) => !allEnumValues.includes(key));
-    if (invalidKeys.length > 0) {
-        throw new Error(`${collectionLabel} contains invalid keys for ${enumLabel}: [${invalidKeys.join(', ')}]. Valid keys are: [${allEnumValues.join(', ')}]`);
-    }
-    const missingKeys = allEnumValues.filter((value) => !(value in collection));
-    if (missingKeys.length > 0) {
-        throw new Error(`${collectionLabel} is missing required keys for ${enumLabel}: [${missingKeys.join(', ')}]`);
-    }
-}
-function uint8ArrayToBase64(uint8Array) {
-    let binaryString = '';
-    for (let i = 0; i < uint8Array.length; i++) {
-        binaryString += String.fromCharCode(uint8Array[i]);
-    }
-    return btoa(binaryString);
-}
-function base64ToUint8Array(base64String) {
-    const binaryString = atob(base64String);
-    const len = binaryString.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes;
-}
-function uint8ArrayToHex(uint8Array) {
-    return Array.from(uint8Array)
-        .map((byte) => byte.toString(16).padStart(2, '0'))
-        .join('');
-}
-function hexToUint8Array(hexString) {
-    const len = hexString.length;
-    const bytes = new Uint8Array(len / 2);
-    for (let i = 0; i < len; i += 2) {
-        bytes[i / 2] = parseInt(hexString.substring(i, i + 2), 16);
-    }
-    return bytes;
-}
-/**
- * Utility functions for browser ECIES implementation
- */
-/**
- * CRC16-CCITT implementation for data integrity checking
- * Uses the same algorithm as the server-side implementation (CRC16-CCITT-FALSE)
- */
-function crc16(data) {
-    let crc = 0xffff; // Initial value for CRC16-CCITT-FALSE
-    const polynomial = 0x1021; // CRC16-CCITT polynomial
-    for (let i = 0; i < data.length; i++) {
-        crc ^= data[i] << 8;
-        for (let j = 0; j < 8; j++) {
-            if (crc & 0x8000) {
-                crc = (crc << 1) ^ polynomial;
-            }
-            else {
-                crc = crc << 1;
-            }
-            crc &= 0xffff; // Keep it 16-bit
-        }
-    }
-    const result = new Uint8Array(2);
-    result[0] = (crc >>> 8) & 0xff; // Big-endian
-    result[1] = crc & 0xff;
-    return result;
-}
-/**
- * Convert string to Uint8Array (UTF-8 encoding)
- */
-function stringToUint8Array(str) {
-    return new TextEncoder().encode(str);
-}
-/**
- * Convert Uint8Array to string (UTF-8 decoding)
- */
-function uint8ArrayToString(array) {
-    return new TextDecoder().decode(array);
-}
-/**
- * Secure random bytes generation
- */
-function randomBytes(length) {
-    return crypto.getRandomValues(new Uint8Array(length));
-}
-/**
- * Compare two Uint8Arrays for equality
- */
-function arraysEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-/**
- * Concatenate multiple Uint8Arrays
- */
-function concatUint8Arrays(...arrays) {
-    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const array of arrays) {
-        result.set(array, offset);
-        offset += array.length;
-    }
-    return result;
-}
-/**
- * Get the length encoding type for a given length
- * @param length The length to evaluate
- * @returns The corresponding LengthEncodingType
- */
-function getLengthEncodingTypeForLength(length) {
-    if (typeof length === 'number') {
-        if (length < 256) {
-            return length_encoding_type_1.LengthEncodingType.UInt8;
-        }
-        else if (length < 65536) {
-            return length_encoding_type_1.LengthEncodingType.UInt16;
-        }
-        else if (length < 4294967296) {
-            return length_encoding_type_1.LengthEncodingType.UInt32;
-        }
-        else if (length < Number.MAX_SAFE_INTEGER) {
-            return length_encoding_type_1.LengthEncodingType.UInt64;
-        }
-        else {
-            throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_LengthExceedsMaximum);
-        }
-    }
-    else if (typeof length === 'bigint') {
-        if (length < 256n) {
-            return length_encoding_type_1.LengthEncodingType.UInt8;
-        }
-        else if (length < 65536n) {
-            return length_encoding_type_1.LengthEncodingType.UInt16;
-        }
-        else if (length < 4294967296n) {
-            return length_encoding_type_1.LengthEncodingType.UInt32;
-        }
-        else if (length < 18446744073709551616n) {
-            return length_encoding_type_1.LengthEncodingType.UInt64;
-        }
-        else {
-            throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_LengthExceedsMaximum);
-        }
-    }
-    else {
-        throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_LengthIsInvalidType);
-    }
-}
-/**
- * Get the length encoding type for a given value
- * @param value The value to evaluate
- * @returns The corresponding LengthEncodingType
- */
-function getLengthEncodingTypeFromValue(value) {
-    for (const length of Object.values(length_encoding_type_1.LengthEncodingType)) {
-        if (length === value) {
-            return length;
-        }
-    }
-    throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_LengthIsInvalidType);
-}
-/**
- * Get the length in bytes for a given LengthEncodingType
- * @param type The LengthEncodingType to evaluate
- * @returns The length in bytes
- */
-function getLengthForLengthType(type) {
-    switch (type) {
-        case length_encoding_type_1.LengthEncodingType.UInt8:
-            return 1;
-        case length_encoding_type_1.LengthEncodingType.UInt16:
-            return 2;
-        case length_encoding_type_1.LengthEncodingType.UInt32:
-            return 4;
-        case length_encoding_type_1.LengthEncodingType.UInt64:
-            return 8;
-        default:
-            throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_LengthIsInvalidType);
-    }
-}
-function parseBackupCodes(user, environment) {
-    const envVarMap = {
-        admin: 'ADMIN_BACKUP_CODES',
-        member: 'MEMBER_BACKUP_CODES',
-        system: 'SYSTEM_BACKUP_CODES',
-    };
-    const envVar = envVarMap[user];
-    const backupCodes = environment[envVar]
-        ?.split(',')
-        .map((code) => new backup_code_1.BackupCode(code.trim())) || [];
-    return backupCodes;
-}
-//# sourceMappingURL=utils.js.map