@rikology/adonisjs-xendit 1.0.0

package/build/index.js

@@ -0,0 +1,70 @@
+import { l as xendit_exception_exports } from "./xendit_exception-kaFnYOo7.js";
+import { configure } from "./configure.js";
+import { a as InvoiceClient, c as DirectDebitClient, i as QrisClient, l as CreditCardClient, n as VirtualAccountClient, o as EWalletClient, r as RetailOutletClient, s as DisbursementClient, t as XenditManager, u as BalanceClient } from "./xendit_manager-DOa0yE8A.js";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+import { configProvider } from "@adonisjs/core";
+import { InvalidArgumentsException } from "@adonisjs/core/exceptions";
+import crypto from "node:crypto";
+//#region stubs/main.ts
+/**
+* Path to the root directory where the stubs are stored.
+* Computed from import.meta.url so it remains correct after bundling.
+*/
+const stubsRoot = dirname(fileURLToPath(import.meta.url));
+//#endregion
+//#region src/define_config.ts
+/**
+* Defines the Xendit configuration for your AdonisJS application.
+* This function returns a config provider that resolves the Xendit
+* configuration lazily when the application boots.
+*
+* @param config - The Xendit configuration object
+*
+* @example
+* ```ts
+* import { defineConfig } from '@rikology/adonisjs-xendit'
+*
+* export default defineConfig({
+*   secretKey: env.get('XENDIT_SECRET_KEY'),
+*   environment: 'sandbox',
+*   callbackToken: env.get('XENDIT_CALLBACK_TOKEN'),
+* })
+* ```
+*/
+function defineConfig(config) {
+	/**
+	* Secret key should always be provided
+	*/
+	if (!config.secretKey) throw new InvalidArgumentsException("Missing \"secretKey\" property in Xendit config");
+	/**
+	* Environment should be either "sandbox" or "production"
+	*/
+	if (config.environment && !["sandbox", "production"].includes(config.environment)) throw new InvalidArgumentsException(`Invalid "environment" value "${config.environment}". Expected "sandbox" or "production"`);
+	return configProvider.create(async (_app) => {
+		return {
+			secretKey: config.secretKey,
+			environment: config.environment ?? "sandbox",
+			callbackToken: config.callbackToken,
+			timeoutMs: config.timeoutMs ?? 3e4
+		};
+	});
+}
+//#endregion
+//#region src/webhook.ts
+var XenditWebhook = class {
+	static verify(payload, callbackToken, signature) {
+		const expected = crypto.createHmac("sha256", callbackToken).update(payload).digest("hex");
+		const expectedBuffer = Buffer.from(expected);
+		const actualBuffer = Buffer.from(signature);
+		if (expectedBuffer.length !== actualBuffer.length) return false;
+		return crypto.timingSafeEqual(expectedBuffer, actualBuffer);
+	}
+	static parseEvent(payload) {
+		const parsed = JSON.parse(payload);
+		if (typeof parsed !== "object" || parsed === null || typeof parsed.event !== "string" || !("data" in parsed)) throw new TypeError("Invalid Xendit webhook payload");
+		return parsed;
+	}
+};
+//#endregion
+export { BalanceClient, CreditCardClient, DirectDebitClient, DisbursementClient, EWalletClient, InvoiceClient, QrisClient, RetailOutletClient, VirtualAccountClient, XenditManager, XenditWebhook, configure, defineConfig, xendit_exception_exports as errors, stubsRoot };

package/build/providers/xendit_provider.d.ts

@@ -0,0 +1,12 @@
+import { type ApplicationService } from '@adonisjs/core/types';
+import { XenditManager } from '../src/xendit_manager.ts';
+declare module '@adonisjs/core/types' {
+    interface ContainerBindings {
+        'xendit.manager': XenditManager;
+    }
+}
+export default class XenditProvider {
+    protected app: ApplicationService;
+    constructor(app: ApplicationService);
+    register(): void;
+}

package/build/providers/xendit_provider.js

@@ -0,0 +1,19 @@
+import { t as XenditManager } from "../xendit_manager-DOa0yE8A.js";
+import { configProvider } from "@adonisjs/core";
+import { RuntimeException } from "@adonisjs/core/exceptions";
+//#region providers/xendit_provider.ts
+var XenditProvider = class {
+	constructor(app) {
+		this.app = app;
+	}
+	register() {
+		this.app.container.singleton("xendit.manager", async () => {
+			const xenditConfigProvider = this.app.config.get("xendit", {});
+			const config = await configProvider.resolve(this.app, xenditConfigProvider);
+			if (!config || !config.secretKey) throw new RuntimeException("Invalid \"config/xendit.ts\" file. Make sure you are using the \"defineConfig\" method");
+			return new XenditManager(config);
+		});
+	}
+};
+//#endregion
+export { XenditProvider as default };

package/build/src/clients/balance_client.d.ts

@@ -0,0 +1,8 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { Balance, BalanceAccountType } from '../types.ts';
+export declare class BalanceClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    get(): Promise<Balance>;
+    getByAccountType(accountType: BalanceAccountType): Promise<Balance>;
+}

package/build/src/clients/credit_card_client.d.ts

@@ -0,0 +1,10 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { CreateCreditCardAuthRequest, CreditCardAuth, CreateCreditCardChargeRequest, CreditCardCharge, CreateCreditCardRefundRequest, CreditCardRefund } from '../types.ts';
+export declare class CreditCardClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    createAuthorization(data: CreateCreditCardAuthRequest): Promise<CreditCardAuth>;
+    createCharge(data: CreateCreditCardChargeRequest): Promise<CreditCardCharge>;
+    createRefund(chargeId: string, data: CreateCreditCardRefundRequest): Promise<CreditCardRefund>;
+    getCharge(chargeId: string): Promise<CreditCardCharge>;
+}

package/build/src/clients/direct_debit_client.d.ts

@@ -0,0 +1,10 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { CreateDirectDebitPaymentMethodRequest, ValidateDirectDebitOTPRequest, DirectDebitPaymentMethod, CreateDirectDebitPaymentRequest, DirectDebitPayment } from '../types.ts';
+export declare class DirectDebitClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    createPaymentMethod(data: CreateDirectDebitPaymentMethodRequest): Promise<DirectDebitPaymentMethod>;
+    validateOTP(paymentMethodId: string, data: ValidateDirectDebitOTPRequest): Promise<DirectDebitPaymentMethod>;
+    createPayment(data: CreateDirectDebitPaymentRequest): Promise<DirectDebitPayment>;
+    getPayment(paymentId: string): Promise<DirectDebitPayment>;
+}

package/build/src/clients/disbursement_client.d.ts

@@ -0,0 +1,10 @@
+import type { XenditHttpClient, XenditRequestOptions } from '../http_client.ts';
+import type { BatchDisbursement, CreateBatchDisbursementRequest, CreateDisbursementRequest, Disbursement, DisbursementBank } from '../types.ts';
+export declare class DisbursementClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    create(data: CreateDisbursementRequest, options?: Pick<XenditRequestOptions, 'idempotencyKey'>): Promise<Disbursement>;
+    getById(disbursementId: string): Promise<Disbursement>;
+    createBatch(data: CreateBatchDisbursementRequest, options?: Pick<XenditRequestOptions, 'idempotencyKey'>): Promise<BatchDisbursement>;
+    getAvailableBanks(): Promise<DisbursementBank[]>;
+}

package/build/src/clients/ewallet_client.d.ts

@@ -0,0 +1,11 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { CreateEWalletChargeRequest, EWalletCharge } from '../types.ts';
+export declare class EWalletClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    createOvo(data: CreateEWalletChargeRequest): Promise<EWalletCharge>;
+    createDana(data: CreateEWalletChargeRequest): Promise<EWalletCharge>;
+    createLinkAja(data: CreateEWalletChargeRequest): Promise<EWalletCharge>;
+    createShopeepay(data: CreateEWalletChargeRequest): Promise<EWalletCharge>;
+    getStatus(chargeId: string): Promise<EWalletCharge>;
+}

package/build/src/clients/invoice_client.d.ts

@@ -0,0 +1,12 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { CreateInvoiceRequest, Invoice, ListInvoicesParams } from '../types.ts';
+export declare class InvoiceClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    create(data: CreateInvoiceRequest, options?: {
+        idempotencyKey?: string;
+    }): Promise<Invoice>;
+    getById(invoiceId: string): Promise<Invoice>;
+    list(params?: ListInvoicesParams): Promise<Invoice[]>;
+    expire(invoiceId: string): Promise<Invoice>;
+}

package/build/src/clients/qris_client.d.ts

@@ -0,0 +1,9 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { CreateQRCodeRequest, QRCode, QRCodePayment, SimulateQRCodeRequest } from '../types.ts';
+export declare class QrisClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    create(data: CreateQRCodeRequest): Promise<QRCode>;
+    getById(qrId: string): Promise<QRCode>;
+    simulate(qrId: string, data: SimulateQRCodeRequest): Promise<QRCodePayment>;
+}

package/build/src/clients/retail_outlet_client.d.ts

@@ -0,0 +1,9 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { CreateRetailOutletRequest, RetailOutlet, UpdateRetailOutletRequest } from '../types.ts';
+export declare class RetailOutletClient {
+    private readonly http;
+    constructor(http: XenditHttpClient);
+    create(data: CreateRetailOutletRequest): Promise<RetailOutlet>;
+    getById(paymentId: string): Promise<RetailOutlet>;
+    update(paymentId: string, data: UpdateRetailOutletRequest): Promise<RetailOutlet>;
+}

package/build/src/clients/va_client.d.ts

@@ -0,0 +1,10 @@
+import type { XenditHttpClient } from '../http_client.ts';
+import type { CreateVirtualAccountRequest, UpdateVirtualAccountRequest, VirtualAccount, VAPayment } from '../types.ts';
+export declare class VirtualAccountClient {
+    #private;
+    constructor(http: XenditHttpClient);
+    create(data: CreateVirtualAccountRequest): Promise<VirtualAccount>;
+    getById(vaId: string): Promise<VirtualAccount>;
+    update(vaId: string, data: UpdateVirtualAccountRequest): Promise<VirtualAccount>;
+    getPayment(vaId: string): Promise<VAPayment>;
+}

package/build/src/define_config.d.ts

@@ -0,0 +1,21 @@
+import type { ConfigProvider } from '@adonisjs/core/types';
+import type { XenditConfig } from './types.ts';
+/**
+ * Defines the Xendit configuration for your AdonisJS application.
+ * This function returns a config provider that resolves the Xendit
+ * configuration lazily when the application boots.
+ *
+ * @param config - The Xendit configuration object
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from '@rikology/adonisjs-xendit'
+ *
+ * export default defineConfig({
+ *   secretKey: env.get('XENDIT_SECRET_KEY'),
+ *   environment: 'sandbox',
+ *   callbackToken: env.get('XENDIT_CALLBACK_TOKEN'),
+ * })
+ * ```
+ */
+export declare function defineConfig(config: XenditConfig): ConfigProvider<XenditConfig>;

package/build/src/http_client.d.ts

@@ -0,0 +1,15 @@
+export interface XenditHttpClientOptions {
+    baseUrl: string;
+    secretKey: string;
+    timeoutMs?: number;
+}
+export interface XenditRequestOptions {
+    body?: Record<string, unknown>;
+    idempotencyKey?: string;
+    headers?: Record<string, string>;
+}
+export declare class XenditHttpClient {
+    #private;
+    constructor(options: XenditHttpClientOptions);
+    request<T>(method: string, path: string, options?: XenditRequestOptions): Promise<T>;
+}