@classytic/payroll 1.0.2 → 2.3.0

package/dist/services/index.js

@@ -0,0 +1,2172 @@
+import { Types } from 'mongoose';
+
+// src/utils/date.ts
+function addMonths(date, months) {
+  const result = new Date(date);
+  result.setMonth(result.getMonth() + months);
+  return result;
+}
+function startOfMonth(date) {
+  const result = new Date(date);
+  result.setDate(1);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function endOfMonth(date) {
+  const result = new Date(date);
+  result.setMonth(result.getMonth() + 1, 0);
+  result.setHours(23, 59, 59, 999);
+  return result;
+}
+function getPayPeriod(month, year) {
+  const startDate = new Date(year, month - 1, 1);
+  return {
+    month,
+    year,
+    startDate: startOfMonth(startDate),
+    endDate: endOfMonth(startDate)
+  };
+}
+function getCurrentPeriod(date = /* @__PURE__ */ new Date()) {
+  const d = new Date(date);
+  return {
+    year: d.getFullYear(),
+    month: d.getMonth() + 1
+  };
+}
+function calculateProbationEnd(hireDate, probationMonths) {
+  if (!probationMonths || probationMonths <= 0) return null;
+  return addMonths(hireDate, probationMonths);
+}
+
+// src/config.ts
+var HRM_CONFIG = {
+  dataRetention: {
+    payrollRecordsTTL: 63072e3,
+    // 2 years in seconds
+    exportWarningDays: 30,
+    archiveBeforeDeletion: true
+  },
+  payroll: {
+    defaultCurrency: "BDT",
+    allowProRating: true,
+    attendanceIntegration: true,
+    autoDeductions: true,
+    overtimeEnabled: false,
+    overtimeMultiplier: 1.5
+  },
+  salary: {
+    minimumWage: 0,
+    maximumAllowances: 10,
+    maximumDeductions: 10,
+    defaultFrequency: "monthly"
+  },
+  employment: {
+    defaultProbationMonths: 3,
+    maxProbationMonths: 6,
+    allowReHiring: true,
+    trackEmploymentHistory: true
+  },
+  validation: {
+    requireBankDetails: false,
+    requireUserId: false,
+    // Modern: Allow guest employees by default
+    identityMode: "employeeId",
+    // Modern: Use human-readable IDs as primary
+    identityFallbacks: ["email", "userId"]
+    // Smart fallback chain
+  }
+};
+var ORG_ROLES = {
+  OWNER: {
+    key: "owner",
+    label: "Owner",
+    description: "Full organization access (set by Organization model)"
+  },
+  MANAGER: {
+    key: "manager",
+    label: "Manager",
+    description: "Management and administrative features"
+  },
+  TRAINER: {
+    key: "trainer",
+    label: "Trainer",
+    description: "Training and coaching features"
+  },
+  STAFF: {
+    key: "staff",
+    label: "Staff",
+    description: "General staff access to basic features"
+  },
+  INTERN: {
+    key: "intern",
+    label: "Intern",
+    description: "Limited access for interns"
+  },
+  CONSULTANT: {
+    key: "consultant",
+    label: "Consultant",
+    description: "Project-based consultant access"
+  }
+};
+Object.values(ORG_ROLES).map((role) => role.key);
+
+// src/factories/employee.factory.ts
+function normalizeEmail(email) {
+  if (!email || typeof email !== "string") return void 0;
+  const trimmed = email.trim();
+  return trimmed ? trimmed.toLowerCase() : void 0;
+}
+var EmployeeFactory = class {
+  /**
+   * Create employee data object
+   */
+  static create(params, config = HRM_CONFIG) {
+    const { userId, organizationId, employment, compensation, bankDetails } = params;
+    const hireDate = employment.hireDate || /* @__PURE__ */ new Date();
+    const normalizedEmail = normalizeEmail(employment.email);
+    return {
+      ...userId ? { userId } : {},
+      // Only include userId if present
+      ...normalizedEmail ? { email: normalizedEmail } : {},
+      // Include normalized email for guest employees
+      organizationId,
+      employeeId: employment.employeeId || `EMP-${Date.now()}-${Math.random().toString(36).substr(2, 6).toUpperCase()}`,
+      employmentType: employment.type || "full_time",
+      status: "active",
+      department: employment.department,
+      position: employment.position,
+      hireDate,
+      probationEndDate: calculateProbationEnd(
+        hireDate,
+        employment.probationMonths ?? config.employment.defaultProbationMonths
+      ),
+      compensation: this.createCompensation(compensation, config),
+      workSchedule: employment.workSchedule || this.defaultWorkSchedule(),
+      bankDetails: bankDetails || {},
+      payrollStats: {
+        totalPaid: 0,
+        paymentsThisYear: 0,
+        averageMonthly: 0
+      }
+    };
+  }
+  /**
+   * Create compensation object
+   */
+  static createCompensation(params, config = HRM_CONFIG) {
+    return {
+      baseAmount: params.baseAmount,
+      frequency: params.frequency || "monthly",
+      currency: params.currency || config.payroll.defaultCurrency,
+      allowances: (params.allowances || []).map((a) => ({
+        type: a.type || "other",
+        name: a.name || a.type || "other",
+        amount: a.amount || 0,
+        taxable: a.taxable,
+        recurring: a.recurring,
+        effectiveFrom: a.effectiveFrom,
+        effectiveTo: a.effectiveTo
+      })),
+      deductions: (params.deductions || []).map((d) => ({
+        type: d.type || "other",
+        name: d.name || d.type || "other",
+        amount: d.amount || 0,
+        auto: d.auto,
+        recurring: d.recurring,
+        description: d.description,
+        effectiveFrom: d.effectiveFrom,
+        effectiveTo: d.effectiveTo
+      })),
+      grossSalary: 0,
+      netSalary: 0,
+      effectiveFrom: /* @__PURE__ */ new Date(),
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create allowance object
+   */
+  static createAllowance(params) {
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount: params.amount,
+      isPercentage: params.isPercentage ?? false,
+      taxable: params.taxable ?? true,
+      recurring: params.recurring ?? true,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create deduction object
+   */
+  static createDeduction(params) {
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount: params.amount,
+      isPercentage: params.isPercentage ?? false,
+      auto: params.auto ?? false,
+      recurring: params.recurring ?? true,
+      description: params.description,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Default work schedule
+   */
+  static defaultWorkSchedule() {
+    return {
+      hoursPerWeek: 40,
+      hoursPerDay: 8,
+      workingDays: [1, 2, 3, 4, 5],
+      // Mon-Fri
+      shiftStart: "09:00",
+      shiftEnd: "17:00"
+    };
+  }
+  /**
+   * Create termination data
+   */
+  static createTermination(params) {
+    return {
+      terminatedAt: params.date || /* @__PURE__ */ new Date(),
+      terminationReason: params.reason,
+      terminationNotes: params.notes,
+      terminatedBy: {
+        userId: params.context?.userId,
+        name: params.context?.userName,
+        role: params.context?.userRole
+      }
+    };
+  }
+};
+function toObjectId(id) {
+  if (id instanceof Types.ObjectId) return id;
+  return new Types.ObjectId(id);
+}
+var QueryBuilder = class {
+  query;
+  constructor(initialQuery = {}) {
+    this.query = { ...initialQuery };
+  }
+  /**
+   * Add where condition
+   */
+  where(field, value) {
+    this.query[field] = value;
+    return this;
+  }
+  /**
+   * Add $in condition
+   */
+  whereIn(field, values) {
+    this.query[field] = { $in: values };
+    return this;
+  }
+  /**
+   * Add $nin condition
+   */
+  whereNotIn(field, values) {
+    this.query[field] = { $nin: values };
+    return this;
+  }
+  /**
+   * Add $gte condition
+   */
+  whereGte(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $gte: value };
+    return this;
+  }
+  /**
+   * Add $lte condition
+   */
+  whereLte(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $lte: value };
+    return this;
+  }
+  /**
+   * Add $gt condition
+   */
+  whereGt(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $gt: value };
+    return this;
+  }
+  /**
+   * Add $lt condition
+   */
+  whereLt(field, value) {
+    const existing = this.query[field] || {};
+    this.query[field] = { ...existing, $lt: value };
+    return this;
+  }
+  /**
+   * Add between condition
+   */
+  whereBetween(field, start, end) {
+    this.query[field] = { $gte: start, $lte: end };
+    return this;
+  }
+  /**
+   * Add $exists condition
+   */
+  whereExists(field) {
+    this.query[field] = { $exists: true };
+    return this;
+  }
+  /**
+   * Add $exists: false condition
+   */
+  whereNotExists(field) {
+    this.query[field] = { $exists: false };
+    return this;
+  }
+  /**
+   * Add $ne condition
+   */
+  whereNot(field, value) {
+    this.query[field] = { $ne: value };
+    return this;
+  }
+  /**
+   * Add regex condition
+   */
+  whereRegex(field, pattern, flags = "i") {
+    this.query[field] = { $regex: pattern, $options: flags };
+    return this;
+  }
+  /**
+   * Merge another query
+   */
+  merge(otherQuery) {
+    this.query = { ...this.query, ...otherQuery };
+    return this;
+  }
+  /**
+   * Build and return the query
+   */
+  build() {
+    return { ...this.query };
+  }
+};
+var EmployeeQueryBuilder = class extends QueryBuilder {
+  /**
+   * Filter by organization
+   */
+  forOrganization(organizationId) {
+    return this.where("organizationId", toObjectId(organizationId));
+  }
+  /**
+   * Filter by user
+   */
+  forUser(userId) {
+    return this.where("userId", toObjectId(userId));
+  }
+  /**
+   * Filter by employeeId (human-readable ID)
+   */
+  forEmployeeId(employeeId) {
+    return this.where("employeeId", employeeId);
+  }
+  /**
+   * Filter by email (for guest employees)
+   */
+  forEmail(email) {
+    return this.where("email", email.toLowerCase().trim());
+  }
+  /**
+   * Filter guest employees (no userId)
+   */
+  guestEmployees() {
+    return this.where("userId", null);
+  }
+  /**
+   * Filter user-linked employees (has userId)
+   */
+  userLinkedEmployees() {
+    return this.where("userId", { $ne: null });
+  }
+  /**
+   * Filter by status(es)
+   */
+  withStatus(...statuses) {
+    if (statuses.length === 1) {
+      return this.where("status", statuses[0]);
+    }
+    return this.whereIn("status", statuses);
+  }
+  /**
+   * Filter active employees
+   */
+  active() {
+    return this.withStatus("active");
+  }
+  /**
+   * Filter employed employees (not terminated)
+   */
+  employed() {
+    return this.whereIn("status", ["active", "on_leave", "suspended"]);
+  }
+  /**
+   * Filter terminated employees
+   */
+  terminated() {
+    return this.withStatus("terminated");
+  }
+  /**
+   * Filter by department
+   */
+  inDepartment(department) {
+    return this.where("department", department);
+  }
+  /**
+   * Filter by position
+   */
+  inPosition(position) {
+    return this.where("position", position);
+  }
+  /**
+   * Filter by employment type
+   */
+  withEmploymentType(type) {
+    return this.where("employmentType", type);
+  }
+  /**
+   * Filter by hire date (after)
+   */
+  hiredAfter(date) {
+    return this.whereGte("hireDate", date);
+  }
+  /**
+   * Filter by hire date (before)
+   */
+  hiredBefore(date) {
+    return this.whereLte("hireDate", date);
+  }
+  /**
+   * Filter by minimum salary
+   */
+  withMinSalary(amount) {
+    return this.whereGte("compensation.netSalary", amount);
+  }
+  /**
+   * Filter by maximum salary
+   */
+  withMaxSalary(amount) {
+    return this.whereLte("compensation.netSalary", amount);
+  }
+  /**
+   * Filter by salary range
+   */
+  withSalaryRange(min2, max2) {
+    return this.whereBetween("compensation.netSalary", min2, max2);
+  }
+};
+var PayrollQueryBuilder = class extends QueryBuilder {
+  /**
+   * Filter by organization
+   */
+  forOrganization(organizationId) {
+    return this.where("organizationId", toObjectId(organizationId));
+  }
+  /**
+   * Filter by employee
+   *
+   * Note: PayrollRecord.employeeId is always ObjectId _id
+   * If passing a string business ID, resolve to _id first
+   */
+  forEmployee(employeeId) {
+    return this.where("employeeId", toObjectId(employeeId));
+  }
+  /**
+   * Filter by period
+   */
+  forPeriod(month, year) {
+    if (month !== void 0) {
+      this.where("period.month", month);
+    }
+    if (year !== void 0) {
+      this.where("period.year", year);
+    }
+    return this;
+  }
+  /**
+   * Filter by status(es)
+   */
+  withStatus(...statuses) {
+    if (statuses.length === 1) {
+      return this.where("status", statuses[0]);
+    }
+    return this.whereIn("status", statuses);
+  }
+  /**
+   * Filter paid records
+   */
+  paid() {
+    return this.withStatus("paid");
+  }
+  /**
+   * Filter pending records
+   */
+  pending() {
+    return this.whereIn("status", ["pending", "processing"]);
+  }
+  /**
+   * Filter by date range
+   */
+  inDateRange(start, end) {
+    return this.whereBetween("period.payDate", start, end);
+  }
+  /**
+   * Filter exported records
+   */
+  exported() {
+    return this.where("exported", true);
+  }
+  /**
+   * Filter not exported records
+   */
+  notExported() {
+    return this.where("exported", false);
+  }
+};
+function employee() {
+  return new EmployeeQueryBuilder();
+}
+function payroll() {
+  return new PayrollQueryBuilder();
+}
+var TAX_TYPE = {
+  INCOME_TAX: "income_tax",
+  SOCIAL_SECURITY: "social_security",
+  HEALTH_INSURANCE: "health_insurance",
+  PENSION: "pension",
+  EMPLOYMENT_INSURANCE: "employment_insurance",
+  LOCAL_TAX: "local_tax",
+  OTHER: "other"
+};
+var TAX_STATUS = {
+  PENDING: "pending"};
+
+// src/utils/validation.ts
+function isActive(employee2) {
+  return employee2?.status === "active";
+}
+function isOnLeave(employee2) {
+  return employee2?.status === "on_leave";
+}
+function isSuspended(employee2) {
+  return employee2?.status === "suspended";
+}
+function isEmployed(employee2) {
+  return isActive(employee2) || isOnLeave(employee2) || isSuspended(employee2);
+}
+function canReceiveSalary(employee2) {
+  return (isActive(employee2) || isOnLeave(employee2)) && (employee2.compensation?.baseAmount ?? 0) > 0;
+}
+
+// src/utils/logger.ts
+var createConsoleLogger = () => ({
+  info: (message, meta) => {
+    if (meta) {
+      console.log(`[Payroll] INFO: ${message}`, meta);
+    } else {
+      console.log(`[Payroll] INFO: ${message}`);
+    }
+  },
+  error: (message, meta) => {
+    if (meta) {
+      console.error(`[Payroll] ERROR: ${message}`, meta);
+    } else {
+      console.error(`[Payroll] ERROR: ${message}`);
+    }
+  },
+  warn: (message, meta) => {
+    if (meta) {
+      console.warn(`[Payroll] WARN: ${message}`, meta);
+    } else {
+      console.warn(`[Payroll] WARN: ${message}`);
+    }
+  },
+  debug: (message, meta) => {
+    if (process.env.NODE_ENV !== "production") {
+      if (meta) {
+        console.log(`[Payroll] DEBUG: ${message}`, meta);
+      } else {
+        console.log(`[Payroll] DEBUG: ${message}`);
+      }
+    }
+  }
+});
+var currentLogger = createConsoleLogger();
+var logger = {
+  info: (message, meta) => {
+    currentLogger.info(message, meta);
+  },
+  error: (message, meta) => {
+    currentLogger.error(message, meta);
+  },
+  warn: (message, meta) => {
+    currentLogger.warn(message, meta);
+  },
+  debug: (message, meta) => {
+    currentLogger.debug(message, meta);
+  }
+};
+
+// src/services/employee.service.ts
+var EmployeeService = class {
+  constructor(EmployeeModel, config) {
+    this.EmployeeModel = EmployeeModel;
+    this.config = config || HRM_CONFIG;
+  }
+  config;
+  /**
+   * Find employee by ID with organization validation
+   * 
+   * ⚠️ SECURITY: Always validates employee belongs to specified organization
+   * 
+   * @throws {Error} If employee not found or doesn't belong to organization
+   */
+  async findById(employeeId, organizationId, options = {}) {
+    const query = {
+      _id: toObjectId(employeeId),
+      organizationId: toObjectId(organizationId)
+    };
+    let mongooseQuery = this.EmployeeModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    if (options.populate) {
+      mongooseQuery = mongooseQuery.populate("userId", "name email phone");
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employee by user and organization
+   */
+  async findByUserId(userId, organizationId, options = {}) {
+    const query = employee().forUser(userId).forOrganization(organizationId).build();
+    let mongooseQuery = this.EmployeeModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employee by employeeId (human-readable ID)
+   */
+  async findByEmployeeId(employeeId, organizationId, options = {}) {
+    const query = employee().forEmployeeId(employeeId).forOrganization(organizationId).build();
+    let mongooseQuery = this.EmployeeModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employee by email (guest employees)
+   */
+  async findByEmail(email, organizationId, options = {}) {
+    const query = employee().forEmail(email).forOrganization(organizationId).build();
+    let mongooseQuery = this.EmployeeModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find all guest employees (no userId)
+   */
+  async findGuestEmployees(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).guestEmployees().build();
+    let mongooseQuery = this.EmployeeModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find active employees in organization
+   */
+  async findActive(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).active().build();
+    let mongooseQuery = this.EmployeeModel.find(query, options.projection);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employed employees (not terminated)
+   */
+  async findEmployed(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).employed().build();
+    let mongooseQuery = this.EmployeeModel.find(query, options.projection);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employees by department
+   */
+  async findByDepartment(organizationId, department, options = {}) {
+    const query = employee().forOrganization(organizationId).inDepartment(department).active().build();
+    let mongooseQuery = this.EmployeeModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find employees eligible for payroll
+   */
+  async findEligibleForPayroll(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).employed().build();
+    let mongooseQuery = this.EmployeeModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    const employees = await mongooseQuery.exec();
+    return employees.filter((emp) => canReceiveSalary(emp));
+  }
+  /**
+   * Create new employee
+   */
+  async create(params, options = {}) {
+    const employeeData = EmployeeFactory.create(params, this.config);
+    let employee2;
+    if (!params.userId) {
+      const dataToInsert = {};
+      for (const [key, value] of Object.entries(employeeData)) {
+        if (key === "userId" || key === "email") continue;
+        dataToInsert[key] = value;
+      }
+      if (employeeData.email && employeeData.email !== "") {
+        dataToInsert.email = employeeData.email;
+      }
+      const now = /* @__PURE__ */ new Date();
+      dataToInsert.createdAt = now;
+      dataToInsert.updatedAt = now;
+      const insertOptions = options.session ? { session: options.session } : {};
+      const result = await this.EmployeeModel.collection.insertOne(
+        dataToInsert,
+        insertOptions
+      );
+      employee2 = await this.EmployeeModel.findById(result.insertedId).session(options.session || null).exec();
+    } else {
+      const [created] = await this.EmployeeModel.create([employeeData], {
+        session: options.session
+      });
+      employee2 = created;
+    }
+    logger.info("Employee created", {
+      employeeId: employee2.employeeId,
+      organizationId: employee2.organizationId.toString()
+    });
+    return employee2;
+  }
+  /**
+   * Update employee status with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async updateStatus(employeeId, organizationId, status, context = {}, options = {}) {
+    const employee2 = await this.findById(employeeId, organizationId, options);
+    if (!employee2) {
+      throw new Error(`Employee not found in organization ${organizationId}`);
+    }
+    employee2.status = status;
+    await employee2.save({ session: options.session });
+    logger.info("Employee status updated", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      newStatus: status
+    });
+    return employee2;
+  }
+  /**
+   * Update employee compensation with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   * 
+   * NOTE: This merges the compensation fields rather than replacing the entire object.
+   * To update allowances/deductions, use addAllowance/removeAllowance methods.
+   */
+  async updateCompensation(employeeId, organizationId, compensation, options = {}) {
+    const currentEmployee = await this.findById(employeeId, organizationId, options);
+    if (!currentEmployee) {
+      throw new Error(`Employee not found in organization ${organizationId}`);
+    }
+    const updateFields = {
+      "compensation.lastModified": /* @__PURE__ */ new Date()
+    };
+    if (compensation.baseAmount !== void 0) {
+      updateFields["compensation.baseAmount"] = compensation.baseAmount;
+    }
+    if (compensation.currency !== void 0) {
+      updateFields["compensation.currency"] = compensation.currency;
+    }
+    if (compensation.frequency !== void 0) {
+      updateFields["compensation.frequency"] = compensation.frequency;
+    }
+    if (compensation.effectiveFrom !== void 0) {
+      updateFields["compensation.effectiveFrom"] = compensation.effectiveFrom;
+    }
+    const query = {
+      _id: toObjectId(employeeId),
+      organizationId: toObjectId(organizationId)
+    };
+    const employee2 = await this.EmployeeModel.findOneAndUpdate(
+      query,
+      { $set: updateFields },
+      { new: true, runValidators: true, session: options.session }
+    );
+    if (!employee2) {
+      throw new Error(`Employee not found in organization ${organizationId}`);
+    }
+    logger.info("Employee compensation updated", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString()
+    });
+    return employee2;
+  }
+  /**
+   * Get employee statistics for organization
+   */
+  async getEmployeeStats(organizationId, options = {}) {
+    const query = employee().forOrganization(organizationId).build();
+    let mongooseQuery = this.EmployeeModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    const employees = await mongooseQuery.exec();
+    return {
+      total: employees.length,
+      active: employees.filter(isActive).length,
+      employed: employees.filter(isEmployed).length,
+      canReceiveSalary: employees.filter(canReceiveSalary).length,
+      byStatus: this.groupByStatus(employees),
+      byDepartment: this.groupByDepartment(employees)
+    };
+  }
+  /**
+   * Group employees by status
+   */
+  groupByStatus(employees) {
+    return employees.reduce(
+      (acc, emp) => {
+        acc[emp.status] = (acc[emp.status] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Group employees by department
+   */
+  groupByDepartment(employees) {
+    return employees.reduce(
+      (acc, emp) => {
+        const dept = emp.department || "unassigned";
+        acc[dept] = (acc[dept] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+  }
+  /**
+   * Check if employee is active
+   */
+  isActive(employee2) {
+    return isActive(employee2);
+  }
+  /**
+   * Check if employee is employed
+   */
+  isEmployed(employee2) {
+    return isEmployed(employee2);
+  }
+  /**
+   * Check if employee can receive salary
+   */
+  canReceiveSalary(employee2) {
+    return canReceiveSalary(employee2);
+  }
+};
+function createEmployeeService(EmployeeModel, config) {
+  return new EmployeeService(EmployeeModel, config);
+}
+
+// src/utils/calculation.ts
+function sumBy(items, getter) {
+  return items.reduce((total, item) => total + getter(item), 0);
+}
+function sumAllowances(allowances) {
+  return sumBy(allowances, (a) => a.amount);
+}
+function sumDeductions(deductions) {
+  return sumBy(deductions, (d) => d.amount);
+}
+function applyPercentage(amount, percentage) {
+  return Math.round(amount * (percentage / 100));
+}
+function calculateGross(baseAmount, allowances) {
+  return baseAmount + sumAllowances(allowances);
+}
+function calculateNet(gross, deductions) {
+  return Math.max(0, gross - sumDeductions(deductions));
+}
+
+// src/factories/payroll.factory.ts
+var PayrollFactory = class {
+  /**
+   * Create payroll data object
+   */
+  static create(params) {
+    const {
+      employeeId,
+      organizationId,
+      baseAmount,
+      allowances = [],
+      deductions = [],
+      period = {},
+      metadata = {}
+    } = params;
+    const calculatedAllowances = this.calculateAllowances(baseAmount, allowances);
+    const calculatedDeductions = this.calculateDeductions(baseAmount, deductions);
+    const gross = calculateGross(baseAmount, calculatedAllowances);
+    const net = calculateNet(gross, calculatedDeductions);
+    return {
+      employeeId,
+      organizationId,
+      period: this.createPeriod(period),
+      breakdown: {
+        baseAmount,
+        allowances: calculatedAllowances,
+        deductions: calculatedDeductions,
+        grossSalary: gross,
+        netSalary: net
+      },
+      status: "pending",
+      processedAt: null,
+      paidAt: null,
+      metadata: {
+        currency: metadata.currency || HRM_CONFIG.payroll.defaultCurrency,
+        paymentMethod: metadata.paymentMethod,
+        notes: metadata.notes
+      }
+    };
+  }
+  /**
+   * Create pay period
+   */
+  static createPeriod(params) {
+    const now = /* @__PURE__ */ new Date();
+    const month = params.month || now.getMonth() + 1;
+    const year = params.year || now.getFullYear();
+    const period = getPayPeriod(month, year);
+    return {
+      ...period,
+      payDate: params.payDate || /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Calculate allowances from base amount
+   */
+  static calculateAllowances(baseAmount, allowances) {
+    return allowances.map((allowance) => {
+      const amount = allowance.isPercentage && allowance.value !== void 0 ? Math.round(baseAmount * allowance.value / 100) : allowance.amount;
+      return {
+        type: allowance.type,
+        amount,
+        taxable: allowance.taxable ?? true
+      };
+    });
+  }
+  /**
+   * Calculate deductions from base amount
+   */
+  static calculateDeductions(baseAmount, deductions) {
+    return deductions.map((deduction) => {
+      const amount = deduction.isPercentage && deduction.value !== void 0 ? Math.round(baseAmount * deduction.value / 100) : deduction.amount;
+      return {
+        type: deduction.type,
+        amount,
+        description: deduction.description
+      };
+    });
+  }
+  /**
+   * Create bonus object
+   */
+  static createBonus(params) {
+    return {
+      type: params.type,
+      amount: params.amount,
+      reason: params.reason,
+      approvedBy: params.approvedBy,
+      approvedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Mark payroll as paid (immutable)
+   * Sets both top-level transactionId and metadata for compatibility
+   */
+  static markAsPaid(payroll2, params = {}) {
+    return {
+      ...payroll2,
+      status: "paid",
+      paidAt: params.paidAt || /* @__PURE__ */ new Date(),
+      processedAt: payroll2.processedAt || params.paidAt || /* @__PURE__ */ new Date(),
+      transactionId: params.transactionId || payroll2.transactionId,
+      metadata: {
+        ...payroll2.metadata,
+        transactionId: params.transactionId,
+        paymentMethod: params.paymentMethod || payroll2.metadata?.paymentMethod
+      }
+    };
+  }
+  /**
+   * Mark payroll as processed (immutable)
+   */
+  static markAsProcessed(payroll2, params = {}) {
+    return {
+      ...payroll2,
+      status: "processing",
+      processedAt: params.processedAt || /* @__PURE__ */ new Date()
+    };
+  }
+};
+var BatchPayrollFactory = class {
+  /**
+   * Create payroll records for multiple employees
+   */
+  static createBatch(employees, params) {
+    return employees.map(
+      (employee2) => PayrollFactory.create({
+        employeeId: employee2._id,
+        organizationId: params.organizationId || employee2.organizationId,
+        baseAmount: employee2.compensation.baseAmount,
+        allowances: employee2.compensation.allowances || [],
+        deductions: employee2.compensation.deductions || [],
+        period: { month: params.month, year: params.year },
+        metadata: { currency: employee2.compensation.currency }
+      })
+    );
+  }
+  /**
+   * Calculate total payroll amounts
+   */
+  static calculateTotalPayroll(payrolls) {
+    return payrolls.reduce(
+      (totals, payroll2) => ({
+        count: totals.count + 1,
+        totalGross: totals.totalGross + payroll2.breakdown.grossSalary,
+        totalNet: totals.totalNet + payroll2.breakdown.netSalary,
+        totalAllowances: totals.totalAllowances + sumAllowances(payroll2.breakdown.allowances),
+        totalDeductions: totals.totalDeductions + sumDeductions(payroll2.breakdown.deductions)
+      }),
+      { count: 0, totalGross: 0, totalNet: 0, totalAllowances: 0, totalDeductions: 0 }
+    );
+  }
+};
+
+// src/services/payroll.service.ts
+var PayrollService = class {
+  constructor(PayrollModel, employeeService) {
+    this.PayrollModel = PayrollModel;
+    this.employeeService = employeeService;
+  }
+  /**
+   * Find payroll by ID
+   */
+  async findById(payrollId, options = {}) {
+    let query = this.PayrollModel.findById(toObjectId(payrollId));
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    return query.exec();
+  }
+  /**
+   * Find payrolls by employee
+   */
+  async findByEmployee(employeeId, organizationId, options = {}) {
+    const query = payroll().forEmployee(employeeId).forOrganization(organizationId).build();
+    let mongooseQuery = this.PayrollModel.find(query).sort({ "period.year": -1, "period.month": -1 }).limit(options.limit || 12);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find payrolls for a period
+   */
+  async findForPeriod(organizationId, month, year, options = {}) {
+    const query = payroll().forOrganization(organizationId).forPeriod(month, year).build();
+    let mongooseQuery = this.PayrollModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find pending payrolls
+   */
+  async findPending(organizationId, month, year, options = {}) {
+    const query = payroll().forOrganization(organizationId).forPeriod(month, year).pending().build();
+    let mongooseQuery = this.PayrollModel.find(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Find payroll by employee and period
+   */
+  async findByEmployeeAndPeriod(employeeId, organizationId, month, year, options = {}) {
+    const query = payroll().forEmployee(employeeId).forOrganization(organizationId).forPeriod(month, year).build();
+    let mongooseQuery = this.PayrollModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    return mongooseQuery.exec();
+  }
+  /**
+   * Create payroll record
+   */
+  async create(data, options = {}) {
+    const [payroll2] = await this.PayrollModel.create([data], {
+      session: options.session
+    });
+    logger.info("Payroll record created", {
+      payrollId: payroll2._id.toString(),
+      employeeId: payroll2.employeeId.toString()
+    });
+    return payroll2;
+  }
+  /**
+   * Generate payroll for employee with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization
+   */
+  async generateForEmployee(employeeId, organizationId, month, year, options = {}) {
+    const employee2 = await this.employeeService.findById(employeeId, organizationId, options);
+    if (!employee2) {
+      throw new Error(`Employee not found in organization ${organizationId}`);
+    }
+    if (!canReceiveSalary(employee2)) {
+      throw new Error("Employee not eligible for payroll");
+    }
+    const existing = await this.findByEmployeeAndPeriod(
+      employeeId,
+      organizationId,
+      month,
+      year,
+      options
+    );
+    if (existing) {
+      throw new Error("Payroll already exists for this period");
+    }
+    const payrollData = PayrollFactory.create({
+      employeeId,
+      organizationId,
+      baseAmount: employee2.compensation.baseAmount,
+      allowances: employee2.compensation.allowances || [],
+      deductions: employee2.compensation.deductions || [],
+      period: { month, year },
+      metadata: { currency: employee2.compensation.currency }
+    });
+    return this.create(payrollData, options);
+  }
+  /**
+   * Generate batch payroll
+   */
+  async generateBatch(organizationId, month, year, options = {}) {
+    const employees = await this.employeeService.findEligibleForPayroll(
+      organizationId,
+      options
+    );
+    if (employees.length === 0) {
+      return {
+        success: true,
+        generated: 0,
+        skipped: 0,
+        payrolls: [],
+        message: "No eligible employees"
+      };
+    }
+    const existingPayrolls = await this.findForPeriod(
+      organizationId,
+      month,
+      year,
+      options
+    );
+    const existingEmployeeIds = new Set(
+      existingPayrolls.map((p) => p.employeeId.toString())
+    );
+    const eligibleEmployees = employees.filter(
+      (emp) => !existingEmployeeIds.has(emp._id.toString())
+    );
+    if (eligibleEmployees.length === 0) {
+      return {
+        success: true,
+        generated: 0,
+        skipped: employees.length,
+        payrolls: [],
+        message: "Payrolls already exist for all employees"
+      };
+    }
+    const payrollsData = BatchPayrollFactory.createBatch(eligibleEmployees, {
+      month,
+      year,
+      organizationId
+    });
+    const created = await this.PayrollModel.insertMany(payrollsData, {
+      session: options.session
+    });
+    logger.info("Batch payroll generated", {
+      organizationId: organizationId.toString(),
+      month,
+      year,
+      count: created.length
+    });
+    return {
+      success: true,
+      generated: created.length,
+      skipped: existingEmployeeIds.size,
+      payrolls: created,
+      message: `Generated ${created.length} payrolls`
+    };
+  }
+  /**
+   * Mark payroll as paid with organization validation
+   * 
+   * ⚠️ SECURITY: Validates payroll belongs to organization
+   */
+  async markAsPaid(payrollId, organizationId, paymentDetails = {}, options = {}) {
+    const query = {
+      _id: toObjectId(payrollId),
+      organizationId: toObjectId(organizationId)
+    };
+    let payrollFindQuery = this.PayrollModel.findOne(query);
+    if (options.session) {
+      payrollFindQuery = payrollFindQuery.session(options.session);
+    }
+    const payroll2 = await payrollFindQuery;
+    if (!payroll2) {
+      throw new Error(`Payroll not found in organization ${organizationId}`);
+    }
+    if (payroll2.status === "paid") {
+      throw new Error("Payroll already paid");
+    }
+    const payrollObj = payroll2.toObject();
+    const updatedData = PayrollFactory.markAsPaid(payrollObj, paymentDetails);
+    const updated = await this.PayrollModel.findByIdAndUpdate(
+      payrollId,
+      updatedData,
+      { new: true, runValidators: true, session: options.session }
+    );
+    if (!updated) {
+      throw new Error("Failed to update payroll");
+    }
+    logger.info("Payroll marked as paid", {
+      payrollId: payrollId.toString()
+    });
+    return updated;
+  }
+  /**
+   * Mark payroll as processed with organization validation
+   * 
+   * ⚠️ SECURITY: Validates payroll belongs to organization
+   */
+  async markAsProcessed(payrollId, organizationId, options = {}) {
+    const query = {
+      _id: toObjectId(payrollId),
+      organizationId: toObjectId(organizationId)
+    };
+    let payrollFindQuery = this.PayrollModel.findOne(query);
+    if (options.session) {
+      payrollFindQuery = payrollFindQuery.session(options.session);
+    }
+    const payroll2 = await payrollFindQuery;
+    if (!payroll2) {
+      throw new Error(`Payroll not found in organization ${organizationId}`);
+    }
+    const payrollObj = payroll2.toObject();
+    const updatedData = PayrollFactory.markAsProcessed(payrollObj);
+    const updated = await this.PayrollModel.findByIdAndUpdate(
+      payrollId,
+      updatedData,
+      { new: true, runValidators: true, session: options.session }
+    );
+    if (!updated) {
+      throw new Error("Failed to update payroll");
+    }
+    return updated;
+  }
+  /**
+   * Calculate period summary
+   */
+  async calculatePeriodSummary(organizationId, month, year, options = {}) {
+    const payrolls = await this.findForPeriod(organizationId, month, year, options);
+    const summary = BatchPayrollFactory.calculateTotalPayroll(payrolls);
+    return {
+      period: { month, year },
+      ...summary,
+      byStatus: this.groupByStatus(payrolls)
+    };
+  }
+  /**
+   * Get employee payroll history
+   */
+  async getEmployeePayrollHistory(employeeId, organizationId, limit = 12, options = {}) {
+    return this.findByEmployee(employeeId, organizationId, { ...options, limit });
+  }
+  /**
+   * Get overview stats
+   */
+  async getOverviewStats(organizationId, options = {}) {
+    const { month, year } = getCurrentPeriod();
+    const result = await this.calculatePeriodSummary(organizationId, month, year, options);
+    return {
+      currentPeriod: result.period,
+      count: result.count,
+      totalGross: result.totalGross,
+      totalNet: result.totalNet,
+      totalAllowances: result.totalAllowances,
+      totalDeductions: result.totalDeductions,
+      byStatus: result.byStatus
+    };
+  }
+  /**
+   * Group payrolls by status
+   */
+  groupByStatus(payrolls) {
+    return payrolls.reduce(
+      (acc, payroll2) => {
+        acc[payroll2.status] = (acc[payroll2.status] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+  }
+};
+function createPayrollService(PayrollModel, employeeService) {
+  return new PayrollService(PayrollModel, employeeService);
+}
+
+// src/factories/compensation.factory.ts
+var CompensationFactory = class {
+  /**
+   * Create compensation object
+   */
+  static create(params) {
+    const {
+      baseAmount,
+      frequency = "monthly",
+      currency = HRM_CONFIG.payroll.defaultCurrency,
+      allowances = [],
+      deductions = [],
+      effectiveFrom = /* @__PURE__ */ new Date()
+    } = params;
+    return {
+      baseAmount,
+      frequency,
+      currency,
+      allowances: allowances.map((a) => this.createAllowance(a, baseAmount)),
+      deductions: deductions.map((d) => this.createDeduction(d, baseAmount)),
+      effectiveFrom,
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create allowance
+   */
+  static createAllowance(params, baseAmount) {
+    const amount = params.isPercentage && baseAmount ? applyPercentage(baseAmount, params.value) : params.value;
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount,
+      isPercentage: params.isPercentage ?? false,
+      value: params.isPercentage ? params.value : void 0,
+      taxable: params.taxable ?? true,
+      recurring: true,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Create deduction
+   */
+  static createDeduction(params, baseAmount) {
+    const amount = params.isPercentage && baseAmount ? applyPercentage(baseAmount, params.value) : params.value;
+    return {
+      type: params.type,
+      name: params.name || params.type,
+      amount,
+      isPercentage: params.isPercentage ?? false,
+      value: params.isPercentage ? params.value : void 0,
+      auto: params.auto ?? false,
+      recurring: true,
+      effectiveFrom: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Update base amount (immutable)
+   */
+  static updateBaseAmount(compensation, newAmount, effectiveFrom = /* @__PURE__ */ new Date()) {
+    return {
+      ...compensation,
+      baseAmount: newAmount,
+      lastModified: effectiveFrom
+    };
+  }
+  /**
+   * Add allowance (immutable)
+   */
+  static addAllowance(compensation, allowance) {
+    return {
+      ...compensation,
+      allowances: [
+        ...compensation.allowances,
+        this.createAllowance(allowance, compensation.baseAmount)
+      ],
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Remove allowance (immutable)
+   */
+  static removeAllowance(compensation, allowanceType) {
+    return {
+      ...compensation,
+      allowances: compensation.allowances.filter((a) => a.type !== allowanceType),
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Add deduction (immutable)
+   */
+  static addDeduction(compensation, deduction) {
+    return {
+      ...compensation,
+      deductions: [
+        ...compensation.deductions,
+        this.createDeduction(deduction, compensation.baseAmount)
+      ],
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Remove deduction (immutable)
+   */
+  static removeDeduction(compensation, deductionType) {
+    return {
+      ...compensation,
+      deductions: compensation.deductions.filter((d) => d.type !== deductionType),
+      lastModified: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Calculate compensation breakdown
+   */
+  static calculateBreakdown(compensation) {
+    const { baseAmount, allowances, deductions } = compensation;
+    const calculatedAllowances = allowances.map((a) => ({
+      ...a,
+      calculatedAmount: a.isPercentage && a.value !== void 0 ? applyPercentage(baseAmount, a.value) : a.amount
+    }));
+    const calculatedDeductions = deductions.map((d) => ({
+      ...d,
+      calculatedAmount: d.isPercentage && d.value !== void 0 ? applyPercentage(baseAmount, d.value) : d.amount
+    }));
+    const grossAmount = calculateGross(
+      baseAmount,
+      calculatedAllowances.map((a) => ({ amount: a.calculatedAmount }))
+    );
+    const netAmount = calculateNet(
+      grossAmount,
+      calculatedDeductions.map((d) => ({ amount: d.calculatedAmount }))
+    );
+    return {
+      baseAmount,
+      allowances: calculatedAllowances,
+      deductions: calculatedDeductions,
+      grossAmount,
+      netAmount: Math.max(0, netAmount)
+    };
+  }
+  /**
+   * Apply salary increment (immutable)
+   */
+  static applyIncrement(compensation, params) {
+    const newBaseAmount = params.amount ? compensation.baseAmount + params.amount : compensation.baseAmount * (1 + (params.percentage || 0) / 100);
+    return this.updateBaseAmount(
+      compensation,
+      Math.round(newBaseAmount),
+      params.effectiveFrom
+    );
+  }
+};
+var CompensationBuilder = class {
+  data = {
+    baseAmount: 0,
+    frequency: "monthly",
+    currency: HRM_CONFIG.payroll.defaultCurrency,
+    allowances: [],
+    deductions: []
+  };
+  /**
+   * Set base amount
+   */
+  withBase(amount, frequency = "monthly", currency = HRM_CONFIG.payroll.defaultCurrency) {
+    this.data.baseAmount = amount;
+    this.data.frequency = frequency;
+    this.data.currency = currency;
+    return this;
+  }
+  /**
+   * Add allowance
+   */
+  addAllowance(type, value, isPercentage = false, name) {
+    this.data.allowances = [
+      ...this.data.allowances || [],
+      { type, value, isPercentage, name }
+    ];
+    return this;
+  }
+  /**
+   * Add deduction
+   */
+  addDeduction(type, value, isPercentage = false, name) {
+    this.data.deductions = [
+      ...this.data.deductions || [],
+      { type, value, isPercentage, name }
+    ];
+    return this;
+  }
+  /**
+   * Set effective date
+   */
+  effectiveFrom(date) {
+    this.data.effectiveFrom = date;
+    return this;
+  }
+  /**
+   * Build compensation
+   */
+  build() {
+    if (!this.data.baseAmount) {
+      throw new Error("baseAmount is required");
+    }
+    return CompensationFactory.create(this.data);
+  }
+};
+var CompensationPresets = {
+  /**
+   * Basic compensation (base only)
+   */
+  basic(baseAmount) {
+    return new CompensationBuilder().withBase(baseAmount).build();
+  },
+  /**
+   * With house rent allowance
+   */
+  withHouseRent(baseAmount, rentPercentage = 50) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", rentPercentage, true, "House Rent").build();
+  },
+  /**
+   * With medical allowance
+   */
+  withMedical(baseAmount, medicalPercentage = 10) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("medical", medicalPercentage, true, "Medical Allowance").build();
+  },
+  /**
+   * Standard package (house rent + medical + transport)
+   */
+  standard(baseAmount) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", 50, true, "House Rent").addAllowance("medical", 10, true, "Medical Allowance").addAllowance("transport", 5, true, "Transport Allowance").build();
+  },
+  /**
+   * With provident fund
+   */
+  withProvidentFund(baseAmount, pfPercentage = 10) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", 50, true, "House Rent").addAllowance("medical", 10, true, "Medical Allowance").addDeduction("provident_fund", pfPercentage, true, "Provident Fund").build();
+  },
+  /**
+   * Executive package
+   */
+  executive(baseAmount) {
+    return new CompensationBuilder().withBase(baseAmount).addAllowance("housing", 60, true, "House Rent").addAllowance("medical", 15, true, "Medical Allowance").addAllowance("transport", 10, true, "Transport Allowance").addAllowance("mobile", 5, true, "Mobile Allowance").addDeduction("provident_fund", 10, true, "Provident Fund").build();
+  }
+};
+
+// src/services/compensation.service.ts
+var CompensationService = class {
+  constructor(EmployeeModel) {
+    this.EmployeeModel = EmployeeModel;
+  }
+  /**
+   * Get employee compensation with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization
+   */
+  async getEmployeeCompensation(employeeId, organizationId, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    return employee2.compensation;
+  }
+  /**
+   * Calculate compensation breakdown with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization
+   */
+  async calculateBreakdown(employeeId, organizationId, options = {}) {
+    const compensation = await this.getEmployeeCompensation(employeeId, organizationId, options);
+    return CompensationFactory.calculateBreakdown(compensation);
+  }
+  /**
+   * Update base amount with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async updateBaseAmount(employeeId, organizationId, newAmount, effectiveFrom = /* @__PURE__ */ new Date(), options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    const updatedCompensation = CompensationFactory.updateBaseAmount(
+      employee2.compensation,
+      newAmount,
+      effectiveFrom
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Compensation base amount updated", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      newAmount
+    });
+    return this.calculateBreakdown(employeeId, organizationId, options);
+  }
+  /**
+   * Apply salary increment with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async applyIncrement(employeeId, organizationId, params, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    const previousAmount = employee2.compensation.baseAmount;
+    const updatedCompensation = CompensationFactory.applyIncrement(
+      employee2.compensation,
+      params
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Salary increment applied", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      previousAmount,
+      newAmount: updatedCompensation.baseAmount,
+      percentage: params.percentage
+    });
+    return this.calculateBreakdown(employeeId, organizationId, options);
+  }
+  /**
+   * Add allowance with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async addAllowance(employeeId, organizationId, allowance, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    const updatedCompensation = CompensationFactory.addAllowance(
+      employee2.compensation,
+      allowance
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Allowance added", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      type: allowance.type,
+      value: allowance.value
+    });
+    return this.calculateBreakdown(employeeId, organizationId, options);
+  }
+  /**
+   * Remove allowance with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async removeAllowance(employeeId, organizationId, allowanceType, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    const updatedCompensation = CompensationFactory.removeAllowance(
+      employee2.compensation,
+      allowanceType
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Allowance removed", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      type: allowanceType
+    });
+    return this.calculateBreakdown(employeeId, organizationId, options);
+  }
+  /**
+   * Add deduction with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async addDeduction(employeeId, organizationId, deduction, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    const updatedCompensation = CompensationFactory.addDeduction(
+      employee2.compensation,
+      deduction
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Deduction added", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      type: deduction.type,
+      value: deduction.value
+    });
+    return this.calculateBreakdown(employeeId, organizationId, options);
+  }
+  /**
+   * Remove deduction with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async removeDeduction(employeeId, organizationId, deductionType, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    const updatedCompensation = CompensationFactory.removeDeduction(
+      employee2.compensation,
+      deductionType
+    );
+    employee2.compensation = updatedCompensation;
+    await employee2.save({ session: options.session });
+    logger.info("Deduction removed", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      type: deductionType
+    });
+    return this.calculateBreakdown(employeeId, organizationId, options);
+  }
+  /**
+   * Set standard compensation with organization validation
+   * 
+   * ⚠️ SECURITY: Validates employee belongs to organization before update
+   */
+  async setStandardCompensation(employeeId, organizationId, baseAmount, options = {}) {
+    const employee2 = await this.findEmployee(employeeId, organizationId, options);
+    employee2.compensation = CompensationPresets.standard(baseAmount);
+    await employee2.save({ session: options.session });
+    logger.info("Standard compensation set", {
+      employeeId: employee2.employeeId,
+      organizationId: organizationId.toString(),
+      baseAmount
+    });
+    return this.calculateBreakdown(employeeId, organizationId, options);
+  }
+  /**
+   * Compare compensation between two employees
+   * 
+   * ⚠️ SECURITY: Validates both employees belong to organization
+   */
+  async compareCompensation(employeeId1, employeeId2, organizationId, options = {}) {
+    const breakdown1 = await this.calculateBreakdown(employeeId1, organizationId, options);
+    const breakdown2 = await this.calculateBreakdown(employeeId2, organizationId, options);
+    return {
+      employee1: breakdown1,
+      employee2: breakdown2,
+      difference: {
+        base: breakdown2.baseAmount - breakdown1.baseAmount,
+        gross: breakdown2.grossAmount - breakdown1.grossAmount,
+        net: breakdown2.netAmount - breakdown1.netAmount
+      },
+      ratio: {
+        base: breakdown1.baseAmount > 0 ? breakdown2.baseAmount / breakdown1.baseAmount : 0,
+        gross: breakdown1.grossAmount > 0 ? breakdown2.grossAmount / breakdown1.grossAmount : 0,
+        net: breakdown1.netAmount > 0 ? breakdown2.netAmount / breakdown1.netAmount : 0
+      }
+    };
+  }
+  /**
+   * Get department compensation stats
+   */
+  async getDepartmentCompensationStats(organizationId, department, options = {}) {
+    let query = this.EmployeeModel.find({
+      organizationId: toObjectId(organizationId),
+      department,
+      status: { $in: ["active", "on_leave"] }
+    });
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    const employees = await query.exec();
+    const breakdowns = employees.map(
+      (emp) => CompensationFactory.calculateBreakdown(emp.compensation)
+    );
+    const totals = breakdowns.reduce(
+      (acc, breakdown) => ({
+        totalBase: acc.totalBase + breakdown.baseAmount,
+        totalGross: acc.totalGross + breakdown.grossAmount,
+        totalNet: acc.totalNet + breakdown.netAmount
+      }),
+      { totalBase: 0, totalGross: 0, totalNet: 0 }
+    );
+    const count = employees.length || 1;
+    return {
+      department,
+      employeeCount: employees.length,
+      ...totals,
+      averageBase: Math.round(totals.totalBase / count),
+      averageGross: Math.round(totals.totalGross / count),
+      averageNet: Math.round(totals.totalNet / count)
+    };
+  }
+  /**
+   * Get organization compensation stats
+   */
+  async getOrganizationCompensationStats(organizationId, options = {}) {
+    let query = this.EmployeeModel.find({
+      organizationId: toObjectId(organizationId),
+      status: { $in: ["active", "on_leave"] }
+    });
+    if (options.session) {
+      query = query.session(options.session);
+    }
+    const employees = await query.exec();
+    const breakdowns = employees.map(
+      (emp) => CompensationFactory.calculateBreakdown(emp.compensation)
+    );
+    const totals = breakdowns.reduce(
+      (acc, breakdown) => ({
+        totalBase: acc.totalBase + breakdown.baseAmount,
+        totalGross: acc.totalGross + breakdown.grossAmount,
+        totalNet: acc.totalNet + breakdown.netAmount
+      }),
+      { totalBase: 0, totalGross: 0, totalNet: 0 }
+    );
+    const byDepartment = {};
+    employees.forEach((emp, i) => {
+      const dept = emp.department || "unassigned";
+      if (!byDepartment[dept]) {
+        byDepartment[dept] = { count: 0, totalNet: 0 };
+      }
+      byDepartment[dept].count++;
+      byDepartment[dept].totalNet += breakdowns[i].netAmount;
+    });
+    const count = employees.length || 1;
+    return {
+      employeeCount: employees.length,
+      ...totals,
+      averageBase: Math.round(totals.totalBase / count),
+      averageGross: Math.round(totals.totalGross / count),
+      averageNet: Math.round(totals.totalNet / count),
+      byDepartment
+    };
+  }
+  /**
+   * Find employee helper with organization validation
+   * 
+   * ⚠️ SECURITY: Always validates employee belongs to organization
+   */
+  async findEmployee(employeeId, organizationId, options = {}) {
+    const query = {
+      _id: toObjectId(employeeId),
+      organizationId: toObjectId(organizationId)
+    };
+    let mongooseQuery = this.EmployeeModel.findOne(query);
+    if (options.session) {
+      mongooseQuery = mongooseQuery.session(options.session);
+    }
+    const employee2 = await mongooseQuery.exec();
+    if (!employee2) {
+      throw new Error(`Employee not found in organization ${organizationId}`);
+    }
+    return employee2;
+  }
+};
+function createCompensationService(EmployeeModel) {
+  return new CompensationService(EmployeeModel);
+}
+
+// src/services/tax-withholding.service.ts
+var TaxWithholdingService = class {
+  constructor(TaxWithholdingModel, TransactionModel, events) {
+    this.TaxWithholdingModel = TaxWithholdingModel;
+    this.TransactionModel = TransactionModel;
+    this.events = events;
+  }
+  /**
+   * Create tax withholding records from payroll breakdown
+   *
+   * Extracts tax deductions from the breakdown and creates separate
+   * TaxWithholding records for each tax type
+   */
+  async createFromBreakdown(params) {
+    const {
+      organizationId,
+      employeeId,
+      userId,
+      payrollRecordId,
+      transactionId,
+      period,
+      breakdown,
+      currency = "BDT",
+      session,
+      context
+    } = params;
+    const taxDeductions = breakdown.deductions?.filter(
+      (d) => d.type === "tax" || this.isTaxDeduction(d.type)
+    ) || [];
+    if (taxDeductions.length === 0) {
+      return [];
+    }
+    const withholdings = [];
+    for (const deduction of taxDeductions) {
+      const taxType = this.mapDeductionTypeToTaxType(deduction.type);
+      const taxRate = breakdown.taxableAmount && breakdown.taxableAmount > 0 ? deduction.amount / breakdown.taxableAmount : 0;
+      const withholdingData = {
+        organizationId,
+        employeeId,
+        userId,
+        payrollRecordId,
+        transactionId,
+        period,
+        amount: deduction.amount,
+        currency,
+        taxType,
+        taxRate,
+        taxableAmount: breakdown.taxableAmount || breakdown.grossSalary,
+        status: TAX_STATUS.PENDING
+      };
+      const [withholding] = await this.TaxWithholdingModel.create([withholdingData], {
+        session
+      });
+      withholdings.push(withholding);
+      if (this.events) {
+        this.events.emitSync("tax:withheld", {
+          withholding: {
+            id: withholding._id,
+            taxType: withholding.taxType,
+            amount: withholding.amount
+          },
+          employee: {
+            id: employeeId,
+            employeeId: ""
+            // Will be filled by caller if needed
+          },
+          payrollRecord: {
+            id: payrollRecordId
+          },
+          period: {
+            month: period.month,
+            year: period.year
+          },
+          organizationId,
+          context
+        });
+      }
+      logger.info("Tax withholding created", {
+        withholdingId: withholding._id.toString(),
+        employeeId: employeeId.toString(),
+        taxType,
+        amount: deduction.amount,
+        period: `${period.month}/${period.year}`
+      });
+    }
+    return withholdings;
+  }
+  /**
+   * Get pending tax withholdings with optional filters
+   */
+  async getPending(params) {
+    const { organizationId, fromPeriod, toPeriod, taxType, employeeId } = params;
+    const options = {};
+    if (fromPeriod) {
+      options.fromMonth = fromPeriod.month;
+      options.fromYear = fromPeriod.year;
+    }
+    if (toPeriod) {
+      options.toMonth = toPeriod.month;
+      options.toYear = toPeriod.year;
+    }
+    if (taxType) {
+      options.taxType = taxType;
+    }
+    let query = this.TaxWithholdingModel.findPending(
+      toObjectId(organizationId),
+      options
+    );
+    if (employeeId) {
+      query = query.where({ employeeId: toObjectId(employeeId) });
+    }
+    return query.exec();
+  }
+  /**
+   * Get tax summary aggregated by type, period, or employee
+   */
+  async getSummary(params) {
+    const { organizationId, fromPeriod, toPeriod, groupBy = "type" } = params;
+    if (groupBy === "type") {
+      const byType = await this.TaxWithholdingModel.getSummaryByType(
+        toObjectId(organizationId),
+        fromPeriod,
+        toPeriod
+      );
+      const totalAmount = byType.reduce((sum2, item) => sum2 + item.totalAmount, 0);
+      const count = byType.reduce((sum2, item) => sum2 + item.count, 0);
+      return {
+        totalAmount,
+        count,
+        byType,
+        period: {
+          fromMonth: fromPeriod.month,
+          fromYear: fromPeriod.year,
+          toMonth: toPeriod.month,
+          toYear: toPeriod.year
+        }
+      };
+    }
+    throw new Error(`groupBy '${groupBy}' not yet implemented`);
+  }
+  /**
+   * Mark tax withholdings as paid
+   *
+   * Updates status, optionally creates government payment transaction,
+   * and emits tax:paid event
+   */
+  async markPaid(params) {
+    const {
+      organizationId,
+      withholdingIds,
+      createTransaction = false,
+      referenceNumber,
+      paidAt = /* @__PURE__ */ new Date(),
+      notes,
+      context
+    } = params;
+    const session = context?.session;
+    const withholdings = await this.TaxWithholdingModel.find({
+      _id: { $in: withholdingIds.map(toObjectId) },
+      organizationId: toObjectId(organizationId)
+    }).session(session || null);
+    if (withholdings.length === 0) {
+      throw new Error("No tax withholdings found with provided IDs");
+    }
+    const totalAmount = withholdings.reduce((sum2, w) => sum2 + w.amount, 0);
+    let governmentTransaction = null;
+    if (createTransaction && this.TransactionModel) {
+      const transactionData = {
+        organizationId: toObjectId(organizationId),
+        type: "tax_payment",
+        flow: "outflow",
+        tags: ["tax", "government", "withholding"],
+        amount: totalAmount,
+        grossAmount: totalAmount,
+        currency: withholdings[0].currency || "BDT",
+        status: "completed",
+        date: paidAt,
+        description: `Tax payment to government - ${referenceNumber || "Multiple withholdings"}`,
+        notes,
+        metadata: {
+          withholdingIds: withholdingIds.map((id) => id.toString()),
+          referenceNumber
+        }
+      };
+      [governmentTransaction] = await this.TransactionModel.create([transactionData], {
+        session
+      });
+    }
+    for (const withholding of withholdings) {
+      withholding.markAsPaid(
+        governmentTransaction?._id,
+        referenceNumber,
+        paidAt
+      );
+      await withholding.save({ session });
+    }
+    if (this.events) {
+      this.events.emitSync("tax:paid", {
+        withholdings: withholdings.map((w) => ({
+          id: w._id,
+          taxType: w.taxType,
+          amount: w.amount
+        })),
+        transaction: governmentTransaction ? {
+          id: governmentTransaction._id,
+          amount: governmentTransaction.amount
+        } : void 0,
+        totalAmount,
+        referenceNumber,
+        paidAt,
+        organizationId: toObjectId(organizationId),
+        context
+      });
+    }
+    logger.info("Tax withholdings marked as paid", {
+      count: withholdings.length,
+      totalAmount,
+      referenceNumber,
+      transactionId: governmentTransaction?._id.toString()
+    });
+    return {
+      withholdings,
+      transaction: governmentTransaction
+    };
+  }
+  /**
+   * Get tax withholdings for a specific payroll record
+   */
+  async getByPayrollRecord(payrollRecordId) {
+    return this.TaxWithholdingModel.getByPayrollRecord(toObjectId(payrollRecordId)).exec();
+  }
+  /**
+   * Get tax withholdings for a specific employee
+   */
+  async getByEmployee(employeeId, options) {
+    return this.TaxWithholdingModel.findByEmployee(toObjectId(employeeId), options).exec();
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  /**
+   * Check if deduction type is a tax deduction
+   */
+  isTaxDeduction(deductionType) {
+    const taxTypes = ["tax", "income_tax", "social_security", "health_insurance", "pension", "employment_insurance", "local_tax"];
+    return taxTypes.includes(deductionType.toLowerCase());
+  }
+  /**
+   * Map deduction type to TaxType enum
+   */
+  mapDeductionTypeToTaxType(deductionType) {
+    const typeMap = {
+      "tax": TAX_TYPE.INCOME_TAX,
+      "income_tax": TAX_TYPE.INCOME_TAX,
+      "social_security": TAX_TYPE.SOCIAL_SECURITY,
+      "health_insurance": TAX_TYPE.HEALTH_INSURANCE,
+      "pension": TAX_TYPE.PENSION,
+      "employment_insurance": TAX_TYPE.EMPLOYMENT_INSURANCE,
+      "local_tax": TAX_TYPE.LOCAL_TAX
+    };
+    return typeMap[deductionType.toLowerCase()] || TAX_TYPE.OTHER;
+  }
+};
+function createTaxWithholdingService(config) {
+  return new TaxWithholdingService(
+    config.TaxWithholdingModel,
+    config.TransactionModel,
+    config.events
+  );
+}
+
+export { CompensationService, EmployeeService, PayrollService, TaxWithholdingService, createCompensationService, createEmployeeService, createPayrollService, createTaxWithholdingService };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map