procbay-schema 1.0.0

package/prisma/seeders/state.seed.js

@@ -0,0 +1,170 @@
+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 { connectionManager } from "./utils/connection-manager.js";
+import { createBulkSeeder } from "./utils/bulk-seeder.js";
+import { 
+  RetryHandler, 
+  MemoryManager,
+  createGeographicRetryHandler 
+} from "./utils/performance-helpers.js";
+
+const stateIdMap = new Map();
+
+async function processBatchOptimized(prisma, batch, countryIdMap, tracker, retryHandler) {
+  const statesToCreate = batch
+    .map((state) => {
+      const countryDbId = state.country_id
+        ? countryIdMap.get(state.country_id)
+        : null;
+      if (!countryDbId) {
+        return null; // Skip states with no matching country
+      }
+      return {
+        name: state.name,
+        country_id: countryDbId,
+        state_code: state.state_code || "",
+        type: state.type,
+        latitude: state.latitude ? parseFloat(state.latitude) : null,
+        longitude: state.longitude ? parseFloat(state.longitude) : null,
+        wikiDataId: state.wikiDataId,
+        status: true,
+      };
+    })
+    .filter(Boolean);
+
+  if (statesToCreate.length > 0) {
+    try {
+      // Use connection manager for transaction-based processing
+      const result = await retryHandler.execute(async () => {
+        return await prisma.state.createMany({
+          data: statesToCreate,
+          skipDuplicates: true,
+        });
+      }, `State batch (${statesToCreate.length} items)`);
+      
+      tracker.update(batch.length);
+      return { success: true, created: result.count };
+    } catch (error) {
+      logEntityError("state batch", "N/A", error.message);
+      tracker.update(batch.length);
+      return { success: false, error: error.message };
+    }
+  }
+  tracker.update(batch.length);
+  return { success: true, created: 0 };
+}
+
+async function repopulateStateIdMap(
+  prisma,
+  statesData,
+  countryIdMap
+) {
+  logSeederStart("Re-populating state ID map");
+  const countryDbIds = Array.from(countryIdMap.values());
+
+  if (countryDbIds.length === 0) {
+    logSeederComplete("State ID map re-population (no countries to-do)");
+    return;
+  }
+
+  const allCreatedStates = await prisma.state.findMany({
+    where: { country_id: { in: countryDbIds } },
+    select: { id: true, name: true, state_code: true, country_id: true },
+  });
+
+  const dbStateLookup = new Map();
+  allCreatedStates.forEach((s) => {
+    const key = `${s.country_id}|${s.name}|${s.state_code || ""}`;
+    dbStateLookup.set(key, s.id);
+  });
+
+  statesData.forEach((jsonState) => {
+    const countryDbId = countryIdMap.get(jsonState.country_id);
+    if (countryDbId) {
+      const key = `${countryDbId}|${jsonState.name}|${jsonState.state_code || ""}`;
+      const dbId = dbStateLookup.get(key);
+      if (dbId) {
+        stateIdMap.set(jsonState.id, dbId);
+      }
+    }
+  });
+  logSeederComplete("State ID map re-populated");
+}
+
+export async function seedStates(
+  prismaClient,
+  countryIdMap,
+  filteredCountryIds = null
+) {
+  const prisma = prismaClient || new PrismaClient();
+  logSeederStart("states");
+
+  try {
+    const statesData = loadGeoData("states");
+    let filteredStatesData = statesData;
+
+    if (filteredCountryIds && filteredCountryIds.size > 0) {
+      filteredStatesData = statesData.filter((state) =>
+        filteredCountryIds.has(state.country_id)
+      );
+      console.log(`Filtering states by ${filteredCountryIds.size} countries`);
+      console.log(
+        `Found ${filteredStatesData.length} matching states out of ${statesData.length} total`
+      );
+    }
+
+    const tracker = createProgressTracker(filteredStatesData.length, "states");
+const performanceConfig = createPerformanceConfig().getConfig('geographic', 'states');
+    const batchSize = performanceConfig.batchSize;
+    const batchPromises = [];
+
+    const retryHandler = new RetryHandler(
+      performanceConfig.retryAttempts || 3,
+      performanceConfig.retryDelay || 1000
+    );
+    // Log initial memory usage
+    MemoryManager.logMemoryUsage('Before state processing');
+
+    for (let i = 0; i < filteredStatesData.length; i += batchSize) {
+      const batch = filteredStatesData.slice(i, i + batchSize);
+      batchPromises.push(processBatchOptimized(prisma, batch, countryIdMap, tracker, retryHandler));
+      global.gc && global.gc(); // Hint garbage collection
+    }
+
+    // Execute batches and monitor memory
+    const results = await Promise.allSettled(batchPromises);
+    
+    // Check for failed batches
+    const failedBatches = results.filter(result => result.status === 'rejected');
+    if (failedBatches.length > 0) {
+      console.warn(`${failedBatches.length} state batches failed`);
+      failedBatches.forEach((result, index) => {
+        console.error(`Batch ${index} error:`, result.reason);
+      });
+    }
+
+    // Final memory cleanup
+    await MemoryManager.forceGarbageCollectionWithDelay();
+    MemoryManager.logMemoryUsage('After state processing');
+
+    await repopulateStateIdMap(prisma, statesData, countryIdMap);
+
+    logSeederComplete(`States${filteredCountryIds ? " (filtered)" : ""}`);
+    return stateIdMap;
+  } catch (error) {
+    logSeederError("states", error);
+    throw error;
+  } finally {
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+  }
+}

package/prisma/seeders/strategies.seed.js

@@ -0,0 +1,54 @@
+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 seedStrategies(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("strategies");
+
+  // Load strategies from JSON
+  const strategiesData = loadContentData("strategies");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(strategiesData.length, "strategies");
+
+  for (const strategy of strategiesData) {
+    try {
+      await prisma.strategies.upsert({
+        where: { name: strategy.name }, // Use a unique identifier
+        update: {
+          name: strategy.name,
+          description: strategy.description,
+          is_active: strategy.is_active,
+          updated_at: new Date(), // Update the timestamp when updating
+          updated_by: 1,
+        },
+        create: {
+          name: strategy.name,
+          description: strategy.description,
+          is_active: strategy.is_active,
+          created_at: new Date(),
+          created_by: 1,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError("strategy", strategy.name, error.message);
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Strategies");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/subregion.seed.js

@@ -0,0 +1,88 @@
+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";
+
+// Map to store JSON ID to database ID mapping
+const subregionIdMap = new Map();
+
+export async function seedSubregions(prismaClient, regionIdMap) {
+  // Use provided transaction object or create a new prisma client
+  const prisma = prismaClient || new PrismaClient();
+  logSeederStart("subregions");
+
+  try {
+    // Load subregions from JSON
+    const subregionsData = loadGeoData("subregions");
+
+    // Create progress tracker
+    const tracker = createProgressTracker(subregionsData.length, "subregions");
+
+    // Process each subregion using upsert
+    for (const subregion of subregionsData) {
+      const jsonId = subregion.id;
+      const regionJsonId = subregion.region_id;
+
+      try {
+        // Get the DB ID for the related region
+        const regionDbId = regionJsonId ? regionIdMap.get(regionJsonId) : null;
+
+        // Upsert subregion using Prisma
+        const dbSubregion = await prisma.subregion.upsert({
+          where: {
+            name: subregion.name,
+          },
+          update: {
+            translations: subregion.translations,
+            wikiDataId: subregion.wikiDataId,
+            region: regionDbId
+              ? {
+                  connect: { id: regionDbId },
+                }
+              : undefined,
+          },
+          create: {
+            name: subregion.name,
+            translations: subregion.translations,
+            wikiDataId: subregion.wikiDataId,
+            region: regionDbId
+              ? {
+                  connect: { id: regionDbId },
+                }
+              : undefined,
+          },
+        });
+
+        // Store the mapping between JSON ID and database ID
+        subregionIdMap.set(jsonId, dbSubregion.id);
+      } catch (error) {
+        // Log error but don't interrupt progress bar
+        logEntityError("subregion", subregion.name, error.message);
+      }
+      tracker.update();
+    }
+
+    logSeederComplete("Subregions");
+
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+
+    return subregionIdMap;
+  } catch (error) {
+    logSeederError("subregions", error);
+
+    // Only disconnect if we created our own client
+    if (!prismaClient) {
+      await prisma.$disconnect();
+    }
+
+    throw error;
+  }
+}

package/prisma/seeders/support-category.seed.js

@@ -0,0 +1,56 @@
+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 seedSupportCategories(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("support categories");
+
+  // Load support categories from JSON
+  const supportCategoryData = loadContentData("support-categories");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(
+    supportCategoryData.length,
+    "support categories"
+  );
+
+  for (const supportCategory of supportCategoryData) {
+    try {
+      await prisma.supportCategory.upsert({
+        where: {
+          name: supportCategory.name,
+        },
+        update: {
+          description: supportCategory.description,
+          slug: supportCategory.slug,
+          is_active: supportCategory.is_active,
+        },
+        create: {
+          name: supportCategory.name,
+          description: supportCategory.description,
+          slug: supportCategory.slug,
+          is_active: supportCategory.is_active,
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError("support category", supportCategory.name, error.message);
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Support categories");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}

package/prisma/seeders/template.seed.js

@@ -0,0 +1,87 @@
+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 seedTemplates(prismaClient) {
+  // Use the passed client or create new one only if needed (for standalone testing)
+  const prisma = prismaClient || new PrismaClient();
+
+  logSeederStart("templates");
+
+  // Load templates from JSON
+  const templateData = loadContentData("template");
+
+  // Create progress tracker
+  const tracker = createProgressTracker(templateData.length, "templates");
+
+  for (const template of templateData) {
+    try {
+      await prisma.template.upsert({
+        where: {
+          id: template.id, // Use a unique identifier for the template
+          template_code: template.template_code,
+        }, // Use a unique identifier
+        update: {
+          template_name: template.template_name,
+          template_type: template.template_type,
+          currency_id: template.currency_id,
+          is_active: true, // Set to true if you want the template to be active by default
+          updated_by: 1,
+          fields: {
+            update: template.fields.map((field) => ({
+              where: {
+                id: field.id, // Use a unique identifier for the field
+                field_name: field.field_name,
+              }, // Use a unique identifier for fields
+              data: {
+                field_type: field.field_type,
+                field_role: field.field_role,
+                field_placement: field.field_placement,
+                field_formula: field.field_formula,
+                is_mandatory: field.is_mandatory,
+                position: field.position,
+                updated_by: 1,
+              },
+            })),
+          },
+        },
+        create: {
+          template_code: template.template_code,
+          template_name: template.template_name,
+          template_type: template.template_type,
+          currency_id: template.currency_id,
+          is_active: true, // Set to true if you want the template to be active by default
+          created_by: 1,
+          fields: {
+            create: template.fields.map((field) => ({
+              field_name: field.field_name,
+              field_type: field.field_type,
+              field_role: field.field_role,
+              field_placement: field.field_placement,
+              field_formula: field.field_formula,
+              is_mandatory: field.is_mandatory,
+              position: field.position,
+              created_by: 1,
+            })),
+          },
+        },
+      });
+    } catch (error) {
+      // Log error but don't interrupt progress bar
+      logEntityError("template", template.template_name, error.message);
+    }
+    tracker.update();
+  }
+
+  logSeederComplete("Templates");
+
+  // Only disconnect if we created our own client
+  if (!prismaClient) {
+    await prisma.$disconnect();
+  }
+}