@classytic/revenue 1.1.4 → 2.0.1

package/dist/reconciliation/index.d.mts

@@ -1,193 +0,0 @@
-import { B as TransactionDocument, h as MongooseModel } from "../index-Dsp7H5Wb.mjs";
-
-//#region src/shared/types/reconciliation.d.ts
-/**
- * Gateway Settlement Record
- * Data from payment gateway's settlement report (Stripe, PayPal, etc.)
- */
-interface GatewaySettlement {
-  /** Settlement ID from gateway */
-  settlementId: string;
-  /** Transaction/payment ID from gateway */
-  transactionId: string;
-  /** Amount settled */
-  amount: number;
-  /** Currency */
-  currency: string;
-  /** When funds were settled */
-  settledAt: Date;
-  /** Gateway fee deducted */
-  gatewayFee?: number;
-  /** Net amount received (amount - gatewayFee) */
-  netAmount?: number;
-  /** Payment status in gateway */
-  status?: string;
-  /** Additional gateway metadata */
-  metadata?: Record<string, unknown>;
-}
-/**
- * Reconciliation Options
- * Configuration for reconciliation process
- */
-interface ReconciliationOptions {
-  /** Filter by organization */
-  organizationId?: string;
-  /** Filter by payment gateway */
-  gateway?: string;
-  /** Start date for reconciliation period */
-  startDate?: Date;
-  /** End date for reconciliation period */
-  endDate?: Date;
-  /** Automatically match by transactionId */
-  autoMatch?: boolean;
-  /** Tolerance for amount mismatches (in cents) */
-  amountTolerance?: number;
-}
-/**
- * Reconciliation Report
- * Result of reconciling gateway settlements with database transactions
- */
-interface ReconciliationReport {
-  /** Summary statistics */
-  summary: {
-    /** Total transactions in gateway report */totalGatewayTransactions: number; /** Total transactions in database */
-    totalDbTransactions: number; /** Number of matched transactions */
-    matched: number; /** Number missing in database */
-    missing: number; /** Number extra in database (not in gateway) */
-    extra: number; /** Number with amount mismatches */
-    amountMismatches: number; /** Total amount difference across all mismatches */
-    totalAmountDiff: number;
-  };
-  /** Transactions in gateway but not in database */
-  missingInDb: GatewaySettlement[];
-  /** Transactions in database but not in gateway */
-  missingInGateway: TransactionDocument[];
-  /** Transactions with amount mismatches */
-  amountMismatches: Array<{
-    transactionId: string;
-    gatewayAmount: number;
-    dbAmount: number;
-    diff: number;
-    transaction?: TransactionDocument;
-    gatewayRecord?: GatewaySettlement;
-  }>;
-  /** Successfully matched transactions */
-  matched: Array<{
-    transactionId: string;
-    amount: number;
-    transaction: TransactionDocument;
-    gatewayRecord: GatewaySettlement;
-  }>;
-  /** Reconciliation metadata */
-  metadata: {
-    reconciledAt: Date;
-    period: {
-      start?: Date;
-      end?: Date;
-    };
-    gateway?: string;
-    organizationId?: string;
-  };
-}
-/**
- * Discrepancy Type
- */
-type DiscrepancyType = 'missing_in_db' | 'missing_in_gateway' | 'amount_mismatch' | 'status_mismatch';
-/**
- * Discrepancy Record
- * Individual reconciliation discrepancy
- */
-interface Discrepancy {
-  type: DiscrepancyType;
-  transactionId: string;
-  severity: 'low' | 'medium' | 'high';
-  description: string;
-  gatewayData?: GatewaySettlement;
-  dbData?: TransactionDocument;
-  diff?: number;
-}
-//#endregion
-//#region src/reconciliation/reconciler.d.ts
-/**
- * Reconcile gateway settlements with database transactions
- *
- * Compares payment gateway's settlement report with your database to identify:
- * - Transactions in gateway but missing in DB
- * - Transactions in DB but missing in gateway
- * - Amount mismatches between gateway and DB
- *
- * @param gatewaySettlements - Settlement data from payment gateway
- * @param TransactionModel - Mongoose Transaction model
- * @param options - Reconciliation options
- * @returns Reconciliation report with findings
- *
- * @example
- * ```typescript
- * import { reconcileSettlement } from '@classytic/revenue/reconciliation';
- *
- * // Get Stripe settlements for January
- * const stripeSettlements = await stripe.balanceTransactions.list({
- *   created: { gte: jan1, lte: jan31 },
- * });
- *
- * // Reconcile with database
- * const report = await reconcileSettlement(
- *   stripeSettlements.data.map(s => ({
- *     settlementId: s.id,
- *     transactionId: s.source,
- *     amount: s.amount,
- *     currency: s.currency,
- *     settledAt: new Date(s.created * 1000),
- *     gatewayFee: s.fee,
- *     netAmount: s.net,
- *   })),
- *   TransactionModel,
- *   { gateway: 'stripe', startDate: jan1, endDate: jan31 }
- * );
- *
- * console.log(report.summary);
- * // { matched: 1245, missing: 2, extra: 1, amountMismatches: 3 }
- * ```
- */
-declare function reconcileSettlement(gatewaySettlements: GatewaySettlement[], TransactionModel: MongooseModel<TransactionDocument>, options?: ReconciliationOptions): Promise<ReconciliationReport>;
-/**
- * Find transactions missing in database
- *
- * @param organizationId - Organization to check
- * @param dateRange - Date range to search
- * @param gateway - Payment gateway
- * @param TransactionModel - Mongoose Transaction model
- * @returns Missing transaction IDs
- */
-declare function findMissingTransactions(_organizationId: string, _dateRange: {
-  start: Date;
-  end: Date;
-}, _gateway: string, _TransactionModel: MongooseModel<TransactionDocument>): Promise<{
-  inGateway: string[];
-  inDb: string[];
-}>;
-/**
- * Find amount mismatches between gateway and database
- *
- * @param organizationId - Organization to check
- * @param dateRange - Date range to search
- * @param threshold - Amount difference threshold (cents)
- * @param TransactionModel - Mongoose Transaction model
- * @returns Array of mismatches
- */
-declare function findAmountMismatches(_organizationId: string, _dateRange: {
-  start: Date;
-  end: Date;
-}, _threshold: number | undefined, _TransactionModel: MongooseModel<TransactionDocument>): Promise<Array<{
-  transactionId: string;
-  diff: number;
-}>>;
-/**
- * Generate reconciliation discrepancies
- *
- * @param report - Reconciliation report
- * @returns Array of discrepancies sorted by severity
- */
-declare function generateDiscrepancies(report: ReconciliationReport): Discrepancy[];
-//#endregion
-export { type Discrepancy, type DiscrepancyType, type GatewaySettlement, type ReconciliationOptions, type ReconciliationReport, findAmountMismatches, findMissingTransactions, generateDiscrepancies, reconcileSettlement };

package/dist/reconciliation/index.mjs

@@ -1,192 +0,0 @@
-//#region src/reconciliation/reconciler.ts
-/**
-* Reconcile gateway settlements with database transactions
-*
-* Compares payment gateway's settlement report with your database to identify:
-* - Transactions in gateway but missing in DB
-* - Transactions in DB but missing in gateway
-* - Amount mismatches between gateway and DB
-*
-* @param gatewaySettlements - Settlement data from payment gateway
-* @param TransactionModel - Mongoose Transaction model
-* @param options - Reconciliation options
-* @returns Reconciliation report with findings
-*
-* @example
-* ```typescript
-* import { reconcileSettlement } from '@classytic/revenue/reconciliation';
-*
-* // Get Stripe settlements for January
-* const stripeSettlements = await stripe.balanceTransactions.list({
-*   created: { gte: jan1, lte: jan31 },
-* });
-*
-* // Reconcile with database
-* const report = await reconcileSettlement(
-*   stripeSettlements.data.map(s => ({
-*     settlementId: s.id,
-*     transactionId: s.source,
-*     amount: s.amount,
-*     currency: s.currency,
-*     settledAt: new Date(s.created * 1000),
-*     gatewayFee: s.fee,
-*     netAmount: s.net,
-*   })),
-*   TransactionModel,
-*   { gateway: 'stripe', startDate: jan1, endDate: jan31 }
-* );
-*
-* console.log(report.summary);
-* // { matched: 1245, missing: 2, extra: 1, amountMismatches: 3 }
-* ```
-*/
-async function reconcileSettlement(gatewaySettlements, TransactionModel, options = {}) {
-	const { organizationId, gateway, startDate, endDate, autoMatch: _autoMatch = true, amountTolerance = 1 } = options;
-	const query = {};
-	if (organizationId) query.organizationId = organizationId;
-	if (gateway) query["gateway.type"] = gateway;
-	if (startDate || endDate) {
-		query.createdAt = {};
-		if (startDate) query.createdAt.$gte = startDate;
-		if (endDate) query.createdAt.$lte = endDate;
-	}
-	const dbTransactions = await TransactionModel.find(query);
-	const gatewayMap = /* @__PURE__ */ new Map();
-	const dbMap = /* @__PURE__ */ new Map();
-	for (const settlement of gatewaySettlements) gatewayMap.set(settlement.transactionId, settlement);
-	for (const transaction of dbTransactions) {
-		const key = transaction.gateway?.paymentIntentId || transaction._id.toString();
-		dbMap.set(key, transaction);
-	}
-	const report = {
-		summary: {
-			totalGatewayTransactions: gatewaySettlements.length,
-			totalDbTransactions: dbTransactions.length,
-			matched: 0,
-			missing: 0,
-			extra: 0,
-			amountMismatches: 0,
-			totalAmountDiff: 0
-		},
-		missingInDb: [],
-		missingInGateway: [],
-		amountMismatches: [],
-		matched: [],
-		metadata: {
-			reconciledAt: /* @__PURE__ */ new Date(),
-			period: {
-				start: startDate,
-				end: endDate
-			},
-			gateway,
-			organizationId
-		}
-	};
-	for (const [gatewayTxId, gatewaySettlement] of gatewayMap.entries()) {
-		const dbTransaction = dbMap.get(gatewayTxId);
-		if (!dbTransaction) {
-			report.missingInDb.push(gatewaySettlement);
-			report.summary.missing++;
-		} else {
-			const amountDiff = Math.abs(dbTransaction.amount - gatewaySettlement.amount);
-			if (amountDiff > amountTolerance) {
-				report.amountMismatches.push({
-					transactionId: gatewayTxId,
-					gatewayAmount: gatewaySettlement.amount,
-					dbAmount: dbTransaction.amount,
-					diff: dbTransaction.amount - gatewaySettlement.amount,
-					transaction: dbTransaction,
-					gatewayRecord: gatewaySettlement
-				});
-				report.summary.amountMismatches++;
-				report.summary.totalAmountDiff += amountDiff;
-			} else {
-				report.matched.push({
-					transactionId: gatewayTxId,
-					amount: dbTransaction.amount,
-					transaction: dbTransaction,
-					gatewayRecord: gatewaySettlement
-				});
-				report.summary.matched++;
-			}
-			dbMap.delete(gatewayTxId);
-		}
-	}
-	for (const [_, transaction] of dbMap.entries()) {
-		report.missingInGateway.push(transaction);
-		report.summary.extra++;
-	}
-	return report;
-}
-/**
-* Find transactions missing in database
-*
-* @param organizationId - Organization to check
-* @param dateRange - Date range to search
-* @param gateway - Payment gateway
-* @param TransactionModel - Mongoose Transaction model
-* @returns Missing transaction IDs
-*/
-async function findMissingTransactions(_organizationId, _dateRange, _gateway, _TransactionModel) {
-	return {
-		inGateway: [],
-		inDb: []
-	};
-}
-/**
-* Find amount mismatches between gateway and database
-*
-* @param organizationId - Organization to check
-* @param dateRange - Date range to search
-* @param threshold - Amount difference threshold (cents)
-* @param TransactionModel - Mongoose Transaction model
-* @returns Array of mismatches
-*/
-async function findAmountMismatches(_organizationId, _dateRange, _threshold = 1, _TransactionModel) {
-	return [];
-}
-/**
-* Generate reconciliation discrepancies
-*
-* @param report - Reconciliation report
-* @returns Array of discrepancies sorted by severity
-*/
-function generateDiscrepancies(report) {
-	const discrepancies = [];
-	for (const gateway of report.missingInDb) discrepancies.push({
-		type: "missing_in_db",
-		transactionId: gateway.transactionId,
-		severity: "high",
-		description: `Transaction ${gateway.transactionId} found in gateway (${gateway.amount} ${gateway.currency}) but missing in database`,
-		gatewayData: gateway
-	});
-	for (const transaction of report.missingInGateway) discrepancies.push({
-		type: "missing_in_gateway",
-		transactionId: transaction._id.toString(),
-		severity: "medium",
-		description: `Transaction ${transaction._id} found in database but not in gateway report`,
-		dbData: transaction
-	});
-	for (const mismatch of report.amountMismatches) {
-		const severity = Math.abs(mismatch.diff) > 1e3 ? "high" : Math.abs(mismatch.diff) > 100 ? "medium" : "low";
-		discrepancies.push({
-			type: "amount_mismatch",
-			transactionId: mismatch.transactionId,
-			severity,
-			description: `Amount mismatch: Gateway shows ${mismatch.gatewayAmount}, DB shows ${mismatch.dbAmount} (diff: ${mismatch.diff})`,
-			gatewayData: mismatch.gatewayRecord,
-			dbData: mismatch.transaction,
-			diff: mismatch.diff
-		});
-	}
-	const severityOrder = {
-		high: 0,
-		medium: 1,
-		low: 2
-	};
-	discrepancies.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
-	return discrepancies;
-}
-
-//#endregion
-export { findAmountMismatches, findMissingTransactions, generateDiscrepancies, reconcileSettlement };

package/dist/retry-HHCOXYdn.d.mts

@@ -1,186 +0,0 @@
-//#region src/core/result.d.ts
-/**
- * Result Type - Rust-inspired error handling
- * @classytic/revenue
- *
- * No more try/catch - explicit, type-safe error handling
- * Inspired by: Rust Result<T, E>, neverthrow, Effect-TS
- */
-/**
- * Success result
- */
-interface Ok<T> {
-  readonly ok: true;
-  readonly value: T;
-  readonly error?: never;
-}
-/**
- * Error result
- */
-interface Err<E> {
-  readonly ok: false;
-  readonly error: E;
-  readonly value?: never;
-}
-/**
- * Result type - either Ok<T> or Err<E>
- */
-type Result<T, E = Error> = Ok<T> | Err<E>;
-/**
- * Create a success result
- */
-declare function ok<T>(value: T): Ok<T>;
-/**
- * Create an error result
- */
-declare function err<E>(error: E): Err<E>;
-/**
- * Check if result is Ok
- */
-declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
-/**
- * Check if result is Err
- */
-declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
-/**
- * Unwrap a result, throwing if it's an error
- * Use sparingly - prefer pattern matching
- */
-declare function unwrap<T, E>(result: Result<T, E>): T;
-/**
- * Unwrap a result with a default value
- */
-declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
-/**
- * Map over a successful result
- */
-declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
-/**
- * Map over an error result
- */
-declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
-/**
- * Flat map (chain) results
- */
-declare function flatMap<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
-/**
- * Try-catch wrapper that returns Result
- */
-declare function tryCatch<T, E = Error>(fn: () => Promise<T>, mapError?: (e: unknown) => E): Promise<Result<T, E>>;
-/**
- * Synchronous try-catch wrapper
- */
-declare function tryCatchSync<T, E = Error>(fn: () => T, mapError?: (e: unknown) => E): Result<T, E>;
-/**
- * Combine multiple results - all must succeed
- */
-declare function all<T extends readonly Result<unknown, unknown>[]>(results: T): Result<{ [K in keyof T]: T[K] extends Result<infer U, unknown> ? U : never }, T[number] extends Result<unknown, infer E> ? E : never>;
-/**
- * Pattern match on result
- */
-declare function match<T, E, U>(result: Result<T, E>, handlers: {
-  ok: (value: T) => U;
-  err: (error: E) => U;
-}): U;
-declare const Result: {
-  readonly ok: typeof ok;
-  readonly err: typeof err;
-  readonly isOk: typeof isOk;
-  readonly isErr: typeof isErr;
-  readonly unwrap: typeof unwrap;
-  readonly unwrapOr: typeof unwrapOr;
-  readonly map: typeof map;
-  readonly mapErr: typeof mapErr;
-  readonly flatMap: typeof flatMap;
-  readonly tryCatch: typeof tryCatch;
-  readonly tryCatchSync: typeof tryCatchSync;
-  readonly all: typeof all;
-  readonly match: typeof match;
-};
-//#endregion
-//#region src/shared/utils/resilience/retry.d.ts
-interface RetryConfig {
-  /** Maximum number of retry attempts (default: 3) */
-  maxAttempts: number;
-  /** Base delay in milliseconds (default: 1000) */
-  baseDelay: number;
-  /** Maximum delay in milliseconds (default: 30000) */
-  maxDelay: number;
-  /** Backoff multiplier (default: 2) */
-  backoffMultiplier: number;
-  /** Jitter factor 0-1 (default: 0.1) */
-  jitter: number;
-  /** Which errors are retryable */
-  retryIf?: (error: unknown) => boolean;
-  /** Callback on each retry */
-  onRetry?: (error: unknown, attempt: number, delay: number) => void;
-}
-/**
- * Execute operation with retry logic
- */
-declare function retry<T>(operation: () => Promise<T>, config?: Partial<RetryConfig>): Promise<T>;
-type CircuitState = 'closed' | 'open' | 'half-open';
-interface CircuitBreakerConfig {
-  /** Number of failures before opening circuit */
-  failureThreshold: number;
-  /** Time in ms to wait before half-opening */
-  resetTimeout: number;
-  /** Number of successes in half-open to close circuit */
-  successThreshold: number;
-  /** Monitor window in ms */
-  monitorWindow: number;
-}
-/**
- * Circuit breaker for preventing cascade failures
- * Inspired by: Netflix Hystrix, resilience4j
- */
-declare class CircuitBreaker {
-  private state;
-  private failures;
-  private successes;
-  private lastFailure?;
-  private config;
-  constructor(config?: Partial<CircuitBreakerConfig>);
-  /**
-   * Execute operation through circuit breaker
-   */
-  execute<T>(operation: () => Promise<T>): Promise<T>;
-  /**
-   * Execute with Result type
-   */
-  executeWithResult<T>(operation: () => Promise<T>): Promise<Result<T, CircuitOpenError | Error>>;
-  private onSuccess;
-  private onFailure;
-  private shouldAttemptReset;
-  private cleanOldFailures;
-  private reset;
-  /**
-   * Get current circuit state
-   */
-  getState(): CircuitState;
-  /**
-   * Manually reset circuit
-   */
-  forceReset(): void;
-  /**
-   * Get circuit statistics
-   */
-  getStats(): {
-    state: CircuitState;
-    failures: number;
-    successes: number;
-    lastFailure?: Date;
-  };
-}
-/**
- * Error thrown when circuit is open
- */
-declare class CircuitOpenError extends Error {
-  constructor(message: string);
-}
-/**
- * Create a circuit breaker
- */
-declare function createCircuitBreaker(config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
-//#endregion
-export { unwrapOr as S, match as _, createCircuitBreaker as a, tryCatchSync as b, Ok as c, err as d, flatMap as f, mapErr as g, map as h, RetryConfig as i, Result as l, isOk as m, CircuitBreakerConfig as n, retry as o, isErr as p, CircuitState as r, Err as s, CircuitBreaker as t, all as u, ok as v, unwrap as x, tryCatch as y };