@openstax/ts-utils 1.7.0 → 1.9.0

package/dist/cjs/{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/{esm/middleware.d.ts → cjs/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/cjs/misc/hashValue.d.ts

@@ -1,5 +1,5 @@
-declare type HashValue = string | number | boolean | null | HashCompoundValue;
-declare type HashCompoundValue = Array<HashValue> | {
+export declare type HashValue = string | number | boolean | null | HashCompoundValue;
+export declare type HashCompoundValue = Array<HashValue> | {
     [key: string]: HashValue;
 };
 /**
@@ -8,4 +8,3 @@ declare type HashCompoundValue = Array<HashValue> | {
  * @example hashValue({someKey: 'someValue'})
  */
 export declare const hashValue: (value: HashValue) => string;
-export {};

package/dist/cjs/{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/cjs/{pagination.js → pagination/index.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pageNumberPagination = exports.loadMorePagination = exports.createPaginationMiddleware = void 0;
-const assertions_1 = require("./assertions");
-const errors_1 = require("./errors");
-const routing_1 = require("./routing");
+const assertions_1 = require("../assertions");
+const errors_1 = require("../errors");
+const routing_1 = require("../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/cjs/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/cjs/routing/index.js

@@ -33,7 +33,6 @@ exports.METHOD = exports.apiHtmlResponse = exports.apiTextResponse = exports.api
 const pathToRegexp = __importStar(require("path-to-regexp"));
 const query_string_1 = __importDefault(require("query-string"));
 const helpers_1 = require("../misc/helpers");
-const profile_1 = require("../profile");
 const console_1 = require("../services/logger/console");
 /**
  * Makes a createRoute function that can be used to create routes (this is a factory factory). The
@@ -136,11 +135,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, 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);
         }
     };
 };
@@ -189,19 +188,18 @@ const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, er
     // 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();
         const logger = appLogger.createSubContext();
         if (logExtractor) {
             logger.setContext(logExtractor(request));
         }
         try {
-            const executor = (0, helpers_1.mapFind)(boundRoutes, (route) => route(request, profile, logger));
+            const executor = (0, helpers_1.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 {
@@ -209,13 +207,13 @@ const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, er
                 }
             }
             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/cjs/services/authProvider/decryption.js

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

package/dist/cjs/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/cjs/services/authProvider/subrequest.js

@@ -9,23 +9,23 @@ const subrequestAuthProvider = (initializer) => (configProvider) => {
     const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'subrequest')];
     const cookieName = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.cookieName));
     const accountsBase = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.accountsBase));
-    return ({ request, profile }) => {
+    return ({ request }) => {
         let user;
-        const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
+        const getAuthorizedFetchConfig = async () => {
             const [token, headers] = (0, _1.getAuthTokenOrCookie)(request, await cookieName());
             if (!token) {
                 return {};
             }
             return { headers };
-        });
-        const loadUser = profile.track('loadUser', p => async () => {
+        };
+        const loadUser = async () => {
             const [token, headers] = (0, _1.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/cjs/services/documentStore/dynamoEncoding.d.ts

@@ -0,0 +1,10 @@
+import { AttributeValue } from '@aws-sdk/client-dynamodb';
+import { DocumentBaseType, DocumentBaseValueTypes } from '.';
+export declare const encodeDynamoAttribute: (value: DocumentBaseValueTypes) => AttributeValue;
+export declare const encodeDynamoDocument: (base: DocumentBaseType) => {
+    [k: string]: AttributeValue;
+};
+export declare const decodeDynamoAttribute: (value: AttributeValue) => DocumentBaseValueTypes;
+export declare const decodeDynamoDocument: <T extends DocumentBaseType>(document: {
+    [key: string]: AttributeValue;
+}) => T;

package/dist/cjs/services/documentStore/dynamoEncoding.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeDynamoDocument = exports.decodeDynamoAttribute = exports.encodeDynamoDocument = exports.encodeDynamoAttribute = void 0;
+const guards_1 = require("../../guards");
+const encodeDynamoAttribute = (value) => {
+    if (typeof value === 'string') {
+        return { S: value };
+    }
+    if (typeof value === 'number') {
+        return { N: value.toString() };
+    }
+    if (typeof value === 'boolean') {
+        return { BOOL: value };
+    }
+    if (value === null) {
+        return { NULL: true };
+    }
+    if (value instanceof Array) {
+        return { L: value.map(exports.encodeDynamoAttribute) };
+    }
+    if ((0, guards_1.isPlainObject)(value)) {
+        return { M: (0, exports.encodeDynamoDocument)(value) };
+    }
+    throw new Error(`unknown attribute type ${typeof value} with value ${value}.`);
+};
+exports.encodeDynamoAttribute = encodeDynamoAttribute;
+const encodeDynamoDocument = (base) => Object.fromEntries(Object.entries(base).map(([key, value]) => ([key, (0, exports.encodeDynamoAttribute)(value)])));
+exports.encodeDynamoDocument = encodeDynamoDocument;
+const decodeDynamoAttribute = (value) => {
+    if (value.S !== undefined) {
+        return value.S;
+    }
+    if (value.N !== undefined) {
+        return parseFloat(value.N);
+    }
+    if (value.BOOL !== undefined) {
+        return value.BOOL;
+    }
+    if (value.NULL !== undefined) {
+        return null;
+    }
+    if (value.L !== undefined) {
+        return value.L.map(exports.decodeDynamoAttribute);
+    }
+    if (value.M !== undefined) {
+        return (0, exports.decodeDynamoDocument)(value.M);
+    }
+    throw new Error(`unknown attribute type: ${JSON.stringify(value)}.`);
+};
+exports.decodeDynamoAttribute = decodeDynamoAttribute;
+const decodeDynamoDocument = (document) => Object.fromEntries(Object.entries(document).map(([key, value]) => ([key, (0, exports.decodeDynamoAttribute)(value)])));
+exports.decodeDynamoDocument = decodeDynamoDocument;

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

@@ -0,0 +1,14 @@
+export declare type Config = {
+    tableName: string;
+};
+export declare type DocumentBaseMapType = {
+    [key: string]: DocumentBaseValueTypes;
+};
+export declare type DocumentBaseListType = DocumentBaseValueTypes[];
+export declare type DocumentBaseValueTypes = number | boolean | string | null | DocumentBaseMapType | DocumentBaseListType;
+export declare type DocumentBaseType = {
+    [key: string]: DocumentBaseValueTypes;
+};
+export declare type TDocument<T> = {
+    [k in keyof T]: DocumentBaseValueTypes;
+};

package/dist/cjs/services/documentStore/unversioned/dynamodb.d.ts

@@ -0,0 +1,13 @@
+import { Config, TDocument } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+interface Initializer<C> {
+    configSpace?: C;
+}
+export declare const dynamoUnversionedDocumentStore: <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>(_: {}, hashKey: K) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getItem: (id: T[K]) => Promise<T | undefined>;
+    putItem: (item: T) => Promise<T>;
+};
+export {};

package/dist/cjs/services/documentStore/unversioned/dynamodb.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamoUnversionedDocumentStore = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const __1 = require("../../..");
+const config_1 = require("../../../config");
+const guards_1 = require("../../../guards");
+const dynamoEncoding_1 = require("../dynamoEncoding");
+const dynamodb = (0, __1.once)(() => new client_dynamodb_1.DynamoDB({ apiVersion: '2012-08-10' }));
+const dynamoUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey) => {
+    const options = (0, guards_1.ifDefined)(initializer, {});
+    const tableName = (0, __1.once)(() => (0, config_1.resolveConfigValue)(configProvider[(0, guards_1.ifDefined)(options.configSpace, 'dynamodb')].tableName));
+    return {
+        loadAllDocumentsTheBadWay: async () => {
+            const loadAllResults = async (ExclusiveStartKey) => {
+                var _a;
+                const cmd = new client_dynamodb_1.ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
+                const result = await dynamodb().send(cmd);
+                const resultItems = ((_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(dynamoEncoding_1.decodeDynamoDocument)) || [];
+                if (result.LastEvaluatedKey) {
+                    return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
+                }
+                return resultItems;
+            };
+            return loadAllResults();
+        },
+        getItem: async (id) => {
+            const cmd = new client_dynamodb_1.QueryCommand({
+                TableName: await tableName(),
+                KeyConditionExpression: '#hk = :hkv',
+                ExpressionAttributeNames: { '#hk': hashKey.toString() },
+                ExpressionAttributeValues: { ':hkv': (0, dynamoEncoding_1.encodeDynamoAttribute)(id) },
+                ScanIndexForward: false,
+                Limit: 1
+            });
+            return dynamodb().send(cmd).then(result => {
+                var _a;
+                return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(dynamoEncoding_1.decodeDynamoDocument)[0];
+            });
+        },
+        /* saves a new version of a document with the given data */
+        putItem: async (item) => {
+            const cmd = new client_dynamodb_1.PutItemCommand({
+                TableName: await tableName(),
+                Item: (0, dynamoEncoding_1.encodeDynamoDocument)(item),
+            });
+            return dynamodb().send(cmd).then(() => item);
+        },
+    };
+};
+exports.dynamoUnversionedDocumentStore = dynamoUnversionedDocumentStore;

package/dist/cjs/services/documentStore/unversioned/file-system.d.ts

@@ -0,0 +1,15 @@
+import { Config, TDocument } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+interface Initializer<C> {
+    dataDir: string;
+    fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;
+    configSpace?: C;
+}
+export declare const fileSystemUnversionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
+    tableName: import("../../../config").ConfigValueProvider<string>;
+}; }) => <K extends keyof T>(_: {}, hashKey: K) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getItem: (id: T[K]) => Promise<T | undefined>;
+    putItem: (item: T) => Promise<T>;
+};
+export {};

package/dist/cjs/services/documentStore/unversioned/file-system.js

@@ -0,0 +1,81 @@
+"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.fileSystemUnversionedDocumentStore = void 0;
+const fsModule = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const __1 = require("../../..");
+const config_1 = require("../../../config");
+const guards_1 = require("../../../guards");
+const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey) => {
+    const tableName = (0, config_1.resolveConfigValue)(configProvider[initializer.configSpace || 'fileSystem'].tableName);
+    const tablePath = tableName.then((table) => path_1.default.join(initializer.dataDir, table));
+    const { mkdir, readdir, readFile, writeFile } = (0, guards_1.ifDefined)(initializer.fs, fsModule);
+    const mkTableDir = new Promise((resolve, reject) => tablePath.then((path) => mkdir(path, { recursive: true }, (err) => err ? reject(err) : resolve())));
+    const hashFilename = (value) => `${(0, __1.hashValue)(value)}.json`;
+    const filePath = async (filename) => path_1.default.join(await tablePath, filename);
+    const load = async (filename) => {
+        const path = await filePath(filename);
+        await mkTableDir;
+        return new Promise((resolve, reject) => {
+            readFile(path, (err, readData) => {
+                if (err) {
+                    err.code === 'ENOENT' ? resolve(undefined) : reject(err);
+                }
+                else {
+                    try {
+                        const data = JSON.parse(readData.toString());
+                        typeof data === 'object' ? resolve(data) : reject(new Error('unexpected non-object JSON'));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }
+            });
+        });
+    };
+    return {
+        loadAllDocumentsTheBadWay: async () => {
+            const path = await tablePath;
+            await mkTableDir;
+            return new Promise((resolve, reject) => readdir(path, (err, files) => err ?
+                reject(err) :
+                Promise.all(files.map((file) => load(file)))
+                    .then((allData) => resolve(allData.filter(guards_1.isDefined)), (err) => reject(err))));
+        },
+        getItem: (id) => load(hashFilename(id)),
+        putItem: async (item) => {
+            const path = await filePath(hashFilename(item[hashKey]));
+            await mkTableDir;
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve(item));
+            });
+        },
+    };
+};
+exports.fileSystemUnversionedDocumentStore = fileSystemUnversionedDocumentStore;

package/dist/cjs/services/documentStore/unversioned/index.d.ts

@@ -0,0 +1,2 @@
+import { dynamoUnversionedDocumentStore } from './dynamodb';
+export declare type UnversionedDocumentStoreCreator = typeof dynamoUnversionedDocumentStore;

package/dist/cjs/services/documentStore/unversioned/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{esm/services/versionedDocumentStore → cjs/services/documentStore/versioned}/dynamodb.d.ts

@@ -1,17 +1,12 @@
-import { ConfigProviderForConfig } from '../../config';
-import { Track } from '../../profile';
-import { TDocument, VersionedDocumentAuthor } from '.';
-declare type DynamoConfig = {
-    tableName: string;
-};
+import { Config } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+import { VersionedDocumentAuthor, VersionedTDocument } from '.';
 interface Initializer<C> {
     configSpace?: 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) => {
+export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends VersionedTDocument<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) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
         items: T[];