@featurevisor/core 2.26.1 → 3.0.1

package/src/builder/convertToV1.ts

@@ -1,166 +0,0 @@
-import type {
-  DatafileContentV1,
-  FeatureV1,
-  VariableSchema,
-  VariationV1,
-  Variation,
-  VariableV1,
-  Feature,
-  Segment,
-  Attribute,
-} from "@featurevisor/types";
-
-import { ProjectConfig } from "../config";
-
-export interface ConvertToV1Options {
-  revision: string;
-  projectConfig: ProjectConfig;
-  attributes: Attribute[];
-  features: Feature[];
-  segments: Segment[];
-}
-
-export function convertToV1(options: ConvertToV1Options): DatafileContentV1 {
-  const datafileContent: DatafileContentV1 = {
-    schemaVersion: "1",
-    revision: options.revision,
-    attributes: options.attributes,
-    segments: options.segments,
-    features: [],
-  };
-
-  const { features, projectConfig } = options;
-
-  for (const feature of features) {
-    const featureV1: FeatureV1 = {
-      key: feature.key,
-      deprecated: feature.deprecated,
-      bucketBy: feature.bucketBy,
-      required: feature.required,
-      traffic: feature.traffic,
-      force: feature.force,
-      ranges: feature.ranges,
-    };
-
-    if (feature.variablesSchema && !Array.isArray(feature.variablesSchema)) {
-      const variablesSchemaObject = feature.variablesSchema;
-      const variablesSchemaArray: VariableSchema[] = [];
-      const variableKeys = Object.keys(variablesSchemaObject);
-
-      for (const variableKey of variableKeys) {
-        const v = variablesSchemaObject[variableKey];
-        variablesSchemaArray.push({
-          key: variableKey,
-          type: v.type,
-          defaultValue: v.defaultValue,
-          deprecated: v.deprecated === true ? true : undefined,
-        });
-      }
-
-      featureV1.variablesSchema = variablesSchemaArray;
-    }
-
-    if (feature.variations) {
-      const variationsV1: VariationV1[] = feature.variations.map((variation: Variation) => {
-        const variationV1: VariationV1 = {
-          value: variation.value,
-          weight: variation.weight || 0, // weight is not used in v1 datafile, but needed for state files
-        };
-
-        // variables
-        const variablesResult: { [key: string]: VariableV1 } = {};
-
-        if (variation.variables) {
-          const variableKeys = Object.keys(variation.variables);
-
-          for (const variableKey of variableKeys) {
-            const variableValue = variation.variables[variableKey];
-
-            variablesResult[variableKey] = {
-              key: variableKey,
-              value: variableValue,
-            };
-          }
-        }
-
-        if (variation.variableOverrides) {
-          const variableKeys = Object.keys(variation.variableOverrides);
-
-          for (const variableKey of variableKeys) {
-            const overrides = variation.variableOverrides[variableKey];
-
-            if (typeof variablesResult[variableKey] === "undefined") {
-              const variableSchema = feature.variablesSchema?.[variableKey];
-
-              variablesResult[variableKey] = {
-                key: variableKey,
-                value: variableSchema?.defaultValue, // default value if no variable is defined
-              };
-            }
-
-            variablesResult[variableKey].overrides = overrides.map((override) => {
-              if (typeof override.conditions !== "undefined") {
-                return {
-                  conditions: projectConfig.stringify
-                    ? JSON.stringify(override.conditions)
-                    : override.conditions,
-                  value: override.value,
-                };
-              }
-
-              if (typeof override.segments !== "undefined") {
-                return {
-                  segments:
-                    typeof override.segments !== "string" && projectConfig.stringify
-                      ? JSON.stringify(override.segments)
-                      : override.segments,
-                  value: override.value,
-                };
-              }
-
-              return {
-                value: override.value,
-              };
-            });
-          }
-        }
-
-        variationV1.variables = Object.keys(variablesResult).map((variableKey) => {
-          const variable = variablesResult[variableKey];
-
-          return {
-            key: variable.key,
-            value: variable.value,
-            overrides: variable.overrides,
-          };
-        });
-
-        return variationV1;
-      });
-
-      featureV1.variations = variationsV1;
-
-      if (featureV1.force) {
-        featureV1.force = featureV1.force.map((force) => {
-          if (
-            force.conditions &&
-            typeof force.conditions === "string" &&
-            force.conditions !== "*"
-          ) {
-            force.conditions = JSON.parse(force.conditions);
-          }
-
-          if (force.segments && typeof force.segments === "string" && force.segments !== "*") {
-            force.segments = JSON.parse(force.segments);
-          }
-
-          return force;
-        });
-      }
-
-      datafileContent.features.push(featureV1);
-    }
-  }
-
-  return datafileContent;
-}

package/src/site/exportSite.ts

@@ -1,42 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-
-import { generateHistory } from "./generateHistory";
-import { getRepoDetails } from "./getRepoDetails";
-import { generateSiteSearchIndex } from "./generateSiteSearchIndex";
-import { Dependencies } from "../dependencies";
-
-export async function exportSite(deps: Dependencies) {
-  const { projectConfig } = deps;
-
-  const hasError = false;
-
-  fs.mkdirSync(projectConfig.siteExportDirectoryPath, { recursive: true });
-
-  const sitePackagePath = path.dirname(require.resolve("@featurevisor/site/package.json"));
-
-  // copy site dist
-  const siteDistPath = path.join(sitePackagePath, "dist");
-  fs.cpSync(siteDistPath, projectConfig.siteExportDirectoryPath, { recursive: true });
-
-  console.log("Site dist copied to:", projectConfig.siteExportDirectoryPath);
-
-  // generate history
-  const fullHistory = await generateHistory(deps);
-
-  // site search index
-  const repoDetails = getRepoDetails();
-  const searchIndex = await generateSiteSearchIndex(deps, fullHistory, repoDetails);
-  const searchIndexFilePath = path.join(projectConfig.siteExportDirectoryPath, "search-index.json");
-  fs.writeFileSync(searchIndexFilePath, JSON.stringify(searchIndex));
-  console.log(`Site search index written at: ${searchIndexFilePath}`);
-
-  // copy datafiles
-  fs.cpSync(
-    projectConfig.datafilesDirectoryPath,
-    path.join(projectConfig.siteExportDirectoryPath, "datafiles"),
-    { recursive: true },
-  );
-
-  return hasError;
-}

package/src/site/generateHistory.ts

@@ -1,40 +0,0 @@
-import * as path from "path";
-import * as fs from "fs";
-
-import type { HistoryEntry } from "@featurevisor/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.siteExportDirectoryPath,
-      "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/site/generateSiteSearchIndex.ts

@@ -1,258 +0,0 @@
-import type {
-  HistoryEntry,
-  SearchIndex,
-  AttributeKey,
-  FeatureKey,
-  SegmentKey,
-  Condition,
-} from "@featurevisor/types";
-
-import { extractAttributeKeysFromConditions, extractSegmentKeysFromGroupSegments } from "../utils";
-
-import { getRelativePaths } from "./getRelativePaths";
-import { getLastModifiedFromHistory } from "./getLastModifiedFromHistory";
-import { RepoDetails } from "./getRepoDetails";
-import { Dependencies } from "../dependencies";
-
-export async function generateSiteSearchIndex(
-  deps: Dependencies,
-  fullHistory: HistoryEntry[],
-  repoDetails: RepoDetails | undefined,
-): Promise<SearchIndex> {
-  const { rootDirectoryPath, projectConfig, datasource } = deps;
-
-  const result: SearchIndex = {
-    links: undefined,
-    projectConfig: {
-      tags: projectConfig.tags,
-      environments: projectConfig.environments,
-    },
-    entities: {
-      attributes: [],
-      segments: [],
-      features: [],
-    },
-  };
-
-  /**
-   * 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 = await datasource.listFeatures();
-
-  for (const entityName of featureFiles) {
-    const parsed = await datasource.readFeature(entityName);
-
-    if (Array.isArray(parsed.variations)) {
-      parsed.variations.forEach((variation) => {
-        if (!variation.variableOverrides) {
-          return;
-        }
-
-        Object.keys(variation.variableOverrides).forEach((variableKey) => {
-          const overrides = variation.variableOverrides?.[variableKey];
-
-          if (overrides) {
-            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);
-                });
-              }
-            });
-          }
-        });
-      });
-    }
-
-    // rules
-    if (parsed.rules) {
-      if (!Array.isArray(parsed.rules)) {
-        // with environments
-        Object.keys(parsed.rules).forEach((environmentKey) => {
-          const rules = parsed.rules?.[environmentKey];
-
-          rules.forEach((rule) => {
-            if (rule.segments && rule.segments !== "*") {
-              extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
-                if (!segmentsUsedInFeatures[segmentKey]) {
-                  segmentsUsedInFeatures[segmentKey] = new Set();
-                }
-
-                segmentsUsedInFeatures[segmentKey].add(entityName);
-              });
-            }
-          });
-        });
-      } else {
-        // no environments
-        parsed.rules.forEach((rule) => {
-          if (rule.segments && rule.segments !== "*") {
-            extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
-              if (!segmentsUsedInFeatures[segmentKey]) {
-                segmentsUsedInFeatures[segmentKey] = new Set();
-              }
-
-              segmentsUsedInFeatures[segmentKey].add(entityName);
-            });
-          }
-        });
-      }
-    }
-
-    // force
-    if (parsed.force) {
-      if (!Array.isArray(parsed.force)) {
-        // with environments
-        Object.keys(parsed.force).forEach((environmentKey) => {
-          parsed.force?.[environmentKey].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);
-              });
-            }
-          });
-        });
-      } else {
-        // no environments
-        parsed.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);
-            });
-          }
-        });
-      }
-    }
-
-    // push
-    result.entities.features.push({
-      ...parsed,
-      key: entityName,
-      lastModified: getLastModifiedFromHistory(fullHistory, "feature", entityName),
-    });
-  }
-
-  // segments
-  const segmentFiles = await datasource.listSegments();
-  for (const entityName of segmentFiles) {
-    const parsed = await 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 = await datasource.listAttributes();
-  for (const entityName of attributeFiles) {
-    const parsed = await 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

@@ -1,21 +0,0 @@
-import type { 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

@@ -1,17 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,46 +0,0 @@
-import { Plugin } from "../cli";
-import { exportSite } from "./exportSite";
-import { serveSite } from "./serveSite";
-
-export const sitePlugin: Plugin = {
-  command: "site [subcommand]",
-  handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
-    const deps = {
-      rootDirectoryPath,
-      projectConfig,
-      datasource,
-      options: parsed,
-    };
-
-    const allowedSubcommands = ["export", "serve"];
-
-    if (!allowedSubcommands.includes(parsed.subcommand)) {
-      console.log("Please specify a subcommand: `export` or `serve`");
-      return;
-    }
-
-    // export
-    if (parsed.subcommand === "export") {
-      const hasError = await exportSite(deps);
-
-      if (hasError) {
-        return false;
-      }
-    }
-
-    // serve
-    if (parsed.subcommand === "serve") {
-      serveSite(deps);
-    }
-  },
-  examples: [
-    {
-      command: "site export",
-      description: "generate static site with project data",
-    },
-    {
-      command: "site serve",
-      description: "serve already exported site locally",
-    },
-  ],
-};