@procxo/shared 1.0.2 → 1.0.4

package/src/database/seeder/seeds/country.seed.ts

@@ -0,0 +1,58 @@
+import { DataSource } from 'typeorm';
+import { BaseSeeder } from '../base.seed';
+import { Country } from '../../entities/country.entity';
+import countryData from '../../../core/json/geographic-data/countries.json';
+
+export class CountrySeeder extends BaseSeeder {
+  readonly seederName = 'CountrySeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding countries...');
+
+    await this.executeInTransaction(async () => {
+      const repo = this.dataSource.getRepository(Country);
+
+      const existingCount = await repo.count();
+      if (existingCount > 0) {
+        this.log(
+          `Countries already exist (${existingCount} records). Skipping.`,
+        );
+        return;
+      }
+
+      const countries = countryData as any[];
+
+      for (const country of countries) {
+        const entity = repo.create({
+          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,
+          nationality: country.nationality,
+          latitude: country.latitude,
+          longitude: country.longitude,
+          emoji: country.emoji,
+          emojiU: country.emojiU,
+          timezones: country.timezones,
+        });
+        await repo.save(entity);
+      }
+
+      this.log(`Inserted ${countries.length} countries.`);
+    });
+
+    this.logSuccess('Countries seeded.');
+  }
+}

package/src/database/seeder/seeds/currency.seed.ts

@@ -0,0 +1,52 @@
+import { DataSource } from 'typeorm';
+import { BaseSeeder } from '../base.seed';
+import { Currency } from '../../entities/currency.entity';
+import currencyData from '../../../core/json/core-data/currency.json';
+
+export class CurrencySeeder extends BaseSeeder {
+  readonly seederName = 'CurrencySeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding currencies...');
+
+    let created = 0;
+    let updated = 0;
+
+    await this.executeInTransaction(async () => {
+      const repo = this.dataSource.getRepository(Currency);
+
+      for (const curr of currencyData as any[]) {
+        const existing = await repo.findOne({
+          where: { code: curr.code },
+        });
+
+        if (existing) {
+          await repo.update(existing.id, {
+            name: curr.name,
+            code: curr.code,
+            symbol: curr.symbol,
+            isActive: curr.isActive,
+          });
+          updated++;
+        } else {
+          const entity = repo.create({
+            name: curr.name,
+            code: curr.code,
+            symbol: curr.symbol,
+            isActive: curr.isActive,
+          });
+          await repo.save(entity);
+          created++;
+        }
+      }
+    });
+
+    this.logSuccess(
+      `Currencies seeded (created: ${created}, updated: ${updated}).`,
+    );
+  }
+}

package/src/database/seeder/seeds/department.seed.ts

@@ -0,0 +1,47 @@
+import { DataSource } from 'typeorm';
+import { BaseSeeder } from '../base.seed';
+import { Department } from '../../entities/department.entity';
+import departmentData from '../../../core/json/core-data/department.json';
+
+export class DepartmentSeeder extends BaseSeeder {
+  readonly seederName = 'DepartmentSeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding departments...');
+
+    await this.executeInTransaction(async () => {
+      const repo = this.dataSource.getRepository(Department);
+
+      for (const dept of departmentData as any[]) {
+        const existing = await repo.findOne({
+          where: { departmentSlug: dept.departmentSlug },
+        });
+
+        if (existing) {
+          await repo.update(existing.id, {
+            departmentName: dept.departmentName,
+            departmentDescription: dept.departmentDescription,
+            departmentSlug: dept.departmentSlug,
+            isActive: dept.isActive,
+          });
+          this.log(`Updated department: ${dept.departmentSlug}`);
+        } else {
+          const entity = repo.create({
+            departmentName: dept.departmentName,
+            departmentDescription: dept.departmentDescription,
+            departmentSlug: dept.departmentSlug,
+            isActive: dept.isActive,
+          });
+          await repo.save(entity);
+          this.log(`Created department: ${dept.departmentSlug}`);
+        }
+      }
+    });
+
+    this.logSuccess(`Departments seeded (${(departmentData as any[]).length} records).`);
+  }
+}

package/src/database/seeder/seeds/permission.seed.ts

@@ -0,0 +1,54 @@
+import { DataSource } from 'typeorm';
+import { BaseSeeder } from '../base.seed';
+import { Permission } from '../../entities/permission.entity';
+import permissionData from '../../../core/json/core-data/permission.json';
+
+export class PermissionSeeder extends BaseSeeder {
+  readonly seederName = 'PermissionSeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding permissions...');
+
+    let created = 0;
+    let updated = 0;
+
+    await this.executeInTransaction(async () => {
+      const repo = this.dataSource.getRepository(Permission);
+
+      for (const perm of permissionData as any[]) {
+        const existing = await repo.findOne({
+          where: { permissionSlug: perm.slug },
+        });
+
+        if (existing) {
+          await repo.update(existing.id, {
+            permissionName: perm.permissions_name,
+            permissionSlug: perm.slug,
+            permissionDescription: perm.description,
+            moduleName: perm.model,
+            isActive: perm.is_active,
+            createdBy: perm.created_by ?? null,
+          });
+          updated++;
+        } else {
+          const entity = repo.create({
+            permissionName: perm.permissions_name,
+            permissionSlug: perm.slug,
+            permissionDescription: perm.description,
+            moduleName: perm.model,
+            isActive: perm.is_active,
+            createdBy: perm.created_by ?? null,
+          });
+          await repo.save(entity);
+          created++;
+        }
+      }
+    });
+
+    this.logSuccess(`Permissions seeded (created: ${created}, updated: ${updated}).`);
+  }
+}

package/src/database/seeder/seeds/role-permission.seed.ts

@@ -0,0 +1,58 @@
+import { DataSource } from 'typeorm';
+import { BaseSeeder } from '../base.seed';
+import { Role } from '../../entities/role.entity';
+import { Permission } from '../../entities/permission.entity';
+import { RolePermission } from '../../entities/role-permission.entity';
+
+export class RolePermissionSeeder extends BaseSeeder {
+  readonly seederName = 'RolePermissionSeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding role-permission mappings...');
+
+    await this.executeInTransaction(async () => {
+      const roleRepo = this.dataSource.getRepository(Role);
+      const permissionRepo = this.dataSource.getRepository(Permission);
+      const rpRepo = this.dataSource.getRepository(RolePermission);
+
+      const allPermissions = await permissionRepo.find({
+        where: { isActive: true },
+      });
+
+      if (allPermissions.length === 0) {
+        this.log('No active permissions found. Skipping.');
+        return;
+      }
+
+      // Assign all permissions to Super Admin and Partner roles
+      const rolesToSeed = ['Super Admin', 'Partner'];
+
+      for (const roleName of rolesToSeed) {
+        const role = await roleRepo.findOne({ where: { roleName } });
+        if (!role) {
+          this.log(`Role "${roleName}" not found. Skipping.`);
+          continue;
+        }
+
+        // Delete existing mappings for this role
+        await rpRepo.delete({ role_id: role.id });
+        this.log(`Cleared existing mappings for "${roleName}".`);
+
+        // Create new mappings
+        const mappings = allPermissions.map((perm) => ({
+          role_id: role.id,
+          permission_id: perm.id,
+        }));
+
+        await rpRepo.save(mappings);
+        this.log(`Assigned ${mappings.length} permissions to "${roleName}".`);
+      }
+    });
+
+    this.logSuccess('Role-permission mappings seeded.');
+  }
+}

package/src/database/seeder/seeds/role.seed.ts

@@ -0,0 +1,52 @@
+import { DataSource } from 'typeorm';
+import { BaseSeeder } from '../base.seed';
+import { Role } from '../../entities/role.entity';
+import roleData from '../../../core/json/core-data/role.json';
+
+export class RoleSeeder extends BaseSeeder {
+  readonly seederName = 'RoleSeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding roles...');
+
+    let created = 0;
+    let updated = 0;
+
+    await this.executeInTransaction(async () => {
+      const repo = this.dataSource.getRepository(Role);
+
+      for (const role of roleData as any[]) {
+        const existing = await repo.findOne({
+          where: { roleName: role.roleName },
+        });
+
+        if (existing) {
+          await repo.update(existing.id, {
+            roleName: role.roleName,
+            roleSlug: role.roleSlug,
+            roleDescription: role.roleDescription,
+            isMainRoleSlug: role.isMainRoleSlug,
+            isActive: role.isActive,
+          });
+          updated++;
+        } else {
+          const entity = repo.create({
+            roleName: role.roleName,
+            roleSlug: role.roleSlug,
+            roleDescription: role.roleDescription,
+            isMainRoleSlug: role.isMainRoleSlug,
+            isActive: role.isActive,
+          });
+          await repo.save(entity);
+          created++;
+        }
+      }
+    });
+
+    this.logSuccess(`Roles seeded (created: ${created}, updated: ${updated}).`);
+  }
+}

package/src/database/seeder/seeds/user-role.seed.ts

@@ -0,0 +1,72 @@
+import { DataSource } from 'typeorm';
+import { BaseSeeder } from '../base.seed';
+import { User } from '../../entities/user.entity';
+import { Role } from '../../entities/role.entity';
+import { UserRole } from '../../entities/user-role.entity';
+import userData from '../../../core/json/core-data/user.json';
+
+export class UserRoleSeeder extends BaseSeeder {
+  readonly seederName = 'UserRoleSeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding user-role mappings...');
+
+    let created = 0;
+    let skipped = 0;
+
+    await this.executeInTransaction(async () => {
+      const userRepo = this.dataSource.getRepository(User);
+      const roleRepo = this.dataSource.getRepository(Role);
+      const urRepo = this.dataSource.getRepository(UserRole);
+
+      for (const u of userData as any[]) {
+        const user = await userRepo.findOne({
+          where: { email: u.email },
+          select: ['id', 'email'],
+        });
+        if (!user) {
+          this.log(`User "${u.email}" not found. Skipping.`);
+          skipped++;
+          continue;
+        }
+
+        const role = await roleRepo.findOne({
+          where: { roleName: u.roleName },
+          select: ['id', 'roleName'],
+        });
+        if (!role) {
+          this.log(`Role "${u.roleName}" not found. Skipping.`);
+          skipped++;
+          continue;
+        }
+
+        const existing = await urRepo.findOne({
+          where: { user_id: user.id, role_id: role.id },
+        });
+
+        if (!existing) {
+          const entity = urRepo.create({
+            user_id: user.id,
+            role_id: role.id,
+          });
+          await urRepo.save(entity);
+          created++;
+          this.log(`Linked user ${user.email} → role ${role.roleName}`);
+        } else {
+          skipped++;
+          this.log(
+            `User-role already exists: ${user.email} → ${role.roleName}`,
+          );
+        }
+      }
+    });
+
+    this.logSuccess(
+      `User-role mappings seeded (created: ${created}, skipped: ${skipped}).`,
+    );
+  }
+}

package/src/database/seeder/seeds/user.seed.ts

@@ -0,0 +1,87 @@
+import { DataSource } from 'typeorm';
+import * as crypto from 'crypto';
+import { BaseSeeder } from '../base.seed';
+import { User } from '../../entities/user.entity';
+import { Department } from '../../entities/department.entity';
+import userData from '../../../core/json/core-data/user.json';
+
+/**
+ * Simple password hashing using Node.js crypto (no bcrypt dependency needed in shared-lib).
+ * Consuming microservices should use bcrypt for production authentication.
+ */
+function hashPassword(password: string): string {
+  const salt = crypto.randomBytes(16).toString('hex');
+  const hash = crypto
+    .pbkdf2Sync(password, salt, 10000, 64, 'sha512')
+    .toString('hex');
+  return `${salt}:${hash}`;
+}
+
+export class UserSeeder extends BaseSeeder {
+  readonly seederName = 'UserSeeder';
+
+  constructor(dataSource: DataSource) {
+    super(dataSource);
+  }
+
+  async run(): Promise<void> {
+    this.log('Seeding users...');
+
+    let created = 0;
+    let updated = 0;
+
+    await this.executeInTransaction(async () => {
+      const userRepo = this.dataSource.getRepository(User);
+      const deptRepo = this.dataSource.getRepository(Department);
+
+      for (const u of userData as any[]) {
+        const existing = await userRepo.findOne({
+          where: { email: u.email },
+        });
+
+        // Resolve department
+        let departmentId: number | undefined = undefined;
+        if (u.departmentName) {
+          const dept = await deptRepo.findOne({
+            where: { departmentName: u.departmentName },
+          });
+          departmentId = dept ? dept.id : undefined;
+          if (!dept) {
+            this.log(
+              `Department "${u.departmentName}" not found for user "${u.email}".`,
+            );
+          }
+        }
+
+        const hashedPassword = hashPassword(u.password);
+
+        if (existing) {
+          await userRepo.update(existing.id, {
+            name: u.name,
+            email: u.email,
+            password: hashedPassword,
+            isActive: u.isActive,
+            phoneNumber: u.phoneNumber,
+            countryCode: u.countryCode ?? undefined,
+            departmentId,
+          });
+          updated++;
+        } else {
+          const entity = userRepo.create({
+            name: u.name,
+            email: u.email,
+            password: hashedPassword,
+            isActive: u.isActive,
+            phoneNumber: u.phoneNumber,
+            countryCode: u.countryCode ?? undefined,
+            departmentId,
+          });
+          await userRepo.save(entity);
+          created++;
+        }
+      }
+    });
+
+    this.logSuccess(`Users seeded (created: ${created}, updated: ${updated}).`);
+  }
+}

package/{dist/index.d.ts → src/index.ts}

@@ -1,5 +1,9 @@
+// Config
 export { createOrmConfig, getAllSharedEntities } from './config';
 export type { OrmConfigOptions } from './config';
+
+// All entities
 export * from './database';
+
+// Constants
 export * from './core/constant';
-//# sourceMappingURL=index.d.ts.map

package/src/scripts/create-schema.ts

@@ -0,0 +1,94 @@
+import { config } from 'dotenv';
+import { Client } from 'pg';
+
+config(); // Load .env
+
+const env = process.env.NODE_ENV || 'development';
+
+// Schemas that need to exist before migrations run
+const REQUIRED_SCHEMAS = ['user', 'core', 'timesheet', 'notification', 'public'];
+
+// ─── Schema creation ──────────────────────────────────────────
+
+async function createSchemas(): Promise<void> {
+  const client = new Client({
+    host: process.env.DB_HOST ?? 'localhost',
+    port: parseInt(process.env.DB_PORT ?? '5432'),
+    user: process.env.DB_USERNAME ?? 'postgres',
+    password: process.env.DB_PASSWORD ?? 'postgres',
+    database: process.env.DB_NAME ?? 'IVM',
+  });
+
+  try {
+    await client.connect();
+    console.log('  🔍 Checking database schemas...');
+
+    for (const schema of REQUIRED_SCHEMAS) {
+      // Check if schema exists
+      const result = await client.query(
+        `SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1`,
+        [schema]
+      );
+
+      if (result.rows.length === 0) {
+        // Schema doesn't exist, create it
+        await client.query(`CREATE SCHEMA IF NOT EXISTS "${schema}"`);
+        console.log(`  ✅ Created schema "${schema}"`);
+      } else {
+        console.log(`  ✓ Schema "${schema}" already exists`);
+      }
+    }
+  } catch (error) {
+    console.error('  ❌ Error checking/creating schemas:', error);
+    throw error;
+  } finally {
+    await client.end();
+  }
+}
+
+// ─── Main execution ────────────────────────────────────────────
+
+async function run(): Promise<void> {
+  const startTime = Date.now();
+
+  console.log('');
+  console.log('╔══════════════════════════════════════════════════╗');
+  console.log('║         🗄️  CREATE DATABASE SCHEMAS              ║');
+  console.log('╠══════════════════════════════════════════════════╣');
+  console.log(`║  Environment : ${env.padEnd(34)}║`);
+  console.log(`║  Database    : ${(process.env.DB_NAME ?? 'IVM').padEnd(34)}║`);
+  console.log(`║  Host        : ${(process.env.DB_HOST ?? 'localhost').padEnd(34)}║`);
+  console.log(`║  Schemas     : ${REQUIRED_SCHEMAS.join(', ').padEnd(34)}║`);
+  console.log('╚══════════════════════════════════════════════════╝');
+  console.log('');
+
+  try {
+    await createSchemas();
+
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════╗');
+    console.log('║           ✅ SCHEMA CREATION COMPLETE             ║');
+    console.log('╠══════════════════════════════════════════════════╣');
+    console.log(`║  Status     : Completed successfully`.padEnd(51) + '║');
+    console.log(`║  Time       : ${totalTime}s`.padEnd(51) + '║');
+    console.log('╚══════════════════════════════════════════════════╝');
+    console.log('');
+  } catch (error: any) {
+    console.error('');
+    console.error('╔══════════════════════════════════════════════════╗');
+    console.error('║           ❌ SCHEMA CREATION FAILED              ║');
+    console.error('╠══════════════════════════════════════════════════╣');
+    console.error(`║  Error: ${(error.message || 'Unknown error').padEnd(42)}║`);
+    console.error('╚══════════════════════════════════════════════════╝');
+    console.error('');
+    process.exit(1);
+  }
+}
+
+// ─── Execute ──────────────────────────────────────────────────
+
+run().catch((err) => {
+  console.error('❌ Fatal error:', err);
+  process.exit(1);
+});

package/dist/config/index.d.ts

@@ -1,2 +0,0 @@
-export { createOrmConfig, getAllSharedEntities, OrmConfigOptions, } from './ormconfig.factory';
-//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC"}

package/dist/config/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllSharedEntities = exports.createOrmConfig = void 0;
-var ormconfig_factory_1 = require("./ormconfig.factory");
-Object.defineProperty(exports, "createOrmConfig", { enumerable: true, get: function () { return ormconfig_factory_1.createOrmConfig; } });
-Object.defineProperty(exports, "getAllSharedEntities", { enumerable: true, get: function () { return ormconfig_factory_1.getAllSharedEntities; } });
-//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":";;;AAAA,yDAI6B;AAH3B,oHAAA,eAAe,OAAA;AACf,yHAAA,oBAAoB,OAAA"}

package/dist/config/ormconfig.factory.d.ts

@@ -1,10 +0,0 @@
-import { TypeOrmModuleOptions } from '@nestjs/typeorm';
-export interface OrmConfigOptions {
-    schema: string;
-    additionalEntities?: Function[];
-    synchronize?: boolean;
-    logging?: boolean;
-}
-export declare function getAllSharedEntities(): Function[];
-export declare function createOrmConfig(options: OrmConfigOptions): TypeOrmModuleOptions;
-//# sourceMappingURL=ormconfig.factory.d.ts.map

package/dist/config/ormconfig.factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ormconfig.factory.d.ts","sourceRoot":"","sources":["../../src/config/ormconfig.factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAwBvD,MAAM,WAAW,gBAAgB;IAE/B,MAAM,EAAE,MAAM,CAAC;IAEf,kBAAkB,CAAC,EAAE,QAAQ,EAAE,CAAC;IAEhC,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAKD,wBAAgB,oBAAoB,IAAI,QAAQ,EAAE,CA2BjD;AAcD,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,oBAAoB,CAsB/E"}

package/dist/config/ormconfig.factory.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllSharedEntities = getAllSharedEntities;
-exports.createOrmConfig = createOrmConfig;
-const entities_1 = require("../database/entities");
-function getAllSharedEntities() {
-    return [
-        entities_1.User, entities_1.Role, entities_1.Permission, entities_1.RolePermission, entities_1.UserRole, entities_1.Department, entities_1.FileData,
-        entities_1.Chat, entities_1.Entitlement, entities_1.LeaveType, entities_1.LeaveBalance, entities_1.LeaveRequest, entities_1.Gst, entities_1.UploadLog,
-        entities_1.OwnershipTransfer, entities_1.UserSessionHistory,
-        entities_1.ApprovalHierarchy, entities_1.ApprovalHierarchyRole, entities_1.ApprovalHierarchyUser,
-        entities_1.ApprovalLevel, entities_1.ApprovalLevelUser, entities_1.ApprovalLevelEscalation,
-        entities_1.ApprovalLevelEscalationUser, entities_1.ApprovalCondition, entities_1.ApprovalJourney,
-        entities_1.Currency, entities_1.Country, entities_1.City, entities_1.Client, entities_1.Contact, entities_1.Address,
-        entities_1.Matter, entities_1.MatterTag, entities_1.MatterTeamMember, entities_1.MatterTaskViewFilter,
-        entities_1.Task, entities_1.TaskType, entities_1.TaskUser, entities_1.TaskTag, entities_1.TaskComment, entities_1.TaskMilestone, entities_1.TaskReminder,
-        entities_1.SubTask, entities_1.SubTaskUser, entities_1.SubTaskTag, entities_1.Tag,
-        entities_1.Template, entities_1.TemplateTask,
-        entities_1.Invoice, entities_1.InvoiceItem, entities_1.UserInvoiceTemplateEntity,
-        entities_1.UserInvoiceTemplateHeaderEntity, entities_1.UserInvoiceTemplateTableEntity,
-        entities_1.UserInvoiceTemplateFooterEntity, entities_1.FixedInvoiceItem,
-        entities_1.Payment, entities_1.CreditNoteEntity, entities_1.Expense, entities_1.Group, entities_1.Superset,
-        entities_1.QuickBooksConnection, entities_1.QuickBooksSyncLog,
-        entities_1.ActivityLog, entities_1.TaskStatus, entities_1.TimesheetSummary, entities_1.SequenceGenerator,
-        entities_1.Timesheet, entities_1.TimesheetEvent, entities_1.TimesheetComment,
-        entities_1.Shift, entities_1.RoleShift, entities_1.UserShift, entities_1.Holiday,
-        entities_1.Alert, entities_1.UserNotificationPreference, entities_1.UserNotificationChannel,
-    ];
-}
-function createOrmConfig(options) {
-    const { schema, additionalEntities = [], synchronize = false, logging, } = options;
-    return {
-        type: 'postgres',
-        host: process.env.DB_HOST ?? 'localhost',
-        port: parseInt(process.env.DB_PORT ?? '5432', 10),
-        username: process.env.DB_USERNAME ?? 'postgres',
-        password: process.env.DB_PASSWORD ?? 'postgres',
-        database: process.env.DB_NAME ?? 'IVM',
-        entities: [...getAllSharedEntities(), ...additionalEntities],
-        schema,
-        synchronize,
-        logging: logging ?? process.env.NODE_ENV === 'development',
-        retryAttempts: 3,
-        retryDelay: 3000,
-    };
-}
-//# sourceMappingURL=ormconfig.factory.js.map