@happyvertical/accounting 0.80.0 → 0.80.2

package/dist/chunks/quickbooks-BF3GrJBw.js

@@ -0,0 +1,773 @@
+import { createHmac } from "node:crypto";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+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;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+//#region src/providers/quickbooks/index.ts
+/**
+* QuickBooks Online Provider
+*
+* Implements the AccountingProvider interface for QuickBooks Online.
+* Uses the Intuit OAuth2 library for authentication and the QBO API for operations.
+*/
+/**
+* Format a Date to YYYY-MM-DD in local timezone (not UTC)
+* This prevents timezone conversion issues where dates shift by a day
+*/
+function formatLocalDate(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+/**
+* Sleep for a given number of milliseconds
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Compare two values for equality (handles dates, objects, etc.)
+*/
+function valuesEqual(a, b) {
+	if (a === b) return true;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) < .01;
+	return false;
+}
+/**
+* QuickBooks Online accounting provider
+*/
+var QuickBooksProvider = class {
+	type = "quickbooks";
+	options;
+	accessToken = null;
+	tokenExpiresAt = null;
+	customers;
+	invoices;
+	vendors;
+	bills;
+	payments;
+	audit;
+	webhooks;
+	constructor(options) {
+		this.options = {
+			timeout: 3e4,
+			maxRetries: 3,
+			...options
+		};
+		this.customers = new QuickBooksCustomerOperations(this);
+		this.invoices = new QuickBooksInvoiceOperations(this);
+		this.vendors = new QuickBooksVendorOperations(this);
+		this.bills = new QuickBooksBillOperations(this);
+		this.payments = new QuickBooksPaymentOperations(this);
+		this.audit = new QuickBooksAuditOperations(this);
+		this.webhooks = new QuickBooksWebhookOperations(this.options);
+	}
+	/**
+	* Get the QBO API base URL
+	*/
+	get baseUrl() {
+		return this.options.environment === "production" ? "https://quickbooks.api.intuit.com" : "https://sandbox-quickbooks.api.intuit.com";
+	}
+	/**
+	* Get the company/realm ID
+	*/
+	get realmId() {
+		return this.options.realmId;
+	}
+	/**
+	* Ensure we have a valid access token, refreshing if needed
+	*/
+	async ensureAccessToken() {
+		if (this.accessToken && this.tokenExpiresAt) {
+			if ((/* @__PURE__ */ new Date()).getTime() < this.tokenExpiresAt.getTime() - 300 * 1e3) return this.accessToken;
+		}
+		const tokens = await this.refreshAccessToken();
+		this.accessToken = tokens.accessToken;
+		this.tokenExpiresAt = tokens.expiresAt;
+		this.options.refreshToken = tokens.refreshToken;
+		if (this.options.onTokenRefresh) await this.options.onTokenRefresh(tokens);
+		return this.accessToken;
+	}
+	/**
+	* Refresh the OAuth access token
+	*/
+	async refreshAccessToken() {
+		const OAuthClient = (await import("./OAuthClient-Bv-lzpx8.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))).default;
+		const redirectUri = this.options.redirectUri || "https://developer.intuit.com/v2/OAuth2Playground/RedirectUrl";
+		const oauthClient = new OAuthClient({
+			clientId: this.options.clientId,
+			clientSecret: this.options.clientSecret,
+			environment: this.options.environment === "production" ? "production" : "sandbox",
+			redirectUri
+		});
+		oauthClient.setToken({
+			refresh_token: this.options.refreshToken,
+			access_token: this.accessToken || ""
+		});
+		const token = (await oauthClient.refresh()).getJson();
+		return {
+			accessToken: token.access_token,
+			refreshToken: token.refresh_token,
+			expiresAt: new Date(Date.now() + token.expires_in * 1e3),
+			tokenType: token.token_type
+		};
+	}
+	/**
+	* Make an authenticated request to the QBO API with timeout and retry support
+	*/
+	async request(method, endpoint, body) {
+		const accessToken = await this.ensureAccessToken();
+		const url = `${this.baseUrl}/v3/company/${this.realmId}/${endpoint}`;
+		const timeout = this.options.timeout || 3e4;
+		const maxRetries = this.options.maxRetries || 3;
+		let lastError = null;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), timeout);
+			try {
+				const response = await fetch(url, {
+					method,
+					headers: {
+						Authorization: `Bearer ${accessToken}`,
+						Accept: "application/json",
+						"Content-Type": "application/json"
+					},
+					body: body ? JSON.stringify(body) : void 0,
+					signal: controller.signal
+				});
+				clearTimeout(timeoutId);
+				if (!response.ok) {
+					const errorText = await response.text();
+					if (response.status >= 400 && response.status < 500 && response.status !== 429) throw new Error(`QBO API error (${response.status}): ${errorText}`);
+					throw new Error(`QBO API error (${response.status}): ${errorText}`);
+				}
+				return await response.json();
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+			const statusMatch = lastError.message.match(/QBO API error \((\d+)\)/);
+			if (statusMatch) {
+				const status = Number.parseInt(statusMatch[1], 10);
+				if (status >= 400 && status < 500 && status !== 429) throw lastError;
+			}
+			if (attempt < maxRetries) await sleep(2 ** attempt * 1e3);
+		}
+		throw lastError || /* @__PURE__ */ new Error("Request failed after retries");
+	}
+	/**
+	* Execute a QBO query with pagination support
+	*/
+	async queryAll(entity, whereClause, maxResults = 1e3) {
+		const results = [];
+		let startPosition = 1;
+		const pageSize = 100;
+		while (results.length < maxResults) {
+			let query = `SELECT * FROM ${entity}`;
+			if (whereClause) query += ` WHERE ${whereClause}`;
+			query += ` MAXRESULTS ${pageSize} STARTPOSITION ${startPosition}`;
+			const items = (await this.request("GET", `query?query=${encodeURIComponent(query)}`)).QueryResponse[entity] || [];
+			results.push(...items);
+			if (items.length < pageSize) break;
+			startPosition += pageSize;
+		}
+		return results;
+	}
+};
+var QuickBooksCustomerOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async push(customer) {
+		const qboCustomer = mapCustomerToQBO(customer);
+		return {
+			action: "created",
+			externalId: (await this.provider.request("POST", "customer", qboCustomer)).Customer.Id,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async pull(externalId) {
+		return mapQBOToCustomer((await this.provider.request("GET", `customer/${externalId}`)).Customer);
+	}
+	async list(options) {
+		const limit = options?.limit || 1e3;
+		return (await this.provider.queryAll("Customer", void 0, limit)).map(mapQBOToCustomer);
+	}
+	async sync(customer) {
+		if (customer.externalId) {
+			const existing = await this.provider.request("GET", `customer/${customer.externalId}`);
+			const qboCustomer = {
+				...mapCustomerToQBO(customer),
+				Id: customer.externalId,
+				SyncToken: existing.Customer.SyncToken
+			};
+			await this.provider.request("POST", "customer", qboCustomer);
+			return {
+				action: "updated",
+				externalId: customer.externalId,
+				syncedAt: /* @__PURE__ */ new Date()
+			};
+		}
+		return this.push(customer);
+	}
+};
+var QuickBooksInvoiceOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async push(invoice) {
+		const qboInvoice = mapInvoiceToQBO(invoice);
+		return {
+			action: "created",
+			externalId: (await this.provider.request("POST", "invoice", qboInvoice)).Invoice.Id,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async pull(externalId) {
+		return mapQBOToInvoice((await this.provider.request("GET", `invoice/${externalId}`)).Invoice);
+	}
+	async list(options) {
+		const limit = options?.limit || 1e3;
+		let whereClause;
+		if (options?.startDate) {
+			whereClause = `TxnDate >= '${formatLocalDate(options.startDate)}'`;
+			if (options?.endDate) whereClause += ` AND TxnDate <= '${formatLocalDate(options.endDate)}'`;
+		}
+		return (await this.provider.queryAll("Invoice", whereClause, limit)).map(mapQBOToInvoice);
+	}
+	async sync(invoice) {
+		if (invoice.externalId) {
+			const existing = await this.provider.request("GET", `invoice/${invoice.externalId}`);
+			const qboInvoice = {
+				...mapInvoiceToQBO(invoice),
+				Id: invoice.externalId,
+				SyncToken: existing.Invoice.SyncToken
+			};
+			await this.provider.request("POST", "invoice", qboInvoice);
+			return {
+				action: "updated",
+				externalId: invoice.externalId,
+				syncedAt: /* @__PURE__ */ new Date()
+			};
+		}
+		return this.push(invoice);
+	}
+	async send(externalId) {
+		await this.provider.request("POST", `invoice/${externalId}/send`);
+	}
+	async void(externalId) {
+		const existing = await this.provider.request("GET", `invoice/${externalId}`);
+		await this.provider.request("POST", "invoice", {
+			Id: externalId,
+			SyncToken: existing.Invoice.SyncToken,
+			sparse: true,
+			PrivateNote: "VOIDED"
+		});
+	}
+};
+var QuickBooksVendorOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async push(vendor) {
+		const qboVendor = mapVendorToQBO(vendor);
+		return {
+			action: "created",
+			externalId: (await this.provider.request("POST", "vendor", qboVendor)).Vendor.Id,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async pull(externalId) {
+		return mapQBOToVendor((await this.provider.request("GET", `vendor/${externalId}`)).Vendor);
+	}
+	async list(options) {
+		const limit = options?.limit || 1e3;
+		return (await this.provider.queryAll("Vendor", void 0, limit)).map(mapQBOToVendor);
+	}
+	async sync(vendor) {
+		if (vendor.externalId) {
+			const existing = await this.provider.request("GET", `vendor/${vendor.externalId}`);
+			const qboVendor = {
+				...mapVendorToQBO(vendor),
+				Id: vendor.externalId,
+				SyncToken: existing.Vendor.SyncToken
+			};
+			await this.provider.request("POST", "vendor", qboVendor);
+			return {
+				action: "updated",
+				externalId: vendor.externalId,
+				syncedAt: /* @__PURE__ */ new Date()
+			};
+		}
+		return this.push(vendor);
+	}
+};
+var QuickBooksBillOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async push(bill) {
+		const qboBill = mapBillToQBO(bill);
+		return {
+			action: "created",
+			externalId: (await this.provider.request("POST", "bill", qboBill)).Bill.Id,
+			syncedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async pull(externalId) {
+		return mapQBOToBill((await this.provider.request("GET", `bill/${externalId}`)).Bill);
+	}
+	async list(options) {
+		const limit = options?.limit || 1e3;
+		let whereClause;
+		if (options?.startDate) {
+			whereClause = `TxnDate >= '${formatLocalDate(options.startDate)}'`;
+			if (options?.endDate) whereClause += ` AND TxnDate <= '${formatLocalDate(options.endDate)}'`;
+		}
+		return (await this.provider.queryAll("Bill", whereClause, limit)).map(mapQBOToBill);
+	}
+	async sync(bill) {
+		if (bill.externalId) {
+			const existing = await this.provider.request("GET", `bill/${bill.externalId}`);
+			const qboBill = {
+				...mapBillToQBO(bill),
+				Id: bill.externalId,
+				SyncToken: existing.Bill.SyncToken
+			};
+			await this.provider.request("POST", "bill", qboBill);
+			return {
+				action: "updated",
+				externalId: bill.externalId,
+				syncedAt: /* @__PURE__ */ new Date()
+			};
+		}
+		return this.push(bill);
+	}
+};
+var QuickBooksPaymentOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async pull(externalId) {
+		return mapQBOToPayment((await this.provider.request("GET", `payment/${externalId}`)).Payment);
+	}
+	async list(options) {
+		const limit = options?.limit || 1e3;
+		let whereClause;
+		if (options?.startDate) {
+			whereClause = `TxnDate >= '${formatLocalDate(options.startDate)}'`;
+			if (options?.endDate) whereClause += ` AND TxnDate <= '${formatLocalDate(options.endDate)}'`;
+		}
+		return (await this.provider.queryAll("Payment", whereClause, limit)).map(mapQBOToPayment);
+	}
+};
+var QuickBooksAuditOperations = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async reconcileCustomers(locals) {
+		return reconcileRecords(locals, await this.provider.customers.list({ limit: 1e4 }), (l) => l.externalId, (e) => e.externalId, compareCustomer);
+	}
+	async reconcileInvoices(locals, dateRange) {
+		return reconcileRecords(locals, await this.provider.invoices.list({
+			limit: 1e4,
+			startDate: dateRange?.start,
+			endDate: dateRange?.end
+		}), (l) => l.externalId, (e) => e.externalId, compareInvoice);
+	}
+	async reconcileVendors(locals) {
+		return reconcileRecords(locals, await this.provider.vendors.list({ limit: 1e4 }), (l) => l.externalId, (e) => e.externalId, compareVendor);
+	}
+	async reconcileBills(locals, dateRange) {
+		return reconcileRecords(locals, await this.provider.bills.list({
+			limit: 1e4,
+			startDate: dateRange?.start,
+			endDate: dateRange?.end
+		}), (l) => l.externalId, (e) => e.externalId, compareBill);
+	}
+	async reconcilePayments(locals, dateRange) {
+		return reconcileRecords(locals, await this.provider.payments.list({
+			limit: 1e4,
+			startDate: dateRange?.start,
+			endDate: dateRange?.end
+		}), (l) => l.externalId, (e) => e.externalId, comparePayment);
+	}
+};
+/**
+* Generic reconciliation function with field comparison
+*/
+function reconcileRecords(locals, externals, getLocalExternalId, getExternalId, compareFields) {
+	const externalMap = new Map(externals.map((e) => [getExternalId(e), e]));
+	const matchedExternalIds = /* @__PURE__ */ new Set();
+	const matched = [];
+	const localOnly = [];
+	const discrepancies = [];
+	for (const local of locals) {
+		const externalId = getLocalExternalId(local);
+		if (externalId && externalMap.has(externalId)) {
+			const external = externalMap.get(externalId);
+			matchedExternalIds.add(externalId);
+			const differences = compareFields(local, external);
+			if (differences.length === 0) matched.push({
+				local,
+				external,
+				status: "identical"
+			});
+			else discrepancies.push({
+				local,
+				external,
+				differences
+			});
+		} else localOnly.push(local);
+	}
+	const externalOnly = externals.filter((e) => !matchedExternalIds.has(getExternalId(e)));
+	return {
+		provider: "quickbooks",
+		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 diffs = [];
+	if (local.name !== external.name) diffs.push({
+		field: "name",
+		localValue: local.name,
+		externalValue: external.name
+	});
+	if (local.email !== external.email) diffs.push({
+		field: "email",
+		localValue: local.email,
+		externalValue: external.email
+	});
+	return diffs;
+}
+function compareInvoice(local, external) {
+	const diffs = [];
+	if (!valuesEqual(local.totalAmount, external.totalAmount)) diffs.push({
+		field: "totalAmount",
+		localValue: local.totalAmount,
+		externalValue: external.totalAmount
+	});
+	if (local.invoiceNumber !== external.invoiceNumber) diffs.push({
+		field: "invoiceNumber",
+		localValue: local.invoiceNumber,
+		externalValue: external.invoiceNumber
+	});
+	return diffs;
+}
+function compareVendor(local, external) {
+	const diffs = [];
+	if (local.name !== external.name) diffs.push({
+		field: "name",
+		localValue: local.name,
+		externalValue: external.name
+	});
+	if (local.email !== external.email) diffs.push({
+		field: "email",
+		localValue: local.email,
+		externalValue: external.email
+	});
+	return diffs;
+}
+function compareBill(local, external) {
+	const diffs = [];
+	if (!valuesEqual(local.totalAmount, external.totalAmount)) diffs.push({
+		field: "totalAmount",
+		localValue: local.totalAmount,
+		externalValue: external.totalAmount
+	});
+	return diffs;
+}
+function comparePayment(local, external) {
+	const diffs = [];
+	if (!valuesEqual(local.amount, external.amount)) diffs.push({
+		field: "amount",
+		localValue: local.amount,
+		externalValue: external.amount
+	});
+	return diffs;
+}
+var QuickBooksWebhookOperations = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* Verify webhook signature using HMAC-SHA256
+	* @see https://developer.intuit.com/app/developer/qbo/docs/develop/webhooks/verify-webhooks
+	*/
+	verify(payload, signature, secret) {
+		const verifierToken = secret || this.options.webhookVerifierToken;
+		if (!verifierToken) throw new Error("Webhook verifier token not provided. Pass it as the secret parameter or configure webhookVerifierToken in options.");
+		const hmac = createHmac("sha256", verifierToken);
+		hmac.update(payload);
+		const expectedSignature = hmac.digest("base64");
+		if (signature.length !== expectedSignature.length) return false;
+		let result = 0;
+		for (let i = 0; i < signature.length; i++) result |= signature.charCodeAt(i) ^ expectedSignature.charCodeAt(i);
+		return result === 0;
+	}
+	parse(payload) {
+		let data;
+		try {
+			data = JSON.parse(payload);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+			throw new Error(`Invalid QuickBooks webhook payload: ${message}`);
+		}
+		const firstEvent = (data.eventNotifications || [])[0]?.dataChangeEvent?.entities?.[0];
+		return {
+			type: firstEvent?.operation || "unknown",
+			provider: "quickbooks",
+			timestamp: /* @__PURE__ */ new Date(),
+			payload: data,
+			resourceType: mapQBOResourceType(firstEvent?.name),
+			resourceId: firstEvent?.id
+		};
+	}
+};
+function mapQBOResourceType(name) {
+	switch (name?.toLowerCase()) {
+		case "customer": return "customer";
+		case "invoice": return "invoice";
+		case "payment": return "payment";
+		case "vendor": return "vendor";
+		case "bill": return "bill";
+		default: return;
+	}
+}
+function mapCustomerToQBO(customer) {
+	return {
+		DisplayName: customer.name,
+		PrimaryEmailAddr: customer.email ? { Address: customer.email } : void 0,
+		PrimaryPhone: customer.phone ? { FreeFormNumber: customer.phone } : void 0,
+		BillAddr: mapAddressToQBO(customer.billingAddress),
+		ShipAddr: mapAddressToQBO(customer.shippingAddress),
+		CurrencyRef: customer.currency ? { value: customer.currency } : void 0
+	};
+}
+function mapQBOToCustomer(qbo) {
+	return {
+		externalId: qbo.Id,
+		provider: "quickbooks",
+		syncedAt: /* @__PURE__ */ new Date(),
+		name: qbo.DisplayName,
+		email: qbo.PrimaryEmailAddr?.Address,
+		phone: qbo.PrimaryPhone?.FreeFormNumber,
+		billingAddress: mapQBOToAddress(qbo.BillAddr),
+		balance: qbo.Balance,
+		currency: qbo.CurrencyRef?.value,
+		raw: qbo
+	};
+}
+function mapInvoiceToQBO(invoice) {
+	return {
+		CustomerRef: { value: invoice.customerExternalId || invoice.customerId },
+		DocNumber: invoice.invoiceNumber,
+		TxnDate: formatLocalDate(invoice.issueDate),
+		DueDate: formatLocalDate(invoice.dueDate),
+		Line: invoice.lineItems.map((item, idx) => ({
+			LineNum: idx + 1,
+			Description: item.description,
+			Amount: item.amount ?? item.quantity * item.unitPrice,
+			DetailType: "SalesItemLineDetail",
+			SalesItemLineDetail: {
+				Qty: item.quantity,
+				UnitPrice: item.unitPrice
+			}
+		})),
+		CurrencyRef: invoice.currency ? { value: invoice.currency } : void 0,
+		CustomerMemo: invoice.memo ? { value: invoice.memo } : void 0
+	};
+}
+function mapQBOToInvoice(qbo) {
+	const balance = qbo.Balance ?? 0;
+	const totalAmount = qbo.TotalAmt ?? 0;
+	return {
+		externalId: qbo.Id,
+		provider: "quickbooks",
+		syncedAt: /* @__PURE__ */ new Date(),
+		invoiceNumber: qbo.DocNumber || "",
+		customerExternalId: qbo.CustomerRef?.value || "",
+		issueDate: new Date(qbo.TxnDate),
+		dueDate: new Date(qbo.DueDate),
+		subtotal: totalAmount - (qbo.TxnTaxDetail?.TotalTax ?? 0),
+		taxAmount: qbo.TxnTaxDetail?.TotalTax ?? 0,
+		totalAmount,
+		amountPaid: totalAmount - balance,
+		balance,
+		status: mapInvoiceStatus(balance, totalAmount, qbo.DueDate),
+		currency: qbo.CurrencyRef?.value || "USD",
+		raw: qbo
+	};
+}
+function mapInvoiceStatus(balance, total, dueDate) {
+	if (balance === 0) return "paid";
+	if (balance < total) return "viewed";
+	if (new Date(dueDate) < /* @__PURE__ */ new Date()) return "overdue";
+	return "sent";
+}
+function mapVendorToQBO(vendor) {
+	return {
+		DisplayName: vendor.name,
+		PrimaryEmailAddr: vendor.email ? { Address: vendor.email } : void 0,
+		PrimaryPhone: vendor.phone ? { FreeFormNumber: vendor.phone } : void 0,
+		BillAddr: mapAddressToQBO(vendor.address),
+		TaxIdentifier: vendor.taxId,
+		CurrencyRef: vendor.currency ? { value: vendor.currency } : void 0
+	};
+}
+function mapQBOToVendor(qbo) {
+	return {
+		externalId: qbo.Id,
+		provider: "quickbooks",
+		syncedAt: /* @__PURE__ */ new Date(),
+		name: qbo.DisplayName,
+		email: qbo.PrimaryEmailAddr?.Address,
+		phone: qbo.PrimaryPhone?.FreeFormNumber,
+		address: mapQBOToAddress(qbo.BillAddr),
+		balance: qbo.Balance,
+		currency: qbo.CurrencyRef?.value,
+		raw: qbo
+	};
+}
+function mapBillToQBO(bill) {
+	return {
+		VendorRef: { value: bill.vendorExternalId || bill.vendorId },
+		DocNumber: bill.billNumber,
+		TxnDate: formatLocalDate(bill.billDate),
+		DueDate: formatLocalDate(bill.dueDate),
+		Line: bill.lineItems.map((item, idx) => ({
+			LineNum: idx + 1,
+			Description: item.description,
+			Amount: item.amount ?? item.quantity * item.unitPrice,
+			DetailType: "AccountBasedExpenseLineDetail",
+			AccountBasedExpenseLineDetail: { AccountRef: item.accountCode ? { value: item.accountCode } : void 0 }
+		})),
+		CurrencyRef: bill.currency ? { value: bill.currency } : void 0
+	};
+}
+function mapQBOToBill(qbo) {
+	const balance = qbo.Balance ?? 0;
+	const totalAmount = qbo.TotalAmt ?? 0;
+	return {
+		externalId: qbo.Id,
+		provider: "quickbooks",
+		syncedAt: /* @__PURE__ */ new Date(),
+		billNumber: qbo.DocNumber,
+		vendorExternalId: qbo.VendorRef?.value || "",
+		billDate: new Date(qbo.TxnDate),
+		dueDate: new Date(qbo.DueDate),
+		subtotal: totalAmount - (qbo.TxnTaxDetail?.TotalTax ?? 0),
+		taxAmount: qbo.TxnTaxDetail?.TotalTax ?? 0,
+		totalAmount,
+		amountPaid: totalAmount - balance,
+		balance,
+		status: mapBillStatus(balance, totalAmount, qbo.DueDate),
+		currency: qbo.CurrencyRef?.value || "USD",
+		raw: qbo
+	};
+}
+function mapBillStatus(balance, total, dueDate) {
+	if (balance === 0) return "paid";
+	if (new Date(dueDate) < /* @__PURE__ */ new Date()) return "overdue";
+	return "pending";
+}
+function mapQBOToPayment(qbo) {
+	return {
+		externalId: qbo.Id,
+		provider: "quickbooks",
+		syncedAt: /* @__PURE__ */ new Date(),
+		amount: qbo.TotalAmt ?? 0,
+		currency: qbo.CurrencyRef?.value || "USD",
+		paidAt: new Date(qbo.TxnDate),
+		method: qbo.PaymentMethodRef?.name,
+		transactionId: qbo.PaymentRefNum,
+		invoiceExternalIds: qbo.Line?.filter((l) => l.LinkedTxn).flatMap((l) => l.LinkedTxn?.map((t) => t.TxnId) || []),
+		status: "completed",
+		raw: qbo
+	};
+}
+function mapAddressToQBO(address) {
+	if (!address) return void 0;
+	return {
+		Line1: address.street1,
+		Line2: address.street2,
+		City: address.city,
+		CountrySubDivisionCode: address.state,
+		PostalCode: address.postalCode,
+		Country: address.country
+	};
+}
+function mapQBOToAddress(qbo) {
+	if (!qbo) return void 0;
+	return {
+		street1: qbo.Line1,
+		street2: qbo.Line2,
+		city: qbo.City,
+		state: qbo.CountrySubDivisionCode,
+		postalCode: qbo.PostalCode,
+		country: qbo.Country
+	};
+}
+//#endregion
+export { QuickBooksProvider, __toCommonJS as a, __require as i, __esmMin as n, __exportAll as r, __commonJSMin as t };
+
+//# sourceMappingURL=quickbooks-BF3GrJBw.js.map