@classytic/revenue 1.1.4 → 2.0.0

package/dist/category-resolver-DV83N8ok.mjs

@@ -1,284 +0,0 @@
-import { t as LIBRARY_CATEGORIES } from "./transaction.enums-pCyMFT4Z.mjs";
-
-//#region src/core/errors.ts
-/**
-* Base Revenue Error
-*/
-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
-		};
-	}
-};
-/**
-* Configuration Errors
-*/
-var ConfigurationError = class extends RevenueError {
-	constructor(message, metadata = {}) {
-		super(message, "CONFIGURATION_ERROR", {
-			retryable: false,
-			metadata
-		});
-	}
-};
-var ModelNotRegisteredError = class extends ConfigurationError {
-	constructor(modelName) {
-		super(`Model "${modelName}" is not registered. Register it via createRevenue({ models: { ${modelName}: ... } })`, { modelName });
-	}
-};
-/**
-* Provider Errors
-*/
-var ProviderError = class extends RevenueError {
-	constructor(message, code, options = {}) {
-		super(message, code, options);
-	}
-};
-var ProviderNotFoundError = class extends ProviderError {
-	constructor(providerName, availableProviders = []) {
-		super(`Payment provider "${providerName}" not found. Available: ${availableProviders.join(", ")}`, "PROVIDER_NOT_FOUND", {
-			retryable: false,
-			metadata: {
-				providerName,
-				availableProviders
-			}
-		});
-	}
-};
-var ProviderCapabilityError = class extends ProviderError {
-	constructor(providerName, capability) {
-		super(`Provider "${providerName}" does not support ${capability}`, "PROVIDER_CAPABILITY_NOT_SUPPORTED", {
-			retryable: false,
-			metadata: {
-				providerName,
-				capability
-			}
-		});
-	}
-};
-var PaymentIntentCreationError = class extends ProviderError {
-	constructor(providerName, originalError) {
-		super(`Failed to create payment intent with provider "${providerName}": ${originalError.message}`, "PAYMENT_INTENT_CREATION_FAILED", {
-			retryable: true,
-			metadata: {
-				providerName,
-				originalError: originalError.message
-			}
-		});
-	}
-};
-var PaymentVerificationError = class extends ProviderError {
-	constructor(paymentIntentId, reason) {
-		super(`Payment verification failed for intent "${paymentIntentId}": ${reason}`, "PAYMENT_VERIFICATION_FAILED", {
-			retryable: true,
-			metadata: {
-				paymentIntentId,
-				reason
-			}
-		});
-	}
-};
-/**
-* Resource Not Found Errors
-*/
-var NotFoundError = class extends RevenueError {
-	constructor(message, code, metadata = {}) {
-		super(message, code, {
-			retryable: false,
-			metadata
-		});
-	}
-};
-var SubscriptionNotFoundError = class extends NotFoundError {
-	constructor(subscriptionId) {
-		super(`Subscription not found: ${subscriptionId}`, "SUBSCRIPTION_NOT_FOUND", { subscriptionId });
-	}
-};
-var TransactionNotFoundError = class extends NotFoundError {
-	constructor(transactionId) {
-		super(`Transaction not found: ${transactionId}`, "TRANSACTION_NOT_FOUND", { transactionId });
-	}
-};
-/**
-* Validation Errors
-*/
-var ValidationError = class extends RevenueError {
-	constructor(message, metadata = {}) {
-		super(message, "VALIDATION_ERROR", {
-			retryable: false,
-			metadata
-		});
-	}
-};
-var InvalidAmountError = class extends ValidationError {
-	constructor(amount, message) {
-		super(message ?? `Invalid amount: ${amount}. Amount must be non-negative`, { amount });
-	}
-};
-var MissingRequiredFieldError = class extends ValidationError {
-	constructor(fieldName) {
-		super(`Missing required field: ${fieldName}`, { fieldName });
-	}
-};
-/**
-* State Errors
-*/
-var StateError = class extends RevenueError {
-	constructor(message, code, metadata = {}) {
-		super(message, code, {
-			retryable: false,
-			metadata
-		});
-	}
-};
-var AlreadyVerifiedError = class extends StateError {
-	constructor(transactionId) {
-		super(`Transaction ${transactionId} is already verified`, "ALREADY_VERIFIED", { transactionId });
-	}
-};
-var InvalidStateTransitionError = class extends StateError {
-	constructor(resourceType, resourceId, fromState, toState) {
-		super(`Invalid state transition for ${resourceType} ${resourceId}: ${fromState} → ${toState}`, "INVALID_STATE_TRANSITION", {
-			resourceType,
-			resourceId,
-			fromState,
-			toState
-		});
-	}
-};
-var SubscriptionNotActiveError = class extends StateError {
-	constructor(subscriptionId, message) {
-		super(message ?? `Subscription ${subscriptionId} is not active`, "SUBSCRIPTION_NOT_ACTIVE", { subscriptionId });
-	}
-};
-/**
-* Operation Errors
-*/
-var OperationError = class extends RevenueError {
-	constructor(message, code, options = {}) {
-		super(message, code, options);
-	}
-};
-var RefundNotSupportedError = class extends OperationError {
-	constructor(providerName) {
-		super(`Refunds are not supported by provider "${providerName}"`, "REFUND_NOT_SUPPORTED", {
-			retryable: false,
-			metadata: { providerName }
-		});
-	}
-};
-var RefundError = class extends OperationError {
-	constructor(transactionId, reason) {
-		super(`Refund failed for transaction ${transactionId}: ${reason}`, "REFUND_FAILED", {
-			retryable: true,
-			metadata: {
-				transactionId,
-				reason
-			}
-		});
-	}
-};
-/**
-* Error Code Constants
-*/
-const ERROR_CODES = {
-	CONFIGURATION_ERROR: "CONFIGURATION_ERROR",
-	MODEL_NOT_REGISTERED: "MODEL_NOT_REGISTERED",
-	PROVIDER_NOT_FOUND: "PROVIDER_NOT_FOUND",
-	PROVIDER_CAPABILITY_NOT_SUPPORTED: "PROVIDER_CAPABILITY_NOT_SUPPORTED",
-	PAYMENT_INTENT_CREATION_FAILED: "PAYMENT_INTENT_CREATION_FAILED",
-	PAYMENT_VERIFICATION_FAILED: "PAYMENT_VERIFICATION_FAILED",
-	SUBSCRIPTION_NOT_FOUND: "SUBSCRIPTION_NOT_FOUND",
-	TRANSACTION_NOT_FOUND: "TRANSACTION_NOT_FOUND",
-	VALIDATION_ERROR: "VALIDATION_ERROR",
-	INVALID_AMOUNT: "INVALID_AMOUNT",
-	MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD",
-	ALREADY_VERIFIED: "ALREADY_VERIFIED",
-	INVALID_STATE_TRANSITION: "INVALID_STATE_TRANSITION",
-	SUBSCRIPTION_NOT_ACTIVE: "SUBSCRIPTION_NOT_ACTIVE",
-	REFUND_NOT_SUPPORTED: "REFUND_NOT_SUPPORTED",
-	REFUND_FAILED: "REFUND_FAILED"
-};
-/**
-* Check if error is retryable
-*/
-function isRetryable(error) {
-	return error instanceof RevenueError && error.retryable;
-}
-/**
-* Check if error is from revenue package
-*/
-function isRevenueError(error) {
-	return error instanceof RevenueError;
-}
-
-//#endregion
-//#region src/shared/utils/validators/category-resolver.ts
-/**
-* Category Resolver Utility
-* @classytic/revenue
-*
-* Resolves transaction category based on categoryMappings
-*/
-/**
-* Resolve category for a transaction based on entity and monetizationType
-*
-* Resolution Logic:
-* 1. If categoryMappings[entity] exists → use it
-* 2. Otherwise → fall back to default library category
-*
-* @param entity - The logical entity/identifier (e.g., 'Order', 'PlatformSubscription', 'Membership')
-*                 NOTE: This is NOT a database model name - it's just a logical identifier
-* @param monetizationType - The monetization type ('subscription', 'purchase', 'free')
-* @param categoryMappings - User-defined category mappings from config
-* @returns Category name for the transaction
-*
-* @example
-* // With mapping defined
-* resolveCategory('Order', 'subscription', { Order: 'order_subscription' })
-* // Returns: 'order_subscription'
-*
-* @example
-* // Without mapping, falls back to library default
-* resolveCategory('Order', 'subscription', {})
-* // Returns: 'subscription'
-*
-* @example
-* // Different entities with different mappings
-* const mappings = {
-*   Order: 'order_subscription',
-*   PlatformSubscription: 'platform_subscription',
-*   TenantUpgrade: 'tenant_upgrade',
-*   Membership: 'gym_membership',
-*   Enrollment: 'course_enrollment',
-* };
-* resolveCategory('PlatformSubscription', 'subscription', mappings)
-* // Returns: 'platform_subscription'
-*/
-function resolveCategory(entity, monetizationType, categoryMappings = {}) {
-	if (entity && categoryMappings[entity]) return categoryMappings[entity];
-	switch (monetizationType) {
-		case "subscription": return LIBRARY_CATEGORIES.SUBSCRIPTION;
-		case "purchase": return LIBRARY_CATEGORIES.PURCHASE;
-		default: return LIBRARY_CATEGORIES.SUBSCRIPTION;
-	}
-}
-
-//#endregion
-export { ValidationError as C, TransactionNotFoundError as S, isRevenueError as T, RefundNotSupportedError as _, InvalidAmountError as a, SubscriptionNotActiveError as b, ModelNotRegisteredError as c, PaymentIntentCreationError as d, PaymentVerificationError as f, RefundError as g, ProviderNotFoundError as h, ERROR_CODES as i, NotFoundError as l, ProviderError as m, AlreadyVerifiedError as n, InvalidStateTransitionError as o, ProviderCapabilityError as p, ConfigurationError as r, MissingRequiredFieldError as s, resolveCategory as t, OperationError as u, RevenueError as v, isRetryable as w, SubscriptionNotFoundError as x, StateError as y };