@openstax/ts-utils 1.0.6 → 1.1.1

package/dist/config.d.ts

@@ -24,3 +24,4 @@ export declare const awsAccountConfig: <C extends string>(config: {
     production: ConfigValueProvider<C>;
 }) => ConfigValueProvider<C>;
 export declare const awsParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;
+export declare const lambdaParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;

package/dist/config.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.awsParameterConfig = exports.awsAccountConfig = exports.replaceConfig = exports.stubConfig = exports.envConfig = exports.ENV_BUILD_CONFIGS = exports.resolveConfigValue = void 0;
+exports.lambdaParameterConfig = exports.awsParameterConfig = exports.awsAccountConfig = exports.replaceConfig = exports.stubConfig = exports.envConfig = exports.ENV_BUILD_CONFIGS = exports.resolveConfigValue = void 0;
 const client_ssm_1 = require("@aws-sdk/client-ssm");
 const client_sts_1 = require("@aws-sdk/client-sts");
+const node_fetch_1 = __importDefault(require("node-fetch"));
 const assertions_1 = require("./assertions");
 const securityTokenService_1 = require("./aws/securityTokenService");
 const ssmService_1 = require("./aws/ssmService");
@@ -108,3 +112,29 @@ const awsParameterConfig = (parameterName) => {
     };
 };
 exports.awsParameterConfig = awsParameterConfig;
+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, exports.resolveConfigValue)((0, exports.envConfig)('AWS_SESSION_TOKEN', 'runtime'));
+    const name = await (0, exports.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/fetch.d.ts

@@ -53,7 +53,7 @@ export declare type FetchConfig = {
 declare type Headers = {
     get: (name: string) => string | null;
 };
-declare type Response = {
+export declare type Response = {
     status: number;
     headers: Headers;
     json: () => Promise<any>;

package/dist/index.d.ts

@@ -10,6 +10,7 @@ declare type HashCompoundValue = Array<HashValue> | {
 };
 export declare const hashValue: (value: HashValue) => string;
 export declare const once: <F extends (...args: any[]) => any>(fn: F) => F;
+export declare const memoize: <F extends (...args: any[]) => any>(fn: F) => F;
 export declare const roundToPrecision: (num: number, places: number) => number;
 export declare const getCommonProperties: <T1 extends {}, T2 extends {}>(thing1: T1, thing2: T2) => (keyof T1 & keyof T2)[];
 export declare const merge: <T extends {}[]>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tuple = exports.merge = exports.getCommonProperties = exports.roundToPrecision = exports.once = exports.hashValue = exports.mapFind = exports.fnIf = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
+exports.tuple = exports.merge = exports.getCommonProperties = exports.roundToPrecision = exports.memoize = exports.once = exports.hashValue = exports.mapFind = exports.fnIf = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
 const crypto_1 = require("crypto");
 const guards_1 = require("./guards");
 /*
@@ -72,6 +72,34 @@ const once = (fn) => {
     return ((...args) => result || (result = fn(...args)));
 };
 exports.once = once;
+/*
+ * memoizes a function with any number of arguments
+ */
+const memoize = (fn) => {
+    const cache = {};
+    const resolveCache = (cacheLayer, [first, ...rest]) => {
+        if (!first) {
+            return cacheLayer;
+        }
+        const layers = first instanceof Object
+            ? (cacheLayer.weakLayers = (cacheLayer.weakLayers || (typeof WeakMap === 'undefined' ? undefined : new WeakMap())))
+            : (cacheLayer.strongLayers = (cacheLayer.strongLayers || new Map()));
+        // argument is an object and WeakMap is not supported
+        if (!layers) {
+            return {};
+        }
+        const layer = layers.get(first) || {};
+        if (!layers.has(first)) {
+            layers.set(first, layer);
+        }
+        return resolveCache(layer, rest);
+    };
+    return ((...args) => {
+        const thisCache = resolveCache(cache, args);
+        return thisCache.result = (thisCache.result || fn(...args));
+    });
+};
+exports.memoize = memoize;
 /*
  * rounds number to given number of places
  *

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
 import { TupleExtends } from './types';
-export declare type MiddlewareProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => R;
+export declare type MiddlewareProvider<Sa, M, A extends any[], R> = (app: Sa, appBinder?: ((app: Sa, provider: MiddlewareProvider<Sa, M, A, R>) => (middleware: M, ...args: A) => R)) => (middleware: M, ...args: A) => R;
 export declare type MiddlewareTransformProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => Omit<M, keyof R> & R;
 export declare type MiddlewareInput<S> = S extends MiddlewareProvider<any, infer M, any, any> ? M : never;
 export declare type ServiceMiddlewareProviderResult<M, S> = [M] extends [never] ? never : [M] extends [MiddlewareInput<S>] ? S extends MiddlewareTransformProvider<any, M, any, infer R> ? R extends M ? R : Omit<M, keyof R> & R : S extends MiddlewareProvider<any, M, any, infer R> ? R : never : never;

package/dist/middleware.js

@@ -29,8 +29,8 @@ exports.makeComposeMiddleware = void 0;
  * // this helps typescript figure out what is going on
  * eg: const myThing: myType = makeComposeMiddleware()(...);
  * */
-const makeComposeMiddleware = () => (...chain) => (app) => {
-    const boundChain = chain.map(provider => provider(app));
+const makeComposeMiddleware = () => (...chain) => (app, appBinder) => {
+    const boundChain = chain.map(provider => appBinder ? appBinder(app, provider) : provider(app));
     return (middleware, ...args) => {
         return boundChain.reduce((result, provider) => provider(result, ...args), middleware);
     };

package/dist/routing.d.ts

@@ -92,8 +92,11 @@ export declare const getRequestBody: (request: {
     body?: string | undefined;
 }) => any;
 export declare const unsafePayloadValidator: <T>() => (input: any) => input is T;
-export declare const requestPayloadProvider: <T>(validator: (input: any) => input is T) => () => <M extends {
-    request: Parameters<typeof getRequestBody>[0];
+export declare const requestPayloadProvider: <T>(validator: (input: any) => input is T) => () => <R extends {
+    headers: HttpHeaders;
+    body?: string | undefined;
+}, M extends {
+    request: R;
 }>(requestServices: M) => M & {
     payload: T;
 };

package/dist/routing.js

@@ -89,9 +89,9 @@ const makeRenderRouteUrl = () => (route, params, query = {}) => {
 };
 exports.makeRenderRouteUrl = makeRenderRouteUrl;
 exports.renderAnyRouteUrl = (0, exports.makeRenderRouteUrl)();
-const bindRoute = (services, pathExtractor, matcher) => (route) => {
+const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
     const getParamsFromPath = pathToRegexp.match(route.path, { decode: decodeURIComponent });
-    const boundServiceProvider = route.requestServiceProvider && route.requestServiceProvider(services);
+    const boundServiceProvider = route.requestServiceProvider && appBinder(services, route.requestServiceProvider);
     return (request) => {
         const path = pathExtractor(request);
         const match = getParamsFromPath(path);
@@ -120,7 +120,9 @@ const bindRoute = (services, pathExtractor, matcher) => (route) => {
  *     );
  */
 const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler }) => (services, responseMiddleware) => {
-    const boundRoutes = routes().map(bindRoute(services, pathExtractor, routeMatcher));
+    const appBinderImpl = (app, middleware) => middleware(app, appBinder);
+    const appBinder = (0, _1.memoize)(appBinderImpl);
+    const boundRoutes = routes().map(bindRoute(services, appBinder, pathExtractor, routeMatcher));
     const boundResponseMiddleware = responseMiddleware ? responseMiddleware(services) : undefined;
     // *note* this opaque promise guard is less generic than i hoped so
     //   i'm leaving it here instead of the guards file.

package/dist/services/apiGateway/index.d.ts

@@ -1,5 +1,5 @@
 import { ConfigProviderForConfig } from '../../config';
-import { ConfigForFetch, GenericFetch } from '../../fetch';
+import { ConfigForFetch, GenericFetch, Response } from '../../fetch';
 import { AnyRoute, ApiResponse, OutputForRoute, ParamsForRoute, PayloadForRoute, QueryParams } from '../../routing';
 import { UnwrapPromise } from '../../types';
 declare type TResponsePayload<R> = R extends ApiResponse<any, infer P> ? P : never;
@@ -41,6 +41,7 @@ declare type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
         method: string;
     };
 } : never;
+export declare const loadResponse: (response: Response) => () => Promise<any>;
 interface MakeApiGateway<F> {
     <Ru>(config: ConfigProviderForConfig<{
         apiBase: string;
@@ -48,14 +49,7 @@ interface MakeApiGateway<F> {
         getAuthorizedFetchConfig: () => ConfigForFetch<F>;
     }): MapRoutesToClient<Ru>;
 }
-export declare const createApiGateway: <F extends GenericFetch<import("../../fetch").FetchConfig, {
-    status: number;
-    headers: {
-        get: (name: string) => string | null;
-    };
-    json: () => Promise<any>;
-    text: () => Promise<string>;
-}>>(initializer: {
+export declare const createApiGateway: <F extends GenericFetch<import("../../fetch").FetchConfig, Response>>(initializer: {
     fetch: F;
 }) => MakeApiGateway<F>;
 export {};

package/dist/services/apiGateway/index.js

@@ -26,11 +26,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createApiGateway = void 0;
+exports.createApiGateway = exports.loadResponse = void 0;
 const pathToRegexp = __importStar(require("path-to-regexp"));
 const query_string_1 = __importDefault(require("query-string"));
 const __1 = require("../..");
 const config_1 = require("../../config");
+const loadResponse = (response) => () => {
+    const contentType = response.headers.get('content-type');
+    switch (contentType) {
+        case 'text/plain':
+            return response.text();
+        case 'application/json':
+            return response.json();
+        default:
+            throw new Error(`unknown content type ${contentType}`);
+    }
+};
+exports.loadResponse = loadResponse;
 const makeRouteClient = (initializer, config, route, authProvider) => {
     const renderUrl = async ({ params, query }) => {
         const apiBase = await (0, config_1.resolveConfigValue)(config.apiBase);
@@ -55,9 +67,9 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
                 if (!status.includes(response.status)) {
                     throw new Error('unexpected response from api');
                 }
-                return { status: response.status, load: () => response.json() };
+                return { status: response.status, load: (0, exports.loadResponse)(response) };
             },
-            load: () => response.json(),
+            load: (0, exports.loadResponse)(response),
         }));
     };
     routeClient.renderUrl = renderUrl;

package/dist/services/exercisesGateway/index.d.ts

@@ -66,14 +66,7 @@ export declare const exercisesGateway: <C extends string = "exercises">(initiali
 }; }) => {
     searchDigest: (query: string, page?: number, per_page?: number) => Promise<string>;
     get: (uuid: string) => Promise<Exercise | undefined>;
-    request: (method: METHOD, path: string, query?: object | undefined) => Promise<{
-        status: number;
-        headers: {
-            get: (name: string) => string | null;
-        };
-        json: () => Promise<any>;
-        text: () => Promise<string>;
-    }>;
+    request: (method: METHOD, path: string, query?: object | undefined) => Promise<import("../../fetch").Response>;
     search: (query: string, page?: number, per_page?: number) => Promise<ExercisesSearchResultsWithDigest>;
 };
 export declare type ExercisesGateway = ReturnType<ReturnType<typeof exercisesGateway>>;