@openstax/ts-utils 1.1.11 → 1.1.12

package/dist/guards.d.ts

@@ -1,4 +1,5 @@
 export declare const isDefined: <X>(x: X) => x is Exclude<X, undefined>;
+export declare const isNumber: (x: any) => x is number;
 export declare const isPlainObject: (thing: any) => thing is {
     [key: string]: any;
 };

package/dist/guards.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ifDefined = exports.isPlainObject = exports.isDefined = void 0;
+exports.ifDefined = exports.isPlainObject = exports.isNumber = exports.isDefined = void 0;
 /*
  * checks if a thing is defined. this is often easy to do with a simple if statement, but in certain
  * situations the guard is required and its nice to have one pre-defined.
@@ -16,6 +16,8 @@ exports.ifDefined = exports.isPlainObject = exports.isDefined = void 0;
  */
 const isDefined = (x) => x !== undefined;
 exports.isDefined = isDefined;
+const isNumber = (x) => typeof x === 'number';
+exports.isNumber = isNumber;
 /*
  * a guard for plain old javascript objects that are not based on some other prototype,
  * for example making them safe to JSON stringify and stuff

package/dist/index.d.ts

@@ -1,7 +1,13 @@
 import { UnionToIntersection } from './types';
 export declare const getKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O) => O[K];
-export declare const getKeyValueOr: <K extends string, V>(key: K, defaultValue: V) => <O extends { [key in K]?: any; }>(obj: O) => V | NonNullable<O[K]>;
+export declare const getKeyValueOr: <K extends string, V, Od extends { [key in K]?: any; } = { [key_1 in K]?: any; }>(key: K, defaultValue: V) => <O extends Od extends undefined ? { [key_2 in K]?: any; } : Od>(obj: O) => V | NonNullable<O[K]>;
 export declare const putKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O, value: O[K]) => O;
+declare type FlowFn<A, R> = (...args: [A]) => R;
+declare type AnyFlowFn = FlowFn<any, any>;
+declare type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;
+declare type FlowResult<C, A> = C extends [infer F1, ...infer Cr] ? F1 extends AnyFlowFn ? Cr extends never[] ? FlowFnResult<F1, A> : FlowResult<Cr, FlowFnResult<F1, A>> : never : never;
+declare type FlowChainArg<C> = C extends [infer F1, ...infer _] ? F1 extends FlowFn<infer A, any> ? A : never : never;
+export declare const flow: <C extends AnyFlowFn[]>(...chain: C) => (param: FlowChainArg<C>) => FlowResult<C, FlowChainArg<C>>;
 export declare const fnIf: <T1, T2>(condition: boolean, trueValue: T1, falseValue: T2) => T1 | T2;
 export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predicate?: (result: R) => boolean) => R | undefined;
 declare type HashValue = string | number | boolean | null | HashCompoundValue;

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tuple = exports.merge = exports.getCommonProperties = exports.roundToPrecision = exports.memoize = exports.partitionSequence = exports.once = exports.hashValue = exports.mapFind = exports.fnIf = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
+exports.tuple = exports.merge = exports.getCommonProperties = exports.roundToPrecision = exports.memoize = exports.partitionSequence = exports.once = exports.hashValue = exports.mapFind = exports.fnIf = exports.flow = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
 const crypto_1 = require("crypto");
 const deep_equal_1 = __importDefault(require("deep-equal"));
 const guards_1 = require("./guards");
@@ -26,6 +26,17 @@ const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
 exports.getKeyValueOr = getKeyValueOr;
 const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
 exports.putKeyValue = putKeyValue;
+/*
+ * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
+ */
+const flow = (...chain) => (param) => {
+    let result = param;
+    for (const fn of chain) {
+        result = fn(result);
+    }
+    return result;
+};
+exports.flow = flow;
 /*
  * a shameful helper to avoid needing to test code coverage of branches
  */

package/dist/profile.d.ts

@@ -0,0 +1,59 @@
+import { GenericFetch } from './fetch';
+import { ApiResponse, HttpHeaders } from './routing';
+export interface Call {
+    start: number;
+    end?: number;
+    children: Array<Profile | ProfileData>;
+}
+export declare type ProfileFunction = <Fn extends (...args: any[]) => any>(trackName: string, fn: (p: Track) => Fn) => Fn;
+export interface Track {
+    track: ProfileFunction;
+    trackFetch: <F extends GenericFetch>(fetch: F) => F;
+    setTracing: (tracing: boolean | Promise<boolean>) => void;
+    getTracing: () => Promise<undefined | boolean>;
+    data: () => Call;
+    report: () => CallReport;
+    adopt: (child: Profile) => void;
+}
+export interface ProfileData {
+    name: string;
+    calls: Call[];
+}
+export interface Profile extends ProfileData {
+    report: () => ProfileReport;
+    start: () => Track & {
+        end: () => void;
+    };
+}
+interface CallReport {
+    time: number | string;
+    children: ProfileReport[];
+    coverage: 'unknown' | {
+        accountedTime: number;
+        unaccountedTime: number;
+        accountedPercent: number;
+    };
+}
+interface ProfileReport {
+    name: string;
+    time: 'unknown' | {
+        total: number;
+        min: number;
+        max: number;
+        avg: number;
+    };
+    calls: CallReport[];
+}
+export declare const createProfile: (name: string, options?: {
+    trace?: boolean | Promise<boolean>;
+}) => Profile;
+export declare const makeProfileApiResponseMiddleware: <Ri extends {
+    headers: HttpHeaders;
+}>(showReport: (request: Ri) => string | boolean) => () => (responsePromise: Promise<ApiResponse<number, any>> | undefined, { request, profile }: {
+    request: Ri;
+    profile: Track;
+}) => Promise<ApiResponse<number, any>> | undefined;
+export declare const makeHtmlReport: (report: CallReport) => string;
+export declare const makeHtmlProfileReport: (report: ProfileReport) => string;
+export declare const makeHtmlCallReport: (report: CallReport, index: number) => string;
+export {};

package/dist/profile.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHtmlCallReport = exports.makeHtmlProfileReport = exports.makeHtmlReport = exports.makeProfileApiResponseMiddleware = exports.createProfile = void 0;
+const guards_1 = require("./guards");
+const routing_1 = require("./routing");
+const _1 = require(".");
+const callReport = (call) => {
+    const time = call.start && call.end
+        ? call.end - call.start
+        : 'unknown';
+    const children = call.children
+        .filter(profile => profile.calls.length > 0)
+        .map(profileReport);
+    const accountedTime = children.reduce((result, profile) => typeof profile.time === 'string' ? result : result + profile.time.total, 0);
+    const coverage = typeof time === 'number' && children.length > 0 ? {
+        accountedTime,
+        unaccountedTime: time - accountedTime,
+        accountedPercent: (0, _1.roundToPrecision)(accountedTime / time, -2),
+    } : 'unknown';
+    return { time, children, coverage };
+};
+const profileReport = (profile) => {
+    const calls = profile.calls.map(callReport);
+    const times = calls
+        .map(call => call.time)
+        .filter(guards_1.isNumber);
+    const time = times.length > 0 ? {
+        total: times.reduce((result, item) => result + item, 0),
+        min: Math.min(...times),
+        max: Math.max(...times),
+        avg: Math.round(times.reduce((result, item) => result + item, 0) / times.length),
+    } : 'unknown';
+    return {
+        name: profile.name, calls, time
+    };
+};
+const createProfile = (name, options = {}) => {
+    const profile = {
+        name,
+        calls: [],
+        report: () => profileReport(profile),
+        start: () => {
+            const call = { start: Date.now(), children: [] };
+            profile.calls.push(call);
+            return {
+                end: () => { call.end = Date.now(); },
+                report: () => callReport({ end: Date.now(), ...call }),
+                data: () => ({ end: Date.now(), ...call }),
+                adopt: (childProfile) => { call.children.push(childProfile); },
+                setTracing: (tracing) => { options.trace = tracing; },
+                getTracing: async () => options.trace,
+                trackFetch: (fetch) => {
+                    const trackProfile = (0, exports.createProfile)('fetch', options);
+                    call.children.push(trackProfile);
+                    return (async (url, config) => {
+                        const { end, ...track } = trackProfile.start();
+                        const fetchConfig = await options.trace
+                            ? (0, _1.merge)(config || {}, {
+                                headers: { 'x-application-profile': 'trace' }
+                            })
+                            : config;
+                        return fetch(url, fetchConfig).then(response => {
+                            const fetchProfileJson = response.headers.get('x-application-profile');
+                            const fetchProfile = fetchProfileJson ? JSON.parse(fetchProfileJson) : undefined;
+                            end();
+                            if (fetchProfile) {
+                                const subrequestProfile = (0, exports.createProfile)(url, options);
+                                subrequestProfile.calls.push(fetchProfile);
+                                track.adopt(subrequestProfile);
+                            }
+                            return response;
+                        });
+                    });
+                },
+                track: (trackName, fn) => {
+                    const trackProfile = (0, exports.createProfile)(trackName, options);
+                    call.children.push(trackProfile);
+                    return ((...args) => {
+                        const { end, ...track } = trackProfile.start();
+                        const result = fn(track)(...args);
+                        if (result instanceof Promise) {
+                            return result.finally(() => { end(); });
+                        }
+                        else {
+                            end();
+                            return result;
+                        }
+                    });
+                }
+            };
+        },
+    };
+    return profile;
+};
+exports.createProfile = createProfile;
+const makeProfileApiResponseMiddleware = (showReport) => () => (responsePromise, { request, profile }) => {
+    if (responsePromise) {
+        return responsePromise.then(async (response) => {
+            const reportFormat = showReport(request);
+            const enabled = await profile.getTracing();
+            // profiling is disabled, return original response
+            if (!enabled) {
+                return response;
+            }
+            // there is no report format, return original response but
+            // add sub-request trace response if necessary
+            if (reportFormat === false) {
+                if ((0, routing_1.getHeader)(request.headers, 'x-application-profile')) {
+                    return {
+                        ...response,
+                        headers: {
+                            ...response.headers,
+                            'x-application-profile': JSON.stringify(profile.data())
+                        }
+                    };
+                }
+                return response;
+                // override response with html report
+            }
+            else if (reportFormat === 'html') {
+                return (0, routing_1.apiHtmlResponse)(200, (0, exports.makeHtmlReport)(profile.report()));
+            }
+            // override response with json report
+            return (0, routing_1.apiJsonResponse)(200, profile.report());
+        });
+    }
+    return responsePromise;
+};
+exports.makeProfileApiResponseMiddleware = makeProfileApiResponseMiddleware;
+const makeHtmlReport = (report) => `
+<head>
+  <style>
+    table {
+      border-collapse: collapse;
+    }
+    table td,th {
+      border: 1px solid #ccc;
+      padding: 10px;
+    }
+    summary {
+      padding: 10px 0;
+    }
+  </style>
+</head>
+<body>
+  ${(0, exports.makeHtmlCallReport)(report, 0)}
+</body>
+`;
+exports.makeHtmlReport = makeHtmlReport;
+const makeHtmlProfileReport = (report) => `
+<details>
+  <summary>Profile: ${report.name}</summary>
+  <table>
+    <thead>
+      <tr>
+        <th>call #</th>
+        <th>children</th>
+        <th>time</th>
+        <th>time coverage (accounted/unaccounted/percent)</th>
+      </tr>
+    </thead>
+    <tbody>
+      ${report.calls.map((call, i) => `<tr>
+        <td>${i + 1}</td>
+        <td>${call.children.length}</td>
+        <td>${call.time}</td>
+        <td>${typeof call.coverage === 'string' ? call.coverage : `${call.coverage.accountedTime}/${call.coverage.unaccountedTime}/${call.coverage.accountedPercent}`}</td>
+      </tr>`)}
+    </tbody>
+  </table>
+  <div style="padding-left: 20px; border-left: 1px solid #ccc;">
+    ${report.calls.map(exports.makeHtmlCallReport).join('')}
+  </div>
+</details>
+`;
+exports.makeHtmlProfileReport = makeHtmlProfileReport;
+const makeHtmlCallReport = (report, index) => `
+<h4>call # ${index + 1} children<h4>
+<table>
+  <thead>
+    <tr>
+      <th>name</th>
+      <th>calls</th>
+      <th>time (total (min/max/avg))</th>
+    </tr>
+  </thead>
+  <tbody>
+    ${report.children.map(profile => `<tr>
+      <td>${profile.name}</td>
+      <td>${profile.calls.length}</td>
+      <td>${typeof profile.time === 'string' ? profile.time : `${profile.time.total} (${profile.time.min}/${profile.time.max}/${profile.time.avg})`}</td>
+    </tr>`).join('')}
+  </tbody>
+</table>
+<div style="margin-left: 20px">
+  ${report.children.map(exports.makeHtmlProfileReport).join('')}
+</div>
+`;
+exports.makeHtmlCallReport = makeHtmlCallReport;

package/dist/routing.d.ts

@@ -1,3 +1,4 @@
+import { Track } from './profile';
 export declare type QueryParams = Record<string, string | undefined>;
 export declare type RouteParams = {
     [key: string]: string;
@@ -17,6 +18,7 @@ export declare type PayloadForRoute<R> = RequestServicesForRoute<R> extends {
 } ? RequestServicesForRoute<R>['payload'] : undefined;
 declare type RequestServiceProvider<Sa, Sr, Ri> = (app: Sa) => <R>(middleware: {
     request: Ri;
+    profile: Track;
 }, 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 ? {
@@ -51,7 +53,10 @@ declare type RequestPathExtractor<Ri> = (request: Ri) => string;
 declare type RequestRouteMatcher<Ri, R> = (request: Ri, route: R) => boolean;
 declare type RequestResponder<Sa, Ri, Ro> = {
     (services: Sa): (request: Ri) => Ro | undefined;
-    <RoF>(services: Sa, responseMiddleware: (app: Sa) => (response: Ro | undefined, request: Ri) => RoF): (request: Ri) => RoF;
+    <RoF>(services: Sa, responseMiddleware: (app: Sa) => (response: Ro | undefined, request: {
+        request: Ri;
+        profile: Track;
+    }) => RoF): (request: Ri) => RoF;
 };
 export declare const makeGetRequestResponder: <Sa, Ru, Ri, Ro>() => ({ routes, pathExtractor, routeMatcher, errorHandler }: {
     routes: () => AnySpecificRoute<Ru, Sa, Ri, Ro>[];
@@ -77,6 +82,7 @@ export declare type ApiResponse<S extends number, T> = {
 };
 export declare const apiJsonResponse: <S extends number, T extends JsonCompatibleStruct>(statusCode: S, data: T, headers?: HttpHeaders | undefined) => ApiResponse<S, T>;
 export declare const apiTextResponse: <S extends number>(statusCode: S, data: string, headers?: HttpHeaders | undefined) => ApiResponse<S, string>;
+export declare const apiHtmlResponse: <S extends number>(statusCode: S, data: string, headers?: HttpHeaders | undefined) => ApiResponse<S, string>;
 export declare enum METHOD {
     GET = "GET",
     HEAD = "HEAD",

package/dist/routing.js

@@ -26,12 +26,13 @@ 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;
+exports.requestPayloadProvider = exports.unsafePayloadValidator = exports.getRequestBody = exports.getHeader = 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 assertions_1 = require("./assertions");
 const errors_1 = require("./errors");
 const guards_1 = require("./guards");
+const profile_1 = require("./profile");
 const _1 = require(".");
 /*
  * route definition helper. the only required params of the route are the name, path, and handler. other params
@@ -92,11 +93,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) => {
+    return (request, profile) => {
         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);
+            return profile.track(route.name, routeProfile => () => route.handler(match.params, boundServiceProvider ? boundServiceProvider({ request, profile: routeProfile }, { route, params: match.params }) : undefined));
         }
     };
 };
@@ -127,20 +128,21 @@ const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, er
     // *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
+    // 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 { end, ...profile } = (0, profile_1.createProfile)(new Date().toISOString()).start();
         try {
-            const executor = (0, _1.mapFind)(boundRoutes, (route) => route(request));
+            const executor = (0, _1.mapFind)(boundRoutes, (route) => route(request, profile));
             if (executor) {
                 const result = boundResponseMiddleware ?
-                    boundResponseMiddleware(executor(), request) : executor();
+                    boundResponseMiddleware(executor(), { request, profile }) : executor();
                 if (isPromise(result) && errorHandler) {
                     const errorHandlerWithMiddleware = (e) => boundResponseMiddleware ?
-                        boundResponseMiddleware(errorHandler(e), request) : errorHandler(e);
+                        boundResponseMiddleware(errorHandler(e), { request, profile }) : errorHandler(e);
                     return result.catch(errorHandlerWithMiddleware);
                 }
                 else {
@@ -148,12 +150,12 @@ const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, er
                 }
             }
             else if (boundResponseMiddleware) {
-                return boundResponseMiddleware(undefined, request);
+                return boundResponseMiddleware(undefined, { request, profile });
             }
         }
         catch (e) {
             if (errorHandler && e instanceof Error) {
-                return boundResponseMiddleware ? boundResponseMiddleware(errorHandler(e), request) : errorHandler(e);
+                return boundResponseMiddleware ? boundResponseMiddleware(errorHandler(e), { request, profile }) : errorHandler(e);
             }
             throw e;
         }
@@ -165,6 +167,8 @@ const apiJsonResponse = (statusCode, data, headers) => ({ statusCode, data, body
 exports.apiJsonResponse = apiJsonResponse;
 const apiTextResponse = (statusCode, data, headers) => ({ statusCode, data, body: data, headers: { ...headers, 'content-type': 'text/plain' } });
 exports.apiTextResponse = apiTextResponse;
+const apiHtmlResponse = (statusCode, data, headers) => ({ statusCode, data, body: data, headers: { ...headers, 'content-type': 'text/html' } });
+exports.apiHtmlResponse = apiHtmlResponse;
 var METHOD;
 (function (METHOD) {
     METHOD["GET"] = "GET";

package/dist/services/authProvider/decryption.js

@@ -23,16 +23,16 @@ const decryptionAuthProvider = (initializer) => (configProvider) => {
             return undefined;
         }
     };
-    return (request) => {
+    return ({ request, profile }) => {
         let user;
-        const getAuthorizedFetchConfig = async () => {
+        const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
             const [token, headers] = (0, _1.getAuthTokenOrCookie)(request, await cookieName);
             if (!token) {
                 return {};
             }
             return { headers };
-        };
-        const loadUser = async () => {
+        });
+        const loadUser = profile.track('loadUser', () => async () => {
             const [token] = (0, _1.getAuthTokenOrCookie)(request, await cookieName);
             if (!token) {
                 return undefined;
@@ -49,7 +49,7 @@ const decryptionAuthProvider = (initializer) => (configProvider) => {
                 return undefined;
             }
             return jwt.sub;
-        };
+        });
         return {
             getAuthorizedFetchConfig,
             getUser: async () => {

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

@@ -1,14 +1,16 @@
 import { FetchConfig } from '../../fetch';
+import { Track } from '../../profile';
 import { HttpHeaders } from '../../routing';
 export interface User {
+    id: number;
     name: string;
     first_name: string;
     last_name: string;
     full_name: string;
     uuid: string;
     faculty_status: string;
-    is_administrator: string;
-    is_not_gdpr_location: string;
+    is_administrator: boolean;
+    is_not_gdpr_location: boolean;
     contact_infos: Array<{
         type: string;
         value: string;
@@ -27,7 +29,10 @@ export declare type CookieAuthProviderRequest = {
     headers: HttpHeaders;
     cookies?: string[];
 };
-export declare type CookieAuthProvider = (request: CookieAuthProviderRequest) => AuthProvider;
+export declare type CookieAuthProvider = (inputs: {
+    request: CookieAuthProviderRequest;
+    profile: Track;
+}) => AuthProvider;
 export declare type StubAuthProvider = (user: User | undefined) => AuthProvider;
 export declare const stubAuthProvider: (user?: User | undefined) => AuthProvider;
 export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest, cookieName: string) => [string, {

package/dist/services/authProvider/subrequest.js

@@ -8,23 +8,23 @@ 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) => {
+    return ({ request, profile }) => {
         let user;
-        const getAuthorizedFetchConfig = async () => {
+        const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
             const [token, headers] = (0, _1.getAuthTokenOrCookie)(request, await cookieName);
             if (!token) {
                 return {};
             }
             return { headers };
-        };
-        const loadUser = async () => {
+        });
+        const loadUser = profile.track('loadUser', p => async () => {
             const [token, headers] = (0, _1.getAuthTokenOrCookie)(request, await cookieName);
             if (!token) {
                 return undefined;
             }
-            return initializer.fetch(await accountsUrl, { headers })
+            return p.trackFetch(initializer.fetch)(await accountsUrl, { headers })
                 .then(response => response.json());
-        };
+        });
         return {
             getAuthorizedFetchConfig,
             getUser: async () => {

package/dist/services/versionedDocumentStore/dynamodb.d.ts

@@ -1,4 +1,5 @@
 import { ConfigProviderForConfig } from '../../config';
+import { Track } from '../../profile';
 import { TDocument, VersionedDocumentAuthor } from '.';
 declare type DynamoConfig = {
     tableName: string;
@@ -8,7 +9,9 @@ interface Initializer<C> {
 }
 export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
     tableName: import("../../config").ConfigValueProvider<string>;
-}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(hashKey: K, getAuthor: A) => {
+}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>({ profile }: {
+    profile: Track;
+}, hashKey: K, getAuthor: A) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
         items: T[];

package/dist/services/versionedDocumentStore/dynamodb.js

@@ -51,11 +51,11 @@ const decodeDynamoAttribute = (value) => {
 };
 const decodeDynamoDocument = (document) => Object.fromEntries(Object.entries(document).map(([key, value]) => ([key, decodeDynamoAttribute(value)])));
 // i'm not really excited about getAuthor being required, but ts is getting confused about the type when unspecified
-const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => (hashKey, getAuthor) => {
+const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => ({ profile }, hashKey, getAuthor) => {
     const options = (0, guards_1.ifDefined)(initializer, {});
     const tableName = (0, config_1.resolveConfigValue)(configProvider[(0, guards_1.ifDefined)(options.configSpace, 'dynamodb')].tableName);
     return {
-        loadAllDocumentsTheBadWay: async () => {
+        loadAllDocumentsTheBadWay: profile.track('versionedDocumentStore.loadAllDocumentsTheBadWay', () => async () => {
             const loadAllResults = async (ExclusiveStartKey) => {
                 var _a;
                 const cmd = new client_dynamodb_1.ScanCommand({ TableName: await tableName, ExclusiveStartKey });
@@ -74,8 +74,8 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
                 return result;
             }, new Map()));
             return Array.from(allResults.values());
-        },
-        getVersions: async (id, startVersion) => {
+        }),
+        getVersions: profile.track('versionedDocumentStore.getVersions', () => async (id, startVersion) => {
             const cmd = new client_dynamodb_1.QueryCommand({
                 TableName: await tableName,
                 KeyConditionExpression: '#hk = :hkv',
@@ -104,8 +104,8 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
                     nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
                 };
             });
-        },
-        getItem: async (id, timestamp) => {
+        }),
+        getItem: profile.track('versionedDocumentStore.getItem', () => async (id, timestamp) => {
             let keyConditionExpression = '#hk = :hkv';
             const expressionAttributeNames = {
                 '#hk': hashKey.toString()
@@ -130,8 +130,8 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
                 var _a;
                 return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
             });
-        },
-        putItem: async (item, ...authorArgs) => {
+        }),
+        putItem: profile.track('versionedDocumentStore.putItem', () => async (item, ...authorArgs) => {
             // this getAuthor type is terrible
             const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
             const document = {
@@ -145,7 +145,7 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
             });
             return dynamodb().send(cmd)
                 .then(() => document);
-        },
+        }),
     };
 };
 exports.dynamoVersionedDocumentStore = dynamoVersionedDocumentStore;

package/dist/services/versionedDocumentStore/file-system.d.ts

@@ -1,4 +1,5 @@
 import { ConfigProviderForConfig } from '../../config';
+import { Track } from '../../profile';
 import { TDocument, VersionedDocumentAuthor } from '.';
 declare type Config = {
     tableName: string;
@@ -10,7 +11,9 @@ interface Initializer<C> {
 }
 export declare const fileSystemVersionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
     tableName: import("../../config").ConfigValueProvider<string>;
-}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(hashKey: K, getAuthor: A) => {
+}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>({ profile }: {
+    profile: Track;
+}, hashKey: K, getAuthor: A) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
         items: T[];