freshyo/apps/backend/tests/helpers/api.ts
2026-10-20 00:31:05 +05:30

184 lines
6.2 KiB
TypeScript

/**
* HTTP/tRPC client utilities for the live API tests.
*
* Uses the same wire protocol as the apps (`httpBatchLink`, no transformer):
* POST /api/trpc/<router>.<proc>?batch=1 body {"0": <input>}
* GET /api/trpc/<router>.<proc>?batch=1&input=<encoded {"0":<input>}>
*/
import { createTRPCClient, httpBatchLink, TRPCClientError } from '@trpc/client'
import type { AppRouter } from '@/src/trpc/router'
import { API_BASE_URL, TRPC_URL } from './env'
export type ApiClient = ReturnType<typeof createTRPCClient<AppRouter>>
/** A typed tRPC client; pass a token to authenticate as that principal. */
export function apiClient(token?: string): ApiClient {
return createTRPCClient<AppRouter>({
links: [
httpBatchLink({
url: TRPC_URL,
headers: () => (token ? { Authorization: `Bearer ${token}` } : {}),
}),
],
})
}
export interface RawTrpcOptions {
token?: string
/** Override the verb (used by the request-shape edge cases). */
method?: 'GET' | 'POST'
headers?: Record<string, string>
/** Use a raw body instead of the encoded input (malformed-JSON cases). */
body?: string
}
export interface RawTrpcResponse {
status: number
ok: boolean
body: unknown
text: string
headers: Headers
}
/**
* Low-level tRPC call. Queries default to GET and mutations to POST; pass
* `method` to send the wrong verb deliberately.
*/
export async function rawTrpc(
procedure: string,
input: unknown,
options: RawTrpcOptions = {}
): Promise<RawTrpcResponse> {
const headers: Record<string, string> = { ...(options.headers ?? {}) }
if (options.token) headers.Authorization = `Bearer ${options.token}`
if (!headers['content-type'] && !options.body) headers['content-type'] = 'application/json'
let method = options.method
let url = `${TRPC_URL}/${procedure}?batch=1`
let body: string | undefined
if (!method) {
// Public reads are queries; mutations are POST. The caller may override.
method = 'POST'
}
if (options.body != null) {
body = options.body
} else if (method === 'GET') {
url += `&input=${encodeURIComponent(JSON.stringify({ 0: input }))}`
} else {
body = JSON.stringify({ 0: input })
}
const res = await fetch(url, { method, headers, body })
const text = await res.text()
let parsed: unknown = null
try {
parsed = text ? JSON.parse(text) : null
} catch {
parsed = null
}
return { status: res.status, ok: res.ok, body: parsed, text, headers: res.headers }
}
/** Fetch a REST route (`/api/health`, `/api/v1/...`). */
export async function rest(path: string, init: RequestInit = {}): Promise<Response> {
const url = path.startsWith('http') ? path : `${API_BASE_URL}${path}`
return fetch(url, init)
}
/** Unique-enough suffix so reruns never collide on names/emails/codes. */
export function uniqueSuffix(): string {
return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
}
/** Run a call that must reject and hand back the error (fails if it resolves). */
export async function captureError(fn: () => Promise<unknown>): Promise<Error> {
let error: Error | null = null
try {
await fn()
} catch (caught) {
error = caught as Error
}
if (!error) throw new Error('[api-tests] expected the call to reject, but it resolved')
return error
}
export function errorCode(error: unknown): string | undefined {
const candidate = error as { data?: { code?: string }; shape?: { data?: { code?: string } } }
return candidate?.data?.code ?? candidate?.shape?.data?.code
}
export function errorHttpStatus(error: unknown): number | undefined {
const candidate = error as { data?: { httpStatus?: number }; shape?: { data?: { httpStatus?: number } } }
return candidate?.data?.httpStatus ?? candidate?.shape?.data?.httpStatus
}
export function errorMessage(error: unknown): string {
return error instanceof Error ? error.message : String(error)
}
/**
* Assert that a call rejects with a tRPC code (and optionally a message
* fragment). Accepts one code or a list of acceptable codes.
*/
export async function expectTrpcError(
fn: () => Promise<unknown>,
expected: string | string[],
messageContains?: string
): Promise<Error> {
const error = await captureError(fn)
const codes = Array.isArray(expected) ? expected : [expected]
const code = errorCode(error)
if (!code || !codes.includes(code)) {
throw new Error(
`[api-tests] expected tRPC code ${codes.join('|')} but got ${code ?? '<none>'}: ${errorMessage(error)}`
)
}
if (messageContains) {
const haystack = `${errorMessage(error)} ${JSON.stringify((error as any)?.data ?? '')}`
if (!haystack.toLowerCase().includes(messageContains.toLowerCase())) {
throw new Error(
`[api-tests] expected error message to contain "${messageContains}", got: ${errorMessage(error)}`
)
}
}
return error
}
/** Query via GET (the verb the backend expects for queries). */
export function rawQuery(procedure: string, input: unknown, options: Omit<RawTrpcOptions, 'method'> = {}) {
return rawTrpc(procedure, input, { ...options, method: 'GET' })
}
/** Mutation via POST. */
export function rawMutation(procedure: string, input: unknown, options: Omit<RawTrpcOptions, 'method'> = {}) {
return rawTrpc(procedure, input, { ...options, method: 'POST' })
}
export function sleep(ms: number): Promise<void> {
return new Promise((resolve) => setTimeout(resolve, ms))
}
/** Fail fast when the backend is not running. */
export async function assertServerUp(): Promise<void> {
try {
const res = await fetch(`${API_BASE_URL}/api/health`, { signal: AbortSignal.timeout(5_000) })
if (res.status >= 500) throw new Error(`health returned ${res.status}`)
} catch (error) {
throw new Error(
`[api-tests] Backend not reachable at ${API_BASE_URL}. Start it with ` +
`"cd apps/backend && bun run dev" (wrangler dev, port 8787). ` +
`Cause: ${(error as Error).message}`
)
}
}
/** Parse a tRPC batch response and return the first result (or throw). */
export function firstBatchResult<T = unknown>(body: unknown): T {
const entry = Array.isArray(body) ? body[0] : body
const error = (entry as { error?: unknown })?.error
if (error) throw new Error(`[api-tests] tRPC error: ${JSON.stringify(error)}`)
return (entry as { result?: { data?: T } })?.result?.data as T
}