@openstax/ts-utils 1.1.27 → 1.1.29

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

@@ -0,0 +1,5 @@
+import { ConfigValueProvider } from '.';
+export declare const awsAccountConfig: <C extends string>(config: {
+    sandbox: ConfigValueProvider<C>;
+    production: ConfigValueProvider<C>;
+}) => ConfigValueProvider<C>;

package/dist/cjs/config/awsAccountConfig.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awsAccountConfig = void 0;
+const client_sts_1 = require("@aws-sdk/client-sts");
+const assertions_1 = require("../assertions");
+const securityTokenService_1 = require("../aws/securityTokenService");
+const envConfig_1 = require("./envConfig");
+const resolveConfigValue_1 = require("./resolveConfigValue");
+/*
+ * uses a different given value depending on which aws account the code is deployed in.
+ * this resolves the given value recursively, so its composable with more configProviders in the
+ * conditional cases.
+ *
+ * eg:
+ *   const config = {
+ *     configValue: awsAccountConfig({sandbox: 'inTheSandboxConfig', production: 'inProductionConfig'}),
+ *     configValue: awsAccountConfig({sandbox: envConfig('an_environment_variable'), production: 'inProductionConfig'}),
+ *   };
+ * */
+const awsAccountConfig = (config) => {
+    const production = (0, envConfig_1.envConfig)('PRODUCTION_AWS');
+    const sandbox = (0, envConfig_1.envConfig)('SANDBOX_AWS');
+    return async () => {
+        const identity = await (0, securityTokenService_1.securityTokenService)().send(new client_sts_1.GetCallerIdentityCommand({}));
+        switch (identity.Account) {
+            case await (0, resolveConfigValue_1.resolveConfigValue)(sandbox):
+                return await (0, resolveConfigValue_1.resolveConfigValue)((0, assertions_1.assertDefined)(config.sandbox, 'a sandbox config was not provided'));
+            case await (0, resolveConfigValue_1.resolveConfigValue)(production):
+                return await (0, resolveConfigValue_1.resolveConfigValue)((0, assertions_1.assertDefined)(config.production, 'a production config was not provided'));
+            default:
+                throw new Error('unknown aws account');
+        }
+    };
+};
+exports.awsAccountConfig = awsAccountConfig;

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

@@ -0,0 +1,2 @@
+import { ConfigValueProvider } from '.';
+export declare const awsParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/cjs/config/awsParameterConfig.js

@@ -0,0 +1,18 @@
+"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");
+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,3 @@
+import { ConfigValueProvider } from '.';
+export declare const ENV_BUILD_CONFIGS: string[];
+export declare const envConfig: (name: string, type?: 'build' | 'runtime', defaultValue?: string | undefined) => ConfigValueProvider<string>;

package/dist/cjs/config/envConfig.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envConfig = exports.ENV_BUILD_CONFIGS = void 0;
+const assertions_1 = require("../assertions");
+const guards_1 = require("../guards");
+/*
+ * uses a config from the process environment.
+ *
+ * there are two modes for this, by default it expects the value to be provided at build time,
+ * and there is access built in here for webpack to provide the configs. if you pass `runtime`
+ * as the second argument it skips the build logic and will try to literally pull it from
+ * `process.env` when the config is used at runtime
+ *
+ * the value is read from the environment when something tries to use it, not when `envConfig` is called.
+ *
+ * eg:
+ *   const config = {
+ *     configValue: envConfig('environment_variable_name'),
+ *   };
+ * */
+exports.ENV_BUILD_CONFIGS = [];
+const envConfig = (name, type = 'build', defaultValue) => {
+    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
+        const envs = { ...process.env, ...(typeof __PROCESS_ENV !== 'undefined' ? __PROCESS_ENV : {}) };
+        return (0, assertions_1.assertDefined)((0, guards_1.ifDefined)(envs[name], defaultValue), `expected to find environment variable with name: ${name}`);
+    };
+};
+exports.envConfig = envConfig;

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

@@ -0,0 +1,21 @@
+export declare type ConfigValue = string;
+export declare type Config = {
+    [key: string]: Config | ConfigValue;
+};
+export declare type ConfigValueProvider<V extends ConfigValue = ConfigValue> = (() => Promise<V> | V) | V;
+export declare type ConfigProvider = {
+    [key: string]: ConfigProvider | ConfigValueProvider;
+};
+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;
+export declare type ConfigProviderForConfig<T> = T extends ConfigValue ? ConfigValueProvider<T> : T extends Config ? {
+    [key in keyof T]: ConfigProviderForConfig<T[key]>;
+} : never;
+export * from './resolveConfigValue';
+export declare const stubConfig: <V extends string>(configValue: V) => ConfigValueProvider<V>;
+export * from './envConfig';
+export * from './replaceConfig';
+export * from './awsAccountConfig';
+export * from './awsParameterConfig';
+export * from './lambdaParameterConfig';

package/dist/cjs/config/index.js

@@ -0,0 +1,39 @@
+"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
+ *
+ * eg:
+ *   const config = {
+ *     configValue: stubConfig('just-a-string'),
+ *   };
+ * */
+const stubConfig = (configValue) => configValue;
+exports.stubConfig = stubConfig;
+__exportStar(require("./envConfig"), exports);
+__exportStar(require("./replaceConfig"), exports);
+__exportStar(require("./awsAccountConfig"), exports);
+__exportStar(require("./awsParameterConfig"), exports);
+__exportStar(require("./lambdaParameterConfig"), exports);

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

@@ -0,0 +1,2 @@
+import { ConfigValueProvider } from '.';
+export declare const lambdaParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/cjs/config/lambdaParameterConfig.js

@@ -0,0 +1,36 @@
+"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 envConfig_1 = require("./envConfig");
+const _1 = require(".");
+const lambdaExtensionUrl = 'http://localhost:2773';
+let lambdaExtensionReadyPromise;
+// NOTE: Can only be used during in AWS Lambda
+// The AWS Parameters and Secrets Lambda Extension Layer must be included in the Lambda function
+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, node_fetch_1.default)(lambdaExtensionUrl);
+    }
+    await lambdaExtensionReadyPromise;
+    const resp = await (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,4 @@
+import { ConfigValueProvider } from '.';
+export declare const replaceConfig: (base: ConfigValueProvider<string>, replacements: {
+    [token: string]: ConfigValueProvider<string>;
+}) => ConfigValueProvider<string>;

package/dist/cjs/config/replaceConfig.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceConfig = void 0;
+const resolveConfigValue_1 = require("./resolveConfigValue");
+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,2 @@
+import { ConfigValueProvider } from '.';
+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;