@openstax/ts-utils 1.14.0 → 1.15.1

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

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subrequestAuthProvider = void 0;
+const cookie_1 = __importDefault(require("cookie"));
 const __1 = require("../..");
 const config_1 = require("../../config");
 const guards_1 = require("../../guards");
@@ -19,10 +23,12 @@ const subrequestAuthProvider = (initializer) => (configProvider) => {
             return { headers };
         };
         const loadUser = async () => {
-            const [token, headers] = (0, _1.getAuthTokenOrCookie)(request, await cookieName());
+            const resolvedCookeiName = await cookieName();
+            const [token] = (0, _1.getAuthTokenOrCookie)(request, resolvedCookeiName);
             if (!token) {
                 return undefined;
             }
+            const headers = { cookie: cookie_1.default.serialize(resolvedCookeiName, token) };
             return initializer.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
                 .then(response => response.json());
         };

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

@@ -45,7 +45,64 @@ const dynamoUnversionedDocumentStore = (initializer) => () => (configProvider) =
             });
             return dynamodb().send(cmd).then(result => result.Item ? (0, dynamoEncoding_1.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 client_dynamodb_1.UpdateItemCommand({
+                Key: { [key]: (0, dynamoEncoding_1.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}`] = (0, dynamoEncoding_1.encodeDynamoAttribute)(value);
+            });
+            const cmd = new client_dynamodb_1.UpdateItemCommand({
+                Key: { [key]: (0, dynamoEncoding_1.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 (0, dynamoEncoding_1.decodeDynamoDocument)(item.Attributes);
+            });
+        },
+        /* replaces the entire document with the given data */
         putItem: async (item) => {
             const cmd = new client_dynamodb_1.PutItemCommand({
                 TableName: await tableName(),

package/dist/cjs/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/cjs/services/documentStore/unversioned/file-system.js

@@ -73,6 +73,41 @@ const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvide
             return items.filter(guards_1.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/cjs/services/launchParams/verifier.js

@@ -1,13 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLaunchVerifier = void 0;
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const jsonwebtoken_1 = __importStar(require("jsonwebtoken"));
 const jwks_rsa_1 = require("jwks-rsa");
 const __1 = require("../..");
 const config_1 = require("../../config");
+const errors_1 = require("../../errors");
 const guards_1 = require("../../guards");
 /**
  * Creates a class that can verify launch params
@@ -40,7 +61,10 @@ const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
         }
     };
     const verify = (token) => new Promise((resolve, reject) => jsonwebtoken_1.default.verify(token, getKey, {}, (err, payload) => {
-        if (err) {
+        if (err && err instanceof jsonwebtoken_1.TokenExpiredError) {
+            reject(new errors_1.SessionExpiredError());
+        }
+        else if (err) {
             reject(err);
         }
         else if (typeof payload !== 'object') {