@openstax/ts-utils 1.39.1 → 1.40.0

package/dist/cjs/coolFile.d.ts

@@ -0,0 +1 @@
+content

package/dist/cjs/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/cjs/misc/asyncPool.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncPool = void 0;
+/**
+ * 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]
+ */
+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();
+    });
+};
+exports.asyncPool = asyncPool;

package/dist/cjs/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/cjs/misc/hashValue.js

@@ -8,10 +8,11 @@ const crypto_1 = require("crypto");
  * @example hashValue({someKey: 'someValue'})
  */
 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 (0, crypto_1.createHash)('sha1').update(strValue).digest('hex');
 };
 exports.hashValue = hashValue;

package/dist/cjs/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/cjs/routing/index.js

@@ -195,11 +195,13 @@ const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
  *   );
  * ```
  */
-const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }) => (services, responseMiddleware) => {
+const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor, batch }) => (services, responseMiddleware) => {
     const appBinderImpl = (app, middleware) => middleware(app, appBinder);
     const appBinder = (0, helpers_1.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 || (0, console_1.createConsoleLogger)();
     // *note* this opaque promise guard is less generic than i hoped so
     //   i'm leaving it here instead of the guards file.
@@ -209,42 +211,58 @@ const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, er
     // 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 = (0, helpers_1.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;
+    };
 };
 exports.makeGetRequestResponder = makeGetRequestResponder;
 /**

package/dist/cjs/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/cjs/routing/lambdaBatchRequestHandler.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lambdaBatchRequestHandler = void 0;
+const zod_1 = require("zod");
+const asyncPool_1 = require("../misc/asyncPool");
+const helpers_1 = require("./helpers");
+const _1 = require(".");
+const BatchItemSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    path: zod_1.z.string(),
+    method: zod_1.z.string(),
+    queryParams: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    body: zod_1.z.string().optional(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+});
+const BatchRequestSchema = zod_1.z.object({
+    requests: zod_1.z.array(BatchItemSchema),
+});
+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 = (0, helpers_1.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 (0, asyncPool_1.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 (0, _1.apiJsonResponse)(200, data);
+        }
+    });
+};
+exports.lambdaBatchRequestHandler = lambdaBatchRequestHandler;

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

@@ -27,10 +27,12 @@ const subrequestAuthProvider = (initializer) => (configProvider) => {
                 return undefined;
             }
             const user = await (0, userSubrequest_1.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/cjs/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>;