@digitaldefiance/node-express-suite 3.6.21 → 3.6.24

package/src/services/database-initialization.js

@@ -0,0 +1,879 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseInitializationService = void 0;
+const tslib_1 = require("tslib");
+const ecies_lib_1 = require("@digitaldefiance/ecies-lib");
+const i18n_lib_1 = require("@digitaldefiance/i18n-lib");
+const node_ecies_lib_1 = require("@digitaldefiance/node-ecies-lib");
+const suite_core_lib_1 = require("@digitaldefiance/suite-core-lib");
+const crc_1 = require("crc");
+const crypto_1 = require("crypto");
+const fs = tslib_1.__importStar(require("fs"));
+const mongodb_1 = require("mongodb");
+const path = tslib_1.__importStar(require("path"));
+const backup_code_1 = require("../backup-code");
+const base_model_name_1 = require("../enumerations/base-model-name");
+const model_registry_1 = require("../model-registry");
+const key_wrapping_1 = require("../services/key-wrapping");
+const id_converters_1 = require("../types/id-converters");
+const utils_1 = require("../utils");
+const backup_code_2 = require("./backup-code");
+const mnemonic_1 = require("./mnemonic");
+const role_1 = require("./role");
+const system_user_1 = require("./system-user");
+class DatabaseInitializationService {
+    // Static initialization state management
+    static initializationPromises = new Map();
+    static initializationLock = new Map();
+    static defaultI18nTFunc(str, variables, language, application) {
+        // Handles template strings with {{component.key}} syntax
+        return (0, suite_core_lib_1.getSuiteCoreI18nEngine)(application ? { constants: application.constants } : undefined).t(str, variables, language);
+    }
+    /**
+     * Get the mnemonic or generate a new one if not present
+     * @param mnemonic The existing mnemonic or undefined
+     * @param eciesService The ECIES service to generate a new mnemonic
+     * @returns The existing or new mnemonic
+     */
+    static mnemonicOrNew(mnemonic, eciesService) {
+        return mnemonic && mnemonic.hasValue
+            ? mnemonic
+            : eciesService.generateNewMnemonic();
+    }
+    /**
+     * Generate a cache key for a user based on their details
+     * @param username The username
+     * @param email The email address
+     * @param mnemonic The mnemonic
+     * @param id The user ID
+     * @returns The generated cache key
+     */
+    static cacheKey(username, email, mnemonic, id, idToString = (id) => String(id)) {
+        const combined = `${username}|${email.email}|${mnemonic.value}|${idToString(id)}`;
+        const buffer = Buffer.from(combined, 'utf-8');
+        const crcHash = (0, crc_1.crc32)(buffer);
+        return crcHash.toString(16).padStart(8, '0');
+    }
+    /**
+     * Get a cached BackendMember or create a new one if not cached
+     * @param username The username
+     * @param email The email address
+     * @param mnemonic The mnemonic or undefined to generate a new one
+     * @param memberType The type of member (Admin, Member, System)
+     * @param eciesService The ECIES service to handle key generation
+     * @param memberId Optional specific member ID to use
+     * @param createdBy Optional ID of the user who created this member
+     * @returns The cached or newly created BackendMember and the mnemonic used
+     */
+    static cacheOrNew(username, email, mnemonic, memberType, eciesService, memberId, createdBy, idGenerator, idToString = (id) => String(id)) {
+        const m = this.mnemonicOrNew(mnemonic, eciesService);
+        const newId = memberId
+            ? memberId
+            : idGenerator
+                ? idGenerator()
+                : (0, id_converters_1.convertObjectIdToGenericId)(new mongodb_1.ObjectId());
+        const key = DatabaseInitializationService.cacheKey(username, email, m, newId, idToString);
+        if (!global.__MEMBER_CACHE__) {
+            global.__MEMBER_CACHE__ = new Map();
+        }
+        if (!global.__MEMBER_CACHE__.has(key)) {
+            const { wallet } = eciesService.walletAndSeedFromMnemonic(m);
+            // Get private key from wallet
+            const privateKey = wallet.getPrivateKey();
+            // Get compressed public key (already includes prefix)
+            const publicKeyWithPrefix = eciesService.getPublicKey(Buffer.from(privateKey));
+            const user = new node_ecies_lib_1.Member(eciesService, memberType, username, email, publicKeyWithPrefix, new ecies_lib_1.SecureBuffer(privateKey), wallet, newId, undefined, undefined, createdBy);
+            global.__MEMBER_CACHE__.set(key, {
+                mnemonic: m,
+                member: user,
+            });
+            return { mnemonic: m, member: user };
+        }
+        else {
+            return global.__MEMBER_CACHE__.get(key);
+        }
+    }
+    /**
+     * Generate a random password
+     * @param length The length of the password
+     * @returns The generated password
+     */
+    static generatePassword(length) {
+        const specialCharacters = "!@#$%^&*()_+-=[]{};':|,.<>/?";
+        const numbers = '0123456789';
+        const letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        // Get a random character from a string
+        const getRandomChar = (chars) => {
+            // amazonq-ignore-next-line false positive
+            const randomIndex = (0, crypto_1.randomBytes)(1)[0] % chars.length;
+            return chars[randomIndex];
+        };
+        // Start with one of each required character type
+        // amazonq-ignore-next-line false positive
+        let password = '';
+        password += getRandomChar(letters);
+        password += getRandomChar(numbers);
+        password += getRandomChar(specialCharacters);
+        // Fill the rest with random characters from all types
+        const allCharacters = specialCharacters + numbers + letters;
+        for (let i = password.length; i < length; i++) {
+            password += getRandomChar(allCharacters);
+        }
+        // Shuffle the password characters to avoid predictable pattern
+        const chars = password.split('');
+        for (let i = chars.length - 1; i > 0; i--) {
+            // amazonq-ignore-next-line already fixed
+            const j = (0, crypto_1.randomBytes)(1)[0] % (i + 1);
+            [chars[i], chars[j]] = [chars[j], chars[i]];
+        }
+        return chars.join('');
+    }
+    /**
+     * Drops the database
+     * @param connection The database connection
+     * @returns True if the database was dropped, false if not connected
+     */
+    static async dropDatabase(connection) {
+        if (!connection.db)
+            return false;
+        (0, utils_1.debugLog)(true, 'warn', this.defaultI18nTFunc('{{SuiteCoreStringKey.Admin_DroppingDatabase}}'));
+        return connection.db.dropDatabase();
+    }
+    static getInitOptions(application) {
+        const env = application.environment;
+        return {
+            adminId: env.adminId,
+            adminMnemonic: env.adminMnemonic?.hasValue
+                ? env.adminMnemonic
+                : undefined,
+            adminPassword: env.adminPassword?.hasValue
+                ? env.adminPassword
+                : undefined,
+            adminRoleId: env.adminRoleId,
+            adminUserRoleId: env.adminUserRoleId,
+            adminBackupCodes: env.adminBackupCodes,
+            memberId: env.memberId,
+            memberMnemonic: env.memberMnemonic?.hasValue
+                ? env.memberMnemonic
+                : undefined,
+            memberPassword: env.memberPassword?.hasValue
+                ? env.memberPassword
+                : undefined,
+            memberRoleId: env.memberRoleId,
+            memberUserRoleId: env.memberUserRoleId,
+            memberBackupCodes: env.memberBackupCodes,
+            systemId: env.systemId,
+            systemMnemonic: env.systemMnemonic?.hasValue
+                ? env.systemMnemonic
+                : undefined,
+            systemPassword: env.systemPassword?.hasValue
+                ? env.systemPassword
+                : undefined,
+            systemRoleId: env.systemRoleId,
+            systemUserRoleId: env.systemUserRoleId,
+            systemBackupCodes: env.systemBackupCodes,
+        };
+    }
+    static serverInitResultHash(serverInitResult, idToString = (id) => String(id)) {
+        const h = (0, crypto_1.createHash)('sha256');
+        h.update(idToString(serverInitResult.adminUser._id));
+        h.update(idToString(serverInitResult.adminRole._id));
+        h.update(idToString(serverInitResult.adminUserRole._id));
+        h.update(serverInitResult.adminUsername);
+        h.update(serverInitResult.adminEmail);
+        h.update(serverInitResult.adminMnemonic);
+        h.update(serverInitResult.adminPassword);
+        h.update(serverInitResult.adminUser.publicKey);
+        serverInitResult.adminBackupCodes.map((bc) => h.update(bc));
+        h.update(idToString(serverInitResult.memberUser._id));
+        h.update(idToString(serverInitResult.memberRole._id));
+        h.update(idToString(serverInitResult.memberUserRole._id));
+        h.update(serverInitResult.memberUsername);
+        h.update(serverInitResult.memberEmail);
+        h.update(serverInitResult.memberMnemonic);
+        h.update(serverInitResult.memberPassword);
+        h.update(serverInitResult.memberUser.publicKey);
+        serverInitResult.memberBackupCodes.map((bc) => h.update(bc));
+        h.update(idToString(serverInitResult.systemUser._id));
+        h.update(idToString(serverInitResult.systemRole._id));
+        h.update(idToString(serverInitResult.systemUserRole._id));
+        h.update(serverInitResult.systemUsername);
+        h.update(serverInitResult.systemEmail);
+        h.update(serverInitResult.systemMnemonic);
+        h.update(serverInitResult.systemPassword);
+        h.update(serverInitResult.systemUser.publicKey);
+        serverInitResult.systemBackupCodes.map((bc) => h.update(bc));
+        return h.digest('hex');
+    }
+    /**
+     * Initialize the user database with default users and roles (with dependency injection)
+     * @param application The application
+     * @param keyWrappingService The key wrapping service
+     * @param mnemonicService The mnemonic service
+     * @param eciesService The ECIES service
+     * @param roleService The role service
+     * @param backupCodeService The backup code service
+     * @returns The result of the initialization
+     */
+    static async initUserDbWithServices(application, keyWrappingService, mnemonicService, eciesService, roleService, backupCodeService, idGenerator, idToString = (id) => application.constants.idProvider.idToString(id)) {
+        const engine = (0, suite_core_lib_1.getSuiteCoreI18nEngine)({ constants: application.constants });
+        const isTestEnvironment = process.env['NODE_ENV'] === 'test';
+        const options = DatabaseInitializationService.getInitOptions(application);
+        const effectiveIdGenerator = (idGenerator ??
+            (() => application.environment.idAdapter(application.constants.idProvider.generate())));
+        const UserModel = model_registry_1.ModelRegistry.instance.getTypedModel(base_model_name_1.BaseModelName.User);
+        const RoleModel = model_registry_1.ModelRegistry.instance.getTypedModel(base_model_name_1.BaseModelName.Role);
+        const adminUserId = options.adminId ?? effectiveIdGenerator();
+        const adminRoleId = options.adminRoleId ?? effectiveIdGenerator();
+        const adminUserRoleId = options.adminUserRoleId ?? effectiveIdGenerator();
+        const memberUserId = options.memberId ?? effectiveIdGenerator();
+        const memberRoleId = options.memberRoleId ?? effectiveIdGenerator();
+        const memberUserRoleId = options.memberUserRoleId ?? effectiveIdGenerator();
+        const systemUserId = options.systemId ?? effectiveIdGenerator();
+        const systemRoleId = options.systemRoleId ?? effectiveIdGenerator();
+        const systemUserRoleId = options.systemUserRoleId ?? effectiveIdGenerator();
+        // Check for existing users and roles with optimized queries
+        // Use lean() for better performance on read-only operations
+        const [existingUsers, existingRoles] = await Promise.all([
+            UserModel.find({
+                username: {
+                    $in: [
+                        application.constants.SystemUser,
+                        application.constants.AdministratorUser,
+                        application.constants.MemberUser,
+                    ],
+                },
+            }).lean(),
+            RoleModel.find({
+                name: {
+                    $in: [
+                        application.constants.AdministratorRole,
+                        application.constants.MemberRole,
+                        application.constants.SystemRole,
+                    ],
+                },
+            }).lean(),
+        ]);
+        if (existingUsers.length > 0 || existingRoles.length > 0) {
+            // Database is already initialized, return the existing data
+            const existingAdminUser = existingUsers.find((u) => u.username === application.constants.AdministratorUser);
+            const existingMemberUser = existingUsers.find((u) => u.username === application.constants.MemberUser);
+            const existingSystemUser = existingUsers.find((u) => u.username === application.constants.SystemUser);
+            if (existingAdminUser && existingMemberUser && existingSystemUser) {
+                const adminUserDoc = UserModel.hydrate(existingAdminUser);
+                const memberUserDoc = UserModel.hydrate(existingMemberUser);
+                const systemUserDoc = UserModel.hydrate(existingSystemUser);
+                // Try to construct a minimal result from existing data
+                // Note: This is a fallback case and some data may not be available
+                const UserRoleModel = model_registry_1.ModelRegistry.instance.getTypedModel(base_model_name_1.BaseModelName.UserRole);
+                const [adminRole, memberRole, systemRole, adminUserRole, memberUserRole, systemUserRole,] = await Promise.all([
+                    RoleModel.findOne({ name: application.constants.AdministratorRole }),
+                    RoleModel.findOne({ name: application.constants.MemberRole }),
+                    RoleModel.findOne({ name: application.constants.SystemRole }),
+                    UserRoleModel.findOne({ userId: adminUserDoc._id }),
+                    UserRoleModel.findOne({ userId: memberUserDoc._id }),
+                    UserRoleModel.findOne({ userId: systemUserDoc._id }),
+                ]);
+                // detailed case
+                if (adminRole &&
+                    memberRole &&
+                    systemRole &&
+                    adminUserRole &&
+                    memberUserRole &&
+                    systemUserRole) {
+                    return {
+                        alreadyInitialized: true,
+                        success: false,
+                        data: {
+                            adminRole,
+                            adminUserRole,
+                            adminUser: adminUserDoc,
+                            adminUsername: adminUserDoc.username,
+                            adminEmail: adminUserDoc.email,
+                            adminMnemonic: '', // Not available in fallback
+                            adminPassword: '', // Not available in fallback
+                            adminBackupCodes: [], // Not available in fallback
+                            adminMember: {}, // Not available in fallback
+                            memberRole,
+                            memberUserRole,
+                            memberUser: memberUserDoc,
+                            memberUsername: memberUserDoc.username,
+                            memberEmail: memberUserDoc.email,
+                            memberMnemonic: '', // Not available in fallback
+                            memberPassword: '', // Not available in fallback
+                            memberBackupCodes: [], // Not available in fallback
+                            memberMember: {}, // Not available in fallback
+                            systemRole,
+                            systemUserRole,
+                            systemUser: systemUserDoc,
+                            systemUsername: systemUserDoc.username,
+                            systemEmail: systemUserDoc.email,
+                            systemMnemonic: '', // Not available in fallback
+                            systemPassword: '', // Not available in fallback
+                            systemBackupCodes: [], // Not available in fallback
+                            systemMember: {}, // Not available in fallback
+                        },
+                        message: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_DatabaseAlreadyInitialized),
+                        error: new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_DatabaseAlreadyInitialized)),
+                    };
+                }
+            }
+            // basic case
+            return {
+                alreadyInitialized: true,
+                success: false,
+                message: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_DatabaseAlreadyInitialized),
+                error: new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_DatabaseAlreadyInitialized)),
+            };
+        }
+        (0, utils_1.debugLog)(application.environment.detailedDebug, 'log', engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_SettingUpUsersAndRoles));
+        const now = new Date();
+        // Add a small random delay in test environments to reduce collision probability
+        if (isTestEnvironment) {
+            const delay = ((0, crypto_1.randomBytes)(1)[0] % 50) + 10; // 10-60ms random delay (reduced)
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        try {
+            // Use test-optimized settings for better performance
+            const transactionOptions = isTestEnvironment
+                ? { timeoutMs: 15000, retryAttempts: 2 } // Reduced timeout and retries for tests
+                : { timeoutMs: 120000 }; // Keep original production timeout
+            const result = await (0, utils_1.withTransaction)(application.db.connection, application.environment.mongo.useTransactions, undefined, async (sess) => {
+                // Check if admin role already exists
+                let adminRole = await RoleModel.findOne({
+                    name: application.constants.AdministratorRole,
+                }).session(sess ?? null);
+                if (!adminRole) {
+                    const adminRoleDocs = await RoleModel.create([
+                        {
+                            _id: adminRoleId,
+                            name: application.constants.AdministratorRole,
+                            admin: true,
+                            member: true,
+                            system: false,
+                            child: false,
+                            createdAt: now,
+                            updatedAt: now,
+                            createdBy: systemUserId,
+                            updatedBy: systemUserId,
+                        },
+                    ], { session: sess });
+                    if (adminRoleDocs.length !== 1) {
+                        throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_FailedToCreateRoleTemplate, {
+                            NAME: application.constants.AdministratorRole,
+                        });
+                    }
+                    adminRole = adminRoleDocs[0];
+                }
+                // Check if member role already exists
+                let memberRole = await RoleModel.findOne({
+                    name: application.constants.MemberRole,
+                }).session(sess ?? null);
+                if (!memberRole) {
+                    const memberRoleDocs = await RoleModel.create([
+                        {
+                            _id: memberRoleId,
+                            name: application.constants.MemberRole,
+                            admin: false,
+                            member: true,
+                            child: false,
+                            system: false,
+                            createdAt: now,
+                            updatedAt: now,
+                            createdBy: systemUserId,
+                            updatedBy: systemUserId,
+                        },
+                    ], { session: sess });
+                    if (memberRoleDocs.length !== 1) {
+                        throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_FailedToCreateRoleTemplate, {
+                            NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_Member),
+                        });
+                    }
+                    memberRole = memberRoleDocs[0];
+                }
+                // Check if system role already exists
+                let systemRole = await RoleModel.findOne({
+                    name: application.constants.SystemRole,
+                }).session(sess ?? null);
+                if (!systemRole) {
+                    const systemRoleDocs = await RoleModel.create([
+                        {
+                            _id: systemRoleId,
+                            name: application.constants.SystemRole,
+                            admin: true,
+                            member: true,
+                            system: true,
+                            child: false,
+                            createdAt: now,
+                            updatedAt: now,
+                            createdBy: systemUserId,
+                            updatedBy: systemUserId,
+                        },
+                    ], { session: sess });
+                    if (systemRoleDocs.length !== 1) {
+                        throw new suite_core_lib_1.TranslatableSuiteError(suite_core_lib_1.SuiteCoreStringKey.Error_FailedToCreateRoleTemplate);
+                    }
+                    systemRole = systemRoleDocs[0];
+                }
+                const systemUser = DatabaseInitializationService.cacheOrNew(application.constants.SystemUser, new ecies_lib_1.EmailString(application.constants.SystemEmail), options.systemMnemonic, ecies_lib_1.MemberType.System, eciesService, systemUserId, systemUserId, effectiveIdGenerator, idToString);
+                backupCodeService.setSystemUser(systemUser.member);
+                system_user_1.SystemUserService.setSystemUser(systemUser.member, application.constants);
+                // Encrypt mnemonic for recovery
+                const systemEncryptedMnemonic = systemUser.member
+                    .encryptData(Buffer.from(systemUser.mnemonic.value ?? '', 'utf-8'))
+                    .toString('hex');
+                const systemMnemonicDoc = await mnemonicService.addMnemonic(systemUser.mnemonic, sess);
+                if (!systemMnemonicDoc) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_FailedToStoreUserMnemonicTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_System),
+                    }));
+                }
+                const systemPasswordSecure = options.systemPassword
+                    ? options.systemPassword
+                    : new ecies_lib_1.SecureString(this.generatePassword(16));
+                const systemWrapped = keyWrappingService.wrapSecret(systemUser.member.privateKey, systemPasswordSecure, application.constants);
+                const systemBackupCodes = options.systemBackupCodes ?? backup_code_1.BackupCode.generateBackupCodes();
+                const encryptedSystemBackupCodes = await backup_code_1.BackupCode.encryptBackupCodes(systemUser.member, systemUser.member, systemBackupCodes);
+                const systemDocs = await UserModel.create([
+                    {
+                        _id: systemUserId,
+                        username: application.constants.SystemUser,
+                        email: application.constants.SystemEmail,
+                        publicKey: systemUser.member.publicKey.toString('hex'),
+                        duressPasswords: [],
+                        mnemonicRecovery: systemEncryptedMnemonic,
+                        mnemonicId: systemMnemonicDoc._id,
+                        passwordWrappedPrivateKey: systemWrapped,
+                        backupCodes: encryptedSystemBackupCodes,
+                        timezone: application.environment.timezone,
+                        siteLanguage: 'en-US',
+                        emailVerified: true,
+                        darkMode: false,
+                        accountStatus: suite_core_lib_1.AccountStatus.Active,
+                        directChallenge: true, // allow direct challenge login by default
+                        createdAt: now,
+                        updatedAt: now,
+                        createdBy: systemUserId,
+                        updatedBy: systemUserId,
+                    },
+                ], { session: sess });
+                if (systemDocs.length !== 1) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_FailedToCreateUserTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_System),
+                    }));
+                }
+                const systemDoc = systemDocs[0];
+                // Create admin user-role relationship
+                const systemUserRoleDoc = await roleService.addUserToRole(systemRoleId, systemUserId, systemUserId, sess, systemUserRoleId);
+                if (!systemUser.mnemonic.value) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_MnemonicIsNullTemplate, {
+                        NAME: suite_core_lib_1.SuiteCoreStringKey.Common_System,
+                    }));
+                }
+                const adminUser = DatabaseInitializationService.cacheOrNew(application.constants.AdministratorUser, new ecies_lib_1.EmailString(application.constants.AdministratorEmail), options.adminMnemonic, ecies_lib_1.MemberType.User, eciesService, adminUserId, systemDoc._id, effectiveIdGenerator, idToString);
+                // Encrypt mnemonic for recovery
+                const adminEncryptedMnemonic = adminUser.member
+                    .encryptData(Buffer.from(adminUser.mnemonic.value ?? '', 'utf-8'))
+                    .toString('hex');
+                const adminMnemonicDoc = await mnemonicService.addMnemonic(adminUser.mnemonic, sess);
+                if (!adminMnemonicDoc) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_FailedToStoreUserMnemonicTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_Admin),
+                    }));
+                }
+                const adminPasswordSecure = options.adminPassword
+                    ? options.adminPassword
+                    : new ecies_lib_1.SecureString(this.generatePassword(16));
+                const adminWrapped = keyWrappingService.wrapSecret(adminUser.member.privateKey, adminPasswordSecure);
+                const adminBackupCodes = options.adminBackupCodes ?? backup_code_1.BackupCode.generateBackupCodes();
+                const encryptedAdminBackupCodes = await backup_code_1.BackupCode.encryptBackupCodes(adminUser.member, systemUser.member, adminBackupCodes);
+                const adminDocs = await UserModel.create([
+                    {
+                        _id: adminUserId,
+                        username: application.constants.AdministratorUser,
+                        email: application.constants.AdministratorEmail,
+                        publicKey: adminUser.member.publicKey.toString('hex'),
+                        duressPasswords: [],
+                        mnemonicRecovery: adminEncryptedMnemonic,
+                        mnemonicId: adminMnemonicDoc._id,
+                        passwordWrappedPrivateKey: adminWrapped,
+                        backupCodes: encryptedAdminBackupCodes,
+                        timezone: application.environment.timezone,
+                        siteLanguage: 'en-US',
+                        emailVerified: true,
+                        accountStatus: suite_core_lib_1.AccountStatus.Active,
+                        directChallenge: true,
+                        createdAt: now,
+                        updatedAt: now,
+                        createdBy: systemUserId,
+                        updatedBy: systemUserId,
+                    },
+                ], { session: sess });
+                if (adminDocs.length !== 1) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_FailedToCreateUserTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_Admin),
+                    }));
+                }
+                const adminDoc = adminDocs[0];
+                // Create admin user-role relationship
+                const adminUserRoleDoc = await roleService.addUserToRole(adminRoleId, adminUserId, systemUserId, sess, adminUserRoleId);
+                if (!adminUser.mnemonic.value) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_MnemonicIsNullTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_Admin),
+                    }));
+                }
+                const memberUser = DatabaseInitializationService.cacheOrNew(application.constants.MemberUser, new ecies_lib_1.EmailString(application.constants.MemberEmail), options.memberMnemonic, ecies_lib_1.MemberType.User, eciesService, memberUserId, systemDoc._id, effectiveIdGenerator, idToString);
+                const memberPasswordSecure = options.memberPassword
+                    ? options.memberPassword
+                    : new ecies_lib_1.SecureString(this.generatePassword(16));
+                const memberMnemonicDoc = await mnemonicService.addMnemonic(memberUser.mnemonic, sess);
+                if (!memberMnemonicDoc) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_FailedToStoreUserMnemonicTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_Member),
+                    }));
+                }
+                // Encrypt mnemonic for recovery
+                const encryptedMemberMnemonic = memberUser.member
+                    .encryptData(Buffer.from(memberUser.mnemonic.value ?? '', 'utf-8'))
+                    .toString('hex');
+                const memberWrapped = keyWrappingService.wrapSecret(memberUser.member.privateKey, memberPasswordSecure);
+                const memberBackupCodes = options.memberBackupCodes ?? backup_code_1.BackupCode.generateBackupCodes();
+                const encryptedMemberBackupCodes = await backup_code_1.BackupCode.encryptBackupCodes(memberUser.member, systemUser.member, memberBackupCodes);
+                const memberDocs = await UserModel.create([
+                    {
+                        _id: memberUserId,
+                        username: application.constants.MemberUser,
+                        email: application.constants.MemberEmail,
+                        publicKey: memberUser.member.publicKey.toString('hex'),
+                        mnemonicId: memberMnemonicDoc._id,
+                        mnemonicRecovery: encryptedMemberMnemonic,
+                        passwordWrappedPrivateKey: memberWrapped,
+                        backupCodes: encryptedMemberBackupCodes,
+                        duressPasswords: [],
+                        timezone: application.environment.timezone,
+                        siteLanguage: 'en-US',
+                        emailVerified: true,
+                        accountStatus: suite_core_lib_1.AccountStatus.Active,
+                        directChallenge: true,
+                        createdAt: now,
+                        updatedAt: now,
+                        createdBy: systemUserId,
+                        updatedBy: systemUserId,
+                    },
+                ], { session: sess });
+                if (memberDocs.length !== 1) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_FailedToCreateUserTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_Member),
+                    }));
+                }
+                const memberDoc = memberDocs[0];
+                // Create member user-role relationship
+                const memberUserRoleDoc = await roleService.addUserToRole(memberRoleId, memberUserId, systemUserId, sess, memberUserRoleId);
+                if (!memberUser.mnemonic.value) {
+                    throw new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Error_MnemonicIsNullTemplate, {
+                        NAME: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Common_Member),
+                    }));
+                }
+                return {
+                    adminRole,
+                    memberRole,
+                    systemRole,
+                    systemDoc,
+                    systemUserRoleDoc,
+                    systemPassword: systemPasswordSecure.notNullValue,
+                    systemMnemonic: systemUser.mnemonic.notNullValue,
+                    systemBackupCodes: systemBackupCodes,
+                    systemMember: systemUser.member,
+                    adminDoc,
+                    adminUserRoleDoc,
+                    adminPassword: adminPasswordSecure.notNullValue,
+                    adminMnemonic: adminUser.mnemonic.notNullValue,
+                    adminBackupCodes: adminBackupCodes,
+                    adminMember: adminUser.member,
+                    memberDoc,
+                    memberUserRoleDoc,
+                    memberPassword: memberPasswordSecure.notNullValue,
+                    memberMnemonic: memberUser.mnemonic.notNullValue,
+                    memberBackupCodes: memberBackupCodes,
+                    memberUser: memberUser.member,
+                };
+            }, transactionOptions);
+            return {
+                alreadyInitialized: false,
+                success: true,
+                data: {
+                    adminRole: result.adminRole,
+                    adminUserRole: result.adminUserRoleDoc,
+                    adminUser: result.adminDoc,
+                    adminUsername: result.adminDoc.username,
+                    adminEmail: result.adminDoc.email,
+                    adminMnemonic: result.adminMnemonic,
+                    adminPassword: result.adminPassword,
+                    adminBackupCodes: result.adminBackupCodes.map((bc) => bc.value ?? ''),
+                    adminMember: result.adminMember,
+                    memberRole: result.memberRole,
+                    memberUserRole: result.memberUserRoleDoc,
+                    memberUser: result.memberDoc,
+                    memberUsername: result.memberDoc.username,
+                    memberEmail: result.memberDoc.email,
+                    memberMnemonic: result.memberMnemonic,
+                    memberPassword: result.memberPassword,
+                    memberBackupCodes: result.memberBackupCodes.map((bc) => bc.value ?? ''),
+                    memberMember: result.memberUser,
+                    systemRole: result.systemRole,
+                    systemUserRole: result.systemUserRoleDoc,
+                    systemUser: result.systemDoc,
+                    systemUsername: result.systemDoc.username,
+                    systemEmail: result.systemDoc.email,
+                    systemMnemonic: result.systemMnemonic,
+                    systemPassword: result.systemPassword,
+                    systemBackupCodes: result.systemBackupCodes.map((bc) => bc.value ?? ''),
+                    systemMember: result.systemMember,
+                },
+            };
+        }
+        catch (error) {
+            // Check if it's a translatable error and display cleanly
+            if (error instanceof i18n_lib_1.TranslatableGenericError ||
+                error instanceof i18n_lib_1.TranslatableHandleableGenericError ||
+                error instanceof suite_core_lib_1.TranslatableSuiteError ||
+                error instanceof suite_core_lib_1.TranslatableSuiteHandleableError) {
+                return {
+                    alreadyInitialized: false,
+                    success: false,
+                    message: error.message,
+                    error: error,
+                };
+            }
+            return {
+                alreadyInitialized: false,
+                success: false,
+                message: engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_Error_FailedToInitializeUserDatabase),
+                error: error instanceof Error
+                    ? error
+                    : new Error(engine.translate(suite_core_lib_1.SuiteCoreComponentId, suite_core_lib_1.SuiteCoreStringKey.Admin_Error_FailedToInitializeUserDatabase)),
+            };
+        }
+    }
+    static serverInitResultsToDotEnv(serverInitResult, idToString = (id) => String(id)) {
+        return `ADMIN_ID="${idToString(serverInitResult.adminUser._id)}"
+ADMIN_MNEMONIC="${serverInitResult.adminMnemonic}"
+ADMIN_ROLE_ID="${idToString(serverInitResult.adminRole._id)}"
+ADMIN_USER_ROLE_ID="${idToString(serverInitResult.adminUserRole._id)}"
+ADMIN_PASSWORD="${serverInitResult.adminPassword}"
+MEMBER_ID="${idToString(serverInitResult.memberUser._id)}"
+MEMBER_MNEMONIC="${serverInitResult.memberMnemonic}"
+MEMBER_ROLE_ID="${idToString(serverInitResult.memberRole._id)}"
+MEMBER_USER_ROLE_ID="${idToString(serverInitResult.memberUserRole._id)}"
+MEMBER_PASSWORD="${serverInitResult.memberPassword}"
+SYSTEM_ID="${idToString(serverInitResult.systemUser._id)}"
+SYSTEM_MNEMONIC="${serverInitResult.systemMnemonic}"
+SYSTEM_PUBLIC_KEY="${serverInitResult.systemUser.publicKey}"
+SYSTEM_ROLE_ID="${idToString(serverInitResult.systemRole._id)}"
+SYSTEM_USER_ROLE_ID="${idToString(serverInitResult.systemUserRole._id)}"
+SYSTEM_PASSWORD="${serverInitResult.systemPassword}"
+`;
+    }
+    static printServerInitResults(result, printDotEnv = true, idToString = (id) => String(id)) {
+        (0, utils_1.debugLog)(true, 'log', this.defaultI18nTFunc('\n=== {{SuiteCoreStringKey.Admin_AccountCredentials}} ==='));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_ID}}: {id}', {
+            id: idToString(result.systemUser._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_Role}}: {roleName}', {
+            roleName: result.systemRole.name,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_Role}} {{SuiteCoreStringKey.Common_ID}}: {roleId}', {
+            roleId: idToString(result.systemRole._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_User}} {{SuiteCoreStringKey.Common_Role}} {{SuiteCoreStringKey.Common_ID}}: {userRoleId}', {
+            userRoleId: idToString(result.systemUserRole._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_Username}}: {username}', {
+            username: result.systemUsername,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_Email}}: {email}', {
+            email: result.systemEmail,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_Password}}: {password}', {
+            password: result.systemPassword,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_Mnemonic}}: {mnemonic}', {
+            mnemonic: result.systemMnemonic,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_PublicKey}}: {publicKey}', {
+            publicKey: result.systemUser.publicKey,
+        }));
+        (0, utils_1.directLog)(true, 'log', `${this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_System}} {{SuiteCoreStringKey.Common_BackupCodes}}')}: ${result.systemBackupCodes.join(', ')}`);
+        (0, utils_1.directLog)(true, 'log', '');
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_ID}}: {id}', {
+            id: idToString(result.adminUser._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_Role}}: {roleName}', {
+            roleName: result.adminRole.name,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_Role}} {{SuiteCoreStringKey.Common_ID}}: {roleId}', {
+            roleId: idToString(result.adminRole._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_User}} {{SuiteCoreStringKey.Common_Role}} {{SuiteCoreStringKey.Common_ID}}: {userRoleId}', {
+            userRoleId: idToString(result.adminUserRole._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_Username}}: {username}', {
+            username: result.adminUsername,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_Email}}: {email}', {
+            email: result.adminEmail,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_Password}}: {password}', {
+            password: result.adminPassword,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_Mnemonic}}: {mnemonic}', {
+            mnemonic: result.adminMnemonic,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_PublicKey}}: {publicKey}', {
+            publicKey: result.adminUser.publicKey,
+        }));
+        (0, utils_1.directLog)(true, 'log', `${this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Admin}} {{SuiteCoreStringKey.Common_BackupCodes}}')}: ${result.adminBackupCodes.join(', ')}`);
+        (0, utils_1.directLog)(true, 'log', '');
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_ID}}: {id}', {
+            id: idToString(result.memberUser._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_Role}}: {roleName}', {
+            roleName: result.memberRole.name,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_Role}} {{SuiteCoreStringKey.Common_ID}}: {roleId}', {
+            roleId: idToString(result.memberRole._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_User}} {{SuiteCoreStringKey.Common_Role}} {{SuiteCoreStringKey.Common_ID}}: {userRoleId}', {
+            userRoleId: idToString(result.memberUserRole._id),
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_Username}}: {username}', {
+            username: result.memberUsername,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_Email}}: {email}', {
+            email: result.memberEmail,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_Password}}: {password}', {
+            password: result.memberPassword,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_Mnemonic}}: {mnemonic}', {
+            mnemonic: result.memberMnemonic,
+        }));
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_PublicKey}}: {publicKey}', {
+            publicKey: result.memberUser.publicKey,
+        }));
+        (0, utils_1.directLog)(true, 'log', `${this.defaultI18nTFunc('{{SuiteCoreStringKey.Common_Member}} {{SuiteCoreStringKey.Common_BackupCodes}}')}: ${result.memberBackupCodes.join(', ')}`);
+        (0, utils_1.directLog)(true, 'log', this.defaultI18nTFunc('\n=== {{SuiteCoreStringKey.Admin_EndCredentials}} ==='));
+        if (printDotEnv) {
+            (0, utils_1.directLog)(true, 'log', '');
+            (0, utils_1.debugLog)(true, 'log', this.defaultI18nTFunc('=== {{SuiteCoreStringKey.Admin_DotEnvFormat}} ==='));
+            (0, utils_1.directLog)(true, 'log', this.serverInitResultsToDotEnv(result, idToString));
+            (0, utils_1.debugLog)(true, 'log', this.defaultI18nTFunc('=== {{SuiteCoreStringKey.Admin_EndDotEnvFormat}} ==='));
+        }
+    }
+    static setEnvFromInitResults(result, idToString = (id) => String(id)) {
+        process.env['ADMIN_ID'] = idToString(result.adminUser._id);
+        process.env['ADMIN_PUBLIC_KEY'] = result.adminUser.publicKey;
+        process.env['ADMIN_MNEMONIC'] = result.adminMnemonic;
+        process.env['ADMIN_PASSWORD'] = result.adminPassword;
+        process.env['ADMIN_ROLE_ID'] = idToString(result.adminRole._id);
+        process.env['ADMIN_USER_ROLE_ID'] = idToString(result.adminUserRole._id);
+        //
+        process.env['MEMBER_ID'] = idToString(result.memberUser._id);
+        process.env['MEMBER_PUBLIC_KEY'] = result.memberUser.publicKey;
+        process.env['MEMBER_MNEMONIC'] = result.memberMnemonic;
+        process.env['MEMBER_PASSWORD'] = result.memberPassword;
+        process.env['MEMBER_ROLE_ID'] = idToString(result.memberRole._id);
+        process.env['MEMBER_USER_ROLE_ID'] = idToString(result.memberUserRole._id);
+        //
+        process.env['SYSTEM_ID'] = idToString(result.systemUser._id);
+        process.env['SYSTEM_PUBLIC_KEY'] = result.systemUser.publicKey;
+        process.env['SYSTEM_MNEMONIC'] = result.systemMnemonic;
+        process.env['SYSTEM_PASSWORD'] = result.systemPassword;
+        process.env['SYSTEM_ROLE_ID'] = idToString(result.systemRole._id);
+        process.env['SYSTEM_USER_ROLE_ID'] = idToString(result.systemUserRole._id);
+    }
+    /**
+     * Write initialization results to a .env file
+     * Updates or adds the credential variables in the specified .env file
+     * @param envFilePath Path to the .env file to update
+     * @param result The initialization results containing credentials
+     * @param idToString Function to convert IDs to strings
+     */
+    static writeEnvFile(envFilePath, result, idToString = (id) => String(id)) {
+        // Ensure the directory exists
+        const dir = path.dirname(envFilePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Read existing .env file or create empty content
+        let envContent = '';
+        if (fs.existsSync(envFilePath)) {
+            envContent = fs.readFileSync(envFilePath, 'utf-8');
+        }
+        // Define the credentials to update
+        const credentials = {
+            ADMIN_ID: idToString(result.adminUser._id),
+            ADMIN_MNEMONIC: result.adminMnemonic,
+            ADMIN_ROLE_ID: idToString(result.adminRole._id),
+            ADMIN_USER_ROLE_ID: idToString(result.adminUserRole._id),
+            ADMIN_PASSWORD: result.adminPassword,
+            MEMBER_ID: idToString(result.memberUser._id),
+            MEMBER_MNEMONIC: result.memberMnemonic,
+            MEMBER_ROLE_ID: idToString(result.memberRole._id),
+            MEMBER_USER_ROLE_ID: idToString(result.memberUserRole._id),
+            MEMBER_PASSWORD: result.memberPassword,
+            SYSTEM_ID: idToString(result.systemUser._id),
+            SYSTEM_MNEMONIC: result.systemMnemonic,
+            SYSTEM_PUBLIC_KEY: result.systemUser.publicKey,
+            SYSTEM_ROLE_ID: idToString(result.systemRole._id),
+            SYSTEM_USER_ROLE_ID: idToString(result.systemUserRole._id),
+            SYSTEM_PASSWORD: result.systemPassword,
+        };
+        // Update or add each credential
+        for (const [key, value] of Object.entries(credentials)) {
+            const regex = new RegExp(`^${key}=.*$`, 'm');
+            const newLine = `${key}="${value}"`;
+            if (regex.test(envContent)) {
+                // Update existing line
+                envContent = envContent.replace(regex, newLine);
+            }
+            else {
+                // Add new line (append to end)
+                if (envContent && !envContent.endsWith('\n')) {
+                    envContent += '\n';
+                }
+                envContent += newLine + '\n';
+            }
+        }
+        // Write back to file
+        fs.writeFileSync(envFilePath, envContent, 'utf-8');
+        (0, utils_1.debugLog)(true, 'log', this.defaultI18nTFunc('{{SuiteCoreStringKey.Admin_CredentialsWrittenToEnv}}', {
+            path: envFilePath,
+        }));
+    }
+    /**
+     * Initialize the user database with default users and roles (convenience method)
+     * This method creates the necessary services and calls initUserDbWithServices
+     * @param application The application
+     * @returns The result of the initialization
+     */
+    static async initUserDb(application, idGenerator, idToString = (id) => application.constants.idProvider.idToString(id)) {
+        const mnemonicModel = model_registry_1.ModelRegistry.instance.getTypedModel(base_model_name_1.BaseModelName.Mnemonic);
+        const mnemonicService = new mnemonic_1.MnemonicService(mnemonicModel, application.environment.mnemonicHmacSecret, application.constants);
+        const config = {
+            curveName: ecies_lib_1.ECIES.CURVE_NAME,
+            primaryKeyDerivationPath: ecies_lib_1.ECIES.PRIMARY_KEY_DERIVATION_PATH,
+            mnemonicStrength: ecies_lib_1.ECIES.MNEMONIC_STRENGTH,
+            symmetricAlgorithm: ecies_lib_1.ECIES.SYMMETRIC_ALGORITHM_CONFIGURATION,
+            symmetricKeyBits: ecies_lib_1.ECIES.SYMMETRIC.KEY_BITS,
+            symmetricKeyMode: ecies_lib_1.ECIES.SYMMETRIC.MODE,
+        };
+        const eciesService = new node_ecies_lib_1.ECIESService(config);
+        const roleService = new role_1.RoleService(application);
+        const keyWrappingService = new key_wrapping_1.KeyWrappingService();
+        const backupCodeService = new backup_code_2.BackupCodeService(application, eciesService, keyWrappingService, roleService);
+        return this.initUserDbWithServices(application, keyWrappingService, mnemonicService, eciesService, roleService, backupCodeService, idGenerator, idToString);
+    }
+}
+exports.DatabaseInitializationService = DatabaseInitializationService;
+//# sourceMappingURL=database-initialization.js.map