@dittowords/cli 2.5.1 → 2.5.2

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", () => {

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

@@ -1,38 +1,38 @@
-const fs = require("fs");
+import fs from "fs";
 
-const chalk = require("chalk");
+import chalk from "chalk";
 
-const { prompt } = require("enquirer");
+import { prompt } from "enquirer";
 
-const api = require("../api");
-const consts = require("../consts");
-const output = require("../output");
-const config = require("../config");
+import { create } from "../api";
+import consts from "../consts";
+import output from "../output";
+import config from "../config";
 
-function needsToken(configFile, host = consts.API_HOST) {
+export const needsToken = (configFile?: string, host = consts.API_HOST) => {
   if (config.getTokenFromEnv()) {
     return false;
   }
 
   const file = configFile || consts.CONFIG_FILE;
   if (!fs.existsSync(file)) return true;
-  const configData = config.readData(file);
+  const configData = config.readGlobalConfigData(file);
   if (
     !configData[config.justTheHost(host)] ||
     configData[config.justTheHost(host)][0].token === ""
   )
     return true;
   return false;
-}
+};
 
 // Returns true if valid, otherwise an error message.
-async function checkToken(token) {
-  const axios = api.create(token);
+async function checkToken(token: string): Promise<any> {
+  const axios = create(token);
   const endpoint = "/token-check";
 
   const resOrError = await axios
     .get(endpoint)
-    .catch((error) => {
+    .catch((error: any) => {
       if (error.code === "ENOTFOUND") {
         return output.errorText(
           `Can't connect to API: ${output.url(error.hostname)}`
@@ -48,7 +48,6 @@ async function checkToken(token) {
     .catch(() =>
       output.errorText("Sorry! We're having trouble reaching the Ditto API.")
     );
-
   if (typeof resOrError === "string") return resOrError;
 
   if (resOrError.status === 200) return true;
@@ -56,7 +55,7 @@ async function checkToken(token) {
   return output.errorText("This API key isn't valid. Please try another.");
 }
 
-async function collectToken(message) {
+async function collectToken(message: string | null) {
   const blue = output.info;
   const apiUrl = output.url("https://app.dittowords.com/account/user");
   const breadcrumbs = `${blue("User")}`;
@@ -67,7 +66,7 @@ async function collectToken(message) {
     )}".`;
   console.log(tokenDescription);
 
-  const response = await prompt({
+  const response = await prompt<{ token: string }>({
     type: "input",
     name: "token",
     message: "What is your API key?",
@@ -82,7 +81,12 @@ function quit(exitCode = 2) {
   process.exit();
 }
 
-async function collectAndSaveToken(message = null) {
+/**
+ *
+ * @param {string | null} message
+ * @returns
+ */
+export const collectAndSaveToken = async (message: string | null = null) => {
   try {
     const token = await collectToken(message);
     console.log(
@@ -97,6 +101,6 @@ async function collectAndSaveToken(message = null) {
   } catch (error) {
     quit();
   }
-}
+};
 
-module.exports = { needsToken, collectAndSaveToken };
+export default { needsToken, collectAndSaveToken };

package/lib/output.ts

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+
+export const errorText = (msg: string) => chalk.magenta(msg);
+export const warnText = (msg: string) => chalk.yellow(msg);
+export const info = (msg: string) => chalk.blueBright(msg);
+export const success = (msg: string) => chalk.green(msg);
+export const url = (msg: string) => chalk.blueBright.underline(msg);
+export const subtle = (msg: string) => chalk.grey(msg);
+export const write = (msg: string) => chalk.white(msg);
+export const nl = () => console.log("\n");
+
+export default {
+  errorText,
+  warnText,
+  info,
+  success,
+  url,
+  subtle,
+  write,
+  nl,
+};

package/lib/pull.test.ts

@@ -0,0 +1,142 @@
+import fs from "fs";
+import path from "path";
+import api from "./api";
+import config from "./config";
+
+const testProjects = [
+  {
+    id: "1",
+    name: "Project 1",
+    fileName: "Project 1",
+  },
+  { id: "2", name: "Project 2", fileName: "Project 2" },
+];
+
+jest.mock("./api");
+api.get = jest.fn().mockResolvedValue({ data: [] });
+
+jest.mock("./consts", () => ({
+  TEXT_DIR: ".testing",
+  API_HOST: "https://api.dittowords.com",
+  CONFIG_FILE: ".testing/ditto",
+  PROJECT_CONFIG_FILE: ".testing/config.yml",
+  TEXT_FILE: ".testing/text.json",
+}));
+
+import consts from "./consts";
+import allPull from "./pull";
+
+const {
+  _testing: { cleanOutputFiles, downloadAndSaveVariant, downloadAndSaveBase },
+} = allPull;
+const variant = "english";
+
+const cleanOutputDir = () => {
+  if (fs.existsSync(consts.TEXT_DIR))
+    fs.rmSync(consts.TEXT_DIR, { recursive: true, force: true });
+
+  fs.mkdirSync(consts.TEXT_DIR);
+};
+
+afterAll(() => {
+  fs.rmSync(consts.TEXT_DIR, { force: true, recursive: true });
+});
+
+describe("cleanOutputFiles", () => {
+  it("removes .js and .json files", () => {
+    cleanOutputDir();
+
+    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.json"), "test");
+    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.js"), "test");
+    // this file shouldn't be deleted
+    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.txt"), "test");
+
+    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(3);
+
+    cleanOutputFiles();
+
+    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(1);
+  });
+});
+
+// describe("downloadAndSaveVariant", () => {
+//   beforeAll(() => {
+//     if (!fs.existsSync(consts.TEXT_DIR)) {
+//       fs.mkdirSync(consts.TEXT_DIR);
+//     }
+//   });
+
+//   it("writes a single file for default format", async () => {
+//     cleanOutputDir();
+
+//     const output = await downloadAndSaveVariant(variant, testProjects, "");
+//     expect(/saved to.*english\.json/.test(output)).toEqual(true);
+//     expect(output.match(/saved to/g)?.length).toEqual(1);
+//     expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(1);
+//   });
+
+//   it("writes multiple files for flat format", async () => {
+//     cleanOutputDir();
+
+//     const output = await downloadAndSaveVariant(variant, testProjects, "flat");
+
+//     expect(/saved to.*Project 1__english\.json/.test(output)).toEqual(true);
+//     expect(/saved to.*Project 2__english\.json/.test(output)).toEqual(true);
+//     expect(output.match(/saved to/g)?.length).toEqual(2);
+//     expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(2);
+//   });
+
+//   it("writes multiple files for structured format", async () => {
+//     cleanOutputDir();
+
+//     const output = await downloadAndSaveVariant(
+//       variant,
+//       testProjects,
+//       "structured"
+//     );
+
+//     expect(/saved to.*Project 1__english\.json/.test(output)).toEqual(true);
+//     expect(/saved to.*Project 2__english\.json/.test(output)).toEqual(true);
+//     expect(output.match(/saved to/g)?.length).toEqual(2);
+//     expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(2);
+//   });
+// });
+
+describe("downloadAndSaveBase", () => {
+  beforeAll(() => {
+    if (!fs.existsSync(consts.TEXT_DIR)) {
+      fs.mkdirSync(consts.TEXT_DIR);
+    }
+  });
+
+  it("writes to text.json for default format", async () => {
+    cleanOutputDir();
+
+    const output = await downloadAndSaveBase(testProjects, "");
+
+    expect(/saved to.*text\.json/.test(output)).toEqual(true);
+    expect(output.match(/saved to/g)?.length).toEqual(1);
+    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(1);
+  });
+
+  it("writes multiple files for flat format", async () => {
+    cleanOutputDir();
+
+    const output = await downloadAndSaveBase(testProjects, "flat");
+    expect(/saved to.*Project 1\.json/.test(output)).toEqual(true);
+    expect(/saved to.*Project 2\.json/.test(output)).toEqual(true);
+    expect(output.match(/saved to/g)?.length).toEqual(2);
+    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(2);
+  });
+
+  it("writes multiple files for structured format", async () => {
+    cleanOutputDir();
+
+    const output = await downloadAndSaveBase(testProjects, "structured");
+
+    expect(/saved to.*Project 1\.json/.test(output)).toEqual(true);
+    expect(/saved to.*Project 2\.json/.test(output)).toEqual(true);
+    expect(output.match(/saved to/g)?.length).toEqual(2);
+    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(2);
+  });
+});