@reevit/node 0.3.0

package/dist/client.d.ts

@@ -0,0 +1,72 @@
+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 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 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 ReevitAPIClientConfig {
+    publicKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+export declare class ReevitAPIClient {
+    private publicKey;
+    private baseUrl;
+    private timeout;
+    constructor(config: ReevitAPIClientConfig);
+    private request;
+    createPaymentIntent(config: ReevitCheckoutConfig, method: PaymentMethod, country?: string): Promise<{
+        data?: PaymentIntentResponse;
+        error?: PaymentError;
+    }>;
+    getPaymentIntent(paymentId: string): Promise<{
+        data?: PaymentDetailResponse;
+        error?: PaymentError;
+    }>;
+    confirmPayment(paymentId: string): Promise<{
+        data?: PaymentDetailResponse;
+        error?: PaymentError;
+    }>;
+    cancelPaymentIntent(paymentId: string): Promise<{
+        data?: PaymentDetailResponse;
+        error?: PaymentError;
+    }>;
+    private mapPaymentMethod;
+}
+export declare function createReevitClient(config: ReevitAPIClientConfig): ReevitAPIClient;
+export {};

package/dist/client.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReevitAPIClient = void 0;
+exports.createReevitClient = createReevitClient;
+const axios_1 = __importDefault(require("axios"));
+// 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) {
+    return publicKey.startsWith('pk_test_') || publicKey.startsWith('pk_sandbox_');
+}
+function createPaymentError(response, errorData) {
+    return {
+        code: errorData.code || 'api_error',
+        message: errorData.message || 'An unexpected error occurred',
+        details: {
+            httpStatus: response.status,
+            ...errorData.details,
+        },
+    };
+}
+class ReevitAPIClient {
+    constructor(config) {
+        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;
+    }
+    async request(method, path, body) {
+        try {
+            const response = await (0, axios_1.default)({
+                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) {
+            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, method, country = 'GH') {
+        var _a;
+        const request = {
+            amount: config.amount,
+            currency: config.currency,
+            method: this.mapPaymentMethod(method),
+            country,
+            customer_id: (_a = config.metadata) === null || _a === void 0 ? void 0 : _a.customerId,
+            metadata: config.metadata,
+        };
+        return this.request('POST', '/v1/payments/intents', request);
+    }
+    async getPaymentIntent(paymentId) {
+        return this.request('GET', `/v1/payments/${paymentId}`);
+    }
+    async confirmPayment(paymentId) {
+        return this.request('POST', `/v1/payments/${paymentId}/confirm`);
+    }
+    async cancelPaymentIntent(paymentId) {
+        return this.request('POST', `/v1/payments/${paymentId}/cancel`);
+    }
+    mapPaymentMethod(method) {
+        switch (method) {
+            case 'card':
+                return 'card';
+            case 'mobile_money':
+                return 'mobile_money';
+            case 'bank_transfer':
+                return 'bank_transfer';
+            default:
+                return method;
+        }
+    }
+}
+exports.ReevitAPIClient = ReevitAPIClient;
+function createReevitClient(config) {
+    return new ReevitAPIClient(config);
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { PaymentsService } from './services/payments';
+import { ConnectionsService } from './services/connections';
+import { SubscriptionsService } from './services/subscriptions';
+import { FraudService } from './services/fraud';
+export declare class Reevit {
+    private client;
+    payments: PaymentsService;
+    connections: ConnectionsService;
+    subscriptions: SubscriptionsService;
+    fraud: FraudService;
+    constructor(apiKey: string, orgId: string, baseUrl?: string);
+}
+export * from './types';

package/dist/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reevit = void 0;
+const axios_1 = __importDefault(require("axios"));
+const payments_1 = require("./services/payments");
+const connections_1 = require("./services/connections");
+const subscriptions_1 = require("./services/subscriptions");
+const fraud_1 = require("./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) {
+    return apiKey.startsWith('sk_test_') || apiKey.startsWith('sk_sandbox_');
+}
+class Reevit {
+    constructor(apiKey, orgId, baseUrl) {
+        // 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_1.default.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 payments_1.PaymentsService(this.client);
+        this.connections = new connections_1.ConnectionsService(this.client);
+        this.subscriptions = new subscriptions_1.SubscriptionsService(this.client);
+        this.fraud = new fraud_1.FraudService(this.client);
+    }
+}
+exports.Reevit = Reevit;
+__exportStar(require("./types"), exports);

package/dist/services/connections.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance } from 'axios';
+import { Connection, ConnectionRequest } from '../types';
+export declare class ConnectionsService {
+    private client;
+    constructor(client: AxiosInstance);
+    create(data: ConnectionRequest): Promise<Connection>;
+    list(): Promise<Connection[]>;
+    test(data: ConnectionRequest): Promise<boolean>;
+}

package/dist/services/connections.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionsService = void 0;
+class ConnectionsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(data) {
+        const response = await this.client.post('/v1/connections', data);
+        return response.data;
+    }
+    async list() {
+        const response = await this.client.get('/v1/connections');
+        return response.data;
+    }
+    async test(data) {
+        const response = await this.client.post('/v1/connections/test', data);
+        return response.data.success;
+    }
+}
+exports.ConnectionsService = ConnectionsService;

package/dist/services/fraud.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+import { FraudPolicy } from '../types';
+export declare class FraudService {
+    private client;
+    constructor(client: AxiosInstance);
+    get(): Promise<FraudPolicy>;
+    update(policy: FraudPolicy): Promise<FraudPolicy>;
+}

package/dist/services/fraud.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FraudService = void 0;
+class FraudService {
+    constructor(client) {
+        this.client = client;
+    }
+    async get() {
+        const response = await this.client.get('/v1/policies/fraud');
+        return response.data;
+    }
+    async update(policy) {
+        const response = await this.client.post('/v1/policies/fraud', policy);
+        return response.data;
+    }
+}
+exports.FraudService = FraudService;

package/dist/services/payments.d.ts

@@ -0,0 +1,10 @@
+import { AxiosInstance } from 'axios';
+import { Payment, PaymentIntentRequest, PaymentSummary, Refund } from '../types';
+export declare class PaymentsService {
+    private client;
+    constructor(client: AxiosInstance);
+    createIntent(data: PaymentIntentRequest): Promise<Payment>;
+    list(limit?: number, offset?: number): Promise<PaymentSummary[]>;
+    get(id: string): Promise<Payment>;
+    refund(id: string, amount?: number, reason?: string): Promise<Refund>;
+}

package/dist/services/payments.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentsService = void 0;
+class PaymentsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async createIntent(data) {
+        const response = await this.client.post('/v1/payments/intents', data);
+        return response.data;
+    }
+    async list(limit = 50, offset = 0) {
+        const response = await this.client.get('/v1/payments', {
+            params: { limit, offset }
+        });
+        return response.data;
+    }
+    async get(id) {
+        const response = await this.client.get(`/v1/payments/${id}`);
+        return response.data;
+    }
+    async refund(id, amount, reason) {
+        const response = await this.client.post(`/v1/payments/${id}/refund`, {
+            amount,
+            reason
+        });
+        return response.data;
+    }
+}
+exports.PaymentsService = PaymentsService;

package/dist/services/subscriptions.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+import { Subscription, SubscriptionRequest } from '../types';
+export declare class SubscriptionsService {
+    private client;
+    constructor(client: AxiosInstance);
+    create(data: SubscriptionRequest): Promise<Subscription>;
+    list(): Promise<Subscription[]>;
+}

package/dist/services/subscriptions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionsService = void 0;
+class SubscriptionsService {
+    constructor(client) {
+        this.client = client;
+    }
+    async create(data) {
+        const response = await this.client.post('/v1/subscriptions', data);
+        return response.data;
+    }
+    async list() {
+        const response = await this.client.get('/v1/subscriptions');
+        return response.data;
+    }
+}
+exports.SubscriptionsService = SubscriptionsService;

package/dist/types.d.ts

@@ -0,0 +1,118 @@
+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/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@reevit/node",
+  "version": "0.3.0",
+  "description": "Reevit Node.js SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "reevit",
+    "payments",
+    "africa",
+    "orchestration"
+  ],
+  "author": "Reevit",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^18.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.4.0"
+  }
+}