@openstax/ts-utils 1.0.0

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

@@ -0,0 +1,110 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { WithRequired } from '../../types';
+import { AuthProvider } from '../authProvider';
+declare type Config = {
+    lrsHost: string;
+    lrsAuthorization: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export interface XapiStatement {
+    actor: {
+        account: {
+            homePage: 'https://openstax.org';
+            name: string;
+        };
+        objectType: 'Agent';
+    };
+    id: string;
+    context?: {
+        contextActivities?: {
+            parent?: [
+                {
+                    id: string;
+                    objectType: 'Activity';
+                }
+            ];
+        };
+        statement?: {
+            objectType: 'StatementRef';
+            id: string;
+        };
+        registration?: string;
+        platform?: string;
+    };
+    object: {
+        definition?: {
+            extensions?: {
+                [key: string]: string;
+            };
+            name: {
+                [key: string]: string;
+            };
+            type: string;
+        };
+        id: string;
+        objectType: 'Activity';
+    };
+    result?: {
+        score?: {
+            scaled?: number;
+            raw?: number;
+            min?: number;
+            max?: number;
+        };
+        success?: boolean;
+        completion?: boolean;
+        response?: string;
+        duration?: string;
+        extensions?: {
+            [key: string]: string;
+        };
+    };
+    verb: {
+        display?: {
+            [key: string]: string;
+        };
+        id: string;
+    };
+    timestamp: string;
+    stored?: string;
+}
+export declare type SavedXapiStatement = WithRequired<XapiStatement, 'stored'>;
+export declare type EagerXapiStatement = Omit<XapiStatement, 'stored'>;
+export declare type LrsGateway = ReturnType<ReturnType<ReturnType<typeof lrsGateway>>>;
+export declare type LrsProvider = ReturnType<ReturnType<typeof lrsGateway>>;
+export declare const lrsGateway: <C extends string = "lrs">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    lrsHost: import("../../config").ConfigValueProvider<string>;
+    lrsAuthorization: import("../../config").ConfigValueProvider<string>;
+}; }) => (authProvider: AuthProvider) => {
+    putXapiStatements: (statements: Array<Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+        id?: string;
+    }>) => Promise<EagerXapiStatement[]>;
+    getXapiStatements: ({ user, anyUser, ...options }: {
+        verb?: string | undefined;
+        activity?: string | undefined;
+        registration?: string | undefined;
+        related_activities?: boolean | undefined;
+        user?: string | undefined;
+        anyUser?: boolean | undefined;
+    }) => Promise<{
+        more: string;
+        statements: XapiStatement[];
+    }>;
+    getMoreXapiStatements: (more: string) => Promise<{
+        more: string;
+        statements: XapiStatement[];
+    }>;
+    getAllXapiStatements: (args_0: {
+        verb?: string | undefined;
+        activity?: string | undefined;
+        registration?: string | undefined;
+        related_activities?: boolean | undefined;
+        user?: string | undefined;
+        anyUser?: boolean | undefined;
+    }) => Promise<XapiStatement[]>;
+};
+export {};

package/dist/services/lrsGateway/index.js

@@ -0,0 +1,116 @@
+"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.lrsGateway = void 0;
+const formatISO_1 = __importDefault(require("date-fns/formatISO"));
+const queryString = __importStar(require("query-string"));
+const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const guards_1 = require("../../guards");
+const routing_1 = require("../../routing");
+const lrsGateway = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'lrs')];
+    const lrsHost = (0, config_1.resolveConfigValue)(config.lrsHost);
+    const lrsAuthorization = (0, config_1.resolveConfigValue)(config.lrsAuthorization);
+    return (authProvider) => {
+        const putXapiStatements = async (statements) => {
+            const user = (0, assertions_1.assertDefined)(await authProvider.getUser(), new errors_1.UnauthorizedError);
+            const statementsWithDefaults = statements.map(statement => ({
+                ...statement,
+                actor: {
+                    account: {
+                        homePage: 'https://openstax.org',
+                        name: user.uuid,
+                    },
+                    objectType: 'Agent',
+                },
+                timestamp: (0, formatISO_1.default)(new Date())
+            }));
+            return initializer.fetch((await lrsHost).replace(/\/+$/, '') + '/data/xAPI/statements', {
+                body: JSON.stringify(statementsWithDefaults),
+                headers: {
+                    Authorization: await lrsAuthorization,
+                    'Content-Type': 'application/json',
+                    'X-Experience-API-Version': '1.0.0',
+                },
+                method: routing_1.METHOD.POST,
+            })
+                .then(response => response.json())
+                .then(ids => ids.map((id, index) => ({ id, ...statementsWithDefaults[index] })));
+        };
+        const getMoreXapiStatements = async (more) => {
+            return initializer.fetch((await lrsHost).replace(/\/+$/, '') + more, {
+                headers: {
+                    Authorization: await lrsAuthorization,
+                    'X-Experience-API-Version': '1.0.0',
+                },
+            })
+                .then(response => response.json())
+                .then(json => json);
+        };
+        const getXapiStatements = async ({ user, anyUser, ...options }) => {
+            return initializer.fetch((await lrsHost).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
+                ...options,
+                ...(anyUser === true ? {} : {
+                    agent: JSON.stringify({
+                        account: {
+                            homePage: 'https://openstax.org',
+                            name: user || (0, assertions_1.assertDefined)(await authProvider.getUser(), new errors_1.UnauthorizedError()).uuid,
+                        },
+                        objectType: 'Agent',
+                    }),
+                })
+            }), {
+                headers: {
+                    Authorization: await lrsAuthorization,
+                    'X-Experience-API-Version': '1.0.0',
+                },
+            })
+                .then(response => response.json())
+                .then(json => json);
+        };
+        const getAllXapiStatements = (...args) => {
+            const loadRemaining = async (result) => {
+                if (!result.more) {
+                    return result.statements;
+                }
+                const { more, statements } = await getMoreXapiStatements(result.more);
+                return loadRemaining({ more, statements: [...result.statements, ...statements] });
+            };
+            return getXapiStatements(...args).then(loadRemaining);
+        };
+        return {
+            putXapiStatements,
+            getXapiStatements,
+            getMoreXapiStatements,
+            getAllXapiStatements,
+        };
+    };
+};
+exports.lrsGateway = lrsGateway;

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

@@ -0,0 +1,20 @@
+declare type KeysMatching<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never;
+}[keyof T];
+declare type FilterFieldTypes = string;
+declare type Filter<F extends keyof T, T> = F extends KeysMatching<T, FilterFieldTypes> ? {
+    key: F;
+    value: T[F];
+} : never;
+declare type QueryFieldTypes = string | undefined | null;
+declare type Field<F extends keyof T, T> = F extends KeysMatching<T, QueryFieldTypes> ? {
+    key: F;
+    weight: number;
+} : never;
+export interface SearchOptions<T> {
+    page?: number;
+    query: string | undefined;
+    fields: Field<keyof T, T>[];
+    filter?: Filter<keyof T, T>[];
+}
+export {};

package/dist/services/searchProvider/index.js

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

package/dist/services/searchProvider/memorySearchTheBadWay.d.ts

@@ -0,0 +1,12 @@
+import { SearchOptions } from '.';
+export declare const memorySearchTheBadWay: <T>({ loadAllDocumentsTheBadWay }: {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+}) => {
+    search: (options: SearchOptions<T>) => Promise<{
+        items: T[];
+        pageSize: number;
+        currentPage: number;
+        totalItems: number;
+        totalPages: number;
+    }>;
+};

package/dist/services/searchProvider/memorySearchTheBadWay.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memorySearchTheBadWay = void 0;
+const guards_1 = require("../../guards");
+const MIN_MATCH = 0.5;
+const MAX_RESULTS = 10;
+const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
+    return {
+        search: async (options) => {
+            const results = (await loadAllDocumentsTheBadWay())
+                .map(document => {
+                let weight = 0;
+                if (options.query !== undefined) {
+                    for (const field of options.fields) {
+                        const value = document[field.key];
+                        if (value === undefined || value === null) {
+                            continue;
+                        }
+                        if (typeof value === 'string') {
+                            if (value.indexOf(options.query) !== -1) {
+                                weight += (1 * field.weight);
+                            }
+                        }
+                        else {
+                            throw new Error(`invalid value type when searching in field ${field.key.toString()}`);
+                        }
+                    }
+                }
+                for (const field of options.filter || []) {
+                    if (document[field.key] !== field.value) {
+                        return undefined;
+                    }
+                }
+                return { document, weight };
+            })
+                .filter(guards_1.isDefined)
+                .filter(r => !options.query || r.weight >= MIN_MATCH);
+            results.sort((a, b) => b.weight - a.weight);
+            const page = options.page || 1;
+            const offset = (page - 1) * MAX_RESULTS;
+            return {
+                items: results.slice(offset, offset + MAX_RESULTS).map(r => r.document),
+                pageSize: MAX_RESULTS,
+                currentPage: page,
+                totalItems: results.length,
+                totalPages: Math.ceil(results.length / MAX_RESULTS)
+            };
+        }
+    };
+};
+exports.memorySearchTheBadWay = memorySearchTheBadWay;

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

@@ -0,0 +1,20 @@
+import { ConfigProviderForConfig } from '../../config';
+import { TDocument, VersionedDocumentAuthor } from '.';
+declare type DynamoConfig = {
+    tableName: string;
+};
+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>(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>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};

package/dist/services/versionedDocumentStore/dynamodb.js

@@ -0,0 +1,151 @@
+"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 dynamodb = (0, __1.once)(() => new client_dynamodb_1.DynamoDB({ apiVersion: '2012-08-10' }));
+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(encodeDynamoAttribute) };
+    }
+    if ((0, guards_1.isPlainObject)(value)) {
+        return { M: encodeDynamoDocument(value) };
+    }
+    throw new Error(`unknown attribute type ${typeof value} with value ${value}.`);
+};
+const encodeDynamoDocument = (base) => Object.fromEntries(Object.entries(base).map(([key, value]) => ([key, encodeDynamoAttribute(value)])));
+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(decodeDynamoAttribute);
+    }
+    if (value.M !== undefined) {
+        return decodeDynamoDocument(value.M);
+    }
+    throw new Error(`unknown attribute type: ${JSON.stringify(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 options = (0, guards_1.ifDefined)(initializer, {});
+    const tableName = (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(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': encodeDynamoAttribute(id)
+                },
+                ExpressionAttributeNames: {
+                    '#hk': hashKey.toString()
+                },
+                ...(startVersion
+                    ? { ExclusiveStartKey: {
+                            [hashKey]: 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(decodeDynamoDocument);
+                if (!items || items.length === 0) {
+                    return undefined;
+                }
+                return {
+                    items,
+                    nextPageToken: result.LastEvaluatedKey ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
+                };
+            });
+        },
+        getItem: async (id, timestamp) => {
+            let keyConditionExpression = '#hk = :hkv';
+            const expressionAttributeNames = {
+                '#hk': hashKey.toString()
+            };
+            const expressionAttributeValues = {
+                ':hkv': encodeDynamoAttribute(id)
+            };
+            if (timestamp) {
+                keyConditionExpression += ' and #ts = :tsv';
+                expressionAttributeNames['#ts'] = 'timestamp';
+                expressionAttributeValues[':tsv'] = 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(decodeDynamoDocument)[0];
+            });
+        },
+        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: encodeDynamoDocument(document),
+            });
+            return dynamodb().send(cmd)
+                .then(() => document);
+        },
+    };
+};
+exports.dynamoVersionedDocumentStore = dynamoVersionedDocumentStore;

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

@@ -0,0 +1,22 @@
+import { ConfigProviderForConfig } from '../../config';
+import { TDocument, VersionedDocumentAuthor } from '.';
+declare type Config = {
+    tableName: string;
+};
+interface Initializer<C> {
+    dataDir: string;
+    fs?: Pick<typeof import('fs'), 'readFile' | 'writeFile'>;
+    configSpace?: 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) => {
+    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>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,112 @@
+"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.fileSystemVersionedDocumentStore = 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 PAGE_LIMIT = 5;
+const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (hashKey, getAuthor) => {
+    const tableName = (0, config_1.resolveConfigValue)(configProvider[initializer.configSpace || 'fileSystem'].tableName);
+    const filePath = tableName.then((table) => path_1.default.join(initializer.dataDir, table));
+    const { readFile, writeFile } = (0, guards_1.ifDefined)(initializer.fs, fsModule);
+    let data;
+    const load = filePath.then(path => new Promise(resolve => {
+        readFile(path, (err, readData) => {
+            if (err) {
+                console.error(err);
+            }
+            else {
+                try {
+                    data = JSON.parse(readData.toString());
+                    if (typeof data !== 'object') {
+                        data = undefined;
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            resolve();
+        });
+    }));
+    let previousSave;
+    return {
+        loadAllDocumentsTheBadWay: async () => {
+            await load;
+            return Object.entries(data || []).map(([, versions]) => {
+                const versionsList = Object.values(versions);
+                return versionsList[versionsList.length - 1];
+            });
+        },
+        getVersions: async (id, startVersion) => {
+            await load;
+            const versions = data === null || data === void 0 ? void 0 : data[(0, __1.hashValue)(id)];
+            const versionsList = versions ? Object.values(versions) : undefined;
+            if (!versions || !versionsList) {
+                return undefined;
+            }
+            const startIndex = startVersion ? versionsList.indexOf(versions[startVersion.toString()]) + 1 : 0;
+            const items = versionsList.slice(startIndex, startIndex + PAGE_LIMIT);
+            const hasMore = (startIndex + 5) < versionsList.length;
+            return {
+                items,
+                nextPageToken: hasMore ? items[items.length - 1].timestamp : undefined
+            };
+        },
+        getItem: async (id, timestamp) => {
+            await load;
+            const versions = data === null || data === void 0 ? void 0 : data[(0, __1.hashValue)(id)];
+            if (timestamp) {
+                return versions === null || versions === void 0 ? void 0 : versions[timestamp];
+            }
+            const versionsList = versions ? Object.values(versions) : [];
+            return versionsList[versionsList.length - 1];
+        },
+        putItem: async (item, ...authorArgs) => {
+            await load;
+            await previousSave;
+            // this getAuthor type is terrible
+            const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
+            const document = { ...item, timestamp: new Date().getTime(), author };
+            const hash = (0, __1.hashValue)(document[hashKey]);
+            const path = await filePath;
+            const save = previousSave = new Promise(resolve => {
+                data = data || {};
+                const versions = data[hash] = data[hash] || {};
+                versions[document.timestamp] = document;
+                writeFile(path, JSON.stringify(data, null, 2), () => resolve());
+            });
+            await save;
+            return document;
+        },
+    };
+};
+exports.fileSystemVersionedDocumentStore = fileSystemVersionedDocumentStore;

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

@@ -0,0 +1,23 @@
+import { dynamoVersionedDocumentStore } from './dynamodb';
+export declare type DocumentBaseValueTypes = number | boolean | string | null | DocumentBaseMapType | DocumentBaseListType;
+export declare type DocumentBaseMapType = {
+    [key: string]: DocumentBaseValueTypes;
+};
+export declare type DocumentBaseListType = DocumentBaseValueTypes[];
+export declare type VersionedDocumentAuthor = {
+    type: 'user';
+    uuid: string;
+    name: string;
+    reason?: string;
+} | {
+    type: 'system';
+    reason: string;
+};
+export declare type VersionedDocumentRequiredFields = {
+    timestamp: number;
+    author: VersionedDocumentAuthor;
+};
+export declare type TDocument<T> = {
+    [k in keyof T]: DocumentBaseValueTypes;
+} & VersionedDocumentRequiredFields;
+export declare type VersionedDocumentStoreCreator = typeof dynamoVersionedDocumentStore;

package/dist/services/versionedDocumentStore/index.js

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