pipework 0.252.0 → 0.253.0

package/src/request/http/file.ts

@@ -0,0 +1,141 @@
+import { Readable } from 'node:stream'
+import type { FileConfig } from '../di/types.js'
+import { mediaTypeAllowed } from './upload.js'
+
+const FILE_RESPONSE = Symbol.for('pipework.fileResponse')
+
+/** What `http.file()` takes. */
+export interface FileResponseInit {
+  /** The bytes, or a stream that is read as it is sent. */
+  readonly body: Buffer | Uint8Array | Readable
+  /** Content-Type of the response, e.g. `application/pdf`. */
+  readonly mediaType: string
+  /** Name the browser saves the file under. Any characters; the header is escaped. */
+  readonly filename?: string
+  /** `'attachment'` (default) downloads; `'inline'` lets the browser display it. */
+  readonly disposition?: 'attachment' | 'inline'
+  /** Byte length of a stream body, sent as Content-Length. Ignored for a Buffer, whose length is known. */
+  readonly length?: number
+}
+
+/**
+ * A file for a route to answer with, made by `http.file()`. Return it from a
+ * handler declared with `.file()`; it is sent as the response body, streamed
+ * when `body` is a Readable.
+ */
+export interface FileResponse {
+  readonly [FILE_RESPONSE]: true
+  readonly body: Buffer | Readable
+  readonly mediaType: string
+  readonly filename: string | undefined
+  readonly disposition: 'attachment' | 'inline'
+  readonly length: number | undefined
+}
+
+/**
+ * Builds the value a handler returns to answer with a file: `body` (Buffer,
+ * Uint8Array or Readable), `mediaType`, and optionally `filename`,
+ * `disposition` (`'attachment'` default, or `'inline'`) and `length` (the byte
+ * length of a stream, sent as Content-Length; without it a stream is sent
+ * chunked).
+ *
+ * Declare the route with `.file({ mediaTypes })` so OpenAPI describes it. The
+ * response carries Content-Type, Content-Length (Buffer, or stream with
+ * `length`), Content-Disposition with an ASCII `filename=` fallback and the
+ * exact name in `filename*=UTF-8''...`, and `X-Content-Type-Options: nosniff`.
+ *
+ * The request transaction (auto mode) has committed before the first byte is
+ * sent, so a stream must not need it. A stream that fails before its first
+ * byte gets a 500; one that fails after destroys the connection and logs the
+ * error, so the client sees an aborted download, never a complete-looking
+ * short one. Range requests are not supported.
+ */
+export function file(init: FileResponseInit): FileResponse {
+  if (typeof init.mediaType !== 'string' || init.mediaType.trim() === '' || /[\r\n]/.test(init.mediaType)) {
+    throw new Error('[pipework] http.file() needs a mediaType such as "application/pdf" (one line, not empty).')
+  }
+  const disposition: string = init.disposition ?? 'attachment'
+  if (disposition !== 'attachment' && disposition !== 'inline') {
+    throw new Error(`[pipework] http.file() disposition must be 'attachment' or 'inline', got ${String(disposition)}.`)
+  }
+  if (init.length !== undefined && (!Number.isInteger(init.length) || init.length < 0)) {
+    throw new Error(`[pipework] http.file() length must be a non-negative integer number of bytes, got ${String(init.length)}.`)
+  }
+  let body: Buffer | Readable
+  if (init.body instanceof Readable) body = init.body
+  else if (Buffer.isBuffer(init.body)) body = init.body
+  else if (init.body instanceof Uint8Array) body = Buffer.from(init.body.buffer, init.body.byteOffset, init.body.byteLength)
+  else throw new Error('[pipework] http.file() body must be a Buffer, Uint8Array or Readable stream.')
+  return Object.freeze({
+    [FILE_RESPONSE]: true as const,
+    body,
+    mediaType: init.mediaType.trim(),
+    filename: init.filename,
+    disposition,
+    length: init.length,
+  })
+}
+
+/** True for a value made by `http.file()`. */
+export function isFileResponse(value: unknown): value is FileResponse {
+  return value !== null && typeof value === 'object' && (value as Record<symbol, unknown>)[FILE_RESPONSE] === true
+}
+
+/** The reason a file response cannot be sent for a route declared with `declared`, or null. */
+export function fileResponseProblem(declared: FileConfig | null, file: FileResponse): string | null {
+  if (declared === null) return null
+  if (!mediaTypeAllowed(declared.mediaTypes, file.mediaType.split(';')[0]!.trim().toLowerCase())) {
+    return `The file's mediaType ${file.mediaType} is not in the route's .file() list (${declared.mediaTypes.join(', ')}).`
+  }
+  return null
+}
+
+/** Content-Disposition value per RFC 6266 / RFC 5987: ASCII fallback plus the exact name percent-encoded. */
+export function contentDisposition(disposition: 'attachment' | 'inline', filename: string | undefined): string {
+  if (filename === undefined || filename === '') return disposition
+  const wellFormed = filename.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, '\uFFFD')
+  let fallback = ''
+  for (const ch of wellFormed) {
+    const code = ch.codePointAt(0)!
+    if (code > 0x7e) fallback += '_'
+    else if (code < 0x20 || code === 0x7f || ch === '"' || ch === '\\' || ch === '/') continue
+    else fallback += ch
+  }
+  if (fallback.trim() === '') fallback = 'file'
+  const encoded = encodeURIComponent(wellFormed).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`)
+  return `${disposition}; filename="${fallback}"; filename*=UTF-8''${encoded}`
+}
+
+/**
+ * Reads a stream's first chunk before anything is sent, so a stream that fails
+ * at once can still become a normal error response. Returns the stream to send
+ * (the same bytes, replayed), which fails after `length` mismatches or on error.
+ */
+export async function primeStream(source: Readable, length: number | undefined): Promise<Readable> {
+  const iterator = source[Symbol.asyncIterator]()
+  let first: IteratorResult<unknown>
+  try {
+    first = await iterator.next()
+  } catch (error) {
+    source.destroy()
+    throw error
+  }
+  async function* replay(): AsyncGenerator<Buffer> {
+    let sent = 0
+    try {
+      let step = first
+      while (step.done !== true) {
+        const chunk = typeof step.value === 'string' ? Buffer.from(step.value) : (step.value as Buffer)
+        sent += chunk.length
+        yield chunk
+        step = await iterator.next()
+      }
+      if (length !== undefined && sent !== length) {
+        throw new Error(`[pipework] The file stream ended after ${sent} bytes but http.file() declared length ${length}.`)
+      }
+    } finally {
+      if (!source.destroyed) source.destroy()
+    }
+  }
+  return Readable.from(replay(), { objectMode: false })
+}

package/src/request/http/index.ts

@@ -0,0 +1,4 @@
+export { createServer, type PipeworkServer } from './server.js'
+export type { ServerConfig, RouteRegistration, ErrorResponse, HandlerResponse, InjectOptions, InjectResponse, HttpRequest, HttpResponse, CorsConfig, SecurityConfig, RateLimitConfig, RateLimitClassesConfig, RateLimitClass, RateLimitWindow, RateLimitRefusal, InternalErrorFault } from './types.js'
+export type { FileResponse, FileResponseInit } from './file.js'
+export { buildErrorResponse, buildInternalErrorResponse } from './response.js'

package/src/request/http/middleware.ts

@@ -0,0 +1,141 @@
+import type { FastifyRequest } from 'fastify'
+import type { Manifold } from '../../core/pipework.js'
+import type { AuthStrategy, AuthRequest, AuthContext } from '../../auth/auth/types.js'
+import { parseCookies } from '../../auth/auth/cookie.js'
+import type { AuthEnricher, TenantResolver } from '../../auth/auth/chain.js'
+import type { AuthRequirement } from '../di/types.js'
+import type { TenantConfig } from '../../auth/tenant/types.js'
+import type { LoggingConfig } from '../../core/logging/types.js'
+import { createRequestContext, type Flow } from '../context/index.js'
+import { runAuthChain } from '../../auth/auth/chain.js'
+import { extractTenant } from '../../auth/tenant/index.js'
+import { validateTenantId } from '../../auth/tenant/validate.js'
+import { UnauthorizedError } from '../../core/errors/index.js'
+import { isTracingEnabled } from '../../trace/entry/tracing-enabled.js'
+import { openTrace, type ParentTraceRef } from '../../trace/entry/open-trace.js'
+import { parentTraceRef } from '../../trace/entry/parent-trace.js'
+import { parseTraceparent } from '../../trace/entry/parse-traceparent.js'
+
+export function buildAuthRequest(req: FastifyRequest): AuthRequest {
+  return {
+    headers: req.headers as Record<string, string | undefined>,
+    cookies: parseCookies(req.headers['cookie']),
+    method: req.method.toUpperCase(),
+  }
+}
+
+export interface ContextOptions {
+  instance: Manifold
+  strategies: AuthStrategy<unknown>[]
+  enrichers: AuthEnricher<unknown>[]
+  tenantResolver: TenantResolver<unknown> | undefined
+  tenantConfig: TenantConfig | null
+  authOptional: boolean
+  logging: LoggingConfig | null
+}
+
+export async function buildContext(
+  req: FastifyRequest,
+  options: ContextOptions,
+  authRequirement?: AuthRequirement,
+): Promise<Flow> {
+  let auth: unknown = null
+  let tenant: string | null = null
+
+  const isPublic = authRequirement === 'none'
+  const isOptional = authRequirement === 'optional' || (authRequirement !== 'required' && options.authOptional)
+
+  if (options.strategies.length > 0 && !isPublic) {
+    const authReq = buildAuthRequest(req)
+    const authContext = buildAuthContext(options.instance)
+    const result = await runAuthChain(
+      {
+        strategies: options.strategies,
+        ...(options.enrichers.length > 0 ? { enrichers: options.enrichers } : {}),
+        ...(options.tenantResolver ? { tenantResolver: options.tenantResolver } : {}),
+      },
+      authReq,
+      { optional: isOptional },
+      authContext,
+    )
+    auth = result.auth
+    tenant = result.tenant
+  }
+
+  if (options.tenantConfig) {
+    if (tenant === null && auth !== null) {
+      const extracted = extractTenant(auth, options.tenantConfig)
+      tenant = extracted.tenant
+    } else if (tenant !== null) {
+      const validator = options.tenantConfig.validate ?? validateTenantId
+      if (!validator(tenant)) {
+        throw new UnauthorizedError(
+          `Invalid tenant identifier: "${tenant.slice(0, 40)}${tenant.length > 40 ? '...' : ''}". ` +
+          `Tenant IDs must be valid UUIDs (or pass your custom validate function).`,
+        )
+      }
+    }
+  }
+
+  const loggingCfg = options.logging
+  const traceHeader = loggingCfg?.traceHeader ?? 'x-trace-id'
+  const requestIdHeader = loggingCfg?.requestIdHeader ?? 'x-request-id'
+  const sessionHeader = loggingCfg?.sessionHeader ?? 'x-session-id'
+
+  const traceId = (req.headers[traceHeader] as string | undefined)
+    ?? (req.headers[requestIdHeader] as string | undefined)
+    ?? req.id
+
+  const sessionId = (req.headers[sessionHeader] as string | undefined) ?? null
+
+  const trace = isTracingEnabled(options.instance)
+    ? openTrace({
+        instance: options.instance,
+        entryKind: 'http',
+        parent: resolveParent(req),
+        tenant,
+        auth,
+        requestId: String(req.id),
+        sessionId,
+      })
+    : null
+
+  return createRequestContext({
+    instance: options.instance,
+    requestId: String(req.id),
+    auth,
+    tenant,
+    tenantConfig: options.tenantConfig,
+    trace,
+    metadata: {
+      method: req.method,
+      path: req.url,
+      startedAt: Date.now(),
+      traceId: String(traceId),
+      sessionId,
+    },
+  })
+}
+
+/**
+ * Picks the parent trace for an inbound HTTP request. An incoming W3C
+ * `traceparent` (Q10) wins — it's the explicit cross-system propagation
+ * signal — and yields a synthesized parent whose `id` and `rootId` both
+ * equal the header's trace-id (the frontend's distributed trace is the root
+ * of pipework's tree). If the header is absent or malformed, we fall back to
+ * the in-process parent for nested entries (HTTP-via-inject inside a Flow).
+ */
+function resolveParent(req: FastifyRequest): ParentTraceRef | null {
+  const parsed = parseTraceparent(req.headers['traceparent'])
+  if (parsed !== null) return { id: parsed.traceId, rootId: parsed.traceId }
+  return parentTraceRef()
+}
+
+function buildAuthContext(instance: Manifold): AuthContext {
+  return {
+    db(name?: string) {
+      const dbConfig = instance.config.database(name)
+      return instance.pool.getOrCreate(dbConfig).drizzle
+    },
+  }
+}

package/src/request/http/namespace.ts

@@ -0,0 +1,5 @@
+import { file } from './file.js'
+import { detectMediaType, resolveMediaType, SNIFF_BYTES } from './sniff.js'
+
+/** HTTP namespace: `http.file()` builds a file response; `http.detectMediaType()` names bytes the way uploads do; the server itself is managed by manifold.start(). */
+export const http = { file, detectMediaType, resolveMediaType, SNIFF_BYTES } as const

package/src/request/http/rate-limit-classes.ts

@@ -0,0 +1,170 @@
+import type { FastifyRequest } from 'fastify'
+import type { Manifold } from '../../core/pipework.js'
+import { parseRouteInputs } from '../di/resolve.js'
+import type { HandlerMeta } from '../di/types.js'
+import type { Flow } from '../context/index.js'
+import { runInContext } from '../context/store.js'
+import type { DB } from '../../data/db/index.js'
+import { sql } from '../../data/db/sql.js'
+import { define } from '../../data/domain/index.js'
+import { field } from '../../data/domain/field.js'
+import { TooManyRequestsError } from '../../core/errors/index.js'
+import type { RateLimitClassesConfig, RateLimitRefusal, RateLimitWindow, RateLimitWindowName } from './types.js'
+
+// Counts behind `ServerConfig.rateLimits`; `key` is '<class>:<limit>:<value>' for a key with one window,
+// '<class>:<limit>:<windowSeconds>s:<value>' for a key with an array, and value '*' for `total`.
+export const rateLimitCounts = define('pipework_rate_limit_counts', {
+  key: field.text().primaryKey(),
+  count: field.integer().default(0),
+  windowStart: field.timestamp().default('now'),
+})
+
+const WINDOWS: readonly RateLimitWindowName[] = ['perUser', 'perTenant', 'perAddress', 'total']
+
+function windowsOf(win: RateLimitWindow | readonly RateLimitWindow[] | undefined): readonly RateLimitWindow[] {
+  return win === undefined ? [] : Array.isArray(win) ? (win as readonly RateLimitWindow[]) : [win as RateLimitWindow]
+}
+const CLEANUP_EVERY_MS = 60_000
+
+export interface RateLimitClasses {
+  /** Throws at construction for a route that names a class the config does not have. */
+  checkRoute(method: string, path: string, meta: HandlerMeta): void
+  /** Counts the request against its class and throws a 429 when any window is over. */
+  check(req: FastifyRequest, ctx: Flow, meta: HandlerMeta, route: { method: string; url: string }): Promise<void>
+}
+
+export function createRateLimitClasses(instance: Manifold, config: RateLimitClassesConfig): RateLimitClasses {
+  const classes = config.classes
+  let longest = 0
+  for (const [name, cls] of Object.entries(classes)) {
+    for (const w of WINDOWS) {
+      const raw = cls[w]
+      if (Array.isArray(raw)) {
+        const seen = new Set<number>()
+        if (raw.length === 0) {
+          throw new Error(
+            `[pipework] rateLimits.classes.${name}.${w} is an empty array.\n` +
+            '  Fix: Give it at least one window, or remove the key.',
+          )
+        }
+        for (const win of raw) {
+          if (seen.has(win.windowSeconds)) {
+            throw new Error(
+              `[pipework] rateLimits.classes.${name}.${w} has two windows of ${win.windowSeconds} seconds.\n` +
+              '  Fix: Keep one window for each windowSeconds in a key.',
+            )
+          }
+          seen.add(win.windowSeconds)
+        }
+      }
+      for (const win of windowsOf(raw)) if (win.windowSeconds > longest) longest = win.windowSeconds
+    }
+  }
+  let lastCleanup = 0
+
+  const database = (): DB => instance.pool.getOrCreate(instance.config.database(instance.config.defaultDatabaseName())).drizzle
+
+  function classOf(meta: HandlerMeta, signedIn: boolean): { name: string; explicit: boolean } | null {
+    const own = meta.rateLimit ?? null
+    if (own === false) return null
+    if (own !== null) return { name: own, explicit: true }
+    const req = meta.authRequirement
+    const name = req === 'required' ? 'signedIn' : req === 'none' ? 'public' : signedIn ? 'signedIn' : 'public'
+    return { name, explicit: false }
+  }
+
+  // Counts the request against a key; atomic per key. Runs on the system pool,
+  // outside the request's transaction, so a refused or rolled-back request still counts.
+  async function count(db: DB, key: string, windowSeconds: number): Promise<{ count: number; retryAfter: number }> {
+    const rows = await db.execute(sql`
+      INSERT INTO pipework_rate_limit_counts AS r (key, count, window_start)
+      VALUES (${key}, 1, now())
+      ON CONFLICT (key) DO UPDATE SET
+        count = CASE WHEN r.window_start < now() - ${windowSeconds}::int * interval '1 second' THEN 1 ELSE r.count + 1 END,
+        window_start = CASE WHEN r.window_start < now() - ${windowSeconds}::int * interval '1 second' THEN now() ELSE r.window_start END
+      RETURNING count, ceil(extract(epoch FROM (window_start + ${windowSeconds}::int * interval '1 second' - now())))::int AS retry`)
+    const row = rows[0]!
+    return { count: Number(row['count']), retryAfter: Math.max(1, Number(row['retry'])) }
+  }
+
+  function cleanup(db: DB, req: FastifyRequest): void {
+    const now = Date.now()
+    if (now - lastCleanup < CLEANUP_EVERY_MS) return
+    lastCleanup = now
+    void Promise.resolve(db.execute(sql`DELETE FROM pipework_rate_limit_counts WHERE window_start < now() - ${longest}::int * interval '1 second'`))
+      .catch((error: unknown) => req.log.error(error, 'Rate limit cleanup failed'))
+  }
+
+  function report(req: FastifyRequest, ctx: Flow, event: RateLimitRefusal): void {
+    const hook = config.onRefused
+    if (hook === undefined) return
+    try {
+      const result = runInContext(ctx, () => hook(event))
+      if (result !== undefined && typeof (result as Promise<void>).catch === 'function') {
+        ;(result as Promise<void>).catch((error: unknown) => req.log.error(error, 'rateLimits.onRefused threw'))
+      }
+    } catch (error) {
+      req.log.error(error, 'rateLimits.onRefused threw')
+    }
+  }
+
+  return {
+    checkRoute(method, path, meta) {
+      const own = meta.rateLimit ?? null
+      if (typeof own === 'string' && classes[own] === undefined) {
+        throw new Error(
+          `[pipework] ${method} ${path}: rate limit class "${own}" is not in rateLimits.classes.\n` +
+          `  Configured classes: ${Object.keys(classes).join(', ') || '(none)'}.\n` +
+          '  Fix: Add the class to rateLimits.classes, or use another class name, or .rateLimit(false).',
+        )
+      }
+    },
+
+    async check(req, ctx, meta, route) {
+      const auth = ctx.auth as Record<string, unknown> | null
+      const rawUser = auth?.['userId']
+      const userId = rawUser === undefined || rawUser === null || rawUser === '' ? null : String(rawUser)
+      const resolved = classOf(meta, userId !== null)
+      if (resolved === null) return
+      const cls = classes[resolved.name]
+      if (cls === undefined) return
+
+      const values: Record<RateLimitWindowName, string | null> = {
+        perUser: userId,
+        perTenant: ctx.tenant ?? null,
+        perAddress: req.ip,
+        total: '*',
+      }
+      const db = database()
+      const refused: RateLimitRefusal[] = []
+      // Parsed only once a window refuses: most requests pass and never need them.
+      let inputs: ReturnType<typeof parseRouteInputs> | undefined
+      for (const limit of WINDOWS) {
+        const raw = cls[limit]
+        const value = values[limit]
+        if (raw === undefined || value === null) continue
+        const wins = windowsOf(raw)
+        const many = Array.isArray(raw)
+        for (const win of wins) {
+          const key = many ? `${resolved.name}:${limit}:${win.windowSeconds}s:${value}` : `${resolved.name}:${limit}:${value}`
+          const got = await count(db, key, win.windowSeconds)
+          if (got.count > win.max) {
+            refused.push({
+              class: resolved.name, limit, key: value, tenantId: ctx.tenant ?? null, userId,
+              requestId: ctx.requestId, traceId: ctx.trace?.id ?? null, count: got.count, max: win.max,
+              windowSeconds: win.windowSeconds, retryAfterSeconds: got.retryAfter, route,
+              ...(inputs ??= parseRouteInputs(meta, req.query, req.params)),
+            })
+          }
+        }
+        // A refused request is not counted against the later keys: one user over
+        // their own limit does not spend the tenant's.
+        if (refused.length > 0) break
+      }
+      cleanup(db, req)
+      if (refused.length === 0) return
+      for (const event of refused) report(req, ctx, event)
+      throw new TooManyRequestsError(Math.max(...refused.map((e) => e.retryAfterSeconds)))
+    },
+  }
+}

package/src/request/http/response.ts

@@ -0,0 +1,82 @@
+import { PipeworkError, ValidationError } from '../../core/errors/index.js'
+import type { FastifyReply } from 'fastify'
+import type { ErrorResponse } from './types.js'
+
+export function buildErrorResponse(error: PipeworkError): ErrorResponse {
+  const response: ErrorResponse = {
+    error: {
+      code: error.code,
+      message: error.message,
+    },
+  }
+
+  if (error instanceof ValidationError) {
+    response.error.fields = error.fieldErrors
+  }
+
+  const wait = (error as { retryAfterSeconds?: unknown }).retryAfterSeconds
+  if (typeof wait === 'number' && Number.isFinite(wait)) response.error.retryAfterSeconds = Math.max(0, Math.ceil(wait))
+
+  return response
+}
+
+export function buildInternalErrorResponse(error?: unknown, exposeDetails?: boolean): ErrorResponse {
+  const response: ErrorResponse = {
+    error: {
+      code: 'INTERNAL_ERROR',
+      message: 'An unexpected error occurred',
+    },
+  }
+
+  if (exposeDetails === true && error !== undefined) {
+    const root = unwrapCause(error)
+    if (root !== null) {
+      response.error.details = { name: root.name, message: root.message }
+    }
+  }
+
+  return response
+}
+
+function unwrapCause(error: unknown): { name: string; message: string } | null {
+  if (!(error instanceof Error)) return null
+  let current: Error = error
+  const seen = new Set<Error>()
+  while (current.cause instanceof Error && !seen.has(current.cause)) {
+    seen.add(current)
+    current = current.cause
+  }
+  return { name: current.name, message: current.message }
+}
+
+/**
+ * Sends an error reply whole. The per-reply serializer bypasses the route's
+ * declared response schema, which describes only what the handler returns.
+ */
+export function sendError(reply: FastifyReply, status: number, body: unknown): FastifyReply {
+  void reply.serializer(JSON.stringify)
+  void reply.header('content-type', 'application/json; charset=utf-8')
+  return reply.status(status).send(body)
+}
+
+// The codes of the error classes in core/errors/http.ts, by status.
+const CLIENT_ERROR_CODES: Readonly<Record<number, string>> = {
+  401: 'UNAUTHORIZED',
+  403: 'FORBIDDEN',
+  404: 'NOT_FOUND',
+  409: 'CONFLICT',
+  413: 'PAYLOAD_TOO_LARGE',
+  415: 'UNSUPPORTED_MEDIA_TYPE',
+  429: 'TOO_MANY_REQUESTS',
+}
+
+/** Maps a client error (4xx) raised by Fastify itself to Pipework's error shape. */
+export function buildClientErrorResponse(status: number, error: unknown, retryAfter?: unknown): ErrorResponse {
+  const code = CLIENT_ERROR_CODES[status] ?? 'BAD_REQUEST'
+  const raw = (error as { message?: unknown } | null)?.message
+  const response: ErrorResponse = { error: { code, message: typeof raw === 'string' && raw !== '' ? raw : 'Bad request' } }
+  // @fastify/rate-limit sets Retry-After on the reply before it throws.
+  const wait = Number(retryAfter)
+  if (status === 429 && retryAfter !== undefined && retryAfter !== '' && Number.isFinite(wait)) response.error.retryAfterSeconds = Math.max(0, Math.ceil(wait))
+  return response
+}