@rikology/adonisjs-xendit 1.0.0

package/build/xendit_exception-kaFnYOo7.js

@@ -0,0 +1,81 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/xendit_exception.ts
+var xendit_exception_exports = /* @__PURE__ */ __exportAll({
+	XenditAuthenticationError: () => XenditAuthenticationError,
+	XenditConflictError: () => XenditConflictError,
+	XenditException: () => XenditException,
+	XenditNetworkError: () => XenditNetworkError,
+	XenditNotFoundError: () => XenditNotFoundError,
+	XenditRateLimitError: () => XenditRateLimitError,
+	XenditServerError: () => XenditServerError,
+	XenditValidationError: () => XenditValidationError
+});
+var XenditException = class extends Error {
+	/**
+	* HTTP status code or 0 for network errors
+	*/
+	status;
+	/**
+	* Xendit error code (e.g. 'INVALID_AMOUNT', 'UNAUTHORIZED')
+	*/
+	code;
+	/**
+	* The raw JSON response body from Xendit API, if available
+	*/
+	rawResponse;
+	constructor(status, code, message, rawResponse) {
+		super(message);
+		this.name = this.constructor.name;
+		this.status = status;
+		this.code = code;
+		this.rawResponse = rawResponse;
+	}
+};
+var XenditValidationError = class extends XenditException {
+	constructor(code, message, rawResponse) {
+		super(400, code, message, rawResponse);
+	}
+};
+var XenditAuthenticationError = class extends XenditException {
+	constructor(code, message, rawResponse) {
+		super(401, code, message, rawResponse);
+	}
+};
+var XenditNotFoundError = class extends XenditException {
+	constructor(code, message, rawResponse) {
+		super(404, code, message, rawResponse);
+	}
+};
+var XenditConflictError = class extends XenditException {
+	constructor(code, message, rawResponse) {
+		super(409, code, message, rawResponse);
+	}
+};
+var XenditRateLimitError = class extends XenditException {
+	constructor(code, message, rawResponse) {
+		super(429, code, message, rawResponse);
+	}
+};
+var XenditServerError = class extends XenditException {
+	constructor(code, message, rawResponse) {
+		super(500, code, message, rawResponse);
+	}
+};
+var XenditNetworkError = class extends XenditException {
+	constructor(code, message, rawResponse) {
+		super(0, code, message, rawResponse);
+	}
+};
+//#endregion
+export { XenditNotFoundError as a, XenditValidationError as c, XenditNetworkError as i, xendit_exception_exports as l, XenditConflictError as n, XenditRateLimitError as o, XenditException as r, XenditServerError as s, XenditAuthenticationError as t };

package/build/xendit_manager-DOa0yE8A.js

@@ -0,0 +1,332 @@
+import { a as XenditNotFoundError, c as XenditValidationError, i as XenditNetworkError, n as XenditConflictError, o as XenditRateLimitError, s as XenditServerError, t as XenditAuthenticationError } from "./xendit_exception-kaFnYOo7.js";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+//#region src/http_client.ts
+const LIBRARY_VERSION = (() => {
+	try {
+		return JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8")).version;
+	} catch {
+		return "unknown";
+	}
+})();
+var XenditHttpClient = class {
+	#baseUrl;
+	#secretKey;
+	#timeoutMs;
+	constructor(options) {
+		this.#baseUrl = options.baseUrl.replace(/\/$/, "");
+		this.#secretKey = options.secretKey;
+		this.#timeoutMs = options.timeoutMs ?? 3e4;
+	}
+	async request(method, path, options) {
+		return this.#requestWithRetry(method, path, options);
+	}
+	async #requestWithRetry(method, path, options) {
+		const url = `${this.#baseUrl}${path}`;
+		const headers = new Headers({
+			"Authorization": this.#authHeader(),
+			"Content-Type": "application/json",
+			...this.#addTrackingHeaders(),
+			...this.#addIdempotencyHeader(options?.idempotencyKey),
+			...options?.headers
+		});
+		const body = options?.body ? JSON.stringify(options.body) : void 0;
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), this.#timeoutMs);
+		try {
+			const response = await fetch(url, {
+				method,
+				headers,
+				body,
+				signal: controller.signal
+			});
+			clearTimeout(timeoutId);
+			if (!response.ok) {
+				const errorBody = await this.#safeParseJson(response);
+				throw this.#mapError(response.status, errorBody);
+			}
+			return await this.#safeParseJson(response);
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error instanceof Error && error.name === "AbortError") throw new XenditNetworkError("TIMEOUT", `Request timed out after ${this.#timeoutMs}ms`);
+			if (error instanceof XenditValidationError || error instanceof XenditAuthenticationError || error instanceof XenditNotFoundError || error instanceof XenditConflictError || error instanceof XenditRateLimitError || error instanceof XenditServerError) throw error;
+			throw new XenditNetworkError("NETWORK_ERROR", error instanceof Error ? error.message : "Network request failed");
+		}
+	}
+	#authHeader() {
+		return `Basic ${Buffer.from(`${this.#secretKey}:`).toString("base64")}`;
+	}
+	#addTrackingHeaders() {
+		return {
+			"xendit-lib": "adonisjs",
+			"xendit-lib-ver": LIBRARY_VERSION
+		};
+	}
+	#addIdempotencyHeader(idempotencyKey) {
+		if (!idempotencyKey) return {};
+		return { "idempotency-key": idempotencyKey };
+	}
+	#mapError(status, body) {
+		const code = body?.error_code ?? "UNKNOWN_ERROR";
+		const message = body?.message ?? "An error occurred";
+		switch (status) {
+			case 400: return new XenditValidationError(code, message, body ?? void 0);
+			case 401: return new XenditAuthenticationError(code, message, body ?? void 0);
+			case 404: return new XenditNotFoundError(code, message, body ?? void 0);
+			case 409: return new XenditConflictError(code, message, body ?? void 0);
+			case 429: return new XenditRateLimitError(code, message, body ?? void 0);
+			default: return new XenditServerError(code, message, body ?? void 0);
+		}
+	}
+	async #safeParseJson(response) {
+		if (!(response.headers.get("content-type") ?? "").includes("application/json")) return null;
+		try {
+			return await response.json();
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+//#region src/clients/balance_client.ts
+var BalanceClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	get() {
+		return this.#http.request("GET", "/balance");
+	}
+	getByAccountType(accountType) {
+		return this.#http.request("GET", `/balance?account_type=${accountType}`);
+	}
+};
+//#endregion
+//#region src/clients/credit_card_client.ts
+var CreditCardClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	async createAuthorization(data) {
+		return this.#http.request("POST", "/credit_card_charges/auth", { body: data });
+	}
+	async createCharge(data) {
+		return this.#http.request("POST", "/credit_card_charges", { body: data });
+	}
+	async createRefund(chargeId, data) {
+		return this.#http.request("POST", `/credit_card_charges/${chargeId}/refunds`, { body: data });
+	}
+	async getCharge(chargeId) {
+		return this.#http.request("GET", `/credit_card_charges/${chargeId}`);
+	}
+};
+//#endregion
+//#region src/clients/direct_debit_client.ts
+var DirectDebitClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	createPaymentMethod(data) {
+		return this.#http.request("POST", "/direct_debit/payment_methods", { body: data });
+	}
+	validateOTP(paymentMethodId, data) {
+		return this.#http.request("POST", `/direct_debit/payment_methods/${paymentMethodId}/validate`, { body: data });
+	}
+	createPayment(data) {
+		return this.#http.request("POST", "/direct_debit/payments", { body: data });
+	}
+	getPayment(paymentId) {
+		return this.#http.request("GET", `/direct_debit/payments/${paymentId}`);
+	}
+};
+//#endregion
+//#region src/clients/disbursement_client.ts
+var DisbursementClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	create(data, options) {
+		return this.#http.request("POST", "/disbursements", {
+			body: data,
+			idempotencyKey: options?.idempotencyKey
+		});
+	}
+	getById(disbursementId) {
+		return this.#http.request("GET", `/disbursements/${disbursementId}`);
+	}
+	createBatch(data, options) {
+		return this.#http.request("POST", "/batch_disbursements", {
+			body: data,
+			idempotencyKey: options?.idempotencyKey
+		});
+	}
+	getAvailableBanks() {
+		return this.#http.request("GET", "/available_disbursements_banks");
+	}
+};
+//#endregion
+//#region src/clients/ewallet_client.ts
+var EWalletClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	createOvo(data) {
+		return this.#createCharge(data, "ID_OVO");
+	}
+	createDana(data) {
+		return this.#createCharge(data, "ID_DANA");
+	}
+	createLinkAja(data) {
+		return this.#createCharge(data, "ID_LINKAJA");
+	}
+	createShopeepay(data) {
+		return this.#createCharge(data, "ID_SHOPEEPAY");
+	}
+	getStatus(chargeId) {
+		return this.#http.request("GET", `/ewallets/charges/${chargeId}`);
+	}
+	#createCharge(data, channelCode) {
+		return this.#http.request("POST", "/ewallets/charges", { body: {
+			...data,
+			channel_code: channelCode
+		} });
+	}
+};
+//#endregion
+//#region src/clients/invoice_client.ts
+var InvoiceClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	create(data, options) {
+		return this.#http.request("POST", "/v2/invoices", {
+			body: data,
+			idempotencyKey: options?.idempotencyKey
+		});
+	}
+	getById(invoiceId) {
+		return this.#http.request("GET", `/v2/invoices/${invoiceId}`);
+	}
+	list(params) {
+		const searchParams = new URLSearchParams();
+		if (params) {
+			for (const [key, value] of Object.entries(params)) if (value !== void 0 && value !== null) searchParams.append(key, String(value));
+		}
+		const query = searchParams.toString();
+		const path = query ? `/v2/invoices?${query}` : "/v2/invoices";
+		return this.#http.request("GET", path);
+	}
+	expire(invoiceId) {
+		return this.#http.request("POST", `/invoices/${invoiceId}/expire!`);
+	}
+};
+//#endregion
+//#region src/clients/qris_client.ts
+var QrisClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	create(data) {
+		return this.#http.request("POST", "/qr_codes", { body: data });
+	}
+	getById(qrId) {
+		return this.#http.request("GET", `/qr_codes/${qrId}`);
+	}
+	simulate(qrId, data) {
+		return this.#http.request("POST", `/qr_codes/${qrId}/payments/simulate`, { body: data });
+	}
+};
+//#endregion
+//#region src/clients/retail_outlet_client.ts
+var RetailOutletClient = class {
+	constructor(http) {
+		this.http = http;
+	}
+	create(data) {
+		return this.http.request("POST", "/fixed_payment_code", { body: data });
+	}
+	getById(paymentId) {
+		return this.http.request("GET", `/fixed_payment_code/${paymentId}`);
+	}
+	update(paymentId, data) {
+		return this.http.request("PATCH", `/fixed_payment_code/${paymentId}`, { body: data });
+	}
+};
+//#endregion
+//#region src/clients/va_client.ts
+var VirtualAccountClient = class {
+	#http;
+	constructor(http) {
+		this.#http = http;
+	}
+	create(data) {
+		return this.#http.request("POST", "/callback_virtual_accounts", { body: data });
+	}
+	getById(vaId) {
+		return this.#http.request("GET", `/callback_virtual_accounts/${vaId}`);
+	}
+	update(vaId, data) {
+		return this.#http.request("PATCH", `/callback_virtual_accounts/${vaId}`, { body: data });
+	}
+	getPayment(vaId) {
+		return this.#http.request("GET", `/callback_virtual_accounts/${vaId}/payments`);
+	}
+};
+//#endregion
+//#region src/xendit_manager.ts
+const BASE_URLS = {
+	sandbox: "https://sandbox-api.xendit.co",
+	production: "https://api.xendit.co"
+};
+var XenditManager = class {
+	#http;
+	#clients = /* @__PURE__ */ new Map();
+	constructor(config) {
+		const baseUrl = BASE_URLS[config.environment];
+		this.#http = new XenditHttpClient({
+			baseUrl,
+			secretKey: config.secretKey,
+			timeoutMs: config.timeoutMs
+		});
+	}
+	invoice() {
+		return this.#cached("invoice", () => new InvoiceClient(this.#http));
+	}
+	va() {
+		return this.#cached("va", () => new VirtualAccountClient(this.#http));
+	}
+	ewallet() {
+		return this.#cached("ewallet", () => new EWalletClient(this.#http));
+	}
+	qris() {
+		return this.#cached("qris", () => new QrisClient(this.#http));
+	}
+	retailOutlet() {
+		return this.#cached("retailOutlet", () => new RetailOutletClient(this.#http));
+	}
+	creditCard() {
+		return this.#cached("creditCard", () => new CreditCardClient(this.#http));
+	}
+	directDebit() {
+		return this.#cached("directDebit", () => new DirectDebitClient(this.#http));
+	}
+	disbursement() {
+		return this.#cached("disbursement", () => new DisbursementClient(this.#http));
+	}
+	balance() {
+		return this.#cached("balance", () => new BalanceClient(this.#http));
+	}
+	#cached(key, factory) {
+		if (!this.#clients.has(key)) this.#clients.set(key, factory());
+		return this.#clients.get(key);
+	}
+};
+//#endregion
+export { InvoiceClient as a, DirectDebitClient as c, QrisClient as i, CreditCardClient as l, VirtualAccountClient as n, EWalletClient as o, RetailOutletClient as r, DisbursementClient as s, XenditManager as t, BalanceClient as u };

package/package.json

@@ -0,0 +1,188 @@
+{
+  "name": "@rikology/adonisjs-xendit",
+  "description": "AdonisJS v7 package for Xendit payment gateway integration",
+  "version": "1.0.0",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "type": "module",
+  "files": [
+    "build",
+    "!build/bin",
+    "!build/tests",
+    "!build/**/*.map",
+    "LICENSE.md",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./types": {
+      "types": "./build/src/types.d.ts",
+      "default": "./build/src/types.js"
+    },
+    "./xendit_provider": {
+      "types": "./build/providers/xendit_provider.d.ts",
+      "default": "./build/providers/xendit_provider.js"
+    },
+    "./errors": {
+      "types": "./build/src/xendit_exception.d.ts",
+      "default": "./build/src/xendit_exception.js"
+    }
+  },
+  "scripts": {
+    "copy:templates": "copyfiles \"stubs/**/*.stub\" build",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts",
+    "pretest": "npm run build",
+    "test": "c8 npm run quick:test",
+    "test:quick": "npm run quick:test",
+    "precompile": "npm run lint",
+    "compile": "tsdown && tsc --emitDeclarationOnly --declaration",
+    "postcompile": "npm run copy:templates",
+    "build": "npm run compile",
+    "clean": "rm -rf build coverage",
+    "release": "release-it",
+    "release:preview": "release-it --dry-run",
+    "version": "npm run build",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rikoriswandha/adonisjs-xendit.git"
+  },
+  "homepage": "https://github.com/rikoriswandha/adonisjs-xendit#readme",
+  "bugs": {
+    "url": "https://github.com/rikoriswandha/adonisjs-xendit/issues"
+  },
+  "keywords": [
+    "adonisjs",
+    "adonis",
+    "xendit",
+    "payment",
+    "payment-gateway",
+    "fintech",
+    "indonesia",
+    "virtual-account",
+    "ewallet",
+    "qris",
+    "invoice",
+    "disbursement",
+    "credit-card",
+    "direct-debit",
+    "payment-provider",
+    "typescript"
+  ],
+  "author": "Riko Riswandha <rikoriswandha@gmail.com>",
+  "license": "MIT",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/rikoriswandha"
+  },
+  "devDependencies": {
+    "@adonisjs/assembler": "^8.0.0",
+    "@adonisjs/core": "^7.0.1",
+    "@adonisjs/eslint-config": "^3.0.0",
+    "@adonisjs/prettier-config": "^1.4.5",
+    "@adonisjs/tsconfig": "^2.0.0",
+    "@japa/assert": "^4.2.0",
+    "@japa/file-system": "^3.0.0",
+    "@japa/runner": "^5.3.0",
+    "@poppinss/ts-exec": "^1.4.4",
+    "@release-it/conventional-changelog": "^10.0.5",
+    "@types/node": "^22.0.0",
+    "c8": "^11.0.0",
+    "copyfiles": "^2.4.1",
+    "cross-env": "^10.1.0",
+    "eslint": "^10.0.3",
+    "prettier": "^3.8.1",
+    "release-it": "^19.2.4",
+    "tsdown": "^0.21.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@adonisjs/assembler": "^8.0.0",
+    "@adonisjs/core": "^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@adonisjs/assembler": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "tsdown": {
+    "entry": [
+      "./index.ts",
+      "./configure.ts",
+      "./providers/xendit_provider.ts",
+      "./src/types.ts",
+      "./src/xendit_exception.ts"
+    ],
+    "outDir": "./build",
+    "clean": true,
+    "format": "esm",
+    "minify": "dce-only",
+    "fixedExtension": false,
+    "dts": false,
+    "treeshake": false,
+    "sourcemaps": true,
+    "target": "esnext"
+  },
+  "release-it": {
+    "git": {
+      "requireCleanWorkingDir": true,
+      "requireUpstream": true,
+      "commitMessage": "chore(release): ${version}",
+      "tagAnnotation": "v${version}",
+      "push": true,
+      "tagName": "v${version}"
+    },
+    "github": {
+      "release": true
+    },
+    "npm": {
+      "publish": true,
+      "skipChecks": false
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "c8": {
+    "reporter": [
+      "text",
+      "html",
+      "lcov"
+    ],
+    "exclude": [
+      "tests/**",
+      "bin/**",
+      "build/**",
+      "coverage/**",
+      "stubs/**"
+    ],
+    "lines": 80,
+    "functions": 80,
+    "branches": 70,
+    "statements": 80
+  },
+  "prettier": "@adonisjs/prettier-config"
+}