@classytic/revenue 0.2.3 → 1.0.0

package/dist/utils/index.js

@@ -0,0 +1,1067 @@
+import { nanoid } from 'nanoid';
+
+// @classytic/revenue - Enterprise Revenue Management System
+
+// src/utils/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/utils/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
+  );
+}
+async function retryWithResult(operation, config = {}) {
+  try {
+    const result = await retry(operation, config);
+    return ok(result);
+  } catch (error) {
+    if (error instanceof RetryExhaustedError) {
+      return err(error);
+    }
+    return err(new RetryExhaustedError("Operation failed", [
+      error instanceof Error ? error : new Error(String(error))
+    ]));
+  }
+}
+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);
+}
+async function resilientExecute(operation, options = {}) {
+  const { retry: retryConfig, circuitBreaker } = options;
+  const wrappedOperation = async () => {
+    if (circuitBreaker) {
+      return circuitBreaker.execute(operation);
+    }
+    return operation();
+  };
+  if (retryConfig) {
+    return retry(wrappedOperation, retryConfig);
+  }
+  return wrappedOperation();
+}
+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
+   */
+  hashRequest(params) {
+    const json = JSON.stringify(params, Object.keys(params).sort());
+    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 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);
+  }
+};
+function createIdempotencyManager(config) {
+  return new IdempotencyManager(config);
+}
+
+// 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.referenceModel && targetModels.includes(transaction.referenceModel)) {
+    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",
+  "referenceModel",
+  "referenceId"
+];
+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/hooks.ts
+function triggerHook(hooks, event, data, logger2) {
+  const handlers = hooks[event] ?? [];
+  if (handlers.length === 0) {
+    return;
+  }
+  Promise.all(
+    handlers.map(
+      (handler) => Promise.resolve(handler(data)).catch((error) => {
+        logger2.error(`Hook "${event}" failed:`, {
+          error: error.message,
+          stack: error.stack,
+          event,
+          // Don't log full data (could be huge)
+          dataKeys: Object.keys(data)
+        });
+      })
+    )
+  ).catch(() => {
+  });
+}
+
+// src/utils/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 * 100) / 100;
+  const gatewayFeeAmount = Math.round(amount * gatewayFeeRate * 100) / 100;
+  const netAmount = Math.max(0, Math.round((grossAmount - gatewayFeeAmount) * 100) / 100);
+  return {
+    rate: commissionRate,
+    grossAmount,
+    gatewayFeeRate,
+    gatewayFeeAmount,
+    netAmount,
+    status: "pending"
+  };
+}
+function reverseCommission(originalCommission, originalAmount, refundAmount) {
+  if (!originalCommission?.netAmount) {
+    return null;
+  }
+  const refundRatio = refundAmount / originalAmount;
+  const reversedNetAmount = Math.round(originalCommission.netAmount * refundRatio * 100) / 100;
+  const reversedGrossAmount = Math.round(originalCommission.grossAmount * refundRatio * 100) / 100;
+  const reversedGatewayFee = Math.round(originalCommission.gatewayFeeAmount * refundRatio * 100) / 100;
+  return {
+    rate: originalCommission.rate,
+    grossAmount: reversedGrossAmount,
+    gatewayFeeRate: originalCommission.gatewayFeeRate,
+    gatewayFeeAmount: reversedGatewayFee,
+    netAmount: reversedNetAmount,
+    status: "waived"
+    // Commission waived due to refund
+  };
+}
+
+// src/enums/split.enums.ts
+var SPLIT_TYPE = {
+  PLATFORM_COMMISSION: "platform_commission",
+  AFFILIATE_COMMISSION: "affiliate_commission",
+  CUSTOM: "custom"
+};
+var SPLIT_STATUS = {
+  PENDING: "pending",
+  WAIVED: "waived"};
+
+// src/utils/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 * 100) / 100;
+    const gatewayFeeAmount = index === 0 && gatewayFeeRate > 0 ? Math.round(amount * gatewayFeeRate * 100) / 100 : 0;
+    const netAmount = Math.max(0, Math.round((grossAmount - gatewayFeeAmount) * 100) / 100);
+    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, Math.round((amount - totalSplitAmount) * 100) / 100);
+}
+function reverseSplits(originalSplits, originalAmount, refundAmount) {
+  if (!originalSplits || originalSplits.length === 0) {
+    return [];
+  }
+  const refundRatio = refundAmount / originalAmount;
+  return originalSplits.map((split) => ({
+    ...split,
+    grossAmount: Math.round(split.grossAmount * refundRatio * 100) / 100,
+    gatewayFeeAmount: Math.round(split.gatewayFeeAmount * refundRatio * 100) / 100,
+    netAmount: Math.round(split.netAmount * refundRatio * 100) / 100,
+    status: SPLIT_STATUS.WAIVED
+  }));
+}
+function calculateCommissionWithSplits(amount, commissionRate, gatewayFeeRate = 0, options = {}) {
+  const { affiliateRate = 0, affiliateId = null, affiliateType = "user" } = options;
+  if (commissionRate <= 0 && affiliateRate <= 0) {
+    return null;
+  }
+  const splitRules = [];
+  if (commissionRate > 0) {
+    splitRules.push({
+      type: SPLIT_TYPE.PLATFORM_COMMISSION,
+      recipientId: "platform",
+      recipientType: "platform",
+      rate: commissionRate
+    });
+  }
+  if (affiliateRate > 0 && affiliateId) {
+    splitRules.push({
+      type: SPLIT_TYPE.AFFILIATE_COMMISSION,
+      recipientId: affiliateId,
+      recipientType: affiliateType,
+      rate: affiliateRate
+    });
+  }
+  const splits = calculateSplits(amount, splitRules, gatewayFeeRate);
+  const platformSplit = splits.find((s) => s.type === SPLIT_TYPE.PLATFORM_COMMISSION);
+  const affiliateSplit = splits.find((s) => s.type === SPLIT_TYPE.AFFILIATE_COMMISSION);
+  return {
+    rate: commissionRate,
+    grossAmount: platformSplit?.grossAmount ?? 0,
+    gatewayFeeRate: platformSplit?.gatewayFeeRate ?? 0,
+    gatewayFeeAmount: platformSplit?.gatewayFeeAmount ?? 0,
+    netAmount: platformSplit?.netAmount ?? 0,
+    status: "pending",
+    ...splits.length > 0 && { splits },
+    ...affiliateSplit && {
+      affiliate: {
+        recipientId: affiliateSplit.recipientId,
+        recipientType: affiliateSplit.recipientType,
+        rate: affiliateSplit.rate,
+        grossAmount: affiliateSplit.grossAmount,
+        netAmount: affiliateSplit.netAmount
+      }
+    }
+  };
+}
+var LIBRARY_CATEGORIES = {
+  SUBSCRIPTION: "subscription",
+  PURCHASE: "purchase"
+};
+
+// src/utils/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;
+  }
+}
+function isCategoryValid(category, allowedCategories = []) {
+  return allowedCategories.includes(category);
+}
+
+// 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 = {
+  PAUSED: "paused",
+  CANCELLED: "cancelled"};
+
+// 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, CircuitOpenError, EDITABLE_MONETIZATION_FIELDS_PRE_VERIFICATION, IdempotencyError, IdempotencyManager, MANUAL_TRANSACTION_CREATE_FIELDS, MANUAL_TRANSACTION_UPDATE_FIELDS, MemoryIdempotencyStore, Money, PROTECTED_MONETIZATION_FIELDS, RetryExhaustedError, TRANSACTION_MANAGEMENT_TYPE, addDuration, calculateCommission, calculateCommissionWithSplits, calculateDelay, calculateOrganizationPayout, calculatePeriodRange, calculateProratedAmount, calculateSplits, canCancelSubscription, canPauseSubscription, canRenewSubscription, canResumeSubscription, canSelfVerify, createCircuitBreaker, createIdempotencyManager, fromSmallestUnit, getAllowedUpdateFields, getTransactionType, isCategoryValid, isManualTransaction, isMonetizationTransaction, isRetryableError, isSubscriptionActive, logger, logger_default as loggerDefault, resilientExecute, resolveCategory, resolveIntervalToDuration, retry, retryWithResult, reverseCommission, reverseSplits, setLogger, toSmallestUnit, triggerHook, validateFieldUpdate };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map