@featurevisor/core 0.52.0 → 0.53.0

package/src/site/generateSiteSearchIndex.ts

@@ -0,0 +1,203 @@
+import {
+  HistoryEntry,
+  SearchIndex,
+  AttributeKey,
+  FeatureKey,
+  SegmentKey,
+  Condition,
+} from "@featurevisor/types";
+
+import { Datasource } from "../datasource";
+import { ProjectConfig } from "../config";
+import { extractAttributeKeysFromConditions, extractSegmentKeysFromGroupSegments } from "../utils";
+
+import { getRelativePaths } from "./getRelativePaths";
+import { getLastModifiedFromHistory } from "./getLastModifiedFromHistory";
+import { RepoDetails } from "./getRepoDetails";
+
+export function generateSiteSearchIndex(
+  rootDirectoryPath: string,
+  projectConfig: ProjectConfig,
+  fullHistory: HistoryEntry[],
+  repoDetails: RepoDetails | undefined,
+): SearchIndex {
+  const result: SearchIndex = {
+    links: undefined,
+    entities: {
+      attributes: [],
+      segments: [],
+      features: [],
+    },
+  };
+  const datasource = new Datasource(projectConfig);
+
+  /**
+   * Links
+   */
+  if (repoDetails) {
+    const { relativeAttributesPath, relativeSegmentsPath, relativeFeaturesPath } = getRelativePaths(
+      rootDirectoryPath,
+      projectConfig,
+    );
+
+    let prefix = "";
+    if (repoDetails.topLevelPath !== rootDirectoryPath) {
+      prefix = rootDirectoryPath.replace(repoDetails.topLevelPath + "/", "") + "/";
+    }
+
+    result.links = {
+      attribute: repoDetails.blobUrl.replace(
+        "{{blobPath}}",
+        prefix + relativeAttributesPath + "/{{key}}." + datasource.getExtension(),
+      ),
+      segment: repoDetails.blobUrl.replace(
+        "{{blobPath}}",
+        prefix + relativeSegmentsPath + "/{{key}}." + datasource.getExtension(),
+      ),
+      feature: repoDetails.blobUrl.replace(
+        "{{blobPath}}",
+        prefix + relativeFeaturesPath + "/{{key}}." + datasource.getExtension(),
+      ),
+      commit: repoDetails.commitUrl,
+    };
+  }
+
+  /**
+   * Entities
+   */
+  // usage
+  const attributesUsedInFeatures: {
+    [key: AttributeKey]: Set<FeatureKey>;
+  } = {};
+  const attributesUsedInSegments: {
+    [key: AttributeKey]: Set<SegmentKey>;
+  } = {};
+  const segmentsUsedInFeatures: {
+    [key: SegmentKey]: Set<FeatureKey>;
+  } = {};
+
+  // features
+  const featureFiles = datasource.listFeatures();
+  featureFiles.forEach((entityName) => {
+    const parsed = datasource.readFeature(entityName);
+
+    if (Array.isArray(parsed.variations)) {
+      parsed.variations.forEach((variation) => {
+        if (!variation.variables) {
+          return;
+        }
+
+        variation.variables.forEach((v) => {
+          if (v.overrides) {
+            v.overrides.forEach((o) => {
+              if (o.conditions) {
+                extractAttributeKeysFromConditions(o.conditions).forEach((attributeKey) => {
+                  if (!attributesUsedInFeatures[attributeKey]) {
+                    attributesUsedInFeatures[attributeKey] = new Set();
+                  }
+
+                  attributesUsedInFeatures[attributeKey].add(entityName);
+                });
+              }
+
+              if (o.segments && o.segments !== "*") {
+                extractSegmentKeysFromGroupSegments(o.segments).forEach((segmentKey) => {
+                  if (!segmentsUsedInFeatures[segmentKey]) {
+                    segmentsUsedInFeatures[segmentKey] = new Set();
+                  }
+
+                  segmentsUsedInFeatures[segmentKey].add(entityName);
+                });
+              }
+            });
+          }
+        });
+      });
+    }
+
+    Object.keys(parsed.environments).forEach((environmentKey) => {
+      const env = parsed.environments[environmentKey];
+
+      env.rules.forEach((rule) => {
+        if (rule.segments && rule.segments !== "*") {
+          extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
+            if (!segmentsUsedInFeatures[segmentKey]) {
+              segmentsUsedInFeatures[segmentKey] = new Set();
+            }
+
+            segmentsUsedInFeatures[segmentKey].add(entityName);
+          });
+        }
+      });
+
+      if (env.force) {
+        env.force.forEach((force) => {
+          if (force.segments && force.segments !== "*") {
+            extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
+              if (!segmentsUsedInFeatures[segmentKey]) {
+                segmentsUsedInFeatures[segmentKey] = new Set();
+              }
+
+              segmentsUsedInFeatures[segmentKey].add(entityName);
+            });
+          }
+
+          if (force.conditions) {
+            extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
+              if (!attributesUsedInFeatures[attributeKey]) {
+                attributesUsedInFeatures[attributeKey] = new Set();
+              }
+
+              attributesUsedInFeatures[attributeKey].add(entityName);
+            });
+          }
+        });
+      }
+    });
+
+    result.entities.features.push({
+      ...parsed,
+      key: entityName,
+      lastModified: getLastModifiedFromHistory(fullHistory, "feature", entityName),
+    });
+  });
+
+  // segments
+  const segmentFiles = datasource.listSegments();
+  segmentFiles.forEach((entityName) => {
+    const parsed = datasource.readSegment(entityName);
+
+    extractAttributeKeysFromConditions(parsed.conditions as Condition | Condition[]).forEach(
+      (attributeKey) => {
+        if (!attributesUsedInSegments[attributeKey]) {
+          attributesUsedInSegments[attributeKey] = new Set();
+        }
+
+        attributesUsedInSegments[attributeKey].add(entityName);
+      },
+    );
+
+    result.entities.segments.push({
+      ...parsed,
+      key: entityName,
+      lastModified: getLastModifiedFromHistory(fullHistory, "segment", entityName),
+      usedInFeatures: Array.from(segmentsUsedInFeatures[entityName] || []),
+    });
+  });
+
+  // attributes
+  const attributeFiles = datasource.listAttributes();
+  attributeFiles.forEach((entityName) => {
+    const parsed = datasource.readAttribute(entityName);
+
+    result.entities.attributes.push({
+      ...parsed,
+      key: entityName,
+      lastModified: getLastModifiedFromHistory(fullHistory, "attribute", entityName),
+      usedInFeatures: Array.from(attributesUsedInFeatures[entityName] || []),
+      usedInSegments: Array.from(attributesUsedInSegments[entityName] || []),
+    });
+  });
+
+  return result;
+}

package/src/site/getLastModifiedFromHistory.ts

@@ -0,0 +1,21 @@
+import { HistoryEntry, LastModified } from "@featurevisor/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/site/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/site/getRelativePaths.ts

@@ -0,0 +1,24 @@
+import * as path from "path";
+
+import { ProjectConfig } from "../config";
+
+export function getRelativePaths(rootDirectoryPath, projectConfig: ProjectConfig) {
+  const relativeFeaturesPath = path.relative(
+    rootDirectoryPath,
+    projectConfig.featuresDirectoryPath,
+  );
+  const relativeSegmentsPath = path.relative(
+    rootDirectoryPath,
+    projectConfig.segmentsDirectoryPath,
+  );
+  const relativeAttributesPath = path.relative(
+    rootDirectoryPath,
+    projectConfig.attributesDirectoryPath,
+  );
+
+  return {
+    relativeFeaturesPath,
+    relativeSegmentsPath,
+    relativeAttributesPath,
+  };
+}

package/src/site/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/site/index.ts

@@ -0,0 +1,2 @@
+export * from "./exportSite";
+export * from "./serveSite";

package/src/site/serveSite.ts

@@ -0,0 +1,60 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as http from "http";
+
+import { ProjectConfig } from "../config";
+
+export function serveSite(
+  rootDirectoryPath: string,
+  projectConfig: ProjectConfig,
+  options: any = {},
+) {
+  const port = options.p || 3000;
+
+  http
+    .createServer(function (request, response) {
+      const requestedUrl = request.url;
+      const filePath =
+        requestedUrl === "/"
+          ? path.join(projectConfig.siteExportDirectoryPath, "index.html")
+          : path.join(projectConfig.siteExportDirectoryPath, 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}/`);
+}

package/lib/site.d.ts

@@ -1,16 +0,0 @@
-import { HistoryEntry, LastModified, SearchIndex } from "@featurevisor/types";
-import { ProjectConfig } from "./config";
-export declare function generateHistory(rootDirectoryPath: any, projectConfig: ProjectConfig): HistoryEntry[];
-export declare function getLastModifiedFromHistory(fullHistory: HistoryEntry[], type: any, key: any): LastModified | undefined;
-interface RepoDetails {
-    branch: string;
-    remoteUrl: string;
-    blobUrl: string;
-    commitUrl: string;
-    topLevelPath: string;
-}
-export declare function getDetailsFromRepo(): RepoDetails | undefined;
-export declare function generateSiteSearchIndex(rootDirectoryPath: string, projectConfig: ProjectConfig, fullHistory: HistoryEntry[], repoDetails: RepoDetails | undefined): SearchIndex;
-export declare function exportSite(rootDirectoryPath: string, projectConfig: ProjectConfig): boolean;
-export declare function serveSite(rootDirectoryPath: string, projectConfig: ProjectConfig, options?: any): void;
-export {};