@openstax/ts-utils 1.12.2 → 1.13.0

package/dist/cjs/errors/index.d.ts

@@ -1,3 +1,4 @@
+import type { JsonCompatibleStruct } from '../routing';
 /**
  * Returns true if the error is defined in this library
  */
@@ -17,6 +18,19 @@ export declare class InvalidRequestError extends Error {
     static matches: (e: any) => e is typeof InvalidRequestError;
     constructor(message?: string);
 }
+/**
+ * Validation Error
+ *
+ * `ValidationError.matches(error)` is a reliable way to check if an error is an
+ * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+export declare class ValidationError extends Error {
+    static readonly TYPE = "ValidationError";
+    static matches: (e: any) => e is typeof ValidationError;
+    private data;
+    constructor(data: JsonCompatibleStruct);
+    getData(): JsonCompatibleStruct;
+}
 /**
  * Unauthorized error
  *

package/dist/cjs/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.InvalidRequestError = exports.isAppError = void 0;
+exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.ValidationError = exports.InvalidRequestError = exports.isAppError = void 0;
 /*
  * if code is split into multiple bundles, sometimes each bundle
  * will get its own definition of this module and then instanceof checks
@@ -35,6 +35,22 @@ class InvalidRequestError extends Error {
 exports.InvalidRequestError = InvalidRequestError;
 InvalidRequestError.TYPE = 'InvalidRequestError';
 InvalidRequestError.matches = errorIsType(InvalidRequestError);
+/**
+ * Validation Error
+ *
+ * `ValidationError.matches(error)` is a reliable way to check if an error is an
+ * `ValidationError`; `instanceof` checks may not work if code is split into multiple bundles
+ */
+class ValidationError extends Error {
+    constructor(data) {
+        super(InvalidRequestError.TYPE);
+        this.data = data;
+    }
+    getData() { return this.data; }
+}
+exports.ValidationError = ValidationError;
+ValidationError.TYPE = 'ValidationError';
+ValidationError.matches = errorIsType(ValidationError);
 /**
  * Unauthorized error
  *

package/dist/cjs/middleware/apiErrorHandler.d.ts

@@ -1,8 +1,17 @@
+import { InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
 import type { ApiResponse } from '../routing';
 import type { Logger } from '../services/logger';
-declare type Handlers = {
-    [key: string]: (e: Error, logger: Logger) => ApiResponse<number, any>;
+export declare type DefaultErrors = {
+    UnauthorizedError: UnauthorizedError;
+    SessionExpiredError: SessionExpiredError;
+    NotFoundError: NotFoundError;
+    InvalidRequestError: InvalidRequestError;
+    ValidationError: ValidationError;
 };
+export declare type Handlers<E> = {
+    [T in keyof E]: (e: E[T], logger: Logger) => ApiResponse<number, any>;
+};
+export declare const defaultHandlers: Handlers<DefaultErrors>;
 /**
  * Creates an error handler. Provides default handlers for `UnauthorizedError`,
  * `SessionExpiredError`, `NotFoundError`, and `InvalidRequestError`. User-specified
@@ -11,5 +20,4 @@ declare type Handlers = {
  *
  * @param inputHandlers a map of errors to handler functions
  */
-export declare const createErrorHandler: (inputHandlers?: Handlers | undefined) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;
-export {};
+export declare const createErrorHandler: <Errors = DefaultErrors>(inputHandlers?: Handlers<Errors> | undefined) => (e: Error, logger: Logger) => Promise<ApiResponse<number, any>>;

package/dist/cjs/middleware/apiErrorHandler.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createErrorHandler = void 0;
+exports.createErrorHandler = exports.defaultHandlers = void 0;
 const errors_1 = require("../errors");
 const routing_1 = require("../routing");
 const logger_1 = require("../services/logger");
-const defaultHandlers = {
+exports.defaultHandlers = {
     UnauthorizedError: () => (0, routing_1.apiTextResponse)(401, '401 UnauthorizedError'),
     SessionExpiredError: () => (0, routing_1.apiTextResponse)(440, '440 SessionExpiredError'),
     NotFoundError: (e) => (0, routing_1.apiTextResponse)(404, `404 ${e.message}`),
     InvalidRequestError: (e) => (0, routing_1.apiTextResponse)(400, `400 ${e.message}`),
+    ValidationError: (e) => (0, routing_1.apiJsonResponse)(422, e.getData()),
 };
 /**
  * Creates an error handler. Provides default handlers for `UnauthorizedError`,
@@ -19,11 +20,13 @@ const defaultHandlers = {
  * @param inputHandlers a map of errors to handler functions
  */
 const createErrorHandler = (inputHandlers) => {
-    const handlers = { ...defaultHandlers, ...inputHandlers };
+    const handlers = { ...exports.defaultHandlers, ...inputHandlers };
     return async (e, logger) => {
         const name = (0, errors_1.isAppError)(e) ? e.constructor.TYPE : e.constructor.name;
         const handler = handlers[name];
         if (handler) {
+            // convincing typescript that this error is the right kind for the handler
+            // we looked up based on the errors name is very annoying
             return handler(e, logger);
         }
         logger.logEvent(logger_1.Level.Error, {

package/dist/cjs/routing/validators/zod.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+export declare const zodPayloadValidator: <T>(validator: z.ZodType<T, z.ZodTypeDef, T>) => (input: {
+    [key: string]: any;
+}) => input is T;

package/dist/cjs/routing/validators/zod.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodPayloadValidator = void 0;
+const errors_1 = require("../../errors");
+const zodPayloadValidator = (validator) => (input) => {
+    const result = validator.safeParse(input);
+    if (result.success) {
+        return true;
+    }
+    throw new errors_1.ValidationError(result.error.format());
+};
+exports.zodPayloadValidator = zodPayloadValidator;

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

@@ -1,5 +1,5 @@
 import type { FetchConfig } from '../../fetch';
-import type { HttpHeaders } from '../../routing';
+import type { HttpHeaders, QueryParams } from '../../routing';
 export interface TokenUser {
     id: number;
     name: string;
@@ -35,15 +35,16 @@ export declare type AuthProvider = {
     getAuthorizedFetchConfig: () => Promise<FetchConfig>;
 };
 export declare type CookieAuthProviderRequest = {
-    headers: HttpHeaders;
     cookies?: string[];
+    headers: HttpHeaders;
+    queryStringParameters?: QueryParams;
 };
 export declare type CookieAuthProvider = (inputs: {
     request: CookieAuthProviderRequest;
 }) => AuthProvider;
 export declare type StubAuthProvider = (user: User | undefined) => AuthProvider;
 export declare const stubAuthProvider: (user?: User | undefined) => AuthProvider;
-export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest, cookieName: string) => [string, {
+export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest, cookieName: string, queryKey?: string) => [string, {
     Authorization: string;
 }] | [string, {
     cookie: string;

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

@@ -12,12 +12,15 @@ const stubAuthProvider = (user) => ({
     getAuthorizedFetchConfig: () => Promise.resolve(user ? { headers: { Authorization: user.uuid } } : {})
 });
 exports.stubAuthProvider = stubAuthProvider;
-const getAuthTokenOrCookie = (request, cookieName) => {
-    var _a;
+const getAuthTokenOrCookie = (request, cookieName, queryKey = 'auth') => {
+    var _a, _b;
+    const authParam = request.queryStringParameters ? request.queryStringParameters[queryKey] : undefined;
     const authHeader = (0, helpers_2.getHeader)(request.headers, 'authorization');
-    const cookieValue = cookie_1.default.parse(((_a = request.cookies) === null || _a === void 0 ? void 0 : _a.join('; ')) || '')[cookieName];
-    return authHeader && authHeader.length >= 8 && authHeader.startsWith('Bearer ')
-        ? (0, helpers_1.tuple)(authHeader.slice(7), { Authorization: authHeader })
-        : (0, helpers_1.tuple)(cookieValue, { cookie: cookie_1.default.serialize(cookieName, cookieValue) });
+    const cookieValue = cookie_1.default.parse((_b = (_a = request.cookies) === null || _a === void 0 ? void 0 : _a.join('; ')) !== null && _b !== void 0 ? _b : '')[cookieName];
+    return typeof authParam === 'string'
+        ? (0, helpers_1.tuple)(authParam, { Authorization: `Bearer ${authParam}` })
+        : authHeader && authHeader.length >= 8 && authHeader.startsWith('Bearer ')
+            ? (0, helpers_1.tuple)(authHeader.slice(7), { Authorization: authHeader })
+            : (0, helpers_1.tuple)(cookieValue, { cookie: cookie_1.default.serialize(cookieName, cookieValue) });
 };
 exports.getAuthTokenOrCookie = getAuthTokenOrCookie;