@openstax/ts-utils 1.34.0 → 1.35.0

package/dist/cjs/config/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stubConfig = void 0;
+__exportStar(require("./resolveConfigValue"), exports);
+/*
+ * ===========
+ * re-usable config providers
+ * ===========
+ * */
+/**
+ * stub, mostly for testing. sometimes it helps please typescript to use this if you have
+ * two configs you want to have the same type but one is a fixed string and one is a complicated provider
+ *
+ * @example const config = { configValue: stubConfig('just-a-string') };
+ */
+const stubConfig = (configValue) => configValue;
+exports.stubConfig = stubConfig;
+__exportStar(require("./envConfig"), exports);
+__exportStar(require("./replaceConfig"), exports);
+__exportStar(require("./awsParameterConfig"), exports);
+__exportStar(require("./lambdaParameterConfig"), exports);

package/dist/cjs/config/lambdaParameterConfig.d.ts

@@ -0,0 +1,12 @@
+import { ConfigValueProvider } from '.';
+/**
+ * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
+ * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
+ * This extension has built-in caching for requested parameters.
+ *
+ * @param parameterName the name of the parameter; can be a literal name (string) or can itself
+ * be accessed via another parameter by giving a configuration value provider.
+ * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
+export declare const lambdaParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/cjs/config/lambdaParameterConfig.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lambdaParameterConfig = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const assertions_1 = require("../assertions");
+const helpers_1 = require("../misc/helpers");
+const envConfig_1 = require("./envConfig");
+const _1 = require(".");
+const lambdaExtensionUrl = 'http://localhost:2773';
+let lambdaExtensionReadyPromise;
+/**
+ * Returns a value from the AWS Parameter Store. Can only be used during in AWS Lambda, and
+ * requires that the AWS Parameters and Secrets Lambda Extension Layer be included in the Lambda.
+ * This extension has built-in caching for requested parameters.
+ *
+ * @param parameterName the name of the parameter; can be a literal name (string) or can itself
+ * be accessed via another parameter by giving a configuration value provider.
+ * @example const someValue = resolveConfig(lambdaParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
+const lambdaParameterConfig = (parameterName) => async () => {
+    const token = await (0, _1.resolveConfigValue)((0, envConfig_1.envConfig)('AWS_SESSION_TOKEN', 'runtime'));
+    const name = await (0, _1.resolveConfigValue)(parameterName);
+    if (!lambdaExtensionReadyPromise) {
+        // This request will return 400 Bad Request,
+        // but we only care that it'll block until the extension is ready
+        lambdaExtensionReadyPromise = (0, helpers_1.retryWithDelay)(() => (0, node_fetch_1.default)(lambdaExtensionUrl));
+    }
+    await lambdaExtensionReadyPromise;
+    const resp = await (0, helpers_1.retryWithDelay)(() => (0, node_fetch_1.default)(
+    // Port 2773 is the default port for the extension
+    `${lambdaExtensionUrl}/systemsmanager/parameters/get?name=${name}&withDecryption=true`, { headers: { 'X-Aws-Parameters-Secrets-Token': token } }));
+    if (resp.ok) {
+        const response = await resp.json();
+        const parameter = (0, assertions_1.assertDefined)(response.Parameter, `aws GetParameter response missing Parameter key for ${name}"`);
+        return (0, assertions_1.assertDefined)(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${name}"`);
+    }
+    else {
+        throw new Error(`HTTP Error Response ${resp.status} ${resp.statusText} while fetching parameter ${name}`);
+    }
+};
+exports.lambdaParameterConfig = lambdaParameterConfig;

package/dist/cjs/config/replaceConfig.d.ts

@@ -0,0 +1,14 @@
+import { ConfigValueProvider } from '.';
+/**
+ * Substitutes configuration values into a provided string.
+ * Performs a string substitution using configuration values
+ * @param base The string into which substitutions will be made; contains tokens that are
+ * referenced in the `replacements` argument.
+ * @param replacements A map of tokens to configuration value providers. The providers are
+ * resolved and the values are substituted into the `base` string, replacing the tokens.
+ * @example replaceConfig('https://[host]', { '[host]': envConfig('HOST') })
+ * @returns the string after substitution is complete
+ */
+export declare const replaceConfig: (base: ConfigValueProvider<string>, replacements: {
+    [token: string]: ConfigValueProvider<string>;
+}) => ConfigValueProvider<string>;

package/dist/cjs/config/replaceConfig.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceConfig = void 0;
+const resolveConfigValue_1 = require("./resolveConfigValue");
+/**
+ * Substitutes configuration values into a provided string.
+ * Performs a string substitution using configuration values
+ * @param base The string into which substitutions will be made; contains tokens that are
+ * referenced in the `replacements` argument.
+ * @param replacements A map of tokens to configuration value providers. The providers are
+ * resolved and the values are substituted into the `base` string, replacing the tokens.
+ * @example replaceConfig('https://[host]', { '[host]': envConfig('HOST') })
+ * @returns the string after substitution is complete
+ */
+const replaceConfig = (base, replacements) => {
+    return async () => {
+        const resolved = await Promise.all(Object.entries(replacements)
+            .map(async ([token, replacement]) => [token, await (0, resolveConfigValue_1.resolveConfigValue)(replacement)]));
+        return resolved.reduce((result, [token, replacement]) => result.replace(token, replacement), await (0, resolveConfigValue_1.resolveConfigValue)(base));
+    };
+};
+exports.replaceConfig = replaceConfig;

package/dist/cjs/config/resolveConfigValue.d.ts

@@ -0,0 +1,5 @@
+import type { ConfigValue, ConfigValueProvider } from '.';
+/**
+ * resolves a config value into a string, to be used inside of things that are provided configurations
+ */
+export declare const resolveConfigValue: <V extends ConfigValue>(provider: ConfigValueProvider<V>) => Promise<V>;

package/dist/cjs/config/resolveConfigValue.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigValue = void 0;
+/**
+ * resolves a config value into a string, to be used inside of things that are provided configurations
+ */
+const resolveConfigValue = async (provider) => {
+    return typeof provider === 'function'
+        ? await provider()
+        : provider;
+};
+exports.resolveConfigValue = resolveConfigValue;

package/dist/cjs/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/dist/cjs/errors/index.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = exports.SessionExpiredError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ValidationError = exports.InvalidRequestError = exports.isAppError = void 0;
+/*
+ * if code is split into multiple bundles, sometimes each bundle
+ * will get its own definition of this module and then instanceof checks
+ * are unreliable, this provides a way to reliably check the error types
+ *
+ * eg this will always work:
+ *   InvalidRequestError.matches(error);
+ *
+ * eg this might not work if you have code splitting:
+ *   error instanceof InvalidRequestError
+ *
+ */
+const errorIsType = (t) => (e) => e instanceof Error
+    && e.constructor.TYPE === t.TYPE;
+/**
+ * Returns true if the error is defined in this library
+ */
+const isAppError = (e) => e instanceof Error
+    && typeof e.constructor.TYPE === 'string';
+exports.isAppError = isAppError;
+/**
+ * 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
+ */
+class InvalidRequestError extends Error {
+    constructor(message) {
+        super(message || InvalidRequestError.TYPE);
+    }
+}
+exports.InvalidRequestError = InvalidRequestError;
+InvalidRequestError.TYPE = 'InvalidRequestError';
+InvalidRequestError.matches = errorIsType(InvalidRequestError);
+/**
+ * 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
+ */
+class ValidationError extends Error {
+    constructor(data) {
+        super(InvalidRequestError.TYPE);
+        this.data = data;
+    }
+    getData() { return this.data; }
+}
+exports.ValidationError = ValidationError;
+ValidationError.TYPE = 'ValidationError';
+ValidationError.matches = errorIsType(ValidationError);
+/**
+ * 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
+ */
+class UnauthorizedError extends Error {
+    constructor(message) {
+        super(message || UnauthorizedError.TYPE);
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+UnauthorizedError.TYPE = 'UnauthorizedError';
+UnauthorizedError.matches = errorIsType(UnauthorizedError);
+/**
+ * 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
+ */
+class ForbiddenError extends Error {
+    constructor(message) {
+        super(message || ForbiddenError.TYPE);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+ForbiddenError.TYPE = 'ForbiddenError';
+ForbiddenError.matches = errorIsType(ForbiddenError);
+/**
+ * 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
+ */
+class NotFoundError extends Error {
+    constructor(message) {
+        super(message || NotFoundError.TYPE);
+    }
+}
+exports.NotFoundError = NotFoundError;
+NotFoundError.TYPE = 'NotFoundError';
+NotFoundError.matches = errorIsType(NotFoundError);
+/**
+ * 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
+ */
+class SessionExpiredError extends Error {
+    constructor(message) {
+        super(message || SessionExpiredError.TYPE);
+    }
+}
+exports.SessionExpiredError = SessionExpiredError;
+SessionExpiredError.TYPE = 'SessionExpiredError';
+SessionExpiredError.matches = errorIsType(SessionExpiredError);
+/**
+ * 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
+ */
+class ConflictError extends Error {
+    constructor(message) {
+        super(message || ConflictError.TYPE);
+    }
+}
+exports.ConflictError = ConflictError;
+ConflictError.TYPE = 'ConflictError';
+ConflictError.matches = errorIsType(ConflictError);

package/dist/cjs/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/cjs/fetch/fetchStatusRetry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchStatusRetry = void 0;
+const helpers_1 = require("../misc/helpers");
+const fetchStatusRetry = (base, options) => {
+    return (...params) => (0, helpers_1.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);
+};
+exports.fetchStatusRetry = fetchStatusRetry;

package/dist/cjs/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/cjs/fetch/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateHasError = exports.stateHasData = exports.fetchIdle = exports.fetchSuccess = exports.fetchError = exports.fetchLoading = exports.FetchStateType = void 0;
+/*
+ * 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.
+ * */
+var FetchStateType;
+(function (FetchStateType) {
+    FetchStateType["SUCCESS"] = "success";
+    FetchStateType["ERROR"] = "error";
+    FetchStateType["LOADING"] = "loading";
+    FetchStateType["IDLE"] = "idle";
+})(FetchStateType || (exports.FetchStateType = FetchStateType = {}));
+/*
+ * keeps existing data but sets the new status
+ *
+ * const state = fetchLoading(previousState)
+ * */
+const fetchLoading = (previous) => ({ type: FetchStateType.LOADING, ...(previous && 'data' in previous ? { data: previous.data } : {}) });
+exports.fetchLoading = fetchLoading;
+/*
+ * keeps existing data but sets the new status and error value
+ *
+ * const state = fetchError(error, previousState)
+ * */
+const fetchError = (error, previous) => ({ ...previous, type: FetchStateType.ERROR, error });
+exports.fetchError = fetchError;
+/*
+ * formats data with success type
+ *
+ * const state = fetchSuccess(newData)
+ * */
+const fetchSuccess = (data) => ({ type: FetchStateType.SUCCESS, data });
+exports.fetchSuccess = fetchSuccess;
+/*
+ * formats data with idle type
+ *
+ * const state = fetchIdle(newData)
+ * */
+const fetchIdle = () => ({ type: FetchStateType.IDLE });
+exports.fetchIdle = fetchIdle;
+/*
+ * guard for checking if the state has result data, it might be true for any state type.
+ * */
+const stateHasData = (state) => 'data' in state;
+exports.stateHasData = stateHasData;
+/*
+ * guard for checking if the state has an error, it might be true for error or loading states.
+ * */
+const stateHasError = (state) => 'error' in state;
+exports.stateHasError = stateHasError;

package/{packages/utils/src/guards/index.ts → dist/cjs/guards/index.d.ts}

@@ -5,8 +5,7 @@
  *
  * `const result = (array as Array<string | undefined>).filter(isDefined);`
  */
-export const isDefined = <X>(x: X): x is Exclude<X, undefined> => x !== undefined;
-
+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.
@@ -14,8 +13,7 @@ export const isDefined = <X>(x: X): x is Exclude<X, undefined> => x !== undefine
  *
  * `const result = (array as Array<string | null>).filter(isNotNull);`
  */
-export const isNotNull = <X>(x: X): x is Exclude<X, null> => x !== null;
-
+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
@@ -23,19 +21,18 @@ export const isNotNull = <X>(x: X): x is Exclude<X, null> => x !== null;
  *
  * `const result = (array as Array<number | undefined>).filter(isNumber);`
  */
-export const isNumber = (x: any): x is number => typeof x === 'number';
-
+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 const isPlainObject = (thing: any): thing is {[key: string]: any} =>
-  thing instanceof Object && thing.__proto__.constructor.name === 'Object';
-
+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 const ifDefined = <X, D>(x: X, d: D) => isDefined(x) ? x : d;
+export declare const ifDefined: <X, D>(x: X, d: D) => D | Exclude<X, undefined>;

package/dist/cjs/guards/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ifDefined = exports.isPlainObject = exports.isNumber = exports.isNotNull = exports.isDefined = void 0;
+/**
+ * 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);`
+ */
+const isDefined = (x) => x !== undefined;
+exports.isDefined = isDefined;
+/**
+ * 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);`
+ */
+const isNotNull = (x) => x !== null;
+exports.isNotNull = isNotNull;
+/**
+ * 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);`
+ */
+const isNumber = (x) => typeof x === 'number';
+exports.isNumber = isNumber;
+/**
+ * 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
+ */
+const isPlainObject = (thing) => thing instanceof Object && thing.__proto__.constructor.name === 'Object';
+exports.isPlainObject = isPlainObject;
+/**
+ * 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')
+ */
+const ifDefined = (x, d) => (0, exports.isDefined)(x) ? x : d;
+exports.ifDefined = ifDefined;

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./misc/partitionSequence"), exports);
+__exportStar(require("./misc/helpers"), exports);
+__exportStar(require("./misc/merge"), exports);
+__exportStar(require("./misc/hashValue"), exports);

package/dist/cjs/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>>;