@openstax/ts-utils 1.15.1 → 1.15.3

package/dist/esm/services/authProvider/subrequest.js

@@ -17,12 +17,12 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
             return { headers };
         };
         const loadUser = async () => {
-            const resolvedCookeiName = await cookieName();
-            const [token] = getAuthTokenOrCookie(request, resolvedCookeiName);
+            const resolvedCookieName = await cookieName();
+            const [token] = getAuthTokenOrCookie(request, resolvedCookieName);
             if (!token) {
                 return undefined;
             }
-            const headers = { cookie: cookie.serialize(resolvedCookeiName, token) };
+            const headers = { cookie: cookie.serialize(resolvedCookieName, token) };
             return initializer.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
                 .then(response => response.json());
         };

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

@@ -1,6 +1,7 @@
 import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, ScanCommand, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
 import { once } from '../../..';
 import { resolveConfigValue } from '../../../config';
+import { NotFoundError } from '../../../errors';
 import { ifDefined } from '../../../guards';
 import { decodeDynamoDocument, encodeDynamoAttribute, encodeDynamoDocument } from '../dynamoEncoding';
 const dynamodb = once(() => new DynamoDB({ apiVersion: '2012-08-10' }));
@@ -59,7 +60,7 @@ export const dynamoUnversionedDocumentStore = (initializer) => () => (configProv
                 var _a;
                 const result = (_a = item.Attributes) === null || _a === void 0 ? void 0 : _a[field]['N'];
                 if (!result) {
-                    throw new Error(`Item with ${key} "${id}" does not exist`);
+                    throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
                 }
                 return parseFloat(result);
             });

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

@@ -2,12 +2,13 @@ import * as fsModule from 'fs';
 import path from 'path';
 import { hashValue } from '../../..';
 import { resolveConfigValue } from '../../../config';
+import { NotFoundError } from '../../../errors';
 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 mkTableDir = new Promise((resolve, reject) => tablePath.then((path) => mkdir(path, { recursive: true }, (err) => err && err.code !== 'EEXIST' ? reject(err) : resolve())));
     const hashFilename = (value) => `${hashValue(value)}.json`;
     const filePath = async (filename) => path.join(await tablePath, filename);
     const load = async (filename) => {
@@ -72,7 +73,7 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             await mkTableDir;
             const data = await load(filename);
             if (!data) {
-                throw new Error(`Item with ${hashKey.toString()} "${id}" does not exist`);
+                throw new NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
             }
             const newItem = { ...data, ...item };
             return new Promise((resolve, reject) => {

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

@@ -3,7 +3,7 @@ import { ConfigProviderForConfig } from '../../../config';
 import { VersionedDocumentAuthor, VersionedTDocument } from '.';
 interface Initializer<C> {
     dataDir: string;
-    fs?: Pick<typeof import('fs'), 'readFile' | 'writeFile'>;
+    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]: {

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

@@ -1,65 +1,33 @@
-import * as fsModule from 'fs';
-import path from 'path';
-import { hashValue } from '../../..';
-import { resolveConfigValue } from '../../../config';
-import { ifDefined } from '../../../guards';
+import { fileSystemUnversionedDocumentStore } from '../unversioned/file-system';
 const PAGE_LIMIT = 5;
 export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, 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;
+    const unversionedDocuments = fileSystemUnversionedDocumentStore(initializer)()(configProvider)({}, 'id');
     return {
-        loadAllDocumentsTheBadWay: async () => {
-            await load;
-            return Object.entries(data || []).map(([, versions]) => {
-                const versionsList = Object.values(versions);
-                return versionsList[versionsList.length - 1];
-            });
+        loadAllDocumentsTheBadWay: () => {
+            return unversionedDocuments.loadAllDocumentsTheBadWay().then(documents => documents.map(document => {
+                return document.items[document.items.length - 1];
+            }));
         },
         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) {
+            const item = await unversionedDocuments.getItem(id);
+            const versions = item === null || item === void 0 ? void 0 : item.items.reverse();
+            if (!versions) {
                 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;
+            const startIndex = startVersion ? versions.findIndex(version => version.timestamp === startVersion) + 1 : 0;
+            const items = versions.slice(startIndex, startIndex + PAGE_LIMIT);
+            const hasMore = (startIndex + 5) < versions.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[hashValue(id)];
+            const item = await unversionedDocuments.getItem(id);
             if (timestamp) {
-                return versions === null || versions === void 0 ? void 0 : versions[timestamp];
+                return item === null || item === void 0 ? void 0 : item.items.find(version => version.timestamp === timestamp);
             }
-            const versionsList = versions ? Object.values(versions) : [];
-            return versionsList[versionsList.length - 1];
+            return item ? item.items[item.items.length - 1] : undefined;
         },
         prepareItem: async (item, ...authorArgs) => {
             // this getAuthor type is terrible
@@ -68,36 +36,23 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
             return {
                 document: { ...item, timestamp, author },
                 save: async (changes) => {
-                    await load;
-                    await previousSave;
-                    const save = previousSave = new Promise(resolve => (async () => {
-                        const path = await filePath;
-                        data = data || {};
-                        const document = { ...item, ...changes, timestamp, author };
-                        const hash = hashValue(document[hashKey]);
-                        const versions = data[hash] = data[hash] || {};
-                        versions[document.timestamp] = document;
-                        writeFile(path, JSON.stringify(data, null, 2), () => resolve(document));
-                    })());
-                    return await save;
+                    var _a;
+                    const document = { ...item, ...changes, timestamp, author };
+                    const container = (_a = await unversionedDocuments.getItem(document[hashKey])) !== null && _a !== void 0 ? _a : { id: document[hashKey], items: [] };
+                    const updated = { ...container, items: [...container.items, document] };
+                    await unversionedDocuments.putItem(updated);
+                    return document;
                 }
             };
         },
         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;
+            var _a;
+            const author = getAuthor ? await getAuthor(...authorArgs) : authorArgs[0];
+            const document = { ...item, timestamp: new Date().getTime(), author };
+            const container = (_a = await unversionedDocuments.getItem(document[hashKey])) !== null && _a !== void 0 ? _a : { id: document[hashKey], items: [] };
+            const updated = { ...container, items: [...container.items, document] };
+            await unversionedDocuments.putItem(updated);
+            return document;
         },
     };
 };