@openstax/ts-utils 1.2.1 → 1.2.4

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

@@ -12,6 +12,8 @@
  */
 const errorIsType = ({ TYPE }) => (e) => e instanceof Error
     && e.constructor.TYPE === TYPE;
+export const isAppError = (e) => e instanceof Error
+    && typeof e.constructor.TYPE === 'string';
 export class InvalidRequestError extends Error {
 }
 InvalidRequestError.TYPE = 'InvalidRequestError';

package/dist/esm/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/esm/middleware/apiErrorHandler.js

@@ -0,0 +1,25 @@
+import { isAppError } from '../errors';
+import { apiTextResponse } from '../routing';
+import { Level } from '../services/logger';
+const defaultHandlers = {
+    UnauthorizedError: () => apiTextResponse(401, '401 UnauthorizedError'),
+    SessionExpiredError: () => apiTextResponse(440, '440 SessionExpiredError'),
+    NotFoundError: (e) => apiTextResponse(404, e.message || '404 NotFoundError'),
+    InvalidRequestError: (e) => apiTextResponse(400, e.message || '400 InvalidRequestError'),
+};
+export const createErrorHandler = (inputHandlers) => {
+    const handlers = { ...defaultHandlers, ...inputHandlers };
+    return async (e, logger) => {
+        const name = isAppError(e) ? e.constructor.TYPE : e.constructor.name;
+        const handler = handlers[name];
+        if (handler) {
+            return handler(e, logger);
+        }
+        logger.logEvent(Level.Error, {
+            name: e.name,
+            message: e.message,
+            stack: e.stack,
+        });
+        return apiTextResponse(500, '500 Error');
+    };
+};

package/dist/esm/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/esm/middleware/apiSlowResponseMiddleware.js

@@ -0,0 +1,39 @@
+import { resolveConfigValue } from '../config/resolveConfigValue';
+import { once } from '../misc/helpers';
+import { apiTextResponse } from '../routing';
+import { Level } from '../services/logger';
+export const createSlowResponseMiddleware = (config) => {
+    const getSlowThreshold = once(() => resolveConfigValue(config.logResponseSlowerThan).then(result => parseInt(result, 10)));
+    const getTimeoutAfter = once(() => 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(Level.Error, {
+                        message: 'request processing timed out',
+                    });
+                    resolve(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(Level.Warn, {
+                        message: 'slow response',
+                        time,
+                    });
+                }
+                return response;
+            });
+            return timeoutPromise ? Promise.race([timeoutPromise, requestPromise]) : requestPromise;
+        });
+    };
+};

package/dist/esm/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/esm/middleware/lambdaCorsResponseMiddleware.js

@@ -0,0 +1,28 @@
+import { resolveConfigValue } from '../config/resolveConfigValue';
+import { apiTextResponse } from '../routing';
+export const createLambdaCorsResponseMiddleware = (config) => (responsePromise, { request }) => {
+    const cors = async () => {
+        const allowedHost = await resolveConfigValue(config.corsAllowedHostRegex);
+        if (request.headers.origin && request.headers.origin !== 'null' && 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 => apiTextResponse(200, '', headers));
+    }
+    return responsePromise;
+};

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

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

package/dist/esm/middleware/throwNotFoundMiddleware.js

@@ -0,0 +1,7 @@
+import { NotFoundError } from '../errors';
+export const createThrowNotFoundMiddleware = () => () => (response) => {
+    if (!response) {
+        throw new NotFoundError('not found');
+    }
+    return response;
+};

package/dist/esm/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/esm/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/esm/routing/index.js

@@ -2,6 +2,7 @@ import * as pathToRegexp from 'path-to-regexp';
 import queryString from 'query-string';
 import { mapFind, memoize } from '../misc/helpers';
 import { createProfile } from '../profile';
+import { createConsoleLogger } from '../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
@@ -59,11 +60,11 @@ export const renderAnyRouteUrl = 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));
         }
     };
 };
@@ -86,11 +87,12 @@ const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
  *       lambdaMiddleware // environment specific response middleware (like cors)
  *     );
  */
-export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler }) => (services, responseMiddleware) => {
+export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }) => (services, responseMiddleware) => {
     const appBinderImpl = (app, middleware) => middleware(app, appBinder);
     const appBinder = memoize(appBinderImpl);
     const boundRoutes = routes().map(bindRoute(services, appBinder, pathExtractor, routeMatcher));
     const boundResponseMiddleware = responseMiddleware ? responseMiddleware(services) : undefined;
+    const appLogger = services.logger || createConsoleLogger();
     // *note* this opaque promise guard is less generic than i hoped so
     //   i'm leaving it here instead of the guards file.
     //
@@ -101,14 +103,18 @@ export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatc
     const isPromise = (thing) => thing instanceof Promise;
     return (request) => {
         const { end, ...profile } = createProfile(new Date().toISOString()).start();
+        const logger = appLogger.createSubContext();
+        if (logExtractor) {
+            logger.setContext(logExtractor(request));
+        }
         try {
-            const executor = mapFind(boundRoutes, (route) => route(request, profile));
+            const executor = 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 {
@@ -116,12 +122,14 @@ export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatc
                 }
             }
             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/esm/services/apiGateway/index.js

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

package/dist/esm/services/authProvider/browser.d.ts

@@ -48,7 +48,9 @@ export declare const browserAuthProvider: <C extends string = "auth">({ window,
      * gets an authorized url for an iframe src. sets params on the url and saves its
      * origin to trust releasing user identity to it
      */
-    getAuthorizedEmbedUrl: (urlString: string) => string;
+    getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
+        [key: string]: string;
+    } | undefined) => string;
     /**
      * gets second argument for `fetch` that has authentication token or cookie
      */

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

@@ -62,7 +62,7 @@ export 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/esm/services/authProvider/utils/embeddedAuthProvider.d.ts

@@ -14,7 +14,9 @@ export declare const embeddedAuthProvider: (getUserData: UserDataLoader, { query
     window: Window;
 }) => {
     embeddedQueryValue: string;
-    getAuthorizedEmbedUrl: (urlString: string) => string;
+    getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
+        [key: string]: string;
+    } | undefined) => string;
     unmount: () => void;
 };
 export {};

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.js

@@ -1,3 +1,4 @@
+import queryString from 'query-string';
 export var PostMessageTypes;
 (function (PostMessageTypes) {
     PostMessageTypes["ReceiveUser"] = "receive-user";
@@ -14,10 +15,11 @@ export const embeddedAuthProvider = (getUserData, { queryKey = 'auth', window })
         }
     };
     window.addEventListener('message', messageHandler);
-    const getAuthorizedEmbedUrl = (urlString) => {
+    const getAuthorizedEmbedUrl = (urlString, extraParams) => {
         const url = new URL(urlString);
         trustedEmbeds.add(url.origin);
-        url.searchParams.set(queryKey, embeddedQueryValue);
+        const params = queryString.parse(url.search);
+        url.search = queryString.stringify({ ...params, ...extraParams, [queryKey]: embeddedQueryValue });
         return url.href;
     };
     return {

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

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

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

@@ -0,0 +1,5 @@
+import { createCoreLogger } from '.';
+export const createConsoleLogger = () => createCoreLogger((level, event) => console[level](JSON.stringify({
+    eventType: level.toUpperCase(),
+    ...event,
+})));

package/dist/esm/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/esm/services/logger/index.js

@@ -0,0 +1,16 @@
+export var Level;
+(function (Level) {
+    Level["Info"] = "info";
+    Level["Warn"] = "warn";
+    Level["Error"] = "error";
+})(Level || (Level = {}));
+export 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: () => createCoreLogger(driver, getContext),
+    };
+};