@classytic/revenue 1.1.2 → 1.1.4

package/dist/revenue-BhdS7nXh.mjs

@@ -0,0 +1,553 @@
+import { createEventBus } from "./core/events.mjs";
+import { t as PluginManager } from "./plugin-Cd_V04Em.mjs";
+import { c as retry, s as createCircuitBreaker, y as tryCatch } from "./commission-split-BzB8cd39.mjs";
+import { n as createIdempotencyManager } from "./idempotency-DaYcUGY1.mjs";
+import { r as ConfigurationError } from "./category-resolver-DV83N8ok.mjs";
+import { a as MonetizationService, g as resolveConfig, i as PaymentService, n as EscrowService, r as TransactionService, t as SettlementService } from "./settlement.service-DmdKv0Zu.mjs";
+import { nanoid } from "nanoid";
+
+//#region src/core/container.ts
+var Container = class Container {
+	_services;
+	_singletons;
+	constructor() {
+		this._services = /* @__PURE__ */ new Map();
+		this._singletons = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Register a service
+	* @param name - Service name
+	* @param implementation - Service implementation or factory
+	* @param options - Registration options
+	*/
+	register(name, implementation, options = {}) {
+		this._services.set(name, {
+			implementation,
+			singleton: options.singleton !== false,
+			factory: options.factory ?? false
+		});
+		return this;
+	}
+	/**
+	* Register a singleton service
+	* @param name - Service name
+	* @param implementation - Service implementation
+	*/
+	singleton(name, implementation) {
+		return this.register(name, implementation, { singleton: true });
+	}
+	/**
+	* Register a transient service (new instance each time)
+	* @param name - Service name
+	* @param factory - Factory function
+	*/
+	transient(name, factory) {
+		return this.register(name, factory, {
+			singleton: false,
+			factory: true
+		});
+	}
+	/**
+	* Get a service from the container
+	* @param name - Service name
+	* @returns Service instance
+	*/
+	get(name) {
+		if (this._singletons.has(name)) return this._singletons.get(name);
+		const service = this._services.get(name);
+		if (!service) throw new Error(`Service "${name}" not registered in container`);
+		if (service.factory) {
+			const factory = service.implementation;
+			const instance = factory(this);
+			if (service.singleton) this._singletons.set(name, instance);
+			return instance;
+		}
+		const instance = service.implementation;
+		if (service.singleton) this._singletons.set(name, instance);
+		return instance;
+	}
+	/**
+	* Check if service is registered
+	* @param name - Service name
+	*/
+	has(name) {
+		return this._services.has(name);
+	}
+	/**
+	* Get all registered service names
+	*/
+	keys() {
+		return Array.from(this._services.keys());
+	}
+	/**
+	* Clear all services (useful for testing)
+	*/
+	clear() {
+		this._services.clear();
+		this._singletons.clear();
+	}
+	/**
+	* Create a child container (for scoped dependencies)
+	*/
+	createScope() {
+		const scope = new Container();
+		this._services.forEach((value, key) => {
+			scope._services.set(key, value);
+		});
+		return scope;
+	}
+};
+
+//#endregion
+//#region src/core/revenue.ts
+/**
+* Revenue - Modern Payment Management
+* @classytic/revenue
+*
+* Fluent Builder API with integrated services
+* Less code, more power
+*
+* Inspired by: Vercel AI SDK, Stripe SDK, tRPC
+*/
+/**
+* Revenue - Main entry point
+*
+* @example
+* ```typescript
+* const revenue = Revenue
+*   .create({ defaultCurrency: 'USD' })
+*   .withModels({ Transaction, Subscription })
+*   .withProvider('stripe', new StripeProvider({ apiKey: '...' }))
+*   .withProvider('manual', new ManualProvider())
+*   .withPlugin(auditPlugin())
+*   .build();
+*
+* // Access services directly
+* await revenue.monetization.create({ ... });
+* await revenue.payments.verify({ ... });
+*
+* // Or use events
+* revenue.on('payment.verified', (event) => { ... });
+* ```
+*/
+var Revenue = class Revenue {
+	_container;
+	_events;
+	_plugins;
+	_idempotency;
+	_circuitBreaker;
+	_options;
+	_logger;
+	_providers;
+	_config;
+	/** Monetization service - purchases, subscriptions, free items */
+	monetization;
+	/** Payment service - verify, refund, webhooks */
+	payments;
+	/** Transaction service - query, update transactions */
+	transactions;
+	/** Escrow service - hold, release, splits */
+	escrow;
+	/** Settlement service - payout tracking */
+	settlement;
+	constructor(container, events, plugins, options, providers, config) {
+		this._container = container;
+		this._events = events;
+		this._plugins = plugins;
+		this._options = options;
+		this._logger = options.logger;
+		this._providers = providers;
+		this._config = config;
+		this._idempotency = createIdempotencyManager({ ttl: options.idempotencyTtl });
+		if (options.circuitBreaker) this._circuitBreaker = createCircuitBreaker(typeof options.circuitBreaker === "boolean" ? {} : options.circuitBreaker);
+		container.singleton("events", events);
+		container.singleton("plugins", plugins);
+		container.singleton("idempotency", this._idempotency);
+		container.singleton("logger", this._logger);
+		container.singleton("retryConfig", options.retry || {});
+		container.singleton("circuitBreaker", this._circuitBreaker || null);
+		this.monetization = new MonetizationService(container);
+		this.payments = new PaymentService(container);
+		this.transactions = new TransactionService(container);
+		this.escrow = new EscrowService(container);
+		this.settlement = new SettlementService(container);
+		Object.freeze(this._providers);
+		Object.freeze(this._config);
+	}
+	/** @internal Used by RevenueBuilder — do not call directly */
+	static _fromBuilder(container, events, plugins, options, providers, config) {
+		return new Revenue(container, events, plugins, options, providers, config);
+	}
+	/**
+	* Create a new Revenue builder
+	*
+	* @example
+	* ```typescript
+	* const revenue = Revenue
+	*   .create({ defaultCurrency: 'BDT' })
+	*   .withModels({ Transaction, Subscription })
+	*   .withProvider('manual', new ManualProvider())
+	*   .build();
+	* ```
+	*/
+	static create(options = {}) {
+		return new RevenueBuilder(options);
+	}
+	/** DI container (for advanced usage) */
+	get container() {
+		return this._container;
+	}
+	/** Event bus */
+	get events() {
+		return this._events;
+	}
+	/** Registered providers (frozen) */
+	get providers() {
+		return this._providers;
+	}
+	/** Configuration (frozen) */
+	get config() {
+		return this._config;
+	}
+	/** Default currency */
+	get defaultCurrency() {
+		return this._options.defaultCurrency;
+	}
+	/** Current environment */
+	get environment() {
+		return this._options.environment;
+	}
+	/**
+	* Get a provider by name
+	*/
+	getProvider(name) {
+		const provider = this._providers[name];
+		if (!provider) throw new ConfigurationError(`Provider "${name}" not found. Available: ${Object.keys(this._providers).join(", ")}`);
+		return provider;
+	}
+	/**
+	* Get all provider names
+	*/
+	getProviderNames() {
+		return Object.keys(this._providers);
+	}
+	/**
+	* Check if provider exists
+	*/
+	hasProvider(name) {
+		return name in this._providers;
+	}
+	/**
+	* Subscribe to events
+	*
+	* @example
+	* ```typescript
+	* revenue.on('payment.verified', (event) => {
+	*   console.log('Payment:', event.transaction._id);
+	* });
+	* ```
+	*/
+	on = (event, handler) => {
+		return this._events.on(event, handler);
+	};
+	/**
+	* Subscribe once
+	*/
+	once = (event, handler) => {
+		return this._events.once(event, handler);
+	};
+	/**
+	* Unsubscribe
+	*/
+	off = (event, handler) => {
+		this._events.off(event, handler);
+	};
+	/**
+	* Emit an event
+	*/
+	emit = (event, payload) => {
+		this._events.emit(event, payload);
+	};
+	/**
+	* Execute operation with retry and idempotency
+	*/
+	async execute(operation, options = {}) {
+		const { idempotencyKey, params, useRetry = true, useCircuitBreaker = true } = options;
+		const idempotentOp = async () => {
+			if (idempotencyKey) {
+				const result = await this._idempotency.execute(idempotencyKey, params, operation);
+				if (!result.ok) throw result.error;
+				return result.value;
+			}
+			return operation();
+		};
+		const resilientOp = async () => {
+			if (useCircuitBreaker && this._circuitBreaker) return this._circuitBreaker.execute(idempotentOp);
+			return idempotentOp();
+		};
+		if (useRetry && this._options.retry) return tryCatch(() => retry(resilientOp, this._options.retry));
+		return tryCatch(resilientOp);
+	}
+	/**
+	* Create plugin context (for advanced usage)
+	*/
+	createContext(meta = {}) {
+		return {
+			events: this._events,
+			logger: this._logger,
+			storage: /* @__PURE__ */ new Map(),
+			meta: {
+				...meta,
+				requestId: nanoid(12),
+				timestamp: /* @__PURE__ */ new Date()
+			}
+		};
+	}
+	/**
+	* Destroy instance and cleanup
+	*/
+	async destroy() {
+		await this._plugins.destroy();
+		this._events.clear();
+		this._idempotency.destroy();
+	}
+};
+/**
+* Revenue Builder - Fluent configuration API
+*/
+var RevenueBuilder = class {
+	options;
+	models = null;
+	providers = {};
+	plugins = [];
+	categoryMappings = {};
+	transactionTypeMapping = {};
+	constructor(options = {}) {
+		this.options = options;
+	}
+	/**
+	* Register models (required)
+	*
+	* @example
+	* ```typescript
+	* .withModels({
+	*   Transaction: TransactionModel,
+	*   Subscription: SubscriptionModel,
+	* })
+	* ```
+	*/
+	withModels(models) {
+		this.models = models;
+		return this;
+	}
+	/**
+	* Register a single model
+	*/
+	withModel(name, model) {
+		if (!this.models) this.models = {};
+		this.models[name] = model;
+		return this;
+	}
+	/**
+	* Register a payment provider
+	*
+	* @example
+	* ```typescript
+	* .withProvider('stripe', new StripeProvider({ apiKey: '...' }))
+	* .withProvider('manual', new ManualProvider())
+	* ```
+	*/
+	withProvider(name, provider) {
+		this.providers[name] = provider;
+		return this;
+	}
+	/**
+	* Register multiple providers at once
+	*/
+	withProviders(providers) {
+		this.providers = {
+			...this.providers,
+			...providers
+		};
+		return this;
+	}
+	/**
+	* Register a plugin
+	*
+	* @example
+	* ```typescript
+	* .withPlugin(loggingPlugin())
+	* .withPlugin(auditPlugin({ store: saveToDb }))
+	* ```
+	*/
+	withPlugin(plugin) {
+		this.plugins.push(plugin);
+		return this;
+	}
+	/**
+	* Register multiple plugins
+	*/
+	withPlugins(plugins) {
+		this.plugins.push(...plugins);
+		return this;
+	}
+	/**
+	* Set retry configuration
+	*
+	* @example
+	* ```typescript
+	* .withRetry({ maxAttempts: 5, baseDelay: 2000 })
+	* ```
+	*/
+	withRetry(config) {
+		this.options.retry = config;
+		return this;
+	}
+	/**
+	* Enable circuit breaker
+	*/
+	withCircuitBreaker(enabled = true) {
+		this.options.circuitBreaker = enabled;
+		return this;
+	}
+	/**
+	* Set custom logger
+	*/
+	withLogger(logger) {
+		this.options.logger = logger;
+		return this;
+	}
+	/**
+	* Set environment
+	*/
+	forEnvironment(env) {
+		this.options.environment = env;
+		return this;
+	}
+	/**
+	* Enable debug mode
+	*/
+	withDebug(enabled = true) {
+		this.options.debug = enabled;
+		return this;
+	}
+	/**
+	* Set commission rate as decimal (0-1, e.g., 0.10 for 10%)
+	*
+	* @param rate - Commission rate (0-1 decimal format)
+	* @param gatewayFeeRate - Gateway fee rate (0-1 decimal format, e.g., 0.029 for 2.9%)
+	*
+	* @example
+	* ```typescript
+	* .withCommission(0.10, 0.029) // 10% commission + 2.9% gateway fee
+	* ```
+	*/
+	withCommission(rate, gatewayFeeRate = 0) {
+		this.options.commissionRate = rate;
+		this.options.gatewayFeeRate = gatewayFeeRate;
+		return this;
+	}
+	/**
+	* Set category mappings (entity → category)
+	*
+	* @example
+	* ```typescript
+	* .withCategoryMappings({
+	*   PlatformSubscription: 'platform_subscription',
+	*   CourseEnrollment: 'course_enrollment',
+	*   ProductOrder: 'product_order',
+	* })
+	* ```
+	*/
+	withCategoryMappings(mappings) {
+		this.categoryMappings = {
+			...this.categoryMappings,
+			...mappings
+		};
+		return this;
+	}
+	/**
+	* Set transaction flow mapping by category or monetization type
+	*
+	* @example
+	* ```typescript
+	* .withTransactionTypeMapping({
+	*   platform_subscription: 'inflow',
+	*   subscription: 'inflow',
+	*   refund: 'outflow',
+	* })
+	* ```
+	*/
+	withTransactionTypeMapping(mapping) {
+		this.transactionTypeMapping = {
+			...this.transactionTypeMapping,
+			...mapping
+		};
+		return this;
+	}
+	/**
+	* Build the Revenue instance
+	*/
+	build() {
+		if (!this.models) throw new ConfigurationError("Models are required. Use .withModels({ Transaction, Subscription })");
+		if (!this.models.Transaction) throw new ConfigurationError("Transaction model is required in models configuration");
+		if (Object.keys(this.providers).length === 0) throw new ConfigurationError("At least one provider is required. Use .withProvider(name, provider)");
+		const container = new Container();
+		const resolvedOptions = {
+			defaultCurrency: this.options.defaultCurrency ?? "USD",
+			environment: this.options.environment ?? "development",
+			debug: this.options.debug ?? false,
+			retry: this.options.retry ?? { maxAttempts: 3 },
+			idempotencyTtl: this.options.idempotencyTtl ?? 1440 * 60 * 1e3,
+			circuitBreaker: this.options.circuitBreaker ?? false,
+			logger: this.options.logger ?? {
+				debug: (msg, data) => this.options.debug && console.debug(`[Revenue] ${msg}`, data ?? ""),
+				info: (msg, data) => console.info(`[Revenue] ${msg}`, data ?? ""),
+				warn: (msg, data) => console.warn(`[Revenue] ${msg}`, data ?? ""),
+				error: (msg, data) => console.error(`[Revenue] ${msg}`, data ?? "")
+			},
+			commissionRate: this.options.commissionRate ?? 0,
+			gatewayFeeRate: this.options.gatewayFeeRate ?? 0
+		};
+		const config = {
+			...resolveConfig(resolvedOptions),
+			targetModels: [],
+			categoryMappings: this.categoryMappings,
+			transactionTypeMapping: this.transactionTypeMapping
+		};
+		for (const provider of Object.values(this.providers)) if (typeof provider.setDefaultCurrency === "function") provider.setDefaultCurrency(resolvedOptions.defaultCurrency);
+		container.singleton("models", this.models);
+		container.singleton("providers", this.providers);
+		container.singleton("config", config);
+		const events = createEventBus();
+		const pluginManager = new PluginManager();
+		for (const plugin of this.plugins) pluginManager.register(plugin);
+		const revenue = Revenue._fromBuilder(container, events, pluginManager, resolvedOptions, this.providers, config);
+		const ctx = revenue.createContext();
+		pluginManager.init(ctx).catch((err) => {
+			resolvedOptions.logger.error("Failed to initialize plugins", err);
+		});
+		return revenue;
+	}
+};
+/**
+* Create Revenue instance (shorthand)
+*
+* @example
+* ```typescript
+* const revenue = createRevenue({
+*   models: { Transaction, Subscription },
+*   providers: { manual: new ManualProvider() },
+* });
+* ```
+*/
+function createRevenue(config) {
+	let builder = Revenue.create(config.options);
+	builder = builder.withModels(config.models);
+	builder = builder.withProviders(config.providers);
+	if (config.plugins) builder = builder.withPlugins(config.plugins);
+	return builder.build();
+}
+
+//#endregion
+export { Container as i, RevenueBuilder as n, createRevenue as r, Revenue as t };