@procxo/shared 1.0.4 → 1.0.5

package/src/database/entities/transfer-ownership.entity.ts

@@ -1,39 +0,0 @@
-import { Entity, Column, ManyToOne, JoinColumn } from 'typeorm';
-import { BaseEntity } from './base.entity';
-import { User } from './user.entity';
-
-@Entity({ name: 'ownership_transfers', schema: 'user' })
-export class OwnershipTransfer extends BaseEntity {
-  @Column({ name: 'ownership_transfer_from_user_id' })
-  owenershipTransferFromUserId: number;
-
-  @Column({ name: 'ownership_transfer_to_user_id' })
-  ownershipTransferToUserId: number;
-
-  @Column({ name: 'ownership_transfer_reason', type: 'text' })
-  ownershipTransferReason: string;
-
-  @Column({ name: 'ownership_transfer_notes', type: 'text', nullable: true })
-  ownershipTransferNotes: string;
-
-  @Column({ name: 'transferred_at' })
-  transferredAt: Date;
-
-  @Column({name:'transferred_by_user_id'})
-  transferredByUserId: number;
-
-  @Column({name:"transfered_data",type:"jsonb",nullable:true})
-  transferedData: any;
-
-  @ManyToOne(() => User, { nullable: true })
-  @JoinColumn({ name: 'ownership_transfer_from_user_id' })
-  ownershipTransferFromUser: User;
-
-  @ManyToOne(() => User, { nullable: true })
-  @JoinColumn({ name: 'ownership_transfer_to_user_id' })
-  ownershipTransferToUser: User;
-
-  @ManyToOne(() => User, { nullable: true })
-  @JoinColumn({ name: 'transferred_by_user_id' })
-  transferredByUser: User;
-}

package/src/database/entities/upload-log.entity.ts

@@ -1,78 +0,0 @@
-import {
-    Entity,
-    Column,
-    ManyToOne,
-    JoinColumn,
-    CreateDateColumn,
-  } from 'typeorm';
-import {User} from './user.entity';
-import {BaseEntity} from './base.entity';
-  
-  // Enums
-  export enum UploadModuleEnum {
-    HOLIDAY = 'HOLIDAY',
-    USER = 'USER',
-    CLIENT = 'CLIENT',
-    EXPENSE = 'EXPENSE',
-  }
-  
-  export enum UploadStatus {
-    PENDING = 'PENDING',
-    IN_PROGRESS = 'IN_PROGRESS',
-    COMPLETED = 'COMPLETED',
-    FAILED = 'FAILED',
-    PROCESSING = 'PROCESSING',
-  }
-  
-  @Entity({ name: 'upload_logs', schema: 'user'})
-  export class UploadLog extends BaseEntity {
-  
-    @Column()
-    user_id: number;
-  
-    @ManyToOne(() => User, (user) => user.uploadLogs)
-    @JoinColumn({ name: 'user_id' })
-    user: User;
-  
-    @Column({
-      type: 'enum',
-      enum: UploadModuleEnum,
-      nullable: true,
-    })
-    module: UploadModuleEnum;
-  
-    @Column({ nullable: true })
-    file_name: string;
-  
-    @Column({ type: 'int', nullable: true })
-    file_size: number;
-  
-    @Column({
-      type: 'enum',
-      enum: UploadStatus,
-      default: UploadStatus.PENDING,
-    })
-    status: UploadStatus;
-  
-    @Column({ type: 'int', nullable: true })
-    total_records: number;
-  
-    @Column({ type: 'int', nullable: true })
-    success_count: number;
-  
-    @Column({ type: 'int', nullable: true })
-    failure_count: number;
-  
-    @Column({ nullable: true })
-    error_file_path: string;
-  
-    @CreateDateColumn({ name: 'started_at' })
-    started_at: Date;
-  
-    @Column({ type: 'timestamp', nullable: true })
-    completed_at: Date;
-  
-    @Column({ type: 'json', nullable: true })
-    errors: any;
-  }
-  

package/src/database/entities/user-notification-channel.entity.ts

@@ -1,43 +0,0 @@
-import { Entity, Column, Index } from 'typeorm';
-import { BaseEntity } from './base.entity';
-
-/**
- * User Notification Channels Entity
- * Controls global enable/disable for notification channels
- */
-@Entity({ name: 'user_notification_channel', schema: 'notification' })
-@Index(['userId'], { unique: true })
-export class UserNotificationChannel extends BaseEntity {
-  @Column({
-    name: 'user_id',
-    type: 'integer',
-    nullable: false,
-    unique: true,
-    comment: 'ID of the user',
-  })
-  userId: number;
-
-  @Column({
-    name: 'email_enabled',
-    type: 'boolean',
-    default: true,
-    comment: 'Global enable/disable for email notifications',
-  })
-  emailEnabled: boolean;
-
-  @Column({
-    name: 'push_enabled',
-    type: 'boolean',
-    default: true,
-    comment: 'Global enable/disable for push notifications',
-  })
-  pushEnabled: boolean;
-
-  @Column({
-    name: 'whatsapp_enabled',
-    type: 'boolean',
-    default: false,
-    comment: 'Global enable/disable for WhatsApp notifications',
-  })
-  whatsappEnabled: boolean;
-}

package/src/database/entities/user-notification-preference.entity.ts

@@ -1,50 +0,0 @@
-import { Entity, Column, Index } from 'typeorm';
-import { BaseEntity } from './base.entity';
-import { NotificationPreferenceType } from '../../core/constant';
-
-/**
- * User Notification Preference Entity
- * Each row represents one notification type preference for a user
- */
-@Entity({ name: 'user_notification_preferences', schema: 'notification' })
-@Index(['userId', 'preferenceType'], { unique: true })
-export class UserNotificationPreference extends BaseEntity {
-  @Column({
-    name: 'user_id',
-    type: 'integer',
-    nullable: false,
-    comment: 'ID of the user',
-  })
-  userId: number;
-
-  @Column({
-    name: 'preference_type',
-    type: 'enum',
-    enum: NotificationPreferenceType,
-    nullable: false,
-    comment: 'Type of notification preference',
-  })
-  preferenceType: NotificationPreferenceType;
-
-  @Column({
-    name: 'is_enabled',
-    type: 'boolean',
-    default: true,
-    comment: 'Whether this notification type is enabled',
-  })
-  isEnabled: boolean;
-
-  @Column({
-    type: 'text',
-    nullable: true,
-    comment: 'Description of the notification preference',
-  })
-  description: string | null;
-
-  @Column({
-    type: 'json',
-    nullable: true,
-    comment: 'Additional settings for this notification type',
-  })
-  metadata: Record<string, any> | null;
-}

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

@@ -1,25 +0,0 @@
-import {
-  Entity,
-  Column,
-  ManyToOne,
-  JoinColumn,
-} from 'typeorm';
-import { User } from './user.entity';
-import { Role } from './role.entity';
-import { BaseEntity } from './base.entity';
-@Entity({ name: 'user_roles', schema: 'user' })
-export class UserRole extends BaseEntity {
-  @Column({ name: 'user_id' })
-  user_id: number;
-
-  @Column({ name: 'role_id' })
-  role_id: number;
-
-  @ManyToOne(() => User, { onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'user_id' })
-  user: User;
-
-  @ManyToOne(() => Role, { onDelete: 'CASCADE' })
-  @JoinColumn({ name: 'role_id' })
-  role: Role;
-}

package/src/database/entities/user-session-history.entity.ts

@@ -1,45 +0,0 @@
-import { BaseEntity } from './base.entity';
-import {
-  Entity,
-  Column,
-  ManyToOne,
-  JoinColumn,
-} from 'typeorm';
-import { User } from './user.entity';
-
-@Entity({ name: 'user_session_history', schema: 'user' })
-export class UserSessionHistory extends BaseEntity {
-  @Column({ type: 'int', nullable: true })
-  user_id: number | null;
-
-  @ManyToOne(() => User, (user) => user.user_session_history)
-  @JoinColumn({ name: 'user_id' })
-  user: User;
-
-  @Column({ type: 'varchar', nullable: true })
-  ip_address: string | null;
-
-  @Column({ type: 'text', nullable: true })
-  user_agent: string | null;
-
-  @Column({ type: 'varchar', nullable: true })
-  browser: string | null;
-
-  @Column({ type: 'varchar', nullable: true })
-  device: string | null;
-
-  @Column({ type: 'varchar', nullable: true })
-  platform: string | null;
-
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
-  login_timestamp: Date;
-
-  @Column({ type: 'timestamp', nullable: true })
-  logout_timestamp: Date | null;
-
-  @Column({ type: 'varchar', nullable: true })
-  status: string | null;
-
-  @Column({ type: 'varchar', nullable: true })
-  session_id: string | null;
-}

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

@@ -1,109 +0,0 @@
-import { User } from './user.entity';
-import { Entity, Column, JoinColumn, OneToOne, ManyToOne } from 'typeorm';
-import { BaseEntity } from './base.entity';
-import { Shift } from './shift.entity';
-
-export enum AllocationType {
-  ROLE = 'role',
-  USER = 'user',
-}
-
-@Entity({ name: 'user_shifts', schema: 'timesheet' })
-export class UserShift extends BaseEntity {
-  @Column({
-    name: 'user_id',
-    type: 'integer',
-    nullable: false,
-    comment: 'ID of the user associated with the shift',
-  })
-  user_id: number;
-
-  @Column({
-    name: 'current_shift_id',
-    type: 'integer',
-    nullable: false,
-    comment: 'Current shift of the user',
-  })
-  current_shift_id: number;
-
-  @ManyToOne(() => Shift)
-  @JoinColumn({ name: 'current_shift_id' })
-  current_shift: Shift;
-
-  @Column({
-    name: 'is_alternate_shift',
-    type: 'boolean',
-    nullable: false,
-    comment: 'Check if the shift is alternate',
-  })
-  is_alternate_shift: boolean;
-
-  @Column({
-    name: 'current_alternate_shift_id',
-    type: 'integer',
-    nullable: true,
-    comment: 'Current alternate shift of the user',
-  })
-  current_alternate_shift_id: number;
-
-  @ManyToOne(() => Shift)
-  @JoinColumn({ name: 'current_alternate_shift_id' })
-  current_alternate_shift: Shift;
-
-  @Column({
-    name: 'shift_start_date',
-    type: 'date',
-    nullable: false,
-    comment: 'Start date of the shift',
-  })
-  shift_start_date: Date;
-
-  @Column({
-    name: 'shift_end_date',
-    type: 'date',
-    nullable: false,
-    comment: 'End date of the shift',
-  })
-  shift_end_date: Date;
-
-  @Column({
-    name: 'planned_shift_id',
-    type: 'integer',
-    nullable: true,
-    comment: 'The planned shift id to be assigned to the user',
-  })
-  planned_shift_id: number | null;
-
-  @ManyToOne(() => Shift)
-  @JoinColumn({ name: 'planned_shift_id' })
-  planned_shift: Shift;
-
-  @Column({
-    name: 'effective_date',
-    type: 'date',
-    nullable: true,
-    comment: 'The date when the planned shift becomes effective',
-  })
-  effective_date: Date | null;
-
-  @OneToOne(() => User) // Define a one-to-one relationship
-  @JoinColumn({ name: 'user_id' }) // Specify the column for the foreign key
-  user: User;
-
-  @Column({
-    name: 'shift_applied_by',
-    type: 'integer',
-    nullable: true,
-    comment: 'Shift applied by',
-  })
-  shift_applied_by: number;
-
-  @Column({
-    name: 'allocation_type',
-    type: 'enum',
-    enum: AllocationType,
-    nullable: true,
-    comment: 'Allocation type',
-  })
-  allocation_type: AllocationType;
-}

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

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

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

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

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