@openstax/ts-utils 1.7.0 → 1.8.0

package/dist/cjs/types.d.ts

@@ -7,6 +7,10 @@
  * There may be a better way to do this; `T1 extends T2` doesn't work
  */
 export declare type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? T1Head extends T2Head ? TupleExtends<T1Tail, T2Tail> extends 'yes' ? 'yes' : 'no' : 'no' : T2 extends [] ? 'yes' : 'no' : T1 extends [] ? T2 extends [] ? 'yes' : 'no' : 'no';
+/**
+ * unions each member of the tuple
+ */
+export declare type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>] : T2 extends [] ? T1 : never : T1 extends [] ? T2 extends any[] ? T2 : never : never;
 /**
  * If `R` is `Promise<I>`, returns `I`, otherwise returns `R`
  * @deprecated use TypeScript builtin Awaited instead:

package/dist/esm/{fetch.d.ts → fetch/index.d.ts}

@@ -1,4 +1,4 @@
-import { METHOD } from './routing';
+import { METHOD } from '../routing';
 export declare enum FetchStateType {
     SUCCESS = "success",
     ERROR = "error",

package/dist/{cjs/middleware.d.ts → esm/middleware/index.d.ts}

@@ -1,11 +1,11 @@
-import { TupleExtends } from './types';
+import { TupleZip } from '../types';
 export declare type MiddlewareProvider<Sa, M, A extends any[], R> = (app: Sa, appBinder?: ((app: Sa, provider: MiddlewareProvider<Sa, M, A, R>) => (middleware: M, ...args: A) => R)) => (middleware: M, ...args: A) => R;
 export declare type MiddlewareTransformProvider<Sa, M, A extends any[], R> = (app: Sa) => (middleware: M, ...args: A) => Omit<M, keyof R> & R;
 export declare type MiddlewareInput<S> = S extends MiddlewareProvider<any, infer M, any, any> ? M : never;
 export declare type ServiceMiddlewareProviderResult<M, S> = [M] extends [never] ? never : [M] extends [MiddlewareInput<S>] ? S extends MiddlewareTransformProvider<any, M, any, infer R> ? (Omit<R, keyof M> & M) extends R ? Omit<R, keyof M> & M : R extends M ? R : Omit<M, keyof R> & R : S extends MiddlewareProvider<any, M, any, infer R> ? R : never : never;
 export declare type ServiceMiddlewareProviderArgs<S> = S extends MiddlewareProvider<any, any, infer A, any> ? A : never;
 export declare type ServiceMiddlewareProviderChainResult<C, M> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderResult<M, S1> : ServiceMiddlewareProviderChainResult<S, ServiceMiddlewareProviderResult<M, S1>> : C extends unknown ? M : never;
-export declare type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderArgs<S1> : TupleExtends<ServiceMiddlewareProviderChainArgs<S>, ServiceMiddlewareProviderArgs<S1>> extends 'yes' ? ServiceMiddlewareProviderChainArgs<S> : TupleExtends<ServiceMiddlewareProviderArgs<S1>, ServiceMiddlewareProviderChainArgs<S>> extends 'yes' ? ServiceMiddlewareProviderArgs<S1> : never : C extends unknown ? [] : never;
+export declare type ServiceMiddlewareProviderChainArgs<C> = C extends [infer S1, ...infer S] ? S extends never[] ? ServiceMiddlewareProviderArgs<S1> : TupleZip<ServiceMiddlewareProviderChainArgs<S>, ServiceMiddlewareProviderArgs<S1>> : C extends unknown ? [] : never;
 /**
  * Creates a middleware composer for given AppServices and input value types. The composer accepts a list of middleware
  * that it assembles into a chain. The function returned by the composer takes a value of the given input value type,

package/dist/esm/{pagination.d.ts → pagination/index.d.ts}

@@ -1,4 +1,4 @@
-import { QueryParams, RouteMatchRecord } from './routing';
+import { QueryParams, RouteMatchRecord } from '../routing';
 export declare type PaginationHandler<Pa, Q extends QueryParams> = <R>(queryParams: Q, match: RouteMatchRecord<R>) => Pa & {
     getUnusedQueryParams: () => Q;
 };

package/dist/esm/{pagination.js → pagination/index.js}

@@ -1,6 +1,6 @@
-import { notNaN } from './assertions';
-import { InvalidRequestError } from './errors';
-import { renderAnyRouteUrl } from './routing';
+import { notNaN } from '../assertions';
+import { InvalidRequestError } from '../errors';
+import { renderAnyRouteUrl } from '../routing';
 /**
  * helper to create middleware with the given paginator. aside from taking care of annoying to write pagination logic, these helpers also make
  * sure that all item list responses have the same formatting.

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

@@ -1,4 +1,3 @@
-import { Track } from '../profile';
 import { Logger } from '../services/logger';
 /** HTTP query parameters */
 export declare type QueryParams = Record<string, string | undefined | string[] | null>;
@@ -35,7 +34,6 @@ 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;
     logger: Logger;
 }, match: RouteMatchRecord<R>) => Sr;
 declare type RouteHandler<P, Sr, Ro> = (params: P, request: Sr) => Ro;
@@ -168,7 +166,6 @@ declare type RequestResponder<Sa, Ri, Ro> = {
     (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;
 };

package/dist/esm/routing/index.js

@@ -1,7 +1,6 @@
 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';
 /**
  * Makes a createRoute function that can be used to create routes (this is a factory factory). The
@@ -102,11 +101,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, logger) => {
+    return (request, 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, logger }, { route, params: match.params }) : undefined));
+            return () => route.handler(match.params, boundServiceProvider ? boundServiceProvider({ request, logger }, { route, params: match.params }) : undefined);
         }
     };
 };
@@ -155,19 +154,18 @@ export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatc
     // types are getting complicated quickly here.
     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, logger));
+            const executor = mapFind(boundRoutes, (route) => route(request, logger));
             if (executor) {
                 const result = boundResponseMiddleware ?
-                    boundResponseMiddleware(executor(), { request, profile, logger }) : executor();
+                    boundResponseMiddleware(executor(), { request, logger }) : executor();
                 if (isPromise(result) && errorHandler) {
                     const errorHandlerWithMiddleware = (e) => boundResponseMiddleware ?
-                        boundResponseMiddleware(errorHandler(e, logger), { request, profile, logger }) : errorHandler(e, logger);
+                        boundResponseMiddleware(errorHandler(e, logger), { request, logger }) : errorHandler(e, logger);
                     return result.catch(errorHandlerWithMiddleware);
                 }
                 else {
@@ -175,13 +173,13 @@ export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatc
                 }
             }
             else if (boundResponseMiddleware) {
-                return boundResponseMiddleware(undefined, { request, profile, logger });
+                return boundResponseMiddleware(undefined, { request, logger });
             }
         }
         catch (e) {
             if (errorHandler && e instanceof Error) {
                 return boundResponseMiddleware
-                    ? boundResponseMiddleware(errorHandler(e, logger), { request, profile, logger })
+                    ? boundResponseMiddleware(errorHandler(e, logger), { request, logger })
                     : errorHandler(e, logger);
             }
             throw e;

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

@@ -8,22 +8,22 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
     const cookieName = once(() => resolveConfigValue(config.cookieName));
     const encryptionPrivateKey = once(() => resolveConfigValue(config.encryptionPrivateKey));
     const signaturePublicKey = once(() => resolveConfigValue(config.signaturePublicKey));
-    return ({ request, profile }) => {
+    return ({ request }) => {
         let user;
-        const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
+        const getAuthorizedFetchConfig = async () => {
             const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
             if (!token) {
                 return {};
             }
             return { headers };
-        });
-        const loadUser = profile.track('loadUser', () => async () => {
+        };
+        const loadUser = async () => {
             const [token] = getAuthTokenOrCookie(request, await cookieName());
             if (!token) {
                 return undefined;
             }
             return decryptAndVerify(token, await encryptionPrivateKey(), await signaturePublicKey());
-        });
+        };
         return {
             getAuthorizedFetchConfig,
             getUser: async () => {

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

@@ -1,5 +1,4 @@
 import type { FetchConfig } from '../../fetch';
-import type { Track } from '../../profile';
 import type { HttpHeaders } from '../../routing';
 export interface TokenUser {
     id: number;
@@ -41,7 +40,6 @@ export declare type CookieAuthProviderRequest = {
 };
 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;

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

@@ -6,23 +6,23 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'subrequest')];
     const cookieName = once(() => resolveConfigValue(config.cookieName));
     const accountsBase = once(() => resolveConfigValue(config.accountsBase));
-    return ({ request, profile }) => {
+    return ({ request }) => {
         let user;
-        const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
+        const getAuthorizedFetchConfig = async () => {
             const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
             if (!token) {
                 return {};
             }
             return { headers };
-        });
-        const loadUser = profile.track('loadUser', p => async () => {
+        };
+        const loadUser = async () => {
             const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
             if (!token) {
                 return undefined;
             }
-            return p.trackFetch(initializer.fetch)((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
+            return initializer.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
                 .then(response => response.json());
-        });
+        };
         return {
             getAuthorizedFetchConfig,
             getUser: async () => {

package/dist/esm/services/exercisesGateway/index.d.ts

@@ -1,6 +1,5 @@
 import { ConfigProviderForConfig } from '../../config';
 import { GenericFetch } from '../../fetch';
-import { Track } from '../../profile';
 export declare type Config = {
     defaultCorrectness?: string;
     exercisesHost: string;
@@ -63,12 +62,10 @@ export declare const exercisesGateway: <C extends string = "exercises">(initiali
     defaultCorrectness?: import("../../config").ConfigValueProvider<string> | undefined;
     exercisesHost: import("../../config").ConfigValueProvider<string>;
     exercisesAuthToken: import("../../config").ConfigValueProvider<string>;
-}; }) => ({ profile }: {
-    profile: Track;
-}) => {
-    searchDigest: (query: string, page?: any, per_page?: any) => Promise<string>;
+}; }) => (_: {}) => {
+    searchDigest: (query: string, page?: number, per_page?: number) => Promise<string>;
     get: (uuid: string) => Promise<Exercise | undefined>;
-    search: (query: string, page?: any, per_page?: any) => Promise<ExercisesSearchResultsWithDigest>;
+    search: (query: string, page?: number, per_page?: number) => Promise<ExercisesSearchResultsWithDigest>;
 };
 export declare type ExercisesGateway = ReturnType<ReturnType<ReturnType<typeof exercisesGateway>>>;
 export {};

package/dist/esm/services/exercisesGateway/index.js

@@ -32,7 +32,7 @@ export const exercisesGateway = (initializer) => (configProvider) => {
         }
         return exercise;
     };
-    return ({ profile }) => {
+    return (_) => {
         const request = async (method, path, query = undefined) => {
             const host = (await exercisesHost()).replace(/\/+$/, '');
             const baseUrl = `${host}/api/${path}`;
@@ -44,22 +44,22 @@ export const exercisesGateway = (initializer) => (configProvider) => {
                 method,
             });
         };
-        const searchDigest = profile.track('searchExercisesDigest', () => async (query, page = 1, per_page = 100) => {
+        const searchDigest = async (query, page = 1, per_page = 100) => {
             const response = await request(METHOD.HEAD, 'exercises', { query, page, per_page });
             return assertString(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint HEAD did not return an X-Digest header');
-        });
-        const search = profile.track('searchExercises', () => async (query, page = 1, per_page = 100) => {
+        };
+        const search = async (query, page = 1, per_page = 100) => {
             const response = await request(METHOD.GET, 'exercises', { query, page, per_page });
             const digest = assertString(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint GET did not return an X-Digest header');
             const { items, total_count } = await response.json();
             return { digest, items: await Promise.all(items.map(doDefaultCorrectness)), total_count };
-        });
-        const get = profile.track('getExercise', () => async (uuid) => {
+        };
+        const get = async (uuid) => {
             const response = await request(METHOD.GET, `exercises/${uuid}`);
             return response.status === 404
                 ? undefined
                 : response.json().then(doDefaultCorrectness);
-        });
+        };
         return {
             searchDigest,
             get,

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

@@ -1,5 +1,4 @@
 import { ConfigProviderForConfig } from '../../config';
-import { Track } from '../../profile';
 import { TDocument, VersionedDocumentAuthor } from '.';
 declare type DynamoConfig = {
     tableName: string;
@@ -9,9 +8,7 @@ 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>({ profile }: {
-    profile: Track;
-}, hashKey: K, getAuthor: A) => {
+}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(_: {}, hashKey: K, getAuthor: A) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
         items: T[];

package/dist/esm/services/versionedDocumentStore/dynamodb.js

@@ -48,11 +48,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
-export const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => ({ profile }, hashKey, getAuthor) => {
+export const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, getAuthor) => {
     const options = ifDefined(initializer, {});
     const tableName = once(() => resolveConfigValue(configProvider[ifDefined(options.configSpace, 'dynamodb')].tableName));
     return {
-        loadAllDocumentsTheBadWay: profile.track('versionedDocumentStore.loadAllDocumentsTheBadWay', () => async () => {
+        loadAllDocumentsTheBadWay: async () => {
             const loadAllResults = async (ExclusiveStartKey) => {
                 var _a;
                 const cmd = new ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
@@ -71,8 +71,8 @@ export const dynamoVersionedDocumentStore = (initializer) => () => (configProvid
                 return result;
             }, new Map()));
             return Array.from(allResults.values());
-        }),
-        getVersions: profile.track('versionedDocumentStore.getVersions', () => async (id, startVersion) => {
+        },
+        getVersions: async (id, startVersion) => {
             const cmd = new QueryCommand({
                 TableName: await tableName(),
                 KeyConditionExpression: '#hk = :hkv',
@@ -101,8 +101,8 @@ export const dynamoVersionedDocumentStore = (initializer) => () => (configProvid
                     nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
                 };
             });
-        }),
-        getItem: profile.track('versionedDocumentStore.getItem', () => async (id, timestamp) => {
+        },
+        getItem: async (id, timestamp) => {
             let keyConditionExpression = '#hk = :hkv';
             const expressionAttributeNames = {
                 '#hk': hashKey.toString()
@@ -127,18 +127,18 @@ export const dynamoVersionedDocumentStore = (initializer) => () => (configProvid
                 var _a;
                 return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
             });
-        }),
+        },
         /* prepares a new version of a document with the given data, then allows some additional
          * changes to be input to a `save` function that actually saves it. useful for additional
          * changes based on the new document version or author. the document version and author
          * cannot be modified */
-        prepareItem: profile.track('versionedDocumentStore.prepareItem', () => async (item, ...authorArgs) => {
+        prepareItem: async (item, ...authorArgs) => {
             // this getAuthor type is terrible
             const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
             const timestamp = new Date().getTime();
             return {
                 document: { ...item, timestamp, author },
-                save: profile.track('versionedDocumentStore.prepareItem.save', () => async (changes) => {
+                save: async (changes) => {
                     const document = {
                         ...item,
                         ...changes,
@@ -151,11 +151,11 @@ export const dynamoVersionedDocumentStore = (initializer) => () => (configProvid
                     });
                     return dynamodb().send(cmd)
                         .then(() => document);
-                })
+                }
             };
-        }),
+        },
         /* saves a new version of a document with the given data */
-        putItem: profile.track('versionedDocumentStore.putItem', () => async (item, ...authorArgs) => {
+        putItem: async (item, ...authorArgs) => {
             // this getAuthor type is terrible
             const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
             const document = {
@@ -169,6 +169,6 @@ export const dynamoVersionedDocumentStore = (initializer) => () => (configProvid
             });
             return dynamodb().send(cmd)
                 .then(() => document);
-        }),
+        },
     };
 };

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

@@ -1,5 +1,4 @@
 import { ConfigProviderForConfig } from '../../config';
-import { Track } from '../../profile';
 import { TDocument, VersionedDocumentAuthor } from '.';
 declare type Config = {
     tableName: string;
@@ -11,9 +10,7 @@ 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>({ profile }: {
-    profile: Track;
-}, hashKey: K, getAuthor: A) => {
+}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>(_: {}, hashKey: K, getAuthor: A) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
         items: T[];

package/dist/esm/services/versionedDocumentStore/file-system.js

@@ -4,7 +4,7 @@ import { hashValue } from '../..';
 import { resolveConfigValue } from '../../config';
 import { ifDefined } from '../../guards';
 const PAGE_LIMIT = 5;
-export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => ({ profile }, hashKey, getAuthor) => {
+export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, getAuthor) => {
     const tableName = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].tableName);
     const filePath = tableName.then((table) => path.join(initializer.dataDir, table));
     const { readFile, writeFile } = ifDefined(initializer.fs, fsModule);
@@ -30,14 +30,14 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
     }));
     let previousSave;
     return {
-        loadAllDocumentsTheBadWay: profile.track('versionedDocumentStore.loadAllDocumentsTheBadWay', () => async () => {
+        loadAllDocumentsTheBadWay: async () => {
             await load;
             return Object.entries(data || []).map(([, versions]) => {
                 const versionsList = Object.values(versions);
                 return versionsList[versionsList.length - 1];
             });
-        }),
-        getVersions: profile.track('versionedDocumentStore.getVersions', () => async (id, startVersion) => {
+        },
+        getVersions: async (id, startVersion) => {
             await load;
             const versions = data === null || data === void 0 ? void 0 : data[hashValue(id)];
             const versionsList = versions ? Object.values(versions).reverse() : undefined;
@@ -51,8 +51,8 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
                 items,
                 nextPageToken: hasMore ? items[items.length - 1].timestamp : undefined
             };
-        }),
-        getItem: profile.track('versionedDocumentStore.getItem', () => async (id, timestamp) => {
+        },
+        getItem: async (id, timestamp) => {
             await load;
             const versions = data === null || data === void 0 ? void 0 : data[hashValue(id)];
             if (timestamp) {
@@ -60,14 +60,14 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
             }
             const versionsList = versions ? Object.values(versions) : [];
             return versionsList[versionsList.length - 1];
-        }),
-        prepareItem: profile.track('versionedDocumentStore.prepareItem', () => async (item, ...authorArgs) => {
+        },
+        prepareItem: async (item, ...authorArgs) => {
             // this getAuthor type is terrible
             const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
             const timestamp = new Date().getTime();
             return {
                 document: { ...item, timestamp, author },
-                save: profile.track('versionedDocumentStore.prepareItem.save', () => async (changes) => {
+                save: async (changes) => {
                     await load;
                     await previousSave;
                     const save = previousSave = new Promise(resolve => (async () => {
@@ -80,10 +80,10 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
                         writeFile(path, JSON.stringify(data, null, 2), () => resolve(document));
                     })());
                     return await save;
-                })
+                }
             };
-        }),
-        putItem: profile.track('versionedDocumentStore.putItem', () => async (item, ...authorArgs) => {
+        },
+        putItem: async (item, ...authorArgs) => {
             await load;
             await previousSave;
             const save = previousSave = new Promise(resolve => (async () => {
@@ -98,6 +98,6 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
                 writeFile(path, JSON.stringify(data, null, 2), () => resolve(document));
             })());
             return await save;
-        }),
+        },
     };
 };