@procxo/shared 1.0.4 → 1.0.5

package/src/database/seeder/config/seeder.config.ts

@@ -1,26 +0,0 @@
-export interface SeederEnvironmentConfig {
-  /** Whether to truncate tables before seeding */
-  truncate: boolean;
-  /** Enable verbose logging */
-  logging: boolean;
-  /** Schemas to create before seeding */
-  schemas: string[];
-}
-
-export const seederConfig: Record<string, SeederEnvironmentConfig> = {
-  development: {
-    truncate: false,
-    logging: true,
-    schemas: ['user', 'core', 'timesheet', 'notification'],
-  },
-  production: {
-    truncate: false,
-    logging: false,
-    schemas: ['user', 'core', 'timesheet', 'notification'],
-  },
-  test: {
-    truncate: true,
-    logging: false,
-    schemas: ['user', 'core', 'timesheet', 'notification'],
-  },
-};

package/src/database/seeder/errors/seeder.error.ts

@@ -1,20 +0,0 @@
-export class SeederError extends Error {
-  constructor(message: string, public readonly context?: any) {
-    super(message);
-    this.name = 'SeederError';
-  }
-}
-
-export class ValidationError extends SeederError {
-  constructor(message: string, context?: any) {
-    super(message, context);
-    this.name = 'ValidationError';
-  }
-}
-
-export class DependencyError extends SeederError {
-  constructor(message: string, context?: any) {
-    super(message, context);
-    this.name = 'DependencyError';
-  }
-}

package/src/database/seeder/seed-runner.ts

@@ -1,200 +0,0 @@
-import 'reflect-metadata';
-import { DataSource } from 'typeorm';
-import { config } from 'dotenv';
-import { Client } from 'pg';
-import { getAllSharedEntities } from '../../config/ormconfig.factory';
-import { seederConfig } from './config/seeder.config';
-
-// Individual seeders
-import { DepartmentSeeder } from './seeds/department.seed';
-import { PermissionSeeder } from './seeds/permission.seed';
-import { RoleSeeder } from './seeds/role.seed';
-import { RolePermissionSeeder } from './seeds/role-permission.seed';
-import { UserSeeder } from './seeds/user.seed';
-import { UserRoleSeeder } from './seeds/user-role.seed';
-import { CurrencySeeder } from './seeds/currency.seed';
-import { CountrySeeder } from './seeds/country.seed';
-import { CitySeeder } from './seeds/city.seed';
-
-config(); // Load .env
-
-const env = process.env.NODE_ENV || 'development';
-const envConfig = seederConfig[env];
-
-// ─── Progress helper ──────────────────────────────────────────
-
-function progressBar(current: number, total: number, label: string): string {
-  const width = 30;
-  const filled = Math.round((current / total) * width);
-  const empty = width - filled;
-  const bar = '█'.repeat(filled) + '░'.repeat(empty);
-  const pct = Math.round((current / total) * 100);
-  return `  [${bar}] ${pct}% (${current}/${total}) ${label}`;
-}
-
-// ─── Schema creation ──────────────────────────────────────────
-
-async function createSchemas(): Promise<void> {
-  const client = new Client({
-    host: process.env.DB_HOST,
-    port: parseInt(process.env.DB_PORT ?? '5432'),
-    user: process.env.DB_USERNAME,
-    password: process.env.DB_PASSWORD,
-    database: process.env.DB_NAME,
-  });
-
-  try {
-    await client.connect();
-
-    for (const schema of envConfig.schemas) {
-      await client.query(`CREATE SCHEMA IF NOT EXISTS "${schema}"`);
-      console.log(`  ✅ Schema "${schema}" ready`);
-    }
-  } catch (error) {
-    console.error('  ❌ Error creating schemas:', error);
-    throw error;
-  } finally {
-    await client.end();
-  }
-}
-
-// ─── DataSource ───────────────────────────────────────────────
-
-function createDataSource(): DataSource {
-  return new DataSource({
-    type: 'postgres',
-    host: process.env.DB_HOST ?? 'localhost',
-    port: parseInt(process.env.DB_PORT ?? '5432'),
-    username: process.env.DB_USERNAME ?? 'postgres',
-    password: process.env.DB_PASSWORD ?? 'postgres',
-    database: process.env.DB_NAME ?? 'IVM',
-    entities: getAllSharedEntities(),
-    synchronize: false,
-    logging: true,
-  });
-}
-
-// ─── Seeder registry ──────────────────────────────────────────
-
-interface SeederEntry {
-  name: string;
-  factory: (ds: DataSource) => { run(): Promise<void> };
-}
-
-const SEEDERS: SeederEntry[] = [
-  { name: 'Department',       factory: (ds) => new DepartmentSeeder(ds) },
-  { name: 'Permission',       factory: (ds) => new PermissionSeeder(ds) },
-  { name: 'Role',             factory: (ds) => new RoleSeeder(ds) },
-  { name: 'RolePermission',   factory: (ds) => new RolePermissionSeeder(ds) },
-  { name: 'User',             factory: (ds) => new UserSeeder(ds) },
-  { name: 'UserRole',         factory: (ds) => new UserRoleSeeder(ds) },
-  { name: 'Currency',         factory: (ds) => new CurrencySeeder(ds) },
-  { name: 'Country',          factory: (ds) => new CountrySeeder(ds) },
-  { name: 'City',             factory: (ds) => new CitySeeder(ds) },
-];
-
-// ─── Main runner ──────────────────────────────────────────────
-
-async function runSeeders(): Promise<void> {
-  const startTime = Date.now();
-
-  console.log('');
-  console.log('╔══════════════════════════════════════════════════╗');
-  console.log('║          🌱 SHARED-LIB SEED RUNNER              ║');
-  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     : ${envConfig.schemas.join(', ').padEnd(34)}║`);
-  console.log('╚══════════════════════════════════════════════════╝');
-  console.log('');
-
-  // ── Step 1: Create schemas ──
-  console.log('━━━ Step 1/3: Creating database schemas ━━━');
-  await createSchemas();
-  console.log('');
-
-  // ── Step 2: Initialize DataSource ──
-  console.log('━━━ Step 2/3: Initializing DataSource (sync tables) ━━━');
-  const dataSource = createDataSource();
-  await dataSource.initialize();
-  console.log('  ✅ DataSource initialized & tables synchronized');
-  console.log('');
-
-  // ── Step 3: Run seeders ──
-  console.log('━━━ Step 3/3: Running seeders ━━━');
-  console.log('');
-
-  const total = SEEDERS.length;
-  const results: { name: string; status: 'success' | 'failed'; time: number; error?: string }[] = [];
-
-  for (let i = 0; i < SEEDERS.length; i++) {
-    const seeder = SEEDERS[i];
-    const seederStart = Date.now();
-
-    console.log(progressBar(i, total, `→ ${seeder.name}`));
-
-    try {
-      await seeder.factory(dataSource).run();
-      const elapsed = Date.now() - seederStart;
-      results.push({ name: seeder.name, status: 'success', time: elapsed });
-    } catch (error: any) {
-      const elapsed = Date.now() - seederStart;
-      results.push({
-        name: seeder.name,
-        status: 'failed',
-        time: elapsed,
-        error: error.message,
-      });
-      console.error(`  ❌ ${seeder.name} FAILED: ${error.message}`);
-      // Continue with remaining seeders unless it's a critical dependency
-      if (['Department', 'Permission', 'Role', 'User'].includes(seeder.name)) {
-        console.error('  ⛔ Critical seeder failed. Aborting remaining seeders.');
-        break;
-      }
-    }
-    console.log('');
-  }
-
-  // Final progress
-  console.log(progressBar(total, total, '→ Complete'));
-  console.log('');
-
-  // ── Summary ──
-  await dataSource.destroy();
-
-  const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
-  const successCount = results.filter((r) => r.status === 'success').length;
-  const failedCount = results.filter((r) => r.status === 'failed').length;
-
-  console.log('╔══════════════════════════════════════════════════╗');
-  console.log('║              📊 SEEDING SUMMARY                 ║');
-  console.log('╠══════════════════════════════════════════════════╣');
-
-  for (const r of results) {
-    const icon = r.status === 'success' ? '✅' : '❌';
-    const timeStr = `${r.time}ms`;
-    const line = `║  ${icon} ${r.name.padEnd(25)} ${timeStr.padStart(10)}    ║`;
-    console.log(line);
-  }
-
-  console.log('╠══════════════════════════════════════════════════╣');
-  console.log(`║  Total: ${successCount} passed, ${failedCount} failed`.padEnd(51) + '║');
-  console.log(`║  Time : ${totalTime}s`.padEnd(51) + '║');
-  console.log('╚══════════════════════════════════════════════════╝');
-  console.log('');
-
-  if (failedCount > 0) {
-    console.log('Failed seeders:');
-    for (const r of results.filter((r) => r.status === 'failed')) {
-      console.log(`  - ${r.name}: ${r.error}`);
-    }
-    process.exit(1);
-  }
-}
-
-// ─── Execute ──────────────────────────────────────────────────
-runSeeders().catch((err) => {
-  console.error('❌ Fatal error:', err);
-  process.exit(1);
-});

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

@@ -1,70 +0,0 @@
-import { DataSource } from 'typeorm';
-import { BaseSeeder } from '../base.seed';
-import { City } from '../../entities/city.entity';
-import { Country } from '../../entities/country.entity';
-import cityData from '../../../core/json/geographic-data/cities.json';
-
-export class CitySeeder extends BaseSeeder {
-  readonly seederName = 'CitySeeder';
-
-  constructor(dataSource: DataSource) {
-    super(dataSource);
-  }
-
-  async run(): Promise<void> {
-    this.log('Seeding cities...');
-
-    await this.executeInTransaction(async () => {
-      const cityRepo = this.dataSource.getRepository(City);
-      const countryRepo = this.dataSource.getRepository(Country);
-
-      const existingCount = await cityRepo.count();
-      if (existingCount > 0) {
-        this.log(
-          `Cities already exist (${existingCount} records). Skipping.`,
-        );
-        return;
-      }
-
-      // Build country lookup: iso2 → id
-      const countries = await countryRepo.find();
-      const countryMap = new Map<string, number>();
-      for (const c of countries) {
-        if (c.iso2) countryMap.set(c.iso2, c.id);
-      }
-
-      const cities = cityData as any[];
-      const batchSize = 500;
-      let totalInserted = 0;
-
-      for (let i = 0; i < cities.length; i += batchSize) {
-        const batch = cities.slice(i, i + batchSize);
-        const entities = batch
-          .map((city) => {
-            const countryId = countryMap.get(city.country_code);
-            if (!countryId) return null;
-            return cityRepo.create({
-              name: city.name,
-              latitude: city.latitude,
-              longitude: city.longitude,
-              country_id: countryId,
-            });
-          })
-          .filter(Boolean);
-
-        if (entities.length > 0) {
-          await cityRepo.save(entities as City[]);
-          totalInserted += entities.length;
-        }
-
-        this.log(
-          `Batch ${Math.floor(i / batchSize) + 1}: inserted ${entities.length} cities`,
-        );
-      }
-
-      this.log(`Total cities inserted: ${totalInserted}`);
-    });
-
-    this.logSuccess('Cities seeded.');
-  }
-}

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

@@ -1,58 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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}).`);
-  }
-}