@procxo/shared 1.0.2 → 1.0.4

package/src/database/entities/user.entity.ts

@@ -0,0 +1,198 @@
+import { Entity, Column, OneToMany, ManyToOne, JoinColumn, OneToOne } from 'typeorm';
+import { BaseEntity } from './base.entity';
+import { Department } from './department.entity';
+import { UserRole } from './user-role.entity';
+import { ApprovalLevelUser } from './approval-level-user.entity';
+import { ApprovalLevelEscalation } from './approval-level-escalation.entity';
+import { ApprovalLevelEscalationUser } from './approval-level-escalation-user.entity';
+import { ApprovalJourney } from './approval-journey.entity';
+import { Chat } from './chat.entity';
+import { UserSessionHistory } from './user-session-history.entity';
+import { UploadLog } from './upload-log.entity';
+import { OwnershipTransfer } from './transfer-ownership.entity';
+import { Shift } from './shift.entity';
+import { UserShift } from './user-shift.entity';
+import { Timesheet } from './timesheet.entity';
+import { TimesheetEvent } from './timesheet-event.entity';
+import { Matter } from './matter.entity';
+import { CreditNoteEntity } from './credit-note.entity';
+import { TaskUser } from './task-user.entity';
+import { SubTaskUser } from './subtask-user.entity';
+import { MatterTeamMember } from './matter-team-member.entity';
+import { Superset } from './superset.entity';
+import { TaskComment } from './task-comment.entity';
+import { Invoice } from './invoice.entity';
+import { Expense } from './expense.entity';
+
+@Entity({ name: 'users', schema: 'user' })
+export class User extends BaseEntity {
+  @Column({ name: 'name' })
+  name: string;
+
+  @Column({ name: 'email', unique: true })
+  email: string;
+
+  @Column({ name: 'password', nullable: true })
+  password: string;
+
+  @Column({ name: 'language', default: 'en', nullable: true })
+  language: string;
+
+  @Column({ name: 'timezone', default: 'Asia/Kolkata', nullable: true })
+  timezone: string;
+
+  @Column({ name: 'phone_number', nullable: true })
+  phoneNumber: string;
+
+  @Column({ name: 'country_code', nullable: true })
+  countryCode: string;
+
+  @Column({ name: 'department_id', nullable: true })
+  departmentId: number;
+
+  @Column({ name: 'reports_to', type: 'jsonb', nullable: true })
+  reportsTo: any;
+
+  @Column({ name: 'file_id', nullable: true })
+  fileId: number;
+
+  @Column({ name: 'refresh_token', nullable: true })
+  refreshToken: string;
+
+  @Column({ name: 'reset_token', nullable: true })
+  resetToken: string;
+
+  @Column({ name: 'reset_token_expires', nullable: true })
+  resetTokenExpires: Date;
+
+  @Column({ name: 'is_active', default: true })
+  isActive: boolean;
+
+  @Column({ name: 'is_verified', default: false })
+  isVerified: boolean;
+
+  @Column({ name: 'hourly_rate', nullable: true })
+  hourlyRate: number;
+
+  @Column({ name: 'ntrackid', nullable: true })
+  ntrackId: number;
+
+  @Column({ name: 'ntrackempid', nullable: true })
+  ntrackEmpId: string;
+
+  @Column({ name: 'ntrack_password', nullable: true })
+  ntrackPassword: string;
+
+  @ManyToOne(() => Department, (department) => department.users)
+  @JoinColumn({ name: 'department_id' })
+  department: Department;
+
+  @OneToMany(() => UserRole, (userRole) => userRole.user, { cascade: true })
+  user_roles: UserRole[];
+
+  @OneToMany(
+    () => ApprovalLevelUser,
+    (approvalLevelUser) => approvalLevelUser.user,
+    { cascade: true },
+  )
+  approval_level_user: ApprovalLevelUser[];
+
+  @OneToMany(
+    () => ApprovalLevelEscalation,
+    (approvalLevelEscalation) => approvalLevelEscalation.user,
+    { cascade: true },
+  )
+  approval_level_escalation: ApprovalLevelEscalation[];
+
+  @OneToMany(
+    () => ApprovalLevelEscalationUser,
+    (approvalLevelEscalationUser) => approvalLevelEscalationUser.user,
+    { cascade: true },
+  )
+  approval_level_escalation_user: ApprovalLevelEscalationUser[];
+
+  @OneToMany(
+    () => ApprovalJourney,
+    (approvalJourney) => approvalJourney.user,
+    { cascade: true },
+  )
+  approval_journey: ApprovalJourney[];
+
+  @OneToMany(
+    () => ApprovalJourney,
+    (approvalJourney) => approvalJourney.requester,
+    { cascade: true },
+  )
+  approval_journey_requester: ApprovalJourney[];
+
+  @OneToMany(() => Chat, (chat) => chat.sender)
+  sent_chats: Chat[];
+
+  @OneToMany(() => Chat, (chat) => chat.receiver)
+  received_chats: Chat[];
+
+  @OneToMany(
+    () => UserSessionHistory,
+    (userSessionHistory) => userSessionHistory.user,
+    { cascade: true },
+  )
+  user_session_history: UserSessionHistory[];
+
+  @OneToMany(() => UploadLog, (uploadLog) => uploadLog.user)
+  uploadLogs: UploadLog[];
+
+  @OneToMany(()=>OwnershipTransfer, (ownershipTransfer) => ownershipTransfer.ownershipTransferFromUser)
+  ownershipTransfersFrom: OwnershipTransfer[];
+
+  @OneToMany(()=>OwnershipTransfer, (ownershipTransfer) => ownershipTransfer.ownershipTransferToUser)
+  ownershipTransfersTo: OwnershipTransfer[];
+
+  @OneToMany(()=>OwnershipTransfer, (ownershipTransfer) => ownershipTransfer.transferredByUser)
+  ownershipTransfersBy: OwnershipTransfer[];
+
+  @OneToMany(() => TimesheetEvent, (timesheetEvent) => timesheetEvent.user)
+  timesheetEvents: TimesheetEvent[];
+
+  @OneToMany(() => Timesheet, (timesheet) => timesheet.user)
+  timesheets: Timesheet[];
+
+  @OneToOne(() => UserShift, userShift => userShift.user) // Establish the inverse relationship
+  userShift: UserShift;
+
+  @OneToMany(() => Shift, (shift) => shift.created_By)
+  shifts: Shift[];
+
+
+  @OneToMany(() => Matter, (matter) => matter.user)
+  matters: Matter[];
+
+  @OneToMany(() => CreditNoteEntity, (creditNote) => creditNote.raisedBy)
+  creditNotes: CreditNoteEntity[];
+
+  @OneToMany(() => TaskUser, (taskUser) => taskUser.user)
+  tasks: TaskUser[];
+
+  @OneToMany(() => SubTaskUser, (subTaskUser) => subTaskUser.user)
+  subtasks: SubTaskUser[];
+
+  @OneToMany(() => Expense, (expense) => expense.requester)
+  expenses: Expense[];
+
+  @OneToMany(() => Invoice, (invoice) => invoice.approvedBy)
+  approvedInvoices: Invoice[];
+
+  @OneToMany(() => Invoice, (invoice) => invoice.approvalRequestedBy)
+  requestedInvoices: Invoice[];
+
+  @OneToMany(
+    () => MatterTeamMember,
+    (matterTeamMember) => matterTeamMember.user,
+  )
+  teamMembers: MatterTeamMember[];
+
+  @OneToMany(() => Superset, (superset) => superset.user)
+  supersetCharts: Superset[];
+
+  @OneToMany(() => TaskComment, (taskComment) => taskComment.user)
+  taskComments: TaskComment[];
+}

package/src/database/index.ts

@@ -0,0 +1 @@
+export * from './entities';

package/{dist/database/migrations/1770706648232-initialMigration.js → src/database/migrations/1770706648232-initialMigration.ts}

@@ -1,9 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InitialMigration1770706648232 = void 0;
-class InitialMigration1770706648232 {
-    name = 'InitialMigration1770706648232';
-    async up(queryRunner) {
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class InitialMigration1770706648232 implements MigrationInterface {
+    name = 'InitialMigration1770706648232'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
         await queryRunner.query(`CREATE TABLE "core"."activity_logs" ("id" SERIAL NOT NULL, "uuid" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "created_by" integer, "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_by" integer, "is_deleted" boolean NOT NULL DEFAULT false, "deleted_by" integer, "deleted_at" TIMESTAMP, "user_id" integer, "resource_type" character varying, "resource_id" integer, "action" character varying, "description" character varying, "before_data" json, "after_data" json, CONSTRAINT "PK_f25287b6140c5ba18d38776a796" PRIMARY KEY ("id"))`);
         await queryRunner.query(`CREATE TABLE "core"."contacts" ("id" SERIAL NOT NULL, "uuid" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "created_by" integer, "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_by" integer, "is_deleted" boolean NOT NULL DEFAULT false, "deleted_by" integer, "deleted_at" TIMESTAMP, "clientId" integer NOT NULL, "contactName" character varying(100) NOT NULL, "contactType" character varying(10) NOT NULL DEFAULT 'Primary', "contactEmail" character varying(150), "countryCode" character varying(10), "contactPhone" character varying(15), CONSTRAINT "PK_b99cd40cfd66a99f1571f4f72e6" PRIMARY KEY ("id"))`);
         await queryRunner.query(`CREATE TABLE "core"."groups" ("id" SERIAL NOT NULL, "uuid" uuid NOT NULL DEFAULT uuid_generate_v4(), "created_at" TIMESTAMP NOT NULL DEFAULT now(), "created_by" integer, "updated_at" TIMESTAMP NOT NULL DEFAULT now(), "updated_by" integer, "is_deleted" boolean NOT NULL DEFAULT false, "deleted_by" integer, "deleted_at" TIMESTAMP, "group_name" character varying(255) NOT NULL, "is_active" boolean DEFAULT true, "prefix_group" jsonb, CONSTRAINT "UQ_ef10d4611e4f355d10ecaa10ac6" UNIQUE ("group_name"), CONSTRAINT "PK_659d1483316afb28afd3a90646e" PRIMARY KEY ("id"))`);
@@ -236,7 +236,8 @@ class InitialMigration1770706648232 {
         await queryRunner.query(`ALTER TABLE "core"."payments" ADD CONSTRAINT "FK_198183e67e58c2b0790434569d7" FOREIGN KEY ("confirmed_by") REFERENCES "user"."users"("id") ON DELETE SET NULL ON UPDATE CASCADE`);
         await queryRunner.query(`ALTER TABLE "core"."payments" ADD CONSTRAINT "FK_563a5e248518c623eebd987d43e" FOREIGN KEY ("invoice_id") REFERENCES "core"."invoices"("id") ON DELETE CASCADE ON UPDATE CASCADE`);
     }
-    async down(queryRunner) {
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
         await queryRunner.query(`ALTER TABLE "core"."payments" DROP CONSTRAINT "FK_563a5e248518c623eebd987d43e"`);
         await queryRunner.query(`ALTER TABLE "core"."payments" DROP CONSTRAINT "FK_198183e67e58c2b0790434569d7"`);
         await queryRunner.query(`ALTER TABLE "core"."user_invoice_template_footer" DROP CONSTRAINT "FK_f98f17ab7e0ce6f51c0e79b4b79"`);
@@ -469,6 +470,5 @@ class InitialMigration1770706648232 {
         await queryRunner.query(`DROP TABLE "core"."contacts"`);
         await queryRunner.query(`DROP TABLE "core"."activity_logs"`);
     }
+
 }
-exports.InitialMigration1770706648232 = InitialMigration1770706648232;
-//# sourceMappingURL=1770706648232-initialMigration.js.map

package/src/database/seeder/base.seed.ts

@@ -0,0 +1,104 @@
+import { DataSource, QueryRunner } from 'typeorm';
+import { seederConfig } from './config/seeder.config';
+import { SeederError, ValidationError } from './errors/seeder.error';
+
+/**
+ * Base class for all seeders providing common functionality
+ * including transaction management, logging, and validation.
+ */
+export abstract class BaseSeeder {
+  protected queryRunner: QueryRunner;
+  protected readonly config =
+    seederConfig[process.env.NODE_ENV || 'development'];
+
+  constructor(protected dataSource: DataSource) {}
+
+  /** Human-readable name for log output */
+  abstract readonly seederName: string;
+
+  /** Execute the seeding logic (implemented by each seeder) */
+  abstract run(): Promise<void>;
+
+  // ─── Transaction helpers ────────────────────────────────────
+
+  protected async startTransaction(): Promise<void> {
+    try {
+      this.queryRunner = this.dataSource.createQueryRunner();
+      await this.queryRunner.startTransaction();
+    } catch (error) {
+      throw new SeederError('Failed to start transaction', { error });
+    }
+  }
+
+  protected async commitTransaction(): Promise<void> {
+    try {
+      await this.queryRunner.commitTransaction();
+    } catch (error) {
+      throw new SeederError('Failed to commit transaction', { error });
+    }
+  }
+
+  protected async rollbackTransaction(): Promise<void> {
+    try {
+      await this.queryRunner.rollbackTransaction();
+    } catch (error) {
+      throw new SeederError('Failed to rollback transaction', { error });
+    }
+  }
+
+  protected async release(): Promise<void> {
+    try {
+      await this.queryRunner.release();
+    } catch (error) {
+      throw new SeederError('Failed to release query runner', { error });
+    }
+  }
+
+  /**
+   * Executes a callback wrapped in a DB transaction.
+   * Automatically commits on success, rolls back on failure.
+   */
+  protected async executeInTransaction<T>(
+    callback: () => Promise<T>,
+  ): Promise<T> {
+    try {
+      await this.startTransaction();
+      const result = await callback();
+      await this.commitTransaction();
+      return result;
+    } catch (error) {
+      await this.rollbackTransaction();
+      throw error;
+    } finally {
+      await this.release();
+    }
+  }
+
+  // ─── Validation helpers ─────────────────────────────────────
+
+  protected validateRequiredFields(data: any, requiredFields: string[]): void {
+    for (const field of requiredFields) {
+      if (data[field] === undefined || data[field] === null) {
+        throw new ValidationError(`Missing required field: ${field}`);
+      }
+    }
+  }
+
+  // ─── Logging ────────────────────────────────────────────────
+
+  protected log(message: string): void {
+    if (this.config.logging) {
+      console.log(`  [${this.seederName}] ${message}`);
+    }
+  }
+
+  protected logError(message: string): void {
+    console.error(`  [${this.seederName}] ❌ ${message}`);
+  }
+
+  protected logSuccess(message: string): void {
+    if (this.config.logging) {
+      console.log(`  [${this.seederName}] ✅ ${message}`);
+    }
+  }
+}

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

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

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

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

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