@openstax/ts-utils 1.7.0 → 1.9.0

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

@@ -2,65 +2,22 @@
 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 __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 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) => ({ profile }, hashKey, getAuthor) => {
+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: profile.track('versionedDocumentStore.loadAllDocumentsTheBadWay', () => async () => {
+        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)) || [];
+                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)];
                 }
@@ -74,20 +31,20 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
                 return result;
             }, new Map()));
             return Array.from(allResults.values());
-        }),
-        getVersions: profile.track('versionedDocumentStore.getVersions', () => async (id, startVersion) => {
+        },
+        getVersions: async (id, startVersion) => {
             const cmd = new client_dynamodb_1.QueryCommand({
                 TableName: await tableName(),
                 KeyConditionExpression: '#hk = :hkv',
                 ExpressionAttributeValues: {
-                    ':hkv': encodeDynamoAttribute(id)
+                    ':hkv': (0, dynamoEncoding_1.encodeDynamoAttribute)(id)
                 },
                 ExpressionAttributeNames: {
                     '#hk': hashKey.toString()
                 },
                 ...(startVersion
                     ? { ExclusiveStartKey: {
-                            [hashKey]: encodeDynamoAttribute(id),
+                            [hashKey]: (0, dynamoEncoding_1.encodeDynamoAttribute)(id),
                             timestamp: { N: startVersion.toString() }
                         } }
                     : {}),
@@ -95,28 +52,28 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
             });
             return dynamodb().send(cmd).then(result => {
                 var _a;
-                const items = (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument);
+                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 ? decodeDynamoDocument(result.LastEvaluatedKey).timestamp : undefined
+                    nextPageToken: result.LastEvaluatedKey ? (0, dynamoEncoding_1.decodeDynamoDocument)(result.LastEvaluatedKey).timestamp : undefined
                 };
             });
-        }),
-        getItem: profile.track('versionedDocumentStore.getItem', () => async (id, timestamp) => {
+        },
+        getItem: async (id, timestamp) => {
             let keyConditionExpression = '#hk = :hkv';
             const expressionAttributeNames = {
                 '#hk': hashKey.toString()
             };
             const expressionAttributeValues = {
-                ':hkv': encodeDynamoAttribute(id)
+                ':hkv': (0, dynamoEncoding_1.encodeDynamoAttribute)(id)
             };
             if (timestamp) {
                 keyConditionExpression += ' and #ts = :tsv';
                 expressionAttributeNames['#ts'] = 'timestamp';
-                expressionAttributeValues[':tsv'] = encodeDynamoAttribute(timestamp);
+                expressionAttributeValues[':tsv'] = (0, dynamoEncoding_1.encodeDynamoAttribute)(timestamp);
             }
             const cmd = new client_dynamodb_1.QueryCommand({
                 TableName: await tableName(),
@@ -128,20 +85,20 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
             });
             return dynamodb().send(cmd).then(result => {
                 var _a;
-                return (_a = result.Items) === null || _a === void 0 ? void 0 : _a.map(decodeDynamoDocument)[0];
+                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: profile.track('versionedDocumentStore.prepareItem', () => async (item, ...authorArgs) => {
+        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: profile.track('versionedDocumentStore.prepareItem.save', () => async (changes) => {
+                save: async (changes) => {
                     const document = {
                         ...item,
                         ...changes,
@@ -150,15 +107,15 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
                     };
                     const cmd = new client_dynamodb_1.PutItemCommand({
                         TableName: await tableName(),
-                        Item: encodeDynamoDocument(document),
+                        Item: (0, dynamoEncoding_1.encodeDynamoDocument)(document),
                     });
                     return dynamodb().send(cmd)
                         .then(() => document);
-                })
+                }
             };
-        }),
+        },
         /* saves a new version of a document with the given data */
-        putItem: profile.track('versionedDocumentStore.putItem', () => async (item, ...authorArgs) => {
+        putItem: async (item, ...authorArgs) => {
             // this getAuthor type is terrible
             const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
             const document = {
@@ -168,11 +125,11 @@ const dynamoVersionedDocumentStore = (initializer) => () => (configProvider) =>
             };
             const cmd = new client_dynamodb_1.PutItemCommand({
                 TableName: await tableName(),
-                Item: encodeDynamoDocument(document),
+                Item: (0, dynamoEncoding_1.encodeDynamoDocument)(document),
             });
             return dynamodb().send(cmd)
                 .then(() => document);
-        }),
+        },
     };
 };
 exports.dynamoVersionedDocumentStore = dynamoVersionedDocumentStore;

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

@@ -1,19 +1,14 @@
-import { ConfigProviderForConfig } from '../../config';
-import { Track } from '../../profile';
-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>;
-}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>({ profile }: {
-    profile: Track;
-}, hashKey: K, getAuthor: A) => {
+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[];

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

@@ -29,11 +29,11 @@ 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 __1 = require("../../..");
+const config_1 = require("../../../config");
+const guards_1 = require("../../../guards");
 const PAGE_LIMIT = 5;
-const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => ({ profile }, hashKey, getAuthor) => {
+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);
@@ -59,14 +59,14 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
     }));
     let previousSave;
     return {
-        loadAllDocumentsTheBadWay: profile.track('versionedDocumentStore.loadAllDocumentsTheBadWay', () => async () => {
+        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) => {
+        },
+        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).reverse() : undefined;
@@ -80,8 +80,8 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
                 items,
                 nextPageToken: hasMore ? items[items.length - 1].timestamp : undefined
             };
-        }),
-        getItem: profile.track('versionedDocumentStore.getItem', () => async (id, timestamp) => {
+        },
+        getItem: async (id, timestamp) => {
             await load;
             const versions = data === null || data === void 0 ? void 0 : data[(0, __1.hashValue)(id)];
             if (timestamp) {
@@ -89,14 +89,14 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
             }
             const versionsList = versions ? Object.values(versions) : [];
             return versionsList[versionsList.length - 1];
-        }),
-        prepareItem: profile.track('versionedDocumentStore.prepareItem', () => async (item, ...authorArgs) => {
+        },
+        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: profile.track('versionedDocumentStore.prepareItem.save', () => async (changes) => {
+                save: async (changes) => {
                     await load;
                     await previousSave;
                     const save = previousSave = new Promise(resolve => (async () => {
@@ -109,10 +109,10 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
                         writeFile(path, JSON.stringify(data, null, 2), () => resolve(document));
                     })());
                     return await save;
-                })
+                }
             };
-        }),
-        putItem: profile.track('versionedDocumentStore.putItem', () => async (item, ...authorArgs) => {
+        },
+        putItem: async (item, ...authorArgs) => {
             await load;
             await previousSave;
             const save = previousSave = new Promise(resolve => (async () => {
@@ -127,7 +127,7 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
                 writeFile(path, JSON.stringify(data, null, 2), () => resolve(document));
             })());
             return await save;
-        }),
+        },
     };
 };
 exports.fileSystemVersionedDocumentStore = fileSystemVersionedDocumentStore;

package/dist/cjs/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/cjs/services/documentStore/versioned/index.js

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

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

@@ -1,6 +1,5 @@
 import { ConfigProviderForConfig } from '../../config';
 import { GenericFetch } from '../../fetch';
-import { Track } from '../../profile';
 export declare type Config = {
     defaultCorrectness?: string;
     exercisesHost: string;
@@ -63,12 +62,10 @@ export declare const exercisesGateway: <C extends string = "exercises">(initiali
     defaultCorrectness?: import("../../config").ConfigValueProvider<string> | undefined;
     exercisesHost: import("../../config").ConfigValueProvider<string>;
     exercisesAuthToken: import("../../config").ConfigValueProvider<string>;
-}; }) => ({ profile }: {
-    profile: Track;
-}) => {
-    searchDigest: (query: string, page?: any, per_page?: any) => Promise<string>;
+}; }) => (_: {}) => {
+    searchDigest: (query: string, page?: number, per_page?: number) => Promise<string>;
     get: (uuid: string) => Promise<Exercise | undefined>;
-    search: (query: string, page?: any, per_page?: any) => Promise<ExercisesSearchResultsWithDigest>;
+    search: (query: string, page?: number, per_page?: number) => Promise<ExercisesSearchResultsWithDigest>;
 };
 export declare type ExercisesGateway = ReturnType<ReturnType<ReturnType<typeof exercisesGateway>>>;
 export {};

package/dist/cjs/services/exercisesGateway/index.js

@@ -58,7 +58,7 @@ const exercisesGateway = (initializer) => (configProvider) => {
         }
         return exercise;
     };
-    return ({ profile }) => {
+    return (_) => {
         const request = async (method, path, query = undefined) => {
             const host = (await exercisesHost()).replace(/\/+$/, '');
             const baseUrl = `${host}/api/${path}`;
@@ -70,22 +70,22 @@ const exercisesGateway = (initializer) => (configProvider) => {
                 method,
             });
         };
-        const searchDigest = profile.track('searchExercisesDigest', () => async (query, page = 1, per_page = 100) => {
+        const searchDigest = async (query, page = 1, per_page = 100) => {
             const response = await request(routing_1.METHOD.HEAD, 'exercises', { query, page, per_page });
             return (0, assertions_1.assertString)(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint HEAD did not return an X-Digest header');
-        });
-        const search = profile.track('searchExercises', () => async (query, page = 1, per_page = 100) => {
+        };
+        const search = async (query, page = 1, per_page = 100) => {
             const response = await request(routing_1.METHOD.GET, 'exercises', { query, page, per_page });
             const digest = (0, assertions_1.assertString)(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint GET did not return an X-Digest header');
             const { items, total_count } = await response.json();
             return { digest, items: await Promise.all(items.map(doDefaultCorrectness)), total_count };
-        });
-        const get = profile.track('getExercise', () => async (uuid) => {
+        };
+        const get = async (uuid) => {
             const response = await request(routing_1.METHOD.GET, `exercises/${uuid}`);
             return response.status === 404
                 ? undefined
                 : response.json().then(doDefaultCorrectness);
-        });
+        };
         return {
             searchDigest,
             get,