procbay-schema 1.0.0

package/prisma/seeders/faq.seed.js

@@ -0,0 +1,61 @@
+// prisma/seed.ts
+
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadContentData } from "./utils/json-loader.js";
+import {
+  createProgressTracker,
+  logSeederStart,
+  logSeederComplete,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+
+export async function seedFaq(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("FAQs");
+
+  // Load FAQs from JSON
+  const faqData = loadContentData("faqs");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(faqData.length, "FAQs");
+
+  for (const faq of faqData) {
+    try {
+      await prisma.faq.upsert({
+        where: {
+          faq_category_id_question_faq_type: {
+            faq_category_id: faq.faq_category_id,
+            question: faq.question,
+            faq_type: faq.faq_type,
+          },
+        }, // Use composite unique constraint
+        update: {
+          faq_type: faq.faq_type,
+          faq_category_id: faq.faq_category_id,
+          answer: faq.answer,
+          is_active: faq.is_active,
+        },
+        create: {
+          faq_type: faq.faq_type,
+          faq_category_id: faq.faq_category_id,
+          question: faq.question,
+          answer: faq.answer,
+          is_active: faq.is_active ?? true, // Default to true if not provided
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError("FAQ", faq.question, error.message);
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("FAQs");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/form-master.seed.js

@@ -0,0 +1,55 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadContentData } from "./utils/json-loader.js";
+import {
+  createProgressTracker,
+  logSeederStart,
+  logSeederComplete,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+
+export async function seedFormMaster(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("form-master");
+
+  // Load form master data from JSON
+  const formMasterData = loadContentData("form-master");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(formMasterData.length, "form masters");
+
+  for (const formMaster of formMasterData) {
+    try {
+      await prisma.formMaster.upsert({
+        where: {
+          module_slug: formMaster.module_slug,
+        },
+        update: {
+          module_name: formMaster.module_name,
+          is_active: formMaster.is_active,
+          is_deleted: formMaster.is_deleted,
+          created_by: formMaster.created_by,
+        },
+        create: {
+          module_name: formMaster.module_name,
+          module_slug: formMaster.module_slug,
+          is_active: formMaster.is_active,
+          is_deleted: formMaster.is_deleted,
+          created_by: formMaster.created_by,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError("form master", formMaster.module_name, error.message);
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Form-master");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/item.seed.js

@@ -0,0 +1,133 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadContentData } from "./utils/json-loader.js";
+import { createContentSeeder } from "./utils/content-seeder.js";
+import {
+  logSeederStart,
+  logSeederComplete,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+
+/**
+ * Enhanced item seeder using content seeder with:
+ * - Medium batch processing (1000-2000 records)
+ * - Unique constraint mapping for item_code and item_name
+ * - Memory monitoring during large operations
+ * - Connection pooling through manager
+ */
+export async function seedItems(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  try {
+    // Load items from JSON
+    const itemData = loadContentData("items");
+
+    if (!itemData || itemData.length === 0) {
+      console.log("No item data found to seed.");
+      return;
+    }
+
+    // Create enhanced content seeder with item-specific configuration
+    const seeder = await createContentSeeder('items', {
+      // Use connection pooling if no client is provided
+      useConnectionPooling: !prismaClient,
+      // Enable all enhanced features
+      enableUniqueConstraintMapping: true,
+      enableMemoryMonitoring: true,
+      batchUpsertMode: true,
+      // Item-specific unique fields for constraint mapping
+      uniqueFields: ['item_code', 'item_name'],
+      // Higher batch size for items (1000-2000 as configured)
+      batchSize: 2000,
+      // Memory monitoring configuration
+      memoryCheckInterval: 200,
+      memoryThreshold: 0.6,
+      // Retry configuration for robustness
+      retryAttempts: 3,
+      retryDelay: 1000,
+      exponentialBackoff: true,
+      // Logging
+      logProgress: true
+    });
+
+    // Custom processor for items (fallback if batch upsert fails)
+    const itemProcessor = async (chunk, chunkIndex, client) => {
+      let created = 0;
+      
+      for (const item of chunk) {
+        try {
+          await client.item.upsert({
+            where: {
+              item_code: item.item_code, // Use a unique identifier
+            },
+            update: {
+              item_name: item.item_name,
+              slug: item.slug,
+              description: item.description,
+              terms_and_conditions: item.terms_and_conditions,
+              keywords: item.keywords,
+              is_active: item.is_active,
+              created_by: item.created_by,
+              updated_by: item.updated_by,
+              category_id: item.category_id,
+            },
+            create: {
+              item_id: item.item_id,
+              item_code: item.item_code,
+              item_name: item.item_name,
+              slug: item.slug,
+              description: item.description,
+              terms_and_conditions: item.terms_and_conditions,
+              keywords: item.keywords,
+              is_active: item.is_active,
+              created_by: item.created_by,
+              updated_by: item.updated_by,
+              category: item.category_id ? {
+                connect: { id: item.category_id },
+              } : undefined,
+            },
+          });
+          created++;
+        } catch (error) {
+          // Log error but continue processing
+          logEntityError("item", item.item_name || item.item_code, error.message);
+        }
+      }
+      
+      return { created };
+    };
+
+    // Execute enhanced seeding with all new features
+    const result = await seeder.seedContent(
+      'items', 
+      itemData, 
+      itemProcessor,
+      prisma
+    );
+
+    // Log summary
+    console.log(`\nItem seeding summary:`);
+    console.log(`- Total processed: ${result.totalProcessed.toLocaleString()}`);
+    console.log(`- Total created: ${result.totalCreated.toLocaleString()}`);
+    console.log(`- Errors: ${result.errors.length}`);
+    console.log(`- Memory peak: ${((result.memoryStats.maxHeapUsed - result.memoryStats.startHeapUsed) / 1024 / 1024).toFixed(2)}MB`);
+    console.log(`- GC triggered: ${result.memoryStats.gcTriggered} times`);
+    
+    if (result.errors.length > 0) {
+      console.log("\nErrors encountered:");
+      result.errors.slice(0, 5).forEach(error => console.log(`  - ${error}`));
+      if (result.errors.length > 5) {
+        console.log(`  ... and ${result.errors.length - 5} more errors`);
+      }
+    }
+
+  } catch (error) {
+    logEntityError("items", "seeding process", error.message);
+    throw error;
+  } finally {
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}

package/prisma/seeders/permission.seed.js

@@ -0,0 +1,102 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { createCoreSeeder } from "./utils/core-seeder.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import colors from "colors";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function seedPermissions(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  try {
+    // Path to the permissions directory
+    const permissionsDir = path.resolve(
+      __dirname,
+      "../json/core-data/permissions"
+    );
+
+    // Get all JSON files in the permissions directory
+    const permissionFiles = fs
+      .readdirSync(permissionsDir)
+      .filter((file) => file.endsWith(".json"));
+
+    // Array to store all permissions
+    let allPermissions = [];
+
+    // Read each permission file and merge permissions
+    for (const file of permissionFiles) {
+      try {
+        const filePath = path.join(permissionsDir, file);
+        const fileData = JSON.parse(fs.readFileSync(filePath, "utf8"));
+
+        console.log(colors.gray(`Loaded ${fileData.length} permissions from ${file}`));
+        allPermissions = [...allPermissions, ...fileData];
+      } catch (error) {
+        console.error(colors.red(`Error loading permissions from ${file}: ${error.message}`));
+      }
+    }
+
+    console.log(colors.cyan(`Total permissions to seed: ${allPermissions.length}`));
+
+    // Create optimized core seeder with retry logic for critical permission data
+    const coreSeeder = createCoreSeeder(prisma, {
+      profile: 'stability', // Permissions are critical entities
+      enableRetries: true,
+      logProgress: true
+    });
+
+    // Create processor function for permission upserts
+    const permissionProcessor = async (permission, options = {}) => {
+      try {
+        const result = await prisma.permission.upsert({
+          where: {
+            slug: permission.slug,
+          },
+          update: {
+            permissions_name: permission.permissions_name,
+            description: permission.description,
+            model: permission.model,
+            is_active: permission.is_active,
+            created_by: permission.created_by,
+          },
+          create: {
+            permissions_name: permission.permissions_name,
+            slug: permission.slug,
+            description: permission.description,
+            model: permission.model,
+            is_active: permission.is_active,
+            created_by: permission.created_by,
+          },
+        });
+
+        // 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;
+      }
+    };
+
+    // Process permissions with optimized core seeder
+    const result = await coreSeeder.processCore(
+      allPermissions, 
+      permissionProcessor, 
+      'permissions'
+    );
+
+    return result;
+  } finally {
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}

package/prisma/seeders/region.seed.js

@@ -0,0 +1,78 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import {
+  createProgressTracker,
+  logSeederStart,
+  logSeederComplete,
+  logSeederError,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+import { loadGeoData } from "./utils/json-loader.js";
+
+// Map to store JSON ID to database ID mapping
+const regionIdMap = new Map();
+
+export async function seedRegions(prismaClient) {
+  // Use provided transaction object or create a new prisma client
+  const prisma = prismaClient || new PrismaClient();
+  
+  logSeederStart("regions");
+
+  try {
+    // Load categories from JSON
+    const regionsData = loadGeoData("regions");
+
+    // Create progress tracker
+    const tracker = createProgressTracker(regionsData.length, "regions");
+
+    // Process each region using upsert
+    for (const region of regionsData) {
+      const jsonId = region.id;
+
+      try {
+        // Upsert region using Prisma
+        const dbRegion = await prisma.region.upsert({
+          where: {
+            name: region.name,
+          },
+          update: {
+            translations: region.translations,
+            wikiDataId: region.wikiDataId,
+          },
+          create: {
+            name: region.name,
+            translations: region.translations,
+            wikiDataId: region.wikiDataId,
+          },
+        });
+
+        // Store the mapping between JSON ID and database ID
+        regionIdMap.set(jsonId, dbRegion.id);
+      } catch (error) {
+        // Log error but don't interrupt progress bar
+        logEntityError("regions", region.name, error.message);
+      }
+      tracker.update();
+    }
+
+    logSeederComplete("Regions");
+
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+
+    return regionIdMap;
+  } catch (error) {
+    logSeederError("regions", error);
+
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+
+    throw error;
+  }
+}

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

@@ -0,0 +1,70 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import {
+  createProgressTracker,
+  logSeederStart,
+  logSeederComplete,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+
+export async function seedRolePermission(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("role & permission mapping");
+
+  const adminRole = await prisma.role.findMany({
+    where: { slug: { in: ["super_admin", "admin"] } },
+  });
+
+  if (!adminRole.length) {
+    console.log(
+      "Warning: Super admin role not found. Skipping permission assignment."
+    );
+    return;
+  }
+
+  for (const role of adminRole) {
+    await prisma.rolePermission.deleteMany({ where: { role_id: role.id } });
+    console.log(`Existing permissions cleared for role: ${role.role_name}`);
+
+    const allPermissions = await prisma.permission.findMany({
+      where: { is_active: true },
+    });
+
+    if (allPermissions.length > 0) {
+      console.log(
+        `Assigning ${allPermissions.length} permissions to role: ${role.role_name}`
+      );
+
+      // Create progress tracker
+      const tracker = createProgressTracker(
+        allPermissions.length,
+        "permissions"
+      );
+
+      const rolePermissions = [];
+      allPermissions.forEach((permission) => {
+        rolePermissions.push({
+          role_id: role.id,
+          permission_id: permission.id,
+        });
+        tracker.update();
+      });
+
+      try {
+        await prisma.rolePermission.createMany({ data: rolePermissions });
+      } catch (error) {
+        // Log error but don't interrupt progress bar
+        logEntityError("role permissions", adminRole.role_name, error.message);
+      }
+    } else {
+      console.log("No active permissions found to assign");
+    }
+  }
+  logSeederComplete("Role & Permission mapping");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/role.seed.js

@@ -0,0 +1,38 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadCoreData } from "./utils/json-loader.js";
+import { seedCoreEntity } from "./utils/core-seeder.js";
+
+export async function seedRoles(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  try {
+    // Load roles from JSON
+    const roleData = loadCoreData("roles");
+
+    // Process roles with optimized core seeder
+    const result = await seedCoreEntity(
+      prisma,
+      roleData,
+      'roles',
+      {
+        model: 'role',
+        whereField: 'slug',
+        updateFields: ['role_name', 'description', 'is_active'],
+        createFields: ['role_name', 'slug', 'description', 'is_active']
+      },
+      {
+        profile: 'stability', // Roles are critical entities
+        enableRetries: true,
+        logProgress: true
+      }
+    );
+
+    return result;
+  } finally {
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}