doripe

A lightweight utility for managing payment transactions with automatic unique ID generation and MongoDB storage.

Installation

npm install doripe

Usage

In Node.js

const { createTransaction, PaymentMethod, TransactionType } = require('doripe');

// Or with ES6 imports
// import { createTransaction, PaymentMethod, TransactionType } from 'doripe';

const transactionData = {
  orderId: 'order_123',
  merchantId: 'merchant_456',
  amount: 100.50,
  paymentMethod: PaymentMethod.CREDIT_CARD,
  currency: 'USD',
  type: TransactionType.PAYMENT
};

try {
  const transaction = createTransaction(transactionData);
  console.log('Transaction created:', transaction);
} catch (error) {
  console.error('Error creating transaction:', error.message);
}

With MongoDB Storage

To use the MongoDB storage features, you need to set environment variables:

# Set your MongoDB connection string
export DORIPE_MONGODB_URI="mongodb+srv://username:[email protected]/database"
export DORIPE_DATABASE_NAME="doripe"
export DORIPE_COLLECTION_NAME="transactions"

Then use the MongoDB functions:

const { createAndSaveTransaction, findTransactionByPaymentId, connectToDatabase } = require('doripe');

async function example() {
  try {
    // Connect to database
    await connectToDatabase();
    
    // Create and save a transaction
    const transactionData = {
      orderId: 'order_123',
      merchantId: 'merchant_456',
      amount: 100.50,
      paymentMethod: PaymentMethod.CREDIT_CARD
    };
    
    const savedTransaction = await createAndSaveTransaction(transactionData);
    console.log('Transaction saved:', savedTransaction);
    
    // Find transaction by payment ID
    const foundTransaction = await findTransactionByPaymentId(savedTransaction.paymentId);
    console.log('Transaction found:', foundTransaction);
  } catch (error) {
    console.error('Error:', error.message);
  }
}

In React

Installation

npm install doripe

Basic Usage

import React, { useState } from 'react';
import { createTransaction, PaymentMethod } from 'doripe';

function PaymentForm() {
  const [transactionResult, setTransactionResult] = useState(null);
  const [error, setError] = useState(null);

  const handleCreateTransaction = () => {
    const transactionData = {
      orderId: 'order_123',
      merchantId: 'merchant_456',
      amount: 100.50,
      paymentMethod: PaymentMethod.CREDIT_CARD
    };

    try {
      const transaction = createTransaction(transactionData);
      setTransactionResult(transaction);
      setError(null);
    } catch (err) {
      setError(err.message);
      setTransactionResult(null);
    }
  };

  return (
    <div>
      <button onClick={handleCreateTransaction}>Create Transaction</button>
      {transactionResult && (
        <div>
          <h3>Transaction Created:</h3>
          <pre>{JSON.stringify(transactionResult, null, 2)}</pre>
        </div>
      )}
      {error && (
        <div style={{ color: 'red' }}>
          <h3>Error:</h3>
          <p>{error}</p>
        </div>
      )}
    </div>
  );
}

export default PaymentForm;

Resolving Webpack Issues in React

If you encounter webpack errors related to Node.js core modules like net, crypto, fs, etc., it's because the MongoDB driver attempts to load these modules even though they're not used in browser environments.

This package is designed to work in both Node.js and browser environments. The MongoDB functionality is automatically disabled in browser environments, but webpack may still try to resolve these dependencies.

To resolve these issues, you have two options:

1. Option 1: Configure Webpack Fallbacks (Recommended for Create React App with craco or similar tools)

Add these fallbacks to your webpack configuration:

module.exports = {
  // ... other config
  resolve: {
    fallback: {
      "fs": false,
      "path": false,
      "crypto": false,
      "net": false,
      "tls": false,
      "zlib": false,
      "http": false,
      "https": false,
      "stream": false,
      "process": false,
      "os": false,
      "url": false,
      "util": false,
      "dns": false,
      "child_process": false,
      "timers": false
    }
  }
};

2. Option 2: Use Environment Variables (Recommended for Create React App)

If you're using Create React App, you can add this to your .env file:

GENERATE_SOURCEMAP=false

This will prevent some of the warnings, though the underlying issue remains.

3. Option 3: Dynamic Imports (For advanced users)

Import only the functions you need that don't require MongoDB:

// This will work without any webpack configuration
import { createTransaction, generateUniquePaymentId, PaymentMethod } from 'doripe';

The package automatically detects the environment and only loads MongoDB dependencies in Node.js environments.

API

Functions

generateUniquePaymentId()

Generates a unique payment ID with the format pay_[24-character UUID].

generateUniquePaymentIntentId()

Generates a unique payment intent ID with the format pi_[24-character UUID].

createTransaction(data: TransactionData)

Creates a transaction object with unique IDs. Validates required fields and returns a CreatedTransaction object.

Required fields:

• orderId: string
• merchantId: string
• amount: number (must be positive)
• paymentMethod: PaymentMethod

createAndSaveTransaction(data: TransactionData)

Creates a transaction and saves it to MongoDB. Returns a StoredTransaction object.

findTransactionByPaymentId(paymentId: string)

Finds a transaction by its payment ID in MongoDB.

findTransactionsByMerchantId(merchantId: string)

Finds all transactions for a specific merchant ID.

findTransactionsByOrderId(orderId: string)

Finds all transactions for a specific order ID.

updateTransaction(paymentId: string, updates: Partial<TransactionData>)

Updates a transaction in MongoDB.

deleteTransaction(paymentId: string)

Deletes a transaction from MongoDB.

getAllTransactions(filter?: Partial<TransactionData>, limit?: number, skip?: number)

Gets all transactions with optional filtering, limit, and skip parameters.

connectToDatabase(uri?: string, dbName?: string)

Connects to MongoDB. Optionally accepts a URI and database name.

closeDatabase()

Closes the MongoDB connection.

Enums

PaymentMethod

• CREDIT_CARD
• DEBIT_CARD
• PAYPAL
• BANK_TRANSFER
• APPLE_PAY
• GOOGLE_PAY

TransactionType

• PAYMENT
• REFUND
• SUBSCRIPTION

Interfaces

TransactionData

Represents the data needed to create a transaction.

CreatedTransaction

Extends TransactionData with generated paymentId and paymentIntentId.

StoredTransaction

Extends CreatedTransaction with MongoDB _id field.