@owlmeans/api 0.1.18-rc.46 → 0.1.18-rc.47

package/src/utils/body.ts

@@ -2,86 +2,69 @@ import qs from 'qs'
 import { RouteMethod } from '@owlmeans/route'
 import { FORM_CONTENT_TYPE } from './consts.local.js'
 import { JSON_CONTENT_TYPE } from './consts.js'
-import type { RequestBody } from './types.js'
+import type { BodyUtils, RequestBody } from './body/types.js'
 
-/** The request's own `content-type`, whatever case its key is written in. */
-const contentTypeOf = (headers?: Record<string, unknown>): string | undefined => {
-  const value = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === 'content-type')?.[1]
-  if (value == null || value === '') {
-    return undefined
+export const createBodyUtils = (): BodyUtils => {
+  const contentTypeOf = (headers?: Record<string, unknown>): string | undefined => {
+    const value = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === 'content-type')?.[1]
+    if (value == null || value === '') {
+      return undefined
+    }
+    return Array.isArray(value) ? value.join(', ') : `${value}`
   }
-  return Array.isArray(value) ? value.join(', ') : `${value}`
-}
-
-/** `application/json` or a `+json` suffix type, with or without parameters. */
-const isJsonContentType = (type?: string): boolean =>
-  type != null && /^application\/(?:[^\s;]+\+)?json\s*(?:;|$)/i.test(type.trim())
 
-/** A JSON value no serializer quotes for us: a string, a number or a boolean. */
-const isScalar = (value: unknown): value is string | number | boolean =>
-  typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+  const isJsonContentType = (type?: string): boolean =>
+    type != null && /^application\/(?:[^\s;]+\+)?json\s*(?:;|$)/i.test(type.trim())
 
-/** Does the entrypoint's body schema declare a string? */
-const stringContract = (schema?: object): boolean => {
-  const type = (schema as { type?: unknown } | undefined)?.type
-  return (Array.isArray(type) ? type : [type]).includes('string')
-}
+  /** A JSON value no serializer quotes for us: a string, a number or a boolean. */
+  const isScalar = (value: unknown): value is string | number | boolean =>
+    typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
 
-const parse = (text: string): { json: true, value: unknown } | { json: false } => {
-  try {
-    return { json: true, value: JSON.parse(text) }
-  } catch {
-    return { json: false }
+  /** Does the entrypoint's body schema declare a string? */
+  const stringContract = (schema?: object): boolean => {
+    const type = (schema as { type?: unknown } | undefined)?.type
+    return (Array.isArray(type) ? type : [type]).includes('string')
   }
-}
 
-/**
- * The JSON text a scalar body travels as, so the server parses it back to the same value.
- *
- * A number or a boolean is `JSON.stringify`'d. A string is a value unless it is already JSON text:
- * one that does not parse is quoted; one that parses is sent as it is (the caller serialized it
- * itself) — except under a body schema of `type: 'string'`, where only a JSON string literal
- * counts as serialized and `123`, `true` or `{…}` are the text the caller means.
- */
-const jsonScalarBody = (body: string | number | boolean, schema?: object): string => {
-  if (typeof body !== 'string') {
-    return JSON.stringify(body)
+  const parse = (text: string): { json: true, value: unknown } | { json: false } => {
+    try {
+      return { json: true, value: JSON.parse(text) }
+    } catch {
+      return { json: false }
+    }
   }
-  const parsed = parse(body)
-  const serialized = parsed.json && (!stringContract(schema) || typeof parsed.value === 'string')
 
-  return serialized ? body : JSON.stringify(body)
-}
+  const jsonScalarBody = (body: string | number | boolean, schema?: object): string => {
+    if (typeof body !== 'string') {
+      return JSON.stringify(body)
+    }
+    const parsed = parse(body)
+    const serialized = parsed.json && (!stringContract(schema) || typeof parsed.value === 'string')
 
-/**
- * What a request's body becomes on the wire.
- *
- * - A `x-www-form-urlencoded` request: the body through `qs`.
- * - A string, number or boolean under a JSON `content-type` — the caller's, or `application/json`
- *   supplied for a `POST` that names none — becomes JSON text ({@link jsonScalarBody}).
- * - Anything else — objects, arrays, a scalar under another content type — goes to axios as it is,
- *   which serializes an object or an array as JSON.
- */
-const requestBodyOf = (
-  body: unknown, headers: Record<string, unknown> | undefined, method?: RouteMethod, schema?: object
-): RequestBody => {
-  const type = contentTypeOf(headers)
-  if (body != null && type?.includes(FORM_CONTENT_TYPE) === true) {
-    return { data: qs.stringify(body), verbatim: false }
+    return serialized ? body : JSON.stringify(body)
   }
-  if (!isScalar(body)) {
+
+  const requestBodyOf = (
+    body: unknown, headers: Record<string, unknown> | undefined, method?: RouteMethod, schema?: object
+  ): RequestBody => {
+    const type = contentTypeOf(headers)
+    if (body != null && type?.includes(FORM_CONTENT_TYPE) === true) {
+      return { data: qs.stringify(body), verbatim: false }
+    }
+    if (!isScalar(body)) {
+      return { data: body, verbatim: false }
+    }
+    if (type == null && method === RouteMethod.POST) {
+      return { data: jsonScalarBody(body, schema), contentType: JSON_CONTENT_TYPE, verbatim: true }
+    }
+    if (isJsonContentType(type)) {
+      return { data: jsonScalarBody(body, schema), verbatim: true }
+    }
+
     return { data: body, verbatim: false }
   }
-  if (type == null && method === RouteMethod.POST) {
-    return { data: jsonScalarBody(body, schema), contentType: JSON_CONTENT_TYPE, verbatim: true }
-  }
-  if (isJsonContentType(type)) {
-    return { data: jsonScalarBody(body, schema), verbatim: true }
-  }
 
-  return { data: body, verbatim: false }
+  return { contentTypeOf, isJsonContentType, jsonScalarBody, requestBodyOf }
 }
 
-export const createBodyHelper = () => ({ contentTypeOf, isJsonContentType, jsonScalarBody, requestBodyOf })
-
-export const bodyHelper = createBodyHelper()
+export const bodyUtils = createBodyUtils()

package/src/utils/index.ts

@@ -1,2 +1,3 @@
 
-export * from './handler.js'
+export type * from './response/types.js'
+export * from './response.js'

package/src/utils/response/types.ts

@@ -0,0 +1,15 @@
+import type { AbstractResponse } from '@owlmeans/entrypoint'
+import type { AxiosResponse } from 'axios'
+import type { ApiClientError } from '../../errors.js'
+
+/** Turns an axios answer into the entrypoint reply: a resolved value or a typed failure. */
+export interface ResponseUtils {
+  /** Resolves `reply` with a 2xx answer's value, or rejects it with the failure of any other status. */
+  processResponse: (response: AxiosResponse, reply: AbstractResponse<any>) => void
+  /**
+   * The typed error of a bare status: `ServerCrashedError` (500), `ServerAuthError` (401),
+   * `ApiClientError('forbidden[:<id>]')` (403), `ApiStatusError` (`api:client:status:<n>[:<id>]`)
+   * for every other one.
+   */
+  statusError: (status: number, incidentId?: string) => ApiClientError
+}

package/src/utils/response.ts

@@ -0,0 +1,117 @@
+import { type AbstractResponse, EntrypointOutcome } from '@owlmeans/entrypoint'
+import type { AxiosResponse } from 'axios'
+import {
+  ACCEPTED, CREATED, FINISHED, FORBIDDEN_ERROR, INCIDENT_ID_HEADER, DENIAL_KIND_HEADER,
+  ACCESS_DENIED_KIND, OK, SERVER_ERROR, UNAUTHORIZED_ERROR,
+} from '../consts.js'
+import { ResilientError } from '@owlmeans/error'
+import { ApiClientError, ApiStatusError, ServerAuthError, ServerCrashedError } from '../errors.js'
+import { apiStatusHelper } from '../status/helper.js'
+import type { ResponseStatusCarrier } from '../status/types.js'
+import { logger } from '@owlmeans/log'
+import type { ResponseUtils } from './response/types.js'
+
+export const createResponseUtils = (): ResponseUtils => {
+  const log = logger('api')
+
+  const processResponse = (response: AxiosResponse, reply: AbstractResponse<any>): void => {
+    switch (response.status) {
+      case OK:
+        reply.resolve(response.data, EntrypointOutcome.Ok)
+        return
+      case ACCEPTED:
+        reply.resolve(response.data, EntrypointOutcome.Accepted)
+        return
+      case CREATED:
+        return processEmptyResponse(response, reply, EntrypointOutcome.Created)
+      case FINISHED:
+        return processEmptyResponse(response, reply, EntrypointOutcome.Finished)
+      default:
+        // A refusal is ordinary traffic (401, 403, 409, 428): debug, and never the headers.
+        log.debug('Request answered with a failure', {
+          status: response.status, statusText: response.statusText, url: response.config?.url,
+          incidentId: headerOf(response.headers, INCIDENT_ID_HEADER),
+        })
+
+        reply.reject(failureOf(response))
+    }
+  }
+
+  /**
+   * The error a non-2xx answer rejects with — always carrying the HTTP status and, when the server
+   * sent one, its incident id.
+   *
+   * A development body is the marshaled `ResilientError`: it is rebuilt into its own class and
+   * stamped with `responseStatus`. Anything else — the bare incident id of a production body, a
+   * proxy's HTML, a framework's JSON — becomes the status error of {@link statusError}.
+   */
+  const failureOf = (response: AxiosResponse): Error => {
+    const incidentId = headerOf(response.headers, INCIDENT_ID_HEADER)
+      ?? (apiStatusHelper.isIncidentBody(response.data) ? response.data.trim() : undefined)
+    const denialKind = response.status === FORBIDDEN_ERROR
+      && headerOf(response.headers, DENIAL_KIND_HEADER) === ACCESS_DENIED_KIND
+      ? ACCESS_DENIED_KIND : undefined
+
+    if (typeof response.data === 'string' && response.data.includes(ResilientError.separator)) {
+      try {
+        const error = ResilientError.ensure(response.data, true)
+        error.incidentId ??= incidentId
+        Object.assign(error, {
+          responseStatus: response.status, denialKind,
+        } satisfies ResponseStatusCarrier)
+
+        return error
+      } catch {
+        log.warn('Server returned an unrecognizable text error', { status: response.status, body: response.data })
+      }
+    }
+
+    return Object.assign(statusError(response.status, incidentId), { denialKind })
+  }
+
+  /**
+   * The typed error of a bare status: `ServerCrashedError` (500), `ServerAuthError` (401),
+   * `ApiClientError('forbidden[:<id>]')` (403), `ApiStatusError` (`api:client:status:<n>[:<id>]`)
+   * for every other one.
+   */
+  const statusError = (status: number, incidentId?: string): ApiClientError => {
+    const error = status === SERVER_ERROR ? new ServerCrashedError(incidentId)
+      : status === UNAUTHORIZED_ERROR ? new ServerAuthError(incidentId)
+        : status === FORBIDDEN_ERROR ? new ApiClientError(incidentId != null ? `forbidden:${incidentId}` : 'forbidden')
+          : new ApiStatusError(status, incidentId)
+    if (incidentId != null) {
+      error.incidentId = incidentId
+    }
+
+    return Object.assign(error, { responseStatus: status } satisfies ResponseStatusCarrier)
+  }
+
+  /** One response header, from an `AxiosHeaders` instance or a plain header object alike. */
+  const headerOf = (headers: unknown, name: string): string | undefined => {
+    if (headers == null || typeof headers !== 'object') {
+      return undefined
+    }
+    const get = (headers as { get?: unknown }).get
+    const viaGet = typeof get === 'function' ? get.call(headers, name) : undefined
+    const value = viaGet ?? Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1]
+    const first = Array.isArray(value) ? value[0] : value
+
+    return typeof first === 'string' && first.trim() !== '' ? first.trim() : undefined
+  }
+
+  const processEmptyResponse = (response: AxiosResponse, reply: AbstractResponse<any>, outcome: EntrypointOutcome): void => {
+    if (response.data != null && response.data != '') {
+      reply.resolve(response.data, outcome)
+      return
+    }
+    if (response.headers.toJSON != null && typeof response.headers.toJSON === 'function') {
+      reply.resolve(response.headers.toJSON(), outcome)
+      return
+    }
+    reply.resolve(response.headers, outcome)
+  }
+
+  return { processResponse, statusError }
+}
+
+export const responseUtils = createResponseUtils()

package/tests/body.spec.ts

@@ -2,58 +2,58 @@ import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
 import { provideResponse, type AbstractRequest } from '@owlmeans/entrypoint'
 import { RouteMethod } from '@owlmeans/route'
 import { createApiService } from '../src/service.js'
-import { bodyHelper } from '../src/utils/body.js'
+import { bodyUtils } from '../src/utils/body.js'
 
 const STRING = { type: 'string' }
 
 describe('what a request body becomes', () => {
   test('a scalar on a POST without a content type is JSON text', () => {
-    expect(bodyHelper.requestBodyOf('abc', {}, RouteMethod.POST)).toEqual({ data: '"abc"', contentType: 'application/json', verbatim: true })
-    expect(bodyHelper.requestBodyOf('', {}, RouteMethod.POST).data).toBe('""')
-    expect(bodyHelper.requestBodyOf(5, {}, RouteMethod.POST).data).toBe('5')
-    expect(bodyHelper.requestBodyOf(0, {}, RouteMethod.POST).data).toBe('0')
-    expect(bodyHelper.requestBodyOf(true, {}, RouteMethod.POST).data).toBe('true')
-    expect(bodyHelper.requestBodyOf(false, {}, RouteMethod.POST).data).toBe('false')
+    expect(bodyUtils.requestBodyOf('abc', {}, RouteMethod.POST)).toEqual({ data: '"abc"', contentType: 'application/json', verbatim: true })
+    expect(bodyUtils.requestBodyOf('', {}, RouteMethod.POST).data).toBe('""')
+    expect(bodyUtils.requestBodyOf(5, {}, RouteMethod.POST).data).toBe('5')
+    expect(bodyUtils.requestBodyOf(0, {}, RouteMethod.POST).data).toBe('0')
+    expect(bodyUtils.requestBodyOf(true, {}, RouteMethod.POST).data).toBe('true')
+    expect(bodyUtils.requestBodyOf(false, {}, RouteMethod.POST).data).toBe('false')
   })
 
   test('a scalar under an explicit JSON content type is JSON text, on any method', () => {
-    expect(bodyHelper.requestBodyOf('abc', { 'Content-Type': 'application/json; charset=utf-8' }, RouteMethod.PUT))
+    expect(bodyUtils.requestBodyOf('abc', { 'Content-Type': 'application/json; charset=utf-8' }, RouteMethod.PUT))
       .toEqual({ data: '"abc"', verbatim: true })
-    expect(bodyHelper.requestBodyOf(7, { 'content-type': 'application/merge-patch+json' }, RouteMethod.PATCH).data).toBe('7')
+    expect(bodyUtils.requestBodyOf(7, { 'content-type': 'application/merge-patch+json' }, RouteMethod.PATCH).data).toBe('7')
   })
 
   test('already-serialized JSON text is sent as it is', () => {
-    expect(bodyHelper.requestBodyOf('{"a":1}', {}, RouteMethod.POST).data).toBe('{"a":1}')
-    expect(bodyHelper.requestBodyOf('[1,2]', {}, RouteMethod.POST).data).toBe('[1,2]')
-    expect(bodyHelper.requestBodyOf('"abc"', {}, RouteMethod.POST).data).toBe('"abc"')
-    expect(bodyHelper.requestBodyOf('"abc"', {}, RouteMethod.POST, STRING).data).toBe('"abc"')
+    expect(bodyUtils.requestBodyOf('{"a":1}', {}, RouteMethod.POST).data).toBe('{"a":1}')
+    expect(bodyUtils.requestBodyOf('[1,2]', {}, RouteMethod.POST).data).toBe('[1,2]')
+    expect(bodyUtils.requestBodyOf('"abc"', {}, RouteMethod.POST).data).toBe('"abc"')
+    expect(bodyUtils.requestBodyOf('"abc"', {}, RouteMethod.POST, STRING).data).toBe('"abc"')
   })
 
   test('under a string body schema, JSON-looking text is the string the caller means', () => {
-    expect(bodyHelper.jsonScalarBody('123', STRING)).toBe('"123"')
-    expect(bodyHelper.jsonScalarBody('true', STRING)).toBe('"true"')
-    expect(bodyHelper.jsonScalarBody('null', { type: ['string', 'null'] })).toBe('"null"')
-    expect(bodyHelper.jsonScalarBody('{"a":1}', STRING)).toBe('"{\\"a\\":1}"')
-    expect(bodyHelper.jsonScalarBody('123', { type: 'number' })).toBe('123')
+    expect(bodyUtils.jsonScalarBody('123', STRING)).toBe('"123"')
+    expect(bodyUtils.jsonScalarBody('true', STRING)).toBe('"true"')
+    expect(bodyUtils.jsonScalarBody('null', { type: ['string', 'null'] })).toBe('"null"')
+    expect(bodyUtils.jsonScalarBody('{"a":1}', STRING)).toBe('"{\\"a\\":1}"')
+    expect(bodyUtils.jsonScalarBody('123', { type: 'number' })).toBe('123')
   })
 
   test('objects, arrays and everything outside JSON behave as before', () => {
     const object = { a: 1 }
-    expect(bodyHelper.requestBodyOf(object, {}, RouteMethod.POST)).toEqual({ data: object, verbatim: false })
-    expect(bodyHelper.requestBodyOf([1], {}, RouteMethod.POST)).toEqual({ data: [1], verbatim: false })
-    expect(bodyHelper.requestBodyOf(undefined, {}, RouteMethod.POST)).toEqual({ data: undefined, verbatim: false })
-    expect(bodyHelper.requestBodyOf('abc', { 'content-type': 'text/plain' }, RouteMethod.POST)).toEqual({ data: 'abc', verbatim: false })
-    expect(bodyHelper.requestBodyOf('abc', {}, RouteMethod.PUT)).toEqual({ data: 'abc', verbatim: false })
-    expect(bodyHelper.requestBodyOf({ a: '1', b: ['x'] }, { 'content-type': 'application/x-www-form-urlencoded' }, RouteMethod.POST).data)
+    expect(bodyUtils.requestBodyOf(object, {}, RouteMethod.POST)).toEqual({ data: object, verbatim: false })
+    expect(bodyUtils.requestBodyOf([1], {}, RouteMethod.POST)).toEqual({ data: [1], verbatim: false })
+    expect(bodyUtils.requestBodyOf(undefined, {}, RouteMethod.POST)).toEqual({ data: undefined, verbatim: false })
+    expect(bodyUtils.requestBodyOf('abc', { 'content-type': 'text/plain' }, RouteMethod.POST)).toEqual({ data: 'abc', verbatim: false })
+    expect(bodyUtils.requestBodyOf('abc', {}, RouteMethod.PUT)).toEqual({ data: 'abc', verbatim: false })
+    expect(bodyUtils.requestBodyOf({ a: '1', b: ['x'] }, { 'content-type': 'application/x-www-form-urlencoded' }, RouteMethod.POST).data)
       .toBe('a=1&b%5B0%5D=x')
   })
 
   test('the content-type header is read whatever its case', () => {
-    expect(bodyHelper.contentTypeOf({ 'CONTENT-TYPE': 'application/json' })).toBe('application/json')
-    expect(bodyHelper.contentTypeOf({ accept: 'application/json' })).toBeUndefined()
-    expect(bodyHelper.isJsonContentType('application/vnd.api+json')).toBe(true)
-    expect(bodyHelper.isJsonContentType('application/jsonp')).toBe(false)
-    expect(bodyHelper.isJsonContentType('text/plain')).toBe(false)
+    expect(bodyUtils.contentTypeOf({ 'CONTENT-TYPE': 'application/json' })).toBe('application/json')
+    expect(bodyUtils.contentTypeOf({ accept: 'application/json' })).toBeUndefined()
+    expect(bodyUtils.isJsonContentType('application/vnd.api+json')).toBe(true)
+    expect(bodyUtils.isJsonContentType('application/jsonp')).toBe(false)
+    expect(bodyUtils.isJsonContentType('text/plain')).toBe(false)
   })
 })
 

package/tests/handler.spec.ts

@@ -6,12 +6,12 @@ import { EntrypointOutcome } from '@owlmeans/entrypoint'
 import { ResilientError } from '@owlmeans/error'
 import { RecordExists, UnknownRecordError } from '@owlmeans/resource'
 import {
-  ApiClientError, ApiStatusError, ServerAuthError, ServerCrashedError, httpStatusOf, incidentIdOf,
+  ApiClientError, ApiStatusError, ServerAuthError, ServerCrashedError, apiStatusHelper,
   INCIDENT_ID_HEADER,
   DENIAL_KIND_HEADER, ACCESS_DENIED_KIND,
 } from '../src/index.js'
-import { processResponse, statusError } from '../src/utils/handler.js'
-import * as status from '../src/status/index.js'
+import { responseUtils } from '../src/utils/response.js'
+import * as statusModule from '../src/status/index.js'
 
 const INCIDENT = '6f1c1a52-8a0e-4f5e-9a7c-1f2d3e4c5b6a'
 
@@ -41,7 +41,7 @@ const respond = (
     resolve: (value, outcome) => { reply.value = value; reply.outcome = outcome },
     reject: error => { reply.error = error },
   }
-  processResponse({
+  responseUtils.processResponse({
     status: statusCode, statusText: '', data, headers, config: { url: '/spec' },
   } as unknown as AxiosResponse, reply)
 
@@ -63,64 +63,64 @@ describe('2xx', () => {
 describe('a production incident body keeps its status and incident id', () => {
   test('only a labelled 403 is an auth/IAM denial', () => {
     const denied = respond(403, INCIDENT, { [DENIAL_KIND_HEADER]: ACCESS_DENIED_KIND }).error
-    expect(status.isAccessDenied(denied)).toBe(true)
-    expect(status.isAccessDenied(respond(403, INCIDENT).error)).toBe(false)
-    expect(status.isAccessDenied(respond(401, INCIDENT, { [DENIAL_KIND_HEADER]: ACCESS_DENIED_KIND }).error)).toBe(false)
+    expect(statusModule.apiStatusHelper.isAccessDenied(denied)).toBe(true)
+    expect(statusModule.apiStatusHelper.isAccessDenied(respond(403, INCIDENT).error)).toBe(false)
+    expect(statusModule.apiStatusHelper.isAccessDenied(respond(401, INCIDENT, { [DENIAL_KIND_HEADER]: ACCESS_DENIED_KIND }).error)).toBe(false)
   })
   test('428 with the header becomes ApiStatusError', () => {
     const { error } = respond(428, INCIDENT, { [INCIDENT_ID_HEADER.toLowerCase()]: INCIDENT })
     expect(error).toBeInstanceOf(ApiStatusError)
     expect(error!.message).toBe(`api:client:status:428:${INCIDENT}`)
-    expect(httpStatusOf(error)).toBe(428)
-    expect(incidentIdOf(error)).toBe(INCIDENT)
+    expect(apiStatusHelper.httpStatusOf(error)).toBe(428)
+    expect(apiStatusHelper.incidentIdOf(error)).toBe(INCIDENT)
     expect((error as ApiStatusError).status).toBe(428)
   })
 
   test('the header is read from AxiosHeaders too, and the body alone suffices', () => {
     const headers = new AxiosHeaders({ [INCIDENT_ID_HEADER]: INCIDENT })
-    expect(incidentIdOf(respond(409, 'x', headers).error)).toBe(INCIDENT)
-    expect(incidentIdOf(respond(402, INCIDENT).error)).toBe(INCIDENT)
-    expect(httpStatusOf(respond(402, INCIDENT).error)).toBe(402)
+    expect(apiStatusHelper.incidentIdOf(respond(409, 'x', headers).error)).toBe(INCIDENT)
+    expect(apiStatusHelper.incidentIdOf(respond(402, INCIDENT).error)).toBe(INCIDENT)
+    expect(apiStatusHelper.httpStatusOf(respond(402, INCIDENT).error)).toBe(402)
   })
 
   test('500, 401 and 403 keep their classes and markers', () => {
     const crashed = respond(500, INCIDENT).error
     expect(crashed).toBeInstanceOf(ServerCrashedError)
     expect(crashed!.message).toBe(`api:client:crashed:${INCIDENT}`)
-    expect(httpStatusOf(crashed)).toBe(500)
+    expect(apiStatusHelper.httpStatusOf(crashed)).toBe(500)
 
     const auth = respond(401, INCIDENT).error
     expect(auth).toBeInstanceOf(ServerAuthError)
     expect(auth!.message).toBe(`api:client:auth:${INCIDENT}`)
-    expect(httpStatusOf(auth)).toBe(401)
+    expect(apiStatusHelper.httpStatusOf(auth)).toBe(401)
 
     const forbidden = respond(403, INCIDENT).error
     expect(forbidden).toBeInstanceOf(ApiClientError)
     expect(forbidden).not.toBeInstanceOf(ApiStatusError)
     expect(forbidden!.message).toBe(`api:client:forbidden:${INCIDENT}`)
-    expect(httpStatusOf(forbidden)).toBe(403)
+    expect(apiStatusHelper.httpStatusOf(forbidden)).toBe(403)
   })
 
   test('without an incident id the markers stay as before', () => {
-    expect(statusError(500).message).toBe('api:client:crashed:error')
-    expect(statusError(403).message).toBe('api:client:forbidden')
-    expect(incidentIdOf(statusError(500))).toBeNull()
-    expect(statusError(418).message).toBe('api:client:status:418')
+    expect(responseUtils.statusError(500).message).toBe('api:client:crashed:error')
+    expect(responseUtils.statusError(403).message).toBe('api:client:forbidden')
+    expect(apiStatusHelper.incidentIdOf(responseUtils.statusError(500))).toBeNull()
+    expect(responseUtils.statusError(418).message).toBe('api:client:status:418')
   })
 
   test('a proxy HTML page or framework JSON becomes a status error', () => {
     const html = respond(502, '<html><body>Bad Gateway</body></html>').error
     expect(html).toBeInstanceOf(ApiStatusError)
-    expect(httpStatusOf(html)).toBe(502)
-    expect(incidentIdOf(html)).toBeNull()
+    expect(apiStatusHelper.httpStatusOf(html)).toBe(502)
+    expect(apiStatusHelper.incidentIdOf(html)).toBeNull()
 
     const json = respond(400, { statusCode: 400, error: 'Bad Request', message: 'body/x' }).error
     expect(json).toBeInstanceOf(ApiStatusError)
-    expect(httpStatusOf(json)).toBe(400)
+    expect(apiStatusHelper.httpStatusOf(json)).toBe(400)
   })
 
   test('no class declares a static httpStatus, so a rethrow upstream stays 500', () => {
-    for (const error of [statusError(428), statusError(500), statusError(401), statusError(403)]) {
+    for (const error of [responseUtils.statusError(428), responseUtils.statusError(500), responseUtils.statusError(401), responseUtils.statusError(403)]) {
       expect((error.constructor as { httpStatus?: unknown }).httpStatus).toBeUndefined()
     }
   })
@@ -133,8 +133,8 @@ describe('a development body stays its typed class', () => {
     expect(error).toBeInstanceOf(ConsentRequired)
     expect(error!.message).toBe('spec:consent-required:2')
     expect((error as { responseStatus?: number }).responseStatus).toBe(428)
-    expect(httpStatusOf(error)).toBe(428)
-    expect(incidentIdOf(error)).toBe(INCIDENT)
+    expect(apiStatusHelper.httpStatusOf(error)).toBe(428)
+    expect(apiStatusHelper.incidentIdOf(error)).toBe(INCIDENT)
   })
 
   test('a typed api error keeps its marker fields', () => {
@@ -153,8 +153,8 @@ describe('a development body stays its typed class', () => {
       const { error } = respond(code, body, { [INCIDENT_ID_HEADER]: INCIDENT })
       expect(error!.constructor).toBe(refusal.constructor)
       expect(error!.message).toBe(refusal.message)
-      expect(httpStatusOf(error)).toBe(code)
-      expect(incidentIdOf(error)).toBe(INCIDENT)
+      expect(apiStatusHelper.httpStatusOf(error)).toBe(code)
+      expect(apiStatusHelper.incidentIdOf(error)).toBe(INCIDENT)
     }
     const body = ResilientError.marshal(new UnknownRecordError('shelf/3')).message
     expect((respond(404, body).error as UnknownRecordError).id).toBe('shelf/3')
@@ -164,8 +164,8 @@ describe('a development body stays its typed class', () => {
     const body = `ApiSpecUnregisteredRefusal${ResilientError.separator}spec:unregistered:x`
     const { error } = respond(404, body, { [INCIDENT_ID_HEADER]: INCIDENT })
     expect(error).not.toBeInstanceOf(ServerCrashedError)
-    expect(httpStatusOf(error)).toBe(404)
-    expect(incidentIdOf(error)).toBe(INCIDENT)
+    expect(apiStatusHelper.httpStatusOf(error)).toBe(404)
+    expect(apiStatusHelper.incidentIdOf(error)).toBe(INCIDENT)
   })
 })
 
@@ -176,7 +176,7 @@ describe('a production body of a storage refusal keeps the declared status', ()
       expect(error).toBeInstanceOf(ApiStatusError)
       expect(error).not.toBeInstanceOf(ServerCrashedError)
       expect(error!.message).toBe(`api:client:status:${code}:${INCIDENT}`)
-      expect(httpStatusOf(error)).toBe(code)
+      expect(apiStatusHelper.httpStatusOf(error)).toBe(code)
     }
   })
 })
@@ -195,35 +195,35 @@ describe('marshal round trips', () => {
       const back = roundTrip(error)
       expect(back.constructor).toBe(error.constructor)
       expect((back as ApiClientError).status).toBe(code)
-      expect(httpStatusOf(back)).toBe(code)
-      expect(incidentIdOf(back)).toBe(INCIDENT)
+      expect(apiStatusHelper.httpStatusOf(back)).toBe(code)
+      expect(apiStatusHelper.incidentIdOf(back)).toBe(INCIDENT)
     }
   })
 
   test('a legacy bare-status marker still reads', () => {
-    expect(httpStatusOf(new ApiClientError('404'))).toBe(404)
+    expect(apiStatusHelper.httpStatusOf(new ApiClientError('404'))).toBe(404)
   })
 })
 
 describe('./status', () => {
   test('a declared static 428 answers without any marker; an undeclared 5xx does not', () => {
-    expect(status.httpStatusOf(new ConsentRequired())).toBe(428)
-    expect(status.httpStatusOf(new Unavailable())).toBeNull()
-    expect(status.httpStatusOf(new Error('plain'))).toBeNull()
-    expect(status.httpStatusOf(null)).toBeNull()
+    expect(statusModule.apiStatusHelper.httpStatusOf(new ConsentRequired())).toBe(428)
+    expect(statusModule.apiStatusHelper.httpStatusOf(new Unavailable())).toBeNull()
+    expect(statusModule.apiStatusHelper.httpStatusOf(new Error('plain'))).toBeNull()
+    expect(statusModule.apiStatusHelper.httpStatusOf(null)).toBeNull()
   })
 
   test('reads a marker from a plain error message or a type', () => {
-    expect(status.httpStatusOf(new Error(`${status.API_STATUS_MARKER}428:${INCIDENT}`))).toBe(428)
-    expect(status.httpStatusOf({ type: 'api:client:auth:error' })).toBe(401)
-    expect(status.incidentIdOf(new Error(`api:client:crashed:${INCIDENT}`))).toBe(INCIDENT)
+    expect(statusModule.apiStatusHelper.httpStatusOf(new Error(`${statusModule.API_STATUS_MARKER}428:${INCIDENT}`))).toBe(428)
+    expect(statusModule.apiStatusHelper.httpStatusOf({ type: 'api:client:auth:error' })).toBe(401)
+    expect(statusModule.apiStatusHelper.incidentIdOf(new Error(`api:client:crashed:${INCIDENT}`))).toBe(INCIDENT)
   })
 
   test('isIncidentBody accepts a bare incident UUID only', () => {
-    expect(status.isIncidentBody(INCIDENT)).toBe(true)
-    expect(status.isIncidentBody(`${INCIDENT}\n`)).toBe(true)
-    expect(status.isIncidentBody('Unauthorized')).toBe(false)
-    expect(status.isIncidentBody(`ApiError|||api:x|||${INCIDENT}`)).toBe(false)
-    expect(status.isIncidentBody({ id: INCIDENT })).toBe(false)
+    expect(statusModule.apiStatusHelper.isIncidentBody(INCIDENT)).toBe(true)
+    expect(statusModule.apiStatusHelper.isIncidentBody(`${INCIDENT}\n`)).toBe(true)
+    expect(statusModule.apiStatusHelper.isIncidentBody('Unauthorized')).toBe(false)
+    expect(statusModule.apiStatusHelper.isIncidentBody(`ApiError|||api:x|||${INCIDENT}`)).toBe(false)
+    expect(statusModule.apiStatusHelper.isIncidentBody({ id: INCIDENT })).toBe(false)
   })
 })

package/build/utils/handler.d.ts

@@ -1,11 +0,0 @@
-import { type AbstractResponse } from '@owlmeans/entrypoint';
-import type { AxiosResponse } from 'axios';
-import { ApiClientError } from '../errors.js';
-export declare const processResponse: (response: AxiosResponse, reply: AbstractResponse<any>) => void;
-/**
- * The typed error of a bare status: `ServerCrashedError` (500), `ServerAuthError` (401),
- * `ApiClientError('forbidden[:<id>]')` (403), `ApiStatusError` (`api:client:status:<n>[:<id>]`)
- * for every other one.
- */
-export declare const statusError: (status: number, incidentId?: string) => ApiClientError;
-//# sourceMappingURL=handler.d.ts.map

package/build/utils/handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/utils/handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAqB,MAAM,sBAAsB,CAAA;AAC/E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAM1C,OAAO,EAAE,cAAc,EAAuD,MAAM,cAAc,CAAA;AAOlG,eAAO,MAAM,eAAe,aAAc,aAAa,SAAS,gBAAgB,CAAC,GAAG,CAAC,SAqBpF,CAAA;AAkCD;;;;GAIG;AACH,eAAO,MAAM,WAAW,WAAY,MAAM,eAAe,MAAM,KAAG,cAUjE,CAAA"}