@classytic/revenue 0.0.2 → 0.0.22

package/utils/category-resolver.js

@@ -0,0 +1,74 @@
+/**
+ * Category Resolver Utility
+ * @classytic/revenue
+ *
+ * Resolves transaction category based on referenceModel and categoryMappings
+ */
+
+import { LIBRARY_CATEGORIES } from '../enums/transaction.enums.js';
+
+/**
+ * Resolve category for a transaction based on entity and monetizationType
+ *
+ * Resolution Logic:
+ * 1. If categoryMappings[entity] exists → use it
+ * 2. Otherwise → fall back to default library category
+ *
+ * @param {String} entity - The logical entity/identifier (e.g., 'Order', 'PlatformSubscription', 'Membership')
+ *                          NOTE: This is NOT a database model name - it's just a logical identifier
+ * @param {String} monetizationType - The monetization type ('subscription', 'purchase', 'free')
+ * @param {Object} categoryMappings - User-defined category mappings from config
+ * @returns {String} Category name for the transaction
+ *
+ * @example
+ * // With mapping defined
+ * resolveCategory('Order', 'subscription', { Order: 'order_subscription' })
+ * // Returns: 'order_subscription'
+ *
+ * @example
+ * // Without mapping, falls back to library default
+ * resolveCategory('Order', 'subscription', {})
+ * // Returns: 'subscription'
+ *
+ * @example
+ * // Different entities with different mappings
+ * const mappings = {
+ *   Order: 'order_subscription',
+ *   PlatformSubscription: 'platform_subscription',
+ *   TenantUpgrade: 'tenant_upgrade',
+ *   Membership: 'gym_membership',
+ *   Enrollment: 'course_enrollment',
+ * };
+ * resolveCategory('PlatformSubscription', 'subscription', mappings)
+ * // Returns: 'platform_subscription'
+ */
+export function resolveCategory(entity, monetizationType, categoryMappings = {}) {
+  // If user has defined a custom mapping for this entity, use it
+  if (entity && categoryMappings[entity]) {
+    return categoryMappings[entity];
+  }
+
+  // Otherwise, fall back to library default based on monetization type
+  switch (monetizationType) {
+    case 'subscription':
+      return LIBRARY_CATEGORIES.SUBSCRIPTION; // 'subscription'
+    case 'purchase':
+      return LIBRARY_CATEGORIES.PURCHASE; // 'purchase'
+    default:
+      return LIBRARY_CATEGORIES.SUBSCRIPTION; // Default to subscription
+  }
+}
+
+/**
+ * Validate that a category is defined in user's Transaction model enum
+ * This is informational - actual validation happens at Mongoose schema level
+ *
+ * @param {String} category - Category to validate
+ * @param {Array<String>} allowedCategories - List of allowed categories
+ * @returns {Boolean} Whether category is valid
+ */
+export function isCategoryValid(category, allowedCategories = []) {
+  return allowedCategories.includes(category);
+}
+
+export default resolveCategory;

package/utils/logger.js

@@ -6,7 +6,7 @@
  *
  * Usage:
  * ```javascript
- * import { setLogger } from '@fitverse/monetization';
+ * import { setLogger } from '@classytic/revenue';
  *
  * // Optional: Use your own logger
  * setLogger(myPinoLogger);

package/providers/manual.js

@@ -1,171 +0,0 @@
-/**
- * Manual Payment Provider
- * @classytic/revenue
- *
- * Built-in provider for manual payment verification
- * Perfect for: Cash, bank transfers, mobile money without API
- */
-
-import { PaymentProvider, PaymentIntent, PaymentResult, RefundResult } from './base.js';
-import { nanoid } from 'nanoid';
-
-export class ManualProvider extends PaymentProvider {
-  constructor(config = {}) {
-    super(config);
-    this.name = 'manual';
-  }
-
-  /**
-   * Create manual payment intent
-   * Returns instructions for manual payment
-   */
-  async createIntent(params) {
-    const intentId = `manual_${nanoid(16)}`;
-
-    return new PaymentIntent({
-      id: intentId,
-      provider: 'manual',
-      status: 'pending',
-      amount: params.amount,
-      currency: params.currency || 'BDT',
-      metadata: params.metadata || {},
-      instructions: this._getPaymentInstructions(params),
-      raw: params,
-    });
-  }
-
-  /**
-   * Verify manual payment
-   * Note: This is called by admin after checking payment proof
-   */
-  async verifyPayment(intentId) {
-    // Manual verification doesn't auto-verify
-    // Admin must explicitly call payment verification endpoint
-    return new PaymentResult({
-      id: intentId,
-      provider: 'manual',
-      status: 'requires_manual_approval',
-      amount: 0, // Amount will be filled by transaction
-      currency: 'BDT',
-      metadata: {
-        message: 'Manual payment requires admin verification',
-      },
-    });
-  }
-
-  /**
-   * Get payment status
-   */
-  async getStatus(intentId) {
-    return this.verifyPayment(intentId);
-  }
-
-  /**
-   * Refund manual payment
-   */
-  async refund(paymentId, amount, options = {}) {
-    const refundId = `refund_${nanoid(16)}`;
-
-    return new RefundResult({
-      id: refundId,
-      provider: 'manual',
-      status: 'succeeded', // Manual refunds are immediately marked as succeeded
-      amount: amount,
-      currency: options.currency || 'BDT',
-      refundedAt: new Date(),
-      reason: options.reason || 'Manual refund',
-      metadata: options.metadata || {},
-    });
-  }
-
-  /**
-   * Manual provider doesn't support webhooks
-   */
-  async handleWebhook(payload, headers) {
-    throw new Error('Manual provider does not support webhooks');
-  }
-
-  /**
-   * Get provider capabilities
-   */
-  getCapabilities() {
-    return {
-      supportsWebhooks: false,
-      supportsRefunds: true,
-      supportsPartialRefunds: true,
-      requiresManualVerification: true,
-      supportedMethods: ['cash', 'bank', 'bkash', 'nagad', 'rocket', 'manual'],
-    };
-  }
-
-  /**
-   * Generate payment instructions for customer
-   * @private
-   */
-  _getPaymentInstructions(params) {
-    const { organizationPaymentInfo, method } = params.metadata || {};
-
-    if (!organizationPaymentInfo) {
-      return 'Please contact the organization for payment details.';
-    }
-
-    const instructions = [];
-
-    // Add method-specific instructions
-    switch (method) {
-      case 'bkash':
-      case 'nagad':
-      case 'rocket':
-        if (organizationPaymentInfo[`${method}Number`]) {
-          instructions.push(
-            `Send money via ${method.toUpperCase()}:`,
-            `Number: ${organizationPaymentInfo[`${method}Number`]}`,
-            `Amount: ${params.amount} ${params.currency || 'BDT'}`,
-            ``,
-            `After payment, provide the transaction ID/reference number.`
-          );
-        }
-        break;
-
-      case 'bank':
-        if (organizationPaymentInfo.bankAccount) {
-          const bank = organizationPaymentInfo.bankAccount;
-          instructions.push(
-            `Bank Transfer Details:`,
-            `Bank: ${bank.bankName || 'N/A'}`,
-            `Account: ${bank.accountNumber || 'N/A'}`,
-            `Account Name: ${bank.accountName || 'N/A'}`,
-            `Amount: ${params.amount} ${params.currency || 'BDT'}`,
-            ``,
-            `After payment, upload proof and provide reference.`
-          );
-        }
-        break;
-
-      case 'cash':
-        instructions.push(
-          `Cash Payment:`,
-          `Amount: ${params.amount} ${params.currency || 'BDT'}`,
-          ``,
-          `Pay at the organization's office and get a receipt.`
-        );
-        break;
-
-      default:
-        instructions.push(
-          `Payment Amount: ${params.amount} ${params.currency || 'BDT'}`,
-          ``,
-          `Contact the organization for payment details.`
-        );
-    }
-
-    // Add custom instructions if provided
-    if (organizationPaymentInfo.paymentInstructions) {
-      instructions.push(``, `Additional Instructions:`, organizationPaymentInfo.paymentInstructions);
-    }
-
-    return instructions.join('\n');
-  }
-}
-
-export default ManualProvider;