@eventvisor/core 0.23.0 → 0.24.0

package/src/linter/conditionsSchema.ts

@@ -52,6 +52,7 @@ export function getConditionsSchema(deps: Dependencies) {
         "notIn",
       ]),
       value: z.any().optional(),
+      regexFlags: z.string().optional(),
     })
     .refine(...getSourceBaseRefine())
     // @TODO: refine "value" type against each "operator"
@@ -66,24 +67,17 @@ export function getConditionsSchema(deps: Dependencies) {
       { message: "Value is required for all operators except exists and notExists" },
     );
 
-  const andConditionSchema = z.object({
-    and: z.array(plainConditionSchema),
-  });
-
-  const orConditionSchema = z.object({
-    or: z.array(plainConditionSchema),
-  });
-
-  const notConditionSchema = z.object({
-    not: z.array(plainConditionSchema),
-  });
-
-  const conditionSchema = z.union([
-    plainConditionSchema,
-    andConditionSchema,
-    orConditionSchema,
-    notConditionSchema,
-  ]);
+  const stringConditionSchema = z.string();
+
+  const conditionSchema: z.ZodTypeAny = z.lazy(() =>
+    z.union([
+      plainConditionSchema,
+      z.object({ and: z.array(conditionSchema) }).strict(),
+      z.object({ or: z.array(conditionSchema) }).strict(),
+      z.object({ not: z.array(conditionSchema) }).strict(),
+      stringConditionSchema,
+    ]),
+  );
 
   return z.union([conditionSchema, z.array(conditionSchema)]);
 }

package/src/linter/destinationSchema.ts

@@ -1,7 +1,6 @@
 import * as z from "zod";
 import { Dependencies } from "../dependencies";
 
-import { JSONZodSchema } from "./jsonSchema";
 import { getTagsSchema } from "./tagsSchema";
 import { getConditionsSchema } from "./conditionsSchema";
 import { getSampleSchema } from "./sampleSchema";
@@ -10,8 +9,6 @@ import { getTransformsSchema } from "./transformsSchema";
 export function getDestinationSchema(deps: Dependencies) {
   return z
     .object({
-      ...JSONZodSchema.shape,
-
       archived: z.boolean().optional(),
       description: z.string(),
       tags: getTagsSchema(deps),

package/src/linter/effectSchema.ts

@@ -13,6 +13,7 @@ export function getEffectSchema(deps: Dependencies) {
       event_tracked: z.array(z.string()).optional(),
       attribute_set: z.array(z.string()).optional(),
     })
+    .strict()
     .refine(
       (data) => {
         return Object.values(data).some((value) => value !== undefined);
@@ -24,14 +25,16 @@ export function getEffectSchema(deps: Dependencies) {
     );
   const effectOn = z.union([z.array(effectOnType), effectOnRecord]);
 
-  const step = z.object({
-    description: z.string().optional(),
-    handler: z.string().optional(),
-    conditions: getConditionsSchema(deps).optional(),
-    params: z.record(z.string(), z.any()).optional(),
-    transforms: getTransformsSchema(deps).optional(),
-    continueOnError: z.boolean().optional(),
-  });
+  const step = z
+    .object({
+      description: z.string().optional(),
+      handler: z.string().optional(),
+      conditions: getConditionsSchema(deps).optional(),
+      params: z.record(z.string(), z.any()).optional(),
+      transforms: getTransformsSchema(deps).optional(),
+      continueOnError: z.boolean().optional(),
+    })
+    .strict();
 
   return z
     .object({
@@ -42,7 +45,7 @@ export function getEffectSchema(deps: Dependencies) {
       on: effectOn,
       state: z.any().optional(),
       conditions: getConditionsSchema(deps).optional(),
-      steps: z.array(step),
+      steps: z.array(step).optional(),
       persist: getPersistSchema(deps).optional(),
     })
     .strict();

package/src/linter/entitySchemas.spec.ts

@@ -0,0 +1,212 @@
+import { getAttributeSchema } from "./attributeSchema";
+import { getDestinationSchema } from "./destinationSchema";
+import { getEffectSchema } from "./effectSchema";
+import { getEventSchema } from "./eventSchema";
+import { getConditionsSchema } from "./conditionsSchema";
+import { getSampleSchema } from "./sampleSchema";
+import type { Dependencies } from "../dependencies";
+
+function createDeps(): Dependencies {
+  return {
+    rootDirectoryPath: "/tmp/eventvisor",
+    projectConfig: {
+      eventsDirectoryPath: "/tmp/eventvisor/events",
+      attributesDirectoryPath: "/tmp/eventvisor/attributes",
+      destinationsDirectoryPath: "/tmp/eventvisor/destinations",
+      statesDirectoryPath: "/tmp/eventvisor/states",
+      effectsDirectoryPath: "/tmp/eventvisor/effects",
+      testsDirectoryPath: "/tmp/eventvisor/tests",
+      datafilesDirectoryPath: "/tmp/eventvisor/datafiles",
+      systemDirectoryPath: "/tmp/eventvisor/.eventvisor",
+      catalogExportDirectoryPath: "/tmp/eventvisor/out",
+      datafileNamePattern: "eventvisor-%s.json",
+      tags: ["all", "web"],
+      adapter: class {},
+      plugins: [],
+      parser: { extension: "yml", parse: jest.fn(), stringify: jest.fn() },
+      prettyDatafile: false,
+      stringify: true,
+    },
+    datasource: {} as Dependencies["datasource"],
+    options: {},
+  };
+}
+
+describe("entity lint schemas", () => {
+  const deps = createDeps();
+
+  it("accepts string and nested conditions including regexFlags", () => {
+    const schema = getConditionsSchema(deps);
+
+    expect(schema.safeParse("*").success).toBe(true);
+    expect(
+      schema.safeParse({
+        and: [
+          "*",
+          {
+            or: [
+              {
+                payload: "url",
+                operator: "matches",
+                value: "^https://",
+                regexFlags: "i",
+              },
+            ],
+          },
+        ],
+      }).success,
+    ).toBe(true);
+  });
+
+  it("accepts arrays of samples", () => {
+    const schema = getSampleSchema(deps);
+
+    const result = schema.safeParse([
+      {
+        by: "userId",
+        percentage: 50,
+      },
+      {
+        by: { payload: "country" },
+        range: [50, 100],
+      },
+    ]);
+
+    expect(result.success).toBe(true);
+  });
+
+  it("requires attribute metadata", () => {
+    const schema = getAttributeSchema(deps);
+
+    expect(
+      schema.safeParse({
+        type: "string",
+      }).success,
+    ).toBe(false);
+
+    expect(
+      schema.safeParse({
+        description: "User ID attribute",
+        tags: ["web"],
+        type: "string",
+      }).success,
+    ).toBe(true);
+  });
+
+  it("requires event metadata and keeps strict skipValidation/destination overrides", () => {
+    const schema = getEventSchema(deps);
+
+    expect(
+      schema.safeParse({
+        description: "Page view",
+        tags: ["web"],
+        type: "object",
+        skipValidation: {
+          conditions: "*",
+        },
+        destinations: {
+          console: {
+            sample: [
+              {
+                by: "userId",
+                percentage: 50,
+              },
+            ],
+          },
+        },
+      }).success,
+    ).toBe(true);
+
+    expect(
+      schema.safeParse({
+        description: "Page view",
+        tags: ["web"],
+        type: "object",
+        skipValidation: {
+          conditions: "*",
+          extra: true,
+        },
+      }).success,
+    ).toBe(false);
+
+    expect(
+      schema.safeParse({
+        type: "object",
+      }).success,
+    ).toBe(false);
+  });
+
+  it("requires destination metadata and rejects JSON schema-only fields", () => {
+    const schema = getDestinationSchema(deps);
+
+    expect(
+      schema.safeParse({
+        description: "Console destination",
+        tags: ["web"],
+        transport: "console",
+        type: "object",
+      }).success,
+    ).toBe(false);
+
+    expect(
+      schema.safeParse({
+        description: "Console destination",
+        tags: ["web"],
+        transport: "console",
+        sample: [
+          {
+            by: "userId",
+            percentage: 100,
+          },
+        ],
+      }).success,
+    ).toBe(true);
+
+    expect(
+      schema.safeParse({
+        transport: "console",
+      }).success,
+    ).toBe(false);
+  });
+
+  it("requires effect metadata and on, and rejects unknown step fields", () => {
+    const schema = getEffectSchema(deps);
+
+    expect(
+      schema.safeParse({
+        description: "Inject cookie banner",
+        tags: ["web"],
+        on: {
+          event_tracked: ["page_view"],
+        },
+        state: {
+          injected: false,
+        },
+      }).success,
+    ).toBe(true);
+
+    expect(
+      schema.safeParse({
+        description: "Inject cookie banner",
+        tags: ["web"],
+        on: {
+          event_tracked: ["page_view"],
+        },
+        steps: [
+          {
+            handler: "pixel",
+            unknown: true,
+          },
+        ],
+      }).success,
+    ).toBe(false);
+
+    expect(
+      schema.safeParse({
+        description: "Inject cookie banner",
+        tags: ["web"],
+        steps: [],
+      }).success,
+    ).toBe(false);
+  });
+});

package/src/linter/eventSchema.ts

@@ -18,7 +18,7 @@ export function getEventSchema(deps: Dependencies) {
       tags: getTagsSchema(deps),
 
       skipValidation: z
-        .union([z.boolean(), z.object({ conditions: getConditionsSchema(deps) })])
+        .union([z.boolean(), z.object({ conditions: getConditionsSchema(deps) }).strict()])
         .optional(),
       level: z.enum(["fatal", "error", "warning", "log", "info", "debug"]).optional(),
       requiredAttributes: z.array(z.string()).optional(),
@@ -30,11 +30,13 @@ export function getEventSchema(deps: Dependencies) {
           z.string(), // @TODO: get real destination names here
           z.union([
             z.boolean(),
-            z.object({
-              conditions: getConditionsSchema(deps).optional(),
-              sample: getSampleSchema(deps).optional(),
-              transforms: getTransformsSchema(deps).optional(),
-            }),
+            z
+              .object({
+                conditions: getConditionsSchema(deps).optional(),
+                sample: getSampleSchema(deps).optional(),
+                transforms: getTransformsSchema(deps).optional(),
+              })
+              .strict(),
           ]),
         )
         .optional(),

package/src/linter/lintProject.spec.ts

@@ -0,0 +1,112 @@
+import type { Dependencies } from "../dependencies";
+
+jest.mock("chalk", () => ({
+  __esModule: true,
+  default: {
+    bold: {
+      red: {
+        underline: jest.fn((value: string) => value),
+      },
+    },
+  },
+}));
+
+import { lintProject } from "./lintProject";
+
+function createDeps(testContent: Record<string, any>): Dependencies {
+  return {
+    rootDirectoryPath: "/tmp/eventvisor",
+    projectConfig: {
+      eventsDirectoryPath: "/tmp/eventvisor/events",
+      attributesDirectoryPath: "/tmp/eventvisor/attributes",
+      destinationsDirectoryPath: "/tmp/eventvisor/destinations",
+      statesDirectoryPath: "/tmp/eventvisor/states",
+      effectsDirectoryPath: "/tmp/eventvisor/effects",
+      testsDirectoryPath: "/tmp/eventvisor/tests",
+      datafilesDirectoryPath: "/tmp/eventvisor/datafiles",
+      systemDirectoryPath: "/tmp/eventvisor/.eventvisor",
+      catalogExportDirectoryPath: "/tmp/eventvisor/out",
+      datafileNamePattern: "eventvisor-%s.json",
+      tags: ["all"],
+      adapter: class {},
+      plugins: [],
+      parser: { extension: "yml", parse: jest.fn(), stringify: jest.fn() },
+      prettyDatafile: false,
+      stringify: true,
+    },
+    datasource: {
+      listAttributes: jest.fn().mockResolvedValue([]),
+      listEvents: jest.fn().mockResolvedValue(["page_view"]),
+      listDestinations: jest.fn().mockResolvedValue([]),
+      listEffects: jest.fn().mockResolvedValue([]),
+      listTests: jest.fn().mockResolvedValue(["events/page_view.spec"]),
+      readEvent: jest.fn().mockResolvedValue({
+        description: "Page view",
+        tags: ["all"],
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+          },
+        },
+      }),
+      readTest: jest.fn().mockResolvedValue(testContent),
+    } as unknown as Dependencies["datasource"],
+    options: {},
+  };
+}
+
+describe("lintProject", () => {
+  let logSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    logSpy = jest.spyOn(console, "log").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it("includes test specs in linting", async () => {
+    const deps = createDeps({
+      event: "page_view",
+      assertions: [
+        {
+          expectedDestinationsByTag: {
+            marketing: ["console"],
+          },
+        },
+      ],
+    });
+
+    const result = await lintProject(deps);
+
+    expect(result).toBe(false);
+    expect(deps.datasource.listTests).toHaveBeenCalled();
+    expect(deps.datasource.readTest).toHaveBeenCalledWith("events/page_view.spec");
+  });
+
+  it("supports filtering by entityType=test", async () => {
+    const deps = createDeps({
+      event: "page_view",
+      assertions: [
+        {
+          track: {
+            url: "https://example.com",
+          },
+          expectedToBeValid: true,
+        },
+      ],
+    });
+
+    const result = await lintProject(deps, { entityType: "test" });
+
+    expect(result).toBe(true);
+    expect(deps.datasource.listAttributes).toHaveBeenCalled();
+    expect(deps.datasource.listEvents).toHaveBeenCalled();
+    expect(deps.datasource.listDestinations).toHaveBeenCalled();
+    expect(deps.datasource.listEffects).toHaveBeenCalled();
+    expect(deps.datasource.listTests).toHaveBeenCalled();
+    expect(deps.datasource.readTest).toHaveBeenCalledWith("events/page_view.spec");
+  });
+});

package/src/linter/lintProject.ts

@@ -1,3 +1,5 @@
+import * as z from "zod";
+
 import { Plugin } from "../cli";
 import { Dependencies } from "../dependencies";
 
@@ -5,9 +7,42 @@ import { getAttributeSchema } from "./attributeSchema";
 import { getDestinationSchema } from "./destinationSchema";
 import { getEffectSchema } from "./effectSchema";
 import { getEventSchema } from "./eventSchema";
+import { getTestSchema } from "./testSchema";
 import { printError } from "./printError";
+import { getSemanticIssues, type LintContext } from "./semanticValidation";
+
+async function createLintContext(options: Dependencies): Promise<LintContext> {
+  const { datasource } = options;
+
+  const [attributeNames, eventNames, destinationNames, effectNames] = await Promise.all([
+    datasource.listAttributes(),
+    datasource.listEvents(),
+    datasource.listDestinations(),
+    datasource.listEffects(),
+  ]);
+
+  const [attributes, events, destinations, effects] = await Promise.all([
+    Promise.all(
+      attributeNames.map(async (name) => [name, await datasource.readAttribute(name)] as const),
+    ),
+    Promise.all(eventNames.map(async (name) => [name, await datasource.readEvent(name)] as const)),
+    Promise.all(
+      destinationNames.map(async (name) => [name, await datasource.readDestination(name)] as const),
+    ),
+    Promise.all(
+      effectNames.map(async (name) => [name, await datasource.readEffect(name)] as const),
+    ),
+  ]);
+
+  return {
+    attributes: Object.fromEntries(attributes),
+    events: Object.fromEntries(events),
+    destinations: Object.fromEntries(destinations),
+    effects: Object.fromEntries(effects),
+  };
+}
 
-async function lintProject(
+export async function lintProject(
   options: Dependencies,
   filterOptions: {
     keyPattern?: string;
@@ -16,6 +51,7 @@ async function lintProject(
 ): Promise<boolean> {
   const { projectConfig, datasource } = options;
   const { keyPattern, entityType } = filterOptions;
+  const lintContext = await createLintContext(options);
 
   let hasErrors = false;
 
@@ -35,7 +71,7 @@ async function lintProject(
     }
 
     const attributeContent = await datasource.readAttribute(attributeKey);
-    const result = attributeSchema.safeParse(attributeContent);
+    const result = await attributeSchema.safeParseAsync(attributeContent);
 
     if (!result.success) {
       printError({
@@ -45,6 +81,19 @@ async function lintProject(
         projectConfig,
       });
       hasErrors = true;
+      continue;
+    }
+
+    const semanticIssues = getSemanticIssues("attribute", result.data as any, lintContext);
+
+    if (semanticIssues.length > 0) {
+      printError({
+        entityType: "attribute",
+        entityKey: attributeKey,
+        error: new z.ZodError(semanticIssues),
+        projectConfig,
+      });
+      hasErrors = true;
     }
   }
 
@@ -64,7 +113,7 @@ async function lintProject(
     }
 
     const eventContent = await datasource.readEvent(eventKey);
-    const result = eventSchema.safeParse(eventContent);
+    const result = await eventSchema.safeParseAsync(eventContent);
 
     if (!result.success) {
       printError({
@@ -75,6 +124,19 @@ async function lintProject(
       });
 
       hasErrors = true;
+      continue;
+    }
+
+    const semanticIssues = getSemanticIssues("event", result.data as any, lintContext);
+
+    if (semanticIssues.length > 0) {
+      printError({
+        entityType: "event",
+        entityKey: eventKey,
+        error: new z.ZodError(semanticIssues),
+        projectConfig,
+      });
+      hasErrors = true;
     }
   }
 
@@ -94,7 +156,7 @@ async function lintProject(
     }
 
     const destinationContent = await datasource.readDestination(destinationKey);
-    const result = destinationSchema.safeParse(destinationContent);
+    const result = await destinationSchema.safeParseAsync(destinationContent);
 
     if (!result.success) {
       printError({
@@ -104,6 +166,19 @@ async function lintProject(
         projectConfig,
       });
       hasErrors = true;
+      continue;
+    }
+
+    const semanticIssues = getSemanticIssues("destination", result.data as any, lintContext);
+
+    if (semanticIssues.length > 0) {
+      printError({
+        entityType: "destination",
+        entityKey: destinationKey,
+        error: new z.ZodError(semanticIssues),
+        projectConfig,
+      });
+      hasErrors = true;
     }
   }
 
@@ -123,7 +198,7 @@ async function lintProject(
     }
 
     const effectContent = await datasource.readEffect(effectKey);
-    const result = effectSchema.safeParse(effectContent);
+    const result = await effectSchema.safeParseAsync(effectContent);
 
     if (!result.success) {
       printError({
@@ -133,10 +208,63 @@ async function lintProject(
         projectConfig,
       });
       hasErrors = true;
+      continue;
+    }
+
+    const semanticIssues = getSemanticIssues("effect", result.data as any, lintContext);
+
+    if (semanticIssues.length > 0) {
+      printError({
+        entityType: "effect",
+        entityKey: effectKey,
+        error: new z.ZodError(semanticIssues),
+        projectConfig,
+      });
+      hasErrors = true;
     }
   }
 
-  // @TODO: tests
+  // tests
+  console.log("\nLinting tests...");
+
+  const tests = await datasource.listTests();
+  const testSchema = getTestSchema(options);
+
+  for (const testKey of tests) {
+    if (entityType && entityType !== "test") {
+      continue;
+    }
+
+    if (keyPattern && !testKey.includes(keyPattern)) {
+      continue;
+    }
+
+    const testContent = await datasource.readTest(testKey);
+    const result = await testSchema.safeParseAsync(testContent);
+
+    if (!result.success) {
+      printError({
+        entityType: "test",
+        entityKey: testKey,
+        error: result.error,
+        projectConfig,
+      });
+      hasErrors = true;
+      continue;
+    }
+
+    const semanticIssues = getSemanticIssues("test", result.data as any, lintContext);
+
+    if (semanticIssues.length > 0) {
+      printError({
+        entityType: "test",
+        entityKey: testKey,
+        error: new z.ZodError(semanticIssues),
+        projectConfig,
+      });
+      hasErrors = true;
+    }
+  }
 
   if (hasErrors) {
     return false;

package/src/linter/persistSchema.ts

@@ -8,10 +8,12 @@ export function getPersistSchema(deps: Dependencies) {
 
   const simplePersist = z.string();
 
-  const complexPersist = z.object({
-    storage: z.string(),
-    conditions: conditionsSchema.optional(),
-  });
+  const complexPersist = z
+    .object({
+      storage: z.string(),
+      conditions: conditionsSchema.optional(),
+    })
+    .strict();
 
   return z.union([
     simplePersist,

package/src/linter/printError.ts

@@ -23,6 +23,9 @@ function getFilePath(options: PrintErrorOptions) {
   } else if (entityType === "attribute") {
     directoryPath = projectConfig.attributesDirectoryPath;
   } else if (entityType === "destination") {
+    directoryPath = projectConfig.destinationsDirectoryPath;
+  } else if (entityType === "effect") {
+    directoryPath = projectConfig.effectsDirectoryPath;
   } else if (entityType === "test") {
     directoryPath = projectConfig.testsDirectoryPath;
   } else {