@eventvisor/core 0.0.2

package/src/datasource/filesystemAdapter.ts

@@ -0,0 +1,206 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import type { DatafileContent, EntityType } from "@eventvisor/types";
+
+import { Adapter, DatafileOptions } from "./adapter";
+import { ProjectConfig, CustomParser } from "../config";
+
+export function getRevisionFilePath(projectConfig: ProjectConfig): string {
+  return path.join(projectConfig.systemDirectoryPath, `REVISION`);
+}
+
+export function getAllEntityFilePathsRecursively(directoryPath, extension) {
+  let entities: string[] = [];
+
+  if (!fs.existsSync(directoryPath)) {
+    return entities;
+  }
+
+  const files = fs.readdirSync(directoryPath);
+
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const filePath = path.join(directoryPath, file);
+
+    if (fs.statSync(filePath).isDirectory()) {
+      entities = entities.concat(getAllEntityFilePathsRecursively(filePath, extension));
+    } else if (file.endsWith(`.${extension}`)) {
+      entities.push(filePath);
+    }
+  }
+
+  return entities;
+}
+
+export class FilesystemAdapter extends Adapter {
+  private parser: CustomParser;
+
+  constructor(
+    private config: ProjectConfig,
+    private rootDirectoryPath?: string,
+  ) {
+    super();
+
+    this.parser = config.parser as CustomParser;
+  }
+
+  getEntityDirectoryPath(entityType: EntityType): string {
+    if (entityType === "event") {
+      return this.config.eventsDirectoryPath;
+    } else if (entityType === "attribute") {
+      return this.config.attributesDirectoryPath;
+    } else if (entityType === "destination") {
+      return this.config.destinationsDirectoryPath;
+    } else if (entityType === "state") {
+      return this.config.statesDirectoryPath;
+    } else if (entityType === "effect") {
+      return this.config.effectsDirectoryPath;
+    } else if (entityType === "test") {
+      return this.config.testsDirectoryPath;
+    }
+
+    throw new Error(`Unknown entity type: ${entityType}`);
+  }
+
+  getEntityPath(entityType: EntityType, entityKey: string): string {
+    const basePath = this.getEntityDirectoryPath(entityType);
+
+    // taking care of windows paths
+    const relativeEntityPath = entityKey.replace(/\//g, path.sep);
+
+    return path.join(basePath, `${relativeEntityPath}.${this.parser.extension}`);
+  }
+
+  async listEntities(entityType: EntityType): Promise<string[]> {
+    const directoryPath = this.getEntityDirectoryPath(entityType);
+    const filePaths = getAllEntityFilePathsRecursively(directoryPath, this.parser.extension);
+
+    return (
+      filePaths
+        // keep only the files with the right extension
+        .filter((filterPath) => filterPath.endsWith(`.${this.parser.extension}`))
+
+        // remove the entity directory path from beginning
+        .map((filePath) => filePath.replace(directoryPath + path.sep, ""))
+
+        // remove the extension from the end
+        .map((filterPath) => filterPath.replace(`.${this.parser.extension}`, ""))
+
+        // take care of windows paths
+        .map((filterPath) => filterPath.replace(/\\/g, "/"))
+    );
+  }
+
+  async entityExists(entityType: EntityType, entityKey: string): Promise<boolean> {
+    const entityPath = this.getEntityPath(entityType, entityKey);
+
+    return fs.existsSync(entityPath);
+  }
+
+  async readEntity<T>(entityType: EntityType, entityKey: string): Promise<T> {
+    const filePath = this.getEntityPath(entityType, entityKey);
+    const entityContent = fs.readFileSync(filePath, "utf8");
+
+    return this.parser.parse<T>(entityContent, filePath);
+  }
+
+  async writeEntity<T>(entityType: EntityType, entityKey: string, entity: T): Promise<T> {
+    const filePath = this.getEntityPath(entityType, entityKey);
+
+    if (!fs.existsSync(this.getEntityDirectoryPath(entityType))) {
+      fs.mkdirSync(this.getEntityDirectoryPath(entityType), { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, this.parser.stringify(entity));
+
+    return entity;
+  }
+
+  async deleteEntity(entityType: EntityType, entityKey: string): Promise<void> {
+    const filePath = this.getEntityPath(entityType, entityKey);
+
+    if (!fs.existsSync(filePath)) {
+      return;
+    }
+
+    fs.unlinkSync(filePath);
+  }
+
+  /**
+   * Revision
+   */
+  async readRevision(): Promise<string> {
+    const filePath = getRevisionFilePath(this.config);
+
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, "utf8");
+    }
+
+    // maintain backwards compatibility
+    try {
+      const pkg = require(path.join(this.rootDirectoryPath as string, "package.json"));
+      const pkgVersion = pkg.version;
+
+      if (pkgVersion) {
+        return pkgVersion;
+      }
+
+      return "0";
+      // eslint-disable-next-line
+    } catch (e) {
+      return "0";
+    }
+  }
+
+  async writeRevision(revision: string): Promise<void> {
+    const filePath = getRevisionFilePath(this.config);
+
+    if (!fs.existsSync(this.config.systemDirectoryPath)) {
+      fs.mkdirSync(this.config.systemDirectoryPath, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, revision);
+  }
+
+  /**
+   * Datafile
+   */
+  getDatafilePath(options: DatafileOptions): string {
+    const pattern = this.config.datafileNamePattern || "eventvisor-%s.json";
+
+    const fileName = pattern.replace("%s", `tag-${options.tag}`);
+    const dir = options.datafilesDir || this.config.datafilesDirectoryPath;
+
+    return path.join(dir, fileName);
+  }
+
+  async readDatafile(options: DatafileOptions): Promise<DatafileContent> {
+    const filePath = this.getDatafilePath(options);
+    const content = fs.readFileSync(filePath, "utf8");
+    const datafileContent = JSON.parse(content);
+
+    return datafileContent;
+  }
+
+  async writeDatafile(datafileContent: DatafileContent, options: DatafileOptions): Promise<void> {
+    const dir = options.datafilesDir || this.config.datafilesDirectoryPath;
+
+    const outputEnvironmentDirPath = dir;
+    fs.mkdirSync(outputEnvironmentDirPath, { recursive: true });
+
+    const outputFilePath = this.getDatafilePath(options);
+
+    fs.writeFileSync(
+      outputFilePath,
+      this.config.prettyDatafile
+        ? JSON.stringify(datafileContent, null, 2)
+        : JSON.stringify(datafileContent),
+    );
+
+    const root = path.resolve(dir, "..");
+
+    const shortPath = outputFilePath.replace(root + path.sep, "");
+    console.log(`     Datafile generated: ${shortPath}`);
+  }
+}

package/src/datasource/index.ts

@@ -0,0 +1,3 @@
+export * from "./datasource";
+export * from "./adapter";
+export * from "./filesystemAdapter";

package/src/dependencies.ts

@@ -0,0 +1,13 @@
+import { ProjectConfig } from "./config";
+import { Datasource } from "./datasource";
+
+export interface Options {
+  [key: string]: any;
+}
+
+export interface Dependencies {
+  rootDirectoryPath: string;
+  projectConfig: ProjectConfig;
+  datasource: Datasource;
+  options: Options;
+}

package/src/index.spec.ts

@@ -0,0 +1,5 @@
+describe("core :: index", function () {
+  it("should run tests", function () {
+    expect(true).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./cli";
+export * from "./config";
+export * from "./datasource";
+export * from "./dependencies";

package/src/init/index.ts

@@ -0,0 +1,65 @@
+import axios from "axios";
+import * as tar from "tar";
+
+import { Plugin } from "../cli";
+
+export const DEFAULT_PROJECT = "yml";
+
+export const PROJECTS_ORG_NAME = "eventvisor";
+export const PROJECTS_REPO_NAME = "eventvisor";
+export const PROJECTS_BRANCH_NAME = "main";
+
+export const PROJECTS_TAR_URL = `https://codeload.github.com/${PROJECTS_ORG_NAME}/${PROJECTS_REPO_NAME}/tar.gz/${PROJECTS_BRANCH_NAME}`;
+
+function getProjectPath(projectName: string) {
+  return `${PROJECTS_REPO_NAME}-${PROJECTS_BRANCH_NAME}/projects/project-${projectName}/`;
+}
+
+export function initProject(
+  directoryPath: string,
+  projectName: string = DEFAULT_PROJECT,
+): Promise<boolean> {
+  return new Promise(function (resolve) {
+    axios.get(PROJECTS_TAR_URL, { responseType: "stream" }).then((response) => {
+      response.data
+        .pipe(
+          tar.x({
+            C: directoryPath,
+            filter: (path) => path.indexOf(getProjectPath(projectName)) === 0,
+            strip: 3,
+          }),
+        )
+        .on("error", (e) => {
+          console.error(e);
+
+          resolve(false);
+        })
+        .on("finish", () => {
+          console.log(`Project scaffolded in ${directoryPath}`);
+          console.log(``);
+          console.log(`Please run "npm install" in the directory above.`);
+
+          resolve(true);
+        });
+    });
+  });
+}
+
+export const initPlugin: Plugin = {
+  command: "init",
+  handler: async function (options) {
+    const { rootDirectoryPath, parsed } = options;
+
+    await initProject(rootDirectoryPath, parsed.project);
+  },
+  examples: [
+    {
+      command: "init",
+      description: "scaffold a new project in current directory",
+    },
+    {
+      command: "init --project=projectName",
+      description: "scaffold a new project in current directory from known example",
+    },
+  ],
+};

package/src/linter/attributeSchema.ts

@@ -0,0 +1,23 @@
+import * as z from "zod";
+import { Dependencies } from "../dependencies";
+
+import { JSONZodSchema } from "./jsonSchema";
+import { getTagsSchema } from "./tagsSchema";
+import { getTransformsSchema } from "./transformsSchema";
+import { getPersistSchema } from "./persistSchema";
+
+export function getAttributeSchema(deps: Dependencies) {
+  return z
+    .object({
+      ...JSONZodSchema.shape,
+
+      archived: z.boolean().optional(),
+      deprecated: z.boolean().optional(),
+      description: z.string(),
+      tags: getTagsSchema(deps),
+
+      transforms: getTransformsSchema(deps).optional(),
+      persist: getPersistSchema(deps).optional(),
+    })
+    .strict();
+}

package/src/linter/conditionsSchema.ts

@@ -0,0 +1,89 @@
+import * as z from "zod";
+
+import { Dependencies } from "../dependencies";
+import { getSourceBaseRefine, getSourceBaseSchema } from "./sourceSchema";
+
+export function getConditionsSchema(deps: Dependencies) {
+  const sourceBase = getSourceBaseSchema(deps);
+
+  const plainConditionSchema = z
+    .object({
+      ...sourceBase.shape,
+      operator: z.enum([
+        "equals",
+        "notEquals",
+        "exists",
+        "notExists",
+
+        // numeric
+        "greaterThan",
+        "greaterThanOrEquals",
+        "lessThan",
+        "lessThanOrEquals",
+
+        // string
+        "contains",
+        "notContains",
+        "startsWith",
+        "endsWith",
+
+        // semver (string)
+        "semverEquals",
+        "semverNotEquals",
+        "semverGreaterThan",
+        "semverGreaterThanOrEquals",
+        "semverLessThan",
+        "semverLessThanOrEquals",
+
+        // date comparisons
+        "before",
+        "after",
+
+        // array of strings
+        "includes",
+        "notIncludes",
+
+        // regex
+        "matches",
+        "notMatches",
+
+        // array of strings
+        "in",
+        "notIn",
+      ]),
+      value: z.any().optional(),
+    })
+    .refine(...getSourceBaseRefine())
+    // @TODO: refine "value" type against each "operator"
+    .refine(
+      (data) => {
+        if (data.operator === "exists" || data.operator === "notExists") {
+          return data.value === undefined;
+        }
+
+        return data.value !== undefined;
+      },
+      { 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,
+  ]);
+
+  return z.union([conditionSchema, z.array(conditionSchema)]);
+}

package/src/linter/destinationSchema.ts

@@ -0,0 +1,25 @@
+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";
+import { getTransformsSchema } from "./transformsSchema";
+
+export function getDestinationSchema(deps: Dependencies) {
+  return z
+    .object({
+      ...JSONZodSchema.shape,
+
+      archived: z.boolean().optional(),
+      description: z.string(),
+      tags: getTagsSchema(deps),
+
+      transport: z.string(),
+      conditions: getConditionsSchema(deps).optional(),
+      sample: getSampleSchema(deps).optional(),
+      transforms: getTransformsSchema(deps).optional(),
+    })
+    .strict();
+}

package/src/linter/effectSchema.ts

@@ -0,0 +1,49 @@
+import * as z from "zod";
+
+import { Dependencies } from "../dependencies";
+import { getConditionsSchema } from "./conditionsSchema";
+import { getTagsSchema } from "./tagsSchema";
+import { getTransformsSchema } from "./transformsSchema";
+import { getPersistSchema } from "./persistSchema";
+
+export function getEffectSchema(deps: Dependencies) {
+  const effectOnType = z.enum(["event_tracked", "attribute_set"]);
+  const effectOnRecord = z
+    .object({
+      event_tracked: z.array(z.string()).optional(),
+      attribute_set: z.array(z.string()).optional(),
+    })
+    .refine(
+      (data) => {
+        return Object.values(data).some((value) => value !== undefined);
+      },
+      {
+        message: "Either event_tracked or attribute_set must be provided",
+        path: ["event_tracked", "attribute_set"],
+      },
+    );
+  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(),
+  });
+
+  return z
+    .object({
+      archived: z.boolean().optional(),
+      description: z.string(),
+      tags: getTagsSchema(deps),
+
+      on: effectOn,
+      state: z.any().optional(),
+      conditions: getConditionsSchema(deps).optional(),
+      steps: z.array(step),
+      persist: getPersistSchema(deps).optional(),
+    })
+    .strict();
+}

package/src/linter/eventSchema.ts

@@ -0,0 +1,40 @@
+import * as z from "zod";
+import { Dependencies } from "../dependencies";
+
+import { JSONZodSchema } from "./jsonSchema";
+import { getTagsSchema } from "./tagsSchema";
+import { getConditionsSchema } from "./conditionsSchema";
+import { getTransformsSchema } from "./transformsSchema";
+import { getSampleSchema } from "./sampleSchema";
+
+export function getEventSchema(deps: Dependencies) {
+  return z
+    .object({
+      ...JSONZodSchema.shape,
+
+      archived: z.boolean().optional(),
+      deprecated: z.boolean().optional(),
+      description: z.string(),
+      tags: getTagsSchema(deps),
+
+      level: z.enum(["fatal", "error", "warning", "log", "info", "debug"]).optional(),
+      requiredAttributes: z.array(z.string()).optional(),
+      conditions: getConditionsSchema(deps).optional(),
+      sample: getSampleSchema(deps).optional(),
+      transforms: getTransformsSchema(deps).optional(),
+      destinations: z
+        .record(
+          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(),
+            }),
+          ]),
+        )
+        .optional(),
+    })
+    .strict();
+}

package/src/linter/index.ts

@@ -0,0 +1 @@
+export * from "./lintProject";