procbay-schema 1.0.64 → 1.0.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "procbay-schema",
-  "version": "1.0.64",
+  "version": "1.0.66",
   "description": "A set of utilities for managing Prisma database schemas, seeding, and maintenance operations for the Procure-to-Pay system",
   "main": "src/prisma/index.js",
   "type": "module",

package/prisma/migrations/20251103094558_added_user_envirnoment_in_user_table/migration.sql

@@ -0,0 +1,5 @@
+-- CreateEnum
+CREATE TYPE "EnvironmentEnum" AS ENUM ('PRODUCTION', 'SANDBOX');
+
+-- AlterTable
+ALTER TABLE "users" ADD COLUMN     "user_environment" "EnvironmentEnum" NOT NULL DEFAULT 'PRODUCTION';

package/prisma/schema.prisma

@@ -39,6 +39,11 @@ enum StatusEnum {
   Suspended
 }
 
+enum EnvironmentEnum {
+  PRODUCTION
+  SANDBOX
+}
+
 model User {
   id                             Int                           @id @default(autoincrement())
   uuid                           String?                       @unique @default(uuid())
@@ -68,6 +73,7 @@ model User {
   is_deleted                     Boolean                       @default(false)
   deleted_at                     DateTime?                     @db.Timestamptz(6)
   deleted_by                     Int?
+  user_environment               EnvironmentEnum               @default(PRODUCTION)
   user_roles                     UserRole[]
   user_department                UserDepartment[]
   approval_hierarchy             ApprovalHierarchy[]

package/prisma/seeders/seed.js

@@ -199,14 +199,27 @@ function parseArgs() {
  *
  * @param {string[]} [countryFilter] - Optional array of country names to filter geographic data
  * @param {string[]} [industryFilter] - Optional array of industry names to filter content data
+ * @param {Object} [options] - Additional options
+ * @param {string} [options.schema] - Target PostgreSQL schema (for multi-schema support)
+ * @param {Object} [options.prismaClient] - Custom Prisma client (for multi-schema support)
  */
 export async function main(
   countryFilter = ["India", "United States", "Canada"],
-  industryFilter = ["Healthcare"]
+  industryFilter = ["Healthcare"],
+  options = {}
 ) {
   let connectionManager;
   let seederManager;
 
+  // Extract options
+  const {
+    schema = process.env.TARGET_SCHEMA || "procbay_schema",
+    prismaClient = null,
+  } = options;
+
+  // Use custom prisma client if provided, otherwise use global
+  const activePrisma = prismaClient || prisma;
+
   try {
     // Initialize seeder manager with auto-config selection
     const environment = process.env.NODE_ENV || "development";
@@ -235,6 +248,7 @@ export async function main(
     console.log("\n================= SEED PROCESS STARTED =================");
     console.log(`Node version: ${process.version}`);
     console.log(`Environment: ${environment}`);
+    console.log(`Target Schema: ${schema}`);
     console.log(`Memory usage: ${JSON.stringify(process.memoryUsage())}`);
     console.log(
       `Database URL: ${
@@ -254,7 +268,9 @@ export async function main(
       industryFilter = args.industries || [];
     }
 
-    logger.header("🌱 DATABASE SEEDING PROCESS");
+    logger.header(
+      `🌱 DATABASE SEEDING PROCESS ${schema !== "procbay_schema" ? `[Schema: ${schema}]` : ""}`
+    );
 
     if (countryFilter.length > 0) {
       logger.info(`Country filter applied: ${countryFilter.join(", ")}`);
@@ -270,7 +286,11 @@ export async function main(
     logger.info("Starting geographic data seeding...");
     try {
       // Run the geographic data seeding with connection retries
-      await seedGeographicDataWithRetry(countryFilter, seederManager);
+      await seedGeographicDataWithRetry(
+        countryFilter,
+        seederManager,
+        activePrisma
+      );
       logger.success("Geographic data seeded successfully");
     } catch (error) {
       logger.error(`Geographic data seeding failed: ${error.message}`);
@@ -282,7 +302,7 @@ export async function main(
     // Seed base/core data next
     logger.info("Starting core data seeding...");
     try {
-      await seedCoreDataWithRetry(seederManager);
+      await seedCoreDataWithRetry(seederManager, activePrisma);
       logger.success("Core data seeded successfully");
     } catch (error) {
       logger.error(`Core data seeding failed: ${error.message}`);
@@ -294,7 +314,11 @@ export async function main(
     // Seed catalog and content data
     logger.info("Starting content data seeding...");
     try {
-      await seedContentDataWithRetry(seederManager, industryFilter);
+      await seedContentDataWithRetry(
+        seederManager,
+        industryFilter,
+        activePrisma
+      );
       logger.success("Content data seeded successfully");
     } catch (error) {
       logger.error(`Content data seeding failed: ${error.message}`);
@@ -336,10 +360,12 @@ export async function main(
  *
  * @param {string[]} [countryFilter] - Optional array of country names to filter by
  * @param {Object} [seederManager] - Seeder manager with performance configuration
+ * @param {Object} [activePrisma] - Prisma client instance
  */
 export async function seedGeographicData(
   countryFilter = [],
-  seederManager = null
+  seederManager = null,
+  activePrisma = prisma
 ) {
   logger.header("🌎 GEOGRAPHIC DATA SEEDING");
 
@@ -355,7 +381,7 @@ export async function seedGeographicData(
   );
 
   try {
-    await prisma.$transaction(
+    await activePrisma.$transaction(
       async (tx) => {
         // Always seed all regions and subregions regardless of country filter
         logger.info(`Seeding ${colors.highlight("regions")}...`);
@@ -439,12 +465,13 @@ export async function seedGeographicData(
 async function seedGeographicDataWithRetry(
   countryFilter = [],
   seederManager = null,
+  activePrisma = prisma,
   maxRetries = 3
 ) {
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
       logger.info(`Geographic data seeding attempt ${attempt}/${maxRetries}`);
-      await seedGeographicData(countryFilter, seederManager);
+      await seedGeographicData(countryFilter, seederManager, activePrisma);
       return; // Success, exit the function
     } catch (error) {
       logger.warn(
@@ -464,8 +491,10 @@ async function seedGeographicDataWithRetry(
 
 /**
  * Seeds core data (users, roles, permissions, etc.)
+ * @param {Object} [seederManager] - Seeder manager with performance configuration
+ * @param {Object} [activePrisma] - Prisma client instance
  */
-export async function seedCoreData(seederManager) {
+export async function seedCoreData(seederManager, activePrisma = prisma) {
   logger.header("👤 CORE DATA SEEDING");
 
   try {
@@ -473,53 +502,59 @@ export async function seedCoreData(seederManager) {
     const coreDataItems = [
       {
         name: "Serial Number Configurations",
-        fn: (prisma, seederMgr) =>
-          seedSerialNumberConfigurations(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedSerialNumberConfigurations(prismaClient, seederMgr),
       },
       {
         name: "Departments",
-        fn: (prisma, seederMgr) => seedDepartments(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedDepartments(prismaClient, seederMgr),
       },
       {
         name: "Currencies",
-        fn: (prisma, seederMgr) => seedCurrencies(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedCurrencies(prismaClient, seederMgr),
       },
       {
         name: "Users",
-        fn: (prisma, seederMgr) => seedUsers(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) => seedUsers(prismaClient, seederMgr),
       },
       {
         name: "Roles",
-        fn: (prisma, seederMgr) => seedRoles(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) => seedRoles(prismaClient, seederMgr),
       },
       {
         name: "Permissions",
-        fn: (prisma, seederMgr) => seedPermissions(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedPermissions(prismaClient, seederMgr),
       },
       {
         name: "Role permissions",
-        fn: (prisma, seederMgr) => seedRolePermission(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedRolePermission(prismaClient, seederMgr),
       },
       {
         name: "User roles",
-        fn: (prisma, seederMgr) => seedUserRole(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) => seedUserRole(prismaClient, seederMgr),
       },
       {
         name: "User event configurations",
-        fn: (prisma, seederMgr) =>
-          seedUserEventConfigurations(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedUserEventConfigurations(prismaClient, seederMgr),
       },
       {
         name: "Templates",
-        fn: (prisma, seederMgr) => seedTemplates(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) => seedTemplates(prismaClient, seederMgr),
       },
       {
         name: "Email Templates",
-        fn: (prisma, seederMgr) => seedEmailTemplate(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedEmailTemplate(prismaClient, seederMgr),
       },
       {
         name: "Dynamic Forms",
-        fn: (prisma, seederMgr) => seedDynamicForm(prisma, seederMgr),
+        fn: (prismaClient, seederMgr) =>
+          seedDynamicForm(prismaClient, seederMgr),
       },
     ];
 
@@ -531,7 +566,7 @@ export async function seedCoreData(seederManager) {
     // Run core seeders in sequence
     for (const item of coreDataItems) {
       logger.info(`Seeding ${colors.highlight(item.name)}...`);
-      await item.fn(prisma, seederManager);
+      await item.fn(activePrisma, seederManager);
       progress.update();
     }
 
@@ -544,11 +579,15 @@ export async function seedCoreData(seederManager) {
 }
 
 // Add retry wrappers for each seeding phase
-async function seedCoreDataWithRetry(seederManager, maxRetries = 3) {
+async function seedCoreDataWithRetry(
+  seederManager,
+  activePrisma = prisma,
+  maxRetries = 3
+) {
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
       logger.info(`Core data seeding attempt ${attempt}/${maxRetries}`);
-      await seedCoreData(seederManager);
+      await seedCoreData(seederManager, activePrisma);
       return; // Success, exit the function
     } catch (error) {
       logger.warn(
@@ -571,10 +610,12 @@ async function seedCoreDataWithRetry(seederManager, maxRetries = 3) {
  *
  * @param {Object} [seederManager] - Seeder manager with performance configuration
  * @param {string[]} [industryFilter] - Optional array of industry names to filter
+ * @param {Object} [activePrisma] - Prisma client instance
  */
 export async function seedContentData(
   seederManager = null,
-  industryFilter = []
+  industryFilter = [],
+  activePrisma = prisma
 ) {
   logger.header("📋 CONTENT DATA SEEDING");
 
@@ -591,14 +632,14 @@ export async function seedContentData(
     // Seed industries first and get the industry ID map
     logger.info(`Seeding ${colors.highlight("Industries")}...`);
     const industryIdMap = await seedIndustries(
-      prisma,
+      activePrisma,
       seederManager,
       industryFilter
     );
 
     // Seed categories using the industry ID map for filtering
     logger.info(`Seeding ${colors.highlight("Categories")}...`);
-    await seedCategories(prisma, seederManager, industryIdMap);
+    await seedCategories(activePrisma, seederManager, industryIdMap);
 
     logger.success(
       `Content data seeding completed successfully ${
@@ -615,12 +656,13 @@ export async function seedContentData(
 async function seedContentDataWithRetry(
   seederManager = null,
   industryFilter = [],
+  activePrisma = prisma,
   maxRetries = 3
 ) {
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
       logger.info(`Content data seeding attempt ${attempt}/${maxRetries}`);
-      await seedContentData(seederManager, industryFilter);
+      await seedContentData(seederManager, industryFilter, activePrisma);
       return; // Success, exit the function
     } catch (error) {
       logger.warn(