@classytic/revenue 1.1.2 → 1.1.3

package/dist/utils/index.js

@@ -1,1202 +0,0 @@
-import { nanoid } from 'nanoid';
-
-// @classytic/revenue - Enterprise Revenue Management System
-
-// src/core/errors.ts
-var RevenueError = class extends Error {
-  code;
-  retryable;
-  metadata;
-  constructor(message, code, options = {}) {
-    super(message);
-    this.name = this.constructor.name;
-    this.code = code;
-    this.retryable = options.retryable ?? false;
-    this.metadata = options.metadata ?? {};
-    Error.captureStackTrace(this, this.constructor);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      retryable: this.retryable,
-      metadata: this.metadata
-    };
-  }
-};
-var ValidationError = class extends RevenueError {
-  constructor(message, metadata = {}) {
-    super(message, "VALIDATION_ERROR", { retryable: false, metadata });
-  }
-};
-
-// src/shared/utils/calculators/commission.ts
-function calculateCommission(amount, commissionRate, gatewayFeeRate = 0) {
-  if (!commissionRate || commissionRate <= 0) {
-    return null;
-  }
-  if (amount < 0) {
-    throw new Error("Transaction amount cannot be negative");
-  }
-  if (commissionRate < 0 || commissionRate > 1) {
-    throw new Error("Commission rate must be between 0 and 1");
-  }
-  if (gatewayFeeRate < 0 || gatewayFeeRate > 1) {
-    throw new Error("Gateway fee rate must be between 0 and 1");
-  }
-  const grossAmount = Math.round(amount * commissionRate);
-  const gatewayFeeAmount = Math.round(amount * gatewayFeeRate);
-  const netAmount = Math.max(0, grossAmount - gatewayFeeAmount);
-  return {
-    rate: commissionRate,
-    grossAmount,
-    gatewayFeeRate,
-    gatewayFeeAmount,
-    netAmount,
-    status: "pending"
-  };
-}
-function reverseCommission(originalCommission, originalAmount, refundAmount) {
-  if (!originalCommission?.netAmount) {
-    return null;
-  }
-  if (!originalAmount || originalAmount <= 0) {
-    throw new ValidationError("Original amount must be greater than 0", { originalAmount });
-  }
-  if (refundAmount < 0) {
-    throw new ValidationError("Refund amount cannot be negative", { refundAmount });
-  }
-  if (refundAmount > originalAmount) {
-    throw new ValidationError(
-      `Refund amount (${refundAmount}) exceeds original amount (${originalAmount})`,
-      { refundAmount, originalAmount }
-    );
-  }
-  const refundRatio = refundAmount / originalAmount;
-  const reversedNetAmount = Math.round(originalCommission.netAmount * refundRatio);
-  const reversedGrossAmount = Math.round(originalCommission.grossAmount * refundRatio);
-  const reversedGatewayFee = Math.round(originalCommission.gatewayFeeAmount * refundRatio);
-  return {
-    rate: originalCommission.rate,
-    grossAmount: reversedGrossAmount,
-    gatewayFeeRate: originalCommission.gatewayFeeRate,
-    gatewayFeeAmount: reversedGatewayFee,
-    netAmount: reversedNetAmount,
-    status: "waived"
-    // Commission waived due to refund
-  };
-}
-
-// src/shared/utils/calculators/tax.ts
-function calculateTax(amount, category, config) {
-  if (!config?.isRegistered || config.exemptCategories?.includes(category)) {
-    return {
-      isApplicable: false,
-      rate: 0,
-      baseAmount: amount,
-      taxAmount: 0,
-      totalAmount: amount,
-      pricesIncludeTax: false
-    };
-  }
-  const rate = config.defaultRate;
-  const [baseAmount, taxAmount, totalAmount] = config.pricesIncludeTax ? [
-    // Tax-inclusive: extract tax from total
-    Math.round(amount / (1 + rate)),
-    // baseAmount
-    Math.round(amount - amount / (1 + rate)),
-    // taxAmount
-    amount
-    // totalAmount (already integer)
-  ] : [
-    // Tax-exclusive: add tax to base
-    amount,
-    // baseAmount (already integer)
-    Math.round(amount * rate),
-    // taxAmount
-    Math.round(amount * (1 + rate))
-    // totalAmount
-  ];
-  return {
-    isApplicable: true,
-    rate,
-    baseAmount,
-    taxAmount,
-    totalAmount,
-    pricesIncludeTax: config.pricesIncludeTax
-  };
-}
-function getTaxType(transactionFlow, category, exemptCategories = []) {
-  if (exemptCategories.includes(category)) {
-    return "exempt";
-  }
-  return transactionFlow === "inflow" ? "collected" : "paid";
-}
-function reverseTax(originalTax, originalAmount, refundAmount) {
-  if (!originalTax.isApplicable) {
-    return {
-      isApplicable: false,
-      rate: 0,
-      baseAmount: refundAmount,
-      taxAmount: 0,
-      totalAmount: refundAmount,
-      pricesIncludeTax: false
-    };
-  }
-  if (!originalAmount || originalAmount <= 0) {
-    throw new ValidationError("Original amount must be greater than 0", { originalAmount });
-  }
-  if (refundAmount < 0) {
-    throw new ValidationError("Refund amount cannot be negative", { refundAmount });
-  }
-  if (refundAmount > originalAmount) {
-    throw new ValidationError(
-      `Refund amount (${refundAmount}) exceeds original amount (${originalAmount})`,
-      { refundAmount, originalAmount }
-    );
-  }
-  const refundRatio = refundAmount / originalAmount;
-  const reversedType = originalTax.type ? originalTax.type === "collected" ? "paid" : originalTax.type === "paid" ? "collected" : "exempt" : void 0;
-  return {
-    isApplicable: true,
-    rate: originalTax.rate,
-    baseAmount: Math.round(originalTax.baseAmount * refundRatio),
-    taxAmount: Math.round(originalTax.taxAmount * refundRatio),
-    totalAmount: Math.round(originalTax.totalAmount * refundRatio),
-    pricesIncludeTax: originalTax.pricesIncludeTax,
-    type: reversedType
-  };
-}
-
-// src/enums/split.enums.ts
-var SPLIT_TYPE = {
-  PLATFORM_COMMISSION: "platform_commission",
-  AFFILIATE_COMMISSION: "affiliate_commission",
-  REFERRAL_COMMISSION: "referral_commission",
-  PARTNER_COMMISSION: "partner_commission",
-  CUSTOM: "custom"
-};
-var SPLIT_TYPE_VALUES = Object.values(SPLIT_TYPE);
-var SPLIT_STATUS = {
-  PENDING: "pending",
-  DUE: "due",
-  PAID: "paid",
-  WAIVED: "waived",
-  CANCELLED: "cancelled"
-};
-var SPLIT_STATUS_VALUES = Object.values(
-  SPLIT_STATUS
-);
-var PAYOUT_METHOD = {
-  BANK_TRANSFER: "bank_transfer",
-  MOBILE_WALLET: "mobile_wallet",
-  PLATFORM_BALANCE: "platform_balance",
-  CRYPTO: "crypto",
-  CHECK: "check",
-  MANUAL: "manual"
-};
-var PAYOUT_METHOD_VALUES = Object.values(PAYOUT_METHOD);
-new Set(SPLIT_TYPE_VALUES);
-new Set(SPLIT_STATUS_VALUES);
-new Set(PAYOUT_METHOD_VALUES);
-
-// src/shared/utils/calculators/commission-split.ts
-function calculateSplits(amount, splitRules = [], gatewayFeeRate = 0) {
-  if (!splitRules || splitRules.length === 0) {
-    return [];
-  }
-  if (amount < 0) {
-    throw new Error("Transaction amount cannot be negative");
-  }
-  if (gatewayFeeRate < 0 || gatewayFeeRate > 1) {
-    throw new Error("Gateway fee rate must be between 0 and 1");
-  }
-  const totalRate = splitRules.reduce((sum, rule) => sum + rule.rate, 0);
-  if (totalRate > 1) {
-    throw new Error(`Total split rate (${totalRate}) cannot exceed 1.0`);
-  }
-  return splitRules.map((rule, index) => {
-    if (rule.rate < 0 || rule.rate > 1) {
-      throw new Error(`Split rate must be between 0 and 1 for split ${index}`);
-    }
-    const grossAmount = Math.round(amount * rule.rate);
-    const gatewayFeeAmount = index === 0 && gatewayFeeRate > 0 ? Math.round(amount * gatewayFeeRate) : 0;
-    const netAmount = Math.max(0, grossAmount - gatewayFeeAmount);
-    return {
-      type: rule.type ?? SPLIT_TYPE.CUSTOM,
-      recipientId: rule.recipientId,
-      recipientType: rule.recipientType,
-      rate: rule.rate,
-      grossAmount,
-      gatewayFeeRate: gatewayFeeAmount > 0 ? gatewayFeeRate : 0,
-      gatewayFeeAmount,
-      netAmount,
-      status: SPLIT_STATUS.PENDING,
-      dueDate: rule.dueDate ?? null,
-      metadata: rule.metadata ?? {}
-    };
-  });
-}
-function calculateOrganizationPayout(amount, splits = []) {
-  const totalSplitAmount = splits.reduce((sum, split) => sum + split.grossAmount, 0);
-  return Math.max(0, amount - totalSplitAmount);
-}
-function reverseSplits(originalSplits, originalAmount, refundAmount) {
-  if (!originalSplits || originalSplits.length === 0) {
-    return [];
-  }
-  if (!originalAmount || originalAmount <= 0) {
-    throw new ValidationError("Original amount must be greater than 0", { originalAmount });
-  }
-  if (refundAmount < 0) {
-    throw new ValidationError("Refund amount cannot be negative", { refundAmount });
-  }
-  if (refundAmount > originalAmount) {
-    throw new ValidationError(
-      `Refund amount (${refundAmount}) exceeds original amount (${originalAmount})`,
-      { refundAmount, originalAmount }
-    );
-  }
-  const refundRatio = refundAmount / originalAmount;
-  return originalSplits.map((split) => ({
-    ...split,
-    grossAmount: Math.round(split.grossAmount * refundRatio),
-    gatewayFeeAmount: Math.round(split.gatewayFeeAmount * refundRatio),
-    netAmount: Math.round(split.netAmount * refundRatio),
-    status: SPLIT_STATUS.WAIVED
-  }));
-}
-
-// src/shared/utils/formatters/money.ts
-var CURRENCIES = {
-  USD: { code: "USD", decimals: 2, symbol: "$", name: "US Dollar" },
-  EUR: { code: "EUR", decimals: 2, symbol: "\u20AC", name: "Euro" },
-  GBP: { code: "GBP", decimals: 2, symbol: "\xA3", name: "British Pound" },
-  BDT: { code: "BDT", decimals: 2, symbol: "\u09F3", name: "Bangladeshi Taka" },
-  INR: { code: "INR", decimals: 2, symbol: "\u20B9", name: "Indian Rupee" },
-  JPY: { code: "JPY", decimals: 0, symbol: "\xA5", name: "Japanese Yen" },
-  CNY: { code: "CNY", decimals: 2, symbol: "\xA5", name: "Chinese Yuan" },
-  AED: { code: "AED", decimals: 2, symbol: "\u062F.\u0625", name: "UAE Dirham" },
-  SAR: { code: "SAR", decimals: 2, symbol: "\uFDFC", name: "Saudi Riyal" },
-  SGD: { code: "SGD", decimals: 2, symbol: "S$", name: "Singapore Dollar" },
-  AUD: { code: "AUD", decimals: 2, symbol: "A$", name: "Australian Dollar" },
-  CAD: { code: "CAD", decimals: 2, symbol: "C$", name: "Canadian Dollar" }
-};
-var Money = class _Money {
-  amount;
-  currency;
-  constructor(amount, currency) {
-    if (!Number.isInteger(amount)) {
-      throw new Error(`Money amount must be integer (smallest unit). Got: ${amount}`);
-    }
-    this.amount = amount;
-    this.currency = currency.toUpperCase();
-  }
-  // ============ FACTORY METHODS ============
-  /**
-   * Create money from smallest unit (cents, paisa)
-   * @example Money.cents(1999, 'USD') // $19.99
-   */
-  static cents(amount, currency = "USD") {
-    return new _Money(Math.round(amount), currency);
-  }
-  /**
-   * Create money from major unit (dollars, taka)
-   * @example Money.of(19.99, 'USD') // $19.99 (stored as 1999 cents)
-   */
-  static of(amount, currency = "USD") {
-    const config = CURRENCIES[currency.toUpperCase()] ?? { decimals: 2 };
-    const multiplier = Math.pow(10, config.decimals);
-    return new _Money(Math.round(amount * multiplier), currency);
-  }
-  /**
-   * Create zero money
-   */
-  static zero(currency = "USD") {
-    return new _Money(0, currency);
-  }
-  // ============ SHORTHAND FACTORIES ============
-  static usd(cents) {
-    return _Money.cents(cents, "USD");
-  }
-  static eur(cents) {
-    return _Money.cents(cents, "EUR");
-  }
-  static gbp(pence) {
-    return _Money.cents(pence, "GBP");
-  }
-  static bdt(paisa) {
-    return _Money.cents(paisa, "BDT");
-  }
-  static inr(paisa) {
-    return _Money.cents(paisa, "INR");
-  }
-  static jpy(yen) {
-    return _Money.cents(yen, "JPY");
-  }
-  // ============ ARITHMETIC ============
-  /**
-   * Add two money values (must be same currency)
-   */
-  add(other) {
-    this.assertSameCurrency(other);
-    return new _Money(this.amount + other.amount, this.currency);
-  }
-  /**
-   * Subtract money (must be same currency)
-   */
-  subtract(other) {
-    this.assertSameCurrency(other);
-    return new _Money(this.amount - other.amount, this.currency);
-  }
-  /**
-   * Multiply by a factor (rounds to nearest integer)
-   */
-  multiply(factor) {
-    return new _Money(Math.round(this.amount * factor), this.currency);
-  }
-  /**
-   * Divide by a divisor (rounds to nearest integer)
-   */
-  divide(divisor) {
-    if (divisor === 0) throw new Error("Cannot divide by zero");
-    return new _Money(Math.round(this.amount / divisor), this.currency);
-  }
-  /**
-   * Calculate percentage
-   * @example money.percentage(10) // 10% of money
-   */
-  percentage(percent) {
-    return this.multiply(percent / 100);
-  }
-  /**
-   * Allocate money among recipients (handles rounding)
-   * @example Money.usd(100).allocate([1, 1, 1]) // [34, 33, 33] cents
-   */
-  allocate(ratios) {
-    const total = ratios.reduce((a, b) => a + b, 0);
-    if (total === 0) throw new Error("Ratios must sum to more than 0");
-    let remainder = this.amount;
-    const results = [];
-    for (let i = 0; i < ratios.length; i++) {
-      const share = Math.floor(this.amount * ratios[i] / total);
-      results.push(new _Money(share, this.currency));
-      remainder -= share;
-    }
-    for (let i = 0; i < remainder; i++) {
-      results[i] = new _Money(results[i].amount + 1, this.currency);
-    }
-    return results;
-  }
-  /**
-   * Split equally among n recipients
-   */
-  split(parts) {
-    return this.allocate(Array(parts).fill(1));
-  }
-  // ============ COMPARISON ============
-  isZero() {
-    return this.amount === 0;
-  }
-  isPositive() {
-    return this.amount > 0;
-  }
-  isNegative() {
-    return this.amount < 0;
-  }
-  equals(other) {
-    return this.amount === other.amount && this.currency === other.currency;
-  }
-  greaterThan(other) {
-    this.assertSameCurrency(other);
-    return this.amount > other.amount;
-  }
-  lessThan(other) {
-    this.assertSameCurrency(other);
-    return this.amount < other.amount;
-  }
-  greaterThanOrEqual(other) {
-    return this.greaterThan(other) || this.equals(other);
-  }
-  lessThanOrEqual(other) {
-    return this.lessThan(other) || this.equals(other);
-  }
-  // ============ FORMATTING ============
-  /**
-   * Get amount in major unit (dollars, taka)
-   */
-  toUnit() {
-    const config = CURRENCIES[this.currency] ?? { decimals: 2 };
-    return this.amount / Math.pow(10, config.decimals);
-  }
-  /**
-   * Format for display
-   * @example Money.usd(1999).format() // "$19.99"
-   */
-  format(locale = "en-US") {
-    return new Intl.NumberFormat(locale, {
-      style: "currency",
-      currency: this.currency
-    }).format(this.toUnit());
-  }
-  /**
-   * Format without currency symbol
-   */
-  formatAmount(locale = "en-US") {
-    const config = CURRENCIES[this.currency] ?? { decimals: 2 };
-    return new Intl.NumberFormat(locale, {
-      minimumFractionDigits: config.decimals,
-      maximumFractionDigits: config.decimals
-    }).format(this.toUnit());
-  }
-  /**
-   * Convert to JSON-serializable object
-   */
-  toJSON() {
-    return { amount: this.amount, currency: this.currency };
-  }
-  /**
-   * Create from JSON
-   */
-  static fromJSON(json) {
-    return new _Money(json.amount, json.currency);
-  }
-  toString() {
-    return `${this.currency} ${this.amount}`;
-  }
-  // ============ HELPERS ============
-  assertSameCurrency(other) {
-    if (this.currency !== other.currency) {
-      throw new Error(
-        `Currency mismatch: ${this.currency} vs ${other.currency}. Convert first.`
-      );
-    }
-  }
-};
-function toSmallestUnit(amount, currency = "USD") {
-  return Money.of(amount, currency).amount;
-}
-function fromSmallestUnit(amount, currency = "USD") {
-  return Money.cents(amount, currency).toUnit();
-}
-
-// src/core/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-
-// src/shared/utils/resilience/retry.ts
-var DEFAULT_CONFIG = {
-  maxAttempts: 3,
-  baseDelay: 1e3,
-  maxDelay: 3e4,
-  backoffMultiplier: 2,
-  jitter: 0.1,
-  retryIf: isRetryableError
-};
-function calculateDelay(attempt, config) {
-  const exponentialDelay = config.baseDelay * Math.pow(config.backoffMultiplier, attempt);
-  const cappedDelay = Math.min(exponentialDelay, config.maxDelay);
-  const jitterRange = cappedDelay * config.jitter;
-  const jitter = Math.random() * jitterRange * 2 - jitterRange;
-  return Math.round(Math.max(0, cappedDelay + jitter));
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isRetryableError(error) {
-  if (!(error instanceof Error)) return false;
-  if (error.message.includes("ECONNREFUSED")) return true;
-  if (error.message.includes("ETIMEDOUT")) return true;
-  if (error.message.includes("ENOTFOUND")) return true;
-  if (error.message.includes("network")) return true;
-  if (error.message.includes("timeout")) return true;
-  if (error.message.includes("429")) return true;
-  if (error.message.includes("rate limit")) return true;
-  if (error.message.includes("500")) return true;
-  if (error.message.includes("502")) return true;
-  if (error.message.includes("503")) return true;
-  if (error.message.includes("504")) return true;
-  if ("retryable" in error && error.retryable === true) return true;
-  return false;
-}
-async function retry(operation, config = {}) {
-  const fullConfig = { ...DEFAULT_CONFIG, ...config };
-  const state = {
-    attempt: 0,
-    totalDelay: 0,
-    errors: []
-  };
-  while (state.attempt < fullConfig.maxAttempts) {
-    try {
-      return await operation();
-    } catch (error) {
-      state.errors.push(error instanceof Error ? error : new Error(String(error)));
-      state.attempt++;
-      const shouldRetry = fullConfig.retryIf?.(error) ?? isRetryableError(error);
-      if (!shouldRetry || state.attempt >= fullConfig.maxAttempts) {
-        throw new RetryExhaustedError(
-          `Operation failed after ${state.attempt} attempts`,
-          state.errors
-        );
-      }
-      const delay = calculateDelay(state.attempt - 1, fullConfig);
-      state.totalDelay += delay;
-      fullConfig.onRetry?.(error, state.attempt, delay);
-      await sleep(delay);
-    }
-  }
-  throw new RetryExhaustedError(
-    `Operation failed after ${state.attempt} attempts`,
-    state.errors
-  );
-}
-var RetryExhaustedError = class extends Error {
-  attempts;
-  errors;
-  constructor(message, errors) {
-    super(message);
-    this.name = "RetryExhaustedError";
-    this.attempts = errors.length;
-    this.errors = errors;
-  }
-  /**
-   * Get the last error
-   */
-  get lastError() {
-    return this.errors[this.errors.length - 1];
-  }
-  /**
-   * Get the first error
-   */
-  get firstError() {
-    return this.errors[0];
-  }
-};
-var DEFAULT_CIRCUIT_CONFIG = {
-  failureThreshold: 5,
-  resetTimeout: 3e4,
-  successThreshold: 3,
-  monitorWindow: 6e4
-};
-var CircuitBreaker = class {
-  state = "closed";
-  failures = [];
-  successes = 0;
-  lastFailure;
-  config;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CIRCUIT_CONFIG, ...config };
-  }
-  /**
-   * Execute operation through circuit breaker
-   */
-  async execute(operation) {
-    if (this.state === "open") {
-      if (this.shouldAttemptReset()) {
-        this.state = "half-open";
-      } else {
-        throw new CircuitOpenError("Circuit is open, request rejected");
-      }
-    }
-    try {
-      const result = await operation();
-      this.onSuccess();
-      return result;
-    } catch (error) {
-      this.onFailure();
-      throw error;
-    }
-  }
-  /**
-   * Execute with Result type
-   */
-  async executeWithResult(operation) {
-    try {
-      const result = await this.execute(operation);
-      return ok(result);
-    } catch (error) {
-      return err(error);
-    }
-  }
-  onSuccess() {
-    if (this.state === "half-open") {
-      this.successes++;
-      if (this.successes >= this.config.successThreshold) {
-        this.reset();
-      }
-    }
-    this.cleanOldFailures();
-  }
-  onFailure() {
-    this.failures.push(/* @__PURE__ */ new Date());
-    this.lastFailure = /* @__PURE__ */ new Date();
-    this.successes = 0;
-    this.cleanOldFailures();
-    if (this.failures.length >= this.config.failureThreshold) {
-      this.state = "open";
-    }
-  }
-  shouldAttemptReset() {
-    if (!this.lastFailure) return true;
-    return Date.now() - this.lastFailure.getTime() >= this.config.resetTimeout;
-  }
-  cleanOldFailures() {
-    const cutoff = Date.now() - this.config.monitorWindow;
-    this.failures = this.failures.filter((f) => f.getTime() > cutoff);
-  }
-  reset() {
-    this.state = "closed";
-    this.failures = [];
-    this.successes = 0;
-  }
-  /**
-   * Get current circuit state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Manually reset circuit
-   */
-  forceReset() {
-    this.reset();
-  }
-  /**
-   * Get circuit statistics
-   */
-  getStats() {
-    return {
-      state: this.state,
-      failures: this.failures.length,
-      successes: this.successes,
-      lastFailure: this.lastFailure
-    };
-  }
-};
-var CircuitOpenError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "CircuitOpenError";
-  }
-};
-function createCircuitBreaker(config) {
-  return new CircuitBreaker(config);
-}
-var MemoryIdempotencyStore = class {
-  records = /* @__PURE__ */ new Map();
-  cleanupInterval = null;
-  constructor(cleanupIntervalMs = 6e4) {
-    this.cleanupInterval = setInterval(() => {
-      this.cleanup();
-    }, cleanupIntervalMs);
-  }
-  async get(key) {
-    const record = this.records.get(key);
-    if (!record) return null;
-    if (record.expiresAt < /* @__PURE__ */ new Date()) {
-      this.records.delete(key);
-      return null;
-    }
-    return record;
-  }
-  async set(key, record) {
-    this.records.set(key, record);
-  }
-  async delete(key) {
-    this.records.delete(key);
-  }
-  async exists(key) {
-    const record = await this.get(key);
-    return record !== null;
-  }
-  cleanup() {
-    const now = /* @__PURE__ */ new Date();
-    for (const [key, record] of this.records) {
-      if (record.expiresAt < now) {
-        this.records.delete(key);
-      }
-    }
-  }
-  destroy() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    this.records.clear();
-  }
-};
-var IdempotencyError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "IdempotencyError";
-  }
-};
-var IdempotencyManager = class {
-  store;
-  ttl;
-  prefix;
-  constructor(config = {}) {
-    this.store = config.store ?? new MemoryIdempotencyStore();
-    this.ttl = config.ttl ?? 24 * 60 * 60 * 1e3;
-    this.prefix = config.prefix ?? "idem:";
-  }
-  /**
-   * Generate a unique idempotency key
-   */
-  generateKey() {
-    return `${this.prefix}${nanoid(21)}`;
-  }
-  /**
-   * Hash request parameters for validation
-   * Uses deterministic JSON serialization and simple hash function
-   */
-  hashRequest(params) {
-    let normalized;
-    if (params === null || params === void 0) {
-      normalized = null;
-    } else if (typeof params === "object" && !Array.isArray(params)) {
-      const sortedKeys = Object.keys(params).sort();
-      normalized = sortedKeys.reduce((acc, key) => {
-        acc[key] = params[key];
-        return acc;
-      }, {});
-    } else {
-      normalized = params;
-    }
-    const json = JSON.stringify(normalized);
-    let hash = 0;
-    for (let i = 0; i < json.length; i++) {
-      const char = json.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return Math.abs(hash).toString(36);
-  }
-  /**
-   * Execute operation with idempotency protection
-   */
-  async execute(key, params, operation) {
-    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
-    const requestHash = this.hashRequest(params);
-    const existing = await this.store.get(fullKey);
-    if (existing) {
-      if (existing.requestHash !== requestHash) {
-        return err(new IdempotencyError(
-          "Idempotency key used with different request parameters",
-          "REQUEST_MISMATCH"
-        ));
-      }
-      if (existing.status === "completed" && existing.result !== void 0) {
-        return ok(existing.result);
-      }
-      if (existing.status === "pending") {
-        return err(new IdempotencyError(
-          "Request with this idempotency key is already in progress",
-          "REQUEST_IN_PROGRESS"
-        ));
-      }
-      if (existing.status === "failed") {
-        await this.store.delete(fullKey);
-      }
-    }
-    const record = {
-      key: fullKey,
-      status: "pending",
-      createdAt: /* @__PURE__ */ new Date(),
-      requestHash,
-      expiresAt: new Date(Date.now() + this.ttl)
-    };
-    await this.store.set(fullKey, record);
-    try {
-      const result = await operation();
-      record.status = "completed";
-      record.result = result;
-      record.completedAt = /* @__PURE__ */ new Date();
-      await this.store.set(fullKey, record);
-      return ok(result);
-    } catch (error) {
-      record.status = "failed";
-      await this.store.set(fullKey, record);
-      throw error;
-    }
-  }
-  /**
-   * Check if operation with key was already completed
-   */
-  async wasCompleted(key) {
-    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
-    const record = await this.store.get(fullKey);
-    return record?.status === "completed";
-  }
-  /**
-   * Get cached result for key
-   */
-  async getCached(key) {
-    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
-    const record = await this.store.get(fullKey);
-    return record?.status === "completed" ? record.result ?? null : null;
-  }
-  /**
-   * Invalidate a key (force re-execution on next call)
-   */
-  async invalidate(key) {
-    const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
-    await this.store.delete(fullKey);
-  }
-  /**
-   * Destroy the idempotency manager and cleanup resources
-   * Call this when shutting down to prevent memory leaks
-   */
-  destroy() {
-    if (this.store instanceof MemoryIdempotencyStore) {
-      this.store.destroy();
-    }
-  }
-};
-function createIdempotencyManager(config) {
-  return new IdempotencyManager(config);
-}
-
-// src/enums/transaction.enums.ts
-var TRANSACTION_FLOW = {
-  INFLOW: "inflow",
-  OUTFLOW: "outflow"
-};
-var TRANSACTION_FLOW_VALUES = Object.values(
-  TRANSACTION_FLOW
-);
-var TRANSACTION_STATUS = {
-  PENDING: "pending",
-  PAYMENT_INITIATED: "payment_initiated",
-  PROCESSING: "processing",
-  REQUIRES_ACTION: "requires_action",
-  VERIFIED: "verified",
-  COMPLETED: "completed",
-  FAILED: "failed",
-  CANCELLED: "cancelled",
-  EXPIRED: "expired",
-  REFUNDED: "refunded",
-  PARTIALLY_REFUNDED: "partially_refunded"
-};
-var TRANSACTION_STATUS_VALUES = Object.values(
-  TRANSACTION_STATUS
-);
-var LIBRARY_CATEGORIES = {
-  SUBSCRIPTION: "subscription",
-  PURCHASE: "purchase"
-};
-var LIBRARY_CATEGORY_VALUES = Object.values(
-  LIBRARY_CATEGORIES
-);
-new Set(TRANSACTION_FLOW_VALUES);
-new Set(
-  TRANSACTION_STATUS_VALUES
-);
-new Set(LIBRARY_CATEGORY_VALUES);
-
-// src/shared/utils/validators/category-resolver.ts
-function resolveCategory(entity, monetizationType, categoryMappings = {}) {
-  if (entity && categoryMappings[entity]) {
-    return categoryMappings[entity];
-  }
-  switch (monetizationType) {
-    case "subscription":
-      return LIBRARY_CATEGORIES.SUBSCRIPTION;
-    // 'subscription'
-    case "purchase":
-      return LIBRARY_CATEGORIES.PURCHASE;
-    // 'purchase'
-    default:
-      return LIBRARY_CATEGORIES.SUBSCRIPTION;
-  }
-}
-
-// src/utils/transaction-type.ts
-var TRANSACTION_MANAGEMENT_TYPE = {
-  MONETIZATION: "monetization",
-  // Library-managed (subscriptions, purchases)
-  MANUAL: "manual"
-  // Admin-managed (expenses, income, adjustments)
-};
-var DEFAULT_MONETIZATION_CATEGORIES = [
-  "subscription",
-  "purchase"
-];
-function isMonetizationCategory(category, additionalCategories = []) {
-  const allCategories = [...DEFAULT_MONETIZATION_CATEGORIES, ...additionalCategories];
-  return allCategories.includes(category);
-}
-function isMonetizationTransaction(transaction, options = {}) {
-  const {
-    targetModels = ["Subscription", "Membership"],
-    additionalCategories = []
-  } = options;
-  if (transaction.sourceModel && targetModels.includes(transaction.sourceModel)) {
-    return true;
-  }
-  if (transaction.category) {
-    return isMonetizationCategory(transaction.category, additionalCategories);
-  }
-  return false;
-}
-function isManualTransaction(transaction, options = {}) {
-  return !isMonetizationTransaction(transaction, options);
-}
-function getTransactionType(transaction, options = {}) {
-  return isMonetizationTransaction(transaction, options) ? TRANSACTION_MANAGEMENT_TYPE.MONETIZATION : TRANSACTION_MANAGEMENT_TYPE.MANUAL;
-}
-var PROTECTED_MONETIZATION_FIELDS = [
-  "status",
-  "amount",
-  "platformCommission",
-  "netAmount",
-  "verifiedAt",
-  "verifiedBy",
-  "gateway",
-  "webhook",
-  "metadata.commission",
-  "metadata.gateway",
-  "type",
-  "category",
-  "sourceModel",
-  "sourceId"
-];
-var EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION = [
-  "reference",
-  "paymentDetails",
-  "notes"
-];
-var MANUAL_TRANSACTION_CREATE_FIELDS = [
-  "organizationId",
-  "type",
-  "category",
-  "amount",
-  "method",
-  "reference",
-  "paymentDetails",
-  "notes",
-  "date",
-  // Transaction date (can be backdated)
-  "description"
-];
-var MANUAL_TRANSACTION_UPDATE_FIELDS = [
-  "amount",
-  "method",
-  "reference",
-  "paymentDetails",
-  "notes",
-  "date",
-  "description"
-];
-function getAllowedUpdateFields(transaction, options = {}) {
-  const type = getTransactionType(transaction, options);
-  if (type === TRANSACTION_MANAGEMENT_TYPE.MONETIZATION) {
-    if (transaction.status === "pending") {
-      return EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION;
-    }
-    return [];
-  }
-  if (transaction.status === "verified" || transaction.status === "completed") {
-    return ["notes"];
-  }
-  return MANUAL_TRANSACTION_UPDATE_FIELDS;
-}
-function validateFieldUpdate(transaction, fieldName, options = {}) {
-  const allowedFields = getAllowedUpdateFields(transaction, options);
-  if (allowedFields.includes(fieldName)) {
-    return { allowed: true };
-  }
-  const type = getTransactionType(transaction, options);
-  if (type === TRANSACTION_MANAGEMENT_TYPE.MONETIZATION) {
-    if (PROTECTED_MONETIZATION_FIELDS.includes(fieldName)) {
-      return {
-        allowed: false,
-        reason: `Field "${fieldName}" is protected for monetization transactions. Updates must go through payment flow.`
-      };
-    }
-  }
-  return {
-    allowed: false,
-    reason: `Field "${fieldName}" cannot be updated for ${transaction.status} transactions.`
-  };
-}
-function canSelfVerify(transaction, options = {}) {
-  const type = getTransactionType(transaction, options);
-  if (type === TRANSACTION_MANAGEMENT_TYPE.MANUAL) {
-    return transaction.status === "pending";
-  }
-  return false;
-}
-
-// src/utils/logger.ts
-var _logger = console;
-function setLogger(customLogger) {
-  _logger = customLogger;
-}
-var logger = {
-  info: (...args) => {
-    (_logger.info ?? _logger.log)?.call(_logger, ...args);
-  },
-  warn: (...args) => {
-    (_logger.warn ?? _logger.log)?.call(_logger, "WARN:", ...args);
-  },
-  error: (...args) => {
-    (_logger.error ?? _logger.log)?.call(_logger, "ERROR:", ...args);
-  },
-  debug: (...args) => {
-    (_logger.debug ?? _logger.log)?.call(_logger, "DEBUG:", ...args);
-  }
-};
-var logger_default = logger;
-
-// src/utils/subscription/period.ts
-function addDuration(startDate, duration, unit = "days") {
-  const date = new Date(startDate);
-  switch (unit) {
-    case "months":
-    case "month":
-      date.setMonth(date.getMonth() + duration);
-      return date;
-    case "years":
-    case "year":
-      date.setFullYear(date.getFullYear() + duration);
-      return date;
-    case "weeks":
-    case "week":
-      date.setDate(date.getDate() + duration * 7);
-      return date;
-    case "days":
-    case "day":
-    default:
-      date.setDate(date.getDate() + duration);
-      return date;
-  }
-}
-function calculatePeriodRange(params) {
-  const {
-    currentEndDate = null,
-    startDate = null,
-    duration,
-    unit = "days",
-    now = /* @__PURE__ */ new Date()
-  } = params;
-  let periodStart;
-  if (startDate) {
-    periodStart = new Date(startDate);
-  } else if (currentEndDate) {
-    const end = new Date(currentEndDate);
-    periodStart = end > now ? end : now;
-  } else {
-    periodStart = now;
-  }
-  const periodEnd = addDuration(periodStart, duration, unit);
-  return { startDate: periodStart, endDate: periodEnd };
-}
-function calculateProratedAmount(params) {
-  const {
-    amountPaid,
-    startDate,
-    endDate,
-    asOfDate = /* @__PURE__ */ new Date(),
-    precision = 2
-  } = params;
-  if (!amountPaid || amountPaid <= 0) return 0;
-  const start = new Date(startDate);
-  const end = new Date(endDate);
-  const asOf = new Date(asOfDate);
-  const totalMs = end.getTime() - start.getTime();
-  if (totalMs <= 0) return 0;
-  const remainingMs = Math.max(0, end.getTime() - asOf.getTime());
-  if (remainingMs <= 0) return 0;
-  const ratio = remainingMs / totalMs;
-  const amount = amountPaid * ratio;
-  const factor = 10 ** precision;
-  return Math.round(amount * factor) / factor;
-}
-function resolveIntervalToDuration(interval = "month", intervalCount = 1) {
-  const normalized = (interval || "month").toLowerCase();
-  const count = Number(intervalCount) > 0 ? Number(intervalCount) : 1;
-  switch (normalized) {
-    case "year":
-    case "years":
-      return { duration: count, unit: "years" };
-    case "week":
-    case "weeks":
-      return { duration: count, unit: "weeks" };
-    case "quarter":
-    case "quarters":
-      return { duration: count * 3, unit: "months" };
-    case "day":
-    case "days":
-      return { duration: count, unit: "days" };
-    case "month":
-    case "months":
-    default:
-      return { duration: count, unit: "months" };
-  }
-}
-
-// src/enums/subscription.enums.ts
-var SUBSCRIPTION_STATUS = {
-  ACTIVE: "active",
-  PAUSED: "paused",
-  CANCELLED: "cancelled",
-  EXPIRED: "expired",
-  PENDING: "pending",
-  PENDING_RENEWAL: "pending_renewal",
-  INACTIVE: "inactive"
-};
-var SUBSCRIPTION_STATUS_VALUES = Object.values(
-  SUBSCRIPTION_STATUS
-);
-var PLAN_KEYS = {
-  MONTHLY: "monthly",
-  QUARTERLY: "quarterly",
-  YEARLY: "yearly"
-};
-var PLAN_KEY_VALUES = Object.values(PLAN_KEYS);
-new Set(
-  SUBSCRIPTION_STATUS_VALUES
-);
-new Set(PLAN_KEY_VALUES);
-
-// src/utils/subscription/actions.ts
-function isSubscriptionActive(subscription) {
-  if (!subscription) return false;
-  if (!subscription.isActive) return false;
-  if (subscription.endDate) {
-    const now = /* @__PURE__ */ new Date();
-    const endDate = new Date(subscription.endDate);
-    if (endDate < now) return false;
-  }
-  return true;
-}
-function canRenewSubscription(entity) {
-  if (!entity?.subscription) return false;
-  return isSubscriptionActive(entity.subscription);
-}
-function canCancelSubscription(entity) {
-  if (!entity?.subscription) return false;
-  if (!isSubscriptionActive(entity.subscription)) return false;
-  return !entity.subscription.canceledAt;
-}
-function canPauseSubscription(entity) {
-  if (!entity?.subscription) return false;
-  if (entity.status === SUBSCRIPTION_STATUS.PAUSED) return false;
-  if (entity.status === SUBSCRIPTION_STATUS.CANCELLED) return false;
-  return isSubscriptionActive(entity.subscription);
-}
-function canResumeSubscription(entity) {
-  if (!entity?.subscription) return false;
-  return entity.status === SUBSCRIPTION_STATUS.PAUSED;
-}
-
-export { CircuitBreaker, EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION, IdempotencyManager, MANUAL_TRANSACTION_CREATE_FIELDS, MANUAL_TRANSACTION_UPDATE_FIELDS, Money, PROTECTED_MONETIZATION_FIELDS, TRANSACTION_MANAGEMENT_TYPE, addDuration, calculateCommission, calculateOrganizationPayout, calculatePeriodRange, calculateProratedAmount, calculateSplits, calculateTax, canCancelSubscription, canPauseSubscription, canRenewSubscription, canResumeSubscription, canSelfVerify, createCircuitBreaker, createIdempotencyManager, fromSmallestUnit, getAllowedUpdateFields, getTaxType, getTransactionType, isManualTransaction, isMonetizationTransaction, isSubscriptionActive, logger, logger_default as loggerDefault, resolveCategory, resolveIntervalToDuration, retry, reverseCommission, reverseSplits, reverseTax, setLogger, toSmallestUnit, validateFieldUpdate };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map