@classytic/revenue 1.1.2 → 1.1.4

package/dist/plugin-BbK0OVHy.d.mts

@@ -0,0 +1,327 @@
+import { EventBus, RevenueEvents } from "./core/events.mjs";
+
+//#region src/core/plugin.d.ts
+/**
+ * Plugin context passed to hooks
+ */
+interface PluginContext {
+  /** Event bus for emitting events */
+  events: EventBus;
+  /** Logger instance */
+  logger: PluginLogger;
+  /** Plugin-specific storage (use this to share data between hook calls) */
+  storage: Map<string, unknown>;
+  /** Request metadata */
+  meta: {
+    idempotencyKey?: string;
+    requestId: string;
+    timestamp: Date;
+    [key: string]: unknown;
+  };
+}
+/**
+ * Plugin logger interface
+ */
+interface PluginLogger {
+  debug(message: string, data?: unknown): void;
+  info(message: string, data?: unknown): void;
+  warn(message: string, data?: unknown): void;
+  error(message: string, data?: unknown): void;
+}
+/**
+ * Hook function type
+ */
+type HookFn<TInput = unknown, TOutput = unknown> = (ctx: PluginContext, input: TInput, next: () => Promise<TOutput>) => Promise<TOutput>;
+/**
+ * Available hook points
+ */
+interface PluginHooks {
+  'monetization.create.before': HookFn<MonetizationCreateInput>;
+  'monetization.create.after': HookFn<MonetizationCreateInput, MonetizationCreateOutput>;
+  'payment.create.before': HookFn<PaymentCreateInput>;
+  'payment.create.after': HookFn<PaymentCreateInput, PaymentCreateOutput>;
+  'payment.verify.before': HookFn<PaymentVerifyInput>;
+  'payment.verify.after': HookFn<PaymentVerifyInput, PaymentVerifyOutput>;
+  'payment.refund.before': HookFn<RefundInput>;
+  'payment.refund.after': HookFn<RefundInput, RefundOutput>;
+  'subscription.create.before': HookFn<SubscriptionCreateInput>;
+  'subscription.create.after': HookFn<SubscriptionCreateInput, SubscriptionCreateOutput>;
+  'subscription.activate.before': HookFn<SubscriptionActivateInput>;
+  'subscription.activate.after': HookFn<SubscriptionActivateInput, SubscriptionActivateOutput>;
+  'subscription.cancel.before': HookFn<SubscriptionCancelInput>;
+  'subscription.cancel.after': HookFn<SubscriptionCancelInput, SubscriptionCancelOutput>;
+  'subscription.pause.before': HookFn<SubscriptionPauseInput>;
+  'subscription.pause.after': HookFn<SubscriptionPauseInput, SubscriptionPauseOutput>;
+  'subscription.resume.before': HookFn<SubscriptionResumeInput>;
+  'subscription.resume.after': HookFn<SubscriptionResumeInput, SubscriptionResumeOutput>;
+  'transaction.create.before': HookFn<TransactionCreateInput>;
+  'transaction.create.after': HookFn<TransactionCreateInput, TransactionCreateOutput>;
+  'transaction.update.before': HookFn<TransactionUpdateInput>;
+  'transaction.update.after': HookFn<TransactionUpdateInput, TransactionUpdateOutput>;
+  'escrow.hold.before': HookFn<EscrowHoldInput>;
+  'escrow.hold.after': HookFn<EscrowHoldInput, EscrowHoldOutput>;
+  'escrow.release.before': HookFn<EscrowReleaseInput>;
+  'escrow.release.after': HookFn<EscrowReleaseInput, EscrowReleaseOutput>;
+}
+/**
+ * Clean, explicit hook input/output types
+ * Self-documenting and fully type-safe - no more `as any` needed!
+ */
+/**
+ * Data passed to monetization.create hooks
+ * Includes all parameters plus tax if injected by tax plugin
+ */
+interface MonetizationCreateInput {
+  data: {
+    organizationId?: string;
+    customerId?: string;
+    sourceId?: string;
+    sourceModel?: string;
+  };
+  planKey: string;
+  amount: number;
+  currency?: string;
+  gateway?: string;
+  entity?: string | null;
+  monetizationType?: 'subscription' | 'purchase' | 'free';
+  paymentData?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  idempotencyKey?: string | null;
+  tax?: {
+    isApplicable: boolean;
+    rate: number;
+    baseAmount: number;
+    taxAmount: number;
+    totalAmount: number;
+    pricesIncludeTax: boolean;
+    type: 'collected' | 'paid' | 'exempt';
+  };
+}
+interface MonetizationCreateOutput {
+  transactionId?: string;
+  subscriptionId?: string;
+}
+/**
+ * Data passed to payment.create hooks
+ */
+interface PaymentCreateInput {
+  transactionId: string;
+  amount: number;
+  currency: string;
+  gateway: string;
+  paymentData?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+}
+interface PaymentCreateOutput {
+  paymentIntentId: string;
+  clientSecret?: string;
+}
+interface PaymentVerifyInput {
+  id: string;
+  verifiedBy?: string;
+}
+interface PaymentVerifyOutput {
+  verified: boolean;
+}
+interface RefundInput {
+  transactionId: string;
+  amount?: number;
+  reason?: string;
+}
+interface RefundOutput {
+  refundId: string;
+}
+/**
+ * Data passed to subscription.create hooks
+ * Note: subscriptionId is undefined in .before hook (not yet created)
+ *       and populated in .after hook (already created)
+ */
+interface SubscriptionCreateInput {
+  subscriptionId?: string;
+  planKey: string;
+  customerId?: string;
+  organizationId?: string;
+  entity?: string | null;
+}
+interface SubscriptionCreateOutput {
+  subscription: unknown;
+  transaction?: unknown;
+}
+/**
+ * Data passed to subscription.activate hooks
+ */
+interface SubscriptionActivateInput {
+  subscriptionId: string;
+  transactionId?: string;
+  activatedAt?: Date;
+}
+interface SubscriptionActivateOutput {
+  activated: boolean;
+  activatedAt: Date;
+}
+/**
+ * Data passed to subscription.cancel hooks
+ */
+interface SubscriptionCancelInput {
+  subscriptionId: string;
+  immediate?: boolean;
+  reason?: string;
+}
+interface SubscriptionCancelOutput {
+  cancelled: boolean;
+  effectiveDate?: Date;
+}
+/**
+ * Data passed to subscription.pause hooks
+ */
+interface SubscriptionPauseInput {
+  subscriptionId: string;
+  reason?: string;
+}
+interface SubscriptionPauseOutput {
+  paused: boolean;
+  pausedAt: Date;
+}
+/**
+ * Data passed to subscription.resume hooks
+ */
+interface SubscriptionResumeInput {
+  subscriptionId: string;
+  extendPeriod?: boolean;
+}
+interface SubscriptionResumeOutput {
+  resumed: boolean;
+  resumedAt: Date;
+}
+/**
+ * Data passed to transaction.create hooks
+ */
+interface TransactionCreateInput {
+  amount: number;
+  currency: string;
+  type: string;
+  organizationId?: string;
+  customerId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface TransactionCreateOutput {
+  transactionId: string;
+}
+interface TransactionUpdateInput {
+  transactionId: string;
+  updates: Record<string, unknown>;
+}
+interface TransactionUpdateOutput {
+  transaction: unknown;
+}
+interface EscrowHoldInput {
+  transactionId: string;
+  reason?: string;
+}
+interface EscrowHoldOutput {
+  held: boolean;
+}
+interface EscrowReleaseInput {
+  transactionId: string;
+  recipientId?: string;
+  recipientType?: string;
+}
+interface EscrowReleaseOutput {
+  released: boolean;
+}
+/**
+ * Plugin definition
+ */
+interface RevenuePlugin {
+  /** Unique plugin name */
+  name: string;
+  /** Plugin version */
+  version?: string;
+  /** Plugin description */
+  description?: string;
+  /** Dependencies on other plugins */
+  dependencies?: string[];
+  /** Hook implementations */
+  hooks?: Partial<PluginHooks>;
+  /** Event listeners */
+  events?: Partial<{ [K in keyof RevenueEvents]: (event: RevenueEvents[K]) => void | Promise<void> }>;
+  /** Initialize plugin */
+  init?: (ctx: PluginContext) => void | Promise<void>;
+  /** Cleanup plugin */
+  destroy?: () => void | Promise<void>;
+}
+/**
+ * Plugin manager - handles registration and execution
+ */
+declare class PluginManager {
+  private plugins;
+  private hooks;
+  private initialized;
+  /**
+   * Register a plugin
+   */
+  register(plugin: RevenuePlugin): this;
+  /**
+   * Initialize all plugins
+   */
+  init(ctx: PluginContext): Promise<void>;
+  /**
+   * Execute a hook chain
+   */
+  executeHook<TInput, TOutput>(hookName: string, ctx: PluginContext, input: TInput, execute: () => Promise<TOutput>): Promise<TOutput>;
+  /**
+   * Check if plugin is registered
+   */
+  has(name: string): boolean;
+  /**
+   * Get a plugin by name
+   */
+  get(name: string): RevenuePlugin | undefined;
+  /**
+   * Get all registered plugins
+   */
+  list(): RevenuePlugin[];
+  /**
+   * Destroy all plugins
+   */
+  destroy(): Promise<void>;
+}
+/**
+ * Logging plugin - logs all operations
+ */
+declare function loggingPlugin(options?: {
+  level?: 'debug' | 'info';
+}): RevenuePlugin;
+/**
+ * Audit plugin - records all operations for compliance
+ */
+declare function auditPlugin(options?: {
+  store?: (entry: AuditEntry) => Promise<void>;
+}): RevenuePlugin;
+interface AuditEntry {
+  action: string;
+  requestId: string;
+  timestamp: Date;
+  input: Record<string, unknown>;
+  output: Record<string, unknown>;
+  idempotencyKey?: string;
+}
+/**
+ * Metrics plugin - collects operation metrics
+ */
+declare function metricsPlugin(options?: {
+  onMetric?: (metric: Metric) => void;
+}): RevenuePlugin;
+interface Metric {
+  name: string;
+  duration: number;
+  success: boolean;
+  error?: string;
+  [key: string]: unknown;
+}
+/**
+ * Create a custom plugin
+ */
+declare function definePlugin(plugin: RevenuePlugin): RevenuePlugin;
+//#endregion
+export { PluginManager as a, definePlugin as c, PluginLogger as i, loggingPlugin as l, PluginContext as n, RevenuePlugin as o, PluginHooks as r, auditPlugin as s, HookFn as t, metricsPlugin as u };

package/dist/plugin-Cd_V04Em.mjs

@@ -0,0 +1,210 @@
+//#region src/core/plugin.ts
+/**
+* Plugin manager - handles registration and execution
+*/
+var PluginManager = class {
+	plugins = /* @__PURE__ */ new Map();
+	hooks = /* @__PURE__ */ new Map();
+	initialized = false;
+	/**
+	* Register a plugin
+	*/
+	register(plugin) {
+		if (this.plugins.has(plugin.name)) throw new Error(`Plugin "${plugin.name}" is already registered`);
+		if (plugin.dependencies) {
+			for (const dep of plugin.dependencies) if (!this.plugins.has(dep)) throw new Error(`Plugin "${plugin.name}" requires "${dep}" to be registered first`);
+		}
+		this.plugins.set(plugin.name, plugin);
+		if (plugin.hooks) for (const [hookName, hookFn] of Object.entries(plugin.hooks)) {
+			if (!this.hooks.has(hookName)) this.hooks.set(hookName, []);
+			this.hooks.get(hookName).push(hookFn);
+		}
+		return this;
+	}
+	/**
+	* Initialize all plugins
+	*/
+	async init(ctx) {
+		if (this.initialized) return;
+		for (const plugin of this.plugins.values()) {
+			if (plugin.init) await plugin.init(ctx);
+			if (plugin.events) for (const [event, handler] of Object.entries(plugin.events)) ctx.events.on(event, handler);
+		}
+		this.initialized = true;
+	}
+	/**
+	* Execute a hook chain
+	*/
+	async executeHook(hookName, ctx, input, execute) {
+		const hooks = this.hooks.get(hookName) ?? [];
+		if (hooks.length === 0) return execute();
+		let index = 0;
+		const next = async () => {
+			if (index >= hooks.length) return execute();
+			const hook = hooks[index++];
+			return hook(ctx, input, next);
+		};
+		return next();
+	}
+	/**
+	* Check if plugin is registered
+	*/
+	has(name) {
+		return this.plugins.has(name);
+	}
+	/**
+	* Get a plugin by name
+	*/
+	get(name) {
+		return this.plugins.get(name);
+	}
+	/**
+	* Get all registered plugins
+	*/
+	list() {
+		return Array.from(this.plugins.values());
+	}
+	/**
+	* Destroy all plugins
+	*/
+	async destroy() {
+		for (const plugin of this.plugins.values()) if (plugin.destroy) await plugin.destroy();
+		this.plugins.clear();
+		this.hooks.clear();
+		this.initialized = false;
+	}
+};
+/**
+* Logging plugin - logs all operations
+*/
+function loggingPlugin(options = {}) {
+	const level = options.level ?? "info";
+	return {
+		name: "logging",
+		version: "1.0.0",
+		description: "Logs all revenue operations",
+		hooks: {
+			"payment.create.after": async (ctx, input, next) => {
+				ctx.logger[level]("Creating payment", {
+					amount: input.amount,
+					currency: input.currency
+				});
+				const result = await next();
+				ctx.logger[level]("Payment created", { paymentIntentId: result?.paymentIntentId });
+				return result;
+			},
+			"payment.verify.after": async (ctx, input, next) => {
+				ctx.logger[level]("Verifying payment", { id: input.id });
+				const result = await next();
+				ctx.logger[level]("Payment verified", { verified: result?.verified });
+				return result;
+			},
+			"payment.refund.after": async (ctx, input, next) => {
+				ctx.logger[level]("Processing refund", {
+					transactionId: input.transactionId,
+					amount: input.amount
+				});
+				const result = await next();
+				ctx.logger[level]("Refund processed", { refundId: result?.refundId });
+				return result;
+			}
+		}
+	};
+}
+/**
+* Audit plugin - records all operations for compliance
+*/
+function auditPlugin(options = {}) {
+	const entries = [];
+	const store = options.store ?? (async (entry) => {
+		entries.push(entry);
+	});
+	return {
+		name: "audit",
+		version: "1.0.0",
+		description: "Audit trail for all operations",
+		hooks: {
+			"payment.create.after": async (ctx, input, next) => {
+				const result = await next();
+				await store({
+					action: "payment.create",
+					requestId: ctx.meta.requestId,
+					timestamp: ctx.meta.timestamp,
+					input: sanitizeInput(input),
+					output: sanitizeOutput(result),
+					idempotencyKey: ctx.meta.idempotencyKey
+				});
+				return result;
+			},
+			"payment.refund.after": async (ctx, input, next) => {
+				const result = await next();
+				await store({
+					action: "payment.refund",
+					requestId: ctx.meta.requestId,
+					timestamp: ctx.meta.timestamp,
+					input: sanitizeInput(input),
+					output: sanitizeOutput(result),
+					idempotencyKey: ctx.meta.idempotencyKey
+				});
+				return result;
+			}
+		}
+	};
+}
+function sanitizeInput(input) {
+	if (typeof input !== "object" || !input) return {};
+	const sanitized = { ...input };
+	delete sanitized.apiKey;
+	delete sanitized.secretKey;
+	delete sanitized.password;
+	return sanitized;
+}
+function sanitizeOutput(output) {
+	if (typeof output !== "object" || !output) return {};
+	return { ...output };
+}
+/**
+* Metrics plugin - collects operation metrics
+*/
+function metricsPlugin(options = {}) {
+	const metrics = [];
+	const record = options.onMetric ?? ((metric) => {
+		metrics.push(metric);
+	});
+	return {
+		name: "metrics",
+		version: "1.0.0",
+		description: "Collects operation metrics",
+		hooks: { "payment.create.before": async (_ctx, input, next) => {
+			const start = Date.now();
+			try {
+				const result = await next();
+				record({
+					name: "payment.create",
+					duration: Date.now() - start,
+					success: true,
+					amount: input.amount,
+					currency: input.currency
+				});
+				return result;
+			} catch (error) {
+				record({
+					name: "payment.create",
+					duration: Date.now() - start,
+					success: false,
+					error: error.message
+				});
+				throw error;
+			}
+		} }
+	};
+}
+/**
+* Create a custom plugin
+*/
+function definePlugin(plugin) {
+	return plugin;
+}
+
+//#endregion
+export { metricsPlugin as a, loggingPlugin as i, auditPlugin as n, definePlugin as r, PluginManager as t };

package/dist/providers/index.d.mts

@@ -0,0 +1,3 @@
+import { D as ProviderCapabilities, W as WebhookEventData, _ as PaymentIntentData, a as CreateIntentParams, b as PaymentResultData, k as RefundResultData } from "../index-Dsp7H5Wb.mjs";
+import { a as WebhookEvent, i as RefundResult, n as PaymentProvider, r as PaymentResult, t as PaymentIntent } from "../base-CsTlVQJe.mjs";
+export { type CreateIntentParams, PaymentIntent, type PaymentIntentData, PaymentProvider, type PaymentProvider as PaymentProviderDefault, PaymentResult, type PaymentResultData, type ProviderCapabilities, RefundResult, type RefundResultData, WebhookEvent, type WebhookEventData };

package/dist/providers/index.mjs

@@ -0,0 +1,3 @@
+import { a as WebhookEvent, i as RefundResult, n as PaymentProvider, r as PaymentResult, t as PaymentIntent } from "../base-DCoyIUj6.mjs";
+
+export { PaymentIntent, PaymentProvider, PaymentResult, RefundResult, WebhookEvent };