rouzer 3.0.2 → 3.2.0

package/README.md

@@ -6,12 +6,14 @@ and Zod validation between a Hattip-compatible server and a typed fetch client.
 ## What it does
 
 A Rouzer HTTP route tree defines URL patterns, named actions, method schemas, and
-optional response types once, then reuses that contract to:
+optional JSON, error, or newline-delimited JSON response types once, then reuses
+that contract to:
 
 - validate client arguments before `fetch`
 - match and validate server requests before handlers run
 - type handler context from path, query/body, headers, and middleware
 - attach typed client action functions such as `client.profiles.get(...)`
+- parse typed JSON responses, declared error responses, and NDJSON streams
 
 Rouzer optimizes for shared TypeScript route modules over language-agnostic API
 schemas or generated SDKs.
@@ -22,6 +24,8 @@ Use Rouzer if:
 
 - your server and client can import the same TypeScript route tree
 - you want Zod request validation on both sides of an HTTP boundary
+- response data is validated at data/client boundaries, not by re-checking every
+  handler return
 - a Hattip-compatible handler fits your server runtime
 - you prefer named resource/action functions over a generated client class
 
@@ -29,8 +33,8 @@ Consider something else if:
 
 - you need OpenAPI-first workflows, schema files, or generated clients for other
   languages
-- you need runtime response-body validation; `response: $type<T>()` is
-  compile-time only
+- you want the router to validate every response body at the server boundary;
+  `$type<T>()`, `$error<T>()`, and `ndjson.$type<T>()` are type contracts
 - you want a framework that owns controllers, data loading, rendering, and
   deployment adapters
 - you cannot use ESM or Zod v4+
@@ -53,7 +57,7 @@ Import the primary API from the root package and declare routes through the HTTP
 subpath:
 
 ```ts
-import { $type, chain, createClient, createRouter } from 'rouzer'
+import { $error, $type, chain, createClient, createRouter } from 'rouzer'
 import * as http from 'rouzer/http'
 ```
 
@@ -101,10 +105,90 @@ const { message } = await client.hello({
 route arguments before `fetch`; server handlers validate matched path, query,
 headers, and JSON bodies before your handler runs.
 
+### Typed status responses
+
+Use a response map when client code needs declared error statuses as data instead
+of exceptions.
+
+```ts
+import { $error, $type, createClient, createRouter } from 'rouzer'
+import * as http from 'rouzer/http'
+
+type User = { id: string; name: string }
+type NotFound = { code: 'NOT_FOUND'; message: string }
+
+export const getUser = http.get('users/:id', {
+  response: {
+    200: $type<User>(),
+    404: $error<NotFound>(),
+  },
+})
+export const routes = { getUser }
+
+createRouter().use(routes, {
+  getUser(ctx) {
+    if (ctx.path.id === 'missing') {
+      return ctx.error(404, {
+        code: 'NOT_FOUND',
+        message: 'User not found',
+      })
+    }
+    return { id: ctx.path.id, name: 'Ada' }
+  },
+})
+
+const client = createClient({
+  baseURL: 'https://example.com/api/',
+  routes,
+})
+
+const [error, user, status] = await client.getUser({ path: { id: '42' } })
+```
+
+Success entries resolve as `[null, value, status]`; declared error entries
+resolve as `[error, null, status]`.
+
+### NDJSON response streams
+
+Use `response: ndjson.$type<T>()` for endpoints that stream
+newline-delimited JSON. Add `ndjson.routerPlugin` to the router and
+`ndjson.clientPlugin` to the client. Handlers return an `Iterable<T>` or
+`AsyncIterable<T>`; Rouzer wraps it in an `application/x-ndjson` response.
+Client action functions resolve to an `AsyncIterable<T>`.
+
+```ts
+import { createClient, createRouter } from 'rouzer'
+import * as http from 'rouzer/http'
+import * as ndjson from 'rouzer/ndjson'
+
+export const events = http.get('events', {
+  response: ndjson.$type<{ id: number; message: string }>(),
+})
+export const routes = { events }
+
+createRouter({ plugins: [ndjson.routerPlugin] }).use(routes, {
+  async *events() {
+    yield { id: 1, message: 'ready' }
+  },
+})
+
+const client = createClient({
+  baseURL: 'https://example.com/api/',
+  routes,
+  plugins: [ndjson.clientPlugin],
+})
+for await (const event of await client.events()) {
+  console.log(event.message)
+}
+```
+
 ## Documentation
 
-- [Concepts, API selection, and v2.0.1 migration notes](docs/context.md)
+- [Concepts, API selection, and v2->v3 migration notes](docs/context.md)
 - [Runnable shared-route example](examples/basic-usage.ts)
+- [Runnable typed error response example](examples/error-responses.ts)
+- [Runnable NDJSON response-stream example](examples/ndjson-stream.ts)
 - Generated declarations in the published package provide the exact signatures
-  for every public export, including the `rouzer/http` subpath.
+  for every public export, including the `rouzer/http` and `rouzer/ndjson`
+  subpaths.
 - Public TSDoc in `src/` owns symbol-level behavior and option details.

package/dist/client/index.d.ts

@@ -1,5 +1,6 @@
 import { Promisable } from '../common.js';
 import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
+import { type ClientResponsePlugin } from '../response.js';
 import type { RouteArgs } from '../types/args.js';
 import type { RouteRequest } from '../types/request.js';
 import type { InferRouteResponse } from '../types/response.js';
@@ -38,13 +39,17 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
      * ```
      */
     routes?: TRoutes;
+    /** Response codec plugins used by generated action functions. */
+    plugins?: readonly ClientResponsePlugin[];
     /**
-     * Custom handler for non-2xx responses from `.json()`.
+     * Custom handler for non-2xx responses from `.json()` and generated response
+     * helpers.
      *
-     * @remarks When provided, the return value is returned from `.json()` as-is;
-     * Rouzer does not automatically parse a `Response` returned by this hook.
+     * @remarks When provided, the return value is returned from the response
+     * helper as-is; Rouzer does not automatically parse a `Response` returned by
+     * this hook.
      */
-    onJsonError?: (response: Response) => Promisable<Response>;
+    onJsonError?: (response: Response) => Promisable<unknown>;
     /** Custom `fetch` implementation to use for requests. */
     fetch?: typeof globalThis.fetch;
 }): ClientTree<TRoutes, ""> & {
@@ -73,13 +78,17 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
          * ```
          */
         routes?: TRoutes;
+        /** Response codec plugins used by generated action functions. */
+        plugins?: readonly ClientResponsePlugin[];
         /**
-         * Custom handler for non-2xx responses from `.json()`.
+         * Custom handler for non-2xx responses from `.json()` and generated response
+         * helpers.
          *
-         * @remarks When provided, the return value is returned from `.json()` as-is;
-         * Rouzer does not automatically parse a `Response` returned by this hook.
+         * @remarks When provided, the return value is returned from the response
+         * helper as-is; Rouzer does not automatically parse a `Response` returned by
+         * this hook.
          */
-        onJsonError?: (response: Response) => Promisable<Response>;
+        onJsonError?: (response: Response) => Promisable<unknown>;
         /** Custom `fetch` implementation to use for requests. */
         fetch?: typeof globalThis.fetch;
     };
@@ -97,7 +106,11 @@ export type ClientTree<T extends HttpRouteTree, TPrefix extends string = ''> = {
  * Client action function attached for each HTTP action leaf.
  *
  * @remarks Actions whose schema has `response: $type<T>()` return parsed JSON
- * as `T`. Actions without a response marker return the raw `Response`.
+ * as `T`. Actions whose schema has a status-keyed response map return a tuple
+ * union of `[null, value, status]` success entries and `[error, null, status]`
+ * error entries. Actions whose schema has a plugin response marker return the
+ * plugin's client result type. Actions without a response marker return the raw
+ * `Response`.
  */
 export type RouteFunction<T extends RouteSchema, P extends string> = (...p: RouteArgs<T, P> extends infer TArgs ? {} extends TArgs ? [args?: TArgs] : [args: TArgs] : never) => Promise<T extends {
     response: any;

package/dist/client/index.js

@@ -1,6 +1,8 @@
 import { RoutePattern } from '@remix-run/route-pattern';
 import { createHref } from '@remix-run/route-pattern/href';
 import { shake } from '../common.js';
+import { createResponsePluginMap, getResponsePluginMarkerId, } from '../response.js';
+import { getResponseMapPluginIds, isErrorMarker, isResponseMap, } from '../response-map.js';
 /**
  * Create a typed fetch client for an HTTP route tree.
  *
@@ -12,6 +14,10 @@ export function createClient(config) {
     const baseURL = config.baseURL.replace(/\/?$/, '/');
     const defaultHeaders = config.headers && shake(config.headers);
     const fetch = config.fetch ?? globalThis.fetch;
+    const responsePlugins = createResponsePluginMap(config.plugins, 'client response');
+    if (config.routes) {
+        validateClientResponsePlugins(config.routes, responsePlugins);
+    }
     async function request({ path: pathBuilder, method, args, schema, }) {
         let { path, query, body, headers, ...init } = args;
         if (schema.path) {
@@ -58,37 +64,87 @@ export function createClient(config) {
     async function json(props) {
         const response = await request(props);
         if (!response.ok) {
-            if (config.onJsonError) {
-                return config.onJsonError(response);
+            return handleResponseError(response, props);
+        }
+        return response.json();
+    }
+    async function response(props) {
+        const httpResponse = await request(props);
+        const responseSchema = props.schema.response;
+        // Handle status-keyed response maps
+        if (isResponseMap(responseSchema)) {
+            const status = httpResponse.status;
+            if (status in responseSchema) {
+                const marker = responseSchema[status];
+                if (isErrorMarker(marker)) {
+                    return [await httpResponse.json(), null, status];
+                }
+                const pluginId = getResponsePluginMarkerId(marker);
+                if (pluginId) {
+                    const plugin = responsePlugins.get(pluginId);
+                    if (!plugin) {
+                        throw missingClientResponsePlugin(pluginId);
+                    }
+                    return [
+                        null,
+                        await plugin.decode(httpResponse, {
+                            marker: marker,
+                            request: props,
+                        }),
+                        status,
+                    ];
+                }
+                return [null, await httpResponse.json(), status];
             }
-            const error = new Error(`Request to ${props.method} ${createHref(props.path, props.args.path)} failed with status ${response.status}`);
-            const contentType = response.headers.get('content-type');
-            if (contentType?.includes('application/json')) {
-                Object.assign(error, await response.json());
+            // Undeclared status — reject
+            return handleResponseError(httpResponse, props);
+        }
+        if (!httpResponse.ok) {
+            return handleResponseError(httpResponse, props);
+        }
+        const pluginId = getResponsePluginMarkerId(responseSchema);
+        if (pluginId) {
+            const plugin = responsePlugins.get(pluginId);
+            if (!plugin) {
+                throw missingClientResponsePlugin(pluginId);
             }
-            throw error;
+            return plugin.decode(httpResponse, {
+                marker: responseSchema,
+                request: props,
+            });
         }
-        return response.json();
+        return httpResponse.json();
+    }
+    async function handleResponseError(response, props) {
+        if (config.onJsonError) {
+            return config.onJsonError(response);
+        }
+        const error = new Error(`Request to ${props.method} ${createHref(props.path, props.args.path)} failed with status ${response.status}`);
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            Object.assign(error, await response.json());
+        }
+        throw error;
     }
     return {
         ...(config.routes
-            ? connectTree(config.routes, '', request, json)
+            ? connectTree(config.routes, '', request, response)
             : null),
         config,
         request,
         json,
     };
 }
-function connectTree(tree, prefix, request, json) {
+function connectTree(tree, prefix, request, response) {
     return Object.fromEntries(Object.entries(tree).map(([key, node]) => {
         if (node.kind === 'resource') {
             return [
                 key,
-                connectTree(node.children, joinPaths(prefix, node.path.source), request, json),
+                connectTree(node.children, joinPaths(prefix, node.path.source), request, response),
             ];
         }
         const path = RoutePattern.parse(joinPaths(prefix, node.path?.source ?? ''));
-        const fetch = node.schema.response ? json : request;
+        const fetch = node.schema.response ? response : request;
         return [
             key,
             (args = {}) => fetch({
@@ -101,6 +157,26 @@ function connectTree(tree, prefix, request, json) {
         ];
     }));
 }
+function validateClientResponsePlugins(tree, plugins) {
+    for (const node of Object.values(tree)) {
+        if (node.kind === 'resource') {
+            validateClientResponsePlugins(node.children, plugins);
+        }
+        else {
+            const pluginIds = isResponseMap(node.schema.response)
+                ? getResponseMapPluginIds(node.schema.response)
+                : [getResponsePluginMarkerId(node.schema.response)].filter(pluginId => pluginId !== undefined);
+            for (const pluginId of pluginIds) {
+                if (!plugins.has(pluginId)) {
+                    throw missingClientResponsePlugin(pluginId);
+                }
+            }
+        }
+    }
+}
+function missingClientResponsePlugin(pluginId) {
+    return new Error(`Missing client response plugin for ${pluginId}`);
+}
 function joinPaths(left, right) {
     return [left, right].filter(Boolean).join('/').replace(/\/+/g, '/');
 }

package/dist/common.d.ts

@@ -6,9 +6,19 @@ export type Promisable<T> = T | Promise<T>;
  * @remarks Consumers usually use `$type<T>()` instead of constructing this type
  * directly.
  */
-export type Unchecked<T> = {
+export type Unchecked<T> = Record<number, unknown> & {
     __unchecked__: T;
 };
+/**
+ * Compile-time-only marker used by `$error<T>()` to carry a declared error
+ * response type through route declarations.
+ *
+ * @remarks Consumers usually use `$error<T>()` instead of constructing this
+ * type directly.
+ */
+export type UncheckedError<T> = {
+    __uncheckedError__: T;
+};
 /**
  * Map over all the keys to create a new object.
  *

package/dist/http.js

@@ -30,7 +30,9 @@ function deleteAction(pathOrSchema, schema) {
 }
 export { deleteAction as delete };
 function action(method, pathOrSchema, schema) {
-    const path = typeof pathOrSchema === 'string' ? RoutePattern.parse(pathOrSchema) : undefined;
+    const path = typeof pathOrSchema === 'string'
+        ? RoutePattern.parse(pathOrSchema)
+        : undefined;
     schema ??= typeof pathOrSchema === 'string' ? {} : pathOrSchema;
     const request = ((args = {}) => ({
         schema,

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './client/index.js';
+export * from './response.js';
 export * from './type.js';
 export * from './server/router.js';
 export type * from './types/index.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './client/index.js';
+export * from './response.js';
 export * from './type.js';
 export * from './server/router.js';
 export * from 'alien-middleware';

package/dist/ndjson.d.ts

@@ -0,0 +1,54 @@
+import { type ClientResponsePlugin, type ResponsePluginMarker, type RouterResponsePlugin } from './response.js';
+declare const codecId = "rouzer/ndjson";
+/** Values accepted by Rouzer's NDJSON response encoder. */
+export type NdjsonSource<T = unknown> = Iterable<T> | AsyncIterable<T>;
+/**
+ * Create a compile-time marker for newline-delimited JSON response items.
+ *
+ * @remarks The returned marker is handled by `clientPlugin` in clients and
+ * `routerPlugin` in routers. Generated client action functions resolve to an
+ * `AsyncIterable<T>`, while route handlers may return either an `Iterable<T>`
+ * or an `AsyncIterable<T>`. Rouzer does not validate streamed items at runtime.
+ */
+export declare function $type<T>(): ResponsePluginMarker<AsyncIterable<T>, NdjsonSource<T>, typeof codecId>;
+/**
+ * Client plugin that decodes successful NDJSON responses.
+ *
+ * @remarks Register this plugin with `createClient({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers.
+ */
+export declare const clientPlugin: ClientResponsePlugin;
+/**
+ * Router plugin that encodes handler results as NDJSON responses.
+ *
+ * @remarks Register this plugin with `createRouter({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers. Handler or generator
+ * errors are not encoded as NDJSON items; model application-level errors in the
+ * item type when clients should receive them as data.
+ */
+export declare const routerPlugin: RouterResponsePlugin;
+/**
+ * Encode an iterable of values as a newline-delimited JSON byte stream.
+ *
+ * @remarks Each yielded value is serialized with `JSON.stringify` and followed
+ * by `\n`. Values that cannot be represented as a JSON text, such as
+ * `undefined`, cause the stream to error when read.
+ */
+export declare function encodeNdjson(source: NdjsonSource): ReadableStream<Uint8Array>;
+/**
+ * Decode a newline-delimited JSON byte stream.
+ *
+ * @remarks UTF-8 chunks may split JSON lines. Both `\n` and `\r\n` line endings
+ * are accepted, and a final line does not need a trailing newline. Malformed
+ * lines throw a `SyntaxError` that includes the 1-based line number.
+ */
+export declare function decodeNdjson<T = unknown>(stream: ReadableStream<Uint8Array>): AsyncIterable<T>;
+/**
+ * Create a `Response` whose body is encoded as newline-delimited JSON.
+ *
+ * @remarks The response defaults to
+ * `content-type: application/x-ndjson; charset=utf-8` unless the caller supplies
+ * a content type in `init.headers`.
+ */
+export declare function ndjsonResponse<T>(source: NdjsonSource<T>, init?: ResponseInit): Response;
+export {};

package/dist/ndjson.js

@@ -0,0 +1,161 @@
+import { createResponsePluginMarker, } from './response.js';
+const codecId = 'rouzer/ndjson';
+/**
+ * Create a compile-time marker for newline-delimited JSON response items.
+ *
+ * @remarks The returned marker is handled by `clientPlugin` in clients and
+ * `routerPlugin` in routers. Generated client action functions resolve to an
+ * `AsyncIterable<T>`, while route handlers may return either an `Iterable<T>`
+ * or an `AsyncIterable<T>`. Rouzer does not validate streamed items at runtime.
+ */
+export function $type() {
+    return createResponsePluginMarker(codecId);
+}
+/**
+ * Client plugin that decodes successful NDJSON responses.
+ *
+ * @remarks Register this plugin with `createClient({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers.
+ */
+export const clientPlugin = {
+    id: codecId,
+    decode(response) {
+        if (!response.body) {
+            throw new Error('NDJSON response has no body');
+        }
+        return decodeNdjson(response.body);
+    },
+};
+/**
+ * Router plugin that encodes handler results as NDJSON responses.
+ *
+ * @remarks Register this plugin with `createRouter({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers. Handler or generator
+ * errors are not encoded as NDJSON items; model application-level errors in the
+ * item type when clients should receive them as data.
+ */
+export const routerPlugin = {
+    id: codecId,
+    encode(value) {
+        return ndjsonResponse(value);
+    },
+};
+/**
+ * Encode an iterable of values as a newline-delimited JSON byte stream.
+ *
+ * @remarks Each yielded value is serialized with `JSON.stringify` and followed
+ * by `\n`. Values that cannot be represented as a JSON text, such as
+ * `undefined`, cause the stream to error when read.
+ */
+export function encodeNdjson(source) {
+    const iterator = getAsyncIterator(source);
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        async pull(controller) {
+            const { done, value } = await iterator.next();
+            if (done) {
+                controller.close();
+                return;
+            }
+            const line = JSON.stringify(value);
+            if (line === undefined) {
+                throw new TypeError('NDJSON items must serialize to a JSON text; received undefined');
+            }
+            controller.enqueue(encoder.encode(`${line}\n`));
+        },
+        async cancel(reason) {
+            await iterator.return?.(reason);
+        },
+    });
+}
+/**
+ * Decode a newline-delimited JSON byte stream.
+ *
+ * @remarks UTF-8 chunks may split JSON lines. Both `\n` and `\r\n` line endings
+ * are accepted, and a final line does not need a trailing newline. Malformed
+ * lines throw a `SyntaxError` that includes the 1-based line number.
+ */
+export async function* decodeNdjson(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let lineNumber = 0;
+    let doneReading = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                buffer += decoder.decode();
+                doneReading = true;
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                const line = stripCarriageReturn(buffer.slice(0, newlineIndex));
+                buffer = buffer.slice(newlineIndex + 1);
+                lineNumber += 1;
+                yield parseNdjsonLine(line, lineNumber);
+            }
+        }
+        if (buffer.length > 0) {
+            lineNumber += 1;
+            yield parseNdjsonLine(stripCarriageReturn(buffer), lineNumber);
+        }
+    }
+    finally {
+        if (!doneReading) {
+            await reader.cancel().catch(() => { });
+        }
+        reader.releaseLock();
+    }
+}
+/**
+ * Create a `Response` whose body is encoded as newline-delimited JSON.
+ *
+ * @remarks The response defaults to
+ * `content-type: application/x-ndjson; charset=utf-8` unless the caller supplies
+ * a content type in `init.headers`.
+ */
+export function ndjsonResponse(source, init = {}) {
+    const headers = new Headers(init.headers);
+    if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/x-ndjson; charset=utf-8');
+    }
+    return new Response(encodeNdjson(source), {
+        ...init,
+        headers,
+    });
+}
+function getAsyncIterator(source) {
+    const asyncIterator = source[Symbol.asyncIterator]?.();
+    if (asyncIterator) {
+        return asyncIterator;
+    }
+    const iterator = source[Symbol.iterator]?.();
+    if (iterator) {
+        return {
+            next() {
+                return Promise.resolve(iterator.next());
+            },
+            async return() {
+                iterator.return?.();
+                return { done: true, value: undefined };
+            },
+        };
+    }
+    throw new TypeError('NDJSON source must be iterable');
+}
+function stripCarriageReturn(line) {
+    return line.endsWith('\r') ? line.slice(0, -1) : line;
+}
+function parseNdjsonLine(line, lineNumber) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (cause) {
+        const error = new SyntaxError(`Invalid NDJSON at line ${lineNumber}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        error.cause = cause;
+        throw error;
+    }
+}

package/dist/response-map.d.ts

@@ -0,0 +1,10 @@
+import type { RouteResponseMap, RouteSchema } from './types/schema.js';
+/** Return true when the response schema is a status-keyed response map. */
+export declare function isResponseMap(response: RouteSchema['response']): response is RouteResponseMap;
+/** Return true when the marker represents a declared error response. */
+export declare function isErrorMarker(marker: unknown): boolean;
+/** Return true when the marker represents a success response. */
+export declare function isSuccessMarker(marker: unknown): boolean;
+/** Find the default success status for a direct handler result. */
+export declare function getResponseMapPluginIds(responseMap: RouteResponseMap): string[];
+export declare function getDefaultSuccessStatus(responseMap: RouteResponseMap): number;

package/dist/response-map.js

@@ -0,0 +1,32 @@
+import { getResponsePluginMarkerId, responsePluginMarker, } from './response.js';
+import { $error } from './type.js';
+/** Return true when the response schema is a status-keyed response map. */
+export function isResponseMap(response) {
+    return (typeof response === 'object' &&
+        response !== null &&
+        !(responsePluginMarker in response));
+}
+/** Return true when the marker represents a declared error response. */
+export function isErrorMarker(marker) {
+    return marker === $error.symbol;
+}
+/** Return true when the marker represents a success response. */
+export function isSuccessMarker(marker) {
+    return marker !== undefined && !isErrorMarker(marker);
+}
+/** Find the default success status for a direct handler result. */
+export function getResponseMapPluginIds(responseMap) {
+    return Object.values(responseMap).flatMap(marker => {
+        const pluginId = getResponsePluginMarkerId(marker);
+        return pluginId ? [pluginId] : [];
+    });
+}
+export function getDefaultSuccessStatus(responseMap) {
+    for (const key of Object.keys(responseMap)) {
+        const marker = responseMap[Number(key)];
+        if (isSuccessMarker(marker)) {
+            return Number(key);
+        }
+    }
+    return 200;
+}