@openstax/ts-utils 1.14.0 → 1.15.1

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

@@ -1,3 +1,4 @@
+import cookie from 'cookie';
 import { once } from '../..';
 import { resolveConfigValue } from '../../config';
 import { ifDefined } from '../../guards';
@@ -16,10 +17,12 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
             return { headers };
         };
         const loadUser = async () => {
-            const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
+            const resolvedCookeiName = await cookieName();
+            const [token] = getAuthTokenOrCookie(request, resolvedCookeiName);
             if (!token) {
                 return undefined;
             }
+            const headers = { cookie: cookie.serialize(resolvedCookeiName, token) };
             return initializer.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
                 .then(response => response.json());
         };

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

@@ -9,6 +9,8 @@ export declare const dynamoUnversionedDocumentStore: <C extends string = "dynamo
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     batchGetItem: (ids: T[K][]) => Promise<T[]>;
     getItem: (id: T[K]) => Promise<T | undefined>;
+    incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
+    patchItem: (item: Partial<T>) => Promise<T>;
     putItem: (item: T) => Promise<T>;
 };
 export {};

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

@@ -1,4 +1,4 @@
-import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { BatchGetItemCommand, DynamoDB, GetItemCommand, PutItemCommand, ScanCommand, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
 import { once } from '../../..';
 import { resolveConfigValue } from '../../../config';
 import { ifDefined } from '../../../guards';
@@ -42,7 +42,64 @@ export const dynamoUnversionedDocumentStore = (initializer) => () => (configProv
             });
             return dynamodb().send(cmd).then(result => result.Item ? decodeDynamoDocument(result.Item) : undefined);
         },
-        /* saves a new version of a document with the given data */
+        /* atomically increments the given item attribute by 1 */
+        incrementItemAttribute: async (id, attribute) => {
+            const key = hashKey.toString();
+            const field = attribute.toString();
+            const cmd = new UpdateItemCommand({
+                Key: { [key]: encodeDynamoAttribute(id) },
+                TableName: await tableName(),
+                UpdateExpression: 'ADD #f :one',
+                ConditionExpression: 'attribute_exists(#k)',
+                ExpressionAttributeNames: { '#k': hashKey.toString(), '#f': field },
+                ExpressionAttributeValues: { ':one': { N: '1' } },
+                ReturnValues: 'UPDATED_NEW',
+            });
+            return dynamodb().send(cmd).then((item) => {
+                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`);
+                }
+                return parseFloat(result);
+            });
+        },
+        /* replaces only specified attributes with the given data */
+        patchItem: async (item) => {
+            const id = item[hashKey];
+            const key = hashKey.toString();
+            if (!id) {
+                throw new Error(`Key attribute "${key}" is required for patchItem`);
+            }
+            const entries = Object.entries(item).filter(([field]) => field !== key);
+            if (entries.length === 0) {
+                throw new Error('No attributes to update');
+            }
+            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 cmd = new UpdateItemCommand({
+                Key: { [key]: encodeDynamoAttribute(id) },
+                TableName: await tableName(),
+                UpdateExpression: `SET ${updates.join(', ')}`,
+                ConditionExpression: 'attribute_exists(#k)',
+                ExpressionAttributeNames: expressionAttributeNames,
+                ExpressionAttributeValues: expressionAttributeValues,
+                ReturnValues: 'ALL_NEW',
+            });
+            return dynamodb().send(cmd).then((item) => {
+                if (!item.Attributes) {
+                    throw new Error(`Item with ${key} "${id}" does not exist`);
+                }
+                return decodeDynamoDocument(item.Attributes);
+            });
+        },
+        /* replaces the entire document with the given data */
         putItem: async (item) => {
             const cmd = new PutItemCommand({
                 TableName: await tableName(),

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

@@ -11,6 +11,8 @@ export declare const fileSystemUnversionedDocumentStore: <C extends string = "fi
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     batchGetItem: (ids: T[K][]) => Promise<Exclude<Awaited<T>, undefined>[]>;
     getItem: (id: T[K]) => Promise<T | undefined>;
+    incrementItemAttribute: (id: T[K], attribute: keyof T) => Promise<number>;
+    patchItem: (item: Partial<T>) => Promise<T>;
     putItem: (item: T) => Promise<T>;
 };
 export {};

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

@@ -44,6 +44,41 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             return items.filter(isDefined);
         },
         getItem: (id) => load(hashFilename(id)),
+        incrementItemAttribute: async (id, attribute) => {
+            const filename = hashFilename(id);
+            const path = await filePath(filename);
+            await mkTableDir;
+            const data = await load(filename);
+            if (!data) {
+                throw new Error(`Item with ${hashKey.toString()} "${id}" does not exist`);
+            }
+            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));
+            });
+        },
+        patchItem: async (item) => {
+            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) {
+                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 Error(`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));
+            });
+        },
         putItem: async (item) => {
             const path = await filePath(hashFilename(item[hashKey]));
             await mkTableDir;

package/dist/esm/services/launchParams/verifier.js

@@ -1,7 +1,8 @@
-import jwt from 'jsonwebtoken';
+import jwt, { TokenExpiredError } from 'jsonwebtoken';
 import { JwksClient } from 'jwks-rsa';
 import { memoize } from '../..';
 import { resolveConfigValue } from '../../config';
+import { SessionExpiredError } from '../../errors';
 import { ifDefined } from '../../guards';
 /**
  * Creates a class that can verify launch params
@@ -34,7 +35,10 @@ export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvide
         }
     };
     const verify = (token) => new Promise((resolve, reject) => jwt.verify(token, getKey, {}, (err, payload) => {
-        if (err) {
+        if (err && err instanceof TokenExpiredError) {
+            reject(new SessionExpiredError());
+        }
+        else if (err) {
             reject(err);
         }
         else if (typeof payload !== 'object') {