Node.js Examples

Complete Node.js/JavaScript integration examples.

Installation

npm install @auxvault/node

Setup

const AuxVault = require('@auxvault/node');

const client = new AuxVault({
  apiKey: process.env.LUQRA_API_KEY,
  tenantId: process.env.LUQRA_TENANT_ID,
  environment: process.env.NODE_ENV === 'production' ? 'production' : 'sandbox'
});

Process Payment

async function processPayment(paymentData) {
  try {
    const transaction = await client.transactions.create({
      type: 'sale',
      amount: paymentData.amount,
      currency: 'USD',
      card: {
        number: paymentData.cardNumber,
        expiryMonth: paymentData.expiryMonth,
        expiryYear: paymentData.expiryYear,
        cvv: paymentData.cvv
      },
      billing: {
        firstName: paymentData.firstName,
        lastName: paymentData.lastName,
        address: paymentData.address,
        city: paymentData.city,
        state: paymentData.state,
        zip: paymentData.zip,
        country: 'US'
      },
      customer: {
        email: paymentData.email
      }
    });
    
    console.log('Transaction approved:', transaction.id);
    return { success: true, transaction };
    
  } catch (error) {
    console.error('Payment failed:', error.message);
    return { success: false, error: error.message };
  }
}

Process Refund

async function processRefund(transactionId, amount) {
  try {
    const refund = await client.transactions.refund(transactionId, {
      amount: amount,
      reason: 'Customer request'
    });
    
    console.log('Refund processed:', refund.id);
    return { success: true, refund };
    
  } catch (error) {
    console.error('Refund failed:', error.message);
    return { success: false, error: error.message };
  }
}

Create Subscription

async function createSubscription(customerData) {
  try {
    const subscription = await client.recurring.create({
      customerId: customerData.customerId,
      planId: 'plan_monthly_99',
      amount: 99.00,
      frequency: 'monthly',
      startDate: new Date().toISOString().split('T')[0],
      card: {
        number: customerData.cardNumber,
        expiryMonth: customerData.expiryMonth,
        expiryYear: customerData.expiryYear,
        cvv: customerData.cvv
      }
    });
    
    console.log('Subscription created:', subscription.id);
    return { success: true, subscription };
    
  } catch (error) {
    console.error('Subscription failed:', error.message);
    return { success: false, error: error.message };
  }
}

Webhook Handler (Express)

const express = require('express');
const app = express();

app.use(express.json());

app.post('/webhooks/auxvault', async (req, res) => {
  const signature = req.headers['x-luqra-signature'];
  
  // Verify signature
  const isValid = client.webhooks.verify(
    JSON.stringify(req.body),
    signature
  );
  
  if (!isValid) {
    return res.status(401).send('Invalid signature');
  }
  
  const event = req.body;
  
  // Handle event
  switch (event.type) {
    case 'transaction.approved':
      await handleTransactionApproved(event.data);
      break;
      
    case 'transaction.declined':
      await handleTransactionDeclined(event.data);
      break;
      
    case 'subscription.payment_failed':
      await handleSubscriptionFailed(event.data);
      break;
  }
  
  res.sendStatus(200);
});

async function handleTransactionApproved(data) {
  console.log('Transaction approved:', data.transactionId);
  // Update order status, send receipt, etc.
}

async function handleTransactionDeclined(data) {
  console.log('Transaction declined:', data.transactionId);
  // Notify customer, log for review, etc.
}

async function handleSubscriptionFailed(data) {
  console.log('Subscription payment failed:', data.subscriptionId);
  // Send payment update reminder, etc.
}

app.listen(3000, () => {
  console.log('Webhook server running on port 3000');
});

Error Handling

async function processPaymentWithErrorHandling(paymentData) {
  try {
    const transaction = await client.transactions.create(paymentData);
    return { success: true, transaction };
    
  } catch (error) {
    // Handle specific errors
    switch (error.code) {
      case 'TRANSACTION_DECLINED':
        return {
          success: false,
          message: 'Payment declined. Please try a different card.'
        };
        
      case 'INSUFFICIENT_FUNDS':
        return {
          success: false,
          message: 'Insufficient funds. Please try a different card.'
        };
        
      case 'INVALID_CARD':
        return {
          success: false,
          message: 'Invalid card details. Please check and try again.'
        };
        
      case 'RATE_LIMIT_EXCEEDED':
        // Retry with backoff
        await sleep(5000);
        return processPaymentWithErrorHandling(paymentData);
        
      default:
        return {
          success: false,
          message: 'Payment processing error. Please try again.'
        };
    }
  }
}

Retry with Exponential Backoff

async function retryWithBackoff(fn, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (attempt === maxRetries || !isRetryable(error)) {
        throw error;
      }
      
      const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
      console.log(`Retry attempt ${attempt} after ${delay}ms`);
      await sleep(delay);
    }
  }
}

function isRetryable(error) {
  return [
    'RATE_LIMIT_EXCEEDED',
    'GATEWAY_TIMEOUT',
    'SERVICE_UNAVAILABLE'
  ].includes(error.code);
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Usage
const transaction = await retryWithBackoff(() =>
  client.transactions.create(paymentData)
);

Next: PHP examples →