Class InvoiceRepository

src/repositories/invoice-repository.ts:12–125

const logger = createLogger('invoice-repository')

export class InvoiceRepository implements IInvoiceRepository {
  public constructor(private readonly dbClient: DatabaseClient) {}

  public async confirmInvoice(
    invoiceId: string,
    amountPaid: bigint,
    confirmedAt: Date,
    client: DatabaseClient = this.dbClient,
  ): Promise<void> {
    logger('confirming invoice %s at %s: %s', invoiceId, confirmedAt, amountPaid)

    try {
      await client.raw('select confirm_invoice(?, ?, ?)', [invoiceId, amountPaid.toString(), confirmedAt.toISOString()])
    } catch (error) {
      logger.error('Unable to confirm invoice. Reason:', error)

      throw error
    }
  }

  public async findById(id: string, client: DatabaseClient = this.dbClient): Promise<Invoice | undefined> {
    const [dbInvoice] = await client<DBInvoice>('invoices').where('id', id).select()

    if (!dbInvoice) {
      return
    }

    return fromDBInvoice(dbInvoice)
  }

  public async findPendingInvoices(offset = 0, limit = 10, client: DatabaseClient = this.dbClient): Promise<Invoice[]> {
    // Order by created_at ASC for deterministic FIFO polling: oldest pending
    // invoices are picked up first, and the scan is index-only against
    // invoices_pending_created_at_idx (partial on status = 'pending').
    const dbInvoices = await client<DBInvoice>('invoices')
      .where('status', InvoiceStatus.PENDING)
      .orderBy('created_at', 'asc')
      .offset(offset)
      .limit(limit)
      .select()

    return dbInvoices.map(fromDBInvoice)
  }

  public updateStatus(invoice: Invoice, client: DatabaseClient = this.dbClient): Promise<Invoice | undefined> {
    logger('updating invoice status: %o', invoice)

    const query = client<DBInvoice>('invoices')
      .update({
        status: invoice.status,
        updated_at: new Date(),
      })
      .where('id', invoice.id)
      .limit(1)
      .returning(['*'])

    return {
      then: <T1, T2>(