@happyvertical/accounting 0.74.8

package/dist/chunks/index-D0bqSiCo.js

@@ -0,0 +1,893 @@
+import { createHmac } from "node:crypto";
+function formatLocalDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+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) < 0.01;
+  }
+  return false;
+}
+class QuickBooksProvider {
+  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) {
+      const bufferMs = 5 * 60 * 1e3;
+      if ((/* @__PURE__ */ new Date()).getTime() < this.tokenExpiresAt.getTime() - bufferMs) {
+        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-fC3cd77X.js").then((n) => n.O)).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 response = await oauthClient.refresh();
+    const token = response.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 errorMessage = lastError.message;
+        const statusMatch = errorMessage.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) {
+          const backoffMs = 2 ** attempt * 1e3;
+          await sleep(backoffMs);
+        }
+      }
+    }
+    throw lastError || 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 response = await this.request("GET", `query?query=${encodeURIComponent(query)}`);
+      const items = response.QueryResponse[entity] || [];
+      results.push(...items);
+      if (items.length < pageSize) {
+        break;
+      }
+      startPosition += pageSize;
+    }
+    return results;
+  }
+}
+class QuickBooksCustomerOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async push(customer) {
+    const qboCustomer = mapCustomerToQBO(customer);
+    const response = await this.provider.request(
+      "POST",
+      "customer",
+      qboCustomer
+    );
+    return {
+      action: "created",
+      externalId: response.Customer.Id,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async pull(externalId) {
+    const response = await this.provider.request(
+      "GET",
+      `customer/${externalId}`
+    );
+    return mapQBOToCustomer(response.Customer);
+  }
+  async list(options) {
+    const limit = options?.limit || 1e3;
+    const customers = await this.provider.queryAll(
+      "Customer",
+      void 0,
+      limit
+    );
+    return customers.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);
+  }
+}
+class QuickBooksInvoiceOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async push(invoice) {
+    const qboInvoice = mapInvoiceToQBO(invoice);
+    const response = await this.provider.request(
+      "POST",
+      "invoice",
+      qboInvoice
+    );
+    return {
+      action: "created",
+      externalId: response.Invoice.Id,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async pull(externalId) {
+    const response = await this.provider.request(
+      "GET",
+      `invoice/${externalId}`
+    );
+    return mapQBOToInvoice(response.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)}'`;
+      }
+    }
+    const invoices = await this.provider.queryAll(
+      "Invoice",
+      whereClause,
+      limit
+    );
+    return invoices.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,
+      // QBO doesn't have a Void field - you delete the invoice instead
+      // or create a credit memo. For now, we'll use sparse update to mark private note
+      PrivateNote: "VOIDED"
+    });
+  }
+}
+class QuickBooksVendorOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async push(vendor) {
+    const qboVendor = mapVendorToQBO(vendor);
+    const response = await this.provider.request(
+      "POST",
+      "vendor",
+      qboVendor
+    );
+    return {
+      action: "created",
+      externalId: response.Vendor.Id,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async pull(externalId) {
+    const response = await this.provider.request(
+      "GET",
+      `vendor/${externalId}`
+    );
+    return mapQBOToVendor(response.Vendor);
+  }
+  async list(options) {
+    const limit = options?.limit || 1e3;
+    const vendors = await this.provider.queryAll(
+      "Vendor",
+      void 0,
+      limit
+    );
+    return vendors.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);
+  }
+}
+class QuickBooksBillOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async push(bill) {
+    const qboBill = mapBillToQBO(bill);
+    const response = await this.provider.request(
+      "POST",
+      "bill",
+      qboBill
+    );
+    return {
+      action: "created",
+      externalId: response.Bill.Id,
+      syncedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  async pull(externalId) {
+    const response = await this.provider.request(
+      "GET",
+      `bill/${externalId}`
+    );
+    return mapQBOToBill(response.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)}'`;
+      }
+    }
+    const bills = await this.provider.queryAll(
+      "Bill",
+      whereClause,
+      limit
+    );
+    return bills.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);
+  }
+}
+class QuickBooksPaymentOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async pull(externalId) {
+    const response = await this.provider.request(
+      "GET",
+      `payment/${externalId}`
+    );
+    return mapQBOToPayment(response.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)}'`;
+      }
+    }
+    const payments = await this.provider.queryAll(
+      "Payment",
+      whereClause,
+      limit
+    );
+    return payments.map(mapQBOToPayment);
+  }
+}
+class QuickBooksAuditOperations {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async reconcileCustomers(locals) {
+    const externals = await this.provider.customers.list({ limit: 1e4 });
+    return reconcileRecords(
+      locals,
+      externals,
+      (l) => l.externalId,
+      (e) => e.externalId,
+      compareCustomer
+    );
+  }
+  async reconcileInvoices(locals, dateRange) {
+    const externals = await this.provider.invoices.list({
+      limit: 1e4,
+      startDate: dateRange?.start,
+      endDate: dateRange?.end
+    });
+    return reconcileRecords(
+      locals,
+      externals,
+      (l) => l.externalId,
+      (e) => e.externalId,
+      compareInvoice
+    );
+  }
+  async reconcileVendors(locals) {
+    const externals = await this.provider.vendors.list({ limit: 1e4 });
+    return reconcileRecords(
+      locals,
+      externals,
+      (l) => l.externalId,
+      (e) => e.externalId,
+      compareVendor
+    );
+  }
+  async reconcileBills(locals, dateRange) {
+    const externals = await this.provider.bills.list({
+      limit: 1e4,
+      startDate: dateRange?.start,
+      endDate: dateRange?.end
+    });
+    return reconcileRecords(
+      locals,
+      externals,
+      (l) => l.externalId,
+      (e) => e.externalId,
+      compareBill
+    );
+  }
+  async reconcilePayments(locals, dateRange) {
+    const externals = await this.provider.payments.list({
+      limit: 1e4,
+      startDate: dateRange?.start,
+      endDate: dateRange?.end
+    });
+    return reconcileRecords(
+      locals,
+      externals,
+      (l) => l.externalId,
+      (e) => e.externalId,
+      comparePayment
+    );
+  }
+}
+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;
+}
+class QuickBooksWebhookOperations {
+  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 eventNotifications = data.eventNotifications || [];
+    const firstEvent = 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 void 0;
+  }
+}
+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
+  };
+}
+export {
+  QuickBooksProvider
+};
+//# sourceMappingURL=index-D0bqSiCo.js.map