@openstax/ts-utils 1.12.3 → 1.13.0

package/dist/esm/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/esm/errors/index.js

@@ -30,6 +30,21 @@ export class InvalidRequestError extends Error {
 }
 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
+ */
+export class ValidationError extends Error {
+    constructor(data) {
+        super(InvalidRequestError.TYPE);
+        this.data = data;
+    }
+    getData() { return this.data; }
+}
+ValidationError.TYPE = 'ValidationError';
+ValidationError.matches = errorIsType(ValidationError);
 /**
  * Unauthorized error
  *

package/dist/esm/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/esm/middleware/apiErrorHandler.js

@@ -1,11 +1,12 @@
 import { isAppError } from '../errors';
-import { apiTextResponse } from '../routing';
+import { apiJsonResponse, apiTextResponse } from '../routing';
 import { Level } from '../services/logger';
-const defaultHandlers = {
+export const defaultHandlers = {
     UnauthorizedError: () => apiTextResponse(401, '401 UnauthorizedError'),
     SessionExpiredError: () => apiTextResponse(440, '440 SessionExpiredError'),
     NotFoundError: (e) => apiTextResponse(404, `404 ${e.message}`),
     InvalidRequestError: (e) => apiTextResponse(400, `400 ${e.message}`),
+    ValidationError: (e) => apiJsonResponse(422, e.getData()),
 };
 /**
  * Creates an error handler. Provides default handlers for `UnauthorizedError`,
@@ -21,6 +22,8 @@ export const createErrorHandler = (inputHandlers) => {
         const name = 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(Level.Error, {

package/dist/esm/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/esm/routing/validators/zod.js

@@ -0,0 +1,8 @@
+import { ValidationError } from '../../errors';
+export const zodPayloadValidator = (validator) => (input) => {
+    const result = validator.safeParse(input);
+    if (result.success) {
+        return true;
+    }
+    throw new ValidationError(result.error.format());
+};