Improve errors

Author: etienne-dldc

src/compression/Compression.ts

@@ -3,12 +3,12 @@ import { createKey, HttpHeader } from "../core/mod.ts";
 import { ContentEncoding } from "./ContentEnconding.ts";
 import { compress } from "./compress.ts";
 
-export interface ICompression {
+export interface TCompression {
   readonly acceptedEncoding: readonly ContentEncoding[];
   readonly usedEncoding: null | ContentEncoding;
 }
 
-export const CompressionKey: TKey<ICompression> = createKey<ICompression>(
+export const CompressionKey: TKey<TCompression> = createKey<TCompression>(
   "Compress",
 );
 export const CompressConsumer = CompressionKey.Consumer;
@@ -25,7 +25,7 @@ export function Compression(): Middleware {
         : [ContentEncoding.Identity];
 
     const usedEncoding = selectEncoding(acceptedEncoding);
-    const compressCtx: ICompression = {
+    const compressCtx: TCompression = {
       acceptedEncoding,
       usedEncoding,
     };

src/core/HttpErreur.ts

@@ -6,44 +6,55 @@ import type {
 } from "./HttpStatus.ts";
 import { HttpStatus } from "./HttpStatus.ts";
 
-export interface IHttpErreurData {
+export interface THttpErreurData {
   name: HttpStatusName;
   code: HttpStatusCode;
   message: HttpStatusMessage;
 }
 
-const HttpErreurInternal: TErreurStore<IHttpErreurData> = createErreurStore<
-  IHttpErreurData
+const HttpErreurInternal: TErreurStore<THttpErreurData> = createErreurStore<
+  THttpErreurData
 >();
 
 export const HttpErreur = HttpErreurInternal.asReadonly;
 
+export function markHttpErreur(
+  error: unknown,
+  codeOrName: HttpStatusCode | HttpStatusName = 500,
+  message?: HttpStatusMessage,
+): Error {
+  return HttpErreurInternal.setAndReturn(
+    error,
+    resolveHttpErrorParams(codeOrName, message),
+  );
+}
+
 export function createHttpErreur(
   codeOrName: HttpStatusCode | HttpStatusName = 500,
-  messageOrCause?: HttpStatusMessage | Error,
+  message?: HttpStatusMessage,
+  cause?: Error,
 ): Error {
+  const httpError = resolveHttpErrorParams(codeOrName, message);
+  const error = new Error(`${httpError.message} (${httpError.name})`, {
+    cause,
+  });
+  return HttpErreurInternal.setAndReturn(error, httpError);
+}
+
+function resolveHttpErrorParams(
+  codeOrName: HttpStatusCode | HttpStatusName = 500,
+  message?: HttpStatusMessage,
+): THttpErreurData {
   const code: HttpStatusCode = typeof codeOrName === "number"
     ? codeOrName
     : HttpStatus.fromName(codeOrName).code;
   const status = HttpStatus.fromCode(code);
-  const messageStr = messageOrCause
-    ? typeof messageOrCause === "string"
-      ? messageOrCause
-      : messageOrCause.message
-    : undefined;
-  const fullMessage = `${code} ${status.name}${
-    messageStr ? `: ${messageStr}` : ""
-  }`;
-  const error = messageOrCause instanceof Error
-    ? messageOrCause
-    : new Error(fullMessage);
-  return HttpErreurInternal.setAndReturn(error, {
-    code,
-    name: status.name,
-    message: messageStr ?? status.message,
-  });
+  const messageResolved = message ?? status.message;
+  return { code, name: status.name, message: messageResolved };
 }
 
+/** */
+
 export type THttpErreurDetailsData =
   | { type: "Unauthorized"; reason?: string }
   | { type: "NotFound" }
@@ -59,82 +70,124 @@ const HttpErreurDetailsInternal: TErreurStore<THttpErreurDetailsData> =
 
 export const HttpErreurDetails = HttpErreurDetailsInternal.asReadonly;
 
-export function createUnauthorized(reason?: string): Error {
+export function markUnauthorized(error: unknown, reason?: string): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    markHttpErreur(error, "Unauthorized", "Unauthorized"),
+    { type: "Unauthorized", reason },
+  );
+}
+
+export function createUnauthorized(reason?: string, cause?: Error): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    createHttpErreur("Unauthorized", "Unauthorized", cause),
+    { type: "Unauthorized", reason },
+  );
+}
+
+export function markNotFound(error: unknown): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur("Unauthorized", "Unauthorized"),
-    {
-      type: "Unauthorized",
-      reason,
-    },
+    markHttpErreur(error, "NotFound", "Not Found"),
+    { type: "NotFound" },
   );
 }
 
-export function createNotFound(): Error {
+export function createNotFound(cause?: Error): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur("NotFound", "Not Found"),
+    createHttpErreur("NotFound", "Not Found", cause),
     { type: "NotFound" },
   );
 }
 
-export function createNotAcceptable(): Error {
+export function markNotAcceptable(error: unknown): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    markHttpErreur(error, "NotAcceptable", "Not Acceptable"),
+    { type: "NotAcceptable" },
+  );
+}
+
+export function createNotAcceptable(cause?: Error): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur("NotAcceptable", "Not Acceptable"),
-    {
-      type: "NotAcceptable",
-    },
+    createHttpErreur("NotAcceptable", "Not Acceptable", cause),
+    { type: "NotAcceptable" },
   );
 }
 
-export function createBadRequest(message?: string): Error {
+export function markBadRequest(error: unknown, message?: string): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur("BadRequest", message ?? "Bad Request"),
-    {
-      type: "BadRequest",
-      message,
-    },
+    markHttpErreur(error, "BadRequest", message ?? "Bad Request"),
+    { type: "BadRequest", message },
   );
 }
 
-export function createForbidden(reason?: string): Error {
+export function createBadRequest(message?: string, cause?: Error): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur("Forbidden", "Forbidden"),
-    {
-      type: "Forbidden",
-      reason,
-    },
+    createHttpErreur("BadRequest", message ?? "Bad Request", cause),
+    { type: "BadRequest", message },
+  );
+}
+
+export function markForbidden(error: unknown, reason?: string): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    markHttpErreur(error, "Forbidden", "Forbidden"),
+    { type: "Forbidden", reason },
+  );
+}
+
+export function createForbidden(reason?: string, cause?: Error): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    createHttpErreur("Forbidden", "Forbidden", cause),
+    { type: "Forbidden", reason },
+  );
+}
+
+export function markInternalServerError(
+  error: unknown,
+  message?: string,
+): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    markHttpErreur(error, "InternalServerError", message),
+    { type: "InternalServerError", message },
   );
 }
 
 export function createInternalServerError(
-  messageOrCause?: string | Error,
+  message?: string,
+  cause?: Error,
+): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    createHttpErreur("InternalServerError", message, cause),
+    { type: "InternalServerError", message },
+  );
+}
+
+export function markServerDidNotRespond(
+  error: unknown,
+): Error {
+  return HttpErreurDetailsInternal.setAndReturn(
+    markHttpErreur(error, "InternalServerError", "Server did not respond"),
+    { type: "ServerDidNotRespond" },
+  );
+}
+
+export function createServerDidNotRespond(
+  cause?: Error,
 ): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur(
-      "InternalServerError",
-      messageOrCause ?? "Internal Server Error",
-    ),
-    {
-      type: "InternalServerError",
-      message: messageOrCause instanceof Error ? undefined : messageOrCause,
-    },
+    createHttpErreur("InternalServerError", "Server did not respond", cause),
+    { type: "ServerDidNotRespond" },
   );
 }
 
-export function createServerDidNotRespond(): Error {
+export function markTooManyRequests(error: unknown, reason?: string): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur("InternalServerError", "Server did not respond"),
-    {
-      type: "ServerDidNotRespond",
-    },
+    markHttpErreur(error, "TooManyRequests", reason),
+    { type: "TooManyRequests", reason },
   );
 }
 
-export function createTooManyRequests(reason?: string): Error {
+export function createTooManyRequests(reason?: string, cause?: Error): Error {
   return HttpErreurDetailsInternal.setAndReturn(
-    createHttpErreur("TooManyRequests"),
-    {
-      type: "TooManyRequests",
-      reason,
-    },
+    createHttpErreur("TooManyRequests", reason, cause),
+    { type: "TooManyRequests", reason },
   );
 }

src/core/createHandler.ts

@@ -1,3 +1,4 @@
+import { createServerDidNotRespond } from "./HttpErreur.ts";
 import { ZenContext } from "./ZenContext.ts";
 import { ZenResponse } from "./ZenResponse.ts";
 import type { Middleware } from "./compose.ts";
@@ -13,7 +14,7 @@ export function createHandler(middleware: Middleware): Handler {
     try {
       const zenContext = ZenContext.fromRequest(request);
       const zenResponse = await middleware(zenContext, () => {
-        throw new Error("Server did not respond");
+        throw createServerDidNotRespond();
       });
       const res = ZenResponse.toResponse(zenResponse);
       return res;

src/errors/ErrorToHttpError.ts

@@ -3,29 +3,22 @@ import type { Middleware } from "../core/mod.ts";
 import { createInternalServerError, HttpErreur } from "../core/mod.ts";
 import { LoggerConsumer } from "../logger/mod.ts";
 
-export type ErrorToHttpErrorOptions = {
-  logOnError?: boolean;
-};
-
 /**
  * Handle any error and convert it to an HttpError if it's not one
  */
-export function ErrorToHttpError(
-  { logOnError = true }: ErrorToHttpErrorOptions = {},
-): Middleware {
+export function ErrorToHttpError(): Middleware {
   return async (ctx, next) => {
     try {
       return await next(ctx);
     } catch (error) {
       const err = toError(error);
+      const logger = ctx.get(LoggerConsumer);
       if (HttpErreur.has(err)) {
+        logger.info(`Error is already an HttpError, skipping conversion`);
         throw err;
       }
-      if (logOnError) {
-        const logger = ctx.get(LoggerConsumer);
-        logger.error(error);
-      }
-      throw createInternalServerError(err);
+      logger.log(`Rewriting error to HttpError`);
+      throw createInternalServerError(undefined, err);
     }
   };
 }

src/errors/HttpErrorToTextResponse.ts

@@ -1,18 +1,30 @@
 import { toError } from "@dldc/erreur";
 import type { Middleware } from "../core/mod.ts";
 import { HttpErreur, ZenResponse } from "../core/mod.ts";
+import { LoggerConsumer } from "../logger/mod.ts";
+
+export type HttpErrorToTextResponseOptions = {
+  logOnError?: boolean;
+};
 
 /**
  * Handle HttpError and respond with a Text reponse
  */
-export function HttpErrorToTextResponse(): Middleware {
+export function HttpErrorToTextResponse(
+  { logOnError = false }: HttpErrorToTextResponseOptions = {},
+): Middleware {
   return async (ctx, next) => {
     try {
       return await next(ctx);
     } catch (error) {
       const err = toError(error);
       const httpError = HttpErreur.get(err);
       if (httpError) {
+        if (logOnError) {
+          const logger = ctx.get(LoggerConsumer);
+          logger.error(`Handled HttpError: ${httpError.message}`);
+          logger.error(httpError);
+        }
         return ZenResponse.create(
           `Error ${httpError.code} ${httpError.message}`,
           { status: httpError.code },

src/errors/mod.ts

@@ -1,6 +1,5 @@
-export {
-  ErrorToHttpError,
-  type ErrorToHttpErrorOptions,
-} from "./ErrorToHttpError.ts";
+export { ErrorToHttpError } from "./ErrorToHttpError.ts";
 export { HttpErrorToTextResponse } from "./HttpErrorToTextResponse.ts";
+export type { HttpErrorToTextResponseOptions } from "./HttpErrorToTextResponse.ts";
 export { InvalidResponseToHttpError } from "./InvalidResponseToHttpError.ts";
+export type { InvalidResponseToHttpErrorOptions } from "./InvalidResponseToHttpError.ts";

src/zenjson/ZenjsonParser.ts

@@ -10,16 +10,16 @@ export const GetZenjsonBodyKey: TKey<GetZenjsonBody> = createKey<
 >("ZenjsonParser");
 export const GetZenjsonBodyKeyConsumer = GetZenjsonBodyKey.Consumer;
 
-interface IZenjsonConfig {
+interface TZenjsonConfig {
   sanitize?: typeof zen.sanitize;
   restore?: typeof zen.restore;
 }
 
-export const ZenjsonConfig: TKey<IZenjsonConfig> = createKey<IZenjsonConfig>(
+export const ZenjsonConfig: TKey<TZenjsonConfig> = createKey<TZenjsonConfig>(
   "ZenjsonConfig",
 );
 
-export function ZenjsonParser(options: IZenjsonConfig = {}): Middleware {
+export function ZenjsonParser(options: TZenjsonConfig = {}): Middleware {
   const restore = options.restore ?? zen.restore;
 
   return (ctx, next): Promise<any> => {

src/zenjson/zenjson.ts

@@ -3,12 +3,15 @@ import type { ZenContext, ZenResponse } from "../core/mod.ts";
 import { json } from "../json/mod.ts";
 import { ZenjsonConfig } from "./ZenjsonParser.ts";
 
-interface IOptions extends ResponseInit {
+export interface TZenjsonOptions extends ResponseInit {
   sanitize?: typeof defaultSanitize;
   context?: ZenContext;
 }
 
-export function zenjson<Data>(data: Data, options: IOptions = {}): ZenResponse {
+export function zenjson<Data>(
+  data: Data,
+  options: TZenjsonOptions = {},
+): ZenResponse {
   const sanitize = (() => {
     if (options.context) {
       const config = options.context.get(ZenjsonConfig.Consumer);