@classytic/revenue 1.1.2 → 1.1.4

package/dist/reconciliation/index.js

@@ -1,140 +0,0 @@
-// @classytic/revenue - Enterprise Revenue Management System
-
-// src/reconciliation/reconciler.ts
-async function reconcileSettlement(gatewaySettlements, TransactionModel, options = {}) {
-  const {
-    organizationId,
-    gateway,
-    startDate,
-    endDate,
-    autoMatch: _autoMatch = true,
-    amountTolerance = 1
-    // 1 cent tolerance
-  } = 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;
-}
-async function findMissingTransactions(_organizationId, _dateRange, _gateway, _TransactionModel) {
-  return {
-    inGateway: [],
-    // Transactions in gateway but not in DB
-    inDb: []
-    // Transactions in DB but not confirmed by gateway
-  };
-}
-async function findAmountMismatches(_organizationId, _dateRange, _threshold = 1, _TransactionModel) {
-  const mismatches = [];
-  return mismatches;
-}
-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;
-}
-
-export { findAmountMismatches, findMissingTransactions, generateDiscrepancies, reconcileSettlement };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/reconciliation/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/reconciliation/reconciler.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Reconciliation Utilities\n * @classytic/revenue\n *\n * Compare gateway settlement reports with database transactions\n * Find missing transactions, amount mismatches, and discrepancies\n */\n\nimport type {\n  GatewaySettlement,\n  ReconciliationOptions,\n  ReconciliationReport,\n  Discrepancy,\n} from '../shared/types/reconciliation.js';\nimport type { TransactionDocument, MongooseModel } from '../shared/types/index.js';\n\n/**\n * Reconcile gateway settlements with database transactions\n *\n * Compares payment gateway's settlement report with your database to identify:\n * - Transactions in gateway but missing in DB\n * - Transactions in DB but missing in gateway\n * - Amount mismatches between gateway and DB\n *\n * @param gatewaySettlements - Settlement data from payment gateway\n * @param TransactionModel - Mongoose Transaction model\n * @param options - Reconciliation options\n * @returns Reconciliation report with findings\n *\n * @example\n * ```typescript\n * import { reconcileSettlement } from '@classytic/revenue/reconciliation';\n *\n * // Get Stripe settlements for January\n * const stripeSettlements = await stripe.balanceTransactions.list({\n *   created: { gte: jan1, lte: jan31 },\n * });\n *\n * // Reconcile with database\n * const report = await reconcileSettlement(\n *   stripeSettlements.data.map(s => ({\n *     settlementId: s.id,\n *     transactionId: s.source,\n *     amount: s.amount,\n *     currency: s.currency,\n *     settledAt: new Date(s.created * 1000),\n *     gatewayFee: s.fee,\n *     netAmount: s.net,\n *   })),\n *   TransactionModel,\n *   { gateway: 'stripe', startDate: jan1, endDate: jan31 }\n * );\n *\n * console.log(report.summary);\n * // { matched: 1245, missing: 2, extra: 1, amountMismatches: 3 }\n * ```\n */\nexport async function reconcileSettlement(\n  gatewaySettlements: GatewaySettlement[],\n  TransactionModel: MongooseModel<TransactionDocument>,\n  options: ReconciliationOptions = {}\n): Promise<ReconciliationReport> {\n  const {\n    organizationId,\n    gateway,\n    startDate,\n    endDate,\n    autoMatch: _autoMatch = true,\n    amountTolerance = 1, // 1 cent tolerance\n  } = options;\n\n  // Build query for DB transactions\n  const query: Record<string, unknown> = {};\n  if (organizationId) query.organizationId = organizationId;\n  if (gateway) query['gateway.type'] = gateway;\n\n  if (startDate || endDate) {\n    query.createdAt = {};\n    if (startDate) (query.createdAt as Record<string, unknown>).$gte = startDate;\n    if (endDate) (query.createdAt as Record<string, unknown>).$lte = endDate;\n  }\n\n  // Get database transactions\n  const dbTransactions = await (TransactionModel as unknown as {\n    find(filter: object): Promise<TransactionDocument[]>;\n  }).find(query);\n\n  // Create lookup maps\n  const gatewayMap = new Map<string, GatewaySettlement>();\n  const dbMap = new Map<string, TransactionDocument>();\n\n  for (const settlement of gatewaySettlements) {\n    gatewayMap.set(settlement.transactionId, settlement);\n  }\n\n  for (const transaction of dbTransactions) {\n    // Use gateway.paymentIntentId as the key for matching\n    const key = (transaction.gateway?.paymentIntentId || transaction._id.toString());\n    dbMap.set(key, transaction);\n  }\n\n  // Initialize report\n  const report: ReconciliationReport = {\n    summary: {\n      totalGatewayTransactions: gatewaySettlements.length,\n      totalDbTransactions: dbTransactions.length,\n      matched: 0,\n      missing: 0,\n      extra: 0,\n      amountMismatches: 0,\n      totalAmountDiff: 0,\n    },\n    missingInDb: [],\n    missingInGateway: [],\n    amountMismatches: [],\n    matched: [],\n    metadata: {\n      reconciledAt: new Date(),\n      period: { start: startDate, end: endDate },\n      gateway,\n      organizationId,\n    },\n  };\n\n  // Find matches and mismatches\n  for (const [gatewayTxId, gatewaySettlement] of gatewayMap.entries()) {\n    const dbTransaction = dbMap.get(gatewayTxId);\n\n    if (!dbTransaction) {\n      // Missing in DB\n      report.missingInDb.push(gatewaySettlement);\n      report.summary.missing++;\n    } else {\n      // Found - check amount\n      const amountDiff = Math.abs(dbTransaction.amount - gatewaySettlement.amount);\n\n      if (amountDiff > amountTolerance) {\n        // Amount mismatch\n        report.amountMismatches.push({\n          transactionId: gatewayTxId,\n          gatewayAmount: gatewaySettlement.amount,\n          dbAmount: dbTransaction.amount,\n          diff: dbTransaction.amount - gatewaySettlement.amount,\n          transaction: dbTransaction,\n          gatewayRecord: gatewaySettlement,\n        });\n        report.summary.amountMismatches++;\n        report.summary.totalAmountDiff += amountDiff;\n      } else {\n        // Matched!\n        report.matched.push({\n          transactionId: gatewayTxId,\n          amount: dbTransaction.amount,\n          transaction: dbTransaction,\n          gatewayRecord: gatewaySettlement,\n        });\n        report.summary.matched++;\n      }\n\n      // Mark as processed\n      dbMap.delete(gatewayTxId);\n    }\n  }\n\n  // Remaining DB transactions = extra (not in gateway)\n  for (const [_, transaction] of dbMap.entries()) {\n    report.missingInGateway.push(transaction);\n    report.summary.extra++;\n  }\n\n  return report;\n}\n\n/**\n * Find transactions missing in database\n *\n * @param organizationId - Organization to check\n * @param dateRange - Date range to search\n * @param gateway - Payment gateway\n * @param TransactionModel - Mongoose Transaction model\n * @returns Missing transaction IDs\n */\nexport async function findMissingTransactions(\n  _organizationId: string,\n  _dateRange: { start: Date; end: Date },\n  _gateway: string,\n  _TransactionModel: MongooseModel<TransactionDocument>\n): Promise<{ inGateway: string[]; inDb: string[] }> {\n  // This is a simplified version - in production, you'd fetch from gateway API\n  // For now, return structure for apps to implement\n  return {\n    inGateway: [], // Transactions in gateway but not in DB\n    inDb: [],      // Transactions in DB but not confirmed by gateway\n  };\n}\n\n/**\n * Find amount mismatches between gateway and database\n *\n * @param organizationId - Organization to check\n * @param dateRange - Date range to search\n * @param threshold - Amount difference threshold (cents)\n * @param TransactionModel - Mongoose Transaction model\n * @returns Array of mismatches\n */\nexport async function findAmountMismatches(\n  _organizationId: string,\n  _dateRange: { start: Date; end: Date },\n  _threshold: number = 1,\n  _TransactionModel: MongooseModel<TransactionDocument>\n): Promise<Array<{ transactionId: string; diff: number }>> {\n  // This is a stub function for apps to implement\n  // In production, query transactions and compare with gateway data\n\n  const mismatches: Array<{ transactionId: string; diff: number }> = [];\n\n  return mismatches;\n}\n\n/**\n * Generate reconciliation discrepancies\n *\n * @param report - Reconciliation report\n * @returns Array of discrepancies sorted by severity\n */\nexport function generateDiscrepancies(report: ReconciliationReport): Discrepancy[] {\n  const discrepancies: Discrepancy[] = [];\n\n  // Missing in DB (HIGH severity)\n  for (const gateway of report.missingInDb) {\n    discrepancies.push({\n      type: 'missing_in_db',\n      transactionId: gateway.transactionId,\n      severity: 'high',\n      description: `Transaction ${gateway.transactionId} found in gateway (${gateway.amount} ${gateway.currency}) but missing in database`,\n      gatewayData: gateway,\n    });\n  }\n\n  // Missing in gateway (MEDIUM severity)\n  for (const transaction of report.missingInGateway) {\n    discrepancies.push({\n      type: 'missing_in_gateway',\n      transactionId: transaction._id.toString(),\n      severity: 'medium',\n      description: `Transaction ${transaction._id} found in database but not in gateway report`,\n      dbData: transaction,\n    });\n  }\n\n  // Amount mismatches (severity based on amount)\n  for (const mismatch of report.amountMismatches) {\n    const severity: 'low' | 'medium' | 'high' = Math.abs(mismatch.diff) > 1000 ? 'high' : Math.abs(mismatch.diff) > 100 ? 'medium' : 'low';\n\n    discrepancies.push({\n      type: 'amount_mismatch',\n      transactionId: mismatch.transactionId,\n      severity,\n      description: `Amount mismatch: Gateway shows ${mismatch.gatewayAmount}, DB shows ${mismatch.dbAmount} (diff: ${mismatch.diff})`,\n      gatewayData: mismatch.gatewayRecord,\n      dbData: mismatch.transaction,\n      diff: mismatch.diff,\n    });\n  }\n\n  // Sort by severity\n  const severityOrder = { high: 0, medium: 1, low: 2 };\n  discrepancies.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);\n\n  return discrepancies;\n}\n"]}

package/dist/retry-D4hFUwVk.d.ts

@@ -1,194 +0,0 @@
-/**
- * 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;
-}
-/**
- * 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;
-/**
- * Result type - either Ok<T> or Err<E>
- */
-type Result<T, E = Error> = Ok<T> | Err<E>;
-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;
-};
-
-/**
- * Retry Utilities
- * @classytic/revenue
- *
- * Exponential backoff with jitter for resilient operations
- * Inspired by: AWS SDK retry, Netflix Hystrix, resilience4j
- */
-
-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;
-
-export { CircuitBreaker as C, type Err as E, type Ok as O, Result as R, isErr as a, unwrapOr as b, mapErr as c, tryCatchSync as d, err as e, flatMap as f, all as g, match as h, isOk as i, createCircuitBreaker as j, type RetryConfig as k, type CircuitBreakerConfig as l, map as m, type CircuitState as n, ok as o, retry as r, tryCatch as t, unwrap as u };