@happyvertical/accounting 0.79.0 → 0.80.1

package/dist/chunks/stripe-BhTiF2Xx.js

@@ -0,0 +1,644 @@
+import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+//#region src/providers/stripe/index.ts
+/**
+* Stripe Provider
+*
+* Implements Stripe AR, payment, webhook, and billing operations using the
+* Stripe HTTP API directly. The SDK keeps Stripe as an optional runtime
+* dependency by relying on the platform fetch implementation.
+*/
+/**
+* Stripe accounting provider.
+*/
+var StripeProvider = class {
+	type = "stripe";
+	options;
+	fetchImpl;
+	customers;
+	invoices;
+	vendors;
+	bills;
+	payments;
+	audit;
+	webhooks;
+	billing;
+	constructor(options) {
+		this.options = {
+			timeout: 3e4,
+			maxRetries: 3,
+			apiBaseUrl: "https://api.stripe.com",
+			webhookTolerance: 300,
+			...options
+		};
+		this.fetchImpl = options.fetch || fetch;
+		this.customers = new StripeCustomerOperations(this);
+		this.invoices = new StripeInvoiceOperations(this);
+		this.vendors = new UnsupportedVendorOperations();
+		this.bills = new UnsupportedBillOperations();
+		this.payments = new StripePaymentOperations(this);
+		this.audit = new StripeAuditOperations(this);
+		this.webhooks = new StripeWebhookOperations(this.options);
+		this.billing = new StripeBillingOperationsImpl(this);
+	}
+	async request(method, endpoint, params) {
+		const timeout = this.options.timeout || 3e4;
+		const maxRetries = this.options.maxRetries || 3;
+		const idempotencyKey = method === "POST" ? `sdk-${randomUUID()}` : null;
+		let lastError = null;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), timeout);
+			try {
+				const url = this.buildUrl(endpoint, method === "GET" ? params : {});
+				const body = method === "POST" && params ? encodeStripeForm(params).toString() : void 0;
+				const headers = {
+					Authorization: `Bearer ${this.options.secretKey}`,
+					Accept: "application/json"
+				};
+				if (method === "POST") {
+					headers["Content-Type"] = "application/x-www-form-urlencoded";
+					if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
+				}
+				if (this.options.apiVersion) headers["Stripe-Version"] = this.options.apiVersion;
+				const response = await this.fetchImpl(url, {
+					method,
+					headers,
+					body,
+					signal: controller.signal
+				});
+				if (!response.ok) {
+					const errorText = await response.text();
+					const error = /* @__PURE__ */ new Error(`Stripe API error (${response.status}): ${errorText}`);
+					if (response.status < 500 && response.status !== 429) throw error;
+					lastError = error;
+				} else {
+					const text = await response.text();
+					return text ? JSON.parse(text) : {};
+				}
+			} catch (error) {
+				lastError = error instanceof Error ? error : new Error(String(error));
+				const statusMatch = lastError.message.match(/Stripe API error \((\d+)\)/);
+				if (statusMatch) {
+					const status = Number.parseInt(statusMatch[1], 10);
+					if (status >= 400 && status < 500 && status !== 429) throw lastError;
+				}
+			} finally {
+				clearTimeout(timeoutId);
+			}
+			if (attempt < maxRetries) await sleep(2 ** attempt * 500);
+		}
+		throw lastError || /* @__PURE__ */ new Error("Stripe request failed after retries");
+	}
+	buildUrl(endpoint, params) {
+		const baseUrl = this.options.apiBaseUrl || "https://api.stripe.com";
+		const url = new URL(endpoint, baseUrl);
+		if (params && Object.keys(params).length > 0) for (const [key, value] of encodeStripeForm(params).entries()) url.searchParams.append(key, value);
+		return url.toString();
+	}
+};
+var StripeCustomerOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async push(customer) {
+		return {
+			action: "created",
+			externalId: (await this.provider.request("POST", "/v1/customers", mapCustomerToStripe(customer))).id,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async pull(externalId) {
+		return mapStripeCustomer(await this.provider.request("GET", `/v1/customers/${encodeURIComponent(externalId)}`));
+	}
+	async list(options = {}) {
+		return (await this.provider.request("GET", "/v1/customers", mapListOptions(options))).data.map(mapStripeCustomer);
+	}
+	async sync(customer) {
+		if (!customer.externalId) return this.push(customer);
+		await this.provider.request("POST", `/v1/customers/${encodeURIComponent(customer.externalId)}`, mapCustomerToStripe(customer));
+		return {
+			action: "updated",
+			externalId: customer.externalId,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+};
+var StripeInvoiceOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async push(invoice) {
+		if (!invoice.customerExternalId) throw new Error("Stripe invoices require customerExternalId");
+		for (const lineItem of invoice.lineItems) await this.provider.request("POST", "/v1/invoiceitems", {
+			customer: invoice.customerExternalId,
+			currency: invoice.currency || "usd",
+			description: lineItem.description,
+			quantity: lineItem.quantity,
+			unit_amount_decimal: String(Math.round(lineItem.unitPrice * 100)),
+			metadata: normalizeMetadata({
+				local_sku: lineItem.sku,
+				local_discount: lineItem.discount,
+				local_tax_rate: lineItem.taxRate
+			})
+		});
+		return {
+			action: "created",
+			externalId: (await this.provider.request("POST", "/v1/invoices", mapInvoiceToStripe(invoice))).id,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async pull(externalId) {
+		return mapStripeInvoice(await this.provider.request("GET", `/v1/invoices/${encodeURIComponent(externalId)}`));
+	}
+	async list(options = {}) {
+		return (await this.provider.request("GET", "/v1/invoices", mapListOptions(options))).data.map(mapStripeInvoice);
+	}
+	async sync(invoice) {
+		if (!invoice.externalId) return this.push(invoice);
+		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(invoice.externalId)}`, mapInvoiceUpdateToStripe(invoice));
+		return {
+			action: "updated",
+			externalId: invoice.externalId,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async send(externalId) {
+		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(externalId)}/send`);
+	}
+	async void(externalId) {
+		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(externalId)}/void`);
+	}
+};
+var StripePaymentOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async pull(externalId) {
+		return mapStripePaymentIntent(await this.provider.request("GET", `/v1/payment_intents/${encodeURIComponent(externalId)}`));
+	}
+	async list(options = {}) {
+		return (await this.provider.request("GET", "/v1/payment_intents", mapListOptions(options))).data.map(mapStripePaymentIntent);
+	}
+};
+var StripeBillingOperationsImpl = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async createCheckoutSession(input) {
+		const response = await this.provider.request("POST", "/v1/checkout/sessions", mapCheckoutSessionToStripe(input));
+		return {
+			externalId: response.id,
+			url: response.url || null,
+			customerExternalId: response.customer || void 0,
+			subscriptionExternalId: response.subscription || void 0,
+			paymentIntentExternalId: response.payment_intent || void 0,
+			raw: response
+		};
+	}
+	async createCustomerPortalSession(input) {
+		const response = await this.provider.request("POST", "/v1/billing_portal/sessions", {
+			customer: input.customerExternalId,
+			return_url: input.returnUrl,
+			configuration: input.configurationExternalId
+		});
+		return {
+			externalId: response.id,
+			url: response.url,
+			raw: response
+		};
+	}
+	async retrieveSubscriptionStatus(subscriptionExternalId) {
+		return mapStripeSubscription(await this.provider.request("GET", `/v1/subscriptions/${encodeURIComponent(subscriptionExternalId)}`));
+	}
+	async listCustomerSubscriptions(customerExternalId) {
+		return (await this.provider.request("GET", "/v1/subscriptions", {
+			customer: customerExternalId,
+			status: "all",
+			limit: 100
+		})).data.map(mapStripeSubscription);
+	}
+};
+var UnsupportedVendorOperations = class {
+	async push(_vendor) {
+		throw new Error("Stripe does not support vendor operations");
+	}
+	async pull(_externalId) {
+		throw new Error("Stripe does not support vendor operations");
+	}
+	async list(_options) {
+		throw new Error("Stripe does not support vendor operations");
+	}
+	async sync(_vendor) {
+		throw new Error("Stripe does not support vendor operations");
+	}
+};
+var UnsupportedBillOperations = class {
+	async push(_bill) {
+		throw new Error("Stripe does not support bill operations");
+	}
+	async pull(_externalId) {
+		throw new Error("Stripe does not support bill operations");
+	}
+	async list(_options) {
+		throw new Error("Stripe does not support bill operations");
+	}
+	async sync(_bill) {
+		throw new Error("Stripe does not support bill operations");
+	}
+};
+var StripeAuditOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async reconcileCustomers(locals) {
+		return reconcileRecords("stripe", locals, await this.provider.customers.list({ limit: 100 }), compareCustomer);
+	}
+	async reconcileInvoices(locals, dateRange) {
+		return reconcileRecords("stripe", locals, await this.provider.invoices.list({
+			limit: 100,
+			startDate: dateRange?.start,
+			endDate: dateRange?.end
+		}), compareInvoice);
+	}
+	async reconcileVendors(_locals) {
+		throw new Error("Stripe does not support vendor operations");
+	}
+	async reconcileBills(_locals) {
+		throw new Error("Stripe does not support bill operations");
+	}
+	async reconcilePayments(locals, dateRange) {
+		return reconcileRecords("stripe", locals, await this.provider.payments.list({
+			limit: 100,
+			startDate: dateRange?.start,
+			endDate: dateRange?.end
+		}), comparePayment);
+	}
+};
+var StripeWebhookOperations = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	verify(payload, signature, secret) {
+		const endpointSecret = secret || this.options.webhookSecret;
+		if (!endpointSecret) throw new Error("Stripe webhook secret not provided. Pass it as the secret parameter or configure webhookSecret in options.");
+		const parsed = parseStripeSignatureHeader(signature);
+		if (!parsed.timestamp || parsed.signatures.length === 0) return false;
+		const tolerance = this.options.webhookTolerance ?? 300;
+		const timestamp = Number.parseInt(parsed.timestamp, 10);
+		if (!Number.isFinite(timestamp) || Math.abs(Date.now() / 1e3 - timestamp) > tolerance) return false;
+		const signedPayload = `${parsed.timestamp}.${payload}`;
+		const expected = createHmac("sha256", endpointSecret).update(signedPayload).digest("hex");
+		return parsed.signatures.some((value) => constantTimeEqualHex(value, expected));
+	}
+	parse(payload) {
+		let event;
+		try {
+			event = JSON.parse(payload);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+			throw new Error(`Invalid Stripe webhook payload: ${message}`);
+		}
+		const resource = event?.data?.object;
+		return {
+			type: event?.type || "unknown",
+			provider: "stripe",
+			timestamp: unixToDate(event?.created) || /* @__PURE__ */ new Date(),
+			payload: event,
+			resourceType: mapStripeResourceType(resource?.object || void 0, event?.type || void 0),
+			resourceId: typeof resource?.id === "string" ? resource.id : void 0
+		};
+	}
+};
+function encodeStripeForm(params) {
+	const form = new URLSearchParams();
+	for (const [key, value] of Object.entries(params)) appendStripeFormValue(form, key, value);
+	return form;
+}
+function appendStripeFormValue(form, key, value) {
+	if (value === void 0 || value === null) return;
+	if (value instanceof Date) {
+		form.append(key, String(toUnixSeconds(value)));
+		return;
+	}
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => {
+			appendStripeFormValue(form, `${key}[${index}]`, item);
+		});
+		return;
+	}
+	if (typeof value === "object") {
+		for (const [childKey, childValue] of Object.entries(value)) appendStripeFormValue(form, `${key}[${childKey}]`, childValue);
+		return;
+	}
+	form.append(key, String(value));
+}
+function mapCustomerToStripe(customer) {
+	const stripeCustomer = {
+		name: customer.name,
+		email: customer.email,
+		phone: customer.phone,
+		address: customer.billingAddress ? {
+			line1: customer.billingAddress.street1,
+			line2: customer.billingAddress.street2,
+			city: customer.billingAddress.city,
+			state: customer.billingAddress.state,
+			postal_code: customer.billingAddress.postalCode,
+			country: customer.billingAddress.country
+		} : void 0,
+		metadata: normalizeMetadata({
+			local_id: customer.id,
+			payment_terms: customer.paymentTerms,
+			...customer.metadata
+		})
+	};
+	if (customer.taxExempt !== void 0) stripeCustomer.tax_exempt = customer.taxExempt ? "exempt" : "none";
+	return stripeCustomer;
+}
+function mapInvoiceToStripe(invoice) {
+	return {
+		customer: invoice.customerExternalId,
+		collection_method: "send_invoice",
+		due_date: invoice.dueDate,
+		auto_advance: false,
+		pending_invoice_items_behavior: "include",
+		metadata: normalizeMetadata({
+			local_id: invoice.id,
+			invoice_number: invoice.invoiceNumber,
+			reference: invoice.reference,
+			memo: invoice.memo,
+			tax_amount: invoice.taxAmount,
+			subtotal: invoice.subtotal,
+			total_amount: invoice.totalAmount,
+			...invoice.metadata
+		})
+	};
+}
+function mapInvoiceUpdateToStripe(invoice) {
+	return {
+		due_date: invoice.dueDate,
+		metadata: normalizeMetadata({
+			local_id: invoice.id,
+			invoice_number: invoice.invoiceNumber,
+			reference: invoice.reference,
+			memo: invoice.memo,
+			...invoice.metadata
+		})
+	};
+}
+function mapCheckoutSessionToStripe(input) {
+	return {
+		mode: input.mode || "subscription",
+		success_url: input.successUrl,
+		cancel_url: input.cancelUrl,
+		customer: input.customerExternalId,
+		customer_email: input.customerExternalId ? void 0 : input.customerEmail,
+		client_reference_id: input.clientReferenceId,
+		allow_promotion_codes: input.allowPromotionCodes,
+		line_items: input.lineItems.map(mapCheckoutLineItem),
+		metadata: normalizeMetadata(input.metadata || {})
+	};
+}
+function mapCheckoutLineItem(lineItem) {
+	if (lineItem.price) return {
+		price: lineItem.price,
+		quantity: lineItem.quantity || 1
+	};
+	if (!lineItem.priceData) throw new Error("Stripe checkout line item requires price or priceData");
+	const productData = lineItem.priceData.product ? void 0 : { name: lineItem.priceData.productName || "Subscription" };
+	return {
+		quantity: lineItem.quantity || 1,
+		price_data: {
+			currency: lineItem.priceData.currency,
+			unit_amount: lineItem.priceData.unitAmount,
+			product: lineItem.priceData.product,
+			product_data: productData,
+			recurring: lineItem.priceData.recurring ? {
+				interval: lineItem.priceData.recurring.interval,
+				interval_count: lineItem.priceData.recurring.intervalCount
+			} : void 0
+		}
+	};
+}
+function mapListOptions(options) {
+	return {
+		limit: options.limit,
+		starting_after: typeof options.offset === "string" ? options.offset : void 0,
+		created: {
+			gte: options.startDate,
+			lte: options.endDate
+		},
+		status: options.status
+	};
+}
+function mapStripeCustomer(customer) {
+	return {
+		externalId: customer.id,
+		provider: "stripe",
+		syncedAt: /* @__PURE__ */ new Date(),
+		name: customer.name || "",
+		email: customer.email || void 0,
+		phone: customer.phone || void 0,
+		billingAddress: customer.address ? {
+			street1: customer.address.line1 || void 0,
+			street2: customer.address.line2 || void 0,
+			city: customer.address.city || void 0,
+			state: customer.address.state || void 0,
+			postalCode: customer.address.postal_code || void 0,
+			country: customer.address.country || void 0
+		} : void 0,
+		balance: customer.balance === null || customer.balance === void 0 ? void 0 : centsToMoney(customer.balance),
+		currency: customer.currency || void 0,
+		raw: customer
+	};
+}
+function mapStripeInvoice(invoice) {
+	return {
+		externalId: invoice.id,
+		provider: "stripe",
+		syncedAt: /* @__PURE__ */ new Date(),
+		invoiceNumber: invoice.number || invoice.id,
+		customerExternalId: typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id || "",
+		issueDate: unixToDate(invoice.created) || /* @__PURE__ */ new Date(),
+		dueDate: unixToDate(invoice.due_date) || unixToDate(invoice.created) || /* @__PURE__ */ new Date(),
+		subtotal: centsToMoney(invoice.subtotal || 0),
+		taxAmount: centsToMoney(invoice.tax || 0),
+		totalAmount: centsToMoney(invoice.total || 0),
+		amountPaid: centsToMoney(invoice.amount_paid || 0),
+		balance: centsToMoney(invoice.amount_remaining || 0),
+		status: mapStripeInvoiceStatus(invoice.status, invoice.due_date),
+		currency: invoice.currency || "usd",
+		raw: invoice
+	};
+}
+function mapStripePaymentIntent(paymentIntent) {
+	return {
+		externalId: paymentIntent.id,
+		provider: "stripe",
+		syncedAt: /* @__PURE__ */ new Date(),
+		amount: centsToMoney(paymentIntent.amount || 0),
+		currency: paymentIntent.currency || "usd",
+		paidAt: unixToDate(paymentIntent.created) || /* @__PURE__ */ new Date(),
+		method: paymentIntent.payment_method_types?.[0],
+		transactionId: paymentIntent.latest_charge || paymentIntent.id,
+		invoiceExternalIds: paymentIntent.invoice ? [paymentIntent.invoice] : void 0,
+		status: mapStripePaymentStatus(paymentIntent.status),
+		raw: paymentIntent
+	};
+}
+function mapStripeSubscription(subscription) {
+	return {
+		externalId: subscription.id,
+		status: subscription.status,
+		customerExternalId: typeof subscription.customer === "string" ? subscription.customer : subscription.customer.id,
+		currentPeriodStart: unixToDate(subscription.current_period_start),
+		currentPeriodEnd: unixToDate(subscription.current_period_end),
+		cancelAtPeriodEnd: Boolean(subscription.cancel_at_period_end),
+		canceledAt: unixToDate(subscription.canceled_at),
+		trialEnd: unixToDate(subscription.trial_end),
+		raw: subscription
+	};
+}
+function mapStripeInvoiceStatus(status, dueDate) {
+	switch (status) {
+		case "draft": return "draft";
+		case "paid": return "paid";
+		case "void": return "voided";
+		case "open":
+			if (dueDate && dueDate * 1e3 < Date.now()) return "overdue";
+			return "sent";
+		default: return "sent";
+	}
+}
+function mapStripePaymentStatus(status) {
+	switch (status) {
+		case "succeeded": return "completed";
+		case "processing":
+		case "requires_action":
+		case "requires_capture":
+		case "requires_confirmation": return "pending";
+		case "canceled":
+		case "requires_payment_method": return "failed";
+		default: return "pending";
+	}
+}
+function mapStripeResourceType(object, eventType) {
+	if (object === "customer" || eventType?.startsWith("customer.")) return "customer";
+	if (object === "invoice" || eventType?.startsWith("invoice.")) return "invoice";
+	if (object === "payment_intent" || object === "charge" || eventType?.startsWith("payment_intent.") || eventType?.startsWith("charge.")) return "payment";
+}
+function normalizeMetadata(metadata) {
+	const normalized = {};
+	for (const [key, value] of Object.entries(metadata)) if (value !== void 0 && value !== null) normalized[key] = String(value);
+	return normalized;
+}
+function parseStripeSignatureHeader(signature) {
+	const parts = signature.split(",").map((part) => part.trim());
+	const parsed = { signatures: [] };
+	for (const part of parts) {
+		const separatorIndex = part.indexOf("=");
+		if (separatorIndex === -1) continue;
+		const key = part.slice(0, separatorIndex);
+		const value = part.slice(separatorIndex + 1);
+		if (key === "t") parsed.timestamp = value;
+		if (key === "v1" && value) parsed.signatures.push(value);
+	}
+	return parsed;
+}
+function constantTimeEqualHex(left, right) {
+	try {
+		const leftBuffer = Buffer.from(left, "hex");
+		const rightBuffer = Buffer.from(right, "hex");
+		return leftBuffer.length === rightBuffer.length && timingSafeEqual(leftBuffer, rightBuffer);
+	} catch {
+		return false;
+	}
+}
+function reconcileRecords(provider, locals, externals, compare) {
+	const externalById = new Map(externals.map((external) => [external.externalId, external]));
+	const matched = [];
+	const discrepancies = [];
+	const localOnly = [];
+	const seenExternalIds = /* @__PURE__ */ new Set();
+	for (const local of locals) {
+		const external = local.externalId ? externalById.get(local.externalId) : void 0;
+		if (!external) {
+			localOnly.push(local);
+			continue;
+		}
+		seenExternalIds.add(external.externalId);
+		const differences = compare(local, external);
+		if (differences.length === 0) matched.push({
+			local,
+			external,
+			status: "identical"
+		});
+		else discrepancies.push({
+			local,
+			external,
+			differences
+		});
+	}
+	const externalOnly = externals.filter((external) => !seenExternalIds.has(external.externalId));
+	return {
+		provider,
+		auditedAt: /* @__PURE__ */ new Date(),
+		matched,
+		localOnly,
+		externalOnly,
+		discrepancies,
+		summary: {
+			total: locals.length + externalOnly.length,
+			matched: matched.length,
+			localOnly: localOnly.length,
+			externalOnly: externalOnly.length,
+			discrepancies: discrepancies.length
+		}
+	};
+}
+function compareCustomer(local, external) {
+	const customer = external;
+	return [compareField("name", local.name, customer.name), compareField("email", local.email, customer.email)].filter((diff) => Boolean(diff));
+}
+function compareInvoice(local, external) {
+	const invoice = external;
+	return [compareField("totalAmount", local.totalAmount, invoice.totalAmount), compareField("currency", local.currency || "usd", invoice.currency)].filter((diff) => Boolean(diff));
+}
+function comparePayment(local, external) {
+	const payment = external;
+	return [compareField("amount", local.amount, payment.amount), compareField("currency", local.currency || "usd", payment.currency)].filter((diff) => Boolean(diff));
+}
+function compareField(field, localValue, externalValue) {
+	if (valuesEqual(localValue, externalValue)) return null;
+	return {
+		field,
+		localValue,
+		externalValue
+	};
+}
+function valuesEqual(left, right) {
+	if (left === right) return true;
+	if (typeof left === "number" && typeof right === "number") return Math.abs(left - right) < .01;
+	return false;
+}
+function centsToMoney(cents) {
+	return cents / 100;
+}
+function toUnixSeconds(date) {
+	return Math.floor(date.getTime() / 1e3);
+}
+function unixToDate(value) {
+	return value === null || value === void 0 ? void 0 : /* @__PURE__ */ new Date(value * 1e3);
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+export { StripeProvider };
+
+//# sourceMappingURL=stripe-BhTiF2Xx.js.map