@eventvisor/core 0.0.2

package/src/linter/persistSchema.ts

@@ -0,0 +1,21 @@
+import * as z from "zod";
+
+import { Dependencies } from "../dependencies";
+import { getConditionsSchema } from "./conditionsSchema";
+
+export function getPersistSchema(deps: Dependencies) {
+  const conditionsSchema = getConditionsSchema(deps);
+
+  const simplePersist = z.string();
+
+  const complexPersist = z.object({
+    storage: z.string(),
+    conditions: conditionsSchema.optional(),
+  });
+
+  return z.union([
+    simplePersist,
+    complexPersist,
+    z.array(z.union([simplePersist, complexPersist])),
+  ]);
+}

package/src/linter/printError.ts

@@ -0,0 +1,50 @@
+import * as path from "path";
+
+import * as z from "zod";
+import chalk from "chalk";
+
+import { ProjectConfig, CustomParser } from "../config";
+
+export interface PrintErrorOptions {
+  entityType: string;
+  entityKey: string;
+  error: z.ZodError;
+  projectConfig: ProjectConfig;
+}
+
+function getFilePath(options: PrintErrorOptions) {
+  const { entityType, entityKey, projectConfig } = options;
+
+  const extension = (projectConfig.parser as CustomParser).extension;
+
+  let directoryPath = "";
+  if (entityType === "event") {
+    directoryPath = projectConfig.eventsDirectoryPath;
+  } else if (entityType === "attribute") {
+    directoryPath = projectConfig.attributesDirectoryPath;
+  } else if (entityType === "destination") {
+  } else if (entityType === "test") {
+    directoryPath = projectConfig.testsDirectoryPath;
+  } else {
+    throw new Error(`Unknown entity type: ${entityType}`);
+  }
+
+  return path.join(directoryPath, entityKey + "." + extension);
+}
+
+function prefixLines(str: string, prefix: string) {
+  return str
+    .split("\n")
+    .map((line) => prefix + line)
+    .join("\n");
+}
+
+export function printError(options: PrintErrorOptions) {
+  const { error } = options;
+
+  console.log("\n");
+
+  console.log(chalk.bold.red.underline(getFilePath(options)));
+
+  console.log(prefixLines(z.prettifyError(error), "  "));
+}

package/src/linter/sampleSchema.ts

@@ -0,0 +1,45 @@
+import * as z from "zod";
+
+import { Dependencies } from "../dependencies";
+import { getSourceBaseSchema, getSourceBaseRefine } from "./sourceSchema";
+import { getConditionsSchema } from "./conditionsSchema";
+
+export function getSampleSchema(deps: Dependencies) {
+  const sampleByString = z.string();
+  const sampleBySource = getSourceBaseSchema(deps).refine(...getSourceBaseRefine());
+
+  const sampleBySingle = z.union([sampleByString, sampleBySource]);
+  const sampleByMultiple = z.array(sampleBySingle);
+  const sampleByOr = z.object({ or: sampleByMultiple });
+
+  const sampleBy = z.union([sampleBySingle, sampleByMultiple, sampleByOr]);
+
+  return z
+    .object({
+      by: sampleBy,
+      conditions: getConditionsSchema(deps).optional(),
+
+      // one of them below is required
+      percentage: z.number().min(0).max(100).optional(),
+      range: z.array(z.number().min(0).max(100)).min(2).max(2).optional(),
+    })
+    .refine(
+      (data) => {
+        // both missing
+        if (data.percentage === undefined && data.range === undefined) {
+          return false;
+        }
+
+        // both provided
+        if (data.percentage !== undefined && data.range !== undefined) {
+          return false;
+        }
+
+        return true;
+      },
+      {
+        message: "Either `percentage` or `range` must be provided",
+        path: [],
+      },
+    );
+}

package/src/linter/sourceSchema.ts

@@ -0,0 +1,42 @@
+import * as z from "zod";
+import { Dependencies } from "../dependencies";
+
+// eslint-disable-next-line
+export function getSourceBaseSchema(deps: Dependencies) {
+  const source = z.string();
+  const sourceUnion = z.union([source, z.array(source)]);
+
+  // need .shape API from Zod, so cannot do .union() here
+  return z.object({
+    // one of them is required
+    source: sourceUnion.optional(),
+    attribute: sourceUnion.optional(),
+    state: sourceUnion.optional(),
+    effect: sourceUnion.optional(),
+    payload: sourceUnion.optional(),
+    lookup: sourceUnion.optional(),
+  });
+}
+
+const needOneOf = ["source", "attribute", "state", "effect", "payload", "lookup"];
+
+// @TODO: make return type better
+export function getSourceBaseRefine(): [any, any] {
+  return [
+    (data) => {
+      const keys = Object.keys(data);
+
+      for (const key of keys) {
+        if (needOneOf.includes(key)) {
+          return true;
+        }
+      }
+
+      return false;
+    },
+    {
+      message: "At least one source is required",
+      path: [],
+    },
+  ];
+}

package/src/linter/tagsSchema.ts

@@ -0,0 +1,12 @@
+import * as z from "zod";
+import { Dependencies } from "../dependencies";
+
+export function getTagsSchema(deps: Dependencies) {
+  const { projectConfig } = deps;
+
+  return z.array(
+    z.string().refine((tag) => projectConfig.tags.indexOf(tag) > -1, {
+      message: `Tag must be one of: ${projectConfig.tags.join(", ")}`,
+    }),
+  );
+}

package/src/linter/testSchema.ts

@@ -0,0 +1,9 @@
+import * as z from "zod";
+import { Dependencies } from "../dependencies";
+
+// eslint-disable-next-line
+export function getTestSchema(deps: Dependencies) {
+  return z.object({
+    archived: z.boolean().optional(),
+  });
+}

package/src/linter/transformsSchema.ts

@@ -0,0 +1,35 @@
+import * as z from "zod";
+
+import { Dependencies } from "../dependencies";
+import { getSourceBaseSchema } from "./sourceSchema";
+
+export function getTransformsSchema(deps: Dependencies) {
+  return z.array(
+    z.object({
+      // .refine() is intentionally not called here for now, since not all transforms need sources
+      // @TODO: make it stricter based on transform types
+      ...getSourceBaseSchema(deps).shape,
+      type: z.enum([
+        "increment",
+        "decrement",
+        "concat", // @TODO: rename to `join`?
+        "remove",
+        "rename",
+        "set",
+        "trim",
+        "toInteger",
+        "toDouble",
+        "toString",
+        "toBoolean",
+        "spread",
+        "append",
+      ]),
+      target: z.string().optional(),
+      targetMap: z.record(z.string(), z.any()).optional(),
+      value: z.any().optional(),
+
+      // transform type specific params
+      separator: z.string().optional(),
+    }), // do NOT call .strict() here
+  );
+}

package/src/tester/createTestInstance.ts

@@ -0,0 +1,209 @@
+import type { DatafileContent, WithLookups, Value, Step } from "@eventvisor/types";
+
+import { Eventvisor, LogLevel, getComplexPersists } from "@eventvisor/sdk";
+import type { Module } from "@eventvisor/sdk";
+
+import type { TestProjectOptions } from "./testProject";
+
+export interface CreateTestInstanceResult {
+  e: Eventvisor;
+  getBodiesByDestination: () => Record<string, Value[]>;
+  getBodiesBySingleDestination: (destinationName: string) => Value[] | undefined;
+  getCalledStepsByEffect: () => Record<string, Step[]>;
+  getCalledStepsBySingleEffect: (effectName: string) => Step[] | undefined;
+}
+
+export interface CreateTestInstanceOptions {
+  datafile: DatafileContent;
+  cliOptions: TestProjectOptions;
+  withLookups?: WithLookups;
+}
+
+export function createTestInstance(options: CreateTestInstanceOptions): CreateTestInstanceResult {
+  const { datafile, cliOptions, withLookups } = options;
+
+  /**
+   * Log level
+   */
+  let logLevel: LogLevel = "error";
+
+  if (cliOptions.verbose) {
+    logLevel = "debug";
+  } else if (cliOptions.quiet) {
+    logLevel = "fatal";
+  }
+
+  /**
+   * Transport names
+   */
+  const transportNames = new Set<string>();
+  const destinationNames = Object.keys(datafile.destinations);
+  for (const destinationName of destinationNames) {
+    const destination = datafile.destinations[destinationName];
+    if (destination.transport) {
+      transportNames.add(destination.transport);
+    }
+  }
+
+  /**
+   * Storage names
+   */
+  const storageNames = new Set<string>();
+
+  const attributes = Object.keys(datafile.attributes);
+  for (const attributeName of attributes) {
+    const attribute = datafile.attributes[attributeName];
+    if (attribute.persist) {
+      const persists = getComplexPersists(attribute.persist);
+
+      for (const persist of persists) {
+        storageNames.add(persist.storage);
+      }
+    }
+  }
+
+  /**
+   * Handler names
+   */
+  const handlerNames = new Set<string>();
+
+  const effects = Object.keys(datafile.effects);
+  for (const effectName of effects) {
+    const effect = datafile.effects[effectName];
+
+    // handler
+    if (effect.steps) {
+      for (const step of effect.steps) {
+        if (step.handler) {
+          handlerNames.add(step.handler);
+        }
+      }
+    }
+
+    // storage
+    if (effect.persist) {
+      const persists = getComplexPersists(effect.persist);
+
+      for (const persist of persists) {
+        storageNames.add(persist.storage);
+      }
+    }
+  }
+
+  /**
+   * Modules
+   */
+  const modules: Module[] = [];
+  const bodiesByDestination: Record<string, any[]> = {};
+  const calledStepsByEffect: Record<string, Step[]> = {};
+
+  const lookupsMap = {};
+  for (const [key, value] of Object.entries(withLookups || {})) {
+    const [moduleName, ...keyParts] = key.split(".");
+    const lookupKey = keyParts.join(".");
+    if (typeof lookupsMap[moduleName] === "undefined") {
+      lookupsMap[moduleName] = {};
+    }
+    lookupsMap[moduleName][lookupKey] = value;
+  }
+
+  const allModuleNames = Array.from(handlerNames)
+    .concat(Array.from(transportNames))
+    .concat(Object.keys(lookupsMap))
+    .concat(Array.from(storageNames));
+
+  for (const moduleName of allModuleNames) {
+    const moduleObj: Module = { name: moduleName };
+
+    // transport
+    if (transportNames.has(moduleName)) {
+      moduleObj.transport = (options) => {
+        const { destinationName, payload } = options;
+
+        if (typeof bodiesByDestination[destinationName] === "undefined") {
+          bodiesByDestination[destinationName] = [];
+        }
+
+        bodiesByDestination[destinationName].push(payload);
+
+        return Promise.resolve();
+      };
+    }
+
+    // storage
+    if (storageNames.has(moduleName)) {
+      const storageData = {};
+
+      moduleObj.readFromStorage = (options) => {
+        const { key } = options;
+
+        return Promise.resolve(storageData[key]);
+      };
+
+      moduleObj.writeToStorage = (options) => {
+        const { key, value } = options;
+
+        storageData[key] = value;
+
+        return Promise.resolve();
+      };
+    }
+
+    // handler
+    if (handlerNames.has(moduleName)) {
+      moduleObj.handle = (options) => {
+        const { effectName, step } = options;
+
+        if (typeof calledStepsByEffect[effectName] === "undefined") {
+          calledStepsByEffect[effectName] = [];
+        }
+
+        calledStepsByEffect[effectName].push(step);
+
+        return Promise.resolve();
+      };
+    }
+
+    // lookup
+    Object.keys(lookupsMap).forEach((moduleName) => {
+      if (moduleName === moduleObj.name) {
+        moduleObj.lookup = (options) => {
+          const { key } = options;
+
+          return Promise.resolve(lookupsMap[moduleName][key]);
+        };
+      }
+    });
+
+    modules.push(moduleObj);
+  }
+
+  /**
+   * Instance
+   */
+  const e = new Eventvisor({
+    datafile,
+    logLevel,
+    modules,
+  });
+
+  return {
+    e,
+
+    // destinations
+    getBodiesByDestination: () => {
+      return bodiesByDestination;
+    },
+    getBodiesBySingleDestination: (destinationName: string) => {
+      return bodiesByDestination[destinationName];
+    },
+
+    // effects
+    getCalledStepsByEffect: () => {
+      return calledStepsByEffect;
+    },
+    getCalledStepsBySingleEffect: (effectName: string) => {
+      return calledStepsByEffect[effectName];
+    },
+  };
+}