@classytic/payroll 2.0.0 → 2.3.0

package/dist/core/index.js

@@ -1,3 +1,5 @@
+import { LRUCache } from 'lru-cache';
+
 // src/core/result.ts
 function ok(value) {
   return { ok: true, value };
@@ -263,6 +265,219 @@ function onPayrollCompleted(handler) {
 function onMilestoneAchieved(handler) {
   return getEventBus().on("milestone:achieved", handler);
 }
+var IdempotencyManager = class {
+  cache;
+  constructor(options = {}) {
+    this.cache = new LRUCache({
+      max: options.max || 1e4,
+      // Store 10k keys
+      ttl: options.ttl || 1e3 * 60 * 60 * 24
+      // 24 hours default
+    });
+  }
+  /**
+   * Check if key exists and return cached result
+   */
+  get(key) {
+    const cached = this.cache.get(key);
+    if (!cached) return null;
+    return {
+      value: cached.value,
+      cached: true,
+      createdAt: cached.createdAt
+    };
+  }
+  /**
+   * Store result for idempotency key
+   */
+  set(key, value) {
+    this.cache.set(key, {
+      value,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Execute function with idempotency protection
+   */
+  async execute(key, fn) {
+    const cached = this.get(key);
+    if (cached) {
+      return cached;
+    }
+    const value = await fn();
+    this.set(key, value);
+    return {
+      value,
+      cached: false,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Clear a specific key
+   */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Clear all keys
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache stats
+   */
+  stats() {
+    return {
+      size: this.cache.size,
+      max: this.cache.max
+    };
+  }
+};
+function generatePayrollIdempotencyKey(organizationId, employeeId, month, year) {
+  return `payroll:${organizationId}:${employeeId}:${year}-${month}`;
+}
+
+// src/core/webhooks.ts
+var WebhookManager = class {
+  webhooks = [];
+  deliveryLog = [];
+  /**
+   * Register a webhook
+   */
+  register(config) {
+    this.webhooks.push({
+      retries: 3,
+      timeout: 3e4,
+      ...config
+    });
+  }
+  /**
+   * Remove a webhook
+   */
+  unregister(url) {
+    this.webhooks = this.webhooks.filter((w) => w.url !== url);
+  }
+  /**
+   * Send webhook for event
+   */
+  async send(event, payload) {
+    const matchingWebhooks = this.webhooks.filter((w) => w.events.includes(event));
+    const deliveries = matchingWebhooks.map(
+      (webhook) => this.deliver(webhook, event, payload)
+    );
+    await Promise.allSettled(deliveries);
+  }
+  /**
+   * Deliver webhook with retries
+   */
+  async deliver(webhook, event, payload) {
+    const deliveryId = `${Date.now()}-${Math.random().toString(36)}`;
+    const delivery = {
+      id: deliveryId,
+      event,
+      url: webhook.url,
+      payload,
+      attempt: 0,
+      status: "pending"
+    };
+    this.deliveryLog.push(delivery);
+    const maxRetries = webhook.retries || 3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      delivery.attempt = attempt;
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), webhook.timeout || 3e4);
+        const headers = {
+          "Content-Type": "application/json",
+          "X-Payroll-Event": event,
+          "X-Payroll-Delivery": deliveryId,
+          ...webhook.headers
+        };
+        if (webhook.secret) {
+          headers["X-Payroll-Signature"] = this.generateSignature(payload, webhook.secret);
+        }
+        const response = await fetch(webhook.url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            event,
+            payload,
+            deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
+          }),
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        delivery.response = {
+          status: response.status,
+          body: await response.text()
+        };
+        delivery.sentAt = /* @__PURE__ */ new Date();
+        if (response.ok) {
+          delivery.status = "sent";
+          return delivery;
+        }
+        if (response.status >= 500 && attempt < maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+          continue;
+        }
+        delivery.status = "failed";
+        delivery.error = `HTTP ${response.status}`;
+        return delivery;
+      } catch (error) {
+        delivery.error = error.message;
+        if (attempt < maxRetries) {
+          await this.sleep(Math.pow(2, attempt) * 1e3);
+          continue;
+        }
+        delivery.status = "failed";
+        return delivery;
+      }
+    }
+    return delivery;
+  }
+  /**
+   * Generate HMAC signature for webhook
+   */
+  generateSignature(payload, secret) {
+    const data = JSON.stringify(payload);
+    return Buffer.from(`${secret}:${data}`).toString("base64");
+  }
+  /**
+   * Sleep for ms
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get delivery log
+   */
+  getDeliveries(options) {
+    let results = this.deliveryLog;
+    if (options?.event) {
+      results = results.filter((d) => d.event === options.event);
+    }
+    if (options?.status) {
+      results = results.filter((d) => d.status === options.status);
+    }
+    if (options?.limit) {
+      results = results.slice(-options.limit);
+    }
+    return results;
+  }
+  /**
+   * Clear delivery log
+   */
+  clearLog() {
+    this.deliveryLog = [];
+  }
+  /**
+   * Get all registered webhooks
+   */
+  getWebhooks() {
+    return [...this.webhooks];
+  }
+};
 
 // src/core/plugin.ts
 var PluginManager = class {
@@ -529,9 +744,12 @@ var HRM_CONFIG = {
   },
   validation: {
     requireBankDetails: false,
-    requireEmployeeId: true,
-    uniqueEmployeeIdPerOrg: true,
-    allowMultiTenantEmployees: true
+    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 = {
@@ -574,13 +792,17 @@ function mergeConfig(customConfig) {
     payroll: { ...HRM_CONFIG.payroll, ...customConfig.payroll },
     salary: { ...HRM_CONFIG.salary, ...customConfig.salary },
     employment: { ...HRM_CONFIG.employment, ...customConfig.employment },
-    validation: { ...HRM_CONFIG.validation, ...customConfig.validation }
+    validation: {
+      ...HRM_CONFIG.validation,
+      ...customConfig.validation,
+      // Ensure fallbacks is always EmployeeIdentityMode[]
+      identityFallbacks: customConfig.validation?.identityFallbacks ?? HRM_CONFIG.validation.identityFallbacks
+    }
   };
 }
 
 // src/core/container.ts
-var Container = class _Container {
-  static instance = null;
+var Container = class {
   _models = null;
   _config = HRM_CONFIG;
   _singleTenant = null;
@@ -589,21 +811,6 @@ var Container = class _Container {
   constructor() {
     this._logger = getLogger();
   }
-  /**
-   * Get singleton instance
-   */
-  static getInstance() {
-    if (!_Container.instance) {
-      _Container.instance = new _Container();
-    }
-    return _Container.instance;
-  }
-  /**
-   * Reset instance (for testing)
-   */
-  static resetInstance() {
-    _Container.instance = null;
-  }
   /**
    * Initialize container with configuration
    */
@@ -623,6 +830,8 @@ var Container = class _Container {
       hasPayrollRecordModel: !!this._models.PayrollRecordModel,
       hasTransactionModel: !!this._models.TransactionModel,
       hasAttendanceModel: !!this._models.AttendanceModel,
+      hasLeaveRequestModel: !!this._models.LeaveRequestModel,
+      hasTaxWithholdingModel: !!this._models.TaxWithholdingModel,
       isSingleTenant: !!this._singleTenant
     });
   }
@@ -632,6 +841,16 @@ var Container = class _Container {
   isInitialized() {
     return this._initialized;
   }
+  /**
+   * Reset container (useful for testing)
+   */
+  reset() {
+    this._models = null;
+    this._config = HRM_CONFIG;
+    this._singleTenant = null;
+    this._initialized = false;
+    this._logger.info("Container reset");
+  }
   /**
    * Ensure container is initialized
    */
@@ -643,40 +862,54 @@ var Container = class _Container {
     }
   }
   /**
-   * Get models container
+   * Get models container (strongly typed)
    */
   getModels() {
     this.ensureInitialized();
     return this._models;
   }
   /**
-   * Get Employee model
+   * Get Employee model (strongly typed)
    */
   getEmployeeModel() {
     this.ensureInitialized();
     return this._models.EmployeeModel;
   }
   /**
-   * Get PayrollRecord model
+   * Get PayrollRecord model (strongly typed)
    */
   getPayrollRecordModel() {
     this.ensureInitialized();
     return this._models.PayrollRecordModel;
   }
   /**
-   * Get Transaction model
+   * Get Transaction model (strongly typed)
    */
   getTransactionModel() {
     this.ensureInitialized();
     return this._models.TransactionModel;
   }
   /**
-   * Get Attendance model (optional)
+   * Get Attendance model (optional, strongly typed)
    */
   getAttendanceModel() {
     this.ensureInitialized();
     return this._models.AttendanceModel ?? null;
   }
+  /**
+   * Get LeaveRequest model (optional, strongly typed)
+   */
+  getLeaveRequestModel() {
+    this.ensureInitialized();
+    return this._models.LeaveRequestModel ?? null;
+  }
+  /**
+   * Get TaxWithholding model (optional, strongly typed)
+   */
+  getTaxWithholdingModel() {
+    this.ensureInitialized();
+    return this._models.TaxWithholdingModel ?? null;
+  }
   /**
    * Get configuration
    */
@@ -737,82 +970,46 @@ var Container = class _Container {
     return { ...context, ...overrides };
   }
 };
+var defaultContainer = null;
 function getContainer() {
-  return Container.getInstance();
+  if (!defaultContainer) {
+    defaultContainer = new Container();
+  }
+  return defaultContainer;
 }
 function initializeContainer(config) {
-  Container.getInstance().initialize(config);
+  getContainer().initialize(config);
 }
 function isContainerInitialized() {
-  return Container.getInstance().isInitialized();
+  return defaultContainer?.isInitialized() ?? false;
 }
 function getModels() {
-  return Container.getInstance().getModels();
+  return getContainer().getModels();
 }
 function getConfig() {
-  return Container.getInstance().getConfig();
+  return getContainer().getConfig();
 }
 function isSingleTenant() {
-  return Container.getInstance().isSingleTenant();
+  return getContainer().isSingleTenant();
 }
 
 // src/core/config.ts
-var COUNTRY_DEFAULTS = {
-  US: {
-    currency: "USD",
-    workDays: [1, 2, 3, 4, 5],
-    // Mon-Fri
-    taxBrackets: [
-      { min: 0, max: 11e3, rate: 0.1 },
-      { min: 11e3, max: 44725, rate: 0.12 },
-      { min: 44725, max: 95375, rate: 0.22 },
-      { min: 95375, max: 182100, rate: 0.24 },
-      { min: 182100, max: Infinity, rate: 0.32 }
-    ]
-  },
-  BD: {
-    currency: "BDT",
-    workDays: [0, 1, 2, 3, 4],
-    // Sun-Thu
-    taxBrackets: [
-      { min: 0, max: 35e4, rate: 0 },
-      { min: 35e4, max: 45e4, rate: 0.05 },
-      { min: 45e4, max: 75e4, rate: 0.1 },
-      { min: 75e4, max: 115e4, rate: 0.15 },
-      { min: 115e4, max: Infinity, rate: 0.2 }
-    ]
-  },
-  UK: {
-    currency: "GBP",
-    workDays: [1, 2, 3, 4, 5],
-    taxBrackets: [
-      { min: 0, max: 12570, rate: 0 },
-      { min: 12570, max: 50270, rate: 0.2 },
-      { min: 50270, max: 125140, rate: 0.4 },
-      { min: 125140, max: Infinity, rate: 0.45 }
-    ]
-  },
-  IN: {
-    currency: "INR",
-    workDays: [1, 2, 3, 4, 5, 6],
-    // Mon-Sat
-    taxBrackets: [
-      { min: 0, max: 3e5, rate: 0 },
-      { min: 3e5, max: 6e5, rate: 0.05 },
-      { min: 6e5, max: 9e5, rate: 0.1 },
-      { min: 9e5, max: 12e5, rate: 0.15 },
-      { min: 12e5, max: Infinity, rate: 0.2 }
-    ]
-  }
-};
+var DEFAULT_TAX_BRACKETS = [
+  { min: 0, max: 1e4, rate: 0.1 },
+  { min: 1e4, max: 4e4, rate: 0.12 },
+  { min: 4e4, max: 85e3, rate: 0.22 },
+  { min: 85e3, max: 165e3, rate: 0.24 },
+  { min: 165e3, max: 215e3, rate: 0.32 },
+  { min: 215e3, max: 54e4, rate: 0.35 },
+  { min: 54e4, max: Infinity, rate: 0.37 }
+];
 var DEFAULT_WORK_SCHEDULE = {
-  workDays: [1, 2, 3, 4, 5],
+  workingDays: [1, 2, 3, 4, 5],
   // Monday to Friday
   hoursPerDay: 8
 };
-var DEFAULT_TAX_BRACKETS = COUNTRY_DEFAULTS.US.taxBrackets;
 function countWorkingDays(startDate, endDate, options = {}) {
-  const workDays = options.workDays || DEFAULT_WORK_SCHEDULE.workDays;
+  const workDays = options.workingDays || DEFAULT_WORK_SCHEDULE.workingDays;
   const holidaySet = new Set(
     (options.holidays || []).map((d) => new Date(d).toDateString())
   );
@@ -868,8 +1065,7 @@ function calculateProration(hireDate, terminationDate, periodStart, periodEnd) {
   }
   return { ratio, reason, isProrated: ratio < 1 };
 }
-function calculateTax(monthlyIncome, currency, customBrackets) {
-  const brackets = customBrackets || COUNTRY_DEFAULTS[currency]?.taxBrackets || DEFAULT_TAX_BRACKETS;
+function calculateSimpleTax(monthlyIncome, brackets = DEFAULT_TAX_BRACKETS) {
   const annualIncome = monthlyIncome * 12;
   let annualTax = 0;
   for (const bracket of brackets) {
@@ -890,7 +1086,6 @@ function calculateAttendanceDeduction(expectedDays, actualDays, dailyRate, maxDe
 function calculateSalaryBreakdown(params) {
   const {
     baseSalary,
-    currency,
     hireDate,
     terminationDate,
     periodStart,
@@ -902,7 +1097,7 @@ function calculateSalaryBreakdown(params) {
   } = params;
   const workSchedule = { ...DEFAULT_WORK_SCHEDULE, ...options.workSchedule };
   const workingDays = countWorkingDays(periodStart, periodEnd, {
-    workDays: workSchedule.workDays,
+    workingDays: workSchedule.workingDays,
     holidays: options.holidays
   });
   const proration = options.skipProration ? { ratio: 1, reason: "full", isProrated: false } : calculateProration(hireDate, terminationDate, periodStart, periodEnd);
@@ -934,14 +1129,14 @@ function calculateSalaryBreakdown(params) {
   if (!options.skipTax) {
     const taxableAllowances = processedAllowances.filter((a) => a.taxable).reduce((sum, a) => sum + a.amount, 0);
     const taxableIncome = proratedBase + taxableAllowances;
-    const taxResult = calculateTax(taxableIncome, currency);
+    const taxResult = calculateSimpleTax(taxableIncome);
     taxAmount = taxResult.amount;
     if (taxAmount > 0) {
       processedDeductions.push({ type: "tax", amount: taxAmount });
     }
   }
-  const totalDeductions = processedDeductions.filter((d) => d.type !== "tax" && d.type !== "attendance").reduce((sum, d) => sum + d.amount, 0);
-  const netSalary = grossSalary - totalDeductions - attendanceDeduction - taxAmount;
+  const totalDeductions = processedDeductions.filter((d) => d.type !== "tax").reduce((sum, d) => sum + d.amount, 0);
+  const netSalary = grossSalary - totalDeductions - taxAmount;
   return {
     baseSalary,
     proratedBase,
@@ -966,6 +1161,6 @@ function getPayPeriod(month, year, payDay = 28) {
   return { startDate, endDate, payDate };
 }
 
-export { COUNTRY_DEFAULTS, Container, DEFAULT_TAX_BRACKETS, DEFAULT_WORK_SCHEDULE, EventBus, PluginManager, Result, ResultClass, all, calculateAttendanceDeduction, calculateProration, calculateSalaryBreakdown, calculateTax, countWorkingDays, createEventBus, createNotificationPlugin, definePlugin, err, flatMap, fromNullable, fromPromise, getConfig, getContainer, getEventBus, getModels, getPayPeriod, initializeContainer, isContainerInitialized, isErr, isOk, isSingleTenant, loggingPlugin, map, mapErr, match, metricsPlugin, notificationPlugin, ok, onEmployeeHired, onMilestoneAchieved, onPayrollCompleted, onSalaryProcessed, resetEventBus, tryCatch, tryCatchSync, unwrap, unwrapOr, unwrapOrElse };
+export { Container, DEFAULT_TAX_BRACKETS, DEFAULT_WORK_SCHEDULE, EventBus, IdempotencyManager, PluginManager, Result, ResultClass, WebhookManager, all, calculateAttendanceDeduction, calculateProration, calculateSalaryBreakdown, countWorkingDays, createEventBus, createNotificationPlugin, definePlugin, err, flatMap, fromNullable, fromPromise, generatePayrollIdempotencyKey, getConfig, getContainer, getEventBus, getModels, getPayPeriod, initializeContainer, isContainerInitialized, isErr, isOk, isSingleTenant, loggingPlugin, map, mapErr, match, metricsPlugin, notificationPlugin, ok, onEmployeeHired, onMilestoneAchieved, onPayrollCompleted, onSalaryProcessed, resetEventBus, tryCatch, tryCatchSync, unwrap, unwrapOr, unwrapOrElse };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map