feat: include detailed validation errors in parseEvent (#73)

Co-authored-by: Claude Haiku 4.5 <noreply@anthropic.com>

Author: tonyfromundefined

.changeset/light-trains-work.md

@@ -0,0 +1,5 @@
+---
+"ventyd": patch
+---
+
+detailed validation faield error

src/standard.ts

@@ -73,13 +73,19 @@ export function standard<
   return (context) => {
     return {
       parseEvent(input) {
-        for (const eventSchema of Object.values(args.event)) {
-          try {
-            return standardValidate(eventSchema, input);
-          } catch {}
+        const record = input !== null && typeof input === "object" ? (input as Record<string, unknown>) : null;
+        const eventName = typeof record?.eventName === "string" ? record.eventName : undefined;
+
+        if (!eventName) {
+          throw new Error("Validation failed: eventName is missing");
+        }
+
+        if (!args.event[eventName]) {
+          const availableEvents = Object.keys(args.event).join(", ");
+          throw new Error(`Validation failed: event "${eventName}" is not declared. Available events: ${availableEvents}`);
         }
 
-        throw new Error("Validation failed");
+        return standardValidate(args.event[eventName], input, eventName) as $$EventType;
       },
       parseEventByName<K extends $$EventType["eventName"]>(
         eventName: K,

test/standard.spec.ts

@@ -299,7 +299,7 @@ describe("Standard Schema Provider", () => {
           entityId: "usr-123",
           body: {},
         });
-      }).toThrow("Validation failed");
+      }).toThrow('event "user:deleted" is not declared');
     });
   });
 
@@ -339,6 +339,140 @@ describe("Standard Schema Provider", () => {
         });
       }).toThrow('Validation failed: "user:created"');
     });
+
+    test("parseEvent should include event name and field details when eventName matches known schema", () => {
+      const schema = defineSchema("user", {
+        schema: standard({
+          event: {
+            "user:created": v.object({
+              eventId: v.string(),
+              eventName: v.literal("user:created"),
+              eventCreatedAt: v.string(),
+              entityName: v.string(),
+              entityId: v.string(),
+              body: v.object({
+                email: v.pipe(v.string(), v.email()),
+                age: v.pipe(v.number(), v.minValue(13)),
+              }),
+            }),
+          },
+          state: v.object({ email: v.string() }),
+        }),
+        initialEventName: "user:created",
+      });
+
+      expect(() => {
+        schema.parseEvent({
+          eventId: "evt-123",
+          eventName: "user:created",
+          eventCreatedAt: new Date().toISOString(),
+          entityName: "user",
+          entityId: "usr-123",
+          body: {
+            email: "not-an-email",
+            age: 10,
+          },
+        });
+      }).toThrow('Validation failed: "user:created"');
+    });
+
+    test("parseEvent should include field-level error paths in message", () => {
+      const schema = defineSchema("user", {
+        schema: standard({
+          event: {
+            "user:created": v.object({
+              eventId: v.string(),
+              eventName: v.literal("user:created"),
+              eventCreatedAt: v.string(),
+              entityName: v.string(),
+              entityId: v.string(),
+              body: v.object({
+                email: v.pipe(v.string(), v.email()),
+              }),
+            }),
+          },
+          state: v.object({ email: v.string() }),
+        }),
+        initialEventName: "user:created",
+      });
+
+      let errorMessage = "";
+      try {
+        schema.parseEvent({
+          eventId: "evt-123",
+          eventName: "user:created",
+          eventCreatedAt: new Date().toISOString(),
+          entityName: "user",
+          entityId: "usr-123",
+          body: { email: "not-an-email" },
+        });
+      } catch (e) {
+        errorMessage = (e as Error).message;
+      }
+
+      expect(errorMessage).toContain("body.email");
+    });
+
+    test("parseEvent should throw when eventName is undeclared", () => {
+      const schema = defineSchema("user", {
+        schema: standard({
+          event: {
+            "user:created": v.object({
+              eventId: v.string(),
+              eventName: v.literal("user:created"),
+              eventCreatedAt: v.string(),
+              entityName: v.string(),
+              entityId: v.string(),
+              body: v.object({ email: v.string() }),
+            }),
+            "user:updated": v.object({
+              eventId: v.string(),
+              eventName: v.literal("user:updated"),
+              eventCreatedAt: v.string(),
+              entityName: v.string(),
+              entityId: v.string(),
+              body: v.object({ nickname: v.string() }),
+            }),
+          },
+          state: v.object({ email: v.string() }),
+        }),
+        initialEventName: "user:created",
+      });
+
+      expect(() => {
+        schema.parseEvent({
+          eventId: "evt-123",
+          eventName: "user:deleted",
+          eventCreatedAt: new Date().toISOString(),
+          entityName: "user",
+          entityId: "usr-123",
+          body: {},
+        });
+      }).toThrow('event "user:deleted" is not declared');
+    });
+
+    test("parseEvent should throw when eventName is missing", () => {
+      const schema = defineSchema("user", {
+        schema: standard({
+          event: {
+            "user:created": v.object({
+              eventId: v.string(),
+              eventName: v.literal("user:created"),
+              eventCreatedAt: v.string(),
+              entityName: v.string(),
+              entityId: v.string(),
+              body: v.object({ email: v.string() }),
+            }),
+          },
+          state: v.object({ email: v.string() }),
+        }),
+        initialEventName: "user:created",
+      });
+
+      expect(() => {
+        schema.parseEvent({ someRandomField: "value" });
+      }).toThrow("eventName is missing");
+    });
   });
 
   describe("Type inference", () => {