@openstax/ts-utils 1.2.0 → 1.2.3

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

@@ -16,6 +16,5 @@ 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

@@ -34,6 +34,5 @@ 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/errors.d.ts

@@ -1,3 +1,8 @@
+export declare const isAppError: (e: any) => e is Error & {
+    constructor: {
+        TYPE: string;
+    };
+};
 export declare class InvalidRequestError extends Error {
     static readonly TYPE = "InvalidRequestError";
     static matches: (e: any) => e is typeof InvalidRequestError;

package/dist/cjs/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.InvalidRequestError = void 0;
+exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = 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
@@ -15,6 +15,9 @@ exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError
  */
 const errorIsType = ({ TYPE }) => (e) => e instanceof Error
     && e.constructor.TYPE === TYPE;
+const isAppError = (e) => e instanceof Error
+    && typeof e.constructor.TYPE === 'string';
+exports.isAppError = isAppError;
 class InvalidRequestError extends Error {
 }
 exports.InvalidRequestError = InvalidRequestError;

package/dist/cjs/middleware/apiErrorHandler.d.ts

@@ -0,0 +1,7 @@
+import type { ApiResponse } from '../routing';
+import type { Logger } from '../services/logger';
+declare type Handlers = {
+    [key: string]: (e: Error, logger: Logger) => ApiResponse<number, any>;
+};
+export declare const createErrorHandler: (inputHandlers?: Handlers | undefined) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;
+export {};

package/dist/cjs/middleware/apiErrorHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorHandler = void 0;
+const errors_1 = require("../errors");
+const routing_1 = require("../routing");
+const logger_1 = require("../services/logger");
+const defaultHandlers = {
+    UnauthorizedError: () => (0, routing_1.apiTextResponse)(401, '401 UnauthorizedError'),
+    SessionExpiredError: () => (0, routing_1.apiTextResponse)(440, '440 SessionExpiredError'),
+    NotFoundError: (e) => (0, routing_1.apiTextResponse)(404, e.message || '404 NotFoundError'),
+    InvalidRequestError: (e) => (0, routing_1.apiTextResponse)(400, e.message || '400 InvalidRequestError'),
+};
+const createErrorHandler = (inputHandlers) => {
+    const handlers = { ...defaultHandlers, ...inputHandlers };
+    return async (e, logger) => {
+        const name = (0, errors_1.isAppError)(e) ? e.constructor.TYPE : e.constructor.name;
+        const handler = handlers[name];
+        if (handler) {
+            return handler(e, logger);
+        }
+        logger.logEvent(logger_1.Level.Error, {
+            name: e.name,
+            message: e.message,
+            stack: e.stack,
+        });
+        return (0, routing_1.apiTextResponse)(500, '500 Error');
+    };
+};
+exports.createErrorHandler = createErrorHandler;

package/dist/cjs/middleware/apiSlowResponseMiddleware.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigProviderForConfig } from '../config';
+import type { ApiResponse } from '../routing';
+import type { Logger } from '../services/logger';
+declare type Config = {
+    logResponseSlowerThan: string;
+    timeoutResponseAfter: string;
+};
+export declare const createSlowResponseMiddleware: (config: ConfigProviderForConfig<Config>) => () => (response: Promise<ApiResponse<number, any>> | undefined, { logger }: {
+    logger: Logger;
+}) => Promise<ApiResponse<number, string>> | undefined;
+export {};

package/dist/cjs/middleware/apiSlowResponseMiddleware.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSlowResponseMiddleware = void 0;
+const resolveConfigValue_1 = require("../config/resolveConfigValue");
+const helpers_1 = require("../misc/helpers");
+const routing_1 = require("../routing");
+const logger_1 = require("../services/logger");
+const createSlowResponseMiddleware = (config) => {
+    const getSlowThreshold = (0, helpers_1.once)(() => (0, resolveConfigValue_1.resolveConfigValue)(config.logResponseSlowerThan).then(result => parseInt(result, 10)));
+    const getTimeoutAfter = (0, helpers_1.once)(() => (0, resolveConfigValue_1.resolveConfigValue)(config.timeoutResponseAfter).then(result => parseInt(result, 10)));
+    return () => (response, { logger }) => {
+        const start = Date.now();
+        if (!response) {
+            return response;
+        }
+        return Promise.all([getSlowThreshold(), getTimeoutAfter()]).then(([slowThreshold, timeoutAfter]) => {
+            let timeout = undefined;
+            const timeoutPromise = isNaN(timeoutAfter)
+                ? undefined
+                : new Promise(resolve => timeout = setTimeout(() => {
+                    logger.logEvent(logger_1.Level.Error, {
+                        message: 'request processing timed out',
+                    });
+                    resolve((0, routing_1.apiTextResponse)(504, '504 Gateway Timeout'));
+                }, timeoutAfter));
+            const requestPromise = response.then(response => {
+                const time = Date.now() - start;
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                }
+                if (time > slowThreshold) {
+                    logger.logEvent(logger_1.Level.Warn, {
+                        message: 'slow response',
+                        time,
+                    });
+                }
+                return response;
+            });
+            return timeoutPromise ? Promise.race([timeoutPromise, requestPromise]) : requestPromise;
+        });
+    };
+};
+exports.createSlowResponseMiddleware = createSlowResponseMiddleware;

package/dist/cjs/middleware/lambdaCorsResponseMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { APIGatewayProxyEventV2 } from 'aws-lambda';
+import { ConfigProviderForConfig } from '../config';
+import { ApiResponse } from '../routing';
+declare type Config = {
+    corsAllowedHostRegex: string;
+};
+export declare const createLambdaCorsResponseMiddleware: (config: ConfigProviderForConfig<Config>) => (responsePromise: Promise<ApiResponse<number, any>> | undefined, { request }: {
+    request: APIGatewayProxyEventV2;
+}) => Promise<ApiResponse<number, any>> | undefined;
+export {};

package/dist/cjs/middleware/lambdaCorsResponseMiddleware.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLambdaCorsResponseMiddleware = void 0;
+const resolveConfigValue_1 = require("../config/resolveConfigValue");
+const routing_1 = require("../routing");
+const createLambdaCorsResponseMiddleware = (config) => (responsePromise, { request }) => {
+    const cors = async () => {
+        const allowedHost = await (0, resolveConfigValue_1.resolveConfigValue)(config.corsAllowedHostRegex);
+        if (request.headers.origin && new URL(request.headers.origin).hostname.match(new RegExp(allowedHost))) {
+            return {
+                'Access-Control-Allow-Origin': request.headers.origin,
+                'Access-Control-Allow-Credentials': 'true',
+                'Access-Control-Allow-Headers': 'content-type',
+                'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+            };
+        }
+    };
+    if (responsePromise) {
+        return responsePromise.then(async (response) => {
+            response.headers = {
+                ...await cors(),
+                ...response.headers
+            };
+            return response;
+        });
+    }
+    if (request.requestContext.http.method === 'OPTIONS') {
+        return cors().then(headers => (0, routing_1.apiTextResponse)(200, '', headers));
+    }
+    return responsePromise;
+};
+exports.createLambdaCorsResponseMiddleware = createLambdaCorsResponseMiddleware;

package/dist/cjs/middleware/throwNotFoundMiddleware.d.ts

@@ -0,0 +1 @@
+export declare const createThrowNotFoundMiddleware: <Ro>() => () => (response: Promise<Ro> | undefined) => Promise<Ro>;

package/dist/cjs/middleware/throwNotFoundMiddleware.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createThrowNotFoundMiddleware = void 0;
+const errors_1 = require("../errors");
+const createThrowNotFoundMiddleware = () => () => (response) => {
+    if (!response) {
+        throw new errors_1.NotFoundError('not found');
+    }
+    return response;
+};
+exports.createThrowNotFoundMiddleware = createThrowNotFoundMiddleware;

package/dist/cjs/profile.d.ts

@@ -1,5 +1,6 @@
 import { GenericFetch } from './fetch';
 import { ApiResponse, HttpHeaders } from './routing';
+import { Logger } from './services/logger';
 export interface Call {
     start: number;
     end?: number;
@@ -52,6 +53,7 @@ export declare const makeProfileApiResponseMiddleware: <Ri extends {
 }>(showReport: (request: Ri) => string | boolean) => () => (responsePromise: Promise<ApiResponse<number, any>> | undefined, { request, profile }: {
     request: Ri;
     profile: Track;
+    logger: Logger;
 }) => Promise<ApiResponse<number, any>> | undefined;
 export declare const makeHtmlReport: (report: CallReport) => string;
 export declare const makeHtmlProfileReport: (report: ProfileReport) => string;

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

@@ -1,4 +1,5 @@
 import { Track } from '../profile';
+import { Logger } from '../services/logger';
 export declare type QueryParams = Record<string, string | undefined | string[] | null>;
 export declare type RouteParams = {
     [key: string]: string;
@@ -19,6 +20,7 @@ export declare type PayloadForRoute<R> = RequestServicesForRoute<R> extends {
 declare type RequestServiceProvider<Sa, Sr, Ri> = (app: Sa) => <R>(middleware: {
     request: Ri;
     profile: Track;
+    logger: Logger;
 }, match: RouteMatchRecord<R>) => Sr;
 declare type RouteHandler<P, Sr, Ro> = (params: P, request: Sr) => Ro;
 declare type Route<N extends string, P extends RouteParams | undefined, Sa, Sr, Ri, Ro> = (Sr extends undefined ? {
@@ -50,19 +52,27 @@ export declare const makeRenderRouteUrl: <Ru extends {
 }>() => <R extends Ru>(route: R, params: ParamsForRoute<R>, query?: QueryParams) => string;
 export declare const renderAnyRouteUrl: <R extends any>(route: R, params: ParamsForRoute<R>, query?: QueryParams) => string;
 declare type RequestPathExtractor<Ri> = (request: Ri) => string;
+declare type RequestLogExtractor<Ri> = (request: Ri) => JsonCompatibleStruct;
 declare type RequestRouteMatcher<Ri, R> = (request: Ri, route: R) => boolean;
+declare type CompatibleServices<T1> = keyof T1 extends 'logger' ? T1 extends {
+    logger: Logger;
+} ? T1 : never : T1 & {
+    logger?: Logger;
+};
 declare type RequestResponder<Sa, Ri, Ro> = {
-    (services: Sa): (request: Ri) => Ro | undefined;
-    <RoF>(services: Sa, responseMiddleware: (app: Sa) => (response: Ro | undefined, request: {
+    (services: CompatibleServices<Sa>): (request: Ri) => Ro | undefined;
+    <RoF>(services: CompatibleServices<Sa>, responseMiddleware: (app: Sa) => (response: Ro | undefined, request: {
         request: Ri;
         profile: Track;
+        logger: Logger;
     }) => RoF): (request: Ri) => RoF;
 };
-export declare const makeGetRequestResponder: <Sa, Ru, Ri, Ro>() => ({ routes, pathExtractor, routeMatcher, errorHandler }: {
+export declare const makeGetRequestResponder: <Sa, Ru, Ri, Ro>() => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }: {
     routes: () => AnySpecificRoute<Ru, Sa, Ri, Ro>[];
     pathExtractor: RequestPathExtractor<Ri>;
+    logExtractor?: RequestLogExtractor<Ri> | undefined;
     routeMatcher?: RequestRouteMatcher<Ri, AnySpecificRoute<Ru, Sa, Ri, Ro>> | undefined;
-    errorHandler?: ((e: Error) => Ro) | undefined;
+    errorHandler?: ((e: Error, logger: Logger) => Ro) | undefined;
 }) => RequestResponder<Sa, Ri, Ro>;
 export declare type HttpHeaders = {
     [key: string]: string | undefined | string[];

package/dist/cjs/routing/index.js

@@ -34,6 +34,7 @@ const pathToRegexp = __importStar(require("path-to-regexp"));
 const query_string_1 = __importDefault(require("query-string"));
 const helpers_1 = require("../misc/helpers");
 const profile_1 = require("../profile");
+const console_1 = require("../services/logger/console");
 /*
  * route definition helper. the only required params of the route are the name, path, and handler. other params
  * can be added to the type and then later used in the routeMatcher. when defining the `createRoute` method, only
@@ -93,11 +94,11 @@ exports.renderAnyRouteUrl = (0, exports.makeRenderRouteUrl)();
 const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
     const getParamsFromPath = pathToRegexp.match(route.path, { decode: decodeURIComponent });
     const boundServiceProvider = route.requestServiceProvider && appBinder(services, route.requestServiceProvider);
-    return (request, profile) => {
+    return (request, profile, logger) => {
         const path = pathExtractor(request);
         const match = getParamsFromPath(path);
         if ((!matcher || matcher(request, route)) && match) {
-            return profile.track(route.name, routeProfile => () => route.handler(match.params, boundServiceProvider ? boundServiceProvider({ request, profile: routeProfile }, { route, params: match.params }) : undefined));
+            return profile.track(route.name, routeProfile => () => route.handler(match.params, boundServiceProvider ? boundServiceProvider({ request, profile: routeProfile, logger }, { route, params: match.params }) : undefined));
         }
     };
 };
@@ -120,11 +121,12 @@ const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
  *       lambdaMiddleware // environment specific response middleware (like cors)
  *     );
  */
-const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler }) => (services, responseMiddleware) => {
+const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }) => (services, responseMiddleware) => {
     const appBinderImpl = (app, middleware) => middleware(app, appBinder);
     const appBinder = (0, helpers_1.memoize)(appBinderImpl);
     const boundRoutes = routes().map(bindRoute(services, appBinder, pathExtractor, routeMatcher));
     const boundResponseMiddleware = responseMiddleware ? responseMiddleware(services) : undefined;
+    const appLogger = services.logger || (0, console_1.createConsoleLogger)();
     // *note* this opaque promise guard is less generic than i hoped so
     //   i'm leaving it here instead of the guards file.
     //
@@ -135,14 +137,18 @@ const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, er
     const isPromise = (thing) => thing instanceof Promise;
     return (request) => {
         const { end, ...profile } = (0, profile_1.createProfile)(new Date().toISOString()).start();
+        const logger = appLogger.createSubContext();
+        if (logExtractor) {
+            logger.setContext(logExtractor(request));
+        }
         try {
-            const executor = (0, helpers_1.mapFind)(boundRoutes, (route) => route(request, profile));
+            const executor = (0, helpers_1.mapFind)(boundRoutes, (route) => route(request, profile, logger));
             if (executor) {
                 const result = boundResponseMiddleware ?
-                    boundResponseMiddleware(executor(), { request, profile }) : executor();
+                    boundResponseMiddleware(executor(), { request, profile, logger }) : executor();
                 if (isPromise(result) && errorHandler) {
                     const errorHandlerWithMiddleware = (e) => boundResponseMiddleware ?
-                        boundResponseMiddleware(errorHandler(e), { request, profile }) : errorHandler(e);
+                        boundResponseMiddleware(errorHandler(e, logger), { request, profile, logger }) : errorHandler(e, logger);
                     return result.catch(errorHandlerWithMiddleware);
                 }
                 else {
@@ -150,12 +156,14 @@ const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, er
                 }
             }
             else if (boundResponseMiddleware) {
-                return boundResponseMiddleware(undefined, { request, profile });
+                return boundResponseMiddleware(undefined, { request, profile, logger });
             }
         }
         catch (e) {
             if (errorHandler && e instanceof Error) {
-                return boundResponseMiddleware ? boundResponseMiddleware(errorHandler(e), { request, profile }) : errorHandler(e);
+                return boundResponseMiddleware
+                    ? boundResponseMiddleware(errorHandler(e, logger), { request, profile, logger })
+                    : errorHandler(e, logger);
             }
             throw e;
         }

package/dist/cjs/services/apiGateway/index.js

@@ -75,8 +75,9 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
                     if (!status.includes(response.status)) {
                         throw new Error('unexpected response from api');
                     }
-                    return { status: response.status, load: (0, exports.loadResponse)(response) };
+                    return { status: response.status, headers: response.headers, load: (0, exports.loadResponse)(response) };
                 },
+                headers: response.headers,
                 load: (0, exports.loadResponse)(response),
             };
         });

package/dist/cjs/services/authProvider/browser.js

@@ -65,7 +65,7 @@ const browserAuthProvider = ({ window, configSpace }) => (configProvider) => {
         const timeout = setTimeout(() => {
             window.removeEventListener('message', handler);
             reject(new Error('loading user identity timed out'));
-        }, 100);
+        }, 5000);
     });
     /*
      * requests user identity from accounts api using given token or cookie

package/dist/cjs/services/logger/console.d.ts

@@ -0,0 +1 @@
+export declare const createConsoleLogger: () => import(".").Logger;

package/dist/cjs/services/logger/console.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConsoleLogger = void 0;
+const _1 = require(".");
+const createConsoleLogger = () => (0, _1.createCoreLogger)((level, event) => console[level](JSON.stringify({
+    eventType: level.toUpperCase(),
+    ...event,
+})));
+exports.createConsoleLogger = createConsoleLogger;

package/dist/cjs/services/logger/index.d.ts

@@ -0,0 +1,14 @@
+import { JsonCompatibleStruct } from '../../routing';
+export declare enum Level {
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+export declare type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
+export interface Logger {
+    setContext: (obj: JsonCompatibleStruct) => void;
+    logEvent: LogEvent;
+    log: (message: string, level?: Level) => void;
+    createSubContext: () => Logger;
+}
+export declare const createCoreLogger: (driver: LogEvent, getParentContext?: (() => JsonCompatibleStruct) | undefined) => Logger;

package/dist/cjs/services/logger/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCoreLogger = exports.Level = void 0;
+var Level;
+(function (Level) {
+    Level["Info"] = "info";
+    Level["Warn"] = "warn";
+    Level["Error"] = "error";
+})(Level = exports.Level || (exports.Level = {}));
+const createCoreLogger = (driver, getParentContext) => {
+    const context = {};
+    const getContext = () => ({ ...getParentContext === null || getParentContext === void 0 ? void 0 : getParentContext(), ...context });
+    return {
+        logEvent: (level, event) => driver(level, { ...event, context: getContext() }),
+        log: (message, level = Level.Info) => driver(level, { message, context: getContext() }),
+        setContext: (obj) => { Object.assign(context, obj); },
+        createSubContext: () => (0, exports.createCoreLogger)(driver, getContext),
+    };
+};
+exports.createCoreLogger = createCoreLogger;