procbay-schema 1.0.0

package/prisma/seeders/approval-hierarchy.seed.js

@@ -0,0 +1,340 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadContentData } from "./utils/json-loader.js";
+import {
+  createProgressTracker,
+  logEntityError,
+  logSeederComplete,
+  logSeederStart,
+} from "./utils/progress-tracker.js";
+
+export const approvalHierarchy = async (prismaClient) => {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("approval-hierarchy");
+
+  // Load approval hierarchy from JSON
+  const hierarchyData = loadContentData("approval-hierarchy");
+
+  /// Create progress tracker
+  const tracker = createProgressTracker(
+    hierarchyData.length,
+    "approval hierarchies"
+  );
+
+  // Get all active users (not deleted and active)
+  const activeUsers = await prisma.user.findMany({
+    where: {
+      is_deleted: false,
+      status: "Active",
+    },
+  });
+
+  // Create a map of user IDs for quick lookup
+  const activeUserMap = new Map();
+  activeUsers.forEach((user) => {
+    activeUserMap.set(user.id, user);
+  });
+
+  // Make sure we have users to assign as approvers
+  if (activeUsers.length === 0) {
+    console.warn(
+      "No active users found for approval hierarchy. Please ensure users are seeded first."
+    );
+  }
+
+  // Get approver IDs from specified IDs or fallback to random selection
+  // Returns array of unique user IDs to prevent duplicates
+  const getApproverIds = (specifiedIds = [], count = 2) => {
+    // If specific IDs are provided and they exist in active users, use them
+    if (specifiedIds && specifiedIds.length > 0) {
+      // Filter specified IDs to only include active users and ensure uniqueness
+      const validApproverIds = [...new Set(specifiedIds)].filter((id) =>
+        activeUserMap.has(id)
+      );
+      if (validApproverIds.length > 0) {
+        return validApproverIds;
+      }
+    }
+
+    // Fallback to random selection if no valid specified IDs
+    const userCount = Math.min(count, activeUsers.length);
+    const shuffled = [...activeUsers].sort(() => 0.5 - Math.random());
+    const selectedUsers = shuffled.slice(0, userCount);
+    return [...new Set(selectedUsers.map((user) => user.id))]; // Ensure uniqueness
+  };
+
+  for (const hierarchy of hierarchyData) {
+    try {
+      // Track used approvers across all levels in this hierarchy to prevent duplicates
+      const usedApproversInHierarchy = new Set();
+
+      // Check if hierarchy exists
+      const existingHierarchy = await prisma.approvalHierarchy.findFirst({
+        where: {
+          name: hierarchy.name,
+        },
+      });
+
+      let hierarchyId;
+
+      if (!existingHierarchy) {
+        // Create approval hierarchy
+        const createdHierarchy = await prisma.approvalHierarchy.create({
+          data: {
+            name: hierarchy.name,
+            slug: hierarchy.slug,
+            module: hierarchy.module,
+            task: hierarchy.task,
+            initiator_type: hierarchy.initiator_type,
+            roleId: hierarchy.roleId,
+            userId: hierarchy.userId,
+            is_active: hierarchy.is_active,
+            is_deleted: hierarchy.is_deleted,
+            created_by: hierarchy.created_by,
+            updated_by: hierarchy.updated_by,
+          },
+        });
+
+        hierarchyId = createdHierarchy.id;
+      } else {
+        await prisma.approvalHierarchy.update({
+          where: {
+            id: existingHierarchy.id,
+          },
+          data: {
+            name: hierarchy.name,
+            module: hierarchy.module,
+            task: hierarchy.task,
+            initiator_type: hierarchy.initiator_type,
+            roleId: hierarchy.roleId,
+            userId: hierarchy.userId,
+            is_active: hierarchy.is_active,
+            is_deleted: hierarchy.is_deleted,
+            created_by: hierarchy.created_by,
+            updated_by: hierarchy.updated_by,
+          },
+        });
+
+        hierarchyId = existingHierarchy.id;
+      }
+
+      // Seed approval conditions based on hierarchy
+      if (hierarchy.conditions && hierarchy.conditions.length > 0) {
+        for (const condition of hierarchy.conditions) {
+          const existingCondition = await prisma.approvalCondition.findFirst({
+            where: {
+              approval_hierarchy_id: hierarchyId,
+              conditions: condition.type,
+              price_from: condition.price_from,
+              price_to: condition.price_to,
+            },
+          });
+
+          let conditionId;
+
+          if (!existingCondition) {
+            const createdCondition = await prisma.approvalCondition.create({
+              data: {
+                approval_hierarchy_id: hierarchyId,
+                conditions: condition.type,
+                price_from: condition.price_from,
+                price_to: condition.price_to,
+              },
+            });
+
+            conditionId = createdCondition.id;
+          } else {
+            await prisma.approvalCondition.update({
+              where: {
+                id: existingCondition.id,
+              },
+              data: {
+                conditions: condition.type,
+                price_from: condition.price_from,
+                price_to: condition.price_to,
+              },
+            });
+
+            conditionId = existingCondition.id;
+          }
+
+          // Seed approval levels for each condition
+          if (condition.levels && condition.levels.length > 0) {
+            for (const level of condition.levels) {
+              // Track used approvers for this level
+              const usedApproversInLevel = new Set();
+
+              const existingLevel = await prisma.approvalLevel.findFirst({
+                where: {
+                  approval_hierarchy_id: hierarchyId,
+                  approval_condition_id: conditionId,
+                  level: level.level,
+                },
+              });
+
+              let levelId;
+
+              if (!existingLevel) {
+                const createdLevel = await prisma.approvalLevel.create({
+                  data: {
+                    approval_hierarchy_id: hierarchyId,
+                    approval_condition_id: conditionId,
+                    level: level.level,
+                    valid_till_hours: level.valid_till_hours,
+                    valid_till_minutes: level.valid_till_minutes,
+                  },
+                });
+
+                levelId = createdLevel.id;
+              } else {
+                await prisma.approvalLevel.update({
+                  where: {
+                    id: existingLevel.id,
+                  },
+                  data: {
+                    approval_hierarchy_id: hierarchyId,
+                    approval_condition_id: conditionId,
+                    level: level.level,
+                    valid_till_hours: level.valid_till_hours,
+                    valid_till_minutes: level.valid_till_minutes,
+                  },
+                });
+
+                levelId = existingLevel.id;
+              }
+
+              // Use specified approvers or get random ones if not specified
+              const approverIds = getApproverIds(level.approvers, 2);
+
+              // Delete existing level users if any (to ensure clean state)
+              await prisma.approvalLevelUser.deleteMany({
+                where: {
+                  approval_level_id: levelId,
+                },
+              });
+
+              // Seed approval level users with active users, checking for duplicates
+              for (const approverId of approverIds) {
+                // Check if this approver has already been used in this level
+                if (!usedApproversInLevel.has(approverId)) {
+                  await prisma.approvalLevelUser.create({
+                    data: {
+                      approval_level_id: levelId,
+                      approver_id: approverId,
+                    },
+                  });
+
+                  // Mark this approver as used in this level
+                  usedApproversInLevel.add(approverId);
+                }
+              }
+
+              // Seed approval level escalations
+              if (level.escalations && level.escalations.length > 0) {
+                for (const escalation of level.escalations) {
+                  // Track used approvers for this escalation
+                  const usedApproversInEscalation = new Set();
+
+                  // Use specified escalation approver or get random one
+                  const escalationApproverId =
+                    escalation.escalation_approver_id &&
+                    activeUserMap.has(escalation.escalation_approver_id)
+                      ? escalation.escalation_approver_id
+                      : activeUsers.length > 0
+                      ? activeUsers[
+                          Math.floor(Math.random() * activeUsers.length)
+                        ].id
+                      : null;
+
+                  if (!escalationApproverId) {
+                    console.warn(
+                      `No active users available for escalation approver in level ${level.level}`
+                    );
+                    continue;
+                  }
+
+                  const existingEscalation =
+                    await prisma.approvalLevelEscalation.findFirst({
+                      where: {
+                        approval_level_id: levelId,
+                        escalation_approver_id: escalationApproverId,
+                      },
+                    });
+
+                  let escalationId;
+
+                  if (!existingEscalation) {
+                    const createdEscalation =
+                      await prisma.approvalLevelEscalation.create({
+                        data: {
+                          approval_level_id: levelId,
+                          escalation_approver_id: escalationApproverId,
+                          valid_till_hours: escalation.valid_till_hours,
+                          valid_till_minutes: escalation.valid_till_minutes,
+                        },
+                      });
+
+                    escalationId = createdEscalation.id;
+                  } else {
+                    await prisma.approvalLevelEscalation.update({
+                      where: {
+                        id: existingEscalation.id,
+                      },
+                      data: {
+                        approval_level_id: levelId,
+                        escalation_approver_id: escalationApproverId,
+                        valid_till_hours: escalation.valid_till_hours,
+                        valid_till_minutes: escalation.valid_till_minutes,
+                      },
+                    });
+                    escalationId = existingEscalation.id;
+                  }
+
+                  // Use specified escalation approvers or get random ones
+                  const escalationApproverIds = getApproverIds(
+                    escalation.approvers,
+                    2
+                  );
+
+                  // Delete existing escalation users if any (to ensure clean state)
+                  await prisma.approvalLevelEscalationUser.deleteMany({
+                    where: {
+                      approval_level_escalation_id: escalationId,
+                    },
+                  });
+
+                  // Seed approval level escalation users with active users, checking for duplicates
+                  for (const approverId of escalationApproverIds) {
+                    // Check if this approver has already been used in this escalation
+                    if (!usedApproversInEscalation.has(approverId)) {
+                      await prisma.approvalLevelEscalationUser.create({
+                        data: {
+                          approval_level_escalation_id: escalationId,
+                          approver_id: approverId,
+                        },
+                      });
+
+                      // Mark this approver as used in this escalation
+                      usedApproversInEscalation.add(approverId);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      logEntityError("approval-hierarchy", hierarchy.name, error.message);
+      throw error;
+    }
+    tracker.update();
+  }
+  logSeederComplete("Approval Hierarchy");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+};

package/prisma/seeders/attribute-value.seed.js

@@ -0,0 +1,64 @@
+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 seedAttributeValues(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("attribute values");
+
+  // Load attribute values from JSON
+  const attributeValueData = loadContentData("attribute-values");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(
+    attributeValueData.length,
+    "attribute values"
+  );
+
+  for (const attributeValue of attributeValueData) {
+    try {
+      await prisma.attributeValue.upsert({
+        where: {
+          attribute_id_attribute_value_name: {
+            attribute_id: attributeValue.attribute_id,
+            attribute_value_name: attributeValue.attribute_value_name,
+          },
+        },
+        update: {
+          is_active: attributeValue.is_active,
+          slug: attributeValue.slug,
+          created_by: attributeValue.created_by,
+          updated_by: attributeValue.updated_by,
+          is_deleted: attributeValue.is_deleted,
+        },
+        create: {
+          uuid: attributeValue.uuid,
+          attribute_id: attributeValue.attribute_id,
+          attribute_value_name: attributeValue.attribute_value_name,
+          is_active: attributeValue.is_active,
+          slug: attributeValue.slug,
+          created_by: attributeValue.created_by,
+          updated_by: attributeValue.updated_by,
+          is_deleted: attributeValue.is_deleted,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError(
+        "attribute value",
+        attributeValue.attribute_value_name,
+        error.message
+      );
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Attribute values");
+}

package/prisma/seeders/attribute.seed.js

@@ -0,0 +1,61 @@
+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 seedAttributes(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("attributes");
+
+  // Load attributes from JSON
+  const attributeData = loadContentData("attributes");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(attributeData.length, "attributes");
+
+  for (const attribute of attributeData) {
+    try {
+      await prisma.attribute.upsert({
+        where: {
+          uuid: attribute.uuid,
+        },
+        update: {
+          category_id: attribute.category_id,
+          attribute_name: attribute.attribute_name,
+          is_active: attribute.is_active,
+          slug: attribute.slug,
+          created_by: attribute.created_by,
+          updated_by: attribute.updated_by,
+          is_deleted: attribute.is_deleted,
+        },
+        create: {
+          uuid: attribute.uuid,
+          category_id: attribute.category_id,
+          attribute_name: attribute.attribute_name,
+          is_active: attribute.is_active,
+          slug: attribute.slug,
+          created_by: attribute.created_by,
+          updated_by: attribute.updated_by,
+          is_deleted: attribute.is_deleted,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError("attribute", attribute.attribute_name, error.message);
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Attributes");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/category.seed.js

@@ -0,0 +1,133 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadContentData } from "./utils/json-loader.js";
+import { createContentSeeder, seedContentData } from "./utils/content-seeder.js";
+import {
+  logSeederStart,
+  logSeederComplete,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+
+/**
+ * Enhanced category seeder with:
+ * - Medium batch processing (500-1000 records)
+ * - Unique constraint mapping for batch upserts
+ * - Memory monitoring during large operations
+ * - Connection pooling through manager
+ * - Exponential backoff retry logic
+ */
+export async function seedCategories(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  try {
+    // Load categories from JSON
+    const categoryData = loadContentData("categories");
+
+    if (!categoryData || categoryData.length === 0) {
+      console.log("No category data found to seed.");
+      return;
+    }
+
+    // Create enhanced content seeder with category-specific configuration
+    const seeder = await createContentSeeder('categories', {
+      // Use connection pooling if no client is provided
+      useConnectionPooling: !prismaClient,
+      // Enable all enhanced features
+      enableUniqueConstraintMapping: true,
+      enableMemoryMonitoring: true,
+      batchUpsertMode: true,
+      // Category-specific unique fields for constraint mapping
+      uniqueFields: ['name', 'slug'],
+      // Medium batch size as specified (500-1000)
+      batchSize: 750,
+      // Memory monitoring configuration
+      memoryCheckInterval: 100,
+      memoryThreshold: 0.5,
+      // Retry configuration for robustness
+      retryAttempts: 3,
+      retryDelay: 750,
+      exponentialBackoff: true,
+      // Logging
+      logProgress: true
+    });
+
+    // Custom processor for categories (fallback if batch upsert fails)
+    const categoryProcessor = async (chunk, chunkIndex, client) => {
+      let created = 0;
+      
+      for (const category of chunk) {
+        try {
+          // Ensure parent_id defaults to 0 if not provided
+          const categoryRecord = {
+            ...category,
+            parent_id: category.parent_id || 0
+          };
+          
+          await client.category.upsert({
+            where: {
+              name: categoryRecord.name,
+            },
+            update: {
+              slug: categoryRecord.slug,
+              parent_id: categoryRecord.parent_id,
+              description: categoryRecord.description,
+              image_url: categoryRecord.image_url,
+              is_active: categoryRecord.is_active,
+              created_by: categoryRecord.created_by,
+              updated_by: categoryRecord.updated_by,
+            },
+            create: {
+              name: categoryRecord.name,
+              slug: categoryRecord.slug,
+              parent_id: categoryRecord.parent_id,
+              description: categoryRecord.description,
+              image_url: categoryRecord.image_url,
+              is_active: categoryRecord.is_active,
+              created_by: categoryRecord.created_by,
+              updated_by: categoryRecord.updated_by,
+            },
+          });
+          created++;
+        } catch (error) {
+          // Log error but continue processing
+          logEntityError("category", category.name, error.message);
+        }
+      }
+      
+      return { created };
+    };
+
+    // Execute enhanced seeding with all new features
+    const result = await seeder.seedContent(
+      'categories', 
+      categoryData, 
+      categoryProcessor,
+      prisma
+    );
+
+    // Log summary
+    console.log(`\nCategory 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("categories", "seeding process", error.message);
+    throw error;
+  } finally {
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}