@eventvisor/sdk 0.23.0 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventvisor/sdk",
-  "version": "0.23.0",
+  "version": "0.25.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.23.0"
+    "@eventvisor/types": "0.25.0"
   },
-  "gitHead": "8e89c74cde2a35ab0cf76b00f964cf8e606d9b22"
+  "gitHead": "a111ef75495811e9992463bae964c43f5b3482b9"
 }

package/src/instance.spec.ts

@@ -208,7 +208,7 @@ describe("sdk: instance", function () {
     };
 
     async function createEventvisorWithDatafile(datafile: DatafileContent) {
-      const captured: Record<string, any>[] = [];
+      const captured: any[] = [];
       const eventvisor = createInstance({
         datafile,
         modules: [
@@ -470,4 +470,90 @@ describe("sdk: instance", function () {
       expect(captured.length).toBe(1);
     });
   });
+
+  describe("strict object schemas", function () {
+    it("rejects tracked event payloads with unknown object properties", async function () {
+      const captured: any[] = [];
+      const eventvisor = createInstance({
+        datafile: {
+          ...emptyDatafile,
+          events: {
+            strictEvent: {
+              type: "object",
+              properties: {
+                screen: {
+                  type: "object",
+                  properties: {
+                    width: { type: "number" },
+                  },
+                  required: ["width"],
+                },
+              },
+              required: ["screen"],
+            },
+          },
+          destinations: {
+            test: {
+              transport: "test",
+              transforms: [
+                { type: "set", value: {} },
+                { type: "set", source: "payload", target: "payload" },
+              ],
+            },
+          },
+        },
+        modules: [
+          {
+            name: "test",
+            transport: async ({ payload }) => {
+              captured.push(payload);
+            },
+          },
+        ],
+        logLevel: "warn",
+      });
+
+      await eventvisor.onReady();
+
+      const result = await eventvisor.trackAsync("strictEvent", {
+        screen: {
+          width: 100,
+          height: 200,
+        },
+      } as any);
+
+      expect(result).toBeNull();
+      expect(captured).toEqual([]);
+    });
+
+    it("rejects attribute values with unknown object properties", async function () {
+      const eventvisor = createInstance({
+        datafile: {
+          ...emptyDatafile,
+          attributes: {
+            browser: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+              },
+              required: ["name", "version"],
+            },
+          },
+        },
+        logLevel: "warn",
+      });
+
+      await eventvisor.onReady();
+
+      const result = await eventvisor.setAttributeAsync("browser", {
+        name: "Chrome",
+        version: "123",
+        major: 123,
+      } as any);
+
+      expect(result).toBeNull();
+      expect(eventvisor.getAttributeValue("browser")).toBeNull();
+    });
+  });
 });

package/src/modulesManager.ts

@@ -34,7 +34,7 @@ export interface TransportOptions {
   destinationName: DestinationName;
   eventName: EventName;
   eventLevel?: EventLevel;
-  payload: Value; // @TODO: rename to body?
+  payload: Value;
   error?: Error;
 }
 
@@ -60,11 +60,11 @@ export interface ModuleDependencies {
 export interface Module {
   name: ModuleName;
 
-  // initialize?
+  // @TODO: initialize?
 
   lookup?: (options: LookupOptions, deps: ModuleDependencies) => Promise<Value>;
 
-  // transform?: (options: TransformOptions, deps: ModuleDependencies) => Promise<Value>;
+  // @TODO: transform?: (options: TransformOptions, deps: ModuleDependencies) => Promise<Value>;
 
   handle?: (options: HandleOptions, deps: ModuleDependencies) => Promise<void>;
 

package/src/sourceResolver.spec.ts

@@ -39,6 +39,9 @@ describe("SourceResolver", () => {
       destinations: {},
       effects: {
         effect1: {
+          on: {
+            event_tracked: ["event1"],
+          },
           state: {
             nested: {
               value: "effect1 value",
@@ -46,6 +49,9 @@ describe("SourceResolver", () => {
           },
         },
         effect2: {
+          on: {
+            event_tracked: ["event2"],
+          },
           state: 123,
         },
       },
@@ -165,6 +171,12 @@ describe("SourceResolver", () => {
         },
       ),
     ).toEqual(25);
+
+    expect(
+      await sourceResolver.resolve("payload.screen.width", {
+        payload: {},
+      }),
+    ).toEqual(undefined);
   });
 
   it("should resolve attributes", async () => {

package/src/sourceResolver.ts

@@ -27,7 +27,13 @@ export type SourceOrigin = SourcePath & {
 };
 
 function findValueAtPath(obj: any, path: string[]): any {
-  return path.reduce((acc, part) => acc[part], obj);
+  return path.reduce((acc, part) => {
+    if (acc === null || acc === undefined) {
+      return undefined;
+    }
+
+    return acc[part];
+  }, obj);
 }
 
 // @TODO: redo it with a better approach

package/src/transformer.ts

@@ -93,7 +93,7 @@ export class Transformer {
           if (transform.type === "set") {
             if ("value" in transform) {
               result = Transformer.setValueAtPath(result, target, transform.value);
-            } else {
+            } else if (sourceValue !== null && sourceValue !== undefined) {
               result = Transformer.setValueAtPath(result, target, sourceValue);
             }
           }

package/src/transformer_types.spec.ts

@@ -406,6 +406,25 @@ describe("Transformer types", () => {
         lastName: "Baggins",
       });
     });
+
+    it("does not set target when resolved source is missing", async () => {
+      expect(
+        await transformer.applyAll(
+          {
+            firstName: "Bilbo",
+          },
+          [
+            {
+              type: "set",
+              target: "profile.lastName",
+              lookup: "browser.user.lastName",
+            },
+          ],
+        ),
+      ).toEqual({
+        firstName: "Bilbo",
+      });
+    });
   });
 
   /**

package/src/validator.spec.ts

@@ -201,7 +201,7 @@ describe("Validator", () => {
       expect(result.errors![0].message).toContain("Expected type number");
     });
 
-    it("should allow additional properties by default", async () => {
+    it("should reject additional properties", async () => {
       const schema: JSONSchema = {
         type: "object",
         properties: {
@@ -210,8 +210,9 @@ describe("Validator", () => {
       };
       const result = await validate(schema, { name: "John", extra: "value" }, {});
 
-      expect(result.valid).toBe(true);
-      expect(result.value).toEqual({ name: "John", extra: "value" });
+      expect(result.valid).toBe(false);
+      expect(result.errors![0].path).toBe("extra");
+      expect(result.errors![0].message).toContain("not allowed by schema");
     });
   });
 
@@ -342,6 +343,44 @@ describe("Validator", () => {
       expect(result.errors![0].path).toBe("user.profile.age");
     });
 
+    it("should reject additional properties in nested objects", async () => {
+      const schema: JSONSchema = {
+        type: "object",
+        properties: {
+          user: {
+            type: "object",
+            properties: {
+              profile: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                },
+                required: ["name"],
+              },
+            },
+            required: ["profile"],
+          },
+        },
+      };
+
+      const result = await validate(
+        schema,
+        {
+          user: {
+            profile: {
+              name: "John",
+              age: 30,
+            },
+          },
+        },
+        {},
+      );
+
+      expect(result.valid).toBe(false);
+      expect(result.errors![0].path).toBe("user.profile.age");
+      expect(result.errors![0].message).toContain("not allowed by schema");
+    });
+
     it("should validate arrays of objects", async () => {
       const schema: JSONSchema = {
         type: "array",

package/src/validator.ts

@@ -187,8 +187,12 @@ function validateValue(
           validatedObj[prop] = validatedProp;
         }
       } else {
-        // Allow additional properties by default (JSON Schema behavior)
-        validatedObj[prop] = propValue;
+        errors.push({
+          path: path ? `${path}.${prop}` : prop,
+          message: `Property '${prop}' is not allowed by schema`,
+          schema,
+          value: propValue,
+        });
       }
     }