@openstax/ts-utils 1.21.11 → 1.23.0

package/dist/cjs/assertions/index.d.ts

@@ -0,0 +1,85 @@
+export declare type AssertionFailed = string | Error | (() => never) | undefined;
+export declare const doThrow: (failed: AssertionFailed) => never;
+/**
+ * Asserts that the given value is true.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
+ * @returns the value that was asserted
+ */
+export declare const assertTrue: <X>(x: X, failed?: AssertionFailed) => X & true;
+/**
+ * Asserts that the given value is false.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
+ * @returns the value that was asserted
+ */
+export declare const assertFalse: <X>(x: X, failed?: AssertionFailed) => X & false;
+/**
+ * Asserts that the given value is defined.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
+ * @returns the value that was asserted, with a type that excludes undefined
+ */
+export declare const assertDefined: <X>(x: X, failed?: AssertionFailed) => Exclude<X, undefined>;
+/**
+ * Asserts that the given value is a string.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
+ * @returns the value that was asserted
+ */
+export declare const assertString: <X>(x: X, failed?: AssertionFailed) => string;
+/**
+ * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
+ *
+ * @param thing The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
+ * @returns the value that was asserted
+ */
+export declare const assertNotNaN: <T>(thing: T, failed?: AssertionFailed) => T;
+/**
+ * @deprecated use assertNotNaN instead
+ */
+export declare const notNaN: <T>(thing: T, failed?: AssertionFailed) => T;
+/**
+ * Asserts that the first argument is an instance of the second.
+ *
+ * @param thing The value to assert.
+ * @param constructable The class to check against.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
+ * @returns the value that was asserted
+ */
+export declare const assertInstanceOf: <T>(thing: any, constructable: Function & (new (...args: any[]) => T), failed?: AssertionFailed) => T;
+/**
+ * Asserts that the error in the first argument is an instance of the error given as the
+ * second argument
+ *
+ * @param thing The value to assert.
+ * @param constructable The error class to check against.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
+ * @returns the value that was asserted
+ * @throws the original error if the check fails
+ * @see assertInstanceOf
+ */
+export declare const assertErrorInstanceOf: <T extends Error>(thing: unknown, constructable: Function & (new (...args: any[]) => T)) => T;

package/dist/cjs/assertions/index.js

@@ -0,0 +1,157 @@
+"use strict";
+/*
+ * all of these assertions take either a string, throw function, or nothing
+ * for the second argument. its STRONGLY encouraged to provide some error
+ * or message that explains the reason for the assertion
+ *
+ * eg:
+ *   assertDefined(user, new UnauthorizedException())
+ *   assertDefined(thing.otherThing, 'otherThing should be guaranteed to exist, but is missing')
+ *
+ * passing an Error instead of a string makes the first element of the resulting
+ * stack trace more useful, and allows you to use specific error types
+ * that might be handled differently.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertErrorInstanceOf = exports.assertInstanceOf = exports.notNaN = exports.assertNotNaN = exports.assertString = exports.assertDefined = exports.assertFalse = exports.assertTrue = exports.doThrow = void 0;
+const doThrow = (failed) => {
+    if (typeof failed === 'string') {
+        throw new Error(failed);
+    }
+    if (failed instanceof Error) {
+        throw failed;
+    }
+    if (!failed) {
+        throw new Error();
+    }
+    return failed();
+};
+exports.doThrow = doThrow;
+/**
+ * Asserts that the given value is true.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
+ * @returns the value that was asserted
+ */
+const assertTrue = (x, failed) => {
+    if (typeof x !== 'boolean' || x !== true) {
+        return (0, exports.doThrow)(failed);
+    }
+    return x;
+};
+exports.assertTrue = assertTrue;
+/**
+ * Asserts that the given value is false.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
+ * @returns the value that was asserted
+ */
+const assertFalse = (x, failed) => {
+    if (typeof x !== 'boolean' || x !== false) {
+        return (0, exports.doThrow)(failed);
+    }
+    return x;
+};
+exports.assertFalse = assertFalse;
+/**
+ * Asserts that the given value is defined.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
+ * @returns the value that was asserted, with a type that excludes undefined
+ */
+const assertDefined = (x, failed) => {
+    if (x === undefined) {
+        return (0, exports.doThrow)(failed);
+    }
+    return x;
+};
+exports.assertDefined = assertDefined;
+/**
+ * Asserts that the given value is a string.
+ *
+ * @param x The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
+ * @returns the value that was asserted
+ */
+const assertString = (x, failed) => {
+    if (typeof x !== 'string') {
+        return (0, exports.doThrow)(failed);
+    }
+    return x;
+};
+exports.assertString = assertString;
+/**
+ * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
+ *
+ * @param thing The value to assert.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
+ * @returns the value that was asserted
+ */
+const assertNotNaN = (thing, failed) => {
+    if (typeof thing === 'number' && isNaN(thing)) {
+        return (0, exports.doThrow)(failed);
+    }
+    return thing;
+};
+exports.assertNotNaN = assertNotNaN;
+/**
+ * @deprecated use assertNotNaN instead
+ */
+exports.notNaN = exports.assertNotNaN;
+/**
+ * Asserts that the first argument is an instance of the second.
+ *
+ * @param thing The value to assert.
+ * @param constructable The class to check against.
+ * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
+ *  to provide some value for this for traceability. Passing an Error instead of a string
+ *  makes the stack trace more useful and allows you to handle assertion failures differently.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
+ * @returns the value that was asserted
+ */
+const assertInstanceOf = (thing, constructable, failed) => {
+    if (thing instanceof constructable) {
+        return thing;
+    }
+    return (0, exports.doThrow)(failed);
+};
+exports.assertInstanceOf = assertInstanceOf;
+/**
+ * Asserts that the error in the first argument is an instance of the error given as the
+ * second argument
+ *
+ * @param thing The value to assert.
+ * @param constructable The error class to check against.
+ * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
+ * @returns the value that was asserted
+ * @throws the original error if the check fails
+ * @see assertInstanceOf
+ */
+const assertErrorInstanceOf = (thing, constructable) => {
+    if (thing instanceof Error) {
+        return (0, exports.assertInstanceOf)(thing, constructable, thing);
+    }
+    else {
+        // this separate branch prevents an unknown non-Error thing from being passed to the assertion as an AssertionFailed
+        throw new Error(`assertErrorInstanceOf received non-Error argument of type "${typeof thing}" and string representation "${thing}"`);
+    }
+};
+exports.assertErrorInstanceOf = assertErrorInstanceOf;

package/dist/cjs/aws/ssmService.d.ts

@@ -0,0 +1,5 @@
+import { SSM } from '@aws-sdk/client-ssm';
+/**
+ * A memoized instance of the AWS SSM client.
+ */
+export declare const ssmService: () => SSM;

package/dist/cjs/aws/ssmService.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ssmService = void 0;
+const client_ssm_1 = require("@aws-sdk/client-ssm");
+const __1 = require("..");
+/**
+ * A memoized instance of the AWS SSM client.
+ */
+exports.ssmService = (0, __1.once)(() => new client_ssm_1.SSM({ apiVersion: '2012-08-10' }));

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

@@ -0,0 +1,10 @@
+import { ConfigValueProvider } from '.';
+/**
+ * Returns a value from the AWS Parameter Store.
+ *
+ * @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(awsParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
+export declare const awsParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/cjs/config/awsParameterConfig.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awsParameterConfig = void 0;
+const client_ssm_1 = require("@aws-sdk/client-ssm");
+const assertions_1 = require("../assertions");
+const ssmService_1 = require("../aws/ssmService");
+const resolveConfigValue_1 = require("./resolveConfigValue");
+/**
+ * Returns a value from the AWS Parameter Store.
+ *
+ * @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(awsParameterConfig('some-parameter-name'));
+ * @returns the configuration value provider for the value
+ */
+const awsParameterConfig = (parameterName) => {
+    return async () => {
+        const command = new client_ssm_1.GetParameterCommand({ Name: await (0, resolveConfigValue_1.resolveConfigValue)(parameterName), WithDecryption: true });
+        // send() throws ParameterNotFound if the parameter is missing,
+        // so it's not clear what missing Parameter or Value mean
+        const response = await (0, ssmService_1.ssmService)().send(command);
+        const parameter = (0, assertions_1.assertDefined)(response.Parameter, `aws GetParameter response missing Parameter key for ${parameterName}"`);
+        return (0, assertions_1.assertDefined)(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${parameterName}"`);
+    };
+};
+exports.awsParameterConfig = awsParameterConfig;

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

@@ -0,0 +1,24 @@
+import type { ConfigValueProvider } from '.';
+/**
+ * A list of environment variables that were requested at build time. Used by webpack to
+ * capture build-time environment variables values.
+ */
+export declare const ENV_BUILD_CONFIGS: string[];
+/**
+ * Returns an environment variable from the process environment. Depending on the `type` in the
+ * call to get the variable, the variable's value may be what it was at build time, not at runtime.
+ * The return value is not the variable value itself, but rather a provider that has to be called
+ * to read the variable value (meaning, this is safe to call even if the variable doesn't exist,
+ * because someone else later needs to call the provider to get the value -- that call may explode,
+ * but this one won't).
+ *
+ * @param name The name of the environment variable to retrieve.
+ * @param type The mode for accessing the variable. Defaults to `'build'`, i.e. getting the
+ * variable as it was set at build time (webpack is connected here to make this possible). This
+ * argument can also be `'runtime'` in which case the value at build time is ignored and the
+ * variable is pulled live from `process.env`.
+ * @param [defaultValue] The default value to use if the variable is not found.
+ *
+ * @example const config = { configValue: envConfig('environment_variable_name') };
+ */
+export declare const envConfig: (name: string, type?: "build" | "runtime" | undefined, defaultValue?: ConfigValueProvider<string> | undefined) => ConfigValueProvider<string>;

package/dist/cjs/config/envConfig.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envConfig = exports.ENV_BUILD_CONFIGS = void 0;
+const resolveConfigValue_1 = require("./resolveConfigValue");
+/**
+ * A list of environment variables that were requested at build time. Used by webpack to
+ * capture build-time environment variables values.
+ */
+exports.ENV_BUILD_CONFIGS = [];
+/**
+ * Returns an environment variable from the process environment. Depending on the `type` in the
+ * call to get the variable, the variable's value may be what it was at build time, not at runtime.
+ * The return value is not the variable value itself, but rather a provider that has to be called
+ * to read the variable value (meaning, this is safe to call even if the variable doesn't exist,
+ * because someone else later needs to call the provider to get the value -- that call may explode,
+ * but this one won't).
+ *
+ * @param name The name of the environment variable to retrieve.
+ * @param type The mode for accessing the variable. Defaults to `'build'`, i.e. getting the
+ * variable as it was set at build time (webpack is connected here to make this possible). This
+ * argument can also be `'runtime'` in which case the value at build time is ignored and the
+ * variable is pulled live from `process.env`.
+ * @param [defaultValue] The default value to use if the variable is not found.
+ *
+ * @example const config = { configValue: envConfig('environment_variable_name') };
+ */
+const envConfig = (name, type, defaultValue) => {
+    // this doesn't use a default parameter value because of a:
+    //   "Regular parameters should not come after default parameters."
+    // error that occurs when the defaultValue optional default of `undefined`
+    // gets optimized out, causing a problem in cloudfront functions.
+    type !== null && type !== void 0 ? type : (type = 'build');
+    if (type === 'build') {
+        exports.ENV_BUILD_CONFIGS.push(name);
+    }
+    return () => {
+        /*global __PROCESS_ENV*/
+        // @ts-ignore - hack to get around the way webpack/define works
+        // - https://github.com/webpack/webpack/issues/14800
+        // - https://github.com/webpack/webpack/issues/5392
+        // also, spread operator not supported in cloudfront functions
+        const envs = Object.assign({}, process.env, typeof __PROCESS_ENV !== 'undefined' ? __PROCESS_ENV : {});
+        const value = envs[name];
+        if (value === undefined) {
+            if (defaultValue === undefined) {
+                throw new Error(`expected to find environment variable with name: ${name}`);
+            }
+            else {
+                return (0, resolveConfigValue_1.resolveConfigValue)(defaultValue);
+            }
+        }
+        else {
+            return value;
+        }
+    };
+};
+exports.envConfig = envConfig;

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

@@ -0,0 +1,48 @@
+/**
+ * A simple type alias for a string that represents a configuration value. Currently only string values are supported to maintain compatibility with environment variables, but this type is future proofing against allowing other types like `number` as possible config values.
+ */
+export declare type ConfigValue = string;
+/**
+ * A configuration object that may contain nested configuration objects or configuration values.
+ */
+export declare type Config = {
+    [key: string]: Config | ConfigValue;
+};
+/**
+ * Either a function that returns a `ConfigValue` or a `Promise` that resolves to a `ConfigValue`,
+ * or just a `ConfigValue`.
+ */
+export declare type ConfigValueProvider<V extends ConfigValue = ConfigValue> = (() => Promise<V> | V) | V;
+/**
+ * A configuration object that may contain nested configuration objects or configuration value providers.
+ */
+export declare type ConfigProvider = {
+    [key: string]: ConfigProvider | ConfigValueProvider;
+};
+/**
+ * Conditional type that resolves to the type of configuration object for the given configuration
+ * provider. Also resolves to a config value type if the given type is a config value.
+ */
+export declare type ConfigForConfigProvider<T> = T extends ConfigValue ? T : T extends ConfigProvider ? {
+    [key in keyof T]: ConfigForConfigProvider<T[key]>;
+} : T extends ConfigValueProvider<infer R> ? R : never;
+/**
+ * Conditional type that resolves to the `ConfigProvider` type for the given configuration
+ * type (`ConfigValue` or `Config`). The resulting type is either a `ConfigValueProvider` or
+ * a `ConfigProvider`.
+ */
+export declare type ConfigProviderForConfig<T> = T extends ConfigValue ? ConfigValueProvider<T> : T extends Config ? {
+    [key in keyof T]: ConfigProviderForConfig<T[key]>;
+} : never;
+export * from './resolveConfigValue';
+/**
+ * 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') };
+ */
+export declare const stubConfig: <V extends string>(configValue: V) => ConfigValueProvider<V>;
+export * from './envConfig';
+export * from './replaceConfig';
+export * from './awsParameterConfig';
+export * from './lambdaParameterConfig';

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 { 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 string>(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,77 @@
+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);
+}