Integrate OwnPay with JavaScript and TypeScript Apps

// ownpay-client.ts

export interface CreatePaymentRequest {
  amount: string;
  currency: string;
  callback_url?: string;
  redirect_url?: string;
  cancel_url?: string;
  customer_email?: string;
  customer_name?: string;
  customer_phone?: string;
  reference?: string;
  gateway?: string;
  metadata?: Record<string, unknown>;
}

export interface PaymentIntent {
  payment_id: string;
  token: string;
  checkout_url: string;
  status: string;
}

export interface Transaction {
  id: number;
  trx_id: string;
  gateway_trx_id: string;
  amount: string;
  currency: string;
  fee: string;
  net_amount?: string;
  status: string;
  gateway: string;
  method: string;
  reference: string;
  created_at: string;
  completed_at: string | null;
}

export interface Refund {
  id: number;
  uuid: string;
  transaction_id: number;
  trx_id: string;
  gateway_trx_id: string;
  amount: string;
  reason: string;
  status: string;
  processed_at: string;
  created_at: string;
}

export class OwnPayError extends Error {
  constructor(
    public readonly statusCode: number,
    message: string,
    public readonly errors: Array<{ code: string; message: string; field: string }> = [],
    public readonly requestId: string = ''
  ) {
    super(`[${statusCode}] ${message} (request_id=${requestId})`);
    this.name = 'OwnPayError';
  }
}

export class OwnPayClient {
  private readonly baseUrl: string;
  private readonly apiKey: string;

  constructor(
    baseUrl = process.env.OWNPAY_BASE_URL!,
    apiKey  = process.env.OWNPAY_API_KEY!
  ) {
    this.baseUrl = baseUrl;
    this.apiKey  = apiKey;
  }

  private async request<T>(
    method: string,
    path: string,
    body?: unknown
  ): Promise<T> {
    const resp = await fetch(`${this.baseUrl}${path}`, {
      method,
      headers: {
        Authorization:  `Bearer ${this.apiKey}`,
        Accept:         'application/json',
        ...(body ? { 'Content-Type': 'application/json' } : {}),
      },
      ...(body ? { body: JSON.stringify(body) } : {}),
    });

    const json = await resp.json();

    if (!resp.ok) {
      throw new OwnPayError(
        resp.status,
        json.error ?? `HTTP ${resp.status}`,
        json.errors ?? [],
        json.request_id ?? ''
      );
    }

    return json.data as T;
  }

  async health() {
    return this.request<Record<string, unknown>>('GET', '/health');
  }

  async createPayment(req: CreatePaymentRequest): Promise<PaymentIntent> {
    return this.request<PaymentIntent>('POST', '/payments', req);
  }

  async getPayment(paymentId: string): Promise<Transaction> {
    return this.request<Transaction>('GET', `/payments/${paymentId}`);
  }

  async listTransactions(params?: {
    page?: number;
    per_page?: number;
    status?: string;
    gateway?: string;
    from?: string;
    to?: string;
  }): Promise<Transaction[]> {
    const qs = new URLSearchParams(
      Object.entries(params ?? {})
        .filter(([, v]) => v !== undefined)
        .map(([k, v]) => [k, String(v)])
    ).toString();
    return this.request<Transaction[]>('GET', `/transactions${qs ? `?${qs}` : ''}`);
  }

  async getTransaction(trxId: string): Promise<Transaction> {
    return this.request<Transaction>('GET', `/transactions/${trxId}`);
  }

  async createRefund(req: {
    trx_id: string;
    amount?: string;
    reason?: string;
  }): Promise<Refund> {
    return this.request<Refund>('POST', '/refunds', req);
  }

  async createCustomer(req: {
    name: string;
    email?: string;
    phone?: string;
  }): Promise<{ id: number; uuid: string }> {
    return this.request('POST', '/customers', req);
  }

  async getCustomer(identifier: string) {
    const encoded = encodeURIComponent(identifier);
    return this.request('GET', `/customers/${encoded}`);
  }
}