improve error logging for complex types

src/errors.ts

@@ -1,3 +1,56 @@
-export class MonarchError extends Error {}
+export enum ErrorCodes {
+  MONARCH_ERROR = "MONARCH_ERROR",
+  VALIDATION_ERROR = "VALIDATION_ERROR",
+}
 
-export class MonarchParseError extends MonarchError {}
+export class MonarchError extends Error {
+  constructor(
+    message: string,
+    public code: ErrorCodes = ErrorCodes.MONARCH_ERROR,
+    public cause?: Error,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.cause = cause;
+
+    if (!!cause && cause.stack) {
+      this.stack = `${this.stack}\nCaused by: ${cause.stack}`;
+    } else if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+export class FieldError extends Error {
+  constructor(
+    message: string,
+    public fieldPath?: (string | number)[],
+  ) {
+    super(message);
+    this.fieldPath = fieldPath ?? [];
+  }
+}
+
+export class MonarchValidationError extends MonarchError {
+  constructor(
+    message: string,
+    public fieldPath: string,
+    cause?: Error,
+  ) {
+    super(
+      `Validation error: '${fieldPath}' ${message}`,
+      ErrorCodes.VALIDATION_ERROR,
+      cause,
+    );
+  }
+}
+
+export function formatValidationPath(pathSegment: {
+  schema: string;
+  field: string;
+  path?: (string | number)[];
+}): string {
+  const { schema, field, path = [] } = pathSegment;
+  return [schema, field, ...path].join(".");
+}

src/index.ts

@@ -14,7 +14,7 @@ import { tuple } from "./types/tuple";
 import { defaulted, nullable, optional } from "./types/type";
 import { union } from "./types/union";
 
-export { ObjectId } from "mongodb";
+export { MongoClient, MongoError, ObjectId } from "mongodb";
 export { Collection } from "./collection/collection";
 export {
   createClient,

src/schema/schema.ts

@@ -1,5 +1,10 @@
 import type { Projection } from "../collection/types/query-options";
 import { detectProjection } from "../collection/utils/projection";
+import {
+  FieldError,
+  MonarchValidationError,
+  formatValidationPath,
+} from "../errors";
 import { objectId } from "../types/objectId";
 import { type AnyMonarchType, MonarchType } from "../types/type";
 import type { Pretty, WithOptionalId } from "../utils/type-helpers";
@@ -52,10 +57,24 @@ export class Schema<
     // parse fields
     const types = Schema.types(this);
     for (const [key, type] of Object.entries(types)) {
-      const parser = MonarchType.parser(type);
-      const parsed = parser(input[key as keyof InferSchemaInput<this>]);
-      if (parsed === undefined) continue;
-      data[key as keyof typeof data] = parsed;
+      try {
+        const parser = MonarchType.parser(type);
+        const parsed = parser(input[key as keyof InferSchemaInput<this>]);
+        if (parsed === undefined) continue;
+        data[key as keyof typeof data] = parsed;
+      } catch (error) {
+        if (error instanceof FieldError) {
+          throw new MonarchValidationError(
+            error.message,
+            formatValidationPath({
+              schema: this.name,
+              field: key,
+              path: error.fieldPath,
+            }),
+          );
+        }
+        throw error;
+      }
     }
     return data;
   }

src/types/array.ts

@@ -1,4 +1,4 @@
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { type AnyMonarchType, MonarchType } from "./type";
 import type { InferTypeInput, InferTypeOutput } from "./type-helpers";
 
@@ -18,19 +18,18 @@ export class MonarchArray<T extends AnyMonarchType> extends MonarchType<
             const parser = MonarchType.parser(type);
             parsed[index] = parser(value);
           } catch (error) {
-            if (error instanceof MonarchParseError) {
-              throw new MonarchParseError(
-                `element at index '${index}' ${error.message}`,
-              );
+            if (error instanceof FieldError) {
+              throw new FieldError(error.message, [
+                index,
+                ...(error.fieldPath ?? []),
+              ]);
             }
             throw error;
           }
         }
         return parsed;
       }
-      throw new MonarchParseError(
-        `expected 'array' received '${typeof input}'`,
-      );
+      throw new FieldError(`expected 'array' received '${typeof input}'`);
     });
   }
 }

src/types/boolean.ts

@@ -1,4 +1,4 @@
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { MonarchType } from "./type";
 
 export const boolean = () => new MonarchBoolean();
@@ -7,9 +7,7 @@ export class MonarchBoolean extends MonarchType<boolean, boolean> {
   constructor() {
     super((input) => {
       if (typeof input === "boolean") return input;
-      throw new MonarchParseError(
-        `expected 'boolean' received '${typeof input}'`,
-      );
+      throw new FieldError(`expected 'boolean' received '${typeof input}'`);
     });
   }
 }

src/types/date.ts

@@ -1,4 +1,4 @@
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { MonarchType } from "./type";
 
 export const date = () => new MonarchDate();
@@ -7,15 +7,15 @@ export class MonarchDate extends MonarchType<Date, Date> {
   constructor() {
     super((input) => {
       if (input instanceof Date) return input;
-      throw new MonarchParseError(`expected 'Date' received '${typeof input}'`);
+      throw new FieldError(`expected 'Date' received '${typeof input}'`);
     });
   }
 
   public after(afterDate: Date) {
     return date().extend(this, {
       preParse: (input) => {
         if (input > afterDate) return input;
-        throw new MonarchParseError(`date must be after ${afterDate}`);
+        throw new FieldError(`date must be after ${afterDate}`);
       },
     });
   }
@@ -24,7 +24,7 @@ export class MonarchDate extends MonarchType<Date, Date> {
     return date().extend(this, {
       preParse: (input) => {
         if (input > targetDate) {
-          throw new MonarchParseError(
+          throw new FieldError(
             `date must be before ${targetDate.toISOString()}`,
           );
         }
@@ -51,7 +51,7 @@ export class MonarchDateString extends MonarchType<string, Date> {
       if (typeof input === "string" && !Number.isNaN(Date.parse(input))) {
         return new Date(input);
       }
-      throw new MonarchParseError(
+      throw new FieldError(
         `expected 'ISO Date string' received '${typeof input}'`,
       );
     });
@@ -62,7 +62,7 @@ export class MonarchDateString extends MonarchType<string, Date> {
       preParse: (input) => {
         const date = new Date(input);
         if (date > afterDate) return input;
-        throw new MonarchParseError(`date must be after ${afterDate}`);
+        throw new FieldError(`date must be after ${afterDate}`);
       },
     });
   }
@@ -72,7 +72,7 @@ export class MonarchDateString extends MonarchType<string, Date> {
       preParse: (input) => {
         const date = new Date(input);
         if (date > targetDate) {
-          throw new MonarchParseError(
+          throw new FieldError(
             `date must be before ${targetDate.toISOString()}`,
           );
         }

src/types/literal.ts

@@ -1,4 +1,4 @@
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { MonarchType } from "./type";
 
 export const literal = <T extends string | number | boolean>(...values: T[]) =>
@@ -11,7 +11,7 @@ export class MonarchLiteral<
     super((input) => {
       const _values = new Set(values);
       if (_values.has(input)) return input;
-      throw new MonarchParseError(
+      throw new FieldError(
         `unknown value '${input}', literal may only specify known values`,
       );
     });

src/types/number.ts

@@ -1,4 +1,4 @@
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { MonarchType } from "./type";
 
 export const number = () => new MonarchNumber();
@@ -7,17 +7,15 @@ export class MonarchNumber extends MonarchType<number, number> {
   constructor() {
     super((input) => {
       if (typeof input === "number") return input;
-      throw new MonarchParseError(
-        `expected 'number' received '${typeof input}'`,
-      );
+      throw new FieldError(`expected 'number' received '${typeof input}'`);
     });
   }
 
   public min(value: number) {
     return number().extend(this, {
       preParse: (input) => {
         if (input < value) {
-          throw new MonarchParseError(
+          throw new FieldError(
             `number must be greater than or equal to ${value}`,
           );
         }
@@ -30,9 +28,7 @@ export class MonarchNumber extends MonarchType<number, number> {
     return number().extend(this, {
       preParse: (input) => {
         if (input > value) {
-          throw new MonarchParseError(
-            `number must be less than or equal to ${value}`,
-          );
+          throw new FieldError(`number must be less than or equal to ${value}`);
         }
         return input;
       },
@@ -51,7 +47,7 @@ export class MonarchNumber extends MonarchType<number, number> {
     return number().extend(this, {
       postParse: (input) => {
         if (input % value !== 0) {
-          throw new MonarchParseError(`number must be a multiple of ${value}`);
+          throw new FieldError(`number must be a multiple of ${value}`);
         }
         return input;
       },

src/types/object.ts

@@ -1,4 +1,4 @@
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { type AnyMonarchType, MonarchType } from "./type";
 import type {
   InferTypeInput,
@@ -17,7 +17,7 @@ export class MonarchObject<
       if (typeof input === "object" && input !== null) {
         for (const key of Object.keys(input)) {
           if (!(key in types)) {
-            throw new MonarchParseError(
+            throw new FieldError(
               `unknown field '${key}', object may only specify known fields`,
             );
           }
@@ -33,17 +33,18 @@ export class MonarchObject<
               input[key as keyof typeof input] as InferTypeInput<T[keyof T]>,
             );
           } catch (error) {
-            if (error instanceof MonarchParseError) {
-              throw new MonarchParseError(`field '${key}' ${error.message}'`);
+            if (error instanceof FieldError) {
+              throw new FieldError(error.message, [
+                key,
+                ...(error.fieldPath ?? []),
+              ]);
             }
             throw error;
           }
         }
         return parsed;
       }
-      throw new MonarchParseError(
-        `expected 'object' received '${typeof input}'`,
-      );
+      throw new FieldError(`expected 'object' received '${typeof input}'`);
     });
   }
 }

src/types/objectId.ts

@@ -1,5 +1,5 @@
 import { ObjectId } from "mongodb";
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { MonarchType } from "./type";
 
 export const objectId = () => new MonarchObjectId();
@@ -8,7 +8,7 @@ export class MonarchObjectId extends MonarchType<ObjectId | string, ObjectId> {
   constructor() {
     super((input) => {
       if (ObjectId.isValid(input)) return new ObjectId(input);
-      throw new MonarchParseError(
+      throw new FieldError(
         `expected valid ObjectId received '${typeof input}' ${input}`,
       );
     });

src/types/record.ts

@@ -1,4 +1,4 @@
-import { MonarchParseError } from "../errors";
+import { FieldError } from "../errors";
 import { type AnyMonarchType, MonarchType } from "./type";
 import type { InferTypeInput, InferTypeOutput } from "./type-helpers";
 
@@ -18,17 +18,18 @@ export class MonarchRecord<T extends AnyMonarchType> extends MonarchType<
             const parser = MonarchType.parser(type);
             parsed[key] = parser(value);
           } catch (error) {
-            if (error instanceof MonarchParseError) {
-              throw new MonarchParseError(`field '${key}' ${error.message}'`);
+            if (error instanceof FieldError) {
+              throw new FieldError(error.message, [
+                key,
+                ...(error.fieldPath ?? []),
+              ]);
             }
             throw error;
           }
         }
         return parsed;
       }
-      throw new MonarchParseError(
-        `expected 'object' received '${typeof input}'`,
-      );
+      throw new FieldError(`expected 'object' received '${typeof input}'`);
     });
   }
 }