@openstax/ts-utils 1.21.11 → 1.23.0

package/dist/cjs/services/authProvider/utils/userRoleValidator.d.ts

@@ -0,0 +1,13 @@
+import { AuthProvider } from '..';
+import { AssertionFailed } from '../../../assertions';
+import { ConfigProviderForConfig } from '../../../config';
+declare type Config = {
+    application: string;
+};
+export declare const createUserRoleValidator: (auth: AuthProvider, config: ConfigProviderForConfig<Config>) => {
+    getUserRoles: () => Promise<string[]>;
+    userHasRole: (role: string[]) => Promise<boolean>;
+    assertUserRole: (role: string[], fail?: AssertionFailed) => Promise<void>;
+};
+export declare type UserRoleValidator = ReturnType<typeof createUserRoleValidator>;
+export {};

package/dist/cjs/services/authProvider/utils/userRoleValidator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUserRoleValidator = void 0;
+const assertions_1 = require("../../../assertions");
+const resolveConfigValue_1 = require("../../../config/resolveConfigValue");
+const errors_1 = require("../../../errors");
+const helpers_1 = require("../../../misc/helpers");
+const createUserRoleValidator = (auth, config) => {
+    const application = (0, helpers_1.once)(() => (0, resolveConfigValue_1.resolveConfigValue)(config.application));
+    const getUserRoles = async () => {
+        var _a;
+        const user = await auth.getUser();
+        const appName = await application();
+        if (!user || !('applications' in user)) {
+            return [];
+        }
+        return ((_a = user.applications.find(a => a.name === appName)) === null || _a === void 0 ? void 0 : _a.roles) || [];
+    };
+    const userHasRole = async (role) => {
+        const roles = await getUserRoles();
+        if (!roles.some(r => role.includes(r))) {
+            return false;
+        }
+        return true;
+    };
+    const assertUserRole = async (role, fail = new errors_1.UnauthorizedError()) => {
+        if (!await userHasRole(role)) {
+            return (0, assertions_1.doThrow)(fail);
+        }
+    };
+    return {
+        getUserRoles,
+        userHasRole,
+        assertUserRole
+    };
+};
+exports.createUserRoleValidator = createUserRoleValidator;

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/index.js

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

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

@@ -0,0 +1,16 @@
+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[]>;
+    batchGetItem: (ids: T[K][]) => Promise<T[]>;
+    getItem: (id: T[K]) => Promise<T | undefined>;
+    incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
+    patchItem: (item: Partial<T>) => Promise<T>;
+    putItem: (item: T) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,122 @@
+"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 errors_1 = require("../../../errors");
+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, _b;
+                const cmd = new client_dynamodb_1.ScanCommand({ TableName: await tableName(), ExclusiveStartKey });
+                const result = await dynamodb().send(cmd);
+                const resultItems = (_b = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map((item) => (0, dynamoEncoding_1.decodeDynamoDocument)(item))) !== null && _b !== void 0 ? _b : [];
+                if (result.LastEvaluatedKey) {
+                    return [...resultItems, ...await loadAllResults(result.LastEvaluatedKey)];
+                }
+                return resultItems;
+            };
+            return loadAllResults();
+        },
+        batchGetItem: async (ids) => {
+            const table = await tableName();
+            const key = hashKey.toString();
+            const getBatches = async (requestItems) => {
+                const cmd = new client_dynamodb_1.BatchGetItemCommand({
+                    RequestItems: requestItems !== null && requestItems !== void 0 ? requestItems : { [table]: { Keys: ids.map((id) => ({ [key]: (0, dynamoEncoding_1.encodeDynamoAttribute)(id) })) } },
+                });
+                const response = await dynamodb().send(cmd);
+                const currentResponses = response.Responses ?
+                    response.Responses[table].map(response => (0, dynamoEncoding_1.decodeDynamoDocument)(response)) : [];
+                return currentResponses.concat(response.UnprocessedKeys ? await getBatches(response.UnprocessedKeys) : []);
+            };
+            return getBatches();
+        },
+        getItem: async (id) => {
+            const cmd = new client_dynamodb_1.GetItemCommand({
+                Key: { [hashKey.toString()]: (0, dynamoEncoding_1.encodeDynamoAttribute)(id) },
+                TableName: await tableName(),
+            });
+            return dynamodb().send(cmd).then(result => result.Item ? (0, dynamoEncoding_1.decodeDynamoDocument)(result.Item) : undefined);
+        },
+        /* atomically increments the given item attribute by 1 */
+        incrementItemAttribute: async (id, attribute) => {
+            const key = hashKey.toString();
+            const field = attribute.toString();
+            const cmd = new client_dynamodb_1.UpdateItemCommand({
+                Key: { [key]: (0, dynamoEncoding_1.encodeDynamoAttribute)(id) },
+                TableName: await tableName(),
+                UpdateExpression: 'ADD #f :one',
+                ConditionExpression: 'attribute_exists(#k)',
+                ExpressionAttributeNames: { '#k': hashKey.toString(), '#f': field },
+                ExpressionAttributeValues: { ':one': { N: '1' } },
+                ReturnValues: 'UPDATED_NEW',
+            });
+            return dynamodb().send(cmd).then((item) => {
+                var _a;
+                const result = (_a = item.Attributes) === null || _a === void 0 ? void 0 : _a[field]['N'];
+                if (!result) {
+                    throw new errors_1.NotFoundError(`Item with ${key} "${id}" does not exist`);
+                }
+                return parseFloat(result);
+            }).catch((error) => {
+                throw error.name === 'ConditionalCheckFailedException' ?
+                    new errors_1.NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
+            });
+        },
+        /* replaces only specified attributes with the given data */
+        patchItem: async (item) => {
+            const id = item[hashKey];
+            const key = hashKey.toString();
+            if (!id) {
+                throw new Error(`Key attribute "${key}" is required for patchItem`);
+            }
+            const entries = Object.entries(item).filter(([field]) => field !== key);
+            if (entries.length === 0) {
+                throw new Error('No attributes to update');
+            }
+            const updates = [];
+            const expressionAttributeNames = { '#k': key };
+            const expressionAttributeValues = {};
+            entries.forEach(([field, value], index) => {
+                updates.push(`#f${index} = :f${index}`);
+                expressionAttributeNames[`#f${index}`] = field;
+                expressionAttributeValues[`:f${index}`] = (0, dynamoEncoding_1.encodeDynamoAttribute)(value);
+            });
+            const cmd = new client_dynamodb_1.UpdateItemCommand({
+                Key: { [key]: (0, dynamoEncoding_1.encodeDynamoAttribute)(id) },
+                TableName: await tableName(),
+                UpdateExpression: `SET ${updates.join(', ')}`,
+                ConditionExpression: 'attribute_exists(#k)',
+                ExpressionAttributeNames: expressionAttributeNames,
+                ExpressionAttributeValues: expressionAttributeValues,
+                ReturnValues: 'ALL_NEW',
+            });
+            return dynamodb().send(cmd).then((item) => {
+                if (!item.Attributes) {
+                    throw new errors_1.NotFoundError(`Item with ${key} "${id}" does not exist`);
+                }
+                return (0, dynamoEncoding_1.decodeDynamoDocument)(item.Attributes);
+            }).catch((error) => {
+                throw error.name === 'ConditionalCheckFailedException' ?
+                    new errors_1.NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
+            });
+        },
+        /* replaces the entire 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,18 @@
+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[]>;
+    batchGetItem: (ids: T[K][]) => Promise<Exclude<Awaited<T>, undefined>[]>;
+    getItem: (id: T[K]) => Promise<T | undefined>;
+    incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
+    patchItem: (item: Partial<T>) => Promise<T>;
+    putItem: (item: T) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,121 @@
+"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 errors_1 = require("../../../errors");
+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 && err.code !== 'EEXIST' ? 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))));
+        },
+        batchGetItem: async (ids) => {
+            const items = await Promise.all(ids.map((id) => load(hashFilename(id))));
+            return items.filter(guards_1.isDefined);
+        },
+        getItem: (id) => load(hashFilename(id)),
+        incrementItemAttribute: async (id, attribute) => {
+            const filename = hashFilename(id);
+            const path = await filePath(filename);
+            await mkTableDir;
+            const data = await load(filename);
+            if (!data) {
+                throw new errors_1.NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
+            }
+            const newValue = typeof data[attribute] === 'number' ? data[attribute] + 1 : 1;
+            const newItem = { ...data, [hashKey]: id, [attribute]: newValue };
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newValue));
+            });
+        },
+        patchItem: async (item) => {
+            const id = item[hashKey];
+            if (!id) {
+                throw new Error(`Key attribute "${hashKey.toString()}" is required for patchItem`);
+            }
+            // This check is just to make this adapter consistent with the dynamo adapter
+            if (Object.keys(item).filter((key) => key !== hashKey.toString()).length === 0) {
+                throw new Error('No attributes to update');
+            }
+            const filename = hashFilename(id);
+            const path = await filePath(filename);
+            await mkTableDir;
+            const data = await load(filename);
+            if (!data) {
+                throw new errors_1.NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
+            }
+            const newItem = { ...data, ...item };
+            return new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newItem));
+            });
+        },
+        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/cjs/services/documentStore/versioned/dynamodb.d.ts

@@ -0,0 +1,22 @@
+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 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[];
+        nextPageToken: number | undefined;
+    } | undefined>;
+    getItem: (id: T[K], timestamp?: number | undefined) => Promise<T | undefined>;
+    prepareItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<{
+        document: T;
+        save: (changes?: Partial<Omit<T, "timestamp" | "author">> | undefined) => Promise<T>;
+    }>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamoVersionedDocumentStore = 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' }));
+// 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 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;
+            };
+            const allResults = await loadAllResults().then(results => results.reduce((result, document) => {
+                const current = result.get(document[hashKey]);
+                if (!current || current.timestamp < document.timestamp) {
+                    return result.set(document[hashKey], document);
+                }
+                return result;
+            }, new Map()));
+            return Array.from(allResults.values());
+        },
+        getVersions: async (id, startVersion) => {
+            const cmd = new client_dynamodb_1.QueryCommand({
+                TableName: await tableName(),
+                KeyConditionExpression: '#hk = :hkv',
+                ExpressionAttributeValues: {
+                    ':hkv': (0, dynamoEncoding_1.encodeDynamoAttribute)(id)
+                },
+                ExpressionAttributeNames: {
+                    '#hk': hashKey.toString()
+                },
+                ...(startVersion
+                    ? { ExclusiveStartKey: {
+                            [hashKey]: (0, dynamoEncoding_1.encodeDynamoAttribute)(id),
+                            timestamp: { N: startVersion.toString() }
+                        } }
+                    : {}),
+                ScanIndexForward: false,
+            });
+            return dynamodb().send(cmd).then(result => {
+                var _a;
+                const items = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(dynamoEncoding_1.decodeDynamoDocument);
+                if (!items || items.length === 0) {
+                    return undefined;
+                }
+                return {
+                    items,
+                    nextPageToken: result.LastEvaluatedKey ? (0, dynamoEncoding_1.decodeDynamoDocument)(result.LastEvaluatedKey).timestamp : undefined
+                };
+            });
+        },
+        getItem: async (id, timestamp) => {
+            let keyConditionExpression = '#hk = :hkv';
+            const expressionAttributeNames = {
+                '#hk': hashKey.toString()
+            };
+            const expressionAttributeValues = {
+                ':hkv': (0, dynamoEncoding_1.encodeDynamoAttribute)(id)
+            };
+            if (timestamp) {
+                keyConditionExpression += ' and #ts = :tsv';
+                expressionAttributeNames['#ts'] = 'timestamp';
+                expressionAttributeValues[':tsv'] = (0, dynamoEncoding_1.encodeDynamoAttribute)(timestamp);
+            }
+            const cmd = new client_dynamodb_1.QueryCommand({
+                TableName: await tableName(),
+                KeyConditionExpression: keyConditionExpression,
+                ExpressionAttributeNames: expressionAttributeNames,
+                ExpressionAttributeValues: expressionAttributeValues,
+                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];
+            });
+        },
+        /* 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: 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: async (changes) => {
+                    const document = {
+                        ...item,
+                        ...changes,
+                        timestamp,
+                        author
+                    };
+                    const cmd = new client_dynamodb_1.PutItemCommand({
+                        TableName: await tableName(),
+                        Item: (0, dynamoEncoding_1.encodeDynamoDocument)(document),
+                    });
+                    return dynamodb().send(cmd)
+                        .then(() => document);
+                }
+            };
+        },
+        /* saves a new version of a document with the given data */
+        putItem: async (item, ...authorArgs) => {
+            // this getAuthor type is terrible
+            const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
+            const document = {
+                ...item,
+                timestamp: new Date().getTime(),
+                author
+            };
+            const cmd = new client_dynamodb_1.PutItemCommand({
+                TableName: await tableName(),
+                Item: (0, dynamoEncoding_1.encodeDynamoDocument)(document),
+            });
+            return dynamodb().send(cmd)
+                .then(() => document);
+        },
+    };
+};
+exports.dynamoVersionedDocumentStore = dynamoVersionedDocumentStore;

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

@@ -0,0 +1,24 @@
+import { Config } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+import { VersionedDocumentAuthor, VersionedTDocument } from '.';
+interface Initializer<C> {
+    dataDir: string;
+    fs?: Pick<typeof import('fs'), 'mkdir' | 'readdir' | 'readFile' | 'writeFile'>;
+    configSpace?: C;
+}
+export declare const fileSystemVersionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <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[];
+        nextPageToken: number | undefined;
+    } | undefined>;
+    getItem: (id: T[K], timestamp?: number | undefined) => Promise<T | undefined>;
+    prepareItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<{
+        document: T;
+        save: (changes?: Partial<Omit<T, "timestamp" | "author">> | undefined) => Promise<T>;
+    }>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};