@openstax/ts-utils 1.34.0 → 1.35.0

package/dist/esm/errors/index.d.ts

@@ -0,0 +1,88 @@
+import type { JsonCompatibleStruct } from '../routing';
+/**
+ * Returns true if the error is defined in this library
+ */
+export declare const isAppError: (e: any) => e is Error & {
+    constructor: {
+        TYPE: string;
+    };
+};
+/**
+ * Invalid request error
+ *
+ * `InvalidRequestError.matches(error)` is a reliable way to check if an error is an
+ * `InvalidRequestError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class InvalidRequestError extends Error {
+    static readonly TYPE = "InvalidRequestError";
+    static matches: (e: any) => e is typeof InvalidRequestError;
+    constructor(message?: string);
+}
+/**
+ * Validation Error
+ *
+ * `ValidationError.matches(error)` is a reliable way to check if an error is an
+ * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class ValidationError extends Error {
+    static readonly TYPE = "ValidationError";
+    static matches: (e: any) => e is typeof ValidationError;
+    private data;
+    constructor(data: JsonCompatibleStruct);
+    getData(): JsonCompatibleStruct;
+}
+/**
+ * Unauthorized error
+ *
+ * `UnauthorizedError.matches(error)` is a reliable way to check if an error is an
+ * `UnauthorizedError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class UnauthorizedError extends Error {
+    static readonly TYPE = "UnauthorizedError";
+    static matches: (e: any) => e is typeof UnauthorizedError;
+    constructor(message?: string);
+}
+/**
+ * Forbidden error
+ *
+ * `ForbiddenError.matches(error)` is a reliable way to check if an error is a
+ * `ForbiddenError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class ForbiddenError extends Error {
+    static readonly TYPE = "ForbiddenError";
+    static matches: (e: any) => e is typeof ForbiddenError;
+    constructor(message?: string);
+}
+/**
+ * Not found error
+ *
+ * `NotFoundError.matches(error)` is a reliable way to check if an error is a
+ * `NotFoundError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class NotFoundError extends Error {
+    static readonly TYPE = "NotFoundError";
+    static matches: (e: any) => e is typeof NotFoundError;
+    constructor(message?: string);
+}
+/**
+ * Session expired error
+ *
+ * `SessionExpiredError.matches(error)` is a reliable way to check if an error is a
+ * `SessionExpiredError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class SessionExpiredError extends Error {
+    static readonly TYPE = "SessionExpiredError";
+    static matches: (e: any) => e is typeof SessionExpiredError;
+    constructor(message?: string);
+}
+/**
+ * Conflict error
+ *
+ * `ConflictError.matches(error)` is a reliable way to check if an error is a
+ * `ConflictError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class ConflictError extends Error {
+    static readonly TYPE = "ConflictError";
+    static matches: (e: any) => e is typeof ConflictError;
+    constructor(message?: string);
+}

package/{packages/utils/src/errors/index.ts → dist/esm/errors/index.js}

@@ -1,5 +1,3 @@
-import type { JsonCompatibleStruct } from '../routing';
-
 /*
  * if code is split into multiple bundles, sometimes each bundle
  * will get its own definition of this module and then instanceof checks
@@ -12,17 +10,13 @@ import type { JsonCompatibleStruct } from '../routing';
  *   error instanceof InvalidRequestError
  *
  */
-const errorIsType = <T extends {TYPE: string}>(t: T) => (e: any): e is T =>
-  e instanceof Error
-  && (e as any).constructor.TYPE === t.TYPE;
-
+const errorIsType = (t) => (e) => e instanceof Error
+    && e.constructor.TYPE === t.TYPE;
 /**
  * Returns true if the error is defined in this library
  */
-export const isAppError = (e: any): e is Error & {constructor: {TYPE: string}} =>
-  e instanceof Error
-  && typeof (e as any).constructor.TYPE === 'string';
-
+export const isAppError = (e) => e instanceof Error
+    && typeof e.constructor.TYPE === 'string';
 /**
  * Invalid request error
  *
@@ -30,13 +24,12 @@ export const isAppError = (e: any): e is Error & {constructor: {TYPE: string}} =
  * `InvalidRequestError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class InvalidRequestError extends Error {
-  static readonly TYPE = 'InvalidRequestError';
-  static matches = errorIsType(InvalidRequestError);
-  constructor(message?: string) {
-    super(message || InvalidRequestError.TYPE);
-  }
+    constructor(message) {
+        super(message || InvalidRequestError.TYPE);
+    }
 }
-
+InvalidRequestError.TYPE = 'InvalidRequestError';
+InvalidRequestError.matches = errorIsType(InvalidRequestError);
 /**
  * Validation Error
  *
@@ -44,19 +37,14 @@ export class InvalidRequestError extends Error {
  * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class ValidationError extends Error {
-  static readonly TYPE = 'ValidationError';
-  static matches = errorIsType(ValidationError);
-
-  private data: JsonCompatibleStruct;
-  constructor(data: JsonCompatibleStruct) {
-    super(InvalidRequestError.TYPE);
-
-    this.data = data;
-  }
-
-  getData() { return this.data; }
+    constructor(data) {
+        super(InvalidRequestError.TYPE);
+        this.data = data;
+    }
+    getData() { return this.data; }
 }
-
+ValidationError.TYPE = 'ValidationError';
+ValidationError.matches = errorIsType(ValidationError);
 /**
  * Unauthorized error
  *
@@ -64,13 +52,12 @@ export class ValidationError extends Error {
  * `UnauthorizedError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class UnauthorizedError extends Error {
-  static readonly TYPE = 'UnauthorizedError';
-  static matches = errorIsType(UnauthorizedError);
-  constructor(message?: string) {
-    super(message || UnauthorizedError.TYPE);
-  }
+    constructor(message) {
+        super(message || UnauthorizedError.TYPE);
+    }
 }
-
+UnauthorizedError.TYPE = 'UnauthorizedError';
+UnauthorizedError.matches = errorIsType(UnauthorizedError);
 /**
  * Forbidden error
  *
@@ -78,13 +65,12 @@ export class UnauthorizedError extends Error {
  * `ForbiddenError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class ForbiddenError extends Error {
-  static readonly TYPE = 'ForbiddenError';
-  static matches = errorIsType(ForbiddenError);
-  constructor(message?: string) {
-    super(message || ForbiddenError.TYPE);
-  }
+    constructor(message) {
+        super(message || ForbiddenError.TYPE);
+    }
 }
-
+ForbiddenError.TYPE = 'ForbiddenError';
+ForbiddenError.matches = errorIsType(ForbiddenError);
 /**
  * Not found error
  *
@@ -92,13 +78,12 @@ export class ForbiddenError extends Error {
  * `NotFoundError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class NotFoundError extends Error {
-  static readonly TYPE = 'NotFoundError';
-  static matches = errorIsType(NotFoundError);
-  constructor(message?: string) {
-    super(message || NotFoundError.TYPE);
-  }
+    constructor(message) {
+        super(message || NotFoundError.TYPE);
+    }
 }
-
+NotFoundError.TYPE = 'NotFoundError';
+NotFoundError.matches = errorIsType(NotFoundError);
 /**
  * Session expired error
  *
@@ -106,13 +91,12 @@ export class NotFoundError extends Error {
  * `SessionExpiredError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class SessionExpiredError extends Error {
-  static readonly TYPE = 'SessionExpiredError';
-  static matches = errorIsType(SessionExpiredError);
-  constructor(message?: string) {
-    super(message || SessionExpiredError.TYPE);
-  }
+    constructor(message) {
+        super(message || SessionExpiredError.TYPE);
+    }
 }
-
+SessionExpiredError.TYPE = 'SessionExpiredError';
+SessionExpiredError.matches = errorIsType(SessionExpiredError);
 /**
  * Conflict error
  *
@@ -120,9 +104,9 @@ export class SessionExpiredError extends Error {
  * `ConflictError`; `instanceof` checks may not work if code is split into multiple bundles
  */
 export class ConflictError extends Error {
-  static readonly TYPE = 'ConflictError';
-  static matches = errorIsType(ConflictError);
-  constructor(message?: string) {
-    super(message || ConflictError.TYPE);
-  }
+    constructor(message) {
+        super(message || ConflictError.TYPE);
+    }
 }
+ConflictError.TYPE = 'ConflictError';
+ConflictError.matches = errorIsType(ConflictError);

package/dist/esm/fetch/fetchStatusRetry.d.ts

@@ -0,0 +1,8 @@
+import { RetryOptions } from '../misc/helpers';
+import { GenericFetch } from '.';
+interface Options extends RetryOptions {
+    status?: number[];
+    timeout?: number;
+}
+export declare const fetchStatusRetry: (base: GenericFetch, options: Options) => GenericFetch;
+export {};

package/dist/esm/fetch/fetchStatusRetry.js

@@ -0,0 +1,23 @@
+import { retryWithDelay } from '../misc/helpers';
+export const fetchStatusRetry = (base, options) => {
+    return (...params) => retryWithDelay(() => {
+        const fetchPromise = base(...params).then(r => {
+            var _a;
+            if ((_a = options.status) === null || _a === void 0 ? void 0 : _a.includes(r.status)) {
+                return r.text().then(text => {
+                    throw new Error(`fetch failed ${params[0]} -- ${r.status}: ${text}`);
+                });
+            }
+            return r;
+        });
+        if (options.timeout) {
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error(`fetch timeout after ${options.timeout}ms: ${params[0]}`));
+                }, options.timeout);
+            });
+            return Promise.race([fetchPromise, timeoutPromise]);
+        }
+        return fetchPromise;
+    }, options);
+};

package/dist/esm/fetch/index.d.ts

@@ -0,0 +1,64 @@
+import { METHOD } from '../routing';
+export declare enum FetchStateType {
+    SUCCESS = "success",
+    ERROR = "error",
+    LOADING = "loading",
+    IDLE = "idle"
+}
+export type FetchState<D, E> = FetchStateLoading<D> | FetchStateError<D, E> | FetchStateSuccess<D> | FetchStateIdle;
+type FetchStateLoading<D> = {
+    type: FetchStateType.LOADING;
+    data?: D;
+};
+type FetchStateError<D, E> = {
+    type: FetchStateType.ERROR;
+    data?: D;
+    error: E;
+};
+type FetchStateSuccess<D> = {
+    type: FetchStateType.SUCCESS;
+    data: D;
+};
+type FetchStateIdle = {
+    type: FetchStateType.IDLE;
+};
+export declare const fetchLoading: <D, E>(previous?: FetchState<D, E>) => FetchStateLoading<D>;
+export declare const fetchError: <D, E>(error: E, previous?: FetchState<D, E>) => FetchStateError<D, E>;
+export declare const fetchSuccess: <D>(data: D) => FetchStateSuccess<D>;
+export declare const fetchIdle: () => FetchStateIdle;
+export declare const stateHasData: <D, E>(state: {
+    type: FetchStateType;
+    data?: D;
+    error?: E;
+}) => state is {
+    type: FetchStateType;
+    data: D;
+};
+export declare const stateHasError: <D, E>(state: {
+    type: FetchStateType;
+    data?: D;
+    error?: E;
+}) => state is {
+    type: FetchStateType;
+    error: E;
+};
+export type FetchConfig = {
+    credentials?: 'include' | 'omit' | 'same-origin';
+    method?: METHOD;
+    body?: string;
+    headers?: {
+        [key: string]: string;
+    };
+};
+type Headers = {
+    get: (name: string) => string | null;
+};
+export type Response = {
+    status: number;
+    headers: Headers;
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+};
+export type GenericFetch<C extends FetchConfig = FetchConfig, R extends Response = Response> = (url: string, fetchConfig?: C) => Promise<R>;
+export type ConfigForFetch<F> = F extends GenericFetch<infer C, any> ? C : never;
+export {};

package/dist/esm/fetch/index.js

@@ -0,0 +1,46 @@
+/*
+ * these are just helpers for formatting responses, they don't actually do any loading. especially in UI development they
+ * help with continuity over loading, reloading, saving, and errors. this is pretty nice in typescript because you have to deal
+ * with the possibility that the result state is in a loading or error state. if you avoid dealing with those states you need
+ * to write very clear code to ignore them, which easily presents missing functionality like errors that are not being messaged
+ * to the user.
+ * */
+export var FetchStateType;
+(function (FetchStateType) {
+    FetchStateType["SUCCESS"] = "success";
+    FetchStateType["ERROR"] = "error";
+    FetchStateType["LOADING"] = "loading";
+    FetchStateType["IDLE"] = "idle";
+})(FetchStateType || (FetchStateType = {}));
+/*
+ * keeps existing data but sets the new status
+ *
+ * const state = fetchLoading(previousState)
+ * */
+export const fetchLoading = (previous) => ({ type: FetchStateType.LOADING, ...(previous && 'data' in previous ? { data: previous.data } : {}) });
+/*
+ * keeps existing data but sets the new status and error value
+ *
+ * const state = fetchError(error, previousState)
+ * */
+export const fetchError = (error, previous) => ({ ...previous, type: FetchStateType.ERROR, error });
+/*
+ * formats data with success type
+ *
+ * const state = fetchSuccess(newData)
+ * */
+export const fetchSuccess = (data) => ({ type: FetchStateType.SUCCESS, data });
+/*
+ * formats data with idle type
+ *
+ * const state = fetchIdle(newData)
+ * */
+export const fetchIdle = () => ({ type: FetchStateType.IDLE });
+/*
+ * guard for checking if the state has result data, it might be true for any state type.
+ * */
+export const stateHasData = (state) => 'data' in state;
+/*
+ * guard for checking if the state has an error, it might be true for error or loading states.
+ * */
+export const stateHasError = (state) => 'error' in state;

package/dist/esm/guards/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * checks if a thing is defined. while often easy to do with a simple if statement, in certain
+ * situations the guard is required and its nice to have one pre-defined. E.g. in the following
+ * example, the result is `Array<string>`.
+ *
+ * `const result = (array as Array<string | undefined>).filter(isDefined);`
+ */
+export declare const isDefined: <X>(x: X) => x is Exclude<X, undefined>;
+/**
+ * checks if a thing is not null. while often easy to do with a simple if statement,
+ * in certain situations the guard is required and its nice to have one pre-defined.
+ * E.g. in the following example, the result is `Array<string>`.
+ *
+ * `const result = (array as Array<string | null>).filter(isNotNull);`
+ */
+export declare const isNotNull: <X>(x: X) => x is Exclude<X, null>;
+/**
+ * checks if a thing is a number. while often easy to do with a simple if statement, in certain
+ * situations the guard is required and its nice to have one pre-defined. E.g. in the following
+ * example, the result is `Array<number>`.
+ *
+ * `const result = (array as Array<number | undefined>).filter(isNumber);`
+ */
+export declare const isNumber: (x: any) => x is number;
+/**
+ * a guard for plain old javascript objects that are not based on some other prototype,
+ * for example making them safe to JSON stringify and stuff
+ */
+export declare const isPlainObject: (thing: any) => thing is {
+    [key: string]: any;
+};
+/**
+ * if the first thing is defined it uses it, otherwise it returns the second thing. this isn't
+ * really a guard its just a way to provide a default value without creating a coverage branch.
+ *
+ * @example const valueWithDefault = ifDefined(thing, 'default value')
+ */
+export declare const ifDefined: <X, D>(x: X, d: D) => D | Exclude<X, undefined>;

package/dist/esm/guards/index.js

@@ -0,0 +1,36 @@
+/**
+ * checks if a thing is defined. while often easy to do with a simple if statement, in certain
+ * situations the guard is required and its nice to have one pre-defined. E.g. in the following
+ * example, the result is `Array<string>`.
+ *
+ * `const result = (array as Array<string | undefined>).filter(isDefined);`
+ */
+export const isDefined = (x) => x !== undefined;
+/**
+ * checks if a thing is not null. while often easy to do with a simple if statement,
+ * in certain situations the guard is required and its nice to have one pre-defined.
+ * E.g. in the following example, the result is `Array<string>`.
+ *
+ * `const result = (array as Array<string | null>).filter(isNotNull);`
+ */
+export const isNotNull = (x) => x !== null;
+/**
+ * checks if a thing is a number. while often easy to do with a simple if statement, in certain
+ * situations the guard is required and its nice to have one pre-defined. E.g. in the following
+ * example, the result is `Array<number>`.
+ *
+ * `const result = (array as Array<number | undefined>).filter(isNumber);`
+ */
+export const isNumber = (x) => typeof x === 'number';
+/**
+ * a guard for plain old javascript objects that are not based on some other prototype,
+ * for example making them safe to JSON stringify and stuff
+ */
+export const isPlainObject = (thing) => thing instanceof Object && thing.__proto__.constructor.name === 'Object';
+/**
+ * if the first thing is defined it uses it, otherwise it returns the second thing. this isn't
+ * really a guard its just a way to provide a default value without creating a coverage branch.
+ *
+ * @example const valueWithDefault = ifDefined(thing, 'default value')
+ */
+export const ifDefined = (x, d) => isDefined(x) ? x : d;

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './misc/partitionSequence';
+export * from './misc/helpers';
+export * from './misc/merge';
+export * from './misc/hashValue';

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from './misc/partitionSequence';
+export * from './misc/helpers';
+export * from './misc/merge';
+export * from './misc/hashValue';

package/dist/esm/middleware/apiErrorHandler.d.ts

@@ -0,0 +1,24 @@
+import { ForbiddenError, InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
+import type { ApiResponse } from '../routing';
+import type { Logger } from '../services/logger';
+export type DefaultErrors = {
+    InvalidRequestError: InvalidRequestError;
+    UnauthorizedError: UnauthorizedError;
+    ForbiddenError: ForbiddenError;
+    NotFoundError: NotFoundError;
+    ValidationError: ValidationError;
+    SessionExpiredError: SessionExpiredError;
+};
+export type Handlers<E> = {
+    [T in keyof E]?: (e: E[T], logger: Logger) => ApiResponse<number, any>;
+};
+export declare const defaultHandlers: Handlers<DefaultErrors>;
+/**
+ * Creates an error handler. Provides default handlers for `UnauthorizedError`,
+ * `SessionExpiredError`, `NotFoundError`, and `InvalidRequestError`. User-specified
+ * handlers can be added to these. If no handler is found, the error is logged and
+ * a 500 text response is returned.
+ *
+ * @param inputHandlers a map of errors to handler functions
+ */
+export declare const createErrorHandler: <Errors = DefaultErrors>(inputHandlers?: Handlers<Errors>) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;

package/dist/esm/middleware/apiErrorHandler.js

@@ -0,0 +1,38 @@
+import { isAppError, } from '../errors';
+import { apiJsonResponse, apiTextResponse } from '../routing';
+import { Level } from '../services/logger';
+export const defaultHandlers = {
+    InvalidRequestError: (e) => apiTextResponse(400, `400 ${e.message}`),
+    UnauthorizedError: (e) => apiTextResponse(401, `401 ${e.message}`),
+    ForbiddenError: (e) => apiTextResponse(403, `403 ${e.message}`),
+    NotFoundError: (e) => apiTextResponse(404, `404 ${e.message}`),
+    ValidationError: (e) => apiJsonResponse(422, e.getData()),
+    SessionExpiredError: (e) => apiTextResponse(440, `440 ${e.message}`),
+};
+/**
+ * Creates an error handler. Provides default handlers for `UnauthorizedError`,
+ * `SessionExpiredError`, `NotFoundError`, and `InvalidRequestError`. User-specified
+ * handlers can be added to these. If no handler is found, the error is logged and
+ * a 500 text response is returned.
+ *
+ * @param inputHandlers a map of errors to handler functions
+ */
+export const createErrorHandler = (inputHandlers) => {
+    const handlers = { ...defaultHandlers, ...inputHandlers };
+    return async (e, logger) => {
+        const name = isAppError(e) ? e.constructor.TYPE : e.constructor.name;
+        const handler = handlers[name];
+        const logLevel = handler ? Level.Info : Level.Error;
+        logger.logEvent(logLevel, {
+            name: e.name,
+            message: e.message,
+            stack: e.stack,
+        });
+        if (handler) {
+            // convincing typescript that this error is the right kind for the handler
+            // we looked up based on the errors name is very annoying
+            return handler(e, logger);
+        }
+        return apiTextResponse(500, '500 Error');
+    };
+};

package/dist/esm/middleware/apiSlowResponseMiddleware.d.ts

@@ -0,0 +1,23 @@
+import type { ConfigProviderForConfig } from '../config';
+import type { ApiResponse } from '../routing';
+import type { Logger } from '../services/logger';
+type Config = {
+    logResponseSlowerThan: string;
+    timeoutResponseAfter: string;
+};
+/**
+ * Creates response middleware that logs slow responses and times out responses that take too long. lambda functions have a timeout setting, but when a lambda times out there is no way to log anything helpful before it exists. this middleware allows the logger context to show up for timeout requests. just make sure that the `timeoutResponseAfter` is set to something slightly shorter than the lambda timeout so that it has time to run.
+ *
+ * @param config
+ * @param config.logResponseSlowerThan the config that specifies the threshold for a slow response
+ * @param config.timeoutResponseAfter the config that specifies the timeout for a response
+ * @example
+ * createSlowResponseMiddleware({
+ *   logResponseSlowerThan: envConfig('LOG_SLOW_RESPONSE', 'runtime', '1000'),
+ *   timeoutResponseAfter: envConfig('RESPONSE_TIMEOUT', 'runtime', '28000'),
+ * });
+ */
+export declare const createSlowResponseMiddleware: (config: ConfigProviderForConfig<Config>) => () => (response: Promise<ApiResponse<number, any>> | undefined, { logger }: {
+    logger: Logger;
+}) => Promise<ApiResponse<number, string>> | undefined;
+export {};

package/dist/esm/middleware/apiSlowResponseMiddleware.js

@@ -0,0 +1,50 @@
+import { resolveConfigValue } from '../config/resolveConfigValue';
+import { once } from '../misc/helpers';
+import { apiTextResponse } from '../routing';
+import { Level } from '../services/logger';
+/**
+ * Creates response middleware that logs slow responses and times out responses that take too long. lambda functions have a timeout setting, but when a lambda times out there is no way to log anything helpful before it exists. this middleware allows the logger context to show up for timeout requests. just make sure that the `timeoutResponseAfter` is set to something slightly shorter than the lambda timeout so that it has time to run.
+ *
+ * @param config
+ * @param config.logResponseSlowerThan the config that specifies the threshold for a slow response
+ * @param config.timeoutResponseAfter the config that specifies the timeout for a response
+ * @example
+ * createSlowResponseMiddleware({
+ *   logResponseSlowerThan: envConfig('LOG_SLOW_RESPONSE', 'runtime', '1000'),
+ *   timeoutResponseAfter: envConfig('RESPONSE_TIMEOUT', 'runtime', '28000'),
+ * });
+ */
+export const createSlowResponseMiddleware = (config) => {
+    const getSlowThreshold = once(() => resolveConfigValue(config.logResponseSlowerThan).then(result => parseInt(result, 10)));
+    const getTimeoutAfter = once(() => resolveConfigValue(config.timeoutResponseAfter).then(result => parseInt(result, 10)));
+    return () => (response, { logger }) => {
+        const start = Date.now();
+        if (!response) {
+            return response;
+        }
+        return Promise.all([getSlowThreshold(), getTimeoutAfter()]).then(([slowThreshold, timeoutAfter]) => {
+            let timeout = undefined;
+            const timeoutPromise = isNaN(timeoutAfter)
+                ? undefined
+                : new Promise(resolve => timeout = setTimeout(() => {
+                    logger.logEvent(Level.Error, {
+                        message: 'request processing timed out',
+                    });
+                    resolve(apiTextResponse(504, '504 Gateway Timeout'));
+                }, timeoutAfter));
+            const requestPromise = response.finally(() => {
+                const time = Date.now() - start;
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                }
+                if (time > slowThreshold) {
+                    logger.logEvent(Level.Warn, {
+                        message: 'slow response',
+                        time,
+                    });
+                }
+            });
+            return timeoutPromise ? Promise.race([timeoutPromise, requestPromise]) : requestPromise;
+        });
+    };
+};