@openstax/ts-utils 1.8.0 → 1.9.1

package/dist/esm/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/esm/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/esm/services/documentStore/dynamoEncoding.js

@@ -0,0 +1,45 @@
+import { isPlainObject } from '../../guards';
+export 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}.`);
+};
+export const encodeDynamoDocument = (base) => Object.fromEntries(Object.entries(base).map(([key, value]) => ([key, encodeDynamoAttribute(value)])));
+export 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)}.`);
+};
+export const decodeDynamoDocument = (document) => Object.fromEntries(Object.entries(document).map(([key, value]) => ([key, decodeDynamoAttribute(value)])));

package/dist/esm/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/esm/services/documentStore/unversioned/dynamodb.d.ts

@@ -0,0 +1,14 @@
+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>;
+    putItem: (item: T) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,54 @@
+import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { once } from '../../..';
+import { resolveConfigValue } from '../../../config';
+import { ifDefined } from '../../../guards';
+import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
+const dynamodb = once(() => new DynamoDB({ apiVersion: '2012-08-10' }));
+export const dynamoUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey) => {
+    const options = ifDefined(initializer, {});
+    const tableName = once(() => resolveConfigValue(configProvider[ifDefined(options.configSpace, 'dynamodb')].tableName));
+    return {
+        loadAllDocumentsTheBadWay: async () => {
+            const loadAllResults = async (ExclusiveStartKey) => {
+                var _a, _b;
+                const cmd = new 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) => 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 BatchGetItemCommand({
+                    RequestItems: requestItems !== null && requestItems !== void 0 ? requestItems : { [table]: { Keys: ids.map((id) => ({ [key]: encodeDynamoAttribute(id) })) } },
+                });
+                const response = await dynamodb().send(cmd);
+                const currentResponses = response.Responses ?
+                    response.Responses[table].map(response => decodeDynamoDocument(response)) : [];
+                return currentResponses.concat(response.UnprocessedKeys ? await getBatches(response.UnprocessedKeys) : []);
+            };
+            return getBatches();
+        },
+        getItem: async (id) => {
+            const cmd = new GetItemCommand({
+                Key: { [hashKey.toString()]: encodeDynamoAttribute(id) },
+                TableName: await tableName(),
+            });
+            return dynamodb().send(cmd).then(result => result.Item ? decodeDynamoDocument(result.Item) : undefined);
+        },
+        /* saves a new version of a document with the given data */
+        putItem: async (item) => {
+            const cmd = new PutItemCommand({
+                TableName: await tableName(),
+                Item: encodeDynamoDocument(item),
+            });
+            return dynamodb().send(cmd).then(() => item);
+        },
+    };
+};

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

@@ -0,0 +1,16 @@
+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>;
+    putItem: (item: T) => Promise<T>;
+};
+export {};

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

@@ -0,0 +1,55 @@
+import * as fsModule from 'fs';
+import path from 'path';
+import { hashValue } from '../../..';
+import { resolveConfigValue } from '../../../config';
+import { ifDefined, isDefined } from '../../../guards';
+export const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey) => {
+    const tableName = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].tableName);
+    const tablePath = tableName.then((table) => path.join(initializer.dataDir, table));
+    const { mkdir, readdir, readFile, writeFile } = 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) => `${hashValue(value)}.json`;
+    const filePath = async (filename) => path.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(isDefined)), (err) => reject(err))));
+        },
+        batchGetItem: async (ids) => {
+            const items = await Promise.all(ids.map((id) => load(hashFilename(id))));
+            return items.filter(isDefined);
+        },
+        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));
+            });
+        },
+    };
+};

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

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

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

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

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

@@ -1,13 +1,11 @@
-import { ConfigProviderForConfig } from '../../config';
-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>;
+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<{

package/dist/esm/services/{versionedDocumentStore → documentStore/versioned}/dynamodb.js

@@ -1,52 +1,9 @@
 import { DynamoDB, PutItemCommand, QueryCommand, ScanCommand } from '@aws-sdk/client-dynamodb';
-import { once } from '../..';
-import { resolveConfigValue } from '../../config';
-import { ifDefined, isPlainObject } from '../../guards';
+import { once } from '../../..';
+import { resolveConfigValue } from '../../../config';
+import { ifDefined } from '../../../guards';
+import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
 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) => (_, hashKey, getAuthor) => {
     const options = ifDefined(initializer, {});

package/dist/{cjs/services/versionedDocumentStore → esm/services/documentStore/versioned}/file-system.d.ts

@@ -1,15 +1,13 @@
-import { ConfigProviderForConfig } from '../../config';
-import { TDocument, VersionedDocumentAuthor } from '.';
-declare type Config = {
-    tableName: string;
-};
+import { Config } from '..';
+import { ConfigProviderForConfig } from '../../../config';
+import { VersionedDocumentAuthor, VersionedTDocument } from '.';
 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>;
+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<{

package/dist/esm/services/{versionedDocumentStore → documentStore/versioned}/file-system.js

@@ -1,8 +1,8 @@
 import * as fsModule from 'fs';
 import path from 'path';
-import { hashValue } from '../..';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
+import { hashValue } from '../../..';
+import { resolveConfigValue } from '../../../config';
+import { ifDefined } from '../../../guards';
 const PAGE_LIMIT = 5;
 export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, getAuthor) => {
     const tableName = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].tableName);

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

@@ -1,9 +1,5 @@
+import { TDocument } from '..';
 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;
@@ -17,7 +13,5 @@ export declare type VersionedDocumentRequiredFields = {
     timestamp: number;
     author: VersionedDocumentAuthor;
 };
-export declare type TDocument<T> = {
-    [k in keyof T]: DocumentBaseValueTypes;
-} & VersionedDocumentRequiredFields;
+export declare type VersionedTDocument<T> = TDocument<T> & VersionedDocumentRequiredFields;
 export declare type VersionedDocumentStoreCreator = typeof dynamoVersionedDocumentStore;

package/dist/esm/services/documentStore/versioned/index.js

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