@openstax/ts-utils 1.39.0 → 1.40.0

package/dist/esm/misc/asyncPool.d.ts

@@ -0,0 +1,24 @@
+type PromiseInvoker<T> = () => Promise<T>;
+type UnwrapPromiseInvoker<T> = T extends PromiseInvoker<infer U> ? U : never;
+type UnwrapPromiseInvokers<T extends readonly PromiseInvoker<any>[]> = {
+    [K in keyof T]: UnwrapPromiseInvoker<T[K]>;
+};
+/**
+ * Executes a tuple of promise invokers with a concurrency limit.
+ * Similar to Promise.all but limits the number of in-flight promises.
+ *
+ * @param invokers Tuple of functions that return promises
+ * @param concurrency Maximum number of promises to execute concurrently
+ * @returns Promise that resolves with a tuple of results in the same order as the invokers
+ * @throws Rejects with the first error encountered (similar to Promise.all behavior)
+ *
+ * @example
+ * const results = await asyncPool([
+ *   () => fetch('/api/1').then(r => r.json() as Promise<number>),
+ *   () => fetch('/api/2').then(r => r.text()),
+ *   () => fetch('/api/3').then(r => r.json() as Promise<boolean>),
+ * ], 2);
+ * // results has type [number, string, boolean]
+ */
+export declare const asyncPool: <T extends readonly PromiseInvoker<any>[]>(invokers: T, concurrency: number) => Promise<UnwrapPromiseInvokers<T>>;
+export {};

package/dist/esm/misc/asyncPool.js

@@ -0,0 +1,54 @@
+/**
+ * Executes a tuple of promise invokers with a concurrency limit.
+ * Similar to Promise.all but limits the number of in-flight promises.
+ *
+ * @param invokers Tuple of functions that return promises
+ * @param concurrency Maximum number of promises to execute concurrently
+ * @returns Promise that resolves with a tuple of results in the same order as the invokers
+ * @throws Rejects with the first error encountered (similar to Promise.all behavior)
+ *
+ * @example
+ * const results = await asyncPool([
+ *   () => fetch('/api/1').then(r => r.json() as Promise<number>),
+ *   () => fetch('/api/2').then(r => r.text()),
+ *   () => fetch('/api/3').then(r => r.json() as Promise<boolean>),
+ * ], 2);
+ * // results has type [number, string, boolean]
+ */
+export const asyncPool = async (invokers, concurrency) => {
+    if (concurrency <= 0) {
+        throw new Error('Concurrency must be greater than 0');
+    }
+    const results = new Array(invokers.length);
+    let rejected = false;
+    let currentIndex = 0;
+    let completedCount = 0;
+    return new Promise((resolve, reject) => {
+        const executeNext = () => {
+            if (completedCount === invokers.length) {
+                resolve(results);
+                return;
+            }
+            while (currentIndex < invokers.length && (currentIndex - completedCount) < concurrency) {
+                const index = currentIndex++;
+                const invoker = invokers[index];
+                invoker()
+                    .then((result) => {
+                    if (rejected) {
+                        return;
+                    }
+                    results[index] = result;
+                    completedCount++;
+                    executeNext();
+                })
+                    .catch((error) => {
+                    if (!rejected) {
+                        rejected = true;
+                        reject(error);
+                    }
+                });
+            }
+        };
+        executeNext();
+    });
+};

package/dist/esm/misc/hashValue.d.ts

@@ -1,4 +1,4 @@
-export type HashValue = string | number | boolean | null | HashCompoundValue;
+export type HashValue = undefined | string | number | boolean | null | HashCompoundValue;
 export type HashCompoundValue = Array<HashValue> | {
     [key: string]: HashValue;
 };

package/dist/esm/misc/hashValue.js

@@ -5,9 +5,10 @@ import { createHash } from 'crypto';
  * @example hashValue({someKey: 'someValue'})
  */
 export const hashValue = (value) => {
+    var _a;
     // hack for sorting keys https://stackoverflow.com/a/53593328/14809536
     const allKeys = new Set();
     JSON.stringify(value, (k, v) => (allKeys.add(k), v));
-    const strValue = JSON.stringify(value, Array.from(allKeys).sort());
+    const strValue = (_a = JSON.stringify(value, Array.from(allKeys).sort())) !== null && _a !== void 0 ? _a : 'undefined';
     return createHash('sha1').update(strValue).digest('hex');
 };

package/dist/esm/routing/index.d.ts

@@ -187,6 +187,22 @@ type RequestResponder<Sa, Ri, Ro> = {
         logger: Logger;
     }) => RoF): (request: Ri) => RoF;
 };
+export type BatchItem<Ro> = {
+    id: string;
+    makeRequest: () => undefined | Ro;
+};
+export type BatchHandler<Sa, Ri, Ro> = (services: CompatibleServices<Sa>) => ({
+    isBatchRequest: (request: Ri) => boolean;
+    extractBatchRequests: (request: Ri) => {
+        id: string;
+        request: Ri;
+    }[];
+    responseMiddleware?: (app: Sa) => (response: Ro | undefined, request: {
+        request: Ri;
+        logger: Logger;
+    }) => Ro;
+    composeBatchResponse: (items: BatchItem<Ro>[]) => Ro;
+});
 /**
  * A factory factory for creating request responders (functions that take a request and return a
  * response -- these functions let us implement Lambda `handler` functions).
@@ -217,12 +233,13 @@ type RequestResponder<Sa, Ri, Ro> = {
  *   );
  * ```
  */
-export declare const makeGetRequestResponder: <Sa, Ru, Ri, Ro>() => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }: {
+export declare const makeGetRequestResponder: <Sa, Ru, Ri, Ro>() => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor, batch }: {
     routes: () => AnySpecificRoute<Ru, Sa, Ri, Ro>[];
     pathExtractor: RequestPathExtractor<Ri>;
     logExtractor?: RequestLogExtractor<Ri>;
     routeMatcher?: RequestRouteMatcher<Ri, AnySpecificRoute<Ru, Sa, Ri, Ro>>;
     errorHandler?: (e: Error, logger: Logger) => Ro;
+    batch?: BatchHandler<Sa, Ri, Ro>;
 }) => RequestResponder<Sa, Ri, Ro>;
 /** HTTP Headers */
 export type HttpHeaders = {

package/dist/esm/routing/index.js

@@ -150,11 +150,13 @@ const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
  *   );
  * ```
  */
-export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }) => (services, responseMiddleware) => {
+export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor, batch }) => (services, responseMiddleware) => {
     const appBinderImpl = (app, middleware) => middleware(app, appBinder);
     const appBinder = memoize(appBinderImpl);
     const boundRoutes = routes().map(bindRoute(services, appBinder, pathExtractor, routeMatcher));
     const boundResponseMiddleware = responseMiddleware ? responseMiddleware(services) : undefined;
+    const boundBatch = batch ? batch(services) : undefined;
+    const boundBatchResponseMiddleware = (boundBatch === null || boundBatch === void 0 ? void 0 : boundBatch.responseMiddleware) ? boundBatch.responseMiddleware(services) : undefined;
     const appLogger = services.logger || createConsoleLogger();
     // *note* this opaque promise guard is less generic than i hoped so
     //   i'm leaving it here instead of the guards file.
@@ -164,42 +166,58 @@ export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatc
     // promise or a non-promise value and the promise figures it out, but those
     // types are getting complicated quickly here.
     const isPromise = (thing) => thing instanceof Promise;
-    return (request) => {
-        const logger = appLogger.createSubContext();
-        if (logExtractor) {
-            logger.setContext(logExtractor(request));
-        }
-        logger.log('begin request');
+    const requestResponder = (request, logger) => {
+        const boundErrorHandler = errorHandler ? (e) => errorHandler(e, logger) : undefined;
         try {
             const route = mapFind(boundRoutes, (route) => route(request, logger));
             if (route) {
                 logger.log(`route matched ${route.name}`);
-                const result = boundResponseMiddleware ?
-                    boundResponseMiddleware(route.executor(), { request, logger }) : route.executor();
-                if (isPromise(result) && errorHandler) {
-                    const errorHandlerWithMiddleware = (e) => boundResponseMiddleware ?
-                        boundResponseMiddleware(errorHandler(e, logger), { request, logger }) : errorHandler(e, logger);
-                    return result.catch(errorHandlerWithMiddleware);
+                const result = route.executor();
+                if (isPromise(result) && boundErrorHandler) {
+                    return result.catch(boundErrorHandler);
                 }
                 else {
                     return result;
                 }
             }
-            else if (boundResponseMiddleware) {
-                logger.log('no route matched, returning 404');
-                return boundResponseMiddleware(undefined, { request, logger });
-            }
         }
         catch (e) {
-            if (errorHandler && e instanceof Error) {
-                return boundResponseMiddleware
-                    ? boundResponseMiddleware(errorHandler(e, logger), { request, logger })
-                    : errorHandler(e, logger);
+            if (boundErrorHandler && e instanceof Error) {
+                return boundErrorHandler(e);
             }
             throw e;
         }
         return undefined;
     };
+    return (request) => {
+        const logger = appLogger.createSubContext();
+        if (logExtractor)
+            logger.setContext(logExtractor(request));
+        logger.log('begin request');
+        let response = undefined;
+        if (boundBatch === null || boundBatch === void 0 ? void 0 : boundBatch.isBatchRequest(request)) {
+            const batchRequests = boundBatch.extractBatchRequests(request);
+            const batchResponses = [];
+            for (const batchRequest of batchRequests) {
+                const subRequestLogger = logger.createSubContext();
+                subRequestLogger.setContext({ batchRequestId: batchRequest.id });
+                if (logExtractor)
+                    subRequestLogger.setContext(logExtractor(batchRequest.request));
+                batchResponses.push({
+                    id: batchRequest.id,
+                    makeRequest: () => {
+                        const batchItemResponse = requestResponder(batchRequest.request, subRequestLogger);
+                        return boundBatchResponseMiddleware ? boundBatchResponseMiddleware(batchItemResponse, { request: batchRequest.request, logger: subRequestLogger }) : batchItemResponse;
+                    }
+                });
+            }
+            response = boundBatch.composeBatchResponse(batchResponses);
+        }
+        else {
+            response = requestResponder(request, logger);
+        }
+        return boundResponseMiddleware ? boundResponseMiddleware(response, { request, logger }) : response;
+    };
 };
 /**
  * Returns a JSON response. Handles serializing the data to JSON and setting the content-type header.

package/dist/esm/routing/lambdaBatchRequestHandler.d.ts

@@ -0,0 +1,13 @@
+import { APIGatewayProxyEventV2 } from 'aws-lambda';
+import { Logger } from '../services/logger';
+import { ApiResponse, BatchHandler } from '.';
+type Ro = Promise<ApiResponse<number, any>>;
+export declare const lambdaBatchRequestHandler: <Sa, Ri extends APIGatewayProxyEventV2>(config: {
+    batchPath: string;
+    concurrency: number;
+    responseMiddleware?: (app: Sa) => (response: Ro | undefined, request: {
+        request: Ri;
+        logger: Logger;
+    }) => Ro;
+}) => BatchHandler<Sa, Ri, Ro>;
+export {};

package/dist/esm/routing/lambdaBatchRequestHandler.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { asyncPool } from '../misc/asyncPool';
+import { getRequestBody } from './helpers';
+import { apiJsonResponse } from '.';
+const BatchItemSchema = z.object({
+    id: z.string(),
+    path: z.string(),
+    method: z.string(),
+    queryParams: z.record(z.string(), z.string()).optional(),
+    body: z.string().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+});
+const BatchRequestSchema = z.object({
+    requests: z.array(BatchItemSchema),
+});
+export const lambdaBatchRequestHandler = (config) => {
+    const { batchPath, concurrency, responseMiddleware } = config;
+    return () => ({
+        responseMiddleware,
+        isBatchRequest: (request) => {
+            return request.requestContext.http.path === batchPath;
+        },
+        extractBatchRequests: (request) => {
+            // Parse and validate payload
+            const payload = getRequestBody(request);
+            const parsed = BatchRequestSchema.parse(payload);
+            // Create modified requests for each batch item
+            return parsed.requests.map(item => {
+                var _a;
+                return ({
+                    id: item.id,
+                    request: {
+                        ...request,
+                        requestContext: {
+                            ...request.requestContext,
+                            http: {
+                                ...request.requestContext.http,
+                                path: item.path,
+                                method: item.method,
+                            }
+                        },
+                        headers: { ...request.headers, ...item.headers },
+                        body: (_a = item.body) !== null && _a !== void 0 ? _a : request.body,
+                        rawQueryString: item.queryParams
+                            ? new URLSearchParams(item.queryParams).toString()
+                            : request.rawQueryString,
+                    }
+                });
+            });
+        },
+        composeBatchResponse: async (items) => {
+            const results = await asyncPool(items.map(({ id, makeRequest }) => async () => {
+                const response = await makeRequest();
+                return { id, response };
+            }), concurrency);
+            const data = {
+                results: results.map(({ id, response }) => ({
+                    id,
+                    statusCode: (response === null || response === void 0 ? void 0 : response.statusCode) || 500,
+                    body: (response === null || response === void 0 ? void 0 : response.body) || '',
+                    headers: (response === null || response === void 0 ? void 0 : response.headers) || {}
+                }))
+            };
+            return apiJsonResponse(200, data);
+        }
+    });
+};

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

@@ -24,10 +24,12 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
                 return undefined;
             }
             const user = await loadUserData(initializer.fetch, await accountsBase(), resolvedCookieName, token);
-            if (user) {
+            // this returns `{"error_id":null}` when the token is invalid
+            if (user.uuid) {
                 logger.setContext({ user: user.uuid });
+                return user;
             }
-            return user;
+            return undefined;
         };
         const getUser = async () => {
             if (!user) {

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

@@ -1,3 +1,3 @@
 import { ApiUser } from '..';
 import { GenericFetch } from '../../../fetch';
-export declare const loadUserData: (fetch: GenericFetch, accountsBase: string, cookieName: string, token: string) => Promise<ApiUser | undefined>;
+export declare const loadUserData: (fetch: GenericFetch, accountsBase: string, cookieName: string, token: string) => Promise<ApiUser>;

package/dist/esm/services/httpMessageVerifier/index.js

@@ -2,6 +2,7 @@
 import { createHash } from 'crypto';
 import { createVerifier, httpbis } from 'http-message-signatures';
 import { SigningKeyNotFoundError } from 'jwks-rsa';
+import { ByteSequence, parseDictionary, parseItem, Token } from 'structured-headers';
 import { assertString } from '../../assertions';
 import { resolveConfigValue } from '../../config';
 import { InvalidRequestError } from '../../errors';
@@ -28,9 +29,25 @@ export const createHttpMessageVerifier = ({ configSpace, fetcher }) => (configPr
             // but we do not bother matching the Signature-Agent names with the Signature names
             // as that would be awkward with the packages we use
             const signatureAgentString = (_a = headers['signature-agent']) !== null && _a !== void 0 ? _a : '';
-            const signatureAgentMatches = [...signatureAgentString.matchAll(/([^=]+)="([^"]+)"/g)];
-            const signatureAgents = signatureAgentMatches.length == 0 ?
-                [signatureAgentString] : [...new Set(signatureAgentMatches.map((match) => match[2]))];
+            let rawValues;
+            // Try parsing as RFC 8941 Item first (e.g., "https://url" or bare token)
+            try {
+                rawValues = [parseItem(signatureAgentString)];
+            }
+            catch {
+                // If item parsing fails, try parsing as a Dictionary (e.g., sig="https://url")
+                rawValues = Array.from(parseDictionary(signatureAgentString).values());
+            }
+            // Convert values to strings (handle Token, string, and reject others) and deduplicate
+            const signatureAgents = [...new Set(rawValues.map(([bareItem]) => {
+                    if (bareItem instanceof Token) {
+                        return bareItem.toString();
+                    }
+                    return assertString(bareItem, new InvalidRequestError('Signature-Agent values must be strings or tokens'));
+                }))];
+            if (signatureAgents.length === 0) {
+                throw new InvalidRequestError('Signature-Agent header is required');
+            }
             const keys = (await Promise.all(signatureAgents.map(async (signatureAgent) => {
                 if (!await signatureAgentVerifier(signatureAgent)) {
                     throw new InvalidRequestError('Signature-Agent verification failed');
@@ -75,14 +92,37 @@ export const createHttpMessageVerifier = ({ configSpace, fetcher }) => (configPr
             // For example, if a GET request uses configOverride to make content-digest not required
             if (!headers['content-digest'])
                 return true;
-            const match = headers['content-digest'].match(/^(sha-256|sha-512)=:([^:]+):/);
-            if (!match)
+            let contentDigest;
+            try {
+                contentDigest = parseDictionary(headers['content-digest']);
+            }
+            catch {
                 throw new InvalidRequestError('Unsupported Content-Digest header format');
-            const contentDigestAlg = match[1];
-            const contentDigestHash = match[2];
-            const calculatedContentDigestHash = createHash(contentDigestAlg).update(assertString(body)).digest('base64');
-            if (calculatedContentDigestHash !== contentDigestHash.replace(/:/g, '')) {
-                throw new InvalidRequestError('Calculated Content-Digest value did not match header');
+            }
+            if (contentDigest.size === 0) {
+                throw new InvalidRequestError('Content-Digest header is required');
+            }
+            // Map Content-Digest algorithm names to Node's crypto algorithm names
+            const algorithmMap = {
+                'sha-256': 'sha256',
+                'sha-512': 'sha512',
+            };
+            for (const [algorithm, value] of contentDigest.entries()) {
+                const [bareItem] = value;
+                // Convert ByteSequence to string, or assert it's already a string
+                const hashValue = bareItem instanceof ByteSequence
+                    ? bareItem.toBase64()
+                    : assertString(bareItem, new InvalidRequestError('Content-Digest values must be strings'));
+                const cryptoAlgorithm = algorithmMap[algorithm];
+                if (!cryptoAlgorithm) {
+                    throw new InvalidRequestError(`Unsupported Content-Digest algorithm: ${algorithm}`);
+                }
+                // Calculate the hash
+                const calculatedHash = createHash(cryptoAlgorithm).update(assertString(body, new InvalidRequestError('Request body is required when Content-Digest is present'))).digest('base64');
+                // Compare with the provided hash
+                if (calculatedHash !== hashValue) {
+                    throw new InvalidRequestError(`Calculated Content-Digest value did not match header for algorithm ${algorithm}`);
+                }
             }
             return true;
         },