@realtek/core-theme 0.0.60 → 0.0.61

package/scripts/init-admin-mongodb.js

@@ -0,0 +1,788 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { MongoClient, ObjectId } from 'mongodb';
+
+const DEFAULT_MONGO_URI = 'mongodb://admin:e7cH06Dy2LK2@192.168.1.88:27017/znnxt?authSource=admin&authMechanism=SCRAM-SHA-256';
+const DEFAULT_ADMIN_EMAIL = 'admin@example.com';
+const DEFAULT_ADMIN_PASSWORD_HASH = '$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy';
+const HISTORY_COLLECTION = 'MONGO_MIGRATION_HISTORY';
+
+const DEFAULT_TENANT_ID = '93c782a4aa626175e5d11afa';
+const DEFAULT_BUSINESS_ID = '67ac80d40fd559c44345bd30';
+const DEFAULT_BUSINESS_UNIT_ID = '67ac811f0fd559c44345bd31';
+const DEFAULT_ADMIN_ROLE_ID = 5;
+const DEFAULT_ADMIN_USER_ID = 1;
+
+const PERMISSIONS = [
+  { legacyPermissionId: 31, permissionKey: 'view', permissionName: 'View' },
+  { legacyPermissionId: 32, permissionKey: 'add', permissionName: 'Add' },
+  { legacyPermissionId: 33, permissionKey: 'edit', permissionName: 'Edit' },
+  { legacyPermissionId: 34, permissionKey: 'delete', permissionName: 'Delete' },
+  { legacyPermissionId: 35, permissionKey: 'share', permissionName: 'Share' },
+  { legacyPermissionId: 36, permissionKey: 'approve', permissionName: 'Approve' },
+  { legacyPermissionId: 37, permissionKey: 'move_onboard', permissionName: 'Move Onboard' },
+];
+
+const SIDE_MENU_STRUCTURE = {
+  menu: [
+    { key: 'dashboard', icon: 'Dashboard', label: 'Dashboard', status: 'active' },
+    { key: 'jobs', icon: 'Jobs', label: 'Jobs', status: 'active' },
+    { key: 'candidates', icon: 'Candidates', label: 'Candidates', status: 'active' },
+    { key: 'submissions', icon: 'Submissions', label: 'Submissions', status: 'active' },
+    { key: 'onboarding', icon: 'onboarding', label: 'Onboarding', status: 'active' },
+    { key: 'assignments', icon: 'onboarding', label: 'Assignments', status: 'active' },
+    { key: 'timesheet', icon: 'timesheet', label: 'Timesheet', status: 'active' },
+    {
+      key: 'network',
+      icon: 'Network',
+      label: 'Network',
+      status: 'active',
+      children: [
+        { key: 'network/hotlist', icon: 'Hotlist', label: 'Hotlist', status: 'active' },
+        { key: 'network/vendors', icon: 'Vendors', label: 'Vendors', status: 'active' },
+      ],
+    },
+    { key: 'campaign', icon: 'campaign', label: 'Campaign', status: 'active' },
+    { key: 'scheduler', icon: 'Scheduler', label: 'Scheduler', status: 'inactive' },
+    { key: 'reports', icon: 'Reports', label: 'Reports', status: 'inactive' },
+    { key: 'test-cases', icon: 'test-cases', label: 'Test Cases', status: 'active' },
+    { key: 'admin', icon: 'Admin', label: 'Admin', status: 'active' },
+  ],
+  footermenu: [
+    {
+      key: 'settings',
+      icon: 'Settings',
+      label: 'Settings',
+      status: 'inactive',
+      children: [
+        { key: 'Font Size', icon: 'fontsize', label: 'fontsize', status: 'inactive' },
+      ],
+    },
+    { key: 'help', icon: 'Help', label: 'Help', status: 'inactive' },
+  ],
+};
+
+function flattenMenuStructure(menuStructure) {
+  const rows = [];
+  let legacyMenuId = 1;
+  const walk = (items, parentMenuId = null, placement = 'main') => {
+    for (const item of items) {
+      const currentMenuId = legacyMenuId;
+      rows.push({
+        legacyMenuId: currentMenuId,
+        parentMenuId,
+        menuKey: item.key,
+        menuName: item.label,
+        icon: item.icon,
+        status: item.status,
+        placement,
+      });
+      legacyMenuId += 1;
+      if (Array.isArray(item.children) && item.children.length > 0) {
+        walk(item.children, currentMenuId, placement);
+      }
+    }
+  };
+
+  walk(menuStructure.menu, null, 'main');
+  walk(menuStructure.footermenu, null, 'footer');
+  return rows;
+}
+
+const MENUS = flattenMenuStructure(SIDE_MENU_STRUCTURE);
+
+function parseArgs(argv) {
+  const options = {
+    postinstall: false,
+    skipPrompt: false,
+    dbName: process.env.MONGO_DB_NAME || process.env.MONGO_DATABASE || process.env.DB_NAME || '',
+    mongoUri: process.env.MONGO_URI || '',
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--postinstall') {
+      options.postinstall = true;
+    } else if (arg === '--yes' || arg === '-y') {
+      options.skipPrompt = true;
+    } else if (arg === '--db' || arg === '--db-name') {
+      options.dbName = argv[index + 1] || '';
+      index += 1;
+    } else if (arg.startsWith('--db=')) {
+      options.dbName = arg.slice('--db='.length);
+    } else if (arg === '--uri' || arg === '--mongo-uri') {
+      options.mongoUri = argv[index + 1] || '';
+      index += 1;
+    } else if (arg.startsWith('--uri=')) {
+      options.mongoUri = arg.slice('--uri='.length);
+    }
+  }
+
+  options.dbName = String(options.dbName || '').trim();
+  options.mongoUri = String(options.mongoUri || '').trim();
+  return options;
+}
+
+function log(message) {
+  console.log(`[core-theme:init-mongodb] ${message}`);
+}
+
+function parseEnvValue(value) {
+  const trimmed = String(value ?? '').trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function loadEnvFile(path) {
+  if (!existsSync(path)) return false;
+
+  const content = readFileSync(path, 'utf8');
+  content.split(/\r?\n/).forEach((line) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) return;
+
+    const equalIndex = trimmed.indexOf('=');
+    if (equalIndex <= 0) return;
+
+    const key = trimmed.slice(0, equalIndex).trim();
+    const value = parseEnvValue(trimmed.slice(equalIndex + 1));
+    if (!key || process.env[key] !== undefined) return;
+
+    process.env[key] = value;
+  });
+
+  return true;
+}
+
+function loadProjectEnv() {
+  const candidates = [
+    process.env.INIT_CWD,
+    process.cwd(),
+  ]
+    .filter(Boolean)
+    .map((directory) => resolvePath(directory, '.env'));
+
+  const loaded = [];
+  for (const path of Array.from(new Set(candidates))) {
+    if (loadEnvFile(path)) {
+      loaded.push(path);
+    }
+  }
+
+  return loaded;
+}
+
+async function promptForDbName(defaultDbName) {
+  const rl = createInterface({ input, output });
+  try {
+    const suffix = defaultDbName ? ` (${defaultDbName})` : '';
+    const answer = await rl.question(`Enter MongoDB database name${suffix}: `);
+    return answer.trim() || defaultDbName;
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptForMongoUri(defaultMongoUri) {
+  const rl = createInterface({ input, output });
+  try {
+    const suffix = defaultMongoUri ? ` (${defaultMongoUri})` : '';
+    const answer = await rl.question(`Enter MongoDB URI${suffix}: `);
+    return answer.trim() || defaultMongoUri;
+  } finally {
+    rl.close();
+  }
+}
+
+function validator(schema) {
+  return { $jsonSchema: schema };
+}
+
+async function createOrUpdateCollection(db, name, schema) {
+  const exists = await db.listCollections({ name }).hasNext();
+  const collectionValidator = validator(schema);
+
+  if (exists) {
+    await db.command({ collMod: name, validator: collectionValidator });
+    log(`COLLECTION UPDATED : ${name}`);
+    return;
+  }
+
+  await db.createCollection(name, { validator: collectionValidator });
+  log(`COLLECTION CREATED : ${name}`);
+}
+
+async function createIndex(collection, keys, options = {}) {
+  await collection.createIndex(keys, options);
+  const fields = Object.keys(keys).join(', ');
+  log(`INDEX READY        : ${collection.collectionName} (${fields})`);
+}
+
+async function upsertOne(collection, filter, update, label) {
+  const result = await collection.updateOne(filter, update, { upsert: true });
+  if (result.upsertedCount > 0) {
+    log(`SEEDED            : ${label}`);
+  } else if (result.modifiedCount > 0) {
+    log(`UPDATED           : ${label}`);
+  } else {
+    log(`UNCHANGED         : ${label}`);
+  }
+}
+
+async function syncCounter(db, collectionName, minimumValue) {
+  await db.collection('counters').updateOne(
+    { _id: collectionName },
+    { $max: { seq: minimumValue } },
+    { upsert: true },
+  );
+  log(`COUNTER READY     : ${collectionName} >= ${minimumValue}`);
+}
+
+async function createCollections(db) {
+  await createOrUpdateCollection(db, 'users', {
+    bsonType: 'object',
+    required: [
+      'legacyUserId',
+      'firstName',
+      'email',
+      'password',
+      'roleId',
+      'tenantId',
+      'businessId',
+      'businessUnitId',
+      'isLocked',
+      'status',
+      'permissionVersion',
+      'activeStatus',
+      'isDeleted',
+      'createdAt',
+      'updatedAt',
+    ],
+    properties: {
+      legacyUserId: { bsonType: ['int', 'long'] },
+      userName: { bsonType: ['string', 'null'] },
+      firstName: { bsonType: 'string' },
+      lastName: { bsonType: ['string', 'null'] },
+      email: { bsonType: 'string' },
+      password: { bsonType: 'string' },
+      roleId: { bsonType: ['int', 'long'] },
+      tenantId: { bsonType: 'objectId' },
+      businessId: { bsonType: 'objectId' },
+      businessUnitId: { bsonType: 'objectId' },
+      isLocked: { bsonType: 'bool' },
+      invalidAttempts: { bsonType: ['int', 'long', 'null'] },
+      activeStatus: { bsonType: 'bool' },
+      isDeleted: { bsonType: 'bool' },
+      status: { bsonType: ['int', 'long'] },
+      permissionVersion: { bsonType: ['int', 'long'] },
+      verified: { bsonType: ['string', 'null'] },
+      createdBy: { bsonType: ['int', 'long', 'null'] },
+      updatedBy: { bsonType: ['int', 'long', 'null'] },
+      createdAt: { bsonType: 'date' },
+      updatedAt: { bsonType: 'date' },
+    },
+  });
+
+  await createOrUpdateCollection(db, 'menus', {
+    bsonType: 'object',
+    required: ['legacyMenuId', 'menuKey', 'menuName', 'status', 'isDeleted', 'createdAt', 'updatedAt'],
+    properties: {
+      legacyMenuId: { bsonType: ['int', 'long'] },
+      parentMenuId: { bsonType: ['int', 'long', 'null'] },
+      menuKey: { bsonType: 'string' },
+      menuName: { bsonType: 'string' },
+      icon: { bsonType: ['string', 'null'] },
+      placement: { enum: ['main', 'footer'] },
+      status: { enum: ['active', 'inactive'] },
+      isDeleted: { bsonType: 'bool' },
+      createdBy: { bsonType: ['int', 'long', 'null'] },
+      updatedBy: { bsonType: ['int', 'long', 'null'] },
+      createdAt: { bsonType: 'date' },
+      updatedAt: { bsonType: 'date' },
+    },
+  });
+
+  await createOrUpdateCollection(db, 'permissions', {
+    bsonType: 'object',
+    required: ['legacyPermissionId', 'permissionKey', 'permissionName', 'status', 'isDeleted', 'createdAt', 'updatedAt'],
+    properties: {
+      legacyPermissionId: { bsonType: ['int', 'long'] },
+      permissionKey: { bsonType: 'string' },
+      permissionName: { bsonType: 'string' },
+      status: { enum: ['ACTIVE', 'INACTIVE'] },
+      isDeleted: { bsonType: 'bool' },
+      createdBy: { bsonType: ['int', 'long', 'null'] },
+      updatedBy: { bsonType: ['int', 'long', 'null'] },
+      createdAt: { bsonType: 'date' },
+      updatedAt: { bsonType: 'date' },
+    },
+  });
+
+  await createOrUpdateCollection(db, 'roles', {
+    bsonType: 'object',
+    required: ['legacyRoleId', 'roleId', 'roleName', 'tenantId', 'businessId', 'businessUnitId', 'isDeleted', 'createdAt', 'updatedAt'],
+    properties: {
+      legacyId: { bsonType: ['int', 'long'] },
+      legacyRoleId: { bsonType: ['int', 'long'] },
+      roleId: { bsonType: ['int', 'long'] },
+      roleName: { bsonType: 'string' },
+      tenantId: { bsonType: 'objectId' },
+      businessId: { bsonType: 'objectId' },
+      businessUnitId: { bsonType: 'objectId' },
+      status: { bsonType: ['int', 'long'] },
+      isDeleted: { bsonType: 'bool' },
+      createdBy: { bsonType: ['int', 'long', 'null'] },
+      updatedBy: { bsonType: ['int', 'long', 'null'] },
+      createdAt: { bsonType: 'date' },
+      updatedAt: { bsonType: 'date' },
+    },
+  });
+
+  const mappingSchema = {
+    bsonType: 'object',
+    required: ['legacyMapId', 'roleId', 'menuId', 'permissions', 'tenantId', 'businessId', 'businessUnitId', 'isDeleted', 'createdAt', 'updatedAt'],
+    properties: {
+      legacyMapId: { bsonType: ['int', 'long'] },
+      userId: { bsonType: ['int', 'long', 'null'] },
+      roleId: { bsonType: ['int', 'long'] },
+      menuId: { bsonType: ['int', 'long'] },
+      permissionId: { bsonType: ['int', 'long', 'null'] },
+      accessValue: { bsonType: ['string', 'null'] },
+      permissions: { bsonType: 'object' },
+      tenantId: { bsonType: 'objectId' },
+      businessId: { bsonType: 'objectId' },
+      businessUnitId: { bsonType: 'objectId' },
+      status: { bsonType: ['int', 'long'] },
+      isDeleted: { bsonType: 'bool' },
+      createdBy: { bsonType: ['int', 'long', 'null'] },
+      updatedBy: { bsonType: ['int', 'long', 'null'] },
+      createdAt: { bsonType: 'date' },
+      updatedAt: { bsonType: 'date' },
+    },
+  };
+
+  await createOrUpdateCollection(db, 'role_menu_permissions', mappingSchema);
+  await createOrUpdateCollection(db, 'user_menu_permissions', mappingSchema);
+
+  await createOrUpdateCollection(db, 'menu_structures', {
+    bsonType: 'object',
+    required: ['roleId', 'menuStructure', 'tenantId', 'businessId', 'businessUnitId', 'isDeleted', 'createdAt', 'updatedAt'],
+    properties: {
+      roleId: { bsonType: ['int', 'long'] },
+      menuStructure: { bsonType: 'object' },
+      tenantId: { bsonType: 'objectId' },
+      businessId: { bsonType: 'objectId' },
+      businessUnitId: { bsonType: 'objectId' },
+      status: { bsonType: ['int', 'long'] },
+      isDeleted: { bsonType: 'bool' },
+      createdBy: { bsonType: ['int', 'long', 'null'] },
+      updatedBy: { bsonType: ['int', 'long', 'null'] },
+      createdAt: { bsonType: 'date' },
+      updatedAt: { bsonType: 'date' },
+    },
+  });
+}
+
+async function createIndexes(db) {
+  await createIndex(db.collection('users'), { userName: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('users'), { email: 1 }, { unique: true });
+  await createIndex(db.collection('users'), { legacyUserId: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('users'), { roleId: 1 });
+  await createIndex(db.collection('roles'), { legacyRoleId: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('roles'), { roleId: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('roles'), { roleName: 1 });
+  await createIndex(db.collection('menus'), { legacyMenuId: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('menus'), { menuKey: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('menus'), { parentMenuId: 1 });
+  await createIndex(db.collection('permissions'), { legacyPermissionId: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('permissions'), { permissionKey: 1 }, { unique: true, sparse: true });
+  await createIndex(db.collection('role_menu_permissions'), { roleId: 1, menuId: 1 }, { unique: true });
+  await createIndex(db.collection('role_menu_permissions'), { legacyMapId: 1 }, { unique: true });
+  await createIndex(db.collection('user_menu_permissions'), { userId: 1, roleId: 1, menuId: 1 }, { unique: true });
+  await createIndex(db.collection('user_menu_permissions'), { legacyMapId: 1 }, { unique: true });
+  await createIndex(db.collection('menu_structures'), { roleId: 1 }, { unique: true });
+}
+
+async function seedPermissions(db) {
+  const timestamp = new Date();
+  for (const permission of PERMISSIONS) {
+    await upsertOne(
+      db.collection('permissions'),
+      { legacyPermissionId: permission.legacyPermissionId },
+      {
+        $set: {
+          permissionKey: permission.permissionKey,
+          permissionName: permission.permissionName,
+          status: 'ACTIVE',
+          isDeleted: false,
+          updatedAt: timestamp,
+        },
+        $setOnInsert: {
+          legacyPermissionId: permission.legacyPermissionId,
+          migrationSource: 'core-theme-admin.seed',
+          createdBy: 1,
+          createdAt: timestamp,
+        },
+      },
+      `permissions.${permission.permissionKey}`,
+    );
+  }
+  await syncCounter(db, 'permissions', Math.max(...PERMISSIONS.map((permission) => permission.legacyPermissionId)));
+}
+
+async function seedMenus(db) {
+  const timestamp = new Date();
+  for (const menu of MENUS) {
+    await upsertOne(
+      db.collection('menus'),
+      { legacyMenuId: menu.legacyMenuId },
+      {
+        $set: {
+          parentMenuId: menu.parentMenuId,
+          menuKey: menu.menuKey,
+          menuName: menu.menuName,
+          icon: menu.icon,
+          placement: menu.placement,
+          status: menu.status,
+          isDeleted: false,
+          updatedAt: timestamp,
+        },
+        $setOnInsert: {
+          legacyMenuId: menu.legacyMenuId,
+          migrationSource: 'core-theme-admin.seed',
+          createdBy: 1,
+          createdAt: timestamp,
+        },
+      },
+      `menus.${menu.menuKey}`,
+    );
+  }
+  await syncCounter(db, 'menus', MENUS.length);
+}
+
+async function seedRoles(db) {
+  const timestamp = new Date();
+  const tenantId = new ObjectId(process.env.DEFAULT_TENANT_ID || DEFAULT_TENANT_ID);
+  const businessId = new ObjectId(process.env.DEFAULT_BUSINESS_ID || DEFAULT_BUSINESS_ID);
+  const businessUnitId = new ObjectId(process.env.DEFAULT_BUSINESS_UNIT_ID || DEFAULT_BUSINESS_UNIT_ID);
+
+  await upsertOne(
+    db.collection('roles'),
+    { legacyRoleId: DEFAULT_ADMIN_ROLE_ID },
+    {
+      $set: {
+        legacyId: DEFAULT_ADMIN_ROLE_ID,
+        roleId: DEFAULT_ADMIN_ROLE_ID,
+        roleName: 'ADMIN',
+        roleDescription: 'Core theme package admin',
+        roleType: 0,
+        customRoleId: 0,
+        reportingRoleId: 0,
+        orgId: 0,
+        tenantId,
+        businessId,
+        businessUnitId,
+        status: 1,
+        isDeleted: false,
+        updatedBy: 1,
+        updatedAt: timestamp,
+      },
+      $setOnInsert: {
+        migrationSource: 'core-theme-admin.seed',
+        createdBy: 1,
+        createdAt: timestamp,
+      },
+    },
+    'roles.ADMIN',
+  );
+
+  await syncCounter(db, 'roles', DEFAULT_ADMIN_ROLE_ID);
+  return db.collection('roles').findOne({ legacyRoleId: DEFAULT_ADMIN_ROLE_ID });
+}
+
+async function seedAdminUser(db) {
+  const timestamp = new Date();
+  const adminEmail = process.env.ADMIN_EMAIL || DEFAULT_ADMIN_EMAIL;
+  const adminPasswordHash = process.env.ADMIN_PASSWORD_HASH || DEFAULT_ADMIN_PASSWORD_HASH;
+  const tenantId = new ObjectId(process.env.DEFAULT_TENANT_ID || DEFAULT_TENANT_ID);
+  const businessId = new ObjectId(process.env.DEFAULT_BUSINESS_ID || DEFAULT_BUSINESS_ID);
+  const businessUnitId = new ObjectId(process.env.DEFAULT_BUSINESS_UNIT_ID || DEFAULT_BUSINESS_UNIT_ID);
+
+  await upsertOne(
+    db.collection('users'),
+    {
+      $or: [
+        { legacyUserId: DEFAULT_ADMIN_USER_ID },
+        { email: adminEmail },
+        { userName: 'admin' },
+        { username: 'admin' },
+      ],
+    },
+    {
+      $set: {
+        userName: 'admin',
+        nameTitle: '',
+        firstName: 'admin',
+        lastName: '',
+        email: adminEmail,
+        password: adminPasswordHash,
+        roleId: DEFAULT_ADMIN_ROLE_ID,
+        tenantId,
+        businessId,
+        businessUnitId,
+        reportingId: 0,
+        teamId: 0,
+        orgId: 0,
+        gender: 0,
+        location: '',
+        mobileNumber: '',
+        officeNumber: null,
+        phoneExtension: '',
+        phoneNumber: '',
+        photo: { uploadName: '', uniqueName: '', location: '' },
+        socialProfiles: null,
+        defaultValues: null,
+        userType: null,
+        verified: 'OTP_VERIFIED',
+        activeStatus: true,
+        isLocked: false,
+        invalidAttempts: 0,
+        isDeleted: false,
+        status: 1,
+        permissionVersion: 1,
+        lastLoginAt: timestamp,
+        pwdLastChangedAt: timestamp,
+        updatedAt: timestamp,
+        updatedBy: 1,
+      },
+      $setOnInsert: {
+        legacyUserId: DEFAULT_ADMIN_USER_ID,
+        migrationSource: 'core-theme-admin.seed',
+        createdBy: 1,
+        createdAt: timestamp,
+      },
+    },
+    `users.admin (${adminEmail})`,
+  );
+
+  await syncCounter(db, 'users', 1);
+  return db.collection('users').findOne({
+    $or: [
+      { legacyUserId: DEFAULT_ADMIN_USER_ID },
+      { email: adminEmail },
+      { userName: 'admin' },
+      { username: 'admin' },
+    ],
+  });
+}
+
+function allEnabledPermissions() {
+  return Object.fromEntries(PERMISSIONS.map((permission) => [permission.permissionKey, true]));
+}
+
+async function seedRoleMenuPermissions(db) {
+  const timestamp = new Date();
+  const tenantId = new ObjectId(process.env.DEFAULT_TENANT_ID || DEFAULT_TENANT_ID);
+  const businessId = new ObjectId(process.env.DEFAULT_BUSINESS_ID || DEFAULT_BUSINESS_ID);
+  const businessUnitId = new ObjectId(process.env.DEFAULT_BUSINESS_UNIT_ID || DEFAULT_BUSINESS_UNIT_ID);
+  const menus = await db.collection('menus').find({ isDeleted: false }).sort({ legacyMenuId: 1 }).toArray();
+
+  for (const menu of menus) {
+    await upsertOne(
+      db.collection('role_menu_permissions'),
+      { roleId: DEFAULT_ADMIN_ROLE_ID, menuId: menu.legacyMenuId },
+      {
+        $set: {
+          roleId: DEFAULT_ADMIN_ROLE_ID,
+          menuId: menu.legacyMenuId,
+          permissionId: null,
+          accessValue: null,
+          permissions: allEnabledPermissions(),
+          tenantId,
+          businessId,
+          businessUnitId,
+          status: 1,
+          isDeleted: false,
+          updatedBy: 1,
+          updatedAt: timestamp,
+        },
+        $setOnInsert: {
+          legacyMapId: menu.legacyMenuId,
+          migrationSource: 'core-theme-admin.seed',
+          createdBy: 1,
+          createdAt: timestamp,
+        },
+      },
+      `role_menu_permissions.ADMIN.${menu.menuKey}`,
+    );
+  }
+
+  await syncCounter(db, 'role_menu_permissions', MENUS.length);
+}
+
+async function seedUserMenuPermissions(db, adminUser) {
+  const timestamp = new Date();
+  const tenantId = new ObjectId(process.env.DEFAULT_TENANT_ID || DEFAULT_TENANT_ID);
+  const businessId = new ObjectId(process.env.DEFAULT_BUSINESS_ID || DEFAULT_BUSINESS_ID);
+  const businessUnitId = new ObjectId(process.env.DEFAULT_BUSINESS_UNIT_ID || DEFAULT_BUSINESS_UNIT_ID);
+  const menus = await db.collection('menus').find({ isDeleted: false }).sort({ legacyMenuId: 1 }).toArray();
+
+  for (const menu of menus) {
+    await upsertOne(
+      db.collection('user_menu_permissions'),
+      { userId: adminUser.legacyUserId, roleId: DEFAULT_ADMIN_ROLE_ID, menuId: menu.legacyMenuId },
+      {
+        $set: {
+          userId: adminUser.legacyUserId,
+          roleId: DEFAULT_ADMIN_ROLE_ID,
+          menuId: menu.legacyMenuId,
+          permissionId: null,
+          accessValue: null,
+          permissions: allEnabledPermissions(),
+          tenantId,
+          businessId,
+          businessUnitId,
+          status: 1,
+          isDeleted: false,
+          updatedBy: 1,
+          updatedAt: timestamp,
+        },
+        $setOnInsert: {
+          legacyMapId: menu.legacyMenuId,
+          migrationSource: 'core-theme-admin.seed',
+          createdBy: 1,
+          createdAt: timestamp,
+        },
+      },
+      `user_menu_permissions.admin.${menu.menuKey}`,
+    );
+  }
+
+  await syncCounter(db, 'user_menu_permissions', MENUS.length);
+}
+
+async function seedMenuStructure(db) {
+  const timestamp = new Date();
+  const tenantId = new ObjectId(process.env.DEFAULT_TENANT_ID || DEFAULT_TENANT_ID);
+  const businessId = new ObjectId(process.env.DEFAULT_BUSINESS_ID || DEFAULT_BUSINESS_ID);
+  const businessUnitId = new ObjectId(process.env.DEFAULT_BUSINESS_UNIT_ID || DEFAULT_BUSINESS_UNIT_ID);
+
+  await upsertOne(
+    db.collection('menu_structures'),
+    { roleId: DEFAULT_ADMIN_ROLE_ID },
+    {
+      $set: {
+        roleId: DEFAULT_ADMIN_ROLE_ID,
+        menuStructure: SIDE_MENU_STRUCTURE,
+        tenantId,
+        businessId,
+        businessUnitId,
+        status: 1,
+        isDeleted: false,
+        updatedBy: 1,
+        updatedAt: timestamp,
+      },
+      $setOnInsert: {
+        migrationSource: 'core-theme-admin.seed',
+        createdBy: 1,
+        createdAt: timestamp,
+      },
+    },
+    'menu_structures.ADMIN',
+  );
+}
+
+async function markHistory(db) {
+  await db.collection(HISTORY_COLLECTION).updateOne(
+    { migrationName: 'core-theme-admin-mongodb-seed' },
+    {
+      $set: {
+        executedAt: new Date(),
+        status: 'SUCCESS',
+      },
+      $setOnInsert: {
+        migrationName: 'core-theme-admin-mongodb-seed',
+      },
+    },
+    { upsert: true },
+  );
+  log(`HISTORY READY     : ${HISTORY_COLLECTION}`);
+}
+
+async function initializeDatabase({ mongoUri, dbName }) {
+  const client = new MongoClient(mongoUri);
+  await client.connect();
+
+  try {
+    await client.db('admin').command({ ping: 1 });
+    log(`CONNECTED         : ${mongoUri}`);
+    const db = client.db(dbName);
+    log(`DATABASE          : ${dbName}`);
+
+    await createCollections(db);
+    await createIndexes(db);
+    await seedPermissions(db);
+    await seedMenus(db);
+    await seedRoles(db);
+    const adminUser = await seedAdminUser(db);
+    await seedRoleMenuPermissions(db);
+    await seedUserMenuPermissions(db, adminUser);
+    await seedMenuStructure(db);
+    await markHistory(db);
+
+    log(`SUPER ADMIN READY : ${adminUser.email}`);
+    log('DEFAULT LOGIN     : admin@example.com / password');
+  } finally {
+    await client.close();
+  }
+}
+
+async function main() {
+  const loadedEnvFiles = loadProjectEnv();
+  const options = parseArgs(process.argv.slice(2));
+
+  if (process.env.CORE_THEME_SKIP_DB_INIT === '1') {
+    log('SKIPPED           : CORE_THEME_SKIP_DB_INIT=1');
+    return;
+  }
+
+  if (options.postinstall && !process.stdin.isTTY && !options.dbName) {
+    log('SKIPPED           : npm install is not interactive');
+    log('RUN MANUALLY      : npx core-theme-init-mongodb --db <databaseName>');
+    log('OR INSTALL WITH   : MONGO_DB_NAME=<databaseName> npm install @realtek/core-theme');
+    return;
+  }
+
+  const mongoUri = options.mongoUri || (
+    options.skipPrompt
+      ? DEFAULT_MONGO_URI
+      : await promptForMongoUri(DEFAULT_MONGO_URI)
+  );
+  const dbName = options.dbName || (options.skipPrompt ? '' : await promptForDbName(options.dbName));
+  if (!mongoUri) {
+    throw new Error('MongoDB URI is required. Use --uri <mongoUri> or MONGO_URI.');
+  }
+  if (!dbName) {
+    throw new Error('MongoDB database name is required. Use --db <databaseName> or MONGO_DB_NAME.');
+  }
+
+  log('STARTING MONGODB ADMIN SEED');
+  loadedEnvFiles.forEach((path) => log(`ENV LOADED        : ${path}`));
+  await initializeDatabase({ mongoUri, dbName });
+  log('MONGODB ADMIN SEED COMPLETED');
+}
+
+main().catch((error) => {
+  console.error(`[core-theme:init-mongodb] FAILED            : ${error.message}`);
+  process.exitCode = 1;
+});