@dittowords/cli 2.5.1 → 2.6.0

package/lib/{config.test.js → config.test.ts}

@@ -1,11 +1,9 @@
 /* eslint-disable no-underscore-dangle */
-const fs = require("fs");
-const path = require("path");
-
-const tempy = require("tempy");
-const yaml = require("js-yaml");
-
-const config = require("./config");
+import fs from "fs";
+import path from "path";
+import tempy from "tempy";
+import yaml from "js-yaml";
+import config from "./config";
 
 const fakeHomedir = fs.mkdtempSync(path.join(__dirname, "../testing/tmp"));
 
@@ -57,11 +55,15 @@ describe("Tokens in config files", () => {
   describe("saveToken", () => {
     it("creates a config file with config data", () => {
       const fileContents = fs.readFileSync(configFile, "utf8");
-      const configData = yaml.safeLoad(fileContents);
-      expect(configData["testing.dittowords.com"]).toBeDefined();
-      expect(configData["testing.dittowords.com"][0].token).toEqual(
-        "faketoken"
-      );
+      const configData = yaml.load(fileContents);
+      if (configData && typeof configData === "object") {
+        expect(configData["testing.dittowords.com"]).toBeDefined();
+        expect(configData["testing.dittowords.com"][0].token).toEqual(
+          "faketoken"
+        );
+      } else {
+        fail("Config Data should have been an object!");
+      }
     });
   });
 
@@ -73,16 +75,3 @@ describe("Tokens in config files", () => {
     });
   });
 });
-
-describe("save", () => {
-  let data;
-  beforeEach(() => {
-    const file = tempy.writeSync("");
-    config.save(file, "test.setting", true);
-    data = config.readData(file);
-  });
-
-  it("writes a setting correctly", () => {
-    expect(data.test.setting).toEqual(true);
-  });
-});

package/lib/config.ts

@@ -0,0 +1,214 @@
+import fs from "fs";
+import path from "path";
+import url from "url";
+import yaml from "js-yaml";
+
+import consts from "./consts";
+import { Project, ConfigYAML } from "./types";
+
+function createFileIfMissing(filename: string) {
+  const dir = path.dirname(filename);
+
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir);
+
+  if (!fs.existsSync(filename)) {
+    fs.closeSync(fs.openSync(filename, "w"));
+  }
+}
+
+function jsonIsConfigYAML(json: unknown): json is ConfigYAML {
+  return typeof json === "object";
+}
+
+function jsonIsGlobalYAML(
+  json: unknown
+): json is Record<string, { token: string }[]> {
+  return (
+    !!json &&
+    typeof json === "object" &&
+    Object.values(json).every((arr) =>
+      arr.every(
+        (val: any) =>
+          typeof val === "object" && Object.keys(val).includes("token")
+      )
+    )
+  );
+}
+
+/**
+ * Read data from a project config file
+ * @param {string} file defaults to `PROJECT_CONFIG_FILE` defined in `constants.js`
+ * @param {*} defaultData defaults to `{}`
+ * @returns { ConfigYAML }
+ */
+function readProjectConfigData(
+  file = consts.PROJECT_CONFIG_FILE,
+  defaultData = {}
+): ConfigYAML {
+  createFileIfMissing(file);
+  const fileContents = fs.readFileSync(file, "utf8");
+  const yamlData = yaml.load(fileContents);
+  if (jsonIsConfigYAML(yamlData)) {
+    return yamlData;
+  }
+  return defaultData;
+}
+
+/**
+ * Read data from a global config file
+ * @param {string} file defaults to `CONFIG_FILE` defined in `constants.js`
+ * @param {*} defaultData defaults to `{}`
+ * @returns { Record<string, { token: string }[]> }
+ */
+function readGlobalConfigData(
+  file = consts.CONFIG_FILE,
+  defaultData = {}
+): Record<string, { token: string }[]> {
+  createFileIfMissing(file);
+  const fileContents = fs.readFileSync(file, "utf8");
+  const yamlData = yaml.load(fileContents);
+  if (jsonIsGlobalYAML(yamlData)) {
+    return yamlData;
+  }
+  return defaultData;
+}
+
+function writeProjectConfigData(file: string, data: object) {
+  createFileIfMissing(file);
+  const existingData = readProjectConfigData(file);
+  const yamlStr = yaml.dump({ ...existingData, ...data });
+  fs.writeFileSync(file, yamlStr, "utf8");
+}
+
+function writeGlobalConfigData(file: string, data: object) {
+  createFileIfMissing(file);
+  const existingData = readGlobalConfigData(file);
+  const yamlStr = yaml.dump({ ...existingData, ...data });
+  fs.writeFileSync(file, yamlStr, "utf8");
+}
+
+function justTheHost(host: string) {
+  if (!host.includes("://")) return host;
+  return url.parse(host).hostname || "";
+}
+
+function deleteToken(file: string, host: string) {
+  const data = readGlobalConfigData(file);
+  const hostParsed = justTheHost(host);
+  data[hostParsed] = [];
+  data[hostParsed][0] = { token: "" };
+  writeGlobalConfigData(file, data);
+}
+
+function saveToken(file: string, host: string, token: string) {
+  const data = readGlobalConfigData(file);
+  const hostParsed = justTheHost(host);
+  data[hostParsed] = []; // only allow one token per host
+  data[hostParsed][0] = { token };
+  writeGlobalConfigData(file, data);
+}
+
+function getTokenFromEnv() {
+  return process.env.DITTO_API_KEY;
+}
+
+/**
+ *
+ * @param {string} file
+ * @param {string} host
+ * @returns {Token}
+ */
+function getToken(file: string, host: string) {
+  const tokenFromEnv = getTokenFromEnv();
+  if (tokenFromEnv) {
+    return tokenFromEnv;
+  }
+
+  const data = readGlobalConfigData(file);
+  const hostEntry = data[justTheHost(host)];
+  if (!hostEntry) return undefined;
+  const { length } = hostEntry;
+  return hostEntry[length - 1].token;
+}
+
+const IS_DUPLICATE = /-(\d+$)/;
+
+function dedupeProjectName(projectNames: Set<string>, projectName: string) {
+  let dedupedName = projectName;
+
+  if (projectNames.has(dedupedName)) {
+    while (projectNames.has(dedupedName)) {
+      const [_, numberStr] = dedupedName.match(IS_DUPLICATE) || [];
+      if (numberStr && !isNaN(parseInt(numberStr))) {
+        dedupedName = `${dedupedName.replace(IS_DUPLICATE, "")}-${
+          parseInt(numberStr) + 1
+        }`;
+      } else {
+        dedupedName = `${dedupedName}-1`;
+      }
+    }
+  }
+
+  return dedupedName;
+}
+
+/**
+ * Reads from the config file, filters out
+ * invalid projects, dedupes those remaining, and returns:
+ * - whether or not the data required to `pull` is present
+ * - whether or not the component library should be fetched
+ * - an array of valid, deduped projects
+ * - the `variants` and `format` config options
+ */
+function parseSourceInformation() {
+  const { projects, components, variants, format } = readProjectConfigData();
+
+  const projectNames = new Set<string>();
+  const validProjects: Project[] = [];
+
+  let componentLibraryInProjects = false;
+
+  (projects || []).forEach((project) => {
+    const isValid = project.id && project.name;
+    if (!isValid) {
+      return;
+    }
+
+    if (project.id === "ditto_component_library") {
+      componentLibraryInProjects = true;
+      return;
+    }
+
+    project.fileName = dedupeProjectName(projectNames, project.name);
+    projectNames.add(project.fileName);
+
+    validProjects.push(project);
+  });
+
+  const shouldFetchComponentLibrary =
+    !!components || componentLibraryInProjects;
+
+  const hasSourceData = !!validProjects.length || shouldFetchComponentLibrary;
+
+  return {
+    hasSourceData,
+    validProjects,
+    shouldFetchComponentLibrary,
+    variants: variants || false,
+    format,
+  };
+}
+
+export default {
+  createFileIfMissing,
+  readProjectConfigData,
+  readGlobalConfigData,
+  writeGlobalConfigData,
+  writeProjectConfigData,
+  justTheHost,
+  saveToken,
+  deleteToken,
+  getToken,
+  getTokenFromEnv,
+  parseSourceInformation,
+};

package/lib/consts.ts

@@ -0,0 +1,20 @@
+import { homedir } from "os";
+import path from "path";
+
+export const API_HOST =
+  process.env.DITTO_API_HOST || "https://api.dittowords.com";
+export const CONFIG_FILE =
+  process.env.DITTO_CONFIG_FILE || path.join(homedir(), ".config", "ditto");
+export const PROJECT_CONFIG_FILE = path.normalize(
+  path.join("ditto", "config.yml")
+);
+export const TEXT_DIR = process.env.DITTO_TEXT_DIR || "ditto";
+export const TEXT_FILE = path.normalize(path.join(TEXT_DIR, "text.json"));
+
+export default {
+  API_HOST,
+  CONFIG_FILE,
+  PROJECT_CONFIG_FILE,
+  TEXT_DIR,
+  TEXT_FILE,
+};

package/lib/ditto.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+// This is the main entry point for the ditto-cli command.
+import { program } from "commander";
+// to use V8's code cache to speed up instantiation time
+import "v8-compile-cache";
+
+import { init, needsInit } from "./init/init";
+import { pull } from "./pull";
+
+import addProject from "./add-project";
+import removeProject from "./remove-project";
+import processMetaOption from "./utils/processMetaOption";
+
+/**
+ * Catch and report unexpected error.
+ * @param {any} error The thrown error object.
+ * @returns {void}
+ */
+function quit(exitCode = 2) {
+  console.log("\nExiting Ditto CLI...\n");
+  process.exitCode = exitCode;
+  process.exit();
+}
+
+const setupCommands = () => {
+  program.name("ditto-cli");
+  program
+    .command("pull")
+    .description("Sync copy from Ditto into working directory")
+    .action(() => checkInit("pull"));
+
+  const projectDescription = "Add a Ditto project to sync copy from";
+  const projectCommand = program
+    .command("project")
+    .description(projectDescription)
+    .action(() => checkInit("project"));
+
+  projectCommand
+    .command("add")
+    .description(projectDescription)
+    .action(() => checkInit("project"));
+
+  projectCommand
+    .command("remove")
+    .description("Stop syncing copy from a Ditto project")
+    .action(() => checkInit("project remove"));
+};
+
+const setupOptions = () => {
+  program.option(
+    "-m, --meta <data...>",
+    "Optional metadata for this command to send arbitrary data to the backend. Ex: -m githubActionRequest:true trigger:manual"
+  );
+};
+
+const checkInit = async (command: string) => {
+  if (needsInit() && command !== "project remove") {
+    try {
+      await init();
+      if (command === "pull") main(); // re-run to actually pull text now that init is finished
+    } catch (error) {
+      quit();
+    }
+  } else {
+    const { meta } = program.opts();
+    switch (command) {
+      case "pull":
+        pull({ meta: processMetaOption(meta) });
+        break;
+      case "project":
+      case "project add":
+        addProject();
+        break;
+      case "project remove":
+        removeProject();
+        break;
+      case "none":
+        setupCommands();
+        program.help();
+        break;
+      default:
+        quit();
+    }
+  }
+};
+
+const main = async () => {
+  if (process.argv.length <= 2 && process.argv[1].includes("ditto-cli")) {
+    await checkInit("none");
+  } else {
+    setupCommands();
+    setupOptions();
+  }
+  program.parse(process.argv);
+};
+
+main();

package/lib/init/{init.js → init.ts}

@@ -1,17 +1,16 @@
 // Related to initializing a user/environment to ditto.
 // expected to be run once per project.
-const boxen = require("boxen");
-const chalk = require("chalk");
-const projectsToText = require("../utils/projectsToText");
+import boxen from "boxen";
+import chalk from "chalk";
+import projectsToText from "../utils/projectsToText";
 
-const { needsSource, collectAndSaveProject } = require("./project");
-const { needsToken, collectAndSaveToken } = require("./token");
+import { needsSource, collectAndSaveProject } from "./project";
+import { needsToken, collectAndSaveToken } from "./token";
 
-const config = require("../config");
-const output = require("../output");
-const sourcesToText = require("../utils/sourcesToText");
+import config from "../config";
+import sourcesToText from "../utils/sourcesToText";
 
-const needsInit = () => needsToken() || needsSource();
+export const needsInit = () => needsToken() || needsSource();
 
 function welcome() {
   const msg = chalk.white(`${chalk.bold(
@@ -23,7 +22,7 @@ We're glad to have you here.`);
   console.log(boxen(msg, { padding: 1 }));
 }
 
-async function init() {
+export const init = async () => {
   welcome();
 
   if (needsToken()) {
@@ -43,6 +42,6 @@ async function init() {
     sourcesToText(validProjects, shouldFetchComponentLibrary);
 
   console.log(message);
-}
+};
 
-module.exports = { needsInit, init };
+export default { needsInit, init };

package/lib/init/project.test.ts

@@ -0,0 +1,49 @@
+const fs = require("fs");
+const path = require("path");
+
+const yaml = require("js-yaml");
+const { createFileIfMissing } = require("../config");
+
+import { _testing } from "./project";
+
+const fakeProjectDir = path.join(__dirname, "../../testing/tmp");
+const badYaml = path.join(__dirname, "../../testing/fixtures/bad-yaml.yml");
+const configEmptyProjects = path.join(
+  __dirname,
+  "../../testing/fixtures/bad-yaml.yml"
+);
+const configMissingName = path.join(
+  __dirname,
+  "../../testing/fixtures/project-config-no-name.yml"
+);
+const configMissingId = path.join(
+  __dirname,
+  "../../testing/fixtures/project-config-no-id.yml"
+);
+const configLegit = path.join(
+  __dirname,
+  "../../testing/fixtures/project-config-working.yml"
+);
+
+describe("saveProject", () => {
+  const configFile = path.join(fakeProjectDir, "ditto/config.yml");
+  const projectName = "My Amazing Project";
+  const projectId = "5f284259ce1d451b2eb2e23c";
+
+  beforeEach(() => {
+    if (!fs.existsSync(fakeProjectDir)) fs.mkdirSync(fakeProjectDir);
+    _testing.saveProject(configFile, projectName, projectId);
+  });
+
+  afterEach(() => {
+    fs.rmdirSync(fakeProjectDir, { recursive: true });
+  });
+
+  it("creates a config file with config data", () => {
+    const fileContents = fs.readFileSync(configFile, "utf8");
+    const data = yaml.load(fileContents);
+    expect(data.projects).toBeDefined();
+    expect(data.projects[0].name).toEqual(projectName);
+    expect(data.projects[0].id).toEqual(projectId);
+  });
+});

package/lib/init/{project.js → project.ts}

@@ -1,15 +1,17 @@
-const ora = require("ora");
-
-const api = require("../api").default;
-const config = require("../config");
-const consts = require("../consts");
-const output = require("../output");
-const { collectAndSaveToken } = require("../init/token");
-const {
+import ora from "ora";
+
+import api from "../api";
+import config from "../config";
+import consts from "../consts";
+import output from "../output";
+import { collectAndSaveToken } from "./token";
+import {
   getSelectedProjects,
   getIsUsingComponents,
-} = require("../utils/getSelectedProjects");
-const promptForProject = require("../utils/promptForProject");
+} from "../utils/getSelectedProjects";
+import promptForProject from "../utils/promptForProject";
+import { AxiosResponse } from "axios";
+import { Project, Token } from "../types";
 
 function quit(exitCode = 2) {
   console.log("\nExiting Ditto CLI...\n");
@@ -17,23 +19,23 @@ function quit(exitCode = 2) {
   process.exit();
 }
 
-function saveProject(file, name, id) {
-  // old functionality included "components" in the `projects`
+function saveProject(file: string, name: string, id: string) {
+  // old functionality included "ditto_component_library" in the `projects`
   // array, but we want to always treat the component library as a separate
   // entity and use the new notation of a top-level `components` key
   if (id === "components") {
-    config.writeData(file, { components: true });
+    config.writeProjectConfigData(file, { components: true });
     return;
   }
 
   const projects = [...getSelectedProjects(), { name, id }];
 
-  config.writeData(file, { projects });
+  config.writeProjectConfigData(file, { projects });
 }
 
-function needsSource() {
+export const needsSource = () => {
   return !config.parseSourceInformation().hasSourceData;
-}
+};
 
 async function askForAnotherToken() {
   config.deleteToken(consts.CONFIG_FILE, consts.API_HOST);
@@ -43,17 +45,16 @@ async function askForAnotherToken() {
 }
 
 async function listProjects(
-  token,
-  projectsAlreadySelected,
-  componentsSelected
+  token: Token,
+  projectsAlreadySelected: Project[],
+  componentsSelected: boolean
 ) {
   const spinner = ora("Fetching projects in your workspace...");
   spinner.start();
 
-  let projects = [];
-
+  let response: AxiosResponse<{ id: string; name: string }[]>;
   try {
-    projects = await api.get("/project-names", {
+    response = await api.get("/project-names", {
       headers: {
         Authorization: `token ${token}`,
       },
@@ -64,8 +65,7 @@ async function listProjects(
   }
 
   spinner.stop();
-
-  return projects.data.filter(({ id }) => {
+  return response.data.filter(({ id }: Project) => {
     if (id === "ditto_component_library") {
       return !componentsSelected;
     } else {
@@ -74,7 +74,7 @@ async function listProjects(
   });
 }
 
-async function collectProject(token, initialize) {
+async function collectProject(token: Token, initialize: boolean) {
   const path = process.cwd();
   if (initialize) {
     console.log(
@@ -114,7 +114,7 @@ async function collectProject(token, initialize) {
   });
 }
 
-async function collectAndSaveProject(initialize = false) {
+export const collectAndSaveProject = async (initialize = false) => {
   try {
     const token = config.getToken(consts.CONFIG_FILE, consts.API_HOST);
     const project = await collectProject(token, initialize);
@@ -134,7 +134,7 @@ async function collectAndSaveProject(initialize = false) {
     );
 
     saveProject(consts.PROJECT_CONFIG_FILE, project.name, project.id);
-  } catch (e) {
+  } catch (e: any) {
     console.log(e);
     if (e.response && e.response.status === 404) {
       await askForAnotherToken();
@@ -143,6 +143,8 @@ async function collectAndSaveProject(initialize = false) {
       quit();
     }
   }
-}
+};
+
+export const _testing = { saveProject, needsSource };
 
-module.exports = { needsSource, collectAndSaveProject };
+export default { needsSource, collectAndSaveProject };

package/lib/init/{token.test.js → token.test.ts}

@@ -1,7 +1,7 @@
-const tempy = require("tempy");
+import tempy from "tempy";
 
-const config = require("../config");
-const { needsToken } = require("./token");
+import config from "../config";
+import { needsToken } from "./token";
 
 describe("needsToken()", () => {
   it("is true if there is no config file", () => {