@reevit/node 0.3.0

package/src/client.ts

@@ -0,0 +1,202 @@
+import axios from 'axios';
+
+// Types
+
+type PaymentMethod = 'card' | 'mobile_money' | 'bank_transfer';
+
+interface PaymentError {
+  code: string;
+  message: string;
+  details?: any;
+}
+
+interface ReevitCheckoutConfig {
+  amount: number;
+  currency: string;
+  metadata?: Record<string, unknown>;
+}
+
+interface CreatePaymentIntentRequest {
+  amount: number;
+  currency: string;
+  method: string;
+  country: string;
+  customer_id?: string;
+  metadata?: Record<string, unknown>;
+  description?: string;
+  policy?: {
+    prefer?: string[];
+    max_amount?: number;
+    blocked_bins?: string[];
+    allowed_bins?: string[];
+    velocity_max_per_minute?: number;
+  };
+}
+
+interface PaymentIntentResponse {
+  id: string;
+  connection_id: string;
+  provider: string;
+  status: string;
+  client_secret: string;
+  amount: number;
+  currency: string;
+  fee_amount: number;
+  fee_currency: string;
+  net_amount: number;
+}
+
+interface ConfirmPaymentRequest {
+  provider_ref_id: string;
+  provider_data?: Record<string, unknown>;
+}
+
+interface PaymentDetailResponse {
+  id: string;
+  connection_id: string;
+  provider: string;
+  method: string;
+  status: string;
+  amount: number;
+  currency: string;
+  fee_amount: number;
+  fee_currency: string;
+  net_amount: number;
+  customer_id?: string;
+  client_secret: string;
+  provider_ref_id?: string;
+  metadata?: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+}
+
+interface APIErrorResponse {
+  code: string;
+  message: string;
+  details?: Record<string, string>;
+}
+
+interface ReevitAPIClientConfig {
+  publicKey: string;
+  baseUrl?: string;
+  timeout?: number;
+}
+
+// Constants
+
+const API_BASE_URL_PRODUCTION = 'https://api.reevit.io';
+const API_BASE_URL_SANDBOX = 'https://sandbox-api.reevit.io';
+const DEFAULT_TIMEOUT = 30000;
+
+function isSandboxKey(publicKey: string): boolean {
+  return publicKey.startsWith('pk_test_') || publicKey.startsWith('pk_sandbox_');
+}
+
+function createPaymentError(response: any, errorData: APIErrorResponse): PaymentError {
+  return {
+    code: errorData.code || 'api_error',
+    message: errorData.message || 'An unexpected error occurred',
+    details: {
+      httpStatus: response.status,
+      ...errorData.details,
+    },
+  };
+}
+
+export class ReevitAPIClient {
+  private publicKey: string;
+  private baseUrl: string;
+  private timeout: number;
+
+  constructor(config: ReevitAPIClientConfig) {
+    this.publicKey = config.publicKey;
+    this.baseUrl = config.baseUrl || (isSandboxKey(config.publicKey) ? API_BASE_URL_SANDBOX : API_BASE_URL_PRODUCTION);
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+
+  private async request<T>(method: string, path: string, body?: any): Promise<{ data?: T; error?: PaymentError }> {
+    try {
+      const response = await axios({
+        method,
+        url: `${this.baseUrl}${path}`,
+        data: body,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.publicKey}`,
+          'X-Reevit-Client': '@reevit/node',
+          'X-Reevit-Client-Version': '0.3.0',
+        },
+        timeout: this.timeout,
+      });
+      return { data: response.data };
+    } catch (error: any) {
+      if (error.response) {
+        return {
+          error: createPaymentError(error.response, error.response.data),
+        };
+      } else if (error.code === 'ECONNABORTED') {
+        return {
+          error: {
+            code: 'request_timeout',
+            message: 'The request timed out. Please try again.',
+          },
+        };
+      } else if (error.message.includes('Network Error') || error.code === 'ENOTFOUND') {
+        return {
+          error: {
+            code: 'network_error',
+            message: 'Unable to connect to Reevit. Please check your internet connection.',
+          },
+        };
+      } else {
+        return {
+          error: {
+            code: 'unknown_error',
+            message: 'An unexpected error occurred. Please try again.',
+          },
+        };
+      }
+    }
+  }
+
+  async createPaymentIntent(config: ReevitCheckoutConfig, method: PaymentMethod, country = 'GH'): Promise<{ data?: PaymentIntentResponse; error?: PaymentError }> {
+    const request: CreatePaymentIntentRequest = {
+      amount: config.amount,
+      currency: config.currency,
+      method: this.mapPaymentMethod(method),
+      country,
+      customer_id: config.metadata?.customerId as string | undefined,
+      metadata: config.metadata,
+    };
+    return this.request<PaymentIntentResponse>('POST', '/v1/payments/intents', request);
+  }
+
+  async getPaymentIntent(paymentId: string): Promise<{ data?: PaymentDetailResponse; error?: PaymentError }> {
+    return this.request<PaymentDetailResponse>('GET', `/v1/payments/${paymentId}`);
+  }
+
+  async confirmPayment(paymentId: string): Promise<{ data?: PaymentDetailResponse; error?: PaymentError }> {
+    return this.request<PaymentDetailResponse>('POST', `/v1/payments/${paymentId}/confirm`);
+  }
+
+  async cancelPaymentIntent(paymentId: string): Promise<{ data?: PaymentDetailResponse; error?: PaymentError }> {
+    return this.request<PaymentDetailResponse>('POST', `/v1/payments/${paymentId}/cancel`);
+  }
+
+  private mapPaymentMethod(method: PaymentMethod): string {
+    switch (method) {
+      case 'card':
+        return 'card';
+      case 'mobile_money':
+        return 'mobile_money';
+      case 'bank_transfer':
+        return 'bank_transfer';
+      default:
+        return method;
+    }
+  }
+}
+
+export function createReevitClient(config: ReevitAPIClientConfig): ReevitAPIClient {
+  return new ReevitAPIClient(config);
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+import axios, { AxiosInstance } from 'axios';
+import { PaymentsService } from './services/payments';
+import { ConnectionsService } from './services/connections';
+import { SubscriptionsService } from './services/subscriptions';
+import { FraudService } from './services/fraud';
+
+// Default API base URLs (secure HTTPS)
+const API_BASE_URL_PRODUCTION = 'https://api.reevit.io';
+const API_BASE_URL_SANDBOX = 'https://sandbox-api.reevit.io';
+
+/**
+ * Determines if an API key is for sandbox mode
+ */
+function isSandboxKey(apiKey: string): boolean {
+  return apiKey.startsWith('sk_test_') || apiKey.startsWith('sk_sandbox_');
+}
+
+export class Reevit {
+  private client: AxiosInstance;
+
+  public payments: PaymentsService;
+  public connections: ConnectionsService;
+  public subscriptions: SubscriptionsService;
+  public fraud: FraudService;
+
+  constructor(apiKey: string, orgId: string, baseUrl?: string) {
+    // Use provided baseUrl, or auto-detect based on API key prefix
+    const resolvedBaseUrl = baseUrl || (isSandboxKey(apiKey) ? API_BASE_URL_SANDBOX : API_BASE_URL_PRODUCTION);
+
+    this.client = axios.create({
+      baseURL: resolvedBaseUrl,
+      timeout: 10000,
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'reevit-node/0.1.0',
+        'X-Reevit-Key': apiKey,
+        'X-Org-Id': orgId,
+      },
+    });
+
+    this.payments = new PaymentsService(this.client);
+    this.connections = new ConnectionsService(this.client);
+    this.subscriptions = new SubscriptionsService(this.client);
+    this.fraud = new FraudService(this.client);
+  }
+}
+
+export * from './types';

package/src/services/connections.ts

@@ -0,0 +1,21 @@
+import { AxiosInstance } from 'axios';
+import { Connection, ConnectionRequest } from '../types';
+
+export class ConnectionsService {
+  constructor(private client: AxiosInstance) { }
+
+  async create(data: ConnectionRequest): Promise<Connection> {
+    const response = await this.client.post<Connection>('/v1/connections', data);
+    return response.data;
+  }
+
+  async list(): Promise<Connection[]> {
+    const response = await this.client.get<Connection[]>('/v1/connections');
+    return response.data;
+  }
+
+  async test(data: ConnectionRequest): Promise<boolean> {
+    const response = await this.client.post<{ success: boolean }>('/v1/connections/test', data);
+    return response.data.success;
+  }
+}

package/src/services/fraud.ts

@@ -0,0 +1,16 @@
+import { AxiosInstance } from 'axios';
+import { FraudPolicy } from '../types';
+
+export class FraudService {
+  constructor(private client: AxiosInstance) { }
+
+  async get(): Promise<FraudPolicy> {
+    const response = await this.client.get<FraudPolicy>('/v1/policies/fraud');
+    return response.data;
+  }
+
+  async update(policy: FraudPolicy): Promise<FraudPolicy> {
+    const response = await this.client.post<FraudPolicy>('/v1/policies/fraud', policy);
+    return response.data;
+  }
+}

package/src/services/payments.ts

@@ -0,0 +1,36 @@
+import { AxiosInstance } from 'axios';
+import {
+  Payment,
+  PaymentIntentRequest,
+  PaymentSummary,
+  Refund
+} from '../types';
+
+export class PaymentsService {
+  constructor(private client: AxiosInstance) { }
+
+  async createIntent(data: PaymentIntentRequest): Promise<Payment> {
+    const response = await this.client.post<Payment>('/v1/payments/intents', data);
+    return response.data;
+  }
+
+  async list(limit: number = 50, offset: number = 0): Promise<PaymentSummary[]> {
+    const response = await this.client.get<PaymentSummary[]>('/v1/payments', {
+      params: { limit, offset }
+    });
+    return response.data;
+  }
+
+  async get(id: string): Promise<Payment> {
+    const response = await this.client.get<Payment>(`/v1/payments/${id}`);
+    return response.data;
+  }
+
+  async refund(id: string, amount?: number, reason?: string): Promise<Refund> {
+    const response = await this.client.post<Refund>(`/v1/payments/${id}/refund`, {
+      amount,
+      reason
+    });
+    return response.data;
+  }
+}

package/src/services/subscriptions.ts

@@ -0,0 +1,16 @@
+import { AxiosInstance } from 'axios';
+import { Subscription, SubscriptionRequest } from '../types';
+
+export class SubscriptionsService {
+  constructor(private client: AxiosInstance) { }
+
+  async create(data: SubscriptionRequest): Promise<Subscription> {
+    const response = await this.client.post<Subscription>('/v1/subscriptions', data);
+    return response.data;
+  }
+
+  async list(): Promise<Subscription[]> {
+    const response = await this.client.get<Subscription[]>('/v1/subscriptions');
+    return response.data;
+  }
+}

package/src/types.ts

@@ -0,0 +1,129 @@
+export interface PaymentIntentRequest {
+  amount: number;
+  currency: string;
+  method: string;
+  country: string;
+  customer_id?: string;
+  policy?: FraudPolicyInput;
+  metadata?: Record<string, any>;
+}
+
+export interface FraudPolicyInput {
+  prefer?: string[];
+  max_amount?: number;
+  blocked_bins?: string[];
+  allowed_bins?: string[];
+  velocity_max_per_minute?: number;
+}
+
+export interface Payment {
+  id: string;
+  connection_id: string;
+  provider: string;
+  provider_ref_id: string;
+  method: string;
+  status: string;
+  amount: number;
+  currency: string;
+  fee_amount: number;
+  fee_currency: string;
+  net_amount: number;
+  customer_id: string;
+  metadata: Record<string, any>;
+  route: PaymentRouteAttempt[];
+  created_at: string;
+  updated_at: string;
+}
+
+export interface PaymentSummary {
+  id: string;
+  connection_id: string;
+  provider: string;
+  method: string;
+  status: string;
+  amount: number;
+  currency: string;
+  fee_amount: number;
+  fee_currency: string;
+  net_amount: number;
+  customer_id: string;
+  metadata: Record<string, any>;
+  created_at: string;
+}
+
+export interface PaymentRouteAttempt {
+  connection_id: string;
+  provider: string;
+  status: string;
+  error: string;
+  labels: string[];
+  routing_hints?: RoutingHints;
+}
+
+export interface RoutingHints {
+  country_preference: string[];
+  method_bias: Record<string, string>;
+  fallback_only: boolean;
+}
+
+export interface Refund {
+  id: string;
+  payment_id: string;
+  amount: number;
+  status: string;
+  reason: string;
+  created_at: string;
+}
+
+export interface ConnectionRequest {
+  provider: string;
+  mode: string;
+  credentials: Record<string, any>;
+  capabilities?: Record<string, any>;
+  routing_hints?: RoutingHints;
+  labels?: string[];
+}
+
+export interface Connection {
+  id: string;
+  provider: string;
+  mode: string;
+  status: string;
+  capabilities: Record<string, any>;
+  routing_hints: RoutingHints;
+  labels: string[];
+}
+
+export interface SubscriptionRequest {
+  customer_id: string;
+  plan_id: string;
+  amount: number;
+  currency: string;
+  method: string;
+  interval: 'monthly' | 'yearly';
+  metadata?: Record<string, any>;
+}
+
+export interface Subscription {
+  id: string;
+  org_id: string;
+  customer_id: string;
+  plan_id: string;
+  amount: number;
+  currency: string;
+  method: string;
+  interval: string;
+  status: string;
+  next_renewal_at: string;
+  metadata: Record<string, any>;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface FraudPolicy {
+  prefer: string[];
+  max_amount: number;
+  blocked_bins: string[];
+  allowed_bins: string[];
+  velocity_max_per_minute: number;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "lib": ["es2018", "dom"],
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}