@openstax/ts-utils 1.15.5 → 1.16.2

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

@@ -1,5 +1,5 @@
 import type { ConfigProviderForConfig } from '../../config';
-import { CookieAuthProvider } from '.';
+import { AuthProvider, CookieAuthProvider } from '.';
 declare type Config = {
     cookieName: string;
     encryptionPrivateKey: string;
@@ -8,9 +8,12 @@ declare type Config = {
 interface Initializer<C> {
     configSpace?: C;
 }
+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>;
-}; }) => CookieAuthProvider;
+}; }) => CookieAuthProvider<DecryptionAuthProvider>;
 export {};

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

@@ -18,12 +18,18 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
             }
             return { headers };
         };
-        const loadUser = 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;
             }
-            const result = decryptAndVerify(token, await encryptionPrivateKey(), await signaturePublicKey());
+            return decryptAndVerify(token, await encryptionPrivateKey(), await signaturePublicKey());
+        };
+        const loadUser = async () => {
+            const result = await getPayload();
+            if (!result) {
+                return undefined;
+            }
             if ('error' in result && result.error == 'expired token') {
                 throw new SessionExpiredError();
             }
@@ -31,12 +37,17 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
         };
         return {
             getAuthorizedFetchConfig,
+            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) {
                     user = await loadUser();
                 }
                 return user;
-            }
+            },
         };
     };
 };

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

@@ -45,9 +45,9 @@ export declare type CookieAuthProviderRequest = {
     headers: HttpHeaders;
     queryStringParameters?: QueryParams;
 };
-export declare type CookieAuthProvider = (inputs: {
+export declare type CookieAuthProvider<T extends AuthProvider = AuthProvider> = (inputs: {
     request: CookieAuthProviderRequest;
-}) => AuthProvider;
+}) => T;
 export declare type StubAuthProvider = (user: User | undefined) => AuthProvider;
 export declare const stubAuthProvider: (user?: User | undefined) => AuthProvider;
 export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest, cookieName: string, queryKey?: string) => [string, {

package/dist/esm/services/authProvider/utils/decryptAndVerify.d.ts

@@ -17,11 +17,13 @@ export declare const verifyJws: (jws: string, signaturePublicKey: Buffer | strin
  * @param token the encrypted token
  * @param encryptionPrivateKey the private key used to encrypt the token
  * @param signaturePublicKey the public key used to verify the decrypted token
- * @returns {user: User} (success) or {error: string} (failure)
+ * @returns {user: User; exp: number} (success) or {error: string} (failure)
  */
 export declare const decryptAndVerify: (token: string, encryptionPrivateKey: string, signaturePublicKey: string) => {
     user: User;
+    exp: number;
 } | {
     error: string;
+    exp?: number;
 };
 export {};

package/dist/esm/services/authProvider/utils/decryptAndVerify.js

@@ -57,7 +57,7 @@ export const verifyJws = (jws, signaturePublicKey) => {
  * @param token the encrypted token
  * @param encryptionPrivateKey the private key used to encrypt the token
  * @param signaturePublicKey the public key used to verify the decrypted token
- * @returns {user: User} (success) or {error: string} (failure)
+ * @returns {user: User; exp: number} (success) or {error: string} (failure)
  */
 export const decryptAndVerify = (token, encryptionPrivateKey, signaturePublicKey) => {
     const timestamp = Math.floor(Date.now() / 1000);
@@ -79,7 +79,7 @@ export const decryptAndVerify = (token, encryptionPrivateKey, signaturePublicKey
         return { error: 'invalid token' };
     }
     if (payload.exp < timestamp - clockTolerance) {
-        return { error: 'expired token' };
+        return { error: 'expired token', exp: payload.exp };
     }
-    return { user: payload.sub };
+    return { user: payload.sub, exp: payload.exp };
 };

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) => Promise<string>;
+    sign: (subject: string, maxExpiresIn?: string | number | null | undefined) => Promise<string>;
 };
 export declare type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
 export {};

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

@@ -1,4 +1,5 @@
 import jwt from 'jsonwebtoken';
+import ms from 'ms';
 import { JWK } from 'node-jose';
 import { once } from '../..';
 import { resolveConfigValue } from '../../config';
@@ -27,9 +28,17 @@ export const createLaunchSigner = ({ configSpace }) => (configProvider) => {
         return keystore;
     });
     const jwks = async () => (await getKeyStore()).toJSON(false);
-    const sign = async (subject) => {
-        const alg = await getAlg();
+    const getExpiresInWithMax = async (maxExpiresIn) => {
         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;
+    };
+    const sign = async (subject, maxExpiresIn) => {
+        const alg = await getAlg();
+        // expiresIn can be a number of seconds or a string like '1h' or '1d'
+        const expiresIn = await getExpiresInWithMax(maxExpiresIn);
         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 };