@teleporthq/teleport-plugin-next-workflows 0.43.57 → 0.43.58

package/__tests__/invoice-generate-hydration.test.ts

@@ -90,8 +90,13 @@ describe('/api/invoices/generate — orderId hydration', () => {
   it('prefers body.items over hydrated items when both exist', () => {
     // Admin "regenerate invoice with custom items" use cases need
     // body.items to win. The condition checks length > 0 so an empty
-    // explicit array still falls back to DB-hydrated items.
-    expect(route).toContain('var items = Array.isArray(body.items) && body.items.length > 0')
+    // explicit array still falls back to DB-hydrated items. The predicate is
+    // named because the settle-wait below keys off it too — a caller that
+    // brought its own lines never waits for the DB rows to land.
+    expect(route).toContain(
+      'var callerSuppliedItems = Array.isArray(body.items) && body.items.length > 0;'
+    )
+    expect(route).toContain('var items = callerSuppliedItems')
   })
 
   it('falls back to order.billing_* / shipping_* fields for customer data', () => {

package/__tests__/invoice-order-items-settle.test.ts

@@ -0,0 +1,308 @@
+import { generateInvoiceGenerateRouteCode } from '../src/invoice/api-routes-code'
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+
+// `/api/invoices/generate` used to invoice a HALF-WRITTEN order.
+//
+// The runtime `data-create-item` handler fire-and-forgets
+// `/api/ecommerce/order-notification` the moment the `teleport_orders` row
+// lands, and that route generates the invoice for every non-webhook payment
+// method. But the checkout workflow writes `teleport_order_items` AFTER the
+// order row, one HTTP round-trip per cart line — so the invoice endpoint was
+// reading the line items while they were still being inserted.
+//
+// Observed in a real store: a 3-line order (4x Linen Table Runner, 3x Ceramic
+// Dinner Plate Set, 2x Wireless Bluetooth Speaker, charged 474.45) produced an
+// invoice with ONE line item and a total of 249.00 — the two rows that had not
+// been inserted yet were simply absent, and nothing anywhere said so.
+//
+// These tests run the EMITTED handler against a data-access stub whose rows
+// arrive progressively, which is what the race actually looks like.
+
+const FAKE_SETTINGS = {
+  invoicePrefix: 'INV-',
+  defaultTaxRate: 10,
+  showDiscount: false,
+  taxIncludedInPrice: false,
+  companyDetails: {},
+  template: { document: null as unknown },
+  tables: { invoicesTable: 'teleport_invoices', invoiceItemsTable: 'teleport_invoice_items' },
+  emailDelivery: { enabled: false },
+} as unknown as UIDLInvoiceSettings
+
+interface OrderItemRow {
+  product_id: string
+  product_name: string
+  quantity: number
+  unit_price: number
+  total_price: number
+}
+
+const ORDER_ROW_BASE = {
+  id: 'order-1',
+  currency: 'USD',
+  total_amount: 474.45,
+  shipping_amount: 150,
+  billing_name: 'Jane Buyer',
+  billing_email: 'jane@example.com',
+}
+
+const ITEM_ROWS: OrderItemRow[] = [
+  {
+    product_id: 'p1',
+    product_name: 'Linen Table Runner',
+    quantity: 4,
+    unit_price: 22.5,
+    total_price: 90,
+  },
+  {
+    product_id: 'p2',
+    product_name: 'Ceramic Dinner Plate Set',
+    quantity: 3,
+    unit_price: 34.99,
+    total_price: 104.97,
+  },
+  {
+    product_id: 'p3',
+    product_name: 'Wireless Bluetooth Speaker',
+    quantity: 2,
+    unit_price: 49.99,
+    total_price: 99.98,
+  },
+]
+
+interface HandlerRun {
+  status: number
+  payload: Record<string, unknown>
+  insertedItems: unknown[]
+  reads: number
+}
+
+/**
+ * Loads the emitted `pages/api/invoices/generate.js` as a real module and
+ * invokes its handler.
+ *
+ * `orderNumberAfterRead` controls when checkout's order-number backfill
+ * becomes visible — that write happens after the item loop in both the COD
+ * and the online-payment branch, so it is one of the endpoint's "the order is
+ * whole now" signals. `Infinity` models a flow that never sets one.
+ */
+async function runHandler(options: {
+  body: Record<string, unknown>
+  /** Number of item rows visible on the Nth read (1-indexed reads). */
+  visibleItemsPerRead: (read: number) => number
+  orderNumberAfterRead?: number
+}): Promise<HandlerRun> {
+  const code = generateInvoiceGenerateRouteCode(FAKE_SETTINGS)
+
+  let reads = 0
+  const insertedItems: unknown[] = []
+  const orderNumberAfterRead = options.orderNumberAfterRead ?? 1
+
+  const dataAccessStub = {
+    getOrderWithItems: async (orderId: string) => {
+      reads += 1
+      if (orderId !== ORDER_ROW_BASE.id) {
+        return null
+      }
+      return {
+        order: {
+          ...ORDER_ROW_BASE,
+          order_number: reads >= orderNumberAfterRead ? 'ORD-1' : null,
+        },
+        items: ITEM_ROWS.slice(0, options.visibleItemsPerRead(reads)),
+      }
+    },
+    getNextInvoiceNumber: async () => 1,
+    insertInvoice: async (invoiceData: Record<string, unknown>) => invoiceData,
+    insertInvoiceItems: async (_invoiceId: string, items: unknown[]) => {
+      insertedItems.push(...items)
+      return items
+    },
+    updateInvoice: async () => ({}),
+  }
+
+  const pdfGeneratorStub = {
+    generateInvoicePdf: async () => Buffer.from('%PDF-1.4 fake'),
+    COMPANY_DETAILS: {},
+  }
+
+  const stubRequire = ((id: string) => {
+    if (id.indexOf('data-access') !== -1) return dataAccessStub
+    if (id.indexOf('pdf-generator') !== -1) return pdfGeneratorStub
+    if (id === 'pg') return { Client: class {} }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(id)
+  }) as unknown as NodeRequire
+
+  const factory = new Function(
+    'require',
+    'module',
+    'exports',
+    `${code}; return module.exports;`
+  ) as (
+    req: NodeRequire,
+    mod: { exports: unknown },
+    exp: unknown
+  ) => (req: unknown, res: unknown) => Promise<void>
+
+  const moduleObject = { exports: {} as unknown }
+  const handler = factory(stubRequire, moduleObject, moduleObject.exports)
+
+  let status = 0
+  let payload: Record<string, unknown> = {}
+  const res = {
+    status(statusCode: number) {
+      status = statusCode
+      return this
+    },
+    json(value: Record<string, unknown>) {
+      payload = value
+      return this
+    },
+    setHeader() {
+      /* not used by this route */
+    },
+    end() {
+      /* not used by this route */
+    },
+  }
+
+  await handler({ method: 'POST', headers: { host: 'localhost:3000' }, body: options.body }, res)
+
+  return { status, payload, insertedItems, reads }
+}
+
+describe('/api/invoices/generate — waits for the order to be fully written', () => {
+  const originalFetch = globalThis.fetch
+  const originalConnString = process.env.TELEPORT_DB_CONNECTION_STRING
+  const originalDatabaseUrl = process.env.DATABASE_URL
+
+  beforeAll(() => {
+    // The route self-fetches the runtime-storage proxy and mirrors onto
+    // `teleport_orders`; neither is under test and neither may reach the
+    // network from a unit test.
+    globalThis.fetch = (async () => {
+      throw new Error('runtime storage not configured in tests')
+    }) as unknown as typeof fetch
+    delete process.env.TELEPORT_DB_CONNECTION_STRING
+    delete process.env.DATABASE_URL
+  })
+
+  afterAll(() => {
+    globalThis.fetch = originalFetch
+    if (originalConnString !== undefined) {
+      process.env.TELEPORT_DB_CONNECTION_STRING = originalConnString
+    }
+    if (originalDatabaseUrl !== undefined) {
+      process.env.DATABASE_URL = originalDatabaseUrl
+    }
+  })
+
+  it('invoices every line of an order whose items are still being inserted', async () => {
+    // The exact shape of the reported bug: one row visible on the first read,
+    // the rest landing while the endpoint runs. `expectedItemCount` is what
+    // the order-notification route forwards from the cart it was handed.
+    const run = await runHandler({
+      body: { orderId: 'order-1', expectedItemCount: 3 },
+      visibleItemsPerRead: (read) => Math.min(read, 3),
+      orderNumberAfterRead: Infinity,
+    })
+
+    expect(run.status).toBe(200)
+    expect(run.insertedItems).toHaveLength(3)
+    expect(run.insertedItems.map((item) => (item as { name: string }).name)).toEqual([
+      'Linen Table Runner',
+      'Ceramic Dinner Plate Set',
+      'Wireless Bluetooth Speaker',
+    ])
+    // 90 + 104.97 + 99.98 = 294.95 net, +10% VAT = 324.45, +150 delivery.
+    expect(run.payload.total).toBe(474.45)
+  })
+
+  it('accepts the order as whole once checkout has backfilled the order number', async () => {
+    // No `expectedItemCount` — the webhook-driven callers send only an
+    // orderId. `teleport_orders.order_number` is written after the item loop,
+    // so its presence is the endpoint's own proof that no line is missing.
+    const run = await runHandler({
+      body: { orderId: 'order-1' },
+      visibleItemsPerRead: (read) => Math.min(read, 3),
+      orderNumberAfterRead: 3,
+    })
+
+    expect(run.status).toBe(200)
+    expect(run.insertedItems).toHaveLength(3)
+    expect(run.reads).toBe(3)
+  })
+
+  it('does not poll an order that is already complete on the first read', async () => {
+    // The common case — every payment-webhook invoice. It must cost exactly
+    // one query and no added latency.
+    const run = await runHandler({
+      body: { orderId: 'order-1' },
+      visibleItemsPerRead: () => 3,
+      orderNumberAfterRead: 1,
+    })
+
+    expect(run.status).toBe(200)
+    expect(run.insertedItems).toHaveLength(3)
+    expect(run.reads).toBe(1)
+  })
+
+  it('does not wait at all when the caller supplied its own line items', async () => {
+    const run = await runHandler({
+      body: {
+        orderId: 'order-1',
+        items: [{ name: 'Handpicked line', quantity: 1, unitPrice: 10, totalPrice: 10 }],
+      },
+      visibleItemsPerRead: () => 0,
+      orderNumberAfterRead: Infinity,
+    })
+
+    expect(run.status).toBe(200)
+    expect(run.reads).toBe(1)
+    expect(run.insertedItems).toHaveLength(1)
+    expect((run.insertedItems[0] as { name: string }).name).toBe('Handpicked line')
+  })
+
+  it('still rejects an order that never gets any line items', async () => {
+    const run = await runHandler({
+      body: { orderId: 'order-1', expectedItemCount: 3 },
+      visibleItemsPerRead: () => 0,
+      orderNumberAfterRead: 1,
+    })
+
+    expect(run.status).toBe(400)
+    expect(run.payload.error).toBe('At least one item is required')
+  }, 15000)
+})
+
+describe('/api/invoices/generate — settle contract (emitted source)', () => {
+  const route = generateInvoiceGenerateRouteCode(FAKE_SETTINGS)
+
+  it('reads the line items through the settling helper, never a bare query', () => {
+    expect(route).toContain('async function hydrateOrderWhenSettled(orderId, expectedItemCount)')
+    expect(route).toContain('await hydrateOrderWhenSettled(body.orderId, expectedItemCount)')
+  })
+
+  it('treats a populated order_number as proof the item loop finished', () => {
+    // Checkout writes it in "Mark Order As Cash On Delivery Confirmed" /
+    // "Set Order Number Before Payment Redirect", both downstream of the loop.
+    expect(route).toContain('var orderNumber = hydrated.order.order_number;')
+    expect(route).toContain(
+      'if (count > 0 && orderNumber != null && String(orderNumber).length > 0) {'
+    )
+  })
+
+  it('bounds the wait so a stuck order still produces an invoice', () => {
+    expect(route).toContain('var SETTLE_TIMEOUT_MS = 6000;')
+    expect(route).toContain('did not settle within ')
+  })
+
+  it('warns when the invoice total disagrees with the amount charged', () => {
+    // The tripwire that would have caught this the first time: the invoice is
+    // summed from line items, `teleport_orders.total_amount` is what the buyer
+    // actually paid, and a missing line makes them disagree.
+    expect(route).toContain('var orderTotalAmount = Number(orderShippingSource.total_amount);')
+    expect(route).toContain('[invoice] Total mismatch for order ')
+  })
+})

package/dist/cjs/invoice/api-routes-code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-routes-code.d.ts","sourceRoot":"","sources":["../../../src/invoice/api-routes-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAEhE,eAAO,MAAM,gCAAgC,aAAc,mBAAmB,KAAG,MAqehF,CAAA;AAED,eAAO,MAAM,2BAA2B,QAAO,MAsD9C,CAAA"}
+{"version":3,"file":"api-routes-code.d.ts","sourceRoot":"","sources":["../../../src/invoice/api-routes-code.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAEhE,eAAO,MAAM,gCAAgC,aAAc,mBAAmB,KAAG,MAsmBhF,CAAA;AAED,eAAO,MAAM,2BAA2B,QAAO,MAsD9C,CAAA"}

package/dist/cjs/invoice/api-routes-code.js

@@ -93,6 +93,100 @@ async function uploadInvoicePdfToRuntimeStorage(pdfBuffer, fileName, baseUrl) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Waiting for the order's line items to be fully written.
+//
+// This endpoint is reached BEFORE checkout has finished writing the order.
+// \`/api/ecommerce/order-notification\` is fire-and-forget'd by the runtime
+// \`data-create-item\` handler the moment the \`teleport_orders\` row lands —
+// which is upstream of the checkout workflow's "Loop Over Each Cart Item",
+// the loop that inserts \`teleport_order_items\` one HTTP round-trip at a
+// time. Hydrating on arrival therefore snapshots a HALF-WRITTEN order: a
+// real 3-line order was invoiced with a single line and a total 225.45
+// short of what the buyer was charged, because the other two rows were
+// still in flight when the hydration query ran.
+//
+// So don't race it — wait for the order to settle, then hydrate. Three exit
+// conditions, cheapest first:
+//
+//   1. \`expectedItemCount\` — the caller's own cart-line count — is reached.
+//      The order-notification route passes it, so the racing path is exact.
+//   2. \`teleport_orders.order_number\` is populated. Checkout backfills the
+//      order number only AFTER the item loop has run to completion (the COD
+//      branch does it in "Mark Order As Cash On Delivery Confirmed", the
+//      online-payment branch in "Set Order Number Before Payment Redirect"),
+//      so a non-empty order number proves every line has been written.
+//   3. The row count is identical across \`SETTLE_STABLE_READS\` consecutive
+//      reads — the fallback for orders written by a flow that never sets an
+//      order number.
+//
+// An order that is already complete — every webhook-driven call, and any
+// hand-built admin call — satisfies (1) or (2) on the FIRST read, so the
+// only request that ever pays for a poll is the one that would otherwise
+// have shipped a wrong invoice.
+var SETTLE_TIMEOUT_MS = 6000;
+var SETTLE_POLL_MS = 400;
+var SETTLE_STABLE_READS = 3;
+
+function sleepMs(ms) {
+  return new Promise(function (resolve) { setTimeout(resolve, ms); });
+}
+
+async function hydrateOrderWhenSettled(orderId, expectedItemCount) {
+  var deadline = Date.now() + SETTLE_TIMEOUT_MS;
+  var lastCount = -1;
+  var repeats = 0;
+  var attempts = 0;
+
+  while (true) {
+    var hydrated = await dataAccess.getOrderWithItems(orderId);
+    attempts += 1;
+    if (!hydrated || !hydrated.order) {
+      // Nothing to wait for — the order id doesn't resolve. The caller logs
+      // this as a miss and falls back to its own body.* fields.
+      return hydrated;
+    }
+
+    var rows = Array.isArray(hydrated.items) ? hydrated.items : [];
+    var count = rows.length;
+
+    if (expectedItemCount > 0 && count >= expectedItemCount) {
+      if (attempts > 1) {
+        console.info('[invoice] Order ' + orderId + ' settled at ' + count + ' line(s) after ' + attempts + ' read(s) (expected ' + expectedItemCount + ')');
+      }
+      return hydrated;
+    }
+
+    var orderNumber = hydrated.order.order_number;
+    if (count > 0 && orderNumber != null && String(orderNumber).length > 0) {
+      if (attempts > 1) {
+        console.info('[invoice] Order ' + orderId + ' settled at ' + count + ' line(s) after ' + attempts + ' read(s) (order_number=' + orderNumber + ')');
+      }
+      return hydrated;
+    }
+
+    if (count === lastCount) {
+      repeats += 1;
+    } else {
+      lastCount = count;
+      repeats = 1;
+    }
+    if (count > 0 && repeats >= SETTLE_STABLE_READS) {
+      console.info('[invoice] Order ' + orderId + ' settled at ' + count + ' line(s) — row count stable across ' + repeats + ' reads');
+      return hydrated;
+    }
+
+    if (Date.now() >= deadline) {
+      console.warn('[invoice] Order ' + orderId + ' did not settle within ' + SETTLE_TIMEOUT_MS +
+        'ms — invoicing the ' + count + ' line(s) visible now' +
+        (expectedItemCount > 0 ? ' (expected ' + expectedItemCount + ')' : ''));
+      return hydrated;
+    }
+
+    await sleepMs(SETTLE_POLL_MS);
+  }
+}
+
 var CURRENCY_SYMBOLS = {
   'USD': '$', 'EUR': '\\u20AC', 'GBP': '\\u00A3', 'JPY': '\\u00A5',
   'CAD': 'C$', 'AUD': 'A$', 'CHF': 'CHF ', 'CNY': '\\u00A5',
@@ -129,11 +223,23 @@ module.exports = async function handler(req, res) {
       return;
     }
 
+    var callerSuppliedItems = Array.isArray(body.items) && body.items.length > 0;
+
+    // How many line items the caller believes this order has. Used only to
+    // stop \`hydrateOrderWhenSettled\` polling the moment the order is whole —
+    // never to reject or pad the invoice, so a wrong count can at worst make
+    // us wait a little longer and fall through to the other exit conditions.
+    var expectedItemCount = Number(body.expectedItemCount);
+    if (!isFinite(expectedItemCount) || expectedItemCount < 0) {
+      expectedItemCount = 0;
+    }
+
     console.info('[invoice] === /api/invoices/generate === baseUrl=' + __baseUrl);
     console.info('[invoice] Request received:', {
       orderId: body.orderId || null,
-      hasBodyItems: Array.isArray(body.items) && body.items.length > 0,
+      hasBodyItems: callerSuppliedItems,
       bodyItemCount: Array.isArray(body.items) ? body.items.length : 0,
+      expectedItemCount: expectedItemCount,
       hasCustomerEmail: !!body.customerEmail,
       requestedCurrency: body.currency || null,
     });
@@ -148,11 +254,19 @@ module.exports = async function handler(req, res) {
     // provide wins, so hand-built admin-side calls (or future clients)
     // can still override the customer/company/notes/etc. without being
     // forced to round-trip the DB themselves.
+    //
+    // The line items are read through \`hydrateOrderWhenSettled\`, which waits
+    // for checkout to finish writing them — see the comment on that helper
+    // for why an unguarded read snapshots a half-written order. A caller that
+    // brought its own \`items\` array doesn't depend on the DB rows at all, so
+    // that path takes the plain single read and skips the wait entirely.
     var hydratedOrder = null;
     var hydratedItems = [];
     if (body.orderId) {
       try {
-        var hydrated = await dataAccess.getOrderWithItems(body.orderId);
+        var hydrated = callerSuppliedItems
+          ? await dataAccess.getOrderWithItems(body.orderId)
+          : await hydrateOrderWhenSettled(body.orderId, expectedItemCount);
         if (hydrated && hydrated.order) {
           hydratedOrder = hydrated.order;
           hydratedItems = Array.isArray(hydrated.items) ? hydrated.items : [];
@@ -167,7 +281,7 @@ module.exports = async function handler(req, res) {
       console.info('[invoice] No orderId in request — skipping DB hydration, using body.* fields verbatim');
     }
 
-    var items = Array.isArray(body.items) && body.items.length > 0
+    var items = callerSuppliedItems
       ? body.items
       : hydratedItems.map(function (row) {
           return {
@@ -254,6 +368,21 @@ module.exports = async function handler(req, res) {
     }
     var total = goodsTotal + shippingAmount;
 
+    // Cross-check against the amount the order was actually placed for. The
+    // invoice is built from line items, the order carries the charged total,
+    // and the two must agree — when they don't, the invoice is being written
+    // from an incomplete set of lines (exactly what a lost race against
+    // checkout's item loop looks like). Log-only: a mismatch must never stop
+    // the merchant getting an invoice, but it has to be visible in the
+    // function logs instead of silently shipping a short bill.
+    var orderTotalAmount = Number(orderShippingSource.total_amount);
+    if (isFinite(orderTotalAmount) && orderTotalAmount > 0 && Math.abs(orderTotalAmount - total) > 0.02) {
+      console.warn('[invoice] Total mismatch for order ' + (body.orderId || '(none)') +
+        ' — invoice total ' + (Math.round(total * 100) / 100) +
+        ' vs teleport_orders.total_amount ' + orderTotalAmount +
+        ' across ' + items.length + ' line item(s). The invoice may be missing lines.');
+    }
+
     var nextNumber = await dataAccess.getNextInvoiceNumber(INVOICE_PREFIX);
     var invoiceNumber = INVOICE_PREFIX + String(nextNumber).padStart(4, '0');
 

package/dist/cjs/invoice/api-routes-code.js.map

@@ -1 +1 @@
-{"version":3,"file":"api-routes-code.js","sourceRoot":"","sources":["../../../src/invoice/api-routes-code.ts"],"names":[],"mappings":";;;AAEO,MAAM,gCAAgC,GAAG,CAAC,QAA6B,EAAU,EAAE;;IACxF,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,IAAI,MAAM,CAAA;IAC/C,MAAM,cAAc,GAAG,QAAQ,CAAC,cAAc,IAAI,CAAC,CAAA;IACnD,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,KAAK,IAAI,CAAA;IACnD,MAAM,kBAAkB,GAAG,QAAQ,CAAC,kBAAkB,KAAK,IAAI,CAAA;IAC/D,MAAM,YAAY,GAAG,QAAQ,CAAC,qBAAqB,KAAK,KAAK,CAAA;IAC7D,MAAM,YAAY,GAAG,CAAA,MAAA,QAAQ,CAAC,aAAa,0CAAE,OAAO,MAAK,IAAI,CAAA;IAC7D,MAAM,oBAAoB,GAAG,CAAA,MAAA,QAAQ,CAAC,QAAQ,0CAAE,QAAQ;QACtD,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAC5C,CAAC,CAAC,MAAM,CAAA;IAEV,OAAO;;;;;;;;;EASP,YAAY,CAAC,CAAC,CAAC,oEAAoE,CAAC,CAAC,CAAC,EAAE;;uBAEnE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;yBACpB,cAAc;;sBAEjB,YAAY;8BACJ,kBAAkB;0BACtB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmZ5C,YAAY;QACV,CAAC,CAAC;;;;;;;;;;;;;;;CAeL;QACG,CAAC,CAAC;;CAGN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCC,CAAA;AACD,CAAC,CAAA;AAreY,QAAA,gCAAgC,oCAqe5C;AAEM,MAAM,2BAA2B,GAAG,GAAW,EAAE;IACtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDR,CAAA;AACD,CAAC,CAAA;AAtDY,QAAA,2BAA2B,+BAsDvC"}
+{"version":3,"file":"api-routes-code.js","sourceRoot":"","sources":["../../../src/invoice/api-routes-code.ts"],"names":[],"mappings":";;;AAEO,MAAM,gCAAgC,GAAG,CAAC,QAA6B,EAAU,EAAE;;IACxF,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,IAAI,MAAM,CAAA;IAC/C,MAAM,cAAc,GAAG,QAAQ,CAAC,cAAc,IAAI,CAAC,CAAA;IACnD,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,KAAK,IAAI,CAAA;IACnD,MAAM,kBAAkB,GAAG,QAAQ,CAAC,kBAAkB,KAAK,IAAI,CAAA;IAC/D,MAAM,YAAY,GAAG,QAAQ,CAAC,qBAAqB,KAAK,KAAK,CAAA;IAC7D,MAAM,YAAY,GAAG,CAAA,MAAA,QAAQ,CAAC,aAAa,0CAAE,OAAO,MAAK,IAAI,CAAA;IAC7D,MAAM,oBAAoB,GAAG,CAAA,MAAA,QAAQ,CAAC,QAAQ,0CAAE,QAAQ;QACtD,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAC5C,CAAC,CAAC,MAAM,CAAA;IAEV,OAAO;;;;;;;;;EASP,YAAY,CAAC,CAAC,CAAC,oEAAoE,CAAC,CAAC,CAAC,EAAE;;uBAEnE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;yBACpB,cAAc;;sBAEjB,YAAY;8BACJ,kBAAkB;0BACtB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAohB5C,YAAY;QACV,CAAC,CAAC;;;;;;;;;;;;;;;CAeL;QACG,CAAC,CAAC;;CAGN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCC,CAAA;AACD,CAAC,CAAA;AAtmBY,QAAA,gCAAgC,oCAsmB5C;AAEM,MAAM,2BAA2B,GAAG,GAAW,EAAE;IACtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDR,CAAA;AACD,CAAC,CAAA;AAtDY,QAAA,2BAA2B,+BAsDvC"}