@classytic/revenue 1.1.3 → 2.0.0

package/dist/revenue-event-catalog-LqxPnsU_.mjs

@@ -0,0 +1,388 @@
+import { t as REVENUE_EVENTS } from "./event-constants-CEMitnIV.mjs";
+import { createEvent, matchEventPattern } from "@classytic/primitives/events";
+import { z } from "zod";
+
+//#region src/events/in-process-bus.ts
+var InProcessRevenueBus = class {
+	name = "in-process-revenue";
+	handlers = /* @__PURE__ */ new Map();
+	logger;
+	constructor(options) {
+		this.logger = options?.logger ?? console;
+	}
+	async publish(event) {
+		const all = /* @__PURE__ */ new Set();
+		for (const [pattern, set] of this.handlers.entries()) if (matchEventPattern(pattern, event.type)) for (const h of set) all.add(h);
+		for (const handler of all) try {
+			await handler(event);
+		} catch (err) {
+			this.logger.error(`[InProcessRevenueBus] Handler error for ${event.type}:`, err);
+		}
+	}
+	async subscribe(pattern, handler) {
+		if (!this.handlers.has(pattern)) this.handlers.set(pattern, /* @__PURE__ */ new Set());
+		this.handlers.get(pattern)?.add(handler);
+		return () => {
+			const set = this.handlers.get(pattern);
+			if (!set) return;
+			set.delete(handler);
+			if (set.size === 0) this.handlers.delete(pattern);
+		};
+	}
+	async close() {
+		this.handlers.clear();
+	}
+};
+
+//#endregion
+//#region src/events/revenue-event-catalog.ts
+/**
+* Revenue event catalog — Zod-source-of-truth definitions for every
+* `revenue:*` event.
+*
+* Each definition exposes:
+*   - `.zodSchema`   — source of truth, used by host code's `.safeParse()`
+*   - `.schema`      — JSON Schema derived via `z.toJSONSchema()`, consumed
+*                     by Arc's EventRegistry + OpenAPI plugin
+*   - `.create(...)` — DomainEvent envelope builder, structurally compatible
+*                     with `@classytic/arc`'s `EventDefinitionOutput`
+*
+* Structurally compatible with Arc 2.10's `EventRegistry` — hosts register
+* `revenueEventDefinitions` directly, no adapter code. Revenue does NOT
+* import from `@classytic/arc` (PACKAGE_RULES §11); compatibility is purely
+* structural.
+*
+* Payload shapes reflect what the repositories actually emit today:
+* domain documents (transactions, subscriptions, settlements) are modelled
+* as structured objects with key business fields required and a passthrough
+* escape hatch for fields host code doesn't care about at validation time.
+* See PACKAGE_RULES §18.5 for the full pattern.
+*
+* @example Wiring into an Arc app
+* ```ts
+* import { createEventRegistry } from '@classytic/arc/events';
+* import { revenueEventDefinitions } from '@classytic/revenue/events';
+*
+* const registry = createEventRegistry();
+* for (const def of revenueEventDefinitions) registry.register(def);
+*
+* const app = await createApp({
+*   arcPlugins: { events: { registry, validateMode: 'reject' } },
+* });
+* ```
+*/
+function defineRevenueEvent(input) {
+	const { name, version = 1, description, zodSchema } = input;
+	return {
+		name,
+		version,
+		description,
+		schema: z.toJSONSchema(zodSchema),
+		zodSchema,
+		create(payload, meta) {
+			return createEvent(name, payload, {
+				resource: "revenue",
+				...meta
+			});
+		}
+	};
+}
+const money = z.object({
+	amount: z.number().nonnegative(),
+	currency: z.string().length(3)
+});
+const transactionRef = z.object({
+	_id: z.union([z.string(), z.any()]).optional(),
+	publicId: z.string().optional(),
+	status: z.string().optional(),
+	monetizationType: z.string().optional(),
+	amount: money.optional()
+}).passthrough();
+const subscriptionRef = z.object({
+	_id: z.union([z.string(), z.any()]).optional(),
+	publicId: z.string().optional(),
+	status: z.string().optional(),
+	planId: z.string().optional(),
+	customerId: z.string().optional()
+}).passthrough();
+const settlementRef = z.object({
+	_id: z.union([z.string(), z.any()]).optional(),
+	publicId: z.string().optional(),
+	status: z.string().optional(),
+	totalAmount: money.optional(),
+	payoutMethod: z.string().optional()
+}).passthrough();
+const paymentVerifiedSchema = z.object({
+	transaction: transactionRef,
+	paymentResult: z.record(z.string(), z.unknown()).optional(),
+	verifiedBy: z.string().optional()
+});
+const paymentFailedSchema = z.object({
+	transaction: transactionRef,
+	paymentResult: z.record(z.string(), z.unknown()).optional(),
+	verifiedBy: z.string().optional()
+});
+const paymentProcessingSchema = z.object({
+	transaction: transactionRef,
+	paymentResult: z.record(z.string(), z.unknown()).optional(),
+	verifiedBy: z.string().optional()
+});
+const paymentRequiresActionSchema = z.object({
+	transaction: transactionRef,
+	paymentResult: z.record(z.string(), z.unknown()).optional(),
+	verifiedBy: z.string().optional()
+});
+const paymentRefundedSchema = z.object({
+	transaction: transactionRef,
+	refundTransaction: transactionRef,
+	refundAmount: money,
+	reason: z.string().optional(),
+	isPartialRefund: z.boolean()
+});
+const monetizationCreatedSchema = z.object({
+	monetizationType: z.string(),
+	transaction: transactionRef
+});
+const purchaseCreatedSchema = monetizationCreatedSchema;
+const freeCreatedSchema = monetizationCreatedSchema;
+const transactionUpdatedSchema = z.object({
+	transaction: transactionRef,
+	changedFields: z.array(z.string()).optional()
+});
+const subscriptionCreatedSchema = z.object({ subscription: subscriptionRef });
+const subscriptionActivatedSchema = z.object({
+	subscription: subscriptionRef,
+	activatedAt: z.iso.datetime()
+});
+const subscriptionRenewedSchema = z.object({
+	subscription: subscriptionRef,
+	renewedAt: z.iso.datetime(),
+	nextPeriodStart: z.iso.datetime().optional(),
+	nextPeriodEnd: z.iso.datetime().optional()
+});
+const subscriptionCancelledSchema = z.object({
+	subscription: subscriptionRef,
+	immediate: z.boolean().optional(),
+	reason: z.string().optional()
+});
+const subscriptionPausedSchema = z.object({
+	subscription: subscriptionRef,
+	reason: z.string().optional()
+});
+const subscriptionResumedSchema = z.object({
+	subscription: subscriptionRef,
+	extendPeriod: z.boolean().optional()
+});
+const escrowHeldSchema = z.object({
+	transaction: transactionRef,
+	heldAmount: money,
+	reason: z.string().optional()
+});
+const escrowReleasedSchema = z.object({
+	transaction: transactionRef,
+	releaseAmount: money,
+	recipientId: z.string().optional(),
+	recipientType: z.string().optional(),
+	isFullRelease: z.boolean(),
+	isPartialRelease: z.boolean()
+});
+const escrowCancelledSchema = z.object({
+	transaction: transactionRef,
+	cancelledAmount: money.optional(),
+	reason: z.string().optional()
+});
+const escrowSplitSchema = z.object({
+	transaction: transactionRef,
+	splits: z.array(z.object({
+		recipientId: z.string(),
+		recipientType: z.string().optional(),
+		amount: money
+	}).passthrough()),
+	organizationPayout: money.optional()
+});
+const settlementCreatedSchema = z.object({ settlement: settlementRef });
+const settlementScheduledSchema = z.object({
+	settlement: settlementRef,
+	scheduledAt: z.iso.datetime()
+});
+const settlementProcessingSchema = z.object({
+	settlement: settlementRef,
+	processedAt: z.iso.datetime()
+});
+const settlementCompletedSchema = z.object({
+	settlement: settlementRef,
+	completedAt: z.iso.datetime()
+});
+const settlementFailedSchema = z.object({
+	settlement: settlementRef,
+	reason: z.string(),
+	code: z.string().optional(),
+	retry: z.boolean().optional()
+});
+const webhookProcessedSchema = z.object({
+	webhookType: z.string(),
+	provider: z.string(),
+	event: z.record(z.string(), z.unknown()),
+	transaction: transactionRef.optional()
+});
+const PaymentVerified = defineRevenueEvent({
+	name: REVENUE_EVENTS.PAYMENT_VERIFIED,
+	description: "A payment transaction was verified by its provider.",
+	zodSchema: paymentVerifiedSchema
+});
+const PaymentFailed = defineRevenueEvent({
+	name: REVENUE_EVENTS.PAYMENT_FAILED,
+	description: "A payment verification failed.",
+	zodSchema: paymentFailedSchema
+});
+const PaymentProcessing = defineRevenueEvent({
+	name: REVENUE_EVENTS.PAYMENT_PROCESSING,
+	description: "A payment entered an in-progress state at the provider.",
+	zodSchema: paymentProcessingSchema
+});
+const PaymentRequiresAction = defineRevenueEvent({
+	name: REVENUE_EVENTS.PAYMENT_REQUIRES_ACTION,
+	description: "A payment requires additional customer action (3DS, OTP, etc.).",
+	zodSchema: paymentRequiresActionSchema
+});
+const PaymentRefunded = defineRevenueEvent({
+	name: REVENUE_EVENTS.PAYMENT_REFUNDED,
+	description: "A payment transaction was (partially or fully) refunded.",
+	zodSchema: paymentRefundedSchema
+});
+const MonetizationCreated = defineRevenueEvent({
+	name: REVENUE_EVENTS.MONETIZATION_CREATED,
+	description: "A monetization transaction (purchase, free grant, …) was created.",
+	zodSchema: monetizationCreatedSchema
+});
+const PurchaseCreated = defineRevenueEvent({
+	name: REVENUE_EVENTS.PURCHASE_CREATED,
+	description: "A one-shot purchase transaction was created.",
+	zodSchema: purchaseCreatedSchema
+});
+const FreeCreated = defineRevenueEvent({
+	name: REVENUE_EVENTS.FREE_CREATED,
+	description: "A free (zero-cost) transaction was granted.",
+	zodSchema: freeCreatedSchema
+});
+const TransactionUpdated = defineRevenueEvent({
+	name: REVENUE_EVENTS.TRANSACTION_UPDATED,
+	description: "Generic host-level update on a transaction record.",
+	zodSchema: transactionUpdatedSchema
+});
+const SubscriptionCreated = defineRevenueEvent({
+	name: REVENUE_EVENTS.SUBSCRIPTION_CREATED,
+	description: "A subscription was created (before first activation).",
+	zodSchema: subscriptionCreatedSchema
+});
+const SubscriptionActivated = defineRevenueEvent({
+	name: REVENUE_EVENTS.SUBSCRIPTION_ACTIVATED,
+	description: "A subscription became active (first successful charge).",
+	zodSchema: subscriptionActivatedSchema
+});
+const SubscriptionRenewed = defineRevenueEvent({
+	name: REVENUE_EVENTS.SUBSCRIPTION_RENEWED,
+	description: "A subscription renewal cycle succeeded.",
+	zodSchema: subscriptionRenewedSchema
+});
+const SubscriptionCancelled = defineRevenueEvent({
+	name: REVENUE_EVENTS.SUBSCRIPTION_CANCELLED,
+	description: "A subscription was cancelled (immediate or end-of-period).",
+	zodSchema: subscriptionCancelledSchema
+});
+const SubscriptionPaused = defineRevenueEvent({
+	name: REVENUE_EVENTS.SUBSCRIPTION_PAUSED,
+	description: "A subscription was paused.",
+	zodSchema: subscriptionPausedSchema
+});
+const SubscriptionResumed = defineRevenueEvent({
+	name: REVENUE_EVENTS.SUBSCRIPTION_RESUMED,
+	description: "A paused subscription was resumed.",
+	zodSchema: subscriptionResumedSchema
+});
+const EscrowHeld = defineRevenueEvent({
+	name: REVENUE_EVENTS.ESCROW_HELD,
+	description: "An amount was placed into escrow against a transaction.",
+	zodSchema: escrowHeldSchema
+});
+const EscrowReleased = defineRevenueEvent({
+	name: REVENUE_EVENTS.ESCROW_RELEASED,
+	description: "Escrow was released (full or partial) to a recipient.",
+	zodSchema: escrowReleasedSchema
+});
+const EscrowCancelled = defineRevenueEvent({
+	name: REVENUE_EVENTS.ESCROW_CANCELLED,
+	description: "An escrow hold was cancelled and funds returned.",
+	zodSchema: escrowCancelledSchema
+});
+const EscrowSplit = defineRevenueEvent({
+	name: REVENUE_EVENTS.ESCROW_SPLIT,
+	description: "Escrow was split across multiple recipients.",
+	zodSchema: escrowSplitSchema
+});
+const SettlementCreated = defineRevenueEvent({
+	name: REVENUE_EVENTS.SETTLEMENT_CREATED,
+	description: "A settlement record was created.",
+	zodSchema: settlementCreatedSchema
+});
+const SettlementScheduled = defineRevenueEvent({
+	name: REVENUE_EVENTS.SETTLEMENT_SCHEDULED,
+	description: "A settlement was scheduled for a future payout.",
+	zodSchema: settlementScheduledSchema
+});
+const SettlementProcessing = defineRevenueEvent({
+	name: REVENUE_EVENTS.SETTLEMENT_PROCESSING,
+	description: "A settlement entered the processing phase.",
+	zodSchema: settlementProcessingSchema
+});
+const SettlementCompleted = defineRevenueEvent({
+	name: REVENUE_EVENTS.SETTLEMENT_COMPLETED,
+	description: "A settlement completed successfully.",
+	zodSchema: settlementCompletedSchema
+});
+const SettlementFailed = defineRevenueEvent({
+	name: REVENUE_EVENTS.SETTLEMENT_FAILED,
+	description: "A settlement failed during processing.",
+	zodSchema: settlementFailedSchema
+});
+const WebhookProcessed = defineRevenueEvent({
+	name: REVENUE_EVENTS.WEBHOOK_PROCESSED,
+	description: "A provider webhook was processed by the revenue engine.",
+	zodSchema: webhookProcessedSchema
+});
+/**
+* Every revenue event defined in the package — pass to Arc's
+* `EventRegistry`. Hosts wire ONE array; the whole `revenue:*` namespace
+* becomes introspectable via OpenAPI and auto-validated at publish time
+* when `eventPlugin({ validateMode: 'reject' })` is set.
+*/
+const revenueEventDefinitions = [
+	PaymentVerified,
+	PaymentFailed,
+	PaymentProcessing,
+	PaymentRequiresAction,
+	PaymentRefunded,
+	MonetizationCreated,
+	PurchaseCreated,
+	FreeCreated,
+	TransactionUpdated,
+	SubscriptionCreated,
+	SubscriptionActivated,
+	SubscriptionRenewed,
+	SubscriptionCancelled,
+	SubscriptionPaused,
+	SubscriptionResumed,
+	EscrowHeld,
+	EscrowReleased,
+	EscrowCancelled,
+	EscrowSplit,
+	SettlementCreated,
+	SettlementScheduled,
+	SettlementProcessing,
+	SettlementCompleted,
+	SettlementFailed,
+	WebhookProcessed
+];
+
+//#endregion
+export { SubscriptionResumed as C, InProcessRevenueBus as D, revenueEventDefinitions as E, SubscriptionRenewed as S, WebhookProcessed as T, SettlementScheduled as _, FreeCreated as a, SubscriptionCreated as b, PaymentProcessing as c, PaymentVerified as d, PurchaseCreated as f, SettlementProcessing as g, SettlementFailed as h, EscrowSplit as i, PaymentRefunded as l, SettlementCreated as m, EscrowHeld as n, MonetizationCreated as o, SettlementCompleted as p, EscrowReleased as r, PaymentFailed as s, EscrowCancelled as t, PaymentRequiresAction as u, SubscriptionActivated as v, TransactionUpdated as w, SubscriptionPaused as x, SubscriptionCancelled as y };