@openstax/ts-utils 1.0.0

package/dist/routing.js

@@ -0,0 +1,237 @@
+"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.requestPayloadProvider = exports.unsafePayloadValidator = exports.getRequestBody = exports.getHeader = exports.METHOD = 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 assertions_1 = require("./assertions");
+const errors_1 = require("./errors");
+const guards_1 = require("./guards");
+const _1 = require(".");
+/*
+ * 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
+ * the request input format is defined, the result format is derived from the routes.
+ *
+ * eg:
+ *   export const createRoute = makeCreateRoute<AppServices, ApiRouteRequest, {
+ *     method: METHOD;
+ *   }>();
+ *
+ * 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: requestServiceProvider({
+ *       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 */
+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;
+exports.renderAnyRouteUrl = (0, exports.makeRenderRouteUrl)();
+const bindRoute = (services, pathExtractor, matcher) => (route) => {
+    const getParamsFromPath = pathToRegexp.match(route.path, { decode: decodeURIComponent });
+    const boundServiceProvider = route.requestServiceProvider && route.requestServiceProvider(services);
+    return (request) => {
+        const path = pathExtractor(request);
+        const match = getParamsFromPath(path);
+        if ((!matcher || matcher(request, route)) && match) {
+            return () => route.handler(match.params, boundServiceProvider ? boundServiceProvider({ request }, { route, params: match.params }) : undefined);
+        }
+    };
+};
+/*
+ * here 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.
+ *
+ * eg:
+ *   export const getRequestResponder = makeGetRequestResponder<AppServices, TRoutes, ApiRouteRequest, Promise<ApiRouteResponse>>()({
+ *     routes: apiRoutes, // the route definitions
+ *     pathExtractor, // how to get the path out of the request format
+ *     routeMatcher, // logic for matching route (if there is any in addition to the path matching)
+ *     errorHandler, // any special error handling
+ *   });
+ *
+ * eg an 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 }) => (services, responseMiddleware) => {
+    const boundRoutes = routes().map(bindRoute(services, 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.
+    //
+    // its less than ideal than 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) => {
+        try {
+            const executor = (0, _1.mapFind)(boundRoutes, (route) => route(request));
+            if (executor) {
+                const result = boundResponseMiddleware ?
+                    boundResponseMiddleware(executor(), request) : executor();
+                if (isPromise(result) && errorHandler) {
+                    const errorHandlerWithMiddleware = (e) => boundResponseMiddleware ?
+                        boundResponseMiddleware(errorHandler(e), request) : errorHandler(e);
+                    return result.catch(errorHandlerWithMiddleware);
+                }
+                else {
+                    return result;
+                }
+            }
+            else if (boundResponseMiddleware) {
+                return boundResponseMiddleware(undefined, request);
+            }
+        }
+        catch (e) {
+            if (errorHandler && e instanceof Error) {
+                return boundResponseMiddleware ? boundResponseMiddleware(errorHandler(e), request) : errorHandler(e);
+            }
+            throw e;
+        }
+        return undefined;
+    };
+};
+exports.makeGetRequestResponder = makeGetRequestResponder;
+const apiJsonResponse = (statusCode, data, headers) => ({ statusCode, data, body: JSON.stringify(data), headers: { ...headers, 'content-type': 'application/json' } });
+exports.apiJsonResponse = apiJsonResponse;
+const apiTextResponse = (statusCode, data, headers) => ({ statusCode, data, body: data, headers: { ...headers, 'content-type': 'text/plain' } });
+exports.apiTextResponse = apiTextResponse;
+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 = {}));
+/* utils and middleware for loading request payload (must follow this pattern for `PayloadForRoute` to work) */
+// use this to support case insensitive header keys
+const getHeader = (headers, name) => {
+    const key = Object.keys(headers).find(header => header.toLowerCase() === name.toLowerCase());
+    return key ? headers[key] : undefined;
+};
+exports.getHeader = getHeader;
+const getRequestBody = (request) => {
+    if ((0, exports.getHeader)(request.headers, 'content-type') !== 'application/json') {
+        throw new errors_1.InvalidRequestError('unknown content type: ' + (0, exports.getHeader)(request.headers, 'content-type'));
+    }
+    if (!request.body) {
+        return {};
+    }
+    try {
+        return JSON.parse(request.body);
+    }
+    catch (error) {
+        // Since the body is provided by the user, invalid JSON in the body is an invalid request
+        // We return the message which tells them why the JSON is invalid, but no backtrace
+        throw new errors_1.InvalidRequestError((0, assertions_1.assertErrorInstanceOf)(error, SyntaxError).message);
+    }
+};
+exports.getRequestBody = getRequestBody;
+// stub validator because writing validators is annoying
+const unsafePayloadValidator = () => (input) => {
+    return (0, guards_1.isPlainObject)(input) && Object.keys(input).length > 0;
+};
+exports.unsafePayloadValidator = unsafePayloadValidator;
+/*
+ * the given validator is a guard, which provides the correct type this helper loads the body, runs the validator, throws if it isn't valid, or returns it as
+ * the correct type if it is valid.
+ *
+ * this accomplishes a few things:
+ *   - establishes type of payload for route body logic
+ *   - validates the payload for route logic
+ *   - establishes type of payload for client logic calling this route
+ *
+ * eg:
+ *   export const exampleRoute = createRoute({name: 'exampleRoute', method: METHOD.POST, path: '/example/:id',
+ *     requestServiceProvider: composeServiceMiddleware(
+ *       requestServiceProvider, // previously compiled middleware can be re-composed if you have something to add
+ *       requestPayloadProvider(validatePayload)
+ *     )},
+ *     async(params: {id: string}, services) => {
+ *       const result = await services.myDocumentStore.putItem({
+ *         ...services.payload,
+ *         id: params.id,
+ *       });
+ *       return apiJsonResponse(201, result);
+ *     }
+ *   );
+ * */
+const requestPayloadProvider = (validator) => () => (requestServices) => {
+    const payload = (0, exports.getRequestBody)(requestServices.request);
+    // for more precise error messages, throw your own InvalidRequestError from your validator function
+    if (!validator(payload)) {
+        throw new errors_1.InvalidRequestError();
+    }
+    return { ...requestServices, payload };
+};
+exports.requestPayloadProvider = requestPayloadProvider;

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

@@ -0,0 +1,61 @@
+import { ConfigProviderForConfig } from '../../config';
+import { ConfigForFetch, GenericFetch } 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;
+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): ApiClientResponse<Extract<Ro, Record<'statusCode', S[number]>>>;
+    <S extends number[]>(...args: S): ApiClientResponse<any>;
+}
+declare type UnsafeApiClientResponse<Ro> = {
+    load: () => Promise<any>;
+    status: number;
+    acceptStatus: AcceptStatus<Ro>;
+};
+declare type ApiClientResponse<Ro> = Ro extends any ? {
+    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;
+interface MakeApiGateway<F> {
+    <Ru>(config: ConfigProviderForConfig<{
+        apiBase: string;
+    }>, routes: MapRoutesToConfig<Ru>, authProvider?: {
+        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: {
+    fetch: F;
+}) => MakeApiGateway<F>;
+export {};

package/dist/services/apiGateway/index.js

@@ -0,0 +1,70 @@
+"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 = 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 makeRouteClient = (initializer, config, route, authProvider) => {
+    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 }) => {
+        const url = await renderUrl({ params, query });
+        const body = payload ? JSON.stringify(payload) : undefined;
+        const baseOptions = (0, __1.merge)((authProvider === null || authProvider === void 0 ? void 0 : authProvider.getAuthorizedFetchConfig()) || {}, fetchConfig || {});
+        return initializer.fetch(url, (0, __1.merge)(baseOptions, {
+            method: route.method,
+            body,
+            headers: {
+                ...fetchConfig === null || fetchConfig === void 0 ? void 0 : fetchConfig.headers,
+                ...(body ? { 'content-type': 'application/json' } : {}),
+            }
+        })).then(response => ({
+            status: response.status,
+            acceptStatus: (...status) => {
+                if (!status.includes(response.status)) {
+                    throw new Error('unexpected response from api');
+                }
+                return { status: response.status, load: () => response.json() };
+            },
+            load: () => response.json(),
+        }));
+    };
+    routeClient.renderUrl = renderUrl;
+    return routeClient;
+};
+const createApiGateway = (initializer) => (config, routes, authProvider) => {
+    return Object.fromEntries(Object.entries(routes)
+        .map(([key, routeConfig]) => ([key, makeRouteClient(initializer, config, routeConfig, authProvider)])));
+};
+exports.createApiGateway = createApiGateway;

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

@@ -0,0 +1,17 @@
+import { ConfigProviderForConfig } from '../../config';
+import { FetchConfig, GenericFetch } from '../../fetch';
+import { User } from '.';
+declare type Config = {
+    accountsUrl: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare const browserAuthProvider: <C extends string = "auth">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    accountsUrl: import("../../config").ConfigValueProvider<string>;
+}; }) => (queryString?: string) => {
+    getAuthorizedFetchConfig: () => FetchConfig;
+    getUser: () => Promise<User | undefined>;
+};
+export {};

package/dist/services/authProvider/browser.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserAuthProvider = void 0;
+const __1 = require("../..");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const browserAuthProvider = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'auth')];
+    const accountsUrl = (0, config_1.resolveConfigValue)(config.accountsUrl);
+    return (queryString = '') => {
+        const token = new URLSearchParams(queryString).get('auth');
+        // *note* that this does not actually prevent cookies from being sent on same-origin
+        // requests, i'm not sure if its possible to stop browsers from sending cookies in
+        // that case
+        const getAuthorizedFetchConfig = () => token ? {
+            headers: { Authorization: `Bearer ${token}` },
+        } : {
+            credentials: 'include',
+        };
+        const getUser = (0, __1.once)(async () => {
+            return initializer.fetch((await accountsUrl).replace(/\/+$/, '') + '/accounts/api/user', getAuthorizedFetchConfig())
+                .then(response => response.status === 200 ? response.json() : undefined);
+        });
+        return {
+            getAuthorizedFetchConfig,
+            getUser
+        };
+    };
+};
+exports.browserAuthProvider = browserAuthProvider;

package/dist/services/authProvider/decryption.d.ts

@@ -0,0 +1,16 @@
+import { ConfigProviderForConfig } from '../../config';
+import { CookieAuthProvider } from '.';
+declare type Config = {
+    cookieName: string;
+    encryptionPrivateKey: string;
+    signaturePublicKey: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+}
+export declare const decryptionAuthProvider: <C extends string = "decryption">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    cookieName: import("../../config").ConfigValueProvider<string>;
+    encryptionPrivateKey: import("../../config").ConfigValueProvider<string>;
+    signaturePublicKey: import("../../config").ConfigValueProvider<string>;
+}; }) => CookieAuthProvider;
+export {};

package/dist/services/authProvider/decryption.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptionAuthProvider = void 0;
+const jose_1 = require("jose");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const _1 = require(".");
+const decryptionAuthProvider = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'decryption')];
+    const cookieName = (0, config_1.resolveConfigValue)(config.cookieName);
+    const encryptionPrivateKey = (0, config_1.resolveConfigValue)(config.encryptionPrivateKey);
+    const signaturePublicKey = (0, config_1.resolveConfigValue)(config.signaturePublicKey);
+    const decryptAndVerify = async (jwt) => {
+        try {
+            // Decrypt SSO cookie
+            const { plaintext } = await (0, jose_1.compactDecrypt)(jwt, Buffer.from(await encryptionPrivateKey), // Note: Buffer.from() is node-js only
+            { contentEncryptionAlgorithms: ['A256GCM'], keyManagementAlgorithms: ['dir'] });
+            // Verify SSO cookie signature
+            const { payload } = await (0, jose_1.compactVerify)(plaintext, await (0, jose_1.importSPKI)(await signaturePublicKey, 'RS256'), { algorithms: ['RS256'] });
+            return payload;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return (request) => {
+        let user;
+        const loadUser = async () => {
+            const token = (0, _1.getAuthTokenOrCookie)(request, await cookieName);
+            if (!token) {
+                return undefined;
+            }
+            const payload = await decryptAndVerify(token);
+            if (!payload) {
+                return undefined;
+            }
+            // Note: Uint8Array.toString() returns text in node-js only
+            //       The browser version is new TextDecoder().decode(payload)
+            const jwt = JSON.parse(payload.toString());
+            // Allow clock skew up to 5 minutes
+            if (!jwt.sub || !jwt.sub.uuid || (jwt.exp && jwt.exp < Math.floor(Date.now() / 1000) - 300)) {
+                return undefined;
+            }
+            return jwt.sub;
+        };
+        return {
+            getUser: async () => {
+                if (!user) {
+                    user = await loadUser();
+                }
+                return user;
+            }
+        };
+    };
+};
+exports.decryptionAuthProvider = decryptionAuthProvider;

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

@@ -0,0 +1,37 @@
+import { HttpHeaders } from '../../routing';
+export interface User {
+    name: string;
+    first_name: string;
+    last_name: string;
+    full_name: string;
+    uuid: string;
+    faculty_status: string;
+    is_administrator: string;
+    is_not_gdpr_location: string;
+    contact_infos: Array<{
+        type: string;
+        value: string;
+        is_verified: boolean;
+        is_guessed_preferred: boolean;
+    }>;
+}
+export declare type AuthProvider = {
+    getUser: () => Promise<User | undefined>;
+};
+export declare type CookieAuthProviderRequest = {
+    headers: HttpHeaders;
+    cookies?: string[];
+};
+export declare type CookieAuthProvider = (request: CookieAuthProviderRequest) => AuthProvider;
+export declare type StubAuthProvider = (user: User | undefined) => AuthProvider;
+export declare const stubAuthProvider: (user?: User | undefined) => {
+    getUser: () => Promise<User | undefined>;
+    getAuthorizedFetchConfig: () => {
+        headers: {
+            Authorization: string;
+        };
+    } | {
+        headers?: undefined;
+    };
+};
+export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest, cookieName: string) => string;

package/dist/services/authProvider/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthTokenOrCookie = exports.stubAuthProvider = void 0;
+const cookie_1 = __importDefault(require("cookie"));
+const routing_1 = require("../../routing");
+const stubAuthProvider = (user) => ({ getUser: () => Promise.resolve(user), getAuthorizedFetchConfig: () => (user ? { headers: { Authorization: user.uuid } } : {}) });
+exports.stubAuthProvider = stubAuthProvider;
+const getAuthTokenOrCookie = (request, cookieName) => {
+    var _a;
+    const authHeader = (0, routing_1.getHeader)(request.headers, 'authorization');
+    return authHeader && authHeader.length >= 8 && authHeader.startsWith('Bearer ') ?
+        authHeader.slice(7) : cookie_1.default.parse(((_a = request.cookies) === null || _a === void 0 ? void 0 : _a.join('; ')) || '')[cookieName];
+};
+exports.getAuthTokenOrCookie = getAuthTokenOrCookie;

package/dist/services/authProvider/subrequest.d.ts

@@ -0,0 +1,16 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { CookieAuthProvider } from '.';
+declare type Config = {
+    cookieName: string;
+    accountsUrl: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare const subrequestAuthProvider: <C extends string = "subrequest">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    cookieName: import("../../config").ConfigValueProvider<string>;
+    accountsUrl: import("../../config").ConfigValueProvider<string>;
+}; }) => CookieAuthProvider;
+export {};

package/dist/services/authProvider/subrequest.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subrequestAuthProvider = void 0;
+const cookie_1 = __importDefault(require("cookie"));
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const _1 = require(".");
+const subrequestAuthProvider = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'subrequest')];
+    const cookieName = (0, config_1.resolveConfigValue)(config.cookieName);
+    const accountsUrl = (0, config_1.resolveConfigValue)(config.accountsUrl);
+    return (request) => {
+        let user;
+        const loadUser = async () => {
+            const token = (0, _1.getAuthTokenOrCookie)(request, await cookieName);
+            if (!token) {
+                return undefined;
+            }
+            return initializer.fetch(await accountsUrl, {
+                headers: {
+                    cookie: cookie_1.default.serialize(await cookieName, token)
+                }
+            })
+                .then(response => response.json());
+        };
+        return {
+            getUser: async () => {
+                if (!user) {
+                    user = await loadUser();
+                }
+                return user;
+            }
+        };
+    };
+};
+exports.subrequestAuthProvider = subrequestAuthProvider;