@openstax/ts-utils 1.21.11 → 1.23.0

package/dist/cjs/routing/index.js

@@ -0,0 +1,270 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METHOD = exports.apiHtmlResponse = exports.apiTextResponse = exports.apiJsonResponse = exports.makeGetRequestResponder = exports.renderAnyRouteUrl = exports.makeRenderRouteUrl = exports.makeCreateRoute = void 0;
+const pathToRegexp = __importStar(require("path-to-regexp"));
+const query_string_1 = __importDefault(require("query-string"));
+const helpers_1 = require("../misc/helpers");
+const console_1 = require("../services/logger/console");
+/**
+ * Makes a createRoute function that can be used to create routes (this is a factory factory). The
+ * `makeCreateRoute` function is typically called once in the backend and once in the frontend to
+ * set the types for the resulting `createRoute` function -- that latter function is called once
+ * per route. E.g. for the backend, the call could look like:
+ *
+ * ```
+ * export const createRoute = makeCreateRoute<AppServices, ApiRouteRequest, {
+ *   method: METHOD;
+ * }>();
+ * ```
+ *
+ * Notes:
+ * * The `{method: METHOD}` defines the `Ex` extension type; here, the `method` property is only
+ *   relevant to backend routes.
+ * * when defining the `createRoute` method, only the request input format is defined, the output
+ *   format is derived from the routes.
+ *
+ * When calling the resulting `createRoute` function, 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.
+ *
+ * eg when defining requestServiceProvider in line, the types have a hard time, it helps to put in another argument:
+ * ```
+ * export const exampleRoute = createRoute({
+ *   name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
+ *   requestServiceProvider: composeServiceMiddleware({
+ *     cookieAuthMiddleware,
+ *     documentStoreMiddleware,
+ *   }},
+ *   async(params: {key: string}, services) => {
+ *     const result = await services.myDocumentStore.getItem(params.key);
+ *
+ *     if (!result) {
+ *       throw new NotFoundError('requested item not found');
+ *     }
+ *
+ *     return apiJsonResponse(200, result);
+ *   }
+ * );
+ * ```
+ * eg when using a pre-existing provider variable the types work better:
+ * ```
+ * export const exampleRoute = createRoute({
+ *   name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
+ *   requestServiceProvider,
+ *   handler: async(params: {key: string}, services) => {
+ *     const result = await services.myDocumentStore.getItem(params.key);
+ *
+ *     if (!result) {
+ *       throw new NotFoundError('requested item not found');
+ *     }
+ *
+ *     return apiJsonResponse(200, result);
+ *   }
+ * });
+ * ```
+ */
+const makeCreateRoute = () => (...args) => {
+    return (args.length === 1
+        ? args[0]
+        : { ...args[0], handler: args[1] });
+};
+exports.makeCreateRoute = makeCreateRoute;
+/* begin reverse routing utils */
+/**
+ * Makes a renderRouteUrl function that can be used to render route paths (this is a factory
+ * factory). The returned function takes a `route`, `params`, and `query` and returns a string
+ * with the params and query substituted into the route path.
+ *
+ * this function is initialized using the Ru type which indicates the specific routes wired into
+ * the application, which means that if you try to build a url with a route which is not wired
+ * into the router you will get a type error. this is a feature to prevent referencing routes that
+ * don't exist or aren't handling requests properly.
+ *
+ * if you are making a helper function or need to render a route outside your application, you
+ * can use the `renderAnyRouteUrl` function
+ */
+const makeRenderRouteUrl = () => (route, params, query = {}) => {
+    const getPathForParams = pathToRegexp.compile(route.path, { encode: encodeURIComponent });
+    const search = query_string_1.default.stringify(query);
+    const path = getPathForParams(params) + (search ? `?${search}` : '');
+    return path;
+};
+exports.makeRenderRouteUrl = makeRenderRouteUrl;
+/**
+ * A pre-made result from `makeRenderRouteUrl`, this function interpolates parameter and query
+ * arguments into a route path.
+ *
+ * prefer using `renderRouteUrl` initialized with your applications route union
+ * when possible to help catch improperly initialized routes.
+ *
+ * @param route the route that has a `path` to be interpolated
+ * @param params the parameters to interpolate into the route path
+ * @param query the query parameters to add to the route path
+ * @returns the interpolated route path
+ */
+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, logger) => {
+        const path = pathExtractor(request);
+        const match = getParamsFromPath(path);
+        if ((!matcher || matcher(request, route)) && match) {
+            return () => route.handler(match.params, boundServiceProvider ? boundServiceProvider({ request, logger }, { route, params: match.params }) : undefined);
+        }
+    };
+};
+/**
+ * A factory factory for creating request responders (functions that take a request and return a
+ * response -- these functions let us implement Lambda `handler` functions).
+ *
+ * Use it in two steps. First, call it with the general business logic that defines routes, logs,
+ * errors, etc:
+ * ```
+ * const getRequestResponder = makeGetRequestResponder<
+ *    AppServices, TRoutes, ApiRouteRequest, Promise<ApiRouteResponse>
+ *   >()  // this empty invocation helps typescript mix defined and inferred types
+ *   ({
+ *     routes: apiRoutes, // the route definitions
+ *     pathExtractor,     // how to get the path out of the request format
+ *     routeMatcher,      // logic for matching route (beyond path matching, optional)
+ *     errorHandler,      // any special error handling
+ *   });
+ * ```
+ * Note here that among other things we're specifying a generic response format that the response
+ * and error handling middleware can use, if any routes have responses that don't adhere to this
+ * it'll complain about it.
+ *
+ * Next, we use the `getRequestResponder` to create a responder for a specific lambda entrypoint:
+ * ```
+ * export const handler: (request: APIGatewayProxyEventV2): Promise<ApiRouteResponse> =>
+ *   getRequestResponder(
+ *     lambdaServices,  // the AppServices for this entrypoint
+ *     lambdaMiddleware // environment specific response middleware (like cors)
+ *   );
+ * ```
+ */
+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.
+    //
+    // its less than ideal because it enforces that the handlers return
+    // the same type as the parent promise, usually a handler can be either a
+    // promise or a non-promise value and the promise figures it out, but those
+    // types are getting complicated quickly here.
+    const isPromise = (thing) => thing instanceof Promise;
+    return (request) => {
+        const logger = appLogger.createSubContext();
+        if (logExtractor) {
+            logger.setContext(logExtractor(request));
+        }
+        try {
+            const executor = (0, helpers_1.mapFind)(boundRoutes, (route) => route(request, logger));
+            if (executor) {
+                const result = boundResponseMiddleware ?
+                    boundResponseMiddleware(executor(), { request, logger }) : executor();
+                if (isPromise(result) && errorHandler) {
+                    const errorHandlerWithMiddleware = (e) => boundResponseMiddleware ?
+                        boundResponseMiddleware(errorHandler(e, logger), { request, logger }) : errorHandler(e, logger);
+                    return result.catch(errorHandlerWithMiddleware);
+                }
+                else {
+                    return result;
+                }
+            }
+            else if (boundResponseMiddleware) {
+                return boundResponseMiddleware(undefined, { request, logger });
+            }
+        }
+        catch (e) {
+            if (errorHandler && e instanceof Error) {
+                return boundResponseMiddleware
+                    ? boundResponseMiddleware(errorHandler(e, logger), { request, logger })
+                    : errorHandler(e, logger);
+            }
+            throw e;
+        }
+        return undefined;
+    };
+};
+exports.makeGetRequestResponder = makeGetRequestResponder;
+/**
+ * Returns a JSON response. Handles serializing the data to JSON and setting the content-type header.
+ * @param statusCode e.g. 201
+ * @param data the object to be serialized to JSON
+ * @param headers HTTP headers
+ * @example
+ * return apiJsonResponse(
+ *   200, {
+ *     message: "hello, world!",
+ *     foo: "bar",
+ *   },
+ *   { 'X-Frame-Options': 'DENY' }
+ * );
+ */
+const apiJsonResponse = (statusCode, data, headers) => ({ statusCode, data, body: JSON.stringify(data), headers: { ...headers, 'content-type': 'application/json' } });
+exports.apiJsonResponse = apiJsonResponse;
+/**
+ * Returns a plain text response. Handles setting the content-type header.
+ * @param statusCode e.g. 201
+ * @param data some string
+ * @param headers HTTP headers
+ * @example return apiTextResponse(200, 'some text')
+ */
+const apiTextResponse = (statusCode, data, headers) => ({ statusCode, data, body: data, headers: { ...headers, 'content-type': 'text/plain' } });
+exports.apiTextResponse = apiTextResponse;
+/**
+ * Returns an HTML response. Handles setting the content-type header.
+ * @param statusCode e.g. 201
+ * @param data some string
+ * @param headers HTTP headers
+ * @example return apiHtmlResponse(200, '<b>some text</b>')
+ */
+const apiHtmlResponse = (statusCode, data, headers) => ({ statusCode, data, body: data, headers: { ...headers, 'content-type': 'text/html' } });
+exports.apiHtmlResponse = apiHtmlResponse;
+/** HTTP method enum */
+var METHOD;
+(function (METHOD) {
+    METHOD["GET"] = "GET";
+    METHOD["HEAD"] = "HEAD";
+    METHOD["POST"] = "POST";
+    METHOD["PUT"] = "PUT";
+    METHOD["PATCH"] = "PATCH";
+    METHOD["DELETE"] = "DELETE";
+    METHOD["OPTIONS"] = "OPTIONS";
+})(METHOD = exports.METHOD || (exports.METHOD = {}));
+__exportStar(require("./helpers"), exports);

package/dist/cjs/routing/validators/zod.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+export declare const zodPayloadValidator: <T>(validator: z.ZodType<T, z.ZodTypeDef, T>) => (input: {
+    [key: string]: any;
+}) => input is T;

package/dist/cjs/routing/validators/zod.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodPayloadValidator = void 0;
+const errors_1 = require("../../errors");
+const zodPayloadValidator = (validator) => (input) => {
+    const result = validator.safeParse(input);
+    if (result.success) {
+        return true;
+    }
+    throw new errors_1.ValidationError(result.error.format());
+};
+exports.zodPayloadValidator = zodPayloadValidator;

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

@@ -0,0 +1,85 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { JsonCompatibleStruct } from '../../routing';
+import { ApiUser, ConsentPreferences } from '../authProvider';
+import { Logger } from '../logger';
+export declare type Config = {
+    accountsBase: string;
+    accountsAuthToken: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare type FindUserPayload = ({
+    external_id: string;
+} | {
+    uuid: string;
+}) & {
+    sso?: string;
+};
+export declare type FindOrCreateUserPayload = {
+    external_id: string;
+    email?: string;
+    already_verified?: boolean;
+    first_name?: string;
+    last_name?: string;
+    full_name?: string;
+    salesforce_contact_id?: string;
+    faculty_status?: string;
+    role?: string;
+    school_type?: string;
+    is_test?: boolean;
+    sso?: string;
+};
+export declare type FindOrCreateUserResponse = {
+    id: number;
+    uuid: string;
+    external_ids: string[];
+    is_test: boolean;
+    sso: string;
+};
+export declare type FindUserResponse = (FindOrCreateUserResponse & {
+    external_ids: string[];
+}) | undefined;
+export declare type LinkUserPayload = {
+    userId: number;
+    externalId: string;
+};
+export declare type LinkUserResponse = {
+    user_id: number;
+    external_id: string;
+};
+export declare type SearchUsersPayload = {
+    q: string;
+    order_by?: string;
+};
+export declare type SearchUsersResponse = {
+    items: Array<ApiUser & {
+        external_ids: string[];
+    } & JsonCompatibleStruct>;
+    total_count: number;
+};
+export declare type UpdateUserPayload = ConsentPreferences;
+export declare type MappedUserInfo<T> = {
+    data: T;
+    fullName: string;
+    platformUserId?: string;
+    uuid: string;
+};
+export declare const accountsGateway: <C extends string = "accounts">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    accountsBase: import("../../config").ConfigValueProvider<string>;
+    accountsAuthToken: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    findOrCreateUser: (body: FindOrCreateUserPayload) => Promise<FindOrCreateUserResponse>;
+    findUser: (body: FindUserPayload) => Promise<FindUserResponse>;
+    getUser: (token: string) => Promise<ApiUser & JsonCompatibleStruct>;
+    linkUser: (body: LinkUserPayload) => Promise<LinkUserResponse>;
+    mapUserUuids: <T>(userUuidsMap: {
+        [uuid: string]: T;
+    }, logger: Logger, platformId?: string | undefined) => Promise<MappedUserInfo<T>[]>;
+    searchUsers: (payload: SearchUsersPayload) => Promise<SearchUsersResponse>;
+    updateUser: (token: string, body: UpdateUserPayload) => Promise<ApiUser & JsonCompatibleStruct>;
+};
+export declare type AccountsGateway = ReturnType<ReturnType<typeof accountsGateway>>;
+export {};

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

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountsGateway = void 0;
+const lodash_1 = require("lodash");
+const query_string_1 = __importDefault(require("query-string"));
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const routing_1 = require("../../routing");
+const logger_1 = require("../logger");
+class ApiError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+const accountsGateway = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'accounts')];
+    const accountsBase = (0, config_1.resolveConfigValue)(config.accountsBase);
+    const accountsAuthToken = (0, config_1.resolveConfigValue)(config.accountsAuthToken);
+    const request = async (method, path, options, statuses = [200, 201]) => {
+        const host = (await accountsBase).replace(/\/+$/, '');
+        const url = `${host}/api/${path}`;
+        const config = {
+            headers: {
+                Authorization: `Bearer ${options.token || await accountsAuthToken}`,
+            },
+            method,
+        };
+        if (options.body) {
+            config.body = JSON.stringify(options.body);
+        }
+        const response = await initializer.fetch(url, config);
+        if (!statuses.includes(response.status)) {
+            throw new ApiError(`Received unexpected status code ${response.status} for Accounts API call: ${method} ${url}`, response.status);
+        }
+        return response.json();
+    };
+    const findOrCreateUser = async (body) => request(routing_1.METHOD.POST, 'user/find-or-create', { body });
+    const findUser = async (body) => {
+        try {
+            return await request(routing_1.METHOD.POST, 'user/find', { body });
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                return undefined;
+            }
+            else {
+                throw error;
+            }
+        }
+    };
+    const getUser = async (token) => request(routing_1.METHOD.GET, 'user', { token });
+    const linkUser = async (body) => request(routing_1.METHOD.POST, 'user/external-ids', {
+        body: {
+            external_id: body.externalId,
+            user_id: body.userId,
+        }
+    });
+    const searchUsers = async (payload) => request(routing_1.METHOD.GET, `users?${query_string_1.default.stringify(payload)}`, {});
+    const updateUser = async (token, body) => request(routing_1.METHOD.PUT, 'user', { body, token });
+    const getPlatformUserId = (externalIds, platformId) => {
+        for (const externalId of externalIds) {
+            const [userPlatformId, userId] = externalId.split('/', 2);
+            if (userPlatformId === platformId) {
+                return userId;
+            }
+        }
+    };
+    /*
+     * If a platformId is given, returns an array where
+     * the first element is the user id from the platform
+     * and the second is the value from the map
+     * Otherwise, returns an array where
+     * the first element is the user's full_name
+     * and the second is the value from the map
+     */
+    const mapUserUuids = async (userUuidsMap, logger, platformId) => {
+        const results = [];
+        // Accounts will not return any results if this search returns more than 10 users
+        const chunkedUuids = (0, lodash_1.chunk)(Object.keys(userUuidsMap), 10);
+        await Promise.all(chunkedUuids.map(async (uuids) => {
+            const { items } = await searchUsers({ q: uuids.map((uuid) => `uuid:${uuid}`).join(' ') });
+            const accountsUuids = items.map((user) => user.uuid);
+            if (!(0, lodash_1.isEqual)(accountsUuids.sort(), uuids.sort())) {
+                logger.logEvent(logger_1.Level.Warn, {
+                    message: 'Unexpected Accounts user search results',
+                    uuids,
+                    accountsUuids,
+                });
+            }
+            items.forEach((user) => {
+                const platformUserId = platformId ? getPlatformUserId(user.external_ids, platformId) : undefined;
+                if (platformId && !platformUserId) {
+                    logger.logEvent(logger_1.Level.Warn, {
+                        message: 'Accounts user has no external_id matching the given platformId',
+                        accountsUuid: user.uuid,
+                        platformId,
+                    });
+                }
+                if (!user.full_name) {
+                    logger.logEvent(logger_1.Level.Warn, {
+                        message: 'Accounts user has no full_name',
+                        accountsUuid: user.uuid,
+                    });
+                }
+                results.push({
+                    data: userUuidsMap[user.uuid], fullName: user.full_name, platformUserId, uuid: user.uuid,
+                });
+            });
+        }));
+        return results;
+    };
+    return { findOrCreateUser, findUser, getUser, linkUser, mapUserUuids, searchUsers, updateUser };
+};
+exports.accountsGateway = accountsGateway;

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

@@ -0,0 +1,63 @@
+import { Headers } from 'node-fetch';
+import { ConfigProviderForConfig } from '../../config';
+import { ConfigForFetch, GenericFetch, Response } from '../../fetch';
+import { AnyRoute, ApiResponse, OutputForRoute, ParamsForRoute, PayloadForRoute, QueryParams } from '../../routing';
+import { UnwrapPromise } from '../../types';
+import { Logger } from '../logger';
+declare type TResponsePayload<R> = R extends ApiResponse<any, infer P> ? P : never;
+declare type TResponseStatus<R> = R extends ApiResponse<infer S, any> ? S : never;
+declare type RouteClient<R> = {
+    (config: {
+        fetchConfig?: any;
+        query?: QueryParams;
+    } & (ParamsForRoute<R> extends undefined ? {} : {
+        params: ParamsForRoute<R>;
+    }) & (PayloadForRoute<R> extends undefined ? {} : {
+        payload: PayloadForRoute<R>;
+    })): Promise<UnsafeApiClientResponse<UnwrapPromise<OutputForRoute<R>>>>;
+    renderUrl: (config: {
+        query?: QueryParams;
+    } & (ParamsForRoute<R> extends undefined ? {} : {
+        params: ParamsForRoute<R>;
+    })) => Promise<string>;
+};
+interface AcceptStatus<Ro> {
+    <S extends TResponseStatus<Ro>[]>(...args: S): Promise<ApiClientResponse<Extract<Ro, Record<'statusCode', S[number]>>>>;
+    <S extends number[]>(...args: S): Promise<ApiClientResponse<any>>;
+}
+declare type UnsafeApiClientResponse<Ro> = {
+    headers: Headers;
+    load: () => Promise<any>;
+    status: number;
+    acceptStatus: AcceptStatus<Ro>;
+};
+declare type ApiClientResponse<Ro> = Ro extends any ? {
+    headers: Headers;
+    status: TResponseStatus<Ro>;
+    load: () => Promise<TResponsePayload<Ro>>;
+} : never;
+declare type MapRoutesToClient<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
+    [N in Ru['name']]: RouteClient<Extract<Ru, Record<'name', N>>>;
+} : never;
+declare type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
+    [N in Ru['name']]: {
+        path: string;
+        method: string;
+    };
+} : never;
+/** Pulls the content out of a response based on the content type */
+export declare const loadResponse: (response: Response) => () => Promise<any>;
+interface MakeApiGateway<F> {
+    <Ru>(config: ConfigProviderForConfig<{
+        apiBase: string;
+    }>, routes: MapRoutesToConfig<Ru>, appProvider?: {
+        authProvider?: {
+            getAuthorizedFetchConfig: () => Promise<ConfigForFetch<F>>;
+        };
+        logger?: Logger;
+    }): MapRoutesToClient<Ru>;
+}
+export declare const createApiGateway: <F extends GenericFetch<import("../../fetch").FetchConfig, Response>>(initializer: {
+    fetch: F;
+}) => MakeApiGateway<F>;
+export {};

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

@@ -0,0 +1,108 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiGateway = exports.loadResponse = void 0;
+const pathToRegexp = __importStar(require("path-to-regexp"));
+const query_string_1 = __importDefault(require("query-string"));
+const uuid_1 = require("uuid");
+const __1 = require("../..");
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const fetchStatusRetry_1 = require("../../fetch/fetchStatusRetry");
+const logger_1 = require("../logger");
+/** Pulls the content out of a response based on the content type */
+const loadResponse = (response) => () => {
+    const [contentType] = (response.headers.get('content-type') || '').split(';');
+    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, appProvider) => {
+    /* TODO this duplicates code with makeRenderRouteUrl, reuse that */
+    const renderUrl = async ({ params, query }) => {
+        const apiBase = await (0, config_1.resolveConfigValue)(config.apiBase);
+        const getPathForParams = pathToRegexp.compile(route.path, { encode: encodeURIComponent });
+        const search = query && query_string_1.default.stringify(query);
+        return apiBase.replace(/\/+$/, '') + getPathForParams(params || {}) + (search ? `?${search}` : '');
+    };
+    const routeClient = async ({ params, payload, query, fetchConfig }) => {
+        var _a, _b;
+        const { fetch } = initializer;
+        const url = await renderUrl({ params, query });
+        const body = payload ? JSON.stringify(payload) : undefined;
+        const baseOptions = (0, __1.merge)((await ((_a = appProvider === null || appProvider === void 0 ? void 0 : appProvider.authProvider) === null || _a === void 0 ? void 0 : _a.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
+        const requestId = (0, uuid_1.v4)();
+        const requestLogger = (_b = appProvider === null || appProvider === void 0 ? void 0 : appProvider.logger) === null || _b === void 0 ? void 0 : _b.createSubContext();
+        requestLogger === null || requestLogger === void 0 ? void 0 : requestLogger.setContext({ requestId, url, timeStamp: new Date().getTime() });
+        const fetcher = (0, fetchStatusRetry_1.fetchStatusRetry)(fetch, { retries: 1, status: [502], logger: requestLogger });
+        requestLogger === null || requestLogger === void 0 ? void 0 : requestLogger.log('Request Initiated', logger_1.Level.Info);
+        return fetcher(url, (0, __1.merge)(baseOptions, {
+            method: route.method,
+            body,
+            headers: {
+                ...fetchConfig === null || fetchConfig === void 0 ? void 0 : fetchConfig.headers,
+                ...(body ? { 'content-type': 'application/json' } : {}),
+                'X-Request-ID': requestId,
+            }
+        })).then(response => {
+            if (response.status === 401) {
+                throw new errors_1.UnauthorizedError();
+            }
+            if (response.status === 403) {
+                throw new errors_1.ForbiddenError();
+            }
+            if (response.status === 440) {
+                throw new errors_1.SessionExpiredError();
+            }
+            return {
+                status: response.status,
+                acceptStatus: async (...status) => {
+                    if (!status.includes(response.status)) {
+                        throw new Error(`unexpected HTTP ${response.status} response from api: ${await response.text()}`);
+                    }
+                    return { status: response.status, headers: response.headers, load: (0, exports.loadResponse)(response) };
+                },
+                headers: response.headers,
+                load: (0, exports.loadResponse)(response),
+            };
+        });
+    };
+    routeClient.renderUrl = renderUrl;
+    return routeClient;
+};
+const createApiGateway = (initializer) => (config, routes, appProvider) => {
+    return Object.fromEntries(Object.entries(routes)
+        .map(([key, routeConfig]) => ([key, makeRouteClient(initializer, config, routeConfig, appProvider)])));
+};
+exports.createApiGateway = createApiGateway;