@openstax/ts-utils 1.34.0 → 1.35.0

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

@@ -6,54 +6,26 @@
  *
  * There may be a better way to do this; `T1 extends T2` doesn't work
  */
-export type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail]
-  ? T2 extends [infer T2Head, ...infer T2Tail]
-    ? T1Head extends T2Head
-      ? TupleExtends<T1Tail, T2Tail> extends 'yes'
-        ? 'yes'
-        : 'no'
-      : 'no'
-    : T2 extends []
-      ? 'yes'
-      : 'no'
-  : T1 extends []
-    ? T2 extends []
-      ? 'yes'
-      : 'no'
-    : 'no'
-;
-
+export type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? T1Head extends T2Head ? TupleExtends<T1Tail, T2Tail> extends 'yes' ? 'yes' : 'no' : 'no' : T2 extends [] ? 'yes' : 'no' : T1 extends [] ? T2 extends [] ? 'yes' : 'no' : 'no';
 /**
  * unions each member of the tuple
  */
-export type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail]
-  ? T2 extends [infer T2Head, ...infer T2Tail]
-    ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>]
-    : T2 extends []
-      ? T1
-      : never
-  : T1 extends []
-    ? T2 extends any[]
-      ? T2
-      : never
-    : never
-;
-
+export type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>] : T2 extends [] ? T1 : never : T1 extends [] ? T2 extends any[] ? T2 : never : never;
 /**
  * If `R` is `Promise<I>`, returns `I`, otherwise returns `R`
  * @deprecated use TypeScript builtin Awaited instead:
  * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#the-awaited-type-and-promise-improvements
  */
 export type UnwrapPromise<R> = R extends Promise<infer I> ? I : R;
-
 /**
  * turns `thing | thing2` into `thing & thing2`
  * @see https://stackoverflow.com/a/50375286/14809536
  */
-export type UnionToIntersection<U> = (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never;
-
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**
  * make certain fields required
  * @see https://stackoverflow.com/a/69328045/14809536
  */
-export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,89 @@
+export 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/{packages/utils/src/assertions/index.ts → dist/esm/assertions/index.js}

@@ -11,22 +11,18 @@
  * stack trace more useful, and allows you to use specific error types
  * that might be handled differently.
  */
-
-export type AssertionFailed = string | Error | (() => never) | undefined;
-
-export const doThrow = (failed: AssertionFailed): never => {
-  if (typeof failed === 'string') {
-    throw new Error(failed);
-  }
-  if (failed instanceof Error) {
-    throw failed;
-  }
-  if (!failed) {
-    throw new Error();
-  }
-  return failed();
+export const doThrow = (failed) => {
+    if (typeof failed === 'string') {
+        throw new Error(failed);
+    }
+    if (failed instanceof Error) {
+        throw failed;
+    }
+    if (!failed) {
+        throw new Error();
+    }
+    return failed();
 };
-
 /**
  * Asserts that the given value is true.
  *
@@ -37,14 +33,12 @@ export const doThrow = (failed: AssertionFailed): never => {
  * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
  * @returns the value that was asserted
  */
-export const assertTrue = <X>(x: X, failed?: AssertionFailed) => {
-  if (typeof x !== 'boolean' || x !== true) {
-    return doThrow(failed);
-  }
-
-  return x;
+export const assertTrue = (x, failed) => {
+    if (typeof x !== 'boolean' || x !== true) {
+        return doThrow(failed);
+    }
+    return x;
 };
-
 /**
  * Asserts that the given value is false.
  *
@@ -55,14 +49,12 @@ export const assertTrue = <X>(x: X, failed?: AssertionFailed) => {
  * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
  * @returns the value that was asserted
  */
-export const assertFalse = <X>(x: X, failed?: AssertionFailed) => {
-  if (typeof x !== 'boolean' || x !== false) {
-    return doThrow(failed);
-  }
-
-  return x;
+export const assertFalse = (x, failed) => {
+    if (typeof x !== 'boolean' || x !== false) {
+        return doThrow(failed);
+    }
+    return x;
 };
-
 /**
  * Asserts that the given value is defined.
  *
@@ -73,14 +65,12 @@ export const assertFalse = <X>(x: X, failed?: AssertionFailed) => {
  * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
  * @returns the value that was asserted, with a type that excludes undefined
  */
-export const assertDefined = <X>(x: X, failed?: AssertionFailed) => {
-  if (x === undefined) {
-    return doThrow(failed);
-  }
-
-  return x as Exclude<X, undefined>;
+export const assertDefined = (x, failed) => {
+    if (x === undefined) {
+        return doThrow(failed);
+    }
+    return x;
 };
-
 /**
  * Asserts that the given value is a string.
  *
@@ -91,14 +81,12 @@ export const assertDefined = <X>(x: X, failed?: AssertionFailed) => {
  * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
  * @returns the value that was asserted
  */
-export const assertString = <X>(x: X, failed?: AssertionFailed): string => {
-  if (typeof x !== 'string') {
-    return doThrow(failed);
-  }
-
-  return x;
+export const assertString = (x, failed) => {
+    if (typeof x !== 'string') {
+        return doThrow(failed);
+    }
+    return x;
 };
-
 /**
  * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
  *
@@ -109,18 +97,16 @@ export const assertString = <X>(x: X, failed?: AssertionFailed): string => {
  * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
  * @returns the value that was asserted
  */
-export const assertNotNaN = <T>(thing: T, failed?: AssertionFailed): T => {
-  if (typeof thing === 'number' && isNaN(thing)) {
-    return doThrow(failed);
-  }
-  return thing;
+export const assertNotNaN = (thing, failed) => {
+    if (typeof thing === 'number' && isNaN(thing)) {
+        return doThrow(failed);
+    }
+    return thing;
 };
-
 /**
  * @deprecated use assertNotNaN instead
  */
 export const notNaN = assertNotNaN;
-
 /**
  * Asserts that the first argument is an instance of the second.
  *
@@ -132,13 +118,12 @@ export const notNaN = assertNotNaN;
  * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
  * @returns the value that was asserted
  */
-export const assertInstanceOf = <T>(thing: any, constructable: Function & { new(...args: any[]): T }, failed?: AssertionFailed): T => {
-  if (thing instanceof constructable) {
-    return thing;
-  }
-  return doThrow(failed);
+export const assertInstanceOf = (thing, constructable, failed) => {
+    if (thing instanceof constructable) {
+        return thing;
+    }
+    return doThrow(failed);
 };
-
 /**
  * Asserts that the error in the first argument is an instance of the error given as the
  * second argument
@@ -150,12 +135,12 @@ export const assertInstanceOf = <T>(thing: any, constructable: Function & { new(
  * @throws the original error if the check fails
  * @see assertInstanceOf
  */
-export const assertErrorInstanceOf = <T extends Error>(thing: unknown, constructable: Function & { new(...args: any[]): T }): T => {
-  if (thing instanceof Error) {
-    return 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}"`);
-  }
+export const assertErrorInstanceOf = (thing, constructable) => {
+    if (thing instanceof Error) {
+        return 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}"`);
+    }
 };

package/dist/esm/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/esm/aws/ssmService.js

@@ -0,0 +1,6 @@
+import { SSM } from '@aws-sdk/client-ssm';
+import { once } from '..';
+/**
+ * A memoized instance of the AWS SSM client.
+ */
+export const ssmService = once(() => new SSM({ apiVersion: '2012-08-10' }));

package/dist/esm/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/esm/config/awsParameterConfig.js

@@ -0,0 +1,22 @@
+import { GetParameterCommand } from '@aws-sdk/client-ssm';
+import { assertDefined } from '../assertions';
+import { ssmService } from '../aws/ssmService';
+import { resolveConfigValue } from './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
+ */
+export const awsParameterConfig = (parameterName) => {
+    return async () => {
+        const command = new GetParameterCommand({ Name: await 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 ssmService().send(command);
+        const parameter = assertDefined(response.Parameter, `aws GetParameter response missing Parameter key for ${parameterName}"`);
+        return assertDefined(parameter.Value, `aws GetParameter response missing Parameter.Value key for ${parameterName}"`);
+    };
+};

package/dist/esm/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", defaultValue?: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/esm/config/envConfig.js

@@ -0,0 +1,53 @@
+import { resolveConfigValue } from './resolveConfigValue';
+/**
+ * A list of environment variables that were requested at build time. Used by webpack to
+ * capture build-time environment variables values.
+ */
+export const 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') };
+ */
+export 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') {
+        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 resolveConfigValue(defaultValue);
+            }
+        }
+        else {
+            return value;
+        }
+    };
+};

package/dist/esm/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 type ConfigValue = string;
+/**
+ * A configuration object that may contain nested configuration objects or configuration values.
+ */
+export 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 type ConfigValueProvider<V extends ConfigValue = ConfigValue> = (() => Promise<V> | V) | V;
+/**
+ * A configuration object that may contain nested configuration objects or configuration value providers.
+ */
+export 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 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 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 ConfigValue>(configValue: V) => ConfigValueProvider<V>;
+export * from './envConfig';
+export * from './replaceConfig';
+export * from './awsParameterConfig';
+export * from './lambdaParameterConfig';

package/dist/esm/config/index.js

@@ -0,0 +1,17 @@
+export * from './resolveConfigValue';
+/*
+ * ===========
+ * 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') };
+ */
+export const stubConfig = (configValue) => configValue;
+export * from './envConfig';
+export * from './replaceConfig';
+export * from './awsParameterConfig';
+export * from './lambdaParameterConfig';

package/dist/esm/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/esm/config/lambdaParameterConfig.js

@@ -0,0 +1,38 @@
+import fetch from 'node-fetch';
+import { assertDefined } from '../assertions';
+import { retryWithDelay } from '../misc/helpers';
+import { envConfig } from './envConfig';
+import { resolveConfigValue } from '.';
+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
+ */
+export const lambdaParameterConfig = (parameterName) => async () => {
+    const token = await resolveConfigValue(envConfig('AWS_SESSION_TOKEN', 'runtime'));
+    const name = await 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 = retryWithDelay(() => fetch(lambdaExtensionUrl));
+    }
+    await lambdaExtensionReadyPromise;
+    const resp = await retryWithDelay(() => fetch(
+    // 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 = assertDefined(response.Parameter, `aws GetParameter response missing Parameter key for ${name}"`);
+        return 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}`);
+    }
+};

package/dist/esm/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/{packages/utils/src/config/replaceConfig.ts → dist/esm/config/replaceConfig.js}

@@ -1,6 +1,4 @@
 import { resolveConfigValue } from './resolveConfigValue';
-import { ConfigValueProvider } from '.';
-
 /**
  * Substitutes configuration values into a provided string.
  * Performs a string substitution using configuration values
@@ -11,18 +9,10 @@ import { ConfigValueProvider } from '.';
  * @example replaceConfig('https://[host]', { '[host]': envConfig('HOST') })
  * @returns the string after substitution is complete
  */
-export const replaceConfig = (
-  base: ConfigValueProvider<string>,
-  replacements: {[token: string]: ConfigValueProvider<string>}
-): ConfigValueProvider<string> => {
-
-  return async() => {
-    const resolved = await Promise.all(Object.entries(replacements)
-      .map(async([token, replacement]) => [token, await resolveConfigValue(replacement)] as const)
-    );
-
-    return resolved.reduce(
-      (result, [token, replacement]) => result.replace(token, replacement)
-    , await resolveConfigValue(base));
-  };
+export const replaceConfig = (base, replacements) => {
+    return async () => {
+        const resolved = await Promise.all(Object.entries(replacements)
+            .map(async ([token, replacement]) => [token, await resolveConfigValue(replacement)]));
+        return resolved.reduce((result, [token, replacement]) => result.replace(token, replacement), await resolveConfigValue(base));
+    };
 };

package/dist/esm/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/esm/config/resolveConfigValue.js

@@ -0,0 +1,8 @@
+/**
+ * resolves a config value into a string, to be used inside of things that are provided configurations
+ */
+export const resolveConfigValue = async (provider) => {
+    return typeof provider === 'function'
+        ? await provider()
+        : provider;
+};