kassza 0.11.0 → 0.13.0

package/dist/payments/paypal.cjs

@@ -0,0 +1,351 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_binary = require("../binary-B89HM03_.cjs");
+const require_rounding = require("../rounding-TxoWy2ww.cjs");
+const require_webhook = require("../webhook-81giRMdQ.cjs");
+const require_json = require("../json-4y4E2xxS.cjs");
+//#region src/payments/paypal.ts
+const PAYPAL_LIVE_API_URL = "https://api-m.paypal.com";
+const PAYPAL_SANDBOX_API_URL = "https://api-m.sandbox.paypal.com";
+const PAYPAL_METHOD = "PayPal";
+const PAYPAL_SHIPPING_ITEM_NAME = "Szállítási díj";
+const PAYPAL_HANDLING_ITEM_NAME = "Kezelési díj";
+const PAYPAL_INSURANCE_ITEM_NAME = "Biztosítás";
+const TOKEN_REFRESH_MARGIN_MS = 6e4;
+const AMOUNT_TOLERANCE = .005;
+const UNAUTHORIZED = 401;
+const TRANSMISSION_HEADERS = {
+	authAlgo: "paypal-auth-algo",
+	certUrl: "paypal-cert-url",
+	transmissionId: "paypal-transmission-id",
+	transmissionSig: "paypal-transmission-sig",
+	transmissionTime: "paypal-transmission-time"
+};
+function apiBase(options) {
+	return (options.apiUrl ?? (options.sandbox ? "https://api-m.sandbox.paypal.com" : "https://api-m.paypal.com")).replace(/\/+$/, "");
+}
+async function readJson(response, what) {
+	const json = require_json.record(await response.json().catch(() => void 0));
+	if (!response.ok || !json) {
+		const detail = require_json.text(json?.message) ?? require_json.text(json?.error_description) ?? require_json.text(json?.name);
+		throw new require_webhook.PaymentProviderError("paypal", `A PayPal ${what} nem sikerült (HTTP ${response.status})${detail ? `: ${detail}` : ""}.`, response.status);
+	}
+	return json;
+}
+function payPalApi(options) {
+	const clientId = options.clientId?.trim();
+	const clientSecret = options.clientSecret?.trim();
+	if (!clientId || !clientSecret) throw new TypeError("Add meg a PayPal REST alkalmazás clientId és clientSecret adatát.");
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	const base = apiBase(options);
+	const now = options.now ?? Date.now;
+	let cached;
+	async function fetchOrThrow(url, init, what) {
+		try {
+			return await fetchImpl(url, init);
+		} catch (error) {
+			throw new require_webhook.PaymentProviderError("paypal", `A PayPal ${what} nem sikerült.`, void 0, error);
+		}
+	}
+	async function token() {
+		if (cached && cached.expiresAt > now()) return cached.value;
+		const credentials = require_binary.bytesToBase64(require_binary.encodeUtf8(`${clientId}:${clientSecret}`));
+		const json = await readJson(await fetchOrThrow(`${base}/v1/oauth2/token`, {
+			method: "POST",
+			headers: {
+				authorization: `Basic ${credentials}`,
+				"content-type": "application/x-www-form-urlencoded",
+				accept: "application/json"
+			},
+			body: "grant_type=client_credentials"
+		}, "hozzáférési token kérése"), "hozzáférési token kérése");
+		const value = require_json.text(json.access_token);
+		if (!value) throw new require_webhook.PaymentProviderError("paypal", "A PayPal token válaszából hiányzik az access_token.");
+		const lifetimeMs = (require_json.numeric(json.expires_in) ?? 0) * 1e3;
+		cached = {
+			value,
+			expiresAt: now() + Math.max(0, lifetimeMs - TOKEN_REFRESH_MARGIN_MS)
+		};
+		return value;
+	}
+	async function send(method, pathname, body) {
+		const what = `${method} ${pathname} hívás`;
+		const attempt = async () => fetchOrThrow(`${base}${pathname}`, {
+			method,
+			headers: {
+				authorization: `Bearer ${await token()}`,
+				accept: "application/json",
+				...body === void 0 ? {} : { "content-type": "application/json" }
+			},
+			...body === void 0 ? {} : { body }
+		}, what);
+		let response = await attempt();
+		if (response.status === UNAUTHORIZED) {
+			cached = void 0;
+			response = await attempt();
+		}
+		return readJson(response, what);
+	}
+	return {
+		get: (pathname) => send("GET", pathname),
+		post: (pathname, body) => send("POST", pathname, body)
+	};
+}
+function payPalTransmission(headers) {
+	const authAlgo = headers.get(TRANSMISSION_HEADERS.authAlgo)?.trim();
+	const certUrl = headers.get(TRANSMISSION_HEADERS.certUrl)?.trim();
+	const transmissionId = headers.get(TRANSMISSION_HEADERS.transmissionId)?.trim();
+	const transmissionSig = headers.get(TRANSMISSION_HEADERS.transmissionSig)?.trim();
+	const transmissionTime = headers.get(TRANSMISSION_HEADERS.transmissionTime)?.trim();
+	if (!authAlgo || !certUrl || !transmissionId || !transmissionSig || !transmissionTime) return;
+	return {
+		authAlgo,
+		certUrl,
+		transmissionId,
+		transmissionSig,
+		transmissionTime
+	};
+}
+async function verifyPayPalWebhook(payload, headers, webhookId, api) {
+	const transmission = payPalTransmission(headers);
+	if (!transmission) throw new require_webhook.WebhookVerificationError("paypal", "missing_signature", "Hiányoznak a PayPal webhook PAYPAL-TRANSMISSION-* és PAYPAL-AUTH-ALGO fejlécei.");
+	require_webhook.parseJsonObject("paypal", payload);
+	const body = [
+		`{"auth_algo":${JSON.stringify(transmission.authAlgo)}`,
+		`"cert_url":${JSON.stringify(transmission.certUrl)}`,
+		`"transmission_id":${JSON.stringify(transmission.transmissionId)}`,
+		`"transmission_sig":${JSON.stringify(transmission.transmissionSig)}`,
+		`"transmission_time":${JSON.stringify(transmission.transmissionTime)}`,
+		`"webhook_id":${JSON.stringify(webhookId)}`,
+		`"webhook_event":${payload.trim()}}`
+	].join(",");
+	const result = await api.post("/v1/notifications/verify-webhook-signature", body);
+	if (require_json.text(result.verification_status) !== "SUCCESS") throw new require_webhook.WebhookVerificationError("paypal", "invalid_signature", "A PayPal szerint a webhook aláírása érvénytelen.");
+}
+function parsePayPalEvent(payload) {
+	const json = require_webhook.parseJsonObject("paypal", payload);
+	const id = require_json.text(json.id);
+	const eventType = require_json.text(json.event_type);
+	const resource = require_json.record(json.resource);
+	if (!id || !eventType || !resource) throw new require_webhook.WebhookVerificationError("paypal", "invalid_payload", "A PayPal eseményből hiányzik az id, az event_type vagy a resource.");
+	return {
+		id,
+		eventType,
+		resourceType: require_json.text(json.resource_type),
+		createTime: require_json.text(json.create_time),
+		resource,
+		raw: json
+	};
+}
+function moneyValue(value) {
+	const amount = require_json.text(require_json.record(value)?.value);
+	return amount === void 0 ? void 0 : require_webhook.parseDecimalAmount(amount);
+}
+function moneyOf(value) {
+	const amount = moneyValue(value);
+	const currency = require_json.text(require_json.record(value)?.currency_code);
+	if (amount === void 0 || !currency) return void 0;
+	return {
+		value: amount,
+		currency: require_webhook.normalizeCurrency(currency)
+	};
+}
+function payPalCaptureIdOfRefund(refund) {
+	const up = require_json.records(refund.links).find((link) => require_json.text(link.rel) === "up");
+	const href = require_json.text(up?.href);
+	if (!href) return void 0;
+	const match = /\/captures\/([^/?#]+)/.exec(href);
+	return match?.[1] ? decodeURIComponent(match[1]) : void 0;
+}
+function payPalOrderIdOfCapture(capture) {
+	return require_json.text(require_json.path(capture, "supplementary_data", "related_ids", "order_id"));
+}
+function addressOf(address) {
+	if (!address) return void 0;
+	return {
+		country: require_json.text(address.country_code),
+		zip: require_json.text(address.postal_code),
+		city: require_json.text(address.admin_area_2),
+		line1: require_json.text(address.address_line_1),
+		line2: require_json.text(address.address_line_2)
+	};
+}
+function personName(name, country) {
+	const full = require_json.text(name?.full_name);
+	if (full) return full;
+	const given = require_json.text(name?.given_name);
+	const surname = require_json.text(name?.surname);
+	const joined = (country === "HU" ? [surname, given] : [given, surname]).filter(Boolean).join(" ");
+	return joined === "" ? void 0 : joined;
+}
+function customerOf(order) {
+	if (!order) return void 0;
+	const payer = require_json.record(order.payer);
+	const shipping = require_json.record(require_json.records(order.purchase_units)[0]?.shipping);
+	const payerAddress = addressOf(require_json.record(payer?.address));
+	const shippingAddress = addressOf(require_json.record(shipping?.address));
+	const address = payerAddress?.line1 ? payerAddress : shippingAddress ?? payerAddress;
+	const name = personName(require_json.record(payer?.name), address?.country) ?? require_json.text(require_json.path(shipping, "name", "full_name"));
+	const email = require_json.text(payer?.email_address);
+	if (!name && !email && !address) return void 0;
+	return {
+		name,
+		email,
+		phone: require_json.text(require_json.path(payer, "phone", "phone_number", "national_number")),
+		address
+	};
+}
+function sameCurrency(values, currency) {
+	return values.every((value) => {
+		const code = require_json.text(require_json.record(value)?.currency_code);
+		return code === void 0 || require_webhook.normalizeCurrency(code) === currency;
+	});
+}
+function extraItem(value, name) {
+	const amount = moneyValue(value) ?? 0;
+	return amount > 0 ? [{
+		name,
+		quantity: 1,
+		totalGross: amount
+	}] : [];
+}
+function itemsOf(order, currency) {
+	const units = require_json.records(order?.purchase_units);
+	const unit = units[0];
+	if (!unit || units.length !== 1 || !currency) return void 0;
+	const breakdown = require_json.record(require_json.path(unit, "amount", "breakdown"));
+	const discount = (moneyValue(breakdown?.discount) ?? 0) + (moneyValue(breakdown?.shipping_discount) ?? 0);
+	const items = require_json.records(unit.items);
+	if (discount > 0 || items.length === 0) return void 0;
+	if ((moneyValue(breakdown?.tax_total) ?? 0) > 0 && !items.every((item) => require_json.record(item.tax))) return void 0;
+	if (!sameCurrency([
+		...items.flatMap((item) => [item.unit_amount, item.tax]),
+		breakdown?.shipping,
+		breakdown?.handling,
+		breakdown?.insurance
+	], currency)) return void 0;
+	return [
+		...items.map((item) => {
+			const quantity = require_json.numeric(item.quantity) ?? 1;
+			const unitGross = (moneyValue(item.unit_amount) ?? 0) + (moneyValue(item.tax) ?? 0);
+			return {
+				name: require_json.text(item.name) ?? "Tétel",
+				quantity,
+				totalGross: require_rounding.roundMoney(unitGross * quantity, 2),
+				sku: require_json.text(item.sku)
+			};
+		}),
+		...extraItem(breakdown?.shipping, PAYPAL_SHIPPING_ITEM_NAME),
+		...extraItem(breakdown?.handling, PAYPAL_HANDLING_ITEM_NAME),
+		...extraItem(breakdown?.insurance, PAYPAL_INSURANCE_ITEM_NAME)
+	];
+}
+function orderRefOf(resource, order) {
+	const unit = require_json.records(order?.purchase_units)[0];
+	return require_json.text(resource.custom_id) ?? require_json.text(resource.invoice_id) ?? require_json.text(unit?.custom_id) ?? require_json.text(unit?.invoice_id) ?? require_json.text(unit?.reference_id);
+}
+function fromCapture(event, kind, options) {
+	const capture = event.resource;
+	const id = require_json.text(capture.id);
+	if (!id) throw new require_webhook.PaymentProviderError("paypal", "A PayPal capture eseményből hiányzik az id.");
+	const amount = moneyOf(capture.amount);
+	const status = require_json.text(capture.status);
+	return {
+		provider: "paypal",
+		kind: kind === "paid" && status !== void 0 && status !== "COMPLETED" ? "other" : kind,
+		id,
+		eventId: event.id,
+		eventType: event.eventType,
+		orderRef: orderRefOf(capture, options.order),
+		amount,
+		paidAt: require_json.text(capture.create_time) ?? event.createTime,
+		method: options.method ?? "PayPal",
+		customer: customerOf(options.order),
+		items: kind === "paid" ? itemsOf(options.order, amount?.currency) : void 0,
+		raw: event.raw
+	};
+}
+function refundKind(refund, capture) {
+	if (require_json.text(refund.status) !== "COMPLETED") return "other";
+	const refunded = moneyValue(refund.amount);
+	const captured = moneyValue(capture?.amount);
+	if (refunded === void 0 || captured === void 0) return "partially-refunded";
+	return Math.abs(refunded - captured) <= AMOUNT_TOLERANCE ? "refunded" : "partially-refunded";
+}
+function fromRefund(event, options) {
+	const refund = event.resource;
+	const captureId = payPalCaptureIdOfRefund(refund);
+	if (!captureId) throw new require_webhook.PaymentProviderError("paypal", "A PayPal visszatérítésből nem olvasható ki az eredeti capture azonosítója.");
+	const capture = options.capture && require_json.text(options.capture.id) === captureId ? options.capture : void 0;
+	return {
+		provider: "paypal",
+		kind: refundKind(refund, capture),
+		id: captureId,
+		eventId: event.id,
+		eventType: event.eventType,
+		orderRef: orderRefOf(refund, void 0) ?? (capture ? orderRefOf(capture, void 0) : void 0),
+		amount: moneyOf(capture?.amount),
+		refundedAmount: moneyOf(require_json.path(refund, "seller_payable_breakdown", "total_refunded_amount")) ?? moneyOf(refund.amount),
+		paidAt: require_json.text(refund.create_time) ?? event.createTime,
+		method: options.method ?? "PayPal",
+		raw: event.raw
+	};
+}
+function payPalPaymentEvent(event, options = {}) {
+	switch (event.eventType) {
+		case "PAYMENT.CAPTURE.COMPLETED": return fromCapture(event, "paid", options);
+		case "PAYMENT.CAPTURE.DENIED":
+		case "PAYMENT.CAPTURE.DECLINED": return fromCapture(event, "failed", options);
+		case "PAYMENT.CAPTURE.PENDING": return fromCapture(event, "other", options);
+		case "PAYMENT.CAPTURE.REFUNDED": return fromRefund(event, options);
+		default: return;
+	}
+}
+async function loadExtras(event, api, options) {
+	if (event.eventType === "PAYMENT.CAPTURE.REFUNDED") {
+		const captureId = payPalCaptureIdOfRefund(event.resource);
+		if (!captureId) return {};
+		return { capture: await api.get(`/v2/payments/captures/${encodeURIComponent(captureId)}`) };
+	}
+	if (event.eventType !== "PAYMENT.CAPTURE.COMPLETED" || options.fetchOrder === false) return {};
+	const orderId = payPalOrderIdOfCapture(event.resource);
+	if (!orderId) return {};
+	return { order: await api.get(`/v2/checkout/orders/${encodeURIComponent(orderId)}`) };
+}
+function payPalWebhook(options) {
+	const webhookId = options.webhookId?.trim();
+	if (!webhookId) throw new TypeError("Add meg a PayPal webhook azonosítóját (webhookId).");
+	const api = payPalApi({
+		clientId: options.clientId,
+		clientSecret: options.clientSecret,
+		sandbox: options.sandbox,
+		apiUrl: options.apiUrl,
+		fetch: options.fetch
+	});
+	return (request) => require_webhook.respondToWebhook(options, async () => {
+		const payload = await require_webhook.readRawBody(request, "paypal", options.maxBodyBytes);
+		await verifyPayPalWebhook(payload, request.headers, webhookId, api);
+		const event = parsePayPalEvent(payload);
+		const extras = await loadExtras(event, api, options);
+		const payment = payPalPaymentEvent(event, {
+			method: options.method,
+			...extras
+		});
+		if (payment) await options.onPayment(payment);
+		return require_webhook.plainResponse(200, "OK");
+	});
+}
+//#endregion
+exports.PAYPAL_HANDLING_ITEM_NAME = PAYPAL_HANDLING_ITEM_NAME;
+exports.PAYPAL_INSURANCE_ITEM_NAME = PAYPAL_INSURANCE_ITEM_NAME;
+exports.PAYPAL_LIVE_API_URL = PAYPAL_LIVE_API_URL;
+exports.PAYPAL_METHOD = PAYPAL_METHOD;
+exports.PAYPAL_SANDBOX_API_URL = PAYPAL_SANDBOX_API_URL;
+exports.PAYPAL_SHIPPING_ITEM_NAME = PAYPAL_SHIPPING_ITEM_NAME;
+exports.parsePayPalEvent = parsePayPalEvent;
+exports.payPalApi = payPalApi;
+exports.payPalCaptureIdOfRefund = payPalCaptureIdOfRefund;
+exports.payPalOrderIdOfCapture = payPalOrderIdOfCapture;
+exports.payPalPaymentEvent = payPalPaymentEvent;
+exports.payPalTransmission = payPalTransmission;
+exports.payPalWebhook = payPalWebhook;
+exports.verifyPayPalWebhook = verifyPayPalWebhook;

package/dist/payments/paypal.d.cts

@@ -0,0 +1,59 @@
+import { i as PaymentEvent, l as PaymentWebhookBaseOptions } from "../types-BVeR7KyU.cjs";
+import { t as JsonRecord } from "../json-B70TwoX1.cjs";
+import { t as WebhookHandler } from "../webhook-CpMJuP6c.cjs";
+//#region src/payments/paypal.d.ts
+export declare const PAYPAL_LIVE_API_URL = "https://api-m.paypal.com";
+export declare const PAYPAL_SANDBOX_API_URL = "https://api-m.sandbox.paypal.com";
+export declare const PAYPAL_METHOD = "PayPal";
+export declare const PAYPAL_SHIPPING_ITEM_NAME = "Szállítási díj";
+export declare const PAYPAL_HANDLING_ITEM_NAME = "Kezelési díj";
+export declare const PAYPAL_INSURANCE_ITEM_NAME = "Biztosítás";
+export interface PayPalApiOptions {
+  readonly clientId: string;
+  readonly clientSecret: string;
+  readonly sandbox?: boolean | undefined;
+  readonly apiUrl?: string | undefined;
+  readonly fetch?: typeof globalThis.fetch | undefined;
+  readonly now?: (() => number) | undefined;
+}
+export interface PayPalApi {
+  get(pathname: string): Promise<JsonRecord>;
+  post(pathname: string, body: string): Promise<JsonRecord>;
+}
+export declare function payPalApi(options: PayPalApiOptions): PayPalApi;
+export interface PayPalTransmission {
+  readonly authAlgo: string;
+  readonly certUrl: string;
+  readonly transmissionId: string;
+  readonly transmissionSig: string;
+  readonly transmissionTime: string;
+}
+export declare function payPalTransmission(headers: Headers): PayPalTransmission | undefined;
+export declare function verifyPayPalWebhook(payload: string, headers: Headers, webhookId: string, api: PayPalApi): Promise<void>;
+export interface PayPalEvent {
+  readonly id: string;
+  readonly eventType: string;
+  readonly resourceType?: string | undefined;
+  readonly createTime?: string | undefined;
+  readonly resource: JsonRecord;
+  readonly raw: JsonRecord;
+}
+export declare function parsePayPalEvent(payload: string): PayPalEvent;
+export declare function payPalCaptureIdOfRefund(refund: JsonRecord): string | undefined;
+export declare function payPalOrderIdOfCapture(capture: JsonRecord): string | undefined;
+export interface PayPalPaymentOptions {
+  readonly method?: string | undefined;
+  readonly order?: JsonRecord | undefined;
+  readonly capture?: JsonRecord | undefined;
+}
+export declare function payPalPaymentEvent(event: PayPalEvent, options?: PayPalPaymentOptions): PaymentEvent | undefined;
+export interface PayPalWebhookOptions extends PaymentWebhookBaseOptions {
+  readonly webhookId: string;
+  readonly clientId: string;
+  readonly clientSecret: string;
+  readonly sandbox?: boolean | undefined;
+  readonly apiUrl?: string | undefined;
+  readonly fetchOrder?: boolean | undefined;
+}
+export declare function payPalWebhook(options: PayPalWebhookOptions): WebhookHandler;
+//#endregion

package/dist/payments/paypal.d.ts

@@ -0,0 +1,59 @@
+import { i as PaymentEvent, l as PaymentWebhookBaseOptions } from "../types-BVeR7KyU.js";
+import { t as JsonRecord } from "../json-B70TwoX1.js";
+import { t as WebhookHandler } from "../webhook-CpCMHhn2.js";
+//#region src/payments/paypal.d.ts
+export declare const PAYPAL_LIVE_API_URL = "https://api-m.paypal.com";
+export declare const PAYPAL_SANDBOX_API_URL = "https://api-m.sandbox.paypal.com";
+export declare const PAYPAL_METHOD = "PayPal";
+export declare const PAYPAL_SHIPPING_ITEM_NAME = "Szállítási díj";
+export declare const PAYPAL_HANDLING_ITEM_NAME = "Kezelési díj";
+export declare const PAYPAL_INSURANCE_ITEM_NAME = "Biztosítás";
+export interface PayPalApiOptions {
+  readonly clientId: string;
+  readonly clientSecret: string;
+  readonly sandbox?: boolean | undefined;
+  readonly apiUrl?: string | undefined;
+  readonly fetch?: typeof globalThis.fetch | undefined;
+  readonly now?: (() => number) | undefined;
+}
+export interface PayPalApi {
+  get(pathname: string): Promise<JsonRecord>;
+  post(pathname: string, body: string): Promise<JsonRecord>;
+}
+export declare function payPalApi(options: PayPalApiOptions): PayPalApi;
+export interface PayPalTransmission {
+  readonly authAlgo: string;
+  readonly certUrl: string;
+  readonly transmissionId: string;
+  readonly transmissionSig: string;
+  readonly transmissionTime: string;
+}
+export declare function payPalTransmission(headers: Headers): PayPalTransmission | undefined;
+export declare function verifyPayPalWebhook(payload: string, headers: Headers, webhookId: string, api: PayPalApi): Promise<void>;
+export interface PayPalEvent {
+  readonly id: string;
+  readonly eventType: string;
+  readonly resourceType?: string | undefined;
+  readonly createTime?: string | undefined;
+  readonly resource: JsonRecord;
+  readonly raw: JsonRecord;
+}
+export declare function parsePayPalEvent(payload: string): PayPalEvent;
+export declare function payPalCaptureIdOfRefund(refund: JsonRecord): string | undefined;
+export declare function payPalOrderIdOfCapture(capture: JsonRecord): string | undefined;
+export interface PayPalPaymentOptions {
+  readonly method?: string | undefined;
+  readonly order?: JsonRecord | undefined;
+  readonly capture?: JsonRecord | undefined;
+}
+export declare function payPalPaymentEvent(event: PayPalEvent, options?: PayPalPaymentOptions): PaymentEvent | undefined;
+export interface PayPalWebhookOptions extends PaymentWebhookBaseOptions {
+  readonly webhookId: string;
+  readonly clientId: string;
+  readonly clientSecret: string;
+  readonly sandbox?: boolean | undefined;
+  readonly apiUrl?: string | undefined;
+  readonly fetchOrder?: boolean | undefined;
+}
+export declare function payPalWebhook(options: PayPalWebhookOptions): WebhookHandler;
+//#endregion