procbay-schema 1.0.0

package/prisma/seeders/test-core-seeders.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for optimized core data seeders
+ * Validates the new batch processing, retry logic, and progress tracking features
+ */
+
+import { PrismaClient } from '../../src/prisma/index.js';
+import { seedUsers } from './user.seed.js';
+import { seedRoles } from './role.seed.js';
+import { seedPermissions } from './permission.seed.js';
+import { seedDepartments } from './department.seed.js';
+import { seedCurrencies } from './currency.seed.js';
+import colors from 'colors';
+
+const prisma = new PrismaClient({
+  log: [
+    { level: 'query', emit: 'event' },
+    { level: 'error', emit: 'stdout' },
+  ],
+});
+
+// Query counter for performance monitoring
+let queryCount = 0;
+prisma.$on('query', () => {
+  queryCount++;
+});
+
+/**
+ * Test configuration for monitoring seeder performance
+ */
+const testConfig = {
+  enableTiming: true,
+  enableMemoryMonitoring: true,
+  enableQueryCounting: true,
+  logDetailedResults: true
+};
+
+/**
+ * Performance monitoring utility
+ */
+class PerformanceMonitor {
+  constructor(entityName) {
+    this.entityName = entityName;
+    this.startTime = Date.now();
+    this.startMemory = process.memoryUsage();
+    this.startQueryCount = queryCount;
+  }
+
+  complete() {
+    const endTime = Date.now();
+    const endMemory = process.memoryUsage();
+    const endQueryCount = queryCount;
+
+    const duration = (endTime - this.startTime) / 1000;
+    const memoryDelta = {
+      rss: (endMemory.rss - this.startMemory.rss) / 1024 / 1024,
+      heapUsed: (endMemory.heapUsed - this.startMemory.heapUsed) / 1024 / 1024,
+      heapTotal: (endMemory.heapTotal - this.startMemory.heapTotal) / 1024 / 1024
+    };
+    const queryDelta = endQueryCount - this.startQueryCount;
+
+    return {
+      entityName: this.entityName,
+      duration,
+      memoryDelta,
+      queryDelta,
+      finalMemory: {
+        rss: endMemory.rss / 1024 / 1024,
+        heapUsed: endMemory.heapUsed / 1024 / 1024,
+        heapTotal: endMemory.heapTotal / 1024 / 1024
+      }
+    };
+  }
+}
+
+/**
+ * Test a single core seeder with performance monitoring
+ */
+async function testSeeder(seederFunction, entityName) {
+  console.log(colors.cyan(`\n🧪 Testing ${entityName} seeder...`));
+  
+  const monitor = new PerformanceMonitor(entityName);
+  
+  try {
+    const result = await seederFunction(prisma);
+    const performance = monitor.complete();
+    
+    // Log results
+    if (testConfig.logDetailedResults) {
+      console.log(colors.green(`✅ ${entityName} seeder completed successfully`));
+      
+      if (result && typeof result === 'object') {
+        console.log(colors.gray(`   📊 Results:`));
+        console.log(colors.gray(`      - Total processed: ${result.totalProcessed || 'N/A'}`));
+        console.log(colors.gray(`      - Total created: ${result.totalCreated || 'N/A'}`));
+        console.log(colors.gray(`      - Total updated: ${result.totalUpdated || 'N/A'}`));
+        console.log(colors.gray(`      - Errors: ${result.errors?.length || 0}`));
+        
+        if (result.config) {
+          console.log(colors.gray(`   ⚙️  Configuration:`));
+          console.log(colors.gray(`      - Batch size: ${result.config.batchSize}`));
+          console.log(colors.gray(`      - Max concurrent batches: ${result.config.maxConcurrentBatches}`));
+          console.log(colors.gray(`      - Retry attempts: ${result.config.retryAttempts}`));
+        }
+      }
+      
+      if (testConfig.enableTiming) {
+        console.log(colors.gray(`   ⏱️  Duration: ${performance.duration.toFixed(2)}s`));
+      }
+      
+      if (testConfig.enableQueryCounting) {
+        console.log(colors.gray(`   🔍 Queries executed: ${performance.queryDelta}`));
+      }
+      
+      if (testConfig.enableMemoryMonitoring) {
+        console.log(colors.gray(`   💾 Memory delta (MB):`));
+        console.log(colors.gray(`      - RSS: ${performance.memoryDelta.rss.toFixed(2)}`));
+        console.log(colors.gray(`      - Heap Used: ${performance.memoryDelta.heapUsed.toFixed(2)}`));
+        console.log(colors.gray(`      - Heap Total: ${performance.memoryDelta.heapTotal.toFixed(2)}`));
+      }
+    }
+    
+    return { success: true, performance, result };
+  } catch (error) {
+    const performance = monitor.complete();
+    
+    console.log(colors.red(`❌ ${entityName} seeder failed`));
+    console.log(colors.red(`   Error: ${error.message}`));
+    
+    if (testConfig.enableTiming) {
+      console.log(colors.gray(`   ⏱️  Duration before failure: ${performance.duration.toFixed(2)}s`));
+    }
+    
+    return { success: false, performance, error: error.message };
+  }
+}
+
+/**
+ * Run comprehensive test of all core seeders
+ */
+async function runCoreSeederTests() {
+  console.log(colors.bold.cyan('\n🚀 CORE SEEDER OPTIMIZATION TEST'));
+  console.log(colors.gray('Testing optimized core data seeders with batch processing and retry logic\n'));
+  
+  const startTime = Date.now();
+  const startMemory = process.memoryUsage();
+  const startQueryCount = queryCount;
+  
+  // Define test sequence (order matters for dependencies)
+  const testSequence = [
+    { name: 'Departments', seeder: seedDepartments },
+    { name: 'Currencies', seeder: seedCurrencies },
+    { name: 'Users', seeder: seedUsers },
+    { name: 'Roles', seeder: seedRoles },
+    { name: 'Permissions', seeder: seedPermissions }
+  ];
+  
+  const results = [];
+  let totalErrors = 0;
+  
+  // Run each seeder test
+  for (const test of testSequence) {
+    const testResult = await testSeeder(test.seeder, test.name);
+    results.push(testResult);
+    
+    if (!testResult.success) {
+      totalErrors++;
+    }
+    
+    // Small delay between tests to allow for cleanup
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+  
+  // Calculate overall performance
+  const totalTime = (Date.now() - startTime) / 1000;
+  const totalMemory = process.memoryUsage();
+  const totalMemoryDelta = {
+    rss: (totalMemory.rss - startMemory.rss) / 1024 / 1024,
+    heapUsed: (totalMemory.heapUsed - startMemory.heapUsed) / 1024 / 1024
+  };
+  const totalQueryDelta = queryCount - startQueryCount;
+  
+  // Print summary
+  console.log(colors.bold.cyan('\n📈 TEST SUMMARY'));
+  console.log(colors.gray('═'.repeat(60)));
+  
+  console.log(colors.green(`✅ Successful seeders: ${results.filter(r => r.success).length}/${results.length}`));
+  console.log(colors.red(`❌ Failed seeders: ${totalErrors}`));
+  console.log(colors.gray(`⏱️  Total time: ${totalTime.toFixed(2)}s`));
+  console.log(colors.gray(`🔍 Total queries: ${totalQueryDelta}`));
+  console.log(colors.gray(`💾 Total memory delta: ${totalMemoryDelta.rss.toFixed(2)} MB RSS, ${totalMemoryDelta.heapUsed.toFixed(2)} MB Heap`));
+  
+  // Performance analysis
+  const avgTimePerSeeder = totalTime / results.length;
+  const avgQueriesPerSeeder = totalQueryDelta / results.length;
+  
+  console.log(colors.cyan('\n📊 PERFORMANCE ANALYSIS'));
+  console.log(colors.gray(`⏱️  Average time per seeder: ${avgTimePerSeeder.toFixed(2)}s`));
+  console.log(colors.gray(`🔍 Average queries per seeder: ${avgQueriesPerSeeder.toFixed(0)}`));
+  
+  // Individual performance breakdown
+  console.log(colors.cyan('\n🔍 INDIVIDUAL PERFORMANCE'));
+  results.forEach(result => {
+    const status = result.success ? colors.green('✅') : colors.red('❌');
+    const timing = result.performance.duration.toFixed(2) + 's';
+    const queries = result.performance.queryDelta;
+    const memory = result.performance.memoryDelta.heapUsed.toFixed(1) + 'MB';
+    
+    console.log(`${status} ${result.performance.entityName.padEnd(12)} - ${timing.padStart(8)} | ${queries.toString().padStart(3)} queries | ${memory.padStart(8)} heap`);
+  });
+  
+  // Optimization recommendations
+  console.log(colors.cyan('\n💡 OPTIMIZATION INSIGHTS'));
+  
+  const slowestSeeder = results.reduce((prev, current) => 
+    (prev.performance.duration > current.performance.duration) ? prev : current
+  );
+  
+  const mostQueriesSeeder = results.reduce((prev, current) => 
+    (prev.performance.queryDelta > current.performance.queryDelta) ? prev : current
+  );
+  
+  console.log(colors.yellow(`⚠️  Slowest seeder: ${slowestSeeder.performance.entityName} (${slowestSeeder.performance.duration.toFixed(2)}s)`));
+  console.log(colors.yellow(`⚠️  Most queries: ${mostQueriesSeeder.performance.entityName} (${mostQueriesSeeder.performance.queryDelta} queries)`));
+  
+  if (totalMemoryDelta.heapUsed > 50) {
+    console.log(colors.yellow(`⚠️  High memory usage detected: ${totalMemoryDelta.heapUsed.toFixed(2)} MB heap increase`));
+    console.log(colors.gray('   Consider reducing batch sizes or enabling more aggressive garbage collection'));
+  }
+  
+  // Final status
+  if (totalErrors === 0) {
+    console.log(colors.bold.green('\n🎉 ALL CORE SEEDERS PASSED! Optimizations are working correctly.'));
+  } else {
+    console.log(colors.bold.red(`\n💥 ${totalErrors} SEEDER(S) FAILED. Check the error messages above.`));
+  }
+  
+  return {
+    success: totalErrors === 0,
+    totalTime,
+    totalErrors,
+    results
+  };
+}
+
+/**
+ * Main test execution
+ */
+async function main() {
+  try {
+    const testResults = await runCoreSeederTests();
+    
+    if (testResults.success) {
+      console.log(colors.bold.green('\n✅ Core seeder optimization test completed successfully!'));
+      process.exit(0);
+    } else {
+      console.log(colors.bold.red('\n❌ Core seeder optimization test completed with errors!'));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(colors.red('\n💥 Test execution failed:'));
+    console.error(colors.red(error.message));
+    console.error(colors.gray(error.stack));
+    process.exit(1);
+  } finally {
+    await prisma.$disconnect();
+  }
+}
+
+// Run tests if this script is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export { runCoreSeederTests };

package/prisma/seeders/user-department.seed.js

@@ -0,0 +1,66 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadCoreData } from "./utils/json-loader.js";
+import {
+  createProgressTracker,
+  logSeederStart,
+  logSeederComplete,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+
+export async function seedUserDepartments(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("user departments");
+
+  // Load user-departments from JSON
+  const userDepartmentData = loadCoreData("user-departments");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(
+    userDepartmentData.length,
+    "user departments"
+  );
+
+  for (const userDepartment of userDepartmentData) {
+    try {
+      await prisma.userDepartment.upsert({
+        where: {
+          id: userDepartment.id,
+        },
+        update: {
+          user_id: userDepartment.user_id,
+          department_id: userDepartment.department_id,
+          created_at: new Date(userDepartment.created_at),
+          created_by: userDepartment.created_by,
+          updated_at: new Date(userDepartment.updated_at),
+          updated_by: userDepartment.updated_by,
+        },
+        create: {
+          id: userDepartment.id,
+          user_id: userDepartment.user_id,
+          department_id: userDepartment.department_id,
+          created_at: new Date(userDepartment.created_at),
+          created_by: userDepartment.created_by,
+          updated_at: new Date(userDepartment.updated_at),
+          updated_by: userDepartment.updated_by,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError(
+        "user department",
+        `ID: ${userDepartment.id}`,
+        error.message
+      );
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("User departments");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/user-event-configuration.seed.js

@@ -0,0 +1,47 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadCoreData } from "./utils/json-loader.js";
+import { seedCoreEntity } from "./utils/core-seeder.js";
+
+export const seedUserEventConfigurations = async (prismaClient) => {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  try {
+    // Load user event configuration data from JSON
+    const userEventConfigurations = loadCoreData("user-event-configuration");
+
+    // Process user event configurations with optimized core seeder
+    const result = await seedCoreEntity(
+      prisma,
+      userEventConfigurations,
+      "user event configurations",
+      {
+        model: "userEventConfiguration",
+        whereField: "slug",
+        updateFields: ["name", "is_active", "is_editable", "created_by"],
+        createFields: [
+          "name",
+          "slug",
+          "is_active",
+          "is_editable",
+          "created_by",
+        ],
+      },
+      {
+        profile: "stability", // User event configurations are core entities
+        enableRetries: true,
+        logProgress: true,
+      }
+    );
+
+    return result;
+  } catch (error) {
+    console.error(`Failed to seed user event configurations: ${error.message}`);
+    throw error;
+  } finally {
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+};

package/prisma/seeders/user-role.seed.js

@@ -0,0 +1,74 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { CURRENT_ADMIN_USER_EMAIL } from "./utils/config.js";
+import {
+  logSeederStart,
+  logSeederComplete,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+
+export async function seedUserRole(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("user role");
+
+  const admin = await prisma.user.findFirst({
+    where: { email_id: CURRENT_ADMIN_USER_EMAIL },
+  });
+
+  if (!admin) {
+    console.log(
+      `Warning: Admin user with email ${CURRENT_ADMIN_USER_EMAIL} not found. Skipping user role assignment.`
+    );
+    logSeederComplete("User role");
+    return;
+  }
+
+  const adminRole = await prisma.role.findFirst({
+    where: { slug: "super_admin" },
+  });
+
+  if (!adminRole) {
+    console.log(
+      `Warning: Super admin role not found. Skipping user role assignment.`
+    );
+    logSeederComplete("User role");
+    return;
+  }
+
+  const userRole = await prisma.userRole.findFirst({
+    where: { user_id: admin.id },
+  });
+
+  if (userRole === null) {
+    console.log(
+      `Assigning role ${adminRole.role_name} to user ${
+        admin.name || admin.email_id
+      }`
+    );
+    try {
+      await prisma.userRole.create({
+        data: {
+          user_id: admin.id,
+          role_id: adminRole.id,
+        },
+      });
+      console.log(`Role assigned successfully`);
+    } catch (error) {
+      logEntityError("user role", admin.email_id, error.message);
+    }
+  } else {
+    console.log(
+      `User ${
+        admin.name || admin.email_id
+      } already has role assignments. Skipping.`
+    );
+  }
+
+  logSeederComplete("User role");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/user.seed.js

@@ -0,0 +1,114 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadCoreData } from "./utils/json-loader.js";
+import * as bcrypt from "bcrypt";
+import { createCoreSeeder } from "./utils/core-seeder.js";
+import { CURRENT_ADMIN_USER_EMAIL } from "./utils/config.js";
+import { getSeederConfig } from "./utils/seeder-config-mapper.js";
+import { createPerformanceConfig } from "./utils/performance-config.js";
+
+export async function seedUsers(prismaClient, seederManager = null) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  try {
+    // Load users from JSON
+    const userData = loadCoreData("users");
+
+    // Get configuration from seeder manager or create default
+    let config;
+    if (seederManager) {
+      config = seederManager.getConfig('user');
+      console.log(`\n=== User Seeder Configuration ===`);
+      console.log(`Category: ${config.category}`);
+      console.log(`Batch Size: ${config.batchSize}`);
+      console.log(`Max Concurrent: ${config.maxConcurrentBatches}`);
+      console.log(`Fallback: ${config.fallback || 'No'}`);
+      console.log(`=====================================\n`);
+    } else {
+      // Fallback to default performance config
+      const perfConfig = createPerformanceConfig({ profile: 'stability' });
+      config = perfConfig.getConfig('core', 'users');
+    }
+
+    // Create optimized core seeder with configuration from seeder manager
+    const coreSeeder = createCoreSeeder(prisma, {
+      performanceConfig: seederManager?.performanceConfig || { profile: 'stability' },
+      enableRetries: true,
+      logProgress: true
+    });
+
+    // Create processor function for user upserts with password hashing
+    const userProcessor = async (user, options = {}) => {
+      try {
+        const email_id = options.isFirstUser ? CURRENT_ADMIN_USER_EMAIL : user.email_id;
+        
+        // Hash password for security
+        const salt = await bcrypt.genSalt();
+        const hashedPassword = await bcrypt.hash(user.password, salt);
+
+        const result = await prisma.user.upsert({
+          where: {
+            unique_id: user.unique_id,
+          },
+          update: {
+            name: user.name,
+            first_name: user.first_name,
+            middle_name: user.middle_name,
+            last_name: user.last_name,
+            country_code: user.country_code,
+            mobile_number: user.mobile_number,
+            access_token_expiry: user.access_token_expiry,
+            password: hashedPassword,
+          },
+          create: {
+            unique_id: user.unique_id,
+            name: user.name,
+            first_name: user.first_name,
+            middle_name: user.middle_name,
+            last_name: user.last_name,
+            email_id: email_id,
+            password: hashedPassword,
+            country_code: user.country_code,
+            mobile_number: user.mobile_number,
+            access_token_expiry: user.access_token_expiry,
+            status: "Active",
+          },
+        });
+
+        // Mark first user as processed
+        if (options.isFirstUser) {
+          options.isFirstUser = false;
+        }
+
+        // Simple heuristic to determine if this was create or update
+        const isNewRecord = result.created_at && 
+          new Date(result.created_at).getTime() > Date.now() - 5000;
+        
+        return {
+          created: isNewRecord,
+          updated: !isNewRecord
+        };
+      } catch (error) {
+        throw error;
+      }
+    };
+
+    // Track first user state across batches
+    const processorOptions = { isFirstUser: true };
+
+    // Process users with optimized core seeder
+    const result = await coreSeeder.processCore(
+      userData, 
+      userProcessor, 
+      'users',
+      processorOptions
+    );
+
+    return result;
+  } finally {
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}