@openstax/ts-utils 1.16.0 → 1.17.0

package/dist/esm/middleware/apiSlowResponseMiddleware.js

@@ -32,7 +32,7 @@ export const createSlowResponseMiddleware = (config) => {
                     });
                     resolve(apiTextResponse(504, '504 Gateway Timeout'));
                 }, timeoutAfter));
-            const requestPromise = response.then(response => {
+            const requestPromise = response.finally(() => {
                 const time = Date.now() - start;
                 if (timeout !== undefined) {
                     clearTimeout(timeout);
@@ -43,7 +43,6 @@ export const createSlowResponseMiddleware = (config) => {
                         time,
                     });
                 }
-                return response;
             });
             return timeoutPromise ? Promise.race([timeoutPromise, requestPromise]) : requestPromise;
         });

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

@@ -130,6 +130,6 @@ export const browserAuthProvider = ({ window, configSpace }) => (configProvider)
         /**
          * loads current user identity. does not reflect changes in identity after being called the first time.
          */
-        getUser
+        getUser,
     };
 };

package/dist/esm/services/authProvider/decryption.d.ts

@@ -8,12 +8,12 @@ declare type Config = {
 interface Initializer<C> {
     configSpace?: C;
 }
-export declare type DecryptionAuthProvider = CookieAuthProvider<AuthProvider & {
-    getTokenExpiration: () => Promise<number | undefined>;
-}>;
+export declare type DecryptionAuthProvider = AuthProvider & {
+    getTokenExpiration: (tokenString?: string) => Promise<number | null | undefined>;
+};
 export declare const decryptionAuthProvider: <C extends string = "decryption">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
     cookieName: import("../../config").ConfigValueProvider<string>;
     encryptionPrivateKey: import("../../config").ConfigValueProvider<string>;
     signaturePublicKey: import("../../config").ConfigValueProvider<string>;
-}; }) => DecryptionAuthProvider;
+}; }) => CookieAuthProvider<DecryptionAuthProvider>;
 export {};

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

@@ -18,8 +18,8 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
             }
             return { headers };
         };
-        const getPayload = async () => {
-            const [token] = getAuthTokenOrCookie(request, await cookieName());
+        const getPayload = async (tokenString) => {
+            const token = tokenString !== null && tokenString !== void 0 ? tokenString : getAuthTokenOrCookie(request, await cookieName())[0];
             if (!token) {
                 return undefined;
             }
@@ -37,9 +37,10 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
         };
         return {
             getAuthorizedFetchConfig,
-            getTokenExpiration: async () => {
-                const result = await getPayload();
-                return result ? result.exp : undefined;
+            getTokenExpiration: async (tokenString) => {
+                var _a;
+                const payload = await getPayload(tokenString);
+                return payload ? ((_a = payload.exp) !== null && _a !== void 0 ? _a : null) : undefined;
             },
             getUser: async () => {
                 if (!user) {

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

@@ -51,7 +51,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 newValue = typeof data[attribute] === 'number' ? data[attribute] + 1 : 1;
             const newItem = { ...data, [hashKey]: id, [attribute]: newValue };

package/dist/esm/services/launchParams/signer.d.ts

@@ -21,7 +21,7 @@ export declare const createLaunchSigner: <C extends string = "launch">({ configS
     jwks: () => Promise<{
         keys: JWK.RawKey[];
     }>;
-    sign: (subject: string, maxExpiresIn?: string | number | undefined) => Promise<string>;
+    sign: (subject: string, maxExp?: number | null | undefined) => Promise<string>;
 };
 export declare type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
 export {};

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

@@ -28,17 +28,21 @@ export const createLaunchSigner = ({ configSpace }) => (configProvider) => {
         return keystore;
     });
     const jwks = async () => (await getKeyStore()).toJSON(false);
-    const getExpiresInWithMax = async (maxExpiresIn) => {
+    const getExpiresInWithMax = async (maxExp) => {
         const expiresIn = await getExpiresIn();
-        const maxExpiresInSeconds = typeof maxExpiresIn === 'number' ? maxExpiresIn :
-            typeof maxExpiresIn === 'string' ? Math.floor(ms(maxExpiresIn) / 1000) :
-                undefined;
-        return maxExpiresInSeconds ? Math.min(Math.floor(ms(expiresIn) / 1000), maxExpiresInSeconds) : expiresIn;
+        // The ms library used by jsonwebtoken can handle a value in seconds as well as a string like '1d'
+        if (!maxExp) {
+            return expiresIn;
+        }
+        // Convert both values to seconds for comparison
+        const expiresInSeconds = Math.floor(ms(expiresIn) / 1000);
+        const maxExpSeconds = maxExp - Math.floor(Date.now() / 1000);
+        return Math.min(expiresInSeconds, maxExpSeconds);
     };
-    const sign = async (subject, maxExpiresIn) => {
+    const sign = async (subject, maxExp) => {
         const alg = await getAlg();
         // expiresIn can be a number of seconds or a string like '1h' or '1d'
-        const expiresIn = await getExpiresInWithMax(maxExpiresIn);
+        const expiresIn = await getExpiresInWithMax(maxExp);
         const iss = await getIss();
         const header = { alg, iss };
         return jwt.sign({}, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });

package/dist/esm/services/launchParams/verifier.d.ts

@@ -1,3 +1,4 @@
+import jwt from 'jsonwebtoken';
 import type { JWK } from 'node-jose';
 import { ConfigProviderForConfig } from '../../config';
 declare type Config = {
@@ -15,7 +16,7 @@ interface Initializer<C> {
 export declare const createLaunchVerifier: <C extends string = "launch">({ configSpace, fetcher }: Initializer<C>) => (configProvider: { [key in C]: {
     trustedDomain: import("../../config").ConfigValueProvider<string>;
 }; }) => {
-    verify: (token: string) => Promise<string>;
+    verify: <T = undefined>(...[token, validator]: T extends undefined ? [string] : [string, (input: any) => T]) => Promise<T extends undefined ? jwt.JwtPayload : T>;
 };
 export declare type LaunchVerifier = ReturnType<ReturnType<typeof createLaunchVerifier>>;
 export {};

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

@@ -34,7 +34,7 @@ export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvide
             callback(error);
         }
     };
-    const verify = (token) => new Promise((resolve, reject) => jwt.verify(token, getKey, {}, (err, payload) => {
+    const verify = (...[token, validator]) => new Promise((resolve, reject) => jwt.verify(token, getKey, {}, (err, payload) => {
         if (err && err instanceof TokenExpiredError) {
             reject(new SessionExpiredError());
         }
@@ -48,7 +48,19 @@ export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvide
             reject(new Error('JWT payload missing sub claim'));
         }
         else {
-            resolve(payload.sub);
+            // we are migrating away from json encoding all the parameters into the `sub` claim
+            // and into using separate claims for each parameter. in transition, we check if the sub
+            // is json and return it if it is. this is still a breaking change when using this
+            // utility because applications no longer need to independently json parse the result
+            // starting now.
+            const parsed = payload;
+            try {
+                const jsonSubContents = JSON.parse(payload.sub);
+                Object.assign(parsed, jsonSubContents);
+            }
+            catch (e) { } // eslint-disable-line no-empty
+            // conditional return types are annoying
+            resolve((validator ? validator(parsed) : parsed));
         }
     }));
     return { verify };