@openstax/ts-utils 1.48.2 → 1.50.0

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

@@ -18,6 +18,7 @@ export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamo
     getItem: (id: T[K]) => Promise<T | undefined>;
     incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
     patchItem: (item: Partial<T>) => Promise<T>;
+    conditionalPatchItem: (item: Partial<T>, condition: Partial<T>) => Promise<T>;
     putItem: (item: T) => Promise<T>;
     createItem: (item: T) => Promise<T>;
     batchCreateItem: (items: T[], concurrency?: number) => Promise<{

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

@@ -113,7 +113,7 @@ export const dynamoUnversionedDocumentStore = (initializer) => {
                 if (!id) {
                     throw new Error(`Key attribute "${key}" is required for patchItem`);
                 }
-                const entries = Object.entries(item).filter(([field]) => field !== key);
+                const entries = Object.entries(item).filter(([field, value]) => field !== key && value !== undefined);
                 if (entries.length === 0) {
                     throw new Error('No attributes to update');
                 }
@@ -147,6 +147,68 @@ export const dynamoUnversionedDocumentStore = (initializer) => {
                         new NotFoundError(`Item with ${key} "${id}" does not exist`) : error;
                 });
             },
+            /* atomically patches only if the condition fields match; throws ConflictError if condition fails */
+            conditionalPatchItem: async (item, condition) => {
+                const id = item[hashKey];
+                const key = hashKey.toString();
+                if (!id) {
+                    throw new Error(`Key attribute "${key}" is required for conditionalPatchItem`);
+                }
+                const entries = Object.entries(item).filter(([field, value]) => field !== key && value !== undefined);
+                if (entries.length === 0) {
+                    throw new Error('No attributes to update');
+                }
+                const conditionEntries = Object.entries(condition);
+                if (conditionEntries.length === 0) {
+                    throw new Error('condition must have at least one attribute');
+                }
+                const updates = [];
+                const expressionAttributeNames = { '#k': key };
+                const expressionAttributeValues = {};
+                entries.forEach(([field, value], index) => {
+                    updates.push(`#f${index} = :f${index}`);
+                    expressionAttributeNames[`#f${index}`] = field;
+                    expressionAttributeValues[`:f${index}`] = encodeDynamoAttribute(value);
+                });
+                const conditionClauses = ['attribute_exists(#k)'];
+                conditionEntries.forEach(([field, value], index) => {
+                    expressionAttributeNames[`#c${index}`] = field;
+                    if (value === undefined) {
+                        conditionClauses.push(`attribute_not_exists(#c${index})`);
+                    }
+                    else {
+                        conditionClauses.push(`#c${index} = :c${index}`);
+                        expressionAttributeValues[`:c${index}`] = encodeDynamoAttribute(value);
+                    }
+                });
+                const cmd = new UpdateItemCommand({
+                    Key: { [key]: encodeDynamoAttribute(id) },
+                    TableName: await tableName(),
+                    UpdateExpression: `SET ${updates.join(', ')}`,
+                    ConditionExpression: conditionClauses.join(' AND '),
+                    ExpressionAttributeNames: expressionAttributeNames,
+                    ExpressionAttributeValues: expressionAttributeValues,
+                    ReturnValues: 'ALL_NEW',
+                    ReturnValuesOnConditionCheckFailure: 'ALL_OLD',
+                });
+                return dynamodb().send(cmd).then(async (result) => {
+                    var _a;
+                    if (!result.Attributes) {
+                        throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
+                    }
+                    const updatedDoc = decodeDynamoDocument(result.Attributes);
+                    await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, updatedDoc));
+                    return updatedDoc;
+                }).catch((error) => {
+                    if (error.name === 'ConditionalCheckFailedException') {
+                        if (!error.Item || Object.keys(error.Item).length === 0) {
+                            throw new NotFoundError(`Item with ${key} "${id}" does not exist`);
+                        }
+                        throw new ConflictError(`Condition failed for item with ${key} "${id}"`);
+                    }
+                    throw error;
+                });
+            },
             /* replaces the entire document with the given data */
             putItem: async (item) => {
                 var _a;

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

@@ -18,6 +18,7 @@ export declare const fileSystemUnversionedDocumentStore: <C extends string = "fi
     getItem: (id: T[K]) => Promise<T | undefined>;
     incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
     patchItem: (item: Partial<T>) => Promise<T>;
+    conditionalPatchItem: (item: Partial<T>, condition: Partial<T>) => Promise<T>;
     putItem: (item: T) => Promise<T>;
     createItem: (item: T) => Promise<T>;
     batchCreateItem: (items: T[], _concurrency?: number) => Promise<{

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

@@ -62,6 +62,7 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             return load(hashFilename(id));
         },
         incrementItemAttribute: async (id, attribute) => {
+            var _a;
             const filename = hashFilename(id);
             const path = await filePath(filename);
             await mkTableDir;
@@ -71,19 +72,50 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             }
             const newValue = typeof data[attribute] === 'number' ? data[attribute] + 1 : 1;
             const newItem = { ...data, [hashKey]: id, [attribute]: newValue };
-            return new Promise((resolve, reject) => {
-                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newValue));
+            await new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve());
             });
+            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, newItem));
+            return newValue;
         },
         patchItem: async (item) => {
+            var _a;
             const id = item[hashKey];
             if (!id) {
                 throw new Error(`Key attribute "${hashKey.toString()}" is required for patchItem`);
             }
             // This check is just to make this adapter consistent with the dynamo adapter
-            if (Object.keys(item).filter((key) => key !== hashKey.toString()).length === 0) {
+            const definedEntries = Object.entries(item).filter(([k, v]) => k !== hashKey.toString() && v !== undefined);
+            if (definedEntries.length === 0) {
+                throw new Error('No attributes to update');
+            }
+            const filename = hashFilename(id);
+            const path = await filePath(filename);
+            await mkTableDir;
+            const data = await load(filename);
+            if (!data) {
+                throw new NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
+            }
+            const newItem = { ...data, ...Object.fromEntries(definedEntries) };
+            await new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve());
+            });
+            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, newItem));
+            return newItem;
+        },
+        conditionalPatchItem: async (item, condition) => {
+            var _a;
+            const id = item[hashKey];
+            if (!id) {
+                throw new Error(`Key attribute "${hashKey.toString()}" is required for conditionalPatchItem`);
+            }
+            const definedEntries = Object.entries(item).filter(([k, v]) => k !== hashKey.toString() && v !== undefined);
+            if (definedEntries.length === 0) {
                 throw new Error('No attributes to update');
             }
+            if (Object.keys(condition).length === 0) {
+                throw new Error('condition must have at least one attribute');
+            }
             const filename = hashFilename(id);
             const path = await filePath(filename);
             await mkTableDir;
@@ -91,19 +123,31 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             if (!data) {
                 throw new NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
             }
-            const newItem = { ...data, ...item };
-            return new Promise((resolve, reject) => {
-                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newItem));
+            // The local version of this method currently supports only primitive value conditions
+            for (const [key, value] of Object.entries(condition)) {
+                if (data[key] !== value) {
+                    throw new ConflictError(`Condition failed for item with ${hashKey.toString()} "${id}"`);
+                }
+            }
+            const newItem = { ...data, ...Object.fromEntries(definedEntries) };
+            await new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve());
             });
+            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, newItem));
+            return newItem;
         },
         putItem: async (item) => {
+            var _a;
             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));
+            await new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve());
             });
+            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, item));
+            return item;
         },
         createItem: async (item) => {
+            var _a;
             const hashed = hashFilename(item[hashKey]);
             const existingItem = await load(hashed);
             if (existingItem) {
@@ -111,9 +155,11 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             }
             const path = await filePath(hashed);
             await mkTableDir;
-            return new Promise((resolve, reject) => {
-                writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve(item));
+            await new Promise((resolve, reject) => {
+                writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve());
             });
+            await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, item));
+            return item;
         },
         batchCreateItem: async (items, _concurrency = 1) => {
             var _a;
@@ -135,11 +181,11 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
                     const createdItem = await new Promise((resolve, reject) => {
                         writeFile(path, JSON.stringify(item, null, 2), (err) => err ? reject(err) : resolve(item));
                     });
-                    successful.push(createdItem);
                     // Only call individual afterWrite if batchAfterWrite is not defined
                     if (!(options === null || options === void 0 ? void 0 : options.batchAfterWrite)) {
                         await ((_a = options === null || options === void 0 ? void 0 : options.afterWrite) === null || _a === void 0 ? void 0 : _a.call(options, createdItem));
                     }
+                    successful.push(createdItem);
                 }
                 catch (error) {
                     failed.push({ item, error: error });