procbay-schema 1.0.0

package/prisma/seeders/seed.js

@@ -0,0 +1,553 @@
+import colors from "colors";
+import { fileURLToPath } from "url";
+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 { seedRolePermission } from "./role-permission.seed.js";
+import { seedUserRole } from "./user-role.seed.js";
+import { seedSerialNumberConfigurations } from "./serial-number-config.seed.js";
+import { seedTemplates } from "./template.seed.js";
+import { seedEmailTemplate } from "./email-template.seed.js";
+import { seedUserEventConfigurations } from "./user-event-configuration.seed.js";
+// Import geo data seeders
+import { seedRegions } from "./region.seed.js";
+import { seedSubregions } from "./subregion.seed.js";
+import { seedCountries } from "./country.seed.js";
+import { seedStates } from "./state.seed.js";
+import { seedCities } from "./city.seed.js";
+import { seedDynamicForm } from "./dynamic-form.seed.js";
+// Import optimization utilities
+import { createPerformanceConfig, PERFORMANCE_PRESETS } from "./utils/performance-config.js";
+import { getConnectionManager } from "./utils/connection-manager.js";
+import { createSeederManager, determineDataVolume } from "./utils/seeder-config-mapper.js";
+
+// Initialize colors
+colors.setTheme({
+  info: "blue",
+  success: "green",
+  warn: "yellow",
+  error: "red",
+  highlight: "cyan",
+  muted: "gray",
+  header: ["bold", "cyan"],
+  progress: "magenta",
+  bold: "bold",
+});
+
+// Create logger function with timing and colors
+const createLogger = () => {
+  const startTime = Date.now();
+  const formatTime = () => {
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+    return colors.muted(`[${elapsed}s]`);
+  };
+
+  // Check if detailed logging is enabled
+  const isDetailedLogging = process.env.DETAILED_LOGGING === "true";
+
+  // Get log level from environment or default to info
+  const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+  };
+
+  const currentLogLevel = LOG_LEVELS[process.env.LOG_LEVEL || "info"];
+
+  return {
+    info: (message) => {
+      // Always log info messages when detailed logging is enabled
+      if (isDetailedLogging || currentLogLevel <= LOG_LEVELS.info) {
+        console.log(`${formatTime()} ${colors.info("ℹ️")} ${message}`);
+      }
+    },
+    success: (message) => {
+      // Always log success messages when detailed logging is enabled
+      if (isDetailedLogging || currentLogLevel <= LOG_LEVELS.info) {
+        console.log(
+          `${formatTime()} ${colors.success("✅")} ${colors.success(message)}`
+        );
+      }
+    },
+    warn: (message) => {
+      // Always log warning messages when detailed logging is enabled
+      if (isDetailedLogging || currentLogLevel <= LOG_LEVELS.warn) {
+        console.warn(
+          `${formatTime()} ${colors.warn("⚠️")} ${colors.warn(message)}`
+        );
+      }
+    },
+    error: (message) => {
+      // Always log error messages
+      console.error(
+        `${formatTime()} ${colors.error("❌")} ${colors.error(message)}`
+      );
+    },
+    header: (message) => {
+      // Always log header messages when detailed logging is enabled
+      if (isDetailedLogging || currentLogLevel <= LOG_LEVELS.info) {
+        console.log(
+          `\n${colors.header(message)}\n${colors.muted("━".repeat(80))}`
+        );
+      }
+    },
+    progressStart: (total, message) => {
+      const progress = { current: 0, total, message };
+      progress.update = (increment = 1) => {
+        progress.current += increment;
+        const percent = Math.min(
+          Math.floor((progress.current / total) * 100),
+          100
+        );
+        const filled = Math.floor((40 * progress.current) / total);
+        const bar =
+          colors.progress("█".repeat(filled)) +
+          colors.muted("░".repeat(40 - filled));
+
+        // Only write progress if detailed logging is enabled or at appropriate log level
+        if (isDetailedLogging || currentLogLevel <= LOG_LEVELS.info) {
+          process.stdout.write(
+            `\r${formatTime()} ${colors.highlight(
+              message
+            )}: ${bar} ${colors.bold(`${percent}%`)} (${
+              progress.current
+            }/${total})`
+          );
+        }
+      };
+      progress.complete = () => {
+        if (progress.current < total) {
+          progress.current = total;
+          progress.update(0); // Just redraw without incrementing
+        }
+        if (isDetailedLogging || currentLogLevel <= LOG_LEVELS.info) {
+          process.stdout.write("\n");
+        }
+      };
+      return progress;
+    },
+    progressBar: (current, total, message = "") => {
+      const percent = Math.min(Math.floor((current / total) * 100), 100);
+      const filled = Math.floor((40 * current) / total);
+      const bar =
+        colors.progress("█".repeat(filled)) +
+        colors.muted("░".repeat(40 - filled));
+      return `${bar} ${colors.bold(`${percent}%`)} ${
+        message ? `(${message})` : ""
+      }`;
+    },
+  };
+};
+
+const logger = createLogger();
+
+const prisma = new PrismaClient({
+  log: [
+    { level: "query", emit: "event" },
+    { level: "error", emit: "stdout" },
+  ],
+});
+
+// Count executed queries for monitoring
+let queryCount = 0;
+prisma.$on("query", () => {
+  queryCount++;
+});
+
+/**
+ * Parse command line arguments for country filters
+ *
+ * Example usage:
+ * node prisma/seeders/seed.js --countries="India,United States,Canada"
+ *
+ * @returns {Object} Object containing parsed arguments
+ */
+function parseArgs() {
+  const args = {};
+
+  // Get command line arguments
+  const cmdArgs = process.argv.slice(2);
+
+  for (const arg of cmdArgs) {
+    if (arg.startsWith("--countries=")) {
+      const countryString = arg.split("=")[1];
+      args.countries = countryString.split(",").map((c) => c.trim());
+    }
+  }
+
+  return args;
+}
+
+
+/**
+ * Main function to run all seeders
+ *
+ * @param {string[]} [countryFilter] - Optional array of country names to filter geographic data
+ */
+export async function main(countryFilter = ["India", "United States", "Canada"]) {
+  let connectionManager;
+  let seederManager;
+  
+  try {
+    // Initialize seeder manager with auto-config selection
+    const environment = process.env.NODE_ENV || 'development';
+    
+    seederManager = createSeederManager({
+      environment,
+      countryFilter,
+      expectedRecords: countryFilter.length === 0 ? 100000 : countryFilter.length * 10000,
+      availableMemory: process.memoryUsage().free
+    });
+    
+    // Log configuration summary
+    seederManager.logConfigSummary();
+    
+    // Initialize connection manager
+    connectionManager = getConnectionManager({
+      connectionLimit: seederManager.performanceConfig.config.geographic.cities.connectionPoolSize,
+      idleTimeout: 300000,
+      acquireTimeout: 60000
+    });
+    
+    // Print start message with environment info to help with debugging
+    console.log("\n================= SEED PROCESS STARTED =================");
+    console.log(`Node version: ${process.version}`);
+    console.log(`Environment: ${environment}`);
+    console.log(`Memory usage: ${JSON.stringify(process.memoryUsage())}`);
+    console.log(
+      `Database URL: ${
+        process.env.DEFAULT_DATABASE_URL ? "Defined" : "Not defined"
+      }`
+    );
+    console.log("=======================================================\n");
+
+    // If no countryFilter is provided, check command line args
+    if (!countryFilter || countryFilter.length === 0) {
+      const args = parseArgs();
+      countryFilter = args.countries || [];
+    }
+
+    logger.header("🌱 DATABASE SEEDING PROCESS");
+
+    if (countryFilter.length > 0) {
+      logger.info(`Country filter applied: ${countryFilter.join(", ")}`);
+    }
+
+    const startTime = Date.now();
+
+    // Run each seeding operation with detailed tracing
+    logger.info("Starting geographic data seeding...");
+    try {
+      // Run the geographic data seeding with connection retries
+      await seedGeographicDataWithRetry(countryFilter);
+      logger.success("Geographic data seeded successfully");
+    } catch (error) {
+      logger.error(`Geographic data seeding failed: ${error.message}`);
+      throw new Error(
+        `Geographic data seeding failed: ${error.stack || error.message}`
+      );
+    }
+
+    // Seed base/core data next
+    logger.info("Starting core data seeding...");
+    try {
+      await seedCoreDataWithRetry(seederManager);
+      logger.success("Core data seeded successfully");
+    } catch (error) {
+      logger.error(`Core data seeding failed: ${error.message}`);
+      throw new Error(
+        `Core data seeding failed: ${error.stack || error.message}`
+      );
+    }
+
+    // Seed catalog and content data
+    logger.info("Starting content data seeding...");
+    try {
+      await seedContentDataWithRetry();
+      logger.success("Content data seeded successfully");
+    } catch (error) {
+      logger.error(`Content data seeding failed: ${error.message}`);
+      throw new Error(
+        `Content data seeding failed: ${error.stack || error.message}`
+      );
+    }
+
+    // Log completion stats
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.header("✅ SEEDING COMPLETED");
+    logger.success(
+      `Database seeded successfully in ${colors.bold(
+        totalTime + "s"
+      )} with ${colors.bold(queryCount.toString())} database queries`
+    );
+
+    logger.info("All categories seeded.");
+
+    return true;
+  } catch (error) {
+    // Enhanced error logging
+    logger.error(`Error during seeding process`);
+    logger.error(`Error message: ${error.message}`);
+    logger.error(`Stack trace: ${error.stack || "No stack trace available"}`);
+
+    // Log memory usage in case we're hitting resource limits
+    console.error(
+      "Memory usage at failure:",
+      JSON.stringify(process.memoryUsage())
+    );
+
+    return false;
+  }
+}
+
+/**
+ * Seeds geographic data (regions, subregions, countries, states, cities)
+ *
+ * @param {string[]} [countryFilter] - Optional array of country names to filter by
+ */
+export async function seedGeographicData(countryFilter = []) {
+  logger.header("🌎 GEOGRAPHIC DATA SEEDING");
+
+  const filteringMode =
+    countryFilter.length > 0
+      ? `filtering by ${countryFilter.length} countries`
+      : "seeding all countries";
+
+  logger.info(
+    `Starting geographic data seeding ${colors.highlight(
+      "(using transaction)"
+    )} - ${colors.highlight(filteringMode)}`
+  );
+
+  try {
+    await prisma.$transaction(
+      async (tx) => {
+        // Always seed all regions and subregions regardless of country filter
+        logger.info(`Seeding ${colors.highlight("regions")}...`);
+        const regionIdMap = await seedRegions(tx);
+
+        logger.info(`Seeding ${colors.highlight("subregions")}...`);
+        const subregionIdMap = await seedSubregions(tx, regionIdMap);
+
+        // Filter countries if specified
+        logger.info(
+          `Seeding ${colors.highlight("countries")}${
+            countryFilter.length > 0 ? " (filtered)" : ""
+          }...`
+        );
+        const countryIdMap = await seedCountries(
+          tx,
+          regionIdMap,
+          subregionIdMap,
+          countryFilter
+        );
+
+        // Create a Set of filtered country JSON IDs if filtering is applied
+        let filteredCountryIds = null;
+        if (countryFilter.length > 0) {
+          filteredCountryIds = new Set();
+          // Populate the Set with the JSON IDs of filtered countries
+          countryIdMap.forEach((dbId, jsonId) => {
+            if (filteredCountryIds) {
+              filteredCountryIds.add(jsonId);
+            }
+          });
+        }
+
+        logger.info(
+          `Seeding ${colors.highlight("states")}${
+            filteredCountryIds ? " (filtered)" : ""
+          }...`
+        );
+        const stateIdMap = await seedStates(
+          tx,
+          countryIdMap,
+          filteredCountryIds
+        );
+
+        logger.info(
+          `Seeding ${colors.highlight("cities")}${
+            filteredCountryIds ? " (filtered)" : ""
+          }...`
+        );
+        await seedCities(tx, countryIdMap, stateIdMap, filteredCountryIds);
+      },
+      {
+        timeout: 600000, // 10 minute transaction timeout
+      }
+    );
+
+    logger.success(
+      `Geographic data seeding completed successfully ${
+        countryFilter.length > 0 ? "(filtered mode)" : ""
+      }`
+    );
+  } catch (error) {
+    logger.error(`Error in geographic data seeding: ${error.message}`);
+    throw error;
+  }
+}
+
+// Add retry wrappers for each seeding phase
+async function seedGeographicDataWithRetry(countryFilter = [], maxRetries = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      logger.info(`Geographic data seeding attempt ${attempt}/${maxRetries}`);
+      await seedGeographicData(countryFilter);
+      return; // Success, exit the function
+    } catch (error) {
+      logger.warn(
+        `Geographic data seeding attempt ${attempt} failed: ${error.message}`
+      );
+
+      if (attempt < maxRetries) {
+        const delay = 2000 * attempt; // Increasing delay between retries
+        logger.info(`Retrying in ${delay / 1000} seconds...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      } else {
+        throw error; // Last attempt failed, rethrow the error
+      }
+    }
+  }
+}
+
+/**
+ * Seeds core data (users, roles, permissions, etc.)
+ */
+export async function seedCoreData(seederManager) {
+  logger.header("👤 CORE DATA SEEDING");
+
+  try {
+    // Create a progress tracker for core data
+    const coreDataItems = [
+      {
+        name: "Serial Number Configurations",
+        fn: (prisma, seederMgr) => seedSerialNumberConfigurations(prisma, seederMgr),
+      },
+      { name: "Departments", fn: (prisma, seederMgr) => seedDepartments(prisma, seederMgr) },
+      { name: "Currencies", fn: (prisma, seederMgr) => seedCurrencies(prisma, seederMgr) },
+      { name: "Users", fn: (prisma, seederMgr) => seedUsers(prisma, seederMgr) },
+      { name: "Roles", fn: (prisma, seederMgr) => seedRoles(prisma, seederMgr) },
+      { name: "Permissions", fn: (prisma, seederMgr) => seedPermissions(prisma, seederMgr) },
+      { name: "Role permissions", fn: (prisma, seederMgr) => seedRolePermission(prisma, seederMgr) },
+      { name: "User roles", fn: (prisma, seederMgr) => seedUserRole(prisma, seederMgr) },
+      { name: "User event configurations", fn: (prisma, seederMgr) => seedUserEventConfigurations(prisma, seederMgr) },
+    ];
+
+    const progress = logger.progressStart(
+      coreDataItems.length,
+      "Core data seeding progress"
+    );
+
+    // Run core seeders in sequence
+    for (const item of coreDataItems) {
+      logger.info(`Seeding ${colors.highlight(item.name)}...`);
+      await item.fn(prisma, seederManager);
+      progress.update();
+    }
+
+    progress.complete();
+    logger.success("Core data seeding completed successfully");
+  } catch (error) {
+    logger.error(`Error in core data seeding: ${error.message}`);
+    throw error;
+  }
+}
+
+// Add retry wrappers for each seeding phase
+async function seedCoreDataWithRetry(seederManager, maxRetries = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      logger.info(`Core data seeding attempt ${attempt}/${maxRetries}`);
+      await seedCoreData(seederManager);
+      return; // Success, exit the function
+    } catch (error) {
+      logger.warn(
+        `Core data seeding attempt ${attempt} failed: ${error.message}`
+      );
+
+      if (attempt < maxRetries) {
+        const delay = 2000 * attempt; // Increasing delay between retries
+        logger.info(`Retrying in ${delay / 1000} seconds...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      } else {
+        throw error; // Last attempt failed, rethrow the error
+      }
+    }
+  }
+}
+
+/**
+ * Seeds content data (FAQs, categories, attributes, etc.)
+ */
+export async function seedContentData() {
+  logger.header("📋 CONTENT DATA SEEDING");
+
+  try {
+    // Create a progress tracker for content data
+    const contentDataItems = [
+      { name: "Templates", fn: (prisma) => seedTemplates(prisma) },
+      { name: "Email Templates", fn: (prisma) => seedEmailTemplate(prisma) },
+      { name: "Dynamic Forms", fn: (prisma) => seedDynamicForm(prisma) },
+    ];
+
+    const progress = logger.progressStart(
+      contentDataItems.length,
+      "Content data seeding progress"
+    );
+
+    // Run content seeders in sequence
+    for (const item of contentDataItems) {
+      logger.info(`Seeding ${colors.highlight(item.name)}...`);
+      await item.fn(prisma);
+      progress.update();
+    }
+
+    progress.complete();
+    logger.success("Content data seeding completed successfully");
+  } catch (error) {
+    logger.error(`Error in content data seeding: ${error.message}`);
+    throw error;
+  }
+}
+
+// Add retry wrappers for each seeding phase
+async function seedContentDataWithRetry(maxRetries = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      logger.info(`Content data seeding attempt ${attempt}/${maxRetries}`);
+      await seedContentData();
+      return; // Success, exit the function
+    } catch (error) {
+      logger.warn(
+        `Content data seeding attempt ${attempt} failed: ${error.message}`
+      );
+
+      if (attempt < maxRetries) {
+        const delay = 2000 * attempt; // Increasing delay between retries
+        logger.info(`Retrying in ${delay / 1000} seconds...`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      } else {
+        throw error; // Last attempt failed, rethrow the error
+      }
+    }
+  }
+}
+
+// Only run main if this script was called directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  await main()
+    .catch((e) => {
+      console.error(e);
+      process.exit(1);
+    })
+    .finally(async () => {
+      // Clean up by disconnecting Prisma Client
+      await prisma.$disconnect();
+    });
+}

package/prisma/seeders/serial-number-config.seed.js

@@ -0,0 +1,58 @@
+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 seedSerialNumberConfigurations(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("serial number configurations");
+
+  // Load serial-number configurations from JSON
+  const serialNumberData = loadCoreData("serial-number-config");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(
+    serialNumberData.length,
+    "serial number configurations"
+  );
+
+  for (const serialConfig of serialNumberData) {
+    try {
+      await prisma.serialNumberConfiguration.upsert({
+        where: {
+          module: serialConfig.module,
+        },
+        update: {
+          alias: serialConfig.alias,
+        },
+        create: {
+          module: serialConfig.module,
+          alias: serialConfig.alias,
+          initial_number: serialConfig.initial_number,
+          current_number: serialConfig.current_number,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError(
+        "serial number configuration",
+        serialConfig.module,
+        error.message
+      );
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Serial number configurations");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/smtp-config.seed.js

@@ -0,0 +1,61 @@
+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 seedSmtpConfig(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("smtp config");
+
+  // Load SMTP configuration from JSON
+  const smtpConfigData = loadCoreData("smtp-config");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(smtpConfigData.length, "smtp configs");
+
+  for (const smtpConfig of smtpConfigData) {
+    try {
+      await prisma.smtpConfig.upsert({
+        where: {
+          smtp_server: smtpConfig.smtp_server,
+        },
+        update: {
+          port: smtpConfig.port,
+          username: smtpConfig.username,
+          password: smtpConfig.password,
+          from_email: smtpConfig.from_email,
+          encryption: smtpConfig.encryption,
+          test_email: smtpConfig.test_email,
+          is_active: smtpConfig.is_active,
+        },
+        create: {
+          smtp_server: smtpConfig.smtp_server,
+          port: smtpConfig.port,
+          username: smtpConfig.username,
+          password: smtpConfig.password,
+          from_email: smtpConfig.from_email,
+          encryption: smtpConfig.encryption,
+          test_email: smtpConfig.test_email,
+          is_active: smtpConfig.is_active,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError("smtp config", smtpConfig.host, error.message);
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("SMTP Config");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}