@classytic/revenue 1.1.2 → 1.1.4

package/dist/commission-split-BzB8cd39.mjs

@@ -0,0 +1,485 @@
+import { C as ValidationError } from "./category-resolver-DV83N8ok.mjs";
+import { a as SPLIT_TYPE, r as SPLIT_STATUS } from "./split.enums-BrjabxIX.mjs";
+
+//#region src/core/result.ts
+/**
+* Create a success result
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/**
+* Create an error result
+*/
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+/**
+* Check if result is Ok
+*/
+function isOk(result) {
+	return result.ok === true;
+}
+/**
+* Check if result is Err
+*/
+function isErr(result) {
+	return result.ok === false;
+}
+/**
+* Unwrap a result, throwing if it's an error
+* Use sparingly - prefer pattern matching
+*/
+function unwrap(result) {
+	if (result.ok) return result.value;
+	throw result.error;
+}
+/**
+* Unwrap a result with a default value
+*/
+function unwrapOr(result, defaultValue) {
+	return result.ok ? result.value : defaultValue;
+}
+/**
+* Map over a successful result
+*/
+function map(result, fn) {
+	return result.ok ? ok(fn(result.value)) : result;
+}
+/**
+* Map over an error result
+*/
+function mapErr(result, fn) {
+	return result.ok ? result : err(fn(result.error));
+}
+/**
+* Flat map (chain) results
+*/
+function flatMap(result, fn) {
+	return result.ok ? fn(result.value) : result;
+}
+/**
+* Try-catch wrapper that returns Result
+*/
+async function tryCatch(fn, mapError) {
+	try {
+		return ok(await fn());
+	} catch (e) {
+		return err(mapError ? mapError(e) : e);
+	}
+}
+/**
+* Synchronous try-catch wrapper
+*/
+function tryCatchSync(fn, mapError) {
+	try {
+		return ok(fn());
+	} catch (e) {
+		return err(mapError ? mapError(e) : e);
+	}
+}
+/**
+* Combine multiple results - all must succeed
+*/
+function all(results) {
+	const values = [];
+	for (const result of results) {
+		if (!result.ok) return result;
+		values.push(result.value);
+	}
+	return ok(values);
+}
+/**
+* Pattern match on result
+*/
+function match(result, handlers) {
+	return result.ok ? handlers.ok(result.value) : handlers.err(result.error);
+}
+const Result = {
+	ok,
+	err,
+	isOk,
+	isErr,
+	unwrap,
+	unwrapOr,
+	map,
+	mapErr,
+	flatMap,
+	tryCatch,
+	tryCatchSync,
+	all,
+	match
+};
+
+//#endregion
+//#region src/shared/utils/resilience/retry.ts
+/**
+* Retry Utilities
+* @classytic/revenue
+*
+* Exponential backoff with jitter for resilient operations
+* Inspired by: AWS SDK retry, Netflix Hystrix, resilience4j
+*/
+const DEFAULT_CONFIG = {
+	maxAttempts: 3,
+	baseDelay: 1e3,
+	maxDelay: 3e4,
+	backoffMultiplier: 2,
+	jitter: .1,
+	retryIf: isRetryableError
+};
+/**
+* Calculate delay with exponential backoff and jitter
+*/
+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));
+}
+/**
+* Sleep for specified milliseconds
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Check if error is retryable by default
+*/
+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;
+}
+/**
+* Execute operation with retry logic
+*/
+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++;
+		if (!(fullConfig.retryIf?.(error) ?? isRetryableError(error)) || 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);
+}
+/**
+* Error thrown when all retries are exhausted
+*/
+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];
+	}
+};
+const DEFAULT_CIRCUIT_CONFIG = {
+	failureThreshold: 5,
+	resetTimeout: 3e4,
+	successThreshold: 3,
+	monitorWindow: 6e4
+};
+/**
+* Circuit breaker for preventing cascade failures
+* Inspired by: Netflix Hystrix, resilience4j
+*/
+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 {
+			return ok(await this.execute(operation));
+		} 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
+		};
+	}
+};
+/**
+* Error thrown when circuit is open
+*/
+var CircuitOpenError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CircuitOpenError";
+	}
+};
+/**
+* Create a circuit breaker
+*/
+function createCircuitBreaker(config) {
+	return new CircuitBreaker(config);
+}
+
+//#endregion
+//#region src/shared/utils/calculators/commission.ts
+/**
+* Build commission object for transaction
+*
+* @param amount - Transaction amount
+* @param commissionRate - Commission rate (0 to 1, e.g., 0.10 for 10%)
+* @param gatewayFeeRate - Gateway fee rate (0 to 1, e.g., 0.018 for 1.8%)
+* @returns Commission object or null
+*/
+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);
+	return {
+		rate: commissionRate,
+		grossAmount,
+		gatewayFeeRate,
+		gatewayFeeAmount,
+		netAmount: Math.max(0, grossAmount - gatewayFeeAmount),
+		status: "pending"
+	};
+}
+/**
+* Reverse commission on refund (proportional)
+*
+* @param originalCommission - Original commission object
+* @param originalAmount - Original transaction amount
+* @param refundAmount - Amount being refunded
+* @returns Reversed commission or null
+*/
+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"
+	};
+}
+
+//#endregion
+//#region src/shared/utils/calculators/commission-split.ts
+/**
+* Commission Split Utilities
+* @classytic/revenue
+*
+* Multi-party commission split calculation for affiliate/referral systems
+*/
+/**
+* Calculate multi-party commission splits
+*
+* @param amount - Transaction amount
+* @param splitRules - Split configuration
+* @param gatewayFeeRate - Gateway fee rate (optional)
+* @returns Split objects
+*
+* @example
+* calculateSplits(1000, [
+*   { type: 'platform_commission', recipientId: 'platform', recipientType: 'platform', rate: 0.10 },
+*   { type: 'affiliate_commission', recipientId: 'affiliate-123', recipientType: 'user', rate: 0.02 },
+* ], 0.018);
+*
+* Returns:
+* [
+*   { type: 'platform_commission', recipientId: 'platform', grossAmount: 100, gatewayFeeAmount: 18, netAmount: 82, ... },
+*   { type: 'affiliate_commission', recipientId: 'affiliate-123', grossAmount: 20, gatewayFeeAmount: 0, netAmount: 20, ... },
+* ]
+*/
+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 ?? {}
+		};
+	});
+}
+/**
+* Calculate organization payout after splits
+*
+* @param amount - Total transaction amount
+* @param splits - Calculated splits
+* @returns Amount organization receives
+*/
+function calculateOrganizationPayout(amount, splits = []) {
+	const totalSplitAmount = splits.reduce((sum, split) => sum + split.grossAmount, 0);
+	return Math.max(0, amount - totalSplitAmount);
+}
+/**
+* Reverse splits proportionally on refund
+*
+* @param originalSplits - Original split objects
+* @param originalAmount - Original transaction amount
+* @param refundAmount - Amount being refunded
+* @returns Reversed splits
+*/
+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
+	}));
+}
+
+//#endregion
+export { unwrapOr as S, match as _, reverseCommission as a, tryCatchSync as b, retry as c, err as d, flatMap as f, mapErr as g, map as h, calculateCommission as i, Result as l, isOk as m, calculateSplits as n, CircuitBreaker as o, isErr as p, reverseSplits as r, createCircuitBreaker as s, calculateOrganizationPayout as t, all as u, ok as v, unwrap as x, tryCatch as y };