procbay-schema 1.0.0

package/prisma/seeders/city.seed.js

@@ -0,0 +1,147 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import {
+  createProgressTracker,
+  logSeederStart,
+  logSeederComplete,
+  logSeederError,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+import { loadGeoData } from "./utils/json-loader.js";
+import { createPerformanceConfig } from "./utils/performance-config.js";
+import { withOptimizedConnection } from "./utils/connection-manager.js";
+
+// Process cities in optimized parallel batches with retry logic
+async function processBatch(prisma, batch, countryIdMap, stateIdMap, tracker, retryAttempts = 3) {
+  const citiesToCreate = batch
+    .map((city) => {
+      const countryDbId = city.country_id
+        ? countryIdMap.get(city.country_id)
+        : null;
+      const stateDbId = city.state_id ? stateIdMap.get(city.state_id) : null;
+
+      // City must have a country. State is optional.
+      if (!countryDbId) {
+        return null;
+      }
+
+      return {
+        name: city.name,
+        country_id: countryDbId,
+        state_id: stateDbId,
+        latitude: city.latitude ? parseFloat(city.latitude) : null,
+        longitude: city.longitude ? parseFloat(city.longitude) : null,
+        wikiDataId: city.wikiDataId,
+        status: true,
+      };
+    })
+    .filter(Boolean); // Filter out nulls for cities with no country match
+
+  if (citiesToCreate.length === 0) {
+    tracker.update(batch.length);
+    return { success: true, created: 0 };
+  }
+
+  // Retry logic for database operations
+  for (let attempt = 1; attempt <= retryAttempts; attempt++) {
+    try {
+      const result = await prisma.city.createMany({
+        data: citiesToCreate,
+        skipDuplicates: true, // Use INSERT ... ON CONFLICT DO NOTHING for performance
+      });
+      tracker.update(batch.length);
+      return { success: true, created: result.count };
+    } catch (error) {
+      if (attempt === retryAttempts) {
+        logEntityError("city batch", `attempt ${attempt}/${retryAttempts}`, error.message);
+        tracker.update(batch.length);
+        return { success: false, error: error.message };
+      }
+      
+      // Wait before retry with exponential backoff
+      const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+}
+
+/**
+ * Seeds city data with optional filtering by country IDs
+ *
+ * @param {PrismaClient} prismaClient - Prisma client instance or transaction
+ * @param {Map} countryIdMap - Mapping of country JSON IDs to DB IDs
+ * @param {Map} stateIdMap - Mapping of state JSON IDs to DB IDs
+ * @param {Set} [filteredCountryIds] - Optional Set of country JSON IDs to filter cities by
+ */
+export async function seedCities(
+  prismaClient,
+  countryIdMap,
+  stateIdMap,
+  filteredCountryIds = null
+) {
+  const prisma = prismaClient || new PrismaClient();
+  logSeederStart("cities");
+
+  try {
+    // Get performance configuration
+    const perfConfig = createPerformanceConfig();
+    const cityConfig = perfConfig.getConfig('geographic', 'cities');
+    
+    console.log(`Using optimized configuration: batch=${cityConfig.batchSize}, concurrent=${cityConfig.maxConcurrentBatches}`);
+    
+    const citiesData = loadGeoData("cities");
+    let filteredCitiesData = citiesData;
+
+    if (filteredCountryIds && filteredCountryIds.size > 0) {
+      filteredCitiesData = citiesData.filter((city) =>
+        filteredCountryIds.has(city.country_id)
+      );
+      console.log(`Filtering cities by ${filteredCountryIds.size} countries`);
+      console.log(
+        `Found ${filteredCitiesData.length} matching cities out of ${citiesData.length} total`
+      );
+    }
+
+    const totalCount = filteredCitiesData.length;
+    console.log(
+      `Total number of cities to process: ${totalCount.toLocaleString()}`
+    );
+
+    const tracker = createProgressTracker(totalCount, "cities");
+
+    // Use performance-optimized batch size
+    const batchSize = cityConfig.batchSize;
+    const maxConcurrentBatches = cityConfig.maxConcurrentBatches;
+    
+    // Process in controlled concurrent batches
+    const chunks = [];
+    for (let i = 0; i < filteredCitiesData.length; i += batchSize) {
+      chunks.push(filteredCitiesData.slice(i, i + batchSize));
+    }
+    
+    console.log(`Processing ${chunks.length} chunks with max ${maxConcurrentBatches} concurrent batches`);
+    
+    // Process chunks in controlled batches to avoid overwhelming the database
+    for (let i = 0; i < chunks.length; i += maxConcurrentBatches) {
+      const currentBatch = chunks.slice(i, i + maxConcurrentBatches);
+      const batchPromises = currentBatch.map(chunk => 
+        processBatch(prisma, chunk, countryIdMap, stateIdMap, tracker, cityConfig.retryAttempts || 3)
+      );
+      
+      await Promise.all(batchPromises);
+      
+      // Memory management: force garbage collection if available
+      if (global.gc && chunks.length > 10) {
+        global.gc();
+      }
+    }
+
+    logSeederComplete(`Cities${filteredCountryIds ? " (filtered)" : ""}`);
+  } catch (error) {
+    logSeederError("cities", error);
+    throw error;
+  } finally {
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}

package/prisma/seeders/country.seed.js

@@ -0,0 +1,282 @@
+import { PrismaClient } from "../../src/prisma/index.js";
+import { loadGeoData } from "./utils/json-loader.js";
+import {
+  createProgressTracker,
+  logSeederStart,
+  logSeederComplete,
+  logSeederError,
+  logEntityError,
+} from "./utils/progress-tracker.js";
+import { createPerformanceConfig } from "./utils/performance-config.js";
+import { connectionManager } from "./utils/connection-manager.js";
+import { RetryHandler, MemoryManager } from "./utils/performance-helpers.js";
+
+// Map to store JSON ID to database ID mapping
+const countryIdMap = new Map();
+
+/**
+ * Repopulate country ID mapping after bulk operations
+ */
+async function repopulateCountryIdMap(prisma, countriesData, regionIdMap) {
+  logSeederStart("Re-populating country ID map");
+
+  // Get all created countries
+  const allCreatedCountries = await prisma.country.findMany({
+    select: { id: true, iso3: true, name: true },
+  });
+
+  // Create lookup map by ISO3 code (unique identifier)
+  const dbCountryLookup = new Map();
+  allCreatedCountries.forEach((country) => {
+    dbCountryLookup.set(country.iso3, country.id);
+  });
+
+  // Map JSON IDs to database IDs
+  countriesData.forEach((jsonCountry) => {
+    const dbId = dbCountryLookup.get(jsonCountry.iso3);
+    if (dbId) {
+      countryIdMap.set(jsonCountry.id, dbId);
+    }
+  });
+
+  logSeederComplete(
+    `Country ID map re-populated with ${countryIdMap.size} entries`
+  );
+}
+
+/**
+ * Optimized batch processor using createMany with retry logic and transactions
+ */
+async function processBatchOptimized(
+  prisma,
+  batch,
+  regionIdMap,
+  subregionIdMap,
+  retryHandler
+) {
+  const countriesToCreate = batch
+    .map((country) => {
+      const regionDbId = country.region_id
+        ? regionIdMap.get(country.region_id)
+        : null;
+      const subregionDbId = country.subregion_id
+        ? subregionIdMap.get(country.subregion_id)
+        : null;
+
+      return {
+        name: country.name,
+        iso3: country.iso3,
+        iso2: country.iso2,
+        numeric_code: country.numeric_code,
+        phonecode: country.phonecode,
+        capital: country.capital,
+        currency: country.currency,
+        currency_name: country.currency_name,
+        currency_symbol: country.currency_symbol,
+        tld: country.tld,
+        native: country.native,
+        region: country.region,
+        subregion: country.subregion,
+        nationality: country.nationality,
+        timezones: country.timezones,
+        translations: country.translations,
+        latitude: country.latitude,
+        longitude: country.longitude,
+        emoji: country.emoji,
+        emojiU: country.emojiU,
+        status: true,
+        region_id: regionDbId,
+        subregion_id: subregionDbId,
+      };
+    })
+    .filter(Boolean);
+
+  if (countriesToCreate.length === 0) {
+    return { success: true, created: 0 };
+  }
+
+  try {
+    // Use transaction for batch processing
+    const result = await retryHandler.execute(async () => {
+      return await prisma.country.createMany({
+        data: countriesToCreate,
+        skipDuplicates: true,
+      });
+    }, `Country batch (${countriesToCreate.length} items)`);
+
+    return { success: true, created: result.count };
+  } catch (error) {
+    logEntityError("country batch", "N/A", error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Seeds country data with optional filtering by country names
+ *
+ * @param {PrismaClient} prismaClient - Prisma client instance or transaction
+ * @param {Map} regionIdMap - Mapping of region JSON IDs to DB IDs
+ * @param {Map} subregionIdMap - Mapping of subregion JSON IDs to DB IDs
+ * @param {string[]} [countryNames] - Optional array of country names to seed; if not provided, all countries will be seeded
+ * @returns {Map} Mapping of country JSON IDs to DB IDs
+ */
+export async function seedCountries(
+  prismaClient,
+  regionIdMap,
+  subregionIdMap,
+  countryNames = []
+) {
+  // Use provided transaction object or create a new prisma client
+  const prisma = prismaClient || new PrismaClient();
+  logSeederStart("countries");
+
+  try {
+    // Load countries data from JSON file using our utility
+    const countriesData = loadGeoData("countries");
+
+    // Filter countries if specific names are provided
+    let filteredCountriesData = countriesData;
+    if (countryNames && countryNames.length > 0) {
+      // Case-insensitive matching of country names
+      const normalizedCountryNames = countryNames.map((name) =>
+        name.toLowerCase().trim()
+      );
+
+      filteredCountriesData = countriesData.filter((country) =>
+        normalizedCountryNames.includes(country.name.toLowerCase().trim())
+      );
+
+      // Log information about the filtering
+      console.log(`Filtering countries by name: ${countryNames.join(", ")}`);
+      console.log(
+        `Found ${filteredCountriesData.length} matching countries out of ${countriesData.length} total`
+      );
+
+      // Check if any requested countries were not found
+      const foundCountryNames = filteredCountriesData.map((c) =>
+        c.name.toLowerCase().trim()
+      );
+      const missingCountryNames = normalizedCountryNames.filter(
+        (name) => !foundCountryNames.includes(name)
+      );
+
+      if (missingCountryNames.length > 0) {
+        console.warn(
+          `Warning: Could not find the following requested countries: ${missingCountryNames.join(
+            ", "
+          )}`
+        );
+      }
+    }
+
+    // Create progress tracker
+    const tracker = createProgressTracker(
+      filteredCountriesData.length,
+      "countries"
+    );
+
+    // Get performance configuration for countries
+    const performanceConfig = createPerformanceConfig().getConfig(
+      "geographic",
+      "countries"
+    );
+    const batchSize = performanceConfig.batchSize;
+    const retryHandler = new RetryHandler(
+      performanceConfig.retryAttempts || 3,
+      performanceConfig.retryDelay || 1000
+    );
+
+    // Create an array of batch processing promises
+    const batchPromises = [];
+
+    for (let i = 0; i < filteredCountriesData.length; i += batchSize) {
+      const batch = filteredCountriesData.slice(i, i + batchSize);
+      batchPromises.push(
+        processBatchOptimized(
+          prisma,
+          batch,
+          regionIdMap,
+          subregionIdMap,
+          retryHandler
+        )
+      );
+      global.gc && global.gc(); // Hint garbage collection after large batches
+    }
+
+    // Log initial memory usage
+    MemoryManager.logMemoryUsage("Before country processing");
+
+    // Execute all batches sequentially to avoid overwhelming the database
+    for (let i = 0; i < batchPromises.length; i++) {
+      await batchPromises[i];
+
+      // Keep the batch completion messages but don't interrupt progress bar
+      if (i < batchPromises.length - 1) {
+        // Don't show for the last batch
+        tracker.log(
+          `Completed batch ${i + 1}/${batchPromises.length} of countries`,
+          "success"
+        );
+      }
+
+      // Force garbage collection every 10 batches
+      if ((i + 1) % 10 === 0) {
+        await MemoryManager.forceGarbageCollectionWithDelay();
+        MemoryManager.logMemoryUsage(`After batch ${i + 1}`);
+      }
+    }
+
+    // Repopulate country ID map after bulk operations
+    await repopulateCountryIdMap(prisma, filteredCountriesData, regionIdMap);
+
+    // Store full countryData mapping for all countries even if we filtered
+    // This allows subsequent state/city seeders to check which countries to seed
+    if (countryNames && countryNames.length > 0) {
+      // For non-seeded countries, we need to fetch their IDs from the database
+      // to properly populate countryIdMap for the state and city seeders
+      const nonSeededCountryData = countriesData.filter(
+        (country) => !filteredCountriesData.includes(country)
+      );
+
+      if (nonSeededCountryData.length > 0) {
+        const existingCountries = await prisma.country.findMany({
+          where: {
+            iso3: {
+              in: nonSeededCountryData.map((c) => c.iso3),
+            },
+          },
+          select: { id: true, iso3: true },
+        });
+
+        // Map existing countries to countryIdMap
+        for (const existingCountry of existingCountries) {
+          const jsonCountry = nonSeededCountryData.find(
+            (c) => c.iso3 === existingCountry.iso3
+          );
+          if (jsonCountry) {
+            countryIdMap.set(jsonCountry.id, existingCountry.id);
+          }
+        }
+      }
+    }
+
+    logSeederComplete("Countries");
+
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+
+    return countryIdMap;
+  } catch (error) {
+    logSeederError("Countries", error);
+
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+
+    console.error("Error seeding countries:", error);
+    throw error;
+  }
+}

package/prisma/seeders/currency.seed.js

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

package/prisma/seeders/customer-notification.seed.js

@@ -0,0 +1,83 @@
+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 seedCustomerNotification(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("customer notifications");
+
+  // Load customer notifications from JSON
+  const notificationData = loadContentData("customer-notification");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(
+    notificationData.length,
+    "customer notifications"
+  );
+
+  for (const notification of notificationData) {
+    try {
+      // Check if the record exists based on unique fields (event + medium)
+      const existingNotification = await prisma.customerNotification.findFirst({
+        where: {
+          event: notification.event,
+          medium: notification.medium,
+        },
+      });
+
+      if (!existingNotification) {
+        // Create if the record does not exist
+        await prisma.customerNotification.create({
+          data: {
+            template_name: notification.template_name,
+            title: notification.title,
+            event: notification.event,
+            medium: notification.medium,
+            remark: notification.remark,
+            template_slug: notification.template_slug,
+            trigger_message: notification.trigger_message,
+            is_recurring: notification.is_recurring,
+            is_active: notification.is_active,
+            created_by: notification.created_by,
+          },
+        });
+
+        // Information messages now handled differently - only display if really important
+        if (tracker.progress % 5 === 0) {
+          // Show info message every 5 items
+          tracker.log(
+            `Created notification for event: ${notification.event}`,
+            "info"
+          );
+        }
+      } else {
+        tracker.log(
+          `Notification for event ${notification.event} already exists`,
+          "info"
+        );
+      }
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError(
+        "customer notification",
+        notification.template_name,
+        error.message
+      );
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Customer notifications");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/department.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 seedDepartments(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  try {
+    // Load departments from JSON
+    const departmentData = loadCoreData("departments");
+
+    // Process departments with optimized core seeder
+    const result = await seedCoreEntity(
+      prisma,
+      departmentData,
+      'departments',
+      {
+        model: 'department',
+        whereField: 'department_slug',
+        updateFields: ['department_name', 'description', 'is_active'],
+        createFields: ['department_name', 'department_slug', 'description', 'is_active']
+      },
+      {
+        profile: 'stability', // Departments are critical entities
+        enableRetries: true,
+        logProgress: true
+      }
+    );
+
+    return result;
+  } finally {
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}