@eventvisor/sdk 0.21.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventvisor/sdk",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Eventvisor SDK for Node.js and the browser",
   "main": "dist/index.cjs.js",
   "module": "dist/index.mjs",
@@ -39,7 +39,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@eventvisor/types": "0.21.0"
+    "@eventvisor/types": "0.23.0"
   },
-  "gitHead": "f86d31fbe7faed68227bcbfde599950d9ce40816"
+  "gitHead": "8e89c74cde2a35ab0cf76b00f964cf8e606d9b22"
 }

package/src/instance.spec.ts

@@ -181,4 +181,293 @@ describe("sdk: instance", function () {
     // should not increase
     expect(capturedHandles.length).toEqual(1);
   });
+
+  describe("skipValidation", function () {
+    const baseDatafile: DatafileContent = {
+      ...emptyDatafile,
+      events: {
+        strictEvent: {
+          type: "object",
+          properties: {
+            url: { type: "string" },
+            count: { type: "number" },
+          },
+          required: ["url", "count"],
+        },
+      },
+      destinations: {
+        test: {
+          transport: "test",
+          transforms: [
+            { type: "set", value: {} },
+            { type: "set", source: "payload", target: "payload" },
+            { type: "set", source: "eventName", target: "eventName" },
+          ],
+        },
+      },
+    };
+
+    async function createEventvisorWithDatafile(datafile: DatafileContent) {
+      const captured: Record<string, any>[] = [];
+      const eventvisor = createInstance({
+        datafile,
+        modules: [
+          {
+            name: "test",
+            transport: async ({ destinationName, eventName, payload }) => {
+              captured.push({ destinationName, eventName, payload });
+            },
+          },
+        ],
+        logLevel: "warn",
+      });
+      await eventvisor.onReady();
+      return { eventvisor, captured };
+    }
+
+    it("runs validation when skipValidation is undefined", async function () {
+      const { eventvisor, captured } = await createEventvisorWithDatafile(baseDatafile);
+
+      const validResult = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+        count: 1,
+      });
+      expect(validResult).not.toBeNull();
+      expect(captured.length).toBe(1);
+      expect(captured[0].payload.payload).toEqual({
+        url: "https://example.com",
+        count: 1,
+      });
+
+      const invalidResult = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+        // missing required "count"
+      } as any);
+      expect(invalidResult).toBeNull();
+      expect(captured.length).toBe(1); // still 1, not 2
+    });
+
+    it("runs validation when skipValidation is true", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: true,
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      const invalidResult = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+      } as any);
+      expect(invalidResult).toBeNull();
+      expect(captured.length).toBe(0);
+    });
+
+    it("skips validation when skipValidation is false", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: false,
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      const result = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+        // missing required "count" - would fail validation
+      } as any);
+      expect(result).not.toBeNull();
+      expect(captured.length).toBe(1);
+      expect(captured[0].payload.payload).toEqual({ url: "https://example.com" });
+    });
+
+    it("skips validation when skipValidation.conditions do NOT match", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: {
+              conditions: [
+                {
+                  source: "eventName",
+                  operator: "equals",
+                  value: "otherEvent",
+                },
+              ],
+            },
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      // eventName is "strictEvent", condition expects "otherEvent" -> not matched -> skip validation
+      const result = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+      } as any);
+      expect(result).not.toBeNull();
+      expect(captured.length).toBe(1);
+      expect(captured[0].payload.payload).toEqual({ url: "https://example.com" });
+    });
+
+    it("runs validation when skipValidation.conditions match", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: {
+              conditions: [
+                {
+                  source: "eventName",
+                  operator: "equals",
+                  value: "strictEvent",
+                },
+              ],
+            },
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      // condition matches -> validate -> invalid payload fails
+      const invalidResult = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+      } as any);
+      expect(invalidResult).toBeNull();
+      expect(captured.length).toBe(0);
+
+      // valid payload still passes
+      const validResult = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+        count: 2,
+      });
+      expect(validResult).not.toBeNull();
+      expect(captured.length).toBe(1);
+      expect(captured[0].payload.payload).toEqual({
+        url: "https://example.com",
+        count: 2,
+      });
+    });
+
+    it("skipValidation.conditions with payload source: skips when condition does not match", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: {
+              conditions: [
+                {
+                  payload: "skip",
+                  operator: "equals",
+                  value: true,
+                },
+              ],
+            },
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      // payload.skip !== true -> conditions not matched -> skip validation
+      const result = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+      } as any);
+      expect(result).not.toBeNull();
+      expect(captured.length).toBe(1);
+
+      // payload.skip === true -> conditions matched -> run validation -> invalid fails
+      const result2 = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+        skip: true,
+      } as any);
+      expect(result2).toBeNull();
+      expect(captured.length).toBe(1);
+    });
+
+    it("skipValidation.conditions with multiple conditions (and semantics): all must match to run validation", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: {
+              conditions: [
+                { source: "eventName", operator: "equals", value: "strictEvent" },
+                { payload: "env", operator: "equals", value: "prod" },
+              ],
+            },
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      // only eventName matches, env !== "prod" -> conditions not all matched -> skip validation
+      const result = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+        env: "dev",
+      } as any);
+      expect(result).not.toBeNull();
+      expect(captured.length).toBe(1);
+
+      // both match -> validate -> invalid (missing count) fails
+      const result2 = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+        env: "prod",
+      } as any);
+      expect(result2).toBeNull();
+      expect(captured.length).toBe(1);
+    });
+
+    it("skipValidation as empty object does not skip validation", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: {},
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      const invalidResult = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+      } as any);
+      expect(invalidResult).toBeNull();
+      expect(captured.length).toBe(0);
+    });
+
+    it("skipValidation.conditions with single condition as object (not array)", async function () {
+      const datafile: DatafileContent = {
+        ...baseDatafile,
+        events: {
+          strictEvent: {
+            ...baseDatafile.events!.strictEvent!,
+            skipValidation: {
+              conditions: {
+                source: "eventName",
+                operator: "equals",
+                value: "otherEvent",
+              },
+            },
+          } as any,
+        },
+      };
+      const { eventvisor, captured } = await createEventvisorWithDatafile(datafile);
+
+      const result = await eventvisor.trackAsync("strictEvent", {
+        url: "https://example.com",
+      } as any);
+      expect(result).not.toBeNull();
+      expect(captured.length).toBe(1);
+    });
+  });
 });

package/src/instance.ts

@@ -331,20 +331,54 @@ export class Eventvisor {
     /**
      * Validate
      */
-    let error: Error | undefined = value instanceof Error ? value : undefined;
-    const validationResult = await this.validator.validate(eventSchema, value);
+    let shouldValidate = true;
+
+    if (typeof eventSchema.skipValidation !== "undefined") {
+      if (eventSchema.skipValidation === false) {
+        // boolean
+        shouldValidate = false;
+      } else if (
+        typeof eventSchema.skipValidation === "object" &&
+        eventSchema.skipValidation.conditions
+      ) {
+        const isMatched = await this.conditionsChecker.allAreMatched(
+          eventSchema.skipValidation.conditions,
+          {
+            eventName,
+            eventLevel,
+            payload: value,
+          },
+        );
+
+        if (!isMatched) {
+          shouldValidate = false;
+        }
+      }
+    }
+
+    let validatedValue: Value | undefined = undefined;
+    let error = value instanceof Error ? value : undefined;
 
-    if (!validationResult.valid) {
-      this.logger.warn(`Event validation failed`, {
+    if (shouldValidate) {
+      const validationResult = await this.validator.validate(eventSchema, value);
+
+      if (!validationResult.valid) {
+        this.logger.warn(`Event validation failed`, {
+          eventName,
+          errors: validationResult.errors,
+        });
+
+        return null; // @TODO: allow to continue based on schema later
+      }
+
+      validatedValue = validationResult.value;
+    } else {
+      this.logger.debug(`Event validation skipped`, {
         eventName,
-        errors: validationResult.errors,
       });
-
-      return null; // @TODO: allow to continue based on schema later
+      validatedValue = value;
     }
 
-    const validatedValue = validationResult.value;
-
     /**
      * Conditions
      */