@classytic/revenue 1.1.2 → 1.1.3

package/README.md

@@ -78,12 +78,13 @@ import type { ITransaction } from '@classytic/shared-types';
 ## Installation
 
 ```bash
-npm install @classytic/revenue mongoose zod
+npm install @classytic/revenue @classytic/shared-types mongoose zod
 ```
 
 **Peer Dependencies:**
+- `@classytic/shared-types` ^1.0.0
 - `mongoose` ^8.0.0 || ^9.0.0
-- `zod` ^4.1.13
+- `zod` ^4.0.0
 
 **Provider Packages** (install as needed):
 ```bash
@@ -435,7 +436,7 @@ await revenue.escrow.split(transaction._id, {
 ```typescript
 import { EventBus } from '@classytic/revenue/events';
 
-revenue.events.on('payment:verified', async (event) => {
+revenue.events.on('payment.verified', async (event) => {
   // Grant access
   await grantAccess(event.transaction.customerId);
 
@@ -443,14 +444,14 @@ revenue.events.on('payment:verified', async (event) => {
   await sendEmail(event.transaction.customerId, 'Payment received!');
 });
 
-revenue.events.on('subscription:cancelled', async (event) => {
+revenue.events.on('subscription.cancelled', async (event) => {
   await removeAccess(event.subscription.customerId);
 });
 
 // Other events:
-// - monetization:created, payment:failed, payment:refunded
-// - subscription:activated, subscription:renewed
-// - escrow:held, escrow:released, settlement:completed
+// - monetization.created, payment.failed, payment.refunded
+// - subscription.activated, subscription.renewed
+// - escrow.held, escrow.released, settlement.completed
 ```
 
 ### Tax Plugin (Optional)

package/dist/application/services/index.d.mts

@@ -0,0 +1,4 @@
+import { a as MonetizationService, i as PaymentService, n as EscrowService, r as TransactionService, t as SettlementService } from "../../settlement.service-BxuiHpNC.mjs";
+import "../../index-Dsp7H5Wb.mjs";
+import "../../settlement.schema-D5uWB5tP.mjs";
+export { EscrowService, MonetizationService, PaymentService, SettlementService, TransactionService };

package/dist/application/services/index.mjs

@@ -0,0 +1,3 @@
+import { a as MonetizationService, i as PaymentService, n as EscrowService, r as TransactionService, t as SettlementService } from "../../settlement.service-CUxbUTzT.mjs";
+
+export { EscrowService, MonetizationService, PaymentService, SettlementService, TransactionService };

package/dist/base-CsTlVQJe.d.mts

@@ -0,0 +1,136 @@
+import { D as ProviderCapabilities, W as WebhookEventData, _ as PaymentIntentData, a as CreateIntentParams, b as PaymentResultData, k as RefundResultData } from "./index-Dsp7H5Wb.mjs";
+
+//#region src/providers/base.d.ts
+/**
+ * Payment Intent - standardized response from createIntent
+ */
+declare class PaymentIntent implements PaymentIntentData {
+  readonly id: string;
+  readonly sessionId: string | null;
+  readonly paymentIntentId: string | null;
+  readonly provider: string;
+  readonly status: string;
+  readonly amount: number;
+  readonly currency?: string;
+  readonly metadata: Record<string, unknown>;
+  readonly clientSecret?: string;
+  readonly paymentUrl?: string;
+  readonly instructions?: string;
+  readonly raw?: unknown;
+  constructor(data: PaymentIntentData);
+}
+/**
+ * Payment Result - standardized response from verifyPayment
+ */
+declare class PaymentResult implements PaymentResultData {
+  readonly id: string;
+  readonly provider: string;
+  readonly status: 'succeeded' | 'failed' | 'processing' | 'requires_action';
+  readonly amount?: number;
+  readonly currency?: string;
+  readonly paidAt?: Date;
+  readonly metadata: Record<string, unknown>;
+  readonly raw?: unknown;
+  constructor(data: PaymentResultData);
+}
+/**
+ * Refund Result - standardized response from refund
+ */
+declare class RefundResult implements RefundResultData {
+  readonly id: string;
+  readonly provider: string;
+  readonly status: 'succeeded' | 'failed' | 'processing';
+  readonly amount?: number;
+  readonly currency?: string;
+  readonly refundedAt?: Date;
+  readonly reason?: string;
+  readonly metadata: Record<string, unknown>;
+  readonly raw?: unknown;
+  constructor(data: RefundResultData);
+}
+/**
+ * Webhook Event - standardized webhook event
+ */
+declare class WebhookEvent implements WebhookEventData {
+  readonly id: string;
+  readonly provider: string;
+  readonly type: string;
+  readonly data: {
+    sessionId?: string;
+    paymentIntentId?: string;
+    [key: string]: unknown;
+  };
+  readonly createdAt?: Date;
+  readonly raw?: unknown;
+  constructor(data: WebhookEventData);
+}
+/**
+ * Base Payment Provider
+ * All payment providers must extend this class
+ */
+declare abstract class PaymentProvider {
+  readonly config: Record<string, unknown>;
+  readonly name: string;
+  /** Default currency - injected by Revenue when provider is registered */
+  private _defaultCurrency;
+  constructor(config?: Record<string, unknown>);
+  /**
+   * Get the default currency for this provider
+   * Used when creating PaymentIntent, PaymentResult, RefundResult without explicit currency
+   */
+  get defaultCurrency(): string;
+  /**
+   * Set the default currency (called by Revenue when registering provider)
+   * @internal
+   */
+  setDefaultCurrency(currency: string): void;
+  /**
+   * Create a payment intent
+   * @param params - Payment parameters
+   * @returns Promise<PaymentIntent>
+   */
+  abstract createIntent(params: CreateIntentParams): Promise<PaymentIntent>;
+  /**
+   * Verify a payment
+   * @param intentId - Payment intent ID
+   * @returns Promise<PaymentResult>
+   */
+  abstract verifyPayment(intentId: string): Promise<PaymentResult>;
+  /**
+   * Get payment status
+   * @param intentId - Payment intent ID
+   * @returns Promise<PaymentResult>
+   */
+  abstract getStatus(intentId: string): Promise<PaymentResult>;
+  /**
+   * Refund a payment
+   * @param paymentId - Payment ID
+   * @param amount - Amount to refund (optional, full refund if not provided)
+   * @param options - Refund options
+   * @returns Promise<RefundResult>
+   */
+  abstract refund(paymentId: string, amount?: number | null, options?: {
+    reason?: string;
+  }): Promise<RefundResult>;
+  /**
+   * Handle webhook from provider
+   * @param payload - Webhook payload
+   * @param headers - Request headers (for signature verification)
+   * @returns Promise<WebhookEvent>
+   */
+  abstract handleWebhook(payload: unknown, headers?: Record<string, string>): Promise<WebhookEvent>;
+  /**
+   * Verify webhook signature (optional)
+   * @param payload - Webhook payload
+   * @param signature - Webhook signature
+   * @returns boolean
+   */
+  verifyWebhookSignature(_payload: unknown, _signature: string): boolean;
+  /**
+   * Get provider capabilities
+   * @returns ProviderCapabilities
+   */
+  getCapabilities(): ProviderCapabilities;
+}
+//#endregion
+export { WebhookEvent as a, RefundResult as i, PaymentProvider as n, PaymentResult as r, PaymentIntent as t };

package/dist/base-DCoyIUj6.mjs

@@ -0,0 +1,152 @@
+//#region src/providers/base.ts
+/**
+* Payment Intent - standardized response from createIntent
+*/
+var PaymentIntent = class {
+	id;
+	sessionId;
+	paymentIntentId;
+	provider;
+	status;
+	amount;
+	currency;
+	metadata;
+	clientSecret;
+	paymentUrl;
+	instructions;
+	raw;
+	constructor(data) {
+		this.id = data.id;
+		this.sessionId = data.sessionId ?? null;
+		this.paymentIntentId = data.paymentIntentId ?? null;
+		this.provider = data.provider;
+		this.status = data.status;
+		this.amount = data.amount;
+		this.currency = data.currency;
+		this.metadata = data.metadata ?? {};
+		this.clientSecret = data.clientSecret;
+		this.paymentUrl = data.paymentUrl;
+		this.instructions = data.instructions;
+		this.raw = data.raw;
+	}
+};
+/**
+* Payment Result - standardized response from verifyPayment
+*/
+var PaymentResult = class {
+	id;
+	provider;
+	status;
+	amount;
+	currency;
+	paidAt;
+	metadata;
+	raw;
+	constructor(data) {
+		this.id = data.id;
+		this.provider = data.provider;
+		this.status = data.status;
+		this.amount = data.amount;
+		this.currency = data.currency;
+		this.paidAt = data.paidAt;
+		this.metadata = data.metadata ?? {};
+		this.raw = data.raw;
+	}
+};
+/**
+* Refund Result - standardized response from refund
+*/
+var RefundResult = class {
+	id;
+	provider;
+	status;
+	amount;
+	currency;
+	refundedAt;
+	reason;
+	metadata;
+	raw;
+	constructor(data) {
+		this.id = data.id;
+		this.provider = data.provider;
+		this.status = data.status;
+		this.amount = data.amount;
+		this.currency = data.currency;
+		this.refundedAt = data.refundedAt;
+		this.reason = data.reason;
+		this.metadata = data.metadata ?? {};
+		this.raw = data.raw;
+	}
+};
+/**
+* Webhook Event - standardized webhook event
+*/
+var WebhookEvent = class {
+	id;
+	provider;
+	type;
+	data;
+	createdAt;
+	raw;
+	constructor(data) {
+		this.id = data.id;
+		this.provider = data.provider;
+		this.type = data.type;
+		this.data = data.data;
+		this.createdAt = data.createdAt;
+		this.raw = data.raw;
+	}
+};
+/**
+* Base Payment Provider
+* All payment providers must extend this class
+*/
+var PaymentProvider = class {
+	config;
+	name;
+	/** Default currency - injected by Revenue when provider is registered */
+	_defaultCurrency = "USD";
+	constructor(config = {}) {
+		this.config = config;
+		this.name = "base";
+		if (config.defaultCurrency && typeof config.defaultCurrency === "string") this._defaultCurrency = config.defaultCurrency;
+	}
+	/**
+	* Get the default currency for this provider
+	* Used when creating PaymentIntent, PaymentResult, RefundResult without explicit currency
+	*/
+	get defaultCurrency() {
+		return this._defaultCurrency;
+	}
+	/**
+	* Set the default currency (called by Revenue when registering provider)
+	* @internal
+	*/
+	setDefaultCurrency(currency) {
+		this._defaultCurrency = currency;
+	}
+	/**
+	* Verify webhook signature (optional)
+	* @param payload - Webhook payload
+	* @param signature - Webhook signature
+	* @returns boolean
+	*/
+	verifyWebhookSignature(_payload, _signature) {
+		return true;
+	}
+	/**
+	* Get provider capabilities
+	* @returns ProviderCapabilities
+	*/
+	getCapabilities() {
+		return {
+			supportsWebhooks: false,
+			supportsRefunds: false,
+			supportsPartialRefunds: false,
+			requiresManualVerification: true
+		};
+	}
+};
+
+//#endregion
+export { WebhookEvent as a, RefundResult as i, PaymentProvider as n, PaymentResult as r, PaymentIntent as t };

package/dist/category-resolver-DV83N8ok.mjs

@@ -0,0 +1,284 @@
+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 };