@openstax/ts-utils 1.1.27 → 1.1.29

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

@@ -0,0 +1,147 @@
+import { DynamoDB, PutItemCommand, QueryCommand, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { once } from '../..';
+import { resolveConfigValue } from '../../config';
+import { ifDefined, isPlainObject } from '../../guards';
+const dynamodb = once(() => new 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 (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
+export const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) => ({ profile }, hashKey, getAuthor) => {
+    const options = ifDefined(initializer, {});
+    const tableName = once(() => resolveConfigValue(configProvider[ifDefined(options.configSpace, 'dynamodb')].tableName));
+    return {
+        loadAllDocumentsTheBadWay: profile.track('versionedDocumentStore.loadAllDocumentsTheBadWay', () => async () => {
+            const loadAllResults = async (ExclusiveStartKey) => {
+                var _a;
+                const cmd = new 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: profile.track('versionedDocumentStore.getVersions', () => async (id, startVersion) => {
+            const cmd = new 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: profile.track('versionedDocumentStore.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 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: profile.track('versionedDocumentStore.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 PutItemCommand({
+                TableName: await tableName(),
+                Item: encodeDynamoDocument(document),
+            });
+            return dynamodb().send(cmd)
+                .then(() => document);
+        }),
+    };
+};

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

@@ -0,0 +1,25 @@
+import { ConfigProviderForConfig } from '../../config';
+import { Track } from '../../profile';
+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>({ profile }: {
+    profile: Track;
+}, 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/esm/services/versionedDocumentStore/file-system.js

@@ -0,0 +1,81 @@
+import * as fsModule from 'fs';
+import path from 'path';
+import { hashValue } from '../..';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+const PAGE_LIMIT = 5;
+export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => ({ profile }, 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);
+    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: profile.track('versionedDocumentStore.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) => {
+            await load;
+            const versions = data === null || data === void 0 ? void 0 : data[hashValue(id)];
+            const versionsList = versions ? Object.values(versions).reverse() : 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: profile.track('versionedDocumentStore.getItem', () => async (id, timestamp) => {
+            await load;
+            const versions = data === null || data === void 0 ? void 0 : data[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: profile.track('versionedDocumentStore.putItem', () => async (item, ...authorArgs) => {
+            await load;
+            await previousSave;
+            const save = previousSave = new Promise(resolve => (async () => {
+                // this getAuthor type is terrible
+                const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
+                const document = { ...item, timestamp: new Date().getTime(), author };
+                const hash = hashValue(document[hashKey]);
+                const path = await filePath;
+                data = data || {};
+                const versions = data[hash] = data[hash] || {};
+                versions[document.timestamp] = document;
+                writeFile(path, JSON.stringify(data, null, 2), () => resolve(document));
+            })());
+            return await save;
+        }),
+    };
+};

package/dist/esm/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/esm/services/versionedDocumentStore/index.js

@@ -0,0 +1 @@
+export {};