@classytic/revenue 1.0.6 → 1.1.3

package/dist/infrastructure/plugins/index.d.mts

@@ -0,0 +1,239 @@
+import "../../index-Dsp7H5Wb.mjs";
+import "../../settlement.schema-D5uWB5tP.mjs";
+import "../../base-CsTlVQJe.mjs";
+import { c as definePlugin, o as RevenuePlugin } from "../../plugin-BbK0OVHy.mjs";
+import { n as TaxConfig } from "../../tax-BoCt5cEd.mjs";
+
+//#region src/infrastructure/plugins/business/logging.plugin.d.ts
+/**
+ * Logging plugin options
+ */
+interface LoggingPluginOptions {
+  /** Log level: 'debug' or 'info' */
+  level?: 'debug' | 'info';
+}
+/**
+ * Logging plugin - logs all operations
+ *
+ * Logs payment creation, verification, and refund operations
+ *
+ * @param options - Plugin options
+ * @returns Logging plugin
+ *
+ * @example
+ * ```typescript
+ * import { Revenue } from '@classytic/revenue';
+ * import { loggingPlugin } from '@classytic/revenue/plugins';
+ *
+ * const revenue = Revenue
+ *   .create()
+ *   .withPlugin(loggingPlugin({ level: 'debug' }))
+ *   .build();
+ * ```
+ */
+declare function loggingPlugin(options?: LoggingPluginOptions): RevenuePlugin;
+//#endregion
+//#region src/infrastructure/plugins/business/audit.plugin.d.ts
+/**
+ * Audit entry record
+ */
+interface AuditEntry {
+  action: string;
+  requestId: string;
+  timestamp: Date;
+  input: Record<string, unknown>;
+  output: Record<string, unknown>;
+  idempotencyKey?: string;
+}
+/**
+ * Audit plugin options
+ */
+interface AuditPluginOptions {
+  /** Custom storage function for audit entries */
+  store?: (entry: AuditEntry) => Promise<void>;
+}
+/**
+ * Audit plugin - records all operations for compliance
+ *
+ * Records payment creation, refunds, and other operations with sanitized data
+ *
+ * @param options - Plugin options
+ * @returns Audit plugin
+ *
+ * @example
+ * ```typescript
+ * import { Revenue } from '@classytic/revenue';
+ * import { auditPlugin } from '@classytic/revenue/plugins';
+ *
+ * const revenue = Revenue
+ *   .create()
+ *   .withPlugin(auditPlugin({
+ *     store: async (entry) => {
+ *       await AuditLog.create(entry);
+ *     }
+ *   }))
+ *   .build();
+ * ```
+ */
+declare function auditPlugin(options?: AuditPluginOptions): RevenuePlugin;
+//#endregion
+//#region src/infrastructure/plugins/business/metrics.plugin.d.ts
+/**
+ * Metric record
+ */
+interface Metric {
+  name: string;
+  duration: number;
+  success: boolean;
+  error?: string;
+  [key: string]: unknown;
+}
+/**
+ * Metrics plugin options
+ */
+interface MetricsPluginOptions {
+  /** Callback for each metric */
+  onMetric?: (metric: Metric) => void;
+}
+/**
+ * Metrics plugin - collects operation metrics
+ *
+ * Tracks duration and success/failure of operations
+ *
+ * @param options - Plugin options
+ * @returns Metrics plugin
+ *
+ * @example
+ * ```typescript
+ * import { Revenue } from '@classytic/revenue';
+ * import { metricsPlugin } from '@classytic/revenue/plugins';
+ *
+ * const revenue = Revenue
+ *   .create()
+ *   .withPlugin(metricsPlugin({
+ *     onMetric: (metric) => {
+ *       // Send to Datadog, Prometheus, etc.
+ *       statsd.timing(metric.name, metric.duration);
+ *       if (!metric.success) {
+ *         statsd.increment(`${metric.name}.error`);
+ *       }
+ *     }
+ *   }))
+ *   .build();
+ * ```
+ */
+declare function metricsPlugin(options?: MetricsPluginOptions): RevenuePlugin;
+//#endregion
+//#region src/infrastructure/plugins/business/tax.plugin.d.ts
+/**
+ * Tax Plugin Options
+ */
+interface TaxPluginOptions {
+  /**
+   * Function to get tax configuration for an organization
+   * Apps implement this to return jurisdiction-specific config
+   *
+   * @param orgId - Organization ID
+   * @returns Tax configuration or null if not registered
+   *
+   * @example
+   * ```typescript
+   * getTaxConfig: async (orgId) => {
+   *   const org = await Organization.findById(orgId);
+   *   if (!org) return null;
+   *
+   *   return {
+   *     isRegistered: org.country === 'AU',
+   *     defaultRate: org.country === 'AU' ? 0.10 : 0, // 10% GST in Australia
+   *     pricesIncludeTax: org.pricesIncludeTax || false,
+   *     exemptCategories: ['education', 'medical'],
+   *   };
+   * }
+   * ```
+   */
+  getTaxConfig: (orgId: string) => Promise<TaxConfig | null>;
+  /**
+   * Category mappings for resolving transaction categories
+   * Maps entity names to category strings
+   *
+   * @example
+   * ```typescript
+   * {
+   *   Order: 'order_subscription',
+   *   PlatformSubscription: 'platform_subscription',
+   *   Membership: 'gym_membership',
+   * }
+   * ```
+   */
+  categoryMappings?: Record<string, string>;
+  /**
+   * Categories that represent income (vs expense)
+   * Used to determine tax type: 'collected' vs 'paid'
+   *
+   * Default: ['subscription', 'purchase', 'course_enrollment']
+   */
+  incomeCategories?: string[];
+}
+/**
+ * Create Tax Plugin
+ *
+ * Automatically calculates and applies tax to transactions during monetization.create()
+ *
+ * @param options - Plugin options
+ * @returns Tax plugin
+ *
+ * @example
+ * ```typescript
+ * import { Revenue } from '@classytic/revenue';
+ * import { createTaxPlugin } from '@classytic/revenue/plugins';
+ *
+ * const revenue = Revenue
+ *   .create({ defaultCurrency: 'USD' })
+ *   .withModels({ Transaction, Subscription })
+ *   .withProvider('stripe', stripeProvider)
+ *   .withPlugin(createTaxPlugin({
+ *     getTaxConfig: async (orgId) => {
+ *       const org = await Organization.findById(orgId);
+ *       return {
+ *         isRegistered: true,
+ *         defaultRate: 0.15, // 15% tax
+ *         pricesIncludeTax: false,
+ *         exemptCategories: ['education'],
+ *       };
+ *     },
+ *     categoryMappings: {
+ *       Order: 'order_subscription',
+ *       Membership: 'gym_membership',
+ *     },
+ *   }))
+ *   .build();
+ *
+ * // Tax is now automatically calculated
+ * await revenue.monetization.create({
+ *   data: { organizationId: 'org_123', customerId: 'cust_456' },
+ *   planKey: 'monthly',
+ *   amount: 10000, // $100
+ *   entity: 'Order',
+ *   monetizationType: 'subscription',
+ * });
+ * // → Creates transaction with tax: {
+ * //   isApplicable: true,
+ * //   rate: 0.15,
+ * //   baseAmount: 10000,
+ * //   taxAmount: 1500,
+ * //   totalAmount: 11500,
+ * //   type: 'collected'
+ * // }
+ * ```
+ */
+declare function createTaxPlugin(options: TaxPluginOptions): RevenuePlugin;
+//#endregion
+//#region src/infrastructure/plugins/index.d.ts
+declare const _default: {
+  loggingPlugin: typeof loggingPlugin;
+  auditPlugin: typeof auditPlugin;
+  metricsPlugin: typeof metricsPlugin;
+  createTaxPlugin: typeof createTaxPlugin;
+};
+//#endregion
+export { type AuditEntry, type AuditPluginOptions, type LoggingPluginOptions, type Metric, type MetricsPluginOptions, type TaxPluginOptions, auditPlugin, createTaxPlugin, _default as default, definePlugin, loggingPlugin, metricsPlugin };

package/dist/infrastructure/plugins/index.mjs

@@ -0,0 +1,345 @@
+import { r as definePlugin } from "../../plugin-Cd_V04Em.mjs";
+import { t as resolveCategory } from "../../category-resolver-DV83N8ok.mjs";
+import { n as getTaxType, t as calculateTax } from "../../tax-EQ15DO81.mjs";
+
+//#region src/infrastructure/plugins/business/logging.plugin.ts
+/**
+* Logging Plugin
+* @classytic/revenue
+*
+* Logs all revenue operations at specified log level
+*/
+/**
+* Logging plugin - logs all operations
+*
+* Logs payment creation, verification, and refund operations
+*
+* @param options - Plugin options
+* @returns Logging plugin
+*
+* @example
+* ```typescript
+* import { Revenue } from '@classytic/revenue';
+* import { loggingPlugin } from '@classytic/revenue/plugins';
+*
+* const revenue = Revenue
+*   .create()
+*   .withPlugin(loggingPlugin({ level: 'debug' }))
+*   .build();
+* ```
+*/
+function loggingPlugin(options = {}) {
+	const level = options.level ?? "info";
+	return definePlugin({
+		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;
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/infrastructure/plugins/business/audit.plugin.ts
+/**
+* Audit Plugin
+* @classytic/revenue
+*
+* Records all operations for compliance and audit trails
+*/
+/**
+* Sanitize input by removing sensitive fields
+* @private
+*/
+function sanitizeInput(input) {
+	if (typeof input !== "object" || !input) return {};
+	const sanitized = { ...input };
+	delete sanitized.apiKey;
+	delete sanitized.secretKey;
+	delete sanitized.password;
+	return sanitized;
+}
+/**
+* Sanitize output
+* @private
+*/
+function sanitizeOutput(output) {
+	if (typeof output !== "object" || !output) return {};
+	return { ...output };
+}
+/**
+* Audit plugin - records all operations for compliance
+*
+* Records payment creation, refunds, and other operations with sanitized data
+*
+* @param options - Plugin options
+* @returns Audit plugin
+*
+* @example
+* ```typescript
+* import { Revenue } from '@classytic/revenue';
+* import { auditPlugin } from '@classytic/revenue/plugins';
+*
+* const revenue = Revenue
+*   .create()
+*   .withPlugin(auditPlugin({
+*     store: async (entry) => {
+*       await AuditLog.create(entry);
+*     }
+*   }))
+*   .build();
+* ```
+*/
+function auditPlugin(options = {}) {
+	const entries = [];
+	const store = options.store ?? (async (entry) => {
+		entries.push(entry);
+	});
+	return definePlugin({
+		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;
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/infrastructure/plugins/business/metrics.plugin.ts
+/**
+* Metrics Plugin
+* @classytic/revenue
+*
+* Collects operation metrics (duration, success/failure)
+*/
+/**
+* Metrics plugin - collects operation metrics
+*
+* Tracks duration and success/failure of operations
+*
+* @param options - Plugin options
+* @returns Metrics plugin
+*
+* @example
+* ```typescript
+* import { Revenue } from '@classytic/revenue';
+* import { metricsPlugin } from '@classytic/revenue/plugins';
+*
+* const revenue = Revenue
+*   .create()
+*   .withPlugin(metricsPlugin({
+*     onMetric: (metric) => {
+*       // Send to Datadog, Prometheus, etc.
+*       statsd.timing(metric.name, metric.duration);
+*       if (!metric.success) {
+*         statsd.increment(`${metric.name}.error`);
+*       }
+*     }
+*   }))
+*   .build();
+* ```
+*/
+function metricsPlugin(options = {}) {
+	const metrics = [];
+	const record = options.onMetric ?? ((metric) => {
+		metrics.push(metric);
+	});
+	return definePlugin({
+		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;
+			}
+		} }
+	});
+}
+
+//#endregion
+//#region src/infrastructure/plugins/business/tax.plugin.ts
+/**
+* Tax Plugin
+* @classytic/revenue
+*
+* Automatic tax calculation for transactions
+* Integrates with monetization.create.before hook
+*/
+/**
+* Create Tax Plugin
+*
+* Automatically calculates and applies tax to transactions during monetization.create()
+*
+* @param options - Plugin options
+* @returns Tax plugin
+*
+* @example
+* ```typescript
+* import { Revenue } from '@classytic/revenue';
+* import { createTaxPlugin } from '@classytic/revenue/plugins';
+*
+* const revenue = Revenue
+*   .create({ defaultCurrency: 'USD' })
+*   .withModels({ Transaction, Subscription })
+*   .withProvider('stripe', stripeProvider)
+*   .withPlugin(createTaxPlugin({
+*     getTaxConfig: async (orgId) => {
+*       const org = await Organization.findById(orgId);
+*       return {
+*         isRegistered: true,
+*         defaultRate: 0.15, // 15% tax
+*         pricesIncludeTax: false,
+*         exemptCategories: ['education'],
+*       };
+*     },
+*     categoryMappings: {
+*       Order: 'order_subscription',
+*       Membership: 'gym_membership',
+*     },
+*   }))
+*   .build();
+*
+* // Tax is now automatically calculated
+* await revenue.monetization.create({
+*   data: { organizationId: 'org_123', customerId: 'cust_456' },
+*   planKey: 'monthly',
+*   amount: 10000, // $100
+*   entity: 'Order',
+*   monetizationType: 'subscription',
+* });
+* // → Creates transaction with tax: {
+* //   isApplicable: true,
+* //   rate: 0.15,
+* //   baseAmount: 10000,
+* //   taxAmount: 1500,
+* //   totalAmount: 11500,
+* //   type: 'collected'
+* // }
+* ```
+*/
+function createTaxPlugin(options) {
+	const { getTaxConfig, categoryMappings = {}, incomeCategories = [
+		"subscription",
+		"purchase",
+		"course_enrollment",
+		"product_order"
+	] } = options;
+	return definePlugin({
+		name: "tax",
+		version: "1.0.0",
+		description: "Automatic tax calculation for transactions",
+		hooks: { "monetization.create.before": async (ctx, input, next) => {
+			const orgId = input.data.organizationId;
+			if (!orgId) {
+				ctx.logger.debug("Tax plugin: No organizationId in input.data, skipping tax calculation");
+				return next();
+			}
+			try {
+				const config = await getTaxConfig(orgId);
+				if (!config) {
+					ctx.logger.debug("Tax plugin: No tax config for org", { orgId });
+					return next();
+				}
+				const category = resolveCategory(input.entity, input.monetizationType || "subscription", categoryMappings);
+				const transactionFlow = incomeCategories.includes(category) ? "inflow" : "outflow";
+				const taxCalc = calculateTax(input.amount, category, config);
+				const taxType = getTaxType(transactionFlow, category, config.exemptCategories);
+				input.tax = {
+					...taxCalc,
+					type: taxType
+				};
+				ctx.logger.debug("Tax plugin: Tax calculated", {
+					orgId,
+					category,
+					entity: input.entity,
+					monetizationType: input.monetizationType,
+					taxAmount: taxCalc.taxAmount,
+					type: taxType
+				});
+			} catch (error) {
+				ctx.logger.error("Tax plugin: Failed to calculate tax", {
+					orgId,
+					error: error.message
+				});
+			}
+			return next();
+		} }
+	});
+}
+
+//#endregion
+//#region src/infrastructure/plugins/index.ts
+var plugins_default = {
+	loggingPlugin,
+	auditPlugin,
+	metricsPlugin,
+	createTaxPlugin
+};
+
+//#endregion
+export { auditPlugin, createTaxPlugin, plugins_default as default, definePlugin, loggingPlugin, metricsPlugin };