Spaces:
Runtime error
Runtime error
| import type { Request, RequestHandler } from 'express' | |
| import type { AuthenticatedRequest } from '@llm-router/auth-client' | |
| import { container } from '../loader.js' | |
| import type { ParsedExpense, SlipStatus, SlipQueueCursor } from '../ports/index.js' | |
| function tenantOf(req: Request): string { | |
| return (req as AuthenticatedRequest).auth!.tenantId | |
| } | |
| // POST /v1/slip-queue — { images: string[] } | |
| // Response: { succeeded: SlipQueueItem[], failed: Array<{ error: string }> } — a | |
| // per-image compression/upload failure doesn't fail the whole batch (see | |
| // SlipQueueService.enqueue); the caller can inspect `failed` for partial-failure info. | |
| export const postSlipQueue: RequestHandler = async (req, res) => { | |
| const { images } = req.body as { images?: unknown } | |
| if (!Array.isArray(images) || images.length === 0) { | |
| res.status(400).json({ error: 'images must be a non-empty array of base64 strings' }) | |
| return | |
| } | |
| if (images.length > 50) { | |
| res.status(400).json({ error: 'Max 50 images per request' }) | |
| return | |
| } | |
| const result = await container.slipQueueService.enqueue(tenantOf(req), images as string[]) | |
| res.status(201).json(result) | |
| } | |
| const VALID_STATUSES: SlipStatus[] = ['pending', 'processing', 'success', 'needs_review', 'failed', 'confirmed', 'duplicate'] | |
| const DEFAULT_PAGE_SIZE = 30 | |
| const MAX_PAGE_SIZE = 100 | |
| // GET /v1/slip-queue?status=<SlipStatus>&limit=<n>&after_created_at=<iso>&after_id=<uuid> | |
| // One tab's page at a time — status is required, there's no "everything" | |
| // mode anymore. Keyset-paginated (see SlipQueueRepository.listByStatus) | |
| // rather than offset-based, so pages stay correct as new slips land mid-scroll. | |
| export const getSlipQueue: RequestHandler = async (req, res) => { | |
| const query = req.query as Record<string, string | undefined> | |
| const status = query['status'] | |
| if (!status || !VALID_STATUSES.includes(status as SlipStatus)) { | |
| res.status(400).json({ error: `status must be one of: ${VALID_STATUSES.join(', ')}` }) | |
| return | |
| } | |
| const limitParam = Number(query['limit'] ?? DEFAULT_PAGE_SIZE) | |
| const limit = Math.min(Math.max(Number.isFinite(limitParam) ? limitParam : DEFAULT_PAGE_SIZE, 1), MAX_PAGE_SIZE) | |
| const after = query['after_created_at'] && query['after_id'] | |
| ? { createdAt: query['after_created_at'], id: query['after_id'] } | |
| : undefined | |
| const opts: { limit: number; after?: SlipQueueCursor } = after ? { limit, after } : { limit } | |
| const page = await container.slipQueueService.listByStatus(tenantOf(req), status as SlipStatus, opts) | |
| res.json(page) | |
| } | |
| // GET /v1/slip-queue/counts — lightweight per-status tallies for the tab | |
| // badges, polled independently of whichever tab's page is currently loaded. | |
| export const getSlipQueueCounts: RequestHandler = async (req, res) => { | |
| const counts = await container.slipQueueService.countsByStatus(tenantOf(req)) | |
| res.json(counts) | |
| } | |
| // POST /v1/slip-queue/process — called by GitHub Actions cron (INTERNAL_SECRET auth via the global auth | |
| // middleware, which bypasses JWT verification entirely — req.auth is never populated here). Sweeps pending | |
| // slips across every tenant; each row is updated back through its own tenant scope (see SlipQueueService.processAll). | |
| export const processSlipQueue: RequestHandler = async (req, res) => { | |
| const limit = Number((req.query as Record<string, string | undefined>)['limit'] ?? 20) | |
| const result = await container.slipQueueService.processAll(limit) | |
| res.json(result) | |
| } | |
| // POST /v1/slip-queue/:id/retry | |
| export const retrySlipQueueItem: RequestHandler = async (req, res) => { | |
| const tenantId = tenantOf(req) | |
| const id = String(req.params['id'] ?? '') | |
| const item = await container.slipQueueService.get(tenantId, id) | |
| if (!item) { res.status(404).json({ error: 'Slip not found' }); return } | |
| if (item.status !== 'failed') { res.status(400).json({ error: 'Only failed slips can be retried' }); return } | |
| const updated = await container.slipQueueService.resetForRetry(tenantId, id) | |
| res.json(updated) | |
| } | |
| // POST /v1/slip-queue/:id/confirm — { category_id: string, overrides?: Partial<CreateExpense>, | |
| // description?: string, shares?: [{person_id, amount}] } | |
| // | |
| // `shares` carries the already-resolved per-person amounts the frontend's SplitBillPanel | |
| // computed (equal-split or manual) — the same shape bill-shares.routes.ts accepts today. | |
| // This handler performs the same two-call, non-transactional sequence the manual/upload | |
| // flows already use (create expense, then create the split): a split failure must not | |
| // undo the already-created expense or block confirmation, since retrying "Confirm" would | |
| // otherwise create a duplicate expense. | |
| export const confirmSlipQueueItem: RequestHandler = async (req, res) => { | |
| const tenantId = tenantOf(req) | |
| const id = String(req.params['id'] ?? '') | |
| const item = await container.slipQueueService.get(tenantId, id) | |
| if (!item) { res.status(404).json({ error: 'Slip not found' }); return } | |
| if (item.status !== 'success') { res.status(400).json({ error: 'Only parsed slips can be confirmed' }); return } | |
| if (!item.parsed_result) { res.status(400).json({ error: 'No parsed result to confirm' }); return } | |
| const body = req.body as { | |
| category_id: string | |
| date?: string | |
| merchant?: string | |
| currency?: string | |
| description?: string | |
| shares?: Array<{ person_id: string; amount: number }> | |
| } | |
| if (!body.category_id) { res.status(400).json({ error: 'category_id is required' }); return } | |
| const today = new Date().toISOString().slice(0, 10) | |
| let expense | |
| try { | |
| expense = await container.expenseService.create(tenantId, { | |
| amount: item.parsed_result.amount, | |
| currency: body.currency ?? item.parsed_result.currency ?? 'USD', | |
| category_id: body.category_id, | |
| date: body.date ?? item.parsed_result.date ?? today, | |
| ...(body.merchant ?? item.parsed_result.merchant ? { merchant: body.merchant ?? item.parsed_result.merchant ?? undefined } : {}), | |
| ...(body.description?.trim() ? { description: body.description.trim() } : {}), | |
| slip_image_key: item.image_key, | |
| reference: item.parsed_result.reference, | |
| }) | |
| } catch (err: unknown) { | |
| const status = (err as NodeJS.ErrnoException & { status?: number })?.status | |
| if (err instanceof Error && status) { | |
| res.status(status).json({ error: err.message }) | |
| return | |
| } | |
| throw err | |
| } | |
| await container.slipQueueService.setConfirmed(tenantId, id) | |
| const validShares = (body.shares ?? []).filter(s => s.person_id && Number(s.amount) > 0) | |
| if (validShares.length > 0) { | |
| try { | |
| await container.billShareService.split(tenantId, { | |
| expense_id: expense.id, | |
| total: expense.amount, | |
| shares: validShares, | |
| }) | |
| } catch (splitErr) { | |
| console.error('Slip confirmed, but splitting it failed:', splitErr) | |
| } | |
| } | |
| res.status(201).json(expense) | |
| } | |
| // POST /v1/slip-queue/:id/apply-match — resolves a needs_review slip via | |
| // either of slip-queue-match-review-ui's two option boxes: | |
| // - "use matched template": body is {} — reuses the slip's own already- | |
| // persisted match_confidence/match_template_id/parsed_result. | |
| // - "set up a new template": body carries the freshly-taught template's | |
| // match result — { parsed_result, match_confidence, match_template_id } | |
| // — which overwrites the stale below-threshold one. | |
| // Either way the slip lands on 'success', same as today's confident-auto- | |
| // match path, so the existing Review & Confirm flow takes over from there. | |
| export const applyMatchSlipQueueItem: RequestHandler = async (req, res) => { | |
| const tenantId = tenantOf(req) | |
| const id = String(req.params['id'] ?? '') | |
| const item = await container.slipQueueService.get(tenantId, id) | |
| if (!item) { res.status(404).json({ error: 'Slip not found' }); return } | |
| if (item.status !== 'needs_review') { res.status(400).json({ error: 'Only needs_review slips can have a match applied' }); return } | |
| const body = req.body as { | |
| parsed_result?: ParsedExpense | |
| match_confidence?: number | |
| match_template_id?: string | null | |
| } | |
| const hasOverride = body.parsed_result !== undefined && body.match_confidence !== undefined | |
| const fields = hasOverride | |
| ? { parsed_result: body.parsed_result!, match_confidence: body.match_confidence!, match_template_id: body.match_template_id ?? null } | |
| : { parsed_result: item.parsed_result, match_confidence: item.match_confidence, match_template_id: item.match_template_id } | |
| if (!hasOverride && !fields.match_template_id) { | |
| res.status(400).json({ error: 'No matched template to apply — teach a new one instead' }) | |
| return | |
| } | |
| const updated = await container.slipQueueService.applyMatch(tenantId, id, { | |
| parsed_result: fields.parsed_result, | |
| match_confidence: fields.match_confidence ?? 0, | |
| match_template_id: fields.match_template_id, | |
| }) | |
| res.json(updated) | |
| } | |
| // DELETE /v1/slip-queue/:id | |
| export const deleteSlipQueueItem: RequestHandler = async (req, res) => { | |
| const tenantId = tenantOf(req) | |
| const id = String(req.params['id'] ?? '') | |
| const item = await container.slipQueueService.get(tenantId, id) | |
| if (!item) { res.status(404).json({ error: 'Slip not found' }); return } | |
| if (item.status === 'confirmed') { | |
| res.status(400).json({ error: 'Cannot discard a confirmed slip — its image is still used by the confirmed expense' }) | |
| return | |
| } | |
| await container.slipQueueService.delete(tenantId, id) | |
| res.status(204).send() | |
| } | |