@eventvisor/core 0.6.0 → 0.8.0

package/src/catalog/exportCatalog.ts

@@ -0,0 +1,40 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import { generateHistory } from "./generateHistory";
+import { getRepoDetails } from "./getRepoDetails";
+import { buildCatalog } from "./buildCatalog";
+import { Dependencies } from "../dependencies";
+
+export async function exportCatalog(deps: Dependencies) {
+  const { projectConfig } = deps;
+
+  fs.mkdirSync(projectConfig.catalogExportDirectoryPath, { recursive: true });
+
+  const catalogPackagePath = path.dirname(require.resolve("@eventvisor/catalog/package.json"));
+
+  // copy catalog dist
+  const catalogDistPath = path.join(catalogPackagePath, "dist");
+  fs.cpSync(catalogDistPath, projectConfig.catalogExportDirectoryPath, { recursive: true });
+
+  console.log("Catalog dist copied to:", projectConfig.catalogExportDirectoryPath);
+
+  // generate history
+  const fullHistory = await generateHistory(deps);
+
+  // site search index
+  const repoDetails = getRepoDetails();
+  const catalog = await buildCatalog(deps, fullHistory, repoDetails);
+  const catalogFilePath = path.join(projectConfig.catalogExportDirectoryPath, "catalog.json");
+  fs.writeFileSync(catalogFilePath, JSON.stringify(catalog));
+  console.log(`Catalog written at: ${catalogFilePath}`);
+
+  // copy datafiles
+  fs.cpSync(
+    projectConfig.datafilesDirectoryPath,
+    path.join(projectConfig.catalogExportDirectoryPath, "datafiles"),
+    { recursive: true },
+  );
+
+  return true;
+}

package/src/catalog/generateHistory.ts

@@ -0,0 +1,40 @@
+import * as path from "path";
+import * as fs from "fs";
+
+import type { HistoryEntry } from "@eventvisor/types";
+import { Dependencies } from "../dependencies";
+
+export async function generateHistory(deps: Dependencies): Promise<HistoryEntry[]> {
+  const { projectConfig, datasource } = deps;
+
+  try {
+    const fullHistory = await datasource.listHistoryEntries();
+
+    const filteredHistory = fullHistory
+      .map((historyEntry) => {
+        return {
+          ...historyEntry,
+          entities: historyEntry.entities.filter((entity) => {
+            // ignore test specs
+            return entity.type !== "test";
+          }),
+        };
+      })
+      .filter((historyEntry) => historyEntry.entities.length > 0);
+
+    const fullHistoryFilePath = path.join(
+      projectConfig.catalogExportDirectoryPath,
+      "history-full.json",
+    );
+    fs.writeFileSync(fullHistoryFilePath, JSON.stringify(filteredHistory));
+    console.log(`History (full) generated at: ${fullHistoryFilePath}`);
+
+    return filteredHistory;
+  } catch (error) {
+    console.error(
+      `Error when generating history from git: ${error.status}\n${error.stderr.toString()}`,
+    );
+
+    return [];
+  }
+}

package/src/catalog/getLastModifiedFromHistory.ts

@@ -0,0 +1,21 @@
+import type { HistoryEntry, LastModified } from "@eventvisor/types";
+
+export function getLastModifiedFromHistory(
+  fullHistory: HistoryEntry[],
+  type,
+  key,
+): LastModified | undefined {
+  const lastModified = fullHistory.find((entry) => {
+    return entry.entities.find((entity) => {
+      return entity.type === type && entity.key === key;
+    });
+  });
+
+  if (lastModified) {
+    return {
+      commit: lastModified.commit,
+      timestamp: lastModified.timestamp,
+      author: lastModified.author,
+    };
+  }
+}

package/src/catalog/getOwnerAndRepoFromUrl.ts

@@ -0,0 +1,17 @@
+export function getOwnerAndRepoFromUrl(url: string): { owner: string; repo: string } {
+  let owner;
+  let repo;
+
+  if (url.startsWith("https://")) {
+    const parts = url.split("/");
+    repo = (parts.pop() as string).replace(".git", "");
+    owner = parts.pop();
+  } else if (url.startsWith("git@")) {
+    const urlParts = url.split(":");
+    const parts = urlParts[1].split("/");
+    repo = (parts.pop() as string).replace(".git", "");
+    owner = parts.pop();
+  }
+
+  return { owner, repo };
+}

package/src/catalog/getRelativePaths.ts

@@ -0,0 +1,23 @@
+import * as path from "path";
+
+import { ProjectConfig } from "../config";
+
+export function getRelativePaths(rootDirectoryPath, projectConfig: ProjectConfig) {
+  const relativeEventsPath = path.relative(rootDirectoryPath, projectConfig.eventsDirectoryPath);
+  const relativeDestinationsPath = path.relative(
+    rootDirectoryPath,
+    projectConfig.destinationsDirectoryPath,
+  );
+  const relativeAttributesPath = path.relative(
+    rootDirectoryPath,
+    projectConfig.attributesDirectoryPath,
+  );
+  const relativeEffectsPath = path.relative(rootDirectoryPath, projectConfig.effectsDirectoryPath);
+
+  return {
+    relativeEventsPath,
+    relativeDestinationsPath,
+    relativeAttributesPath,
+    relativeEffectsPath,
+  };
+}

package/src/catalog/getRepoDetails.ts

@@ -0,0 +1,62 @@
+import { execSync } from "child_process";
+
+import { getOwnerAndRepoFromUrl } from "./getOwnerAndRepoFromUrl";
+
+export interface RepoDetails {
+  branch: string;
+  remoteUrl: string;
+  blobUrl: string;
+  commitUrl: string;
+  topLevelPath: string;
+}
+
+export function getRepoDetails(): RepoDetails | undefined {
+  try {
+    const topLevelPathOutput = execSync(`git rev-parse --show-toplevel`);
+    const topLevelPath = topLevelPathOutput.toString().trim();
+
+    const remoteUrlOutput = execSync(`git remote get-url origin`);
+    const remoteUrl = remoteUrlOutput.toString().trim();
+
+    const branchOutput = execSync(`git rev-parse --abbrev-ref HEAD`);
+    const branch = branchOutput.toString().trim();
+
+    if (!remoteUrl || !branch) {
+      return;
+    }
+
+    const { owner, repo } = getOwnerAndRepoFromUrl(remoteUrl);
+
+    if (!owner || !repo) {
+      return;
+    }
+
+    let blobUrl;
+    let commitUrl;
+
+    if (remoteUrl.indexOf("github.com") > -1) {
+      blobUrl = `https://github.com/${owner}/${repo}/blob/${branch}/{{blobPath}}`;
+      commitUrl = `https://github.com/${owner}/${repo}/commit/{{hash}}`;
+    } else if (remoteUrl.indexOf("bitbucket.org") > -1) {
+      blobUrl = `https://bitbucket.org/${owner}/${repo}/src/${branch}/{{blobPath}}`;
+      commitUrl = `https://bitbucket.org/${owner}/${repo}/commits/{{hash}}`;
+    }
+
+    if (!blobUrl || !commitUrl) {
+      return;
+    }
+
+    return {
+      branch,
+      remoteUrl,
+      blobUrl,
+      commitUrl,
+      topLevelPath,
+    };
+  } catch (e) {
+    console.error(e);
+    return;
+  }
+
+  return;
+}

package/src/catalog/index.ts

@@ -0,0 +1,40 @@
+import { Plugin } from "../cli";
+import { exportCatalog } from "./exportCatalog";
+import { serveCatalog } from "./serveCatalog";
+import { Dependencies } from "../dependencies";
+
+export const catalogPlugin: Plugin = {
+  command: "catalog",
+  handler: async function (options) {
+    const { rootDirectoryPath, projectConfig, datasource, parsed } = options;
+    const deps: Dependencies = { rootDirectoryPath, projectConfig, datasource, options: parsed };
+
+    const allowedSubcommands = ["export", "serve"];
+    const subcommand = parsed._[1];
+
+    if (!allowedSubcommands.includes(subcommand)) {
+      console.log("Please specify a subcommand: `export` or `serve`");
+      return;
+    }
+
+    // export
+    if (subcommand === "export") {
+      return await exportCatalog(deps);
+    }
+
+    // serve
+    if (subcommand === "serve") {
+      return await serveCatalog(deps);
+    }
+  },
+  examples: [
+    {
+      command: "catalog export",
+      description: "export catalog of all entities",
+    },
+    {
+      command: "catalog serve",
+      description: "serve catalog of all entities",
+    },
+  ],
+};

package/src/catalog/serveCatalog.ts

@@ -0,0 +1,60 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as http from "http";
+
+import { Dependencies } from "../dependencies";
+
+export function serveCatalog(deps: Dependencies) {
+  const { projectConfig, options } = deps;
+
+  const port = options.p || 3000;
+
+  http
+    .createServer(function (request, response) {
+      const requestedUrl = request.url;
+      const filePath =
+        requestedUrl === "/"
+          ? path.join(projectConfig.catalogExportDirectoryPath, "index.html")
+          : path.join(projectConfig.catalogExportDirectoryPath, requestedUrl as string);
+
+      console.log("requesting: " + filePath + "");
+
+      const extname = path.extname(filePath);
+      let contentType = "text/html";
+      switch (extname) {
+        case ".js":
+          contentType = "text/javascript";
+          break;
+        case ".css":
+          contentType = "text/css";
+          break;
+        case ".json":
+          contentType = "application/json";
+          break;
+        case ".png":
+          contentType = "image/png";
+          break;
+      }
+
+      fs.readFile(filePath, function (error, content) {
+        if (error) {
+          if (error.code == "ENOENT") {
+            response.writeHead(404, { "Content-Type": "text/html" });
+            response.end("404 Not Found", "utf-8");
+          } else {
+            response.writeHead(500);
+            response.end("Error 500: " + error.code);
+            response.end();
+          }
+        } else {
+          response.writeHead(200, { "Content-Type": contentType });
+          response.end(content, "utf-8");
+        }
+      });
+    })
+    .listen(port);
+
+  console.log(`Server running at http://127.0.0.1:${port}/`);
+
+  return true;
+}

package/src/cli/plugins.ts

@@ -5,9 +5,16 @@ import { lintPlugin } from "../linter";
 import { buildPlugin } from "../builder";
 import { testPlugin } from "../tester";
 import { initPlugin } from "../init";
+import { catalogPlugin } from "../catalog";
 
 export const commonPlugins: Plugin[] = [];
 
 export const nonProjectPlugins: Plugin[] = [initPlugin];
 
-export const projectBasedPlugins: Plugin[] = [configPlugin, lintPlugin, buildPlugin, testPlugin];
+export const projectBasedPlugins: Plugin[] = [
+  configPlugin,
+  lintPlugin,
+  buildPlugin,
+  testPlugin,
+  catalogPlugin,
+];

package/src/config/projectConfig.ts

@@ -13,7 +13,7 @@ export const TESTS_DIRECTORY_NAME = "tests";
 export const SYSTEM_DIRECTORY_NAME = ".eventvisor";
 export const DATAFILES_DIRECTORY_NAME = "datafiles";
 export const DATAFILE_NAME_PATTERN = "eventvisor-%s.json";
-export const SITE_EXPORT_DIRECTORY_NAME = "out";
+export const CATALOG_EXPORT_DIRECTORY_NAME = "out";
 
 export const CONFIG_MODULE_NAME = "eventvisor.config.js";
 export const ROOT_DIR_PLACEHOLDER = "<rootDir>";
@@ -34,6 +34,7 @@ export interface ProjectConfig {
   testsDirectoryPath: string;
   datafilesDirectoryPath: string;
   systemDirectoryPath: string;
+  catalogExportDirectoryPath: string;
   datafileNamePattern: string;
 
   tags: string[];
@@ -68,6 +69,7 @@ export function getProjectConfig(rootDirectoryPath: string): ProjectConfig {
     datafilesDirectoryPath: path.join(rootDirectoryPath, DATAFILES_DIRECTORY_NAME),
     datafileNamePattern: DATAFILE_NAME_PATTERN,
     systemDirectoryPath: path.join(rootDirectoryPath, SYSTEM_DIRECTORY_NAME),
+    catalogExportDirectoryPath: path.join(rootDirectoryPath, CATALOG_EXPORT_DIRECTORY_NAME),
 
     plugins: [],
   };

package/src/datasource/adapter.ts

@@ -1,4 +1,4 @@
-import type { DatafileContent, EntityType } from "@eventvisor/types";
+import type { DatafileContent, EntityType, HistoryEntry, Commit } from "@eventvisor/types";
 
 export interface DatafileOptions {
   tag: string;
@@ -20,4 +20,8 @@ export abstract class Adapter {
   // revision
   abstract readRevision(): Promise<string>;
   abstract writeRevision(revision: string): Promise<void>;
+
+  // history
+  abstract listHistoryEntries(entityType?: EntityType, entityKey?: string): Promise<HistoryEntry[]>;
+  abstract readCommit(commit: string, entityType?: EntityType, entityKey?: string): Promise<Commit>;
 }

package/src/datasource/datasource.ts

@@ -10,6 +10,7 @@ import type {
   Test,
   TestName,
   DatafileContent,
+  EntityType,
 } from "@eventvisor/types";
 
 import { ProjectConfig, CustomParser } from "../config";
@@ -161,4 +162,13 @@ export class Datasource {
   getTestSpecName(testName: TestName) {
     return `${testName}.${this.getExtension()}`;
   }
+
+  // history
+  listHistoryEntries(entityType?: EntityType, entityKey?: string) {
+    return this.adapter.listHistoryEntries(entityType, entityKey);
+  }
+
+  readCommit(commitHash: string, entityType?: EntityType, entityKey?: string) {
+    return this.adapter.readCommit(commitHash, entityType, entityKey);
+  }
 }

package/src/datasource/filesystemAdapter.ts

@@ -1,10 +1,18 @@
 import * as fs from "fs";
 import * as path from "path";
+import { execSync, spawn } from "child_process";
 
-import type { DatafileContent, EntityType } from "@eventvisor/types";
+import type {
+  DatafileContent,
+  EntityType,
+  HistoryEntry,
+  HistoryEntity,
+  Commit,
+} from "@eventvisor/types";
 
 import { Adapter, DatafileOptions } from "./adapter";
 import { ProjectConfig, CustomParser } from "../config";
+import { getCommit } from "../utils/git";
 
 export function getRevisionFilePath(projectConfig: ProjectConfig): string {
   return path.join(projectConfig.systemDirectoryPath, `REVISION`);
@@ -203,4 +211,150 @@ export class FilesystemAdapter extends Adapter {
     const shortPath = outputFilePath.replace(root + path.sep, "");
     console.log(`     Datafile generated: ${shortPath}`);
   }
+
+  /**
+   * History
+   */
+  async getRawHistory(pathPatterns: string[]): Promise<string> {
+    const gitPaths = pathPatterns.join(" ");
+
+    const logCommand = `git log --name-only --pretty=format:"%h|%an|%aI" --relative --no-merges -- ${gitPaths}`;
+    const fullCommand = `(cd ${this.rootDirectoryPath} && ${logCommand})`;
+
+    return new Promise(function (resolve, reject) {
+      const child = spawn(fullCommand, { shell: true });
+      let result = "";
+
+      child.stdout.on("data", function (data) {
+        result += data.toString();
+      });
+
+      child.stderr.on("data", function (data) {
+        console.error(data.toString());
+      });
+
+      child.on("close", function (code) {
+        if (code === 0) {
+          resolve(result);
+        } else {
+          reject(code);
+        }
+      });
+    });
+  }
+
+  getPathPatterns(entityType?: EntityType, entityKey?: string): string[] {
+    let pathPatterns: string[] = [];
+
+    if (entityType && entityKey) {
+      pathPatterns = [this.getEntityPath(entityType, entityKey)];
+    } else if (entityType) {
+      if (entityType === "attribute") {
+        pathPatterns = [this.config.attributesDirectoryPath];
+      } else if (entityType === "event") {
+        pathPatterns = [this.config.eventsDirectoryPath];
+      } else if (entityType === "destination") {
+        pathPatterns = [this.config.destinationsDirectoryPath];
+      } else if (entityType === "effect") {
+        pathPatterns = [this.config.effectsDirectoryPath];
+      } else if (entityType === "test") {
+        pathPatterns = [this.config.testsDirectoryPath];
+      }
+    } else {
+      pathPatterns = [
+        this.config.eventsDirectoryPath,
+        this.config.attributesDirectoryPath,
+        this.config.destinationsDirectoryPath,
+        this.config.effectsDirectoryPath,
+        this.config.testsDirectoryPath,
+      ];
+    }
+
+    return pathPatterns.map((p) => p.replace((this.rootDirectoryPath as string) + path.sep, ""));
+  }
+
+  async listHistoryEntries(entityType?: EntityType, entityKey?: string): Promise<HistoryEntry[]> {
+    const pathPatterns = this.getPathPatterns(entityType, entityKey);
+    const rawHistory = await this.getRawHistory(pathPatterns);
+
+    const fullHistory: HistoryEntry[] = [];
+    const blocks = rawHistory.split("\n\n");
+
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+
+      if (block.length === 0) {
+        continue;
+      }
+
+      const lines = block.split("\n");
+
+      const commitLine = lines[0];
+      const [commitHash, author, timestamp] = commitLine.split("|");
+
+      const entities: HistoryEntity[] = [];
+
+      const filePathLines = lines.slice(1);
+      for (let j = 0; j < filePathLines.length; j++) {
+        const relativePath = filePathLines[j];
+        const absolutePath = path.join(this.rootDirectoryPath as string, relativePath);
+        const fileName = absolutePath.split(path.sep).pop() as string;
+        const relativeDir = path.dirname(absolutePath);
+
+        const key = fileName.replace("." + this.parser.extension, "");
+
+        let type: EntityType = "attribute";
+        if (relativeDir === this.config.attributesDirectoryPath) {
+          type = "attribute";
+        } else if (relativeDir === this.config.eventsDirectoryPath) {
+          type = "event";
+        } else if (relativeDir === this.config.destinationsDirectoryPath) {
+          type = "destination";
+        } else if (relativeDir === this.config.effectsDirectoryPath) {
+          type = "effect";
+        } else if (relativeDir === this.config.testsDirectoryPath) {
+          type = "test";
+        } else {
+          continue;
+        }
+
+        entities.push({
+          type,
+          key,
+        });
+      }
+
+      if (entities.length === 0) {
+        continue;
+      }
+
+      fullHistory.push({
+        commit: commitHash,
+        author,
+        timestamp,
+        entities,
+      });
+    }
+
+    return fullHistory;
+  }
+
+  async readCommit(
+    commitHash: string,
+    entityType?: EntityType,
+    entityKey?: string,
+  ): Promise<Commit> {
+    const pathPatterns = this.getPathPatterns(entityType, entityKey);
+    const gitPaths = pathPatterns.join(" ");
+    const logCommand = `git show ${commitHash} --relative -- ${gitPaths}`;
+    const fullCommand = `(cd ${this.rootDirectoryPath} && ${logCommand})`;
+
+    const gitShowOutput = execSync(fullCommand, { encoding: "utf8" }).toString();
+    const commit = getCommit(gitShowOutput, {
+      rootDirectoryPath: this.rootDirectoryPath as string,
+      projectConfig: this.config,
+    });
+
+    return commit;
+  }
 }

package/src/utils/git.ts

@@ -0,0 +1,129 @@
+import * as path from "path";
+
+import type { Commit, EntityDiff, EntityType } from "@eventvisor/types";
+
+import { CustomParser, ProjectConfig } from "../config";
+
+function parseGitCommitShowOutput(gitShowOutput: string) {
+  const result = {
+    hash: "",
+    author: "",
+    date: "",
+    message: "",
+    diffs: {},
+  };
+
+  const lines = gitShowOutput.split("\n");
+  let currentFile = "";
+  let parsingDiffs = false;
+  let parsingMessage = false;
+
+  lines.forEach((line) => {
+    if (line.startsWith("commit ")) {
+      result.hash = line.replace("commit ", "").trim();
+    } else if (line.startsWith("Author:")) {
+      result.author = line.replace("Author:", "").trim();
+      parsingMessage = false;
+    } else if (line.startsWith("Date:")) {
+      result.date = line.replace("Date:", "").trim();
+      parsingMessage = true; // Start parsing commit message
+    } else if (line.startsWith("diff --git")) {
+      if (currentFile) {
+        // Finish capturing the previous file's diff
+        parsingDiffs = false;
+      }
+      currentFile = line.split(" ")[2].substring(2);
+      result.diffs[currentFile] = line + "\n"; // Include the diff --git line
+      parsingDiffs = true;
+      parsingMessage = false; // Stop parsing commit message
+    } else if (parsingDiffs) {
+      result.diffs[currentFile] += line + "\n";
+    } else if (parsingMessage && line.trim() !== "") {
+      result.message += line.trim() + "\n"; // Capture commit message
+    }
+  });
+
+  return result;
+}
+
+function analyzeFileChange(diff) {
+  let status = "updated"; // Default to 'updated'
+
+  // Check for file creation or deletion
+  if (diff.includes("new file mode")) {
+    status = "created";
+  } else if (diff.includes("deleted file mode")) {
+    status = "deleted";
+  }
+
+  return status;
+}
+
+export function getCommit(
+  gitShowOutput: string,
+  options: { rootDirectoryPath: string; projectConfig: ProjectConfig },
+): Commit {
+  const parsed = parseGitCommitShowOutput(gitShowOutput);
+  const { rootDirectoryPath, projectConfig } = options;
+
+  const commit: Commit = {
+    hash: parsed.hash,
+    author: parsed.author,
+    timestamp: parsed.date,
+    entities: [],
+  };
+
+  Object.keys(parsed.diffs).forEach((file) => {
+    const diff = parsed.diffs[file];
+    const status = analyzeFileChange(diff);
+
+    const absolutePath = path.join(rootDirectoryPath, file);
+    const relativeDir = path.dirname(absolutePath);
+
+    // get entity type
+    let type: EntityType = "attribute";
+    if (relativeDir === projectConfig.attributesDirectoryPath) {
+      type = "attribute";
+    } else if (relativeDir === projectConfig.eventsDirectoryPath) {
+      type = "event";
+    } else if (relativeDir === projectConfig.destinationsDirectoryPath) {
+      type = "destination";
+    } else if (relativeDir === projectConfig.effectsDirectoryPath) {
+      type = "effect";
+    } else if (relativeDir === projectConfig.testsDirectoryPath) {
+      type = "test";
+    } else {
+      // unknown type
+      return;
+    }
+
+    // get entity key
+    const fileName = absolutePath.split(path.sep).pop() as string;
+    const extensionWithDot = "." + (projectConfig.parser as CustomParser).extension;
+
+    if (!fileName.endsWith(extensionWithDot)) {
+      // unknown extension
+      return;
+    }
+
+    const key = fileName.replace(extensionWithDot, "");
+
+    const entityDiff: EntityDiff = {
+      type,
+      key,
+      content: diff,
+    };
+
+    if (status === "created") {
+      entityDiff.created = true;
+    } else if (status === "deleted") {
+      entityDiff.deleted = true;
+    } else {
+      entityDiff.updated = true;
+    }
+
+    commit.entities.push(entityDiff);
+  });
+
+  return commit;
+}