@classytic/payroll 1.0.2 → 2.0.0

package/src/services/employee.service.js

@@ -1,162 +0,0 @@
-/**
- * Employee Service - Clean Abstraction for Employee Operations
- * Dependency injection, testable, beautiful API
- */
-
-import { EmployeeFactory } from '../factories/employee.factory.js';
-import { employee as employeeQuery } from '../utils/query-builders.js';
-import {
-  isActive,
-  isEmployed,
-  canReceiveSalary,
-} from '../utils/validation.utils.js';
-
-export class EmployeeService {
-  constructor(EmployeeModel) {
-    this.EmployeeModel = EmployeeModel;
-  }
-
-  async findById(employeeId) {
-    return this.EmployeeModel.findById(employeeId);
-  }
-
-  async findByUserId(userId, organizationId) {
-    const query = employeeQuery()
-      .forUser(userId)
-      .forOrganization(organizationId)
-      .build();
-
-    return this.EmployeeModel.findOne(query);
-  }
-
-  async findActive(organizationId, options = {}) {
-    const query = employeeQuery()
-      .forOrganization(organizationId)
-      .active()
-      .build();
-
-    return this.EmployeeModel.find(query, options.projection);
-  }
-
-  async findEmployed(organizationId, options = {}) {
-    const query = employeeQuery()
-      .forOrganization(organizationId)
-      .employed()
-      .build();
-
-    return this.EmployeeModel.find(query, options.projection);
-  }
-
-  async findByDepartment(organizationId, department) {
-    const query = employeeQuery()
-      .forOrganization(organizationId)
-      .inDepartment(department)
-      .active()
-      .build();
-
-    return this.EmployeeModel.find(query);
-  }
-
-  async findEligibleForPayroll(organizationId, month, year) {
-    const query = employeeQuery()
-      .forOrganization(organizationId)
-      .employed()
-      .build();
-
-    const employees = await this.EmployeeModel.find(query);
-    return employees.filter(canReceiveSalary);
-  }
-
-  async create(data) {
-    const employeeData = EmployeeFactory.create(data);
-    return this.EmployeeModel.create(employeeData);
-  }
-
-  async updateStatus(employeeId, status, context = {}) {
-    const employee = await this.findById(employeeId);
-    if (!employee) throw new Error('Employee not found');
-
-    employee.status = status;
-    employee.statusHistory = employee.statusHistory || [];
-    employee.statusHistory.push({
-      status,
-      changedAt: new Date(),
-      changedBy: {
-        userId: context.userId,
-        name: context.userName,
-      },
-      reason: context.reason,
-    });
-
-    return employee.save();
-  }
-
-  async terminate(employeeId, reason, context = {}) {
-    const employee = await this.findById(employeeId);
-    if (!employee) throw new Error('Employee not found');
-
-    const terminationData = EmployeeFactory.createTermination({
-      reason,
-      notes: context.notes,
-      context,
-    });
-
-    employee.status = 'terminated';
-    Object.assign(employee, terminationData);
-
-    return employee.save();
-  }
-
-  async updateCompensation(employeeId, compensation) {
-    return this.EmployeeModel.findByIdAndUpdate(
-      employeeId,
-      { compensation, updatedAt: new Date() },
-      { new: true, runValidators: true }
-    );
-  }
-
-  async getEmployeeStats(organizationId) {
-    const query = employeeQuery().forOrganization(organizationId).build();
-
-    const employees = await this.EmployeeModel.find(query);
-
-    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),
-    };
-  }
-
-  groupByStatus(employees) {
-    return employees.reduce((acc, emp) => {
-      acc[emp.status] = (acc[emp.status] || 0) + 1;
-      return acc;
-    }, {});
-  }
-
-  groupByDepartment(employees) {
-    return employees.reduce((acc, emp) => {
-      const dept = emp.department || 'unassigned';
-      acc[dept] = (acc[dept] || 0) + 1;
-      return acc;
-    }, {});
-  }
-
-  isActive(employee) {
-    return isActive(employee);
-  }
-
-  isEmployed(employee) {
-    return isEmployed(employee);
-  }
-
-  canReceiveSalary(employee) {
-    return canReceiveSalary(employee);
-  }
-}
-
-export const createEmployeeService = (EmployeeModel) =>
-  new EmployeeService(EmployeeModel);

package/src/services/payroll.service.js

@@ -1,213 +0,0 @@
-/**
- * Payroll Service - Beautiful Payroll Processing
- * Clean abstraction with dependency injection
- */
-
-import {
-  PayrollFactory,
-  BatchPayrollFactory,
-} from '../factories/payroll.factory.js';
-
-import { payroll as payrollQuery } from '../utils/query-builders.js';
-import { getCurrentPeriod } from '../utils/date.utils.js';
-
-export class PayrollService {
-  constructor(PayrollModel, EmployeeService) {
-    this.PayrollModel = PayrollModel;
-    this.EmployeeService = EmployeeService;
-  }
-
-  async findById(payrollId) {
-    return this.PayrollModel.findById(payrollId);
-  }
-
-  async findByEmployee(employeeId, organizationId, options = {}) {
-    const query = payrollQuery()
-      .forEmployee(employeeId)
-      .forOrganization(organizationId)
-      .build();
-
-    return this.PayrollModel.find(query)
-      .sort({ 'period.year': -1, 'period.month': -1 })
-      .limit(options.limit || 12);
-  }
-
-  async findForPeriod(organizationId, month, year) {
-    const query = payrollQuery()
-      .forOrganization(organizationId)
-      .forPeriod(month, year)
-      .build();
-
-    return this.PayrollModel.find(query);
-  }
-
-  async findPending(organizationId, month, year) {
-    const query = payrollQuery()
-      .forOrganization(organizationId)
-      .forPeriod(month, year)
-      .withStatus('pending')
-      .build();
-
-    return this.PayrollModel.find(query);
-  }
-
-  async create(data) {
-    const payrollData = PayrollFactory.create(data);
-    return this.PayrollModel.create(payrollData);
-  }
-
-  async generateForEmployee(employeeId, organizationId, month, year) {
-    const employee = await this.EmployeeService.findById(employeeId);
-    if (!employee) throw new Error('Employee not found');
-
-    if (!this.EmployeeService.canReceiveSalary(employee)) {
-      throw new Error('Employee not eligible for payroll');
-    }
-
-    // Check if payroll already exists
-    const existing = await this.findByEmployeeAndPeriod(
-      employeeId,
-      organizationId,
-      month,
-      year
-    );
-    if (existing) throw new Error('Payroll already exists for this period');
-
-    return this.create({
-      employeeId,
-      organizationId,
-      baseAmount: employee.compensation.baseAmount,
-      allowances: employee.compensation.allowances || [],
-      deductions: employee.compensation.deductions || [],
-      period: { month, year },
-      metadata: {
-        currency: employee.compensation.currency,
-      },
-    });
-  }
-
-  async generateBatch(organizationId, month, year) {
-    const employees = await this.EmployeeService.findEligibleForPayroll(
-      organizationId,
-      month,
-      year
-    );
-
-    if (employees.length === 0) {
-      return { success: true, generated: 0, message: 'No eligible employees' };
-    }
-
-    // Filter out employees who already have payroll for this period
-    const existingPayrolls = await this.findForPeriod(
-      organizationId,
-      month,
-      year
-    );
-    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,
-        message: 'Payrolls already exist for all employees',
-      };
-    }
-
-    const payrolls = BatchPayrollFactory.createBatch(eligibleEmployees, {
-      month,
-      year,
-      organizationId,
-    });
-
-    const created = await this.PayrollModel.insertMany(payrolls);
-
-    return {
-      success: true,
-      generated: created.length,
-      payrolls: created,
-    };
-  }
-
-  async markAsPaid(payrollId, paymentDetails = {}) {
-    const payroll = await this.findById(payrollId);
-    if (!payroll) throw new Error('Payroll not found');
-
-    if (payroll.status === 'paid') {
-      throw new Error('Payroll already paid');
-    }
-
-    const updatedPayroll = PayrollFactory.markAsPaid(payroll, paymentDetails);
-
-    return this.PayrollModel.findByIdAndUpdate(
-      payrollId,
-      updatedPayroll,
-      { new: true, runValidators: true }
-    );
-  }
-
-  async markAsProcessed(payrollId) {
-    const payroll = await this.findById(payrollId);
-    if (!payroll) throw new Error('Payroll not found');
-
-    const updatedPayroll = PayrollFactory.markAsProcessed(payroll);
-
-    return this.PayrollModel.findByIdAndUpdate(
-      payrollId,
-      updatedPayroll,
-      { new: true, runValidators: true }
-    );
-  }
-
-  async calculatePeriodSummary(organizationId, month, year) {
-    const payrolls = await this.findForPeriod(organizationId, month, year);
-    const summary = BatchPayrollFactory.calculateTotalPayroll(payrolls);
-
-    return {
-      period: { month, year },
-      ...summary,
-      byStatus: this.groupByStatus(payrolls),
-    };
-  }
-
-  async getEmployeePayrollHistory(employeeId, organizationId, limit = 12) {
-    return this.findByEmployee(employeeId, organizationId, { limit });
-  }
-
-  async findByEmployeeAndPeriod(employeeId, organizationId, month, year) {
-    const query = payrollQuery()
-      .forEmployee(employeeId)
-      .forOrganization(organizationId)
-      .forPeriod(month, year)
-      .build();
-
-    return this.PayrollModel.findOne(query);
-  }
-
-  groupByStatus(payrolls) {
-    return payrolls.reduce((acc, payroll) => {
-      acc[payroll.status] = (acc[payroll.status] || 0) + 1;
-      return acc;
-    }, {});
-  }
-
-  async getOverviewStats(organizationId) {
-    const { month, year } = getCurrentPeriod();
-    const currentPeriod = await this.findForPeriod(organizationId, month, year);
-    const summary = BatchPayrollFactory.calculateTotalPayroll(currentPeriod);
-
-    return {
-      currentPeriod: { month, year },
-      ...summary,
-      byStatus: this.groupByStatus(currentPeriod),
-    };
-  }
-}
-
-export const createPayrollService = (PayrollModel, EmployeeService) =>
-  new PayrollService(PayrollModel, EmployeeService);

package/src/utils/calculation.utils.js

@@ -1,91 +0,0 @@
-/**
- * Calculation Utilities - Pure, Functional, Composable
- * Beautiful financial calculations without side effects
- */
-
-export const sum = (items, key) =>
-  items.reduce((total, item) => total + (key ? item[key] : item), 0);
-
-export const sumBy = (key) => (items) => sum(items, key);
-
-export const sumAllowances = sumBy('amount');
-
-export const sumDeductions = sumBy('amount');
-
-export const calculateGross = (base, allowances) =>
-  base + sumAllowances(allowances);
-
-export const calculateNet = (gross, deductions) =>
-  gross - sumDeductions(deductions);
-
-export const calculateTotalCompensation = (base, allowances, deductions) => {
-  const gross = calculateGross(base, allowances);
-  const net = calculateNet(gross, deductions);
-  return { gross, net, deductions: sumDeductions(deductions) };
-};
-
-export const applyTaxBracket = (amount, brackets) => {
-  let tax = 0;
-  let remaining = amount;
-
-  for (const bracket of brackets) {
-    if (remaining <= 0) break;
-
-    const taxableInBracket = bracket.limit
-      ? Math.min(remaining, bracket.limit - (bracket.from || 0))
-      : remaining;
-
-    tax += taxableInBracket * bracket.rate;
-    remaining -= taxableInBracket;
-  }
-
-  return tax;
-};
-
-export const calculateTax = (amount, brackets) => ({
-  gross: amount,
-  tax: applyTaxBracket(amount, brackets),
-  net: amount - applyTaxBracket(amount, brackets),
-});
-
-export const proRateAmount = (amount, workedDays, totalDays) =>
-  Math.round((amount * workedDays) / totalDays);
-
-export const calculatePercentage = (value, total) =>
-  total > 0 ? Math.round((value / total) * 100) : 0;
-
-export const applyPercentage = (amount, percentage) =>
-  Math.round(amount * (percentage / 100));
-
-export const composeDeductions = (...deductionFns) => (amount) =>
-  deductionFns.reduce((remaining, fn) => fn(remaining), amount);
-
-export const composeSalaryPipeline = (base, operations) =>
-  operations.reduce((acc, operation) => operation(acc), { base, total: base });
-
-export const createAllowanceCalculator = (allowances) => (base) =>
-  allowances.map((a) => ({
-    ...a,
-    amount: a.isPercentage ? applyPercentage(base, a.value) : a.value,
-  }));
-
-export const createDeductionCalculator = (deductions) => (gross) =>
-  deductions.map((d) => ({
-    ...d,
-    amount: d.isPercentage ? applyPercentage(gross, d.value) : d.value,
-  }));
-
-/**
- * Functional Composition Utilities
- * Build complex operations from simple functions
- */
-
-// Pipe: Left-to-right function composition
-// pipe(f, g, h)(x) === h(g(f(x)))
-export const pipe = (...fns) => (value) =>
-  fns.reduce((acc, fn) => fn(acc), value);
-
-// Compose: Right-to-left function composition
-// compose(f, g, h)(x) === f(g(h(x)))
-export const compose = (...fns) => (value) =>
-  fns.reduceRight((acc, fn) => fn(acc), value);

package/src/utils/date.utils.js

@@ -1,120 +0,0 @@
-/**
- * Date Utilities - Pure, Composable, Testable
- * Elegant date operations without side effects
- */
-
-export const addDays = (date, days) => {
-  const result = new Date(date);
-  result.setDate(result.getDate() + days);
-  return result;
-};
-
-export const addMonths = (date, months) => {
-  const result = new Date(date);
-  result.setMonth(result.getMonth() + months);
-  return result;
-};
-
-export const addYears = (date, years) => {
-  const result = new Date(date);
-  result.setFullYear(result.getFullYear() + years);
-  return result;
-};
-
-export const startOfMonth = (date) => {
-  const result = new Date(date);
-  result.setDate(1);
-  result.setHours(0, 0, 0, 0);
-  return result;
-};
-
-export const endOfMonth = (date) => {
-  const result = new Date(date);
-  result.setMonth(result.getMonth() + 1, 0);
-  result.setHours(23, 59, 59, 999);
-  return result;
-};
-
-export const startOfYear = (date) => {
-  const result = new Date(date);
-  result.setMonth(0, 1);
-  result.setHours(0, 0, 0, 0);
-  return result;
-};
-
-export const endOfYear = (date) => {
-  const result = new Date(date);
-  result.setMonth(11, 31);
-  result.setHours(23, 59, 59, 999);
-  return result;
-};
-
-export const isWeekday = (date) => {
-  const day = new Date(date).getDay();
-  return day >= 1 && day <= 5;
-};
-
-export const isWeekend = (date) => {
-  const day = new Date(date).getDay();
-  return day === 0 || day === 6;
-};
-
-export const getPayPeriod = (month, year) => {
-  const startDate = new Date(year, month - 1, 1);
-  return {
-    month,
-    year,
-    startDate: startOfMonth(startDate),
-    endDate: endOfMonth(startDate),
-  };
-};
-
-export const getCurrentPeriod = (date = new Date()) => {
-  const d = new Date(date);
-  return {
-    year: d.getFullYear(),
-    month: d.getMonth() + 1,
-  };
-};
-
-export const calculateProbationEnd = (hireDate, probationMonths) =>
-  probationMonths ? addMonths(hireDate, probationMonths) : null;
-
-export const formatDateForDB = (date) => {
-  if (!date) return null;
-  return new Date(date).toISOString();
-};
-
-export const parseDBDate = (dateString) => {
-  if (!dateString) return null;
-  return new Date(dateString);
-};
-
-export const diffInDays = (start, end) =>
-  Math.ceil((new Date(end) - new Date(start)) / (1000 * 60 * 60 * 24));
-
-export const diffInMonths = (start, end) => {
-  const startDate = new Date(start);
-  const endDate = new Date(end);
-  return (
-    (endDate.getFullYear() - startDate.getFullYear()) * 12 +
-    (endDate.getMonth() - startDate.getMonth())
-  );
-};
-
-// Aliases for backwards compatibility
-export const daysBetween = diffInDays;
-export const monthsBetween = diffInMonths;
-
-export const isDateInRange = (date, start, end) => {
-  const checkDate = new Date(date);
-  return checkDate >= new Date(start) && checkDate <= new Date(end);
-};
-
-export const formatPeriod = ({ month, year }) =>
-  `${String(month).padStart(2, '0')}/${year}`;
-
-export const parsePeriod = (periodString) => {
-  const [month, year] = periodString.split('/').map(Number);
-  return { month, year };
-};

package/src/utils/logger.js

@@ -1,36 +0,0 @@
-/**
- * Logger Abstraction for HRM Library
- *
- * Defaults to console for standalone usage
- * Can be overridden with custom logger (pino, winston, etc)
- *
- * Usage:
- * ```javascript
- * import { setLogger } from '@fitverse/hrm';
- *
- * // Optional: Use your own logger
- * setLogger(myPinoLogger);
- * ```
- */
-
-let _logger = console;
-
-/**
- * Set custom logger implementation
- * @param {Object} customLogger - Logger instance with info, warn, error, debug methods
- */
-export function setLogger(customLogger) {
-  _logger = customLogger;
-}
-
-/**
- * Logger proxy - delegates to current logger implementation
- */
-export const logger = {
-  info: (...args) => _logger.info?.(...args) || _logger.log?.('INFO:', ...args),
-  warn: (...args) => _logger.warn?.(...args) || _logger.log?.('WARN:', ...args),
-  error: (...args) => _logger.error?.(...args) || _logger.log?.('ERROR:', ...args),
-  debug: (...args) => _logger.debug?.(...args) || _logger.log?.('DEBUG:', ...args),
-};
-
-export default logger;