@dittowords/cli 2.5.1 → 2.6.0

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,172 @@
+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");
+
+const mockApi = api as jest.Mocked<typeof api>;
+
+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, .json, .xml, and .strings files", () => {
+    cleanOutputDir();
+
+    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.json"), "test");
+    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.js"), "test");
+    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.xml"), "test");
+    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.strings"), "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(5);
+
+    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();
+
+    mockApi.get.mockResolvedValueOnce({ data: [] });
+    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();
+
+    mockApi.get.mockResolvedValue({ data: [] });
+    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();
+
+    mockApi.get.mockResolvedValue({ data: [] });
+    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);
+  });
+
+  it("writes .xml files for android", async () => {
+    cleanOutputDir();
+
+    mockApi.get.mockResolvedValue({ data: "hello" });
+    const output = await downloadAndSaveBase(testProjects, "android");
+
+    expect(/saved to.*Project 1\.xml/.test(output)).toEqual(true);
+    expect(/saved to.*Project 2\.xml/.test(output)).toEqual(true);
+    expect(output.match(/saved to/g)?.length).toEqual(2);
+    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(2);
+  });
+
+  it("writes .strings files for ios-strings", async () => {
+    cleanOutputDir();
+
+    mockApi.get.mockResolvedValue({ data: "hello" });
+    const output = await downloadAndSaveBase(testProjects, "ios-strings");
+
+    expect(/saved to.*Project 1\.strings/.test(output)).toEqual(true);
+    expect(/saved to.*Project 2\.strings/.test(output)).toEqual(true);
+    expect(output.match(/saved to/g)?.length).toEqual(2);
+    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(2);
+  });
+});

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

@@ -1,20 +1,20 @@
-const fs = require("fs");
-const path = require("path");
+import fs from "fs";
+import path from "path";
 
-const ora = require("ora");
+import ora from "ora";
 
-const api = require("./api").default;
-const config = require("./config");
-const consts = require("./consts");
-const output = require("./output");
-const { collectAndSaveToken } = require("./init/token");
-const projectsToText = require("./utils/projectsToText");
-const sourcesToText = require("./utils/sourcesToText");
+import api from "./api";
+import config from "./config";
+import consts from "./consts";
+import output from "./output";
+import { collectAndSaveToken } from "./init/token";
+import sourcesToText from "./utils/sourcesToText";
+import { SourceInformation, Token, Project } from "./types";
 
-const NON_DEFAULT_FORMATS = ["flat", "structured"];
+const NON_DEFAULT_FORMATS = ["flat", "structured", "android", "ios-strings"];
 
 const DEFAULT_FORMAT_KEYS = ["projects", "exported_at"];
-const hasVariantData = (data) => {
+const hasVariantData = (data: any) => {
   const hasTopLevelKeys =
     Object.keys(data).filter((key) => !DEFAULT_FORMAT_KEYS.includes(key))
       .length > 0;
@@ -31,6 +31,16 @@ async function askForAnotherToken() {
   await collectAndSaveToken(message);
 }
 
+function getExtension(format: string) {
+  if (format === "android") {
+    return ".xml";
+  }
+  if (format === "ios-strings") {
+    return ".strings";
+  }
+  return ".json";
+}
+
 /**
  * For a given variant:
  * - if format is unspecified, fetch data for all projects from `/projects` and
@@ -38,15 +48,22 @@ async function askForAnotherToken() {
  * - if format is `flat` or `structured`, fetch data for each project from `/project/:project_id` and
  * save in `{projectName}-${variantApiId}.json`
  */
-async function downloadAndSaveVariant(variantApiId, projects, format, token) {
-  const params = { variant: variantApiId };
+async function downloadAndSaveVariant(
+  variantApiId: string | null,
+  projects: Project[],
+  format: string | undefined,
+  token?: Token
+) {
+  const params: Record<string, string | null> = {
+    variant: variantApiId,
+  };
   if (format) {
     params.format = format;
   }
 
-  if (NON_DEFAULT_FORMATS.includes(format)) {
+  if (format && NON_DEFAULT_FORMATS.includes(format)) {
     const savedMessages = await Promise.all(
-      projects.map(async ({ id, fileName }) => {
+      projects.map(async ({ id, fileName }: Project) => {
         const { data } = await api.get(`/projects/${id}`, {
           params,
           headers: { Authorization: `token ${token}` },
@@ -56,10 +73,16 @@ async function downloadAndSaveVariant(variantApiId, projects, format, token) {
           return "";
         }
 
-        const filename = fileName + ("__" + (variantApiId || "base")) + ".json";
+        const extension = getExtension(format);
+
+        const filename =
+          fileName + ("__" + (variantApiId || "base")) + extension;
         const filepath = path.join(consts.TEXT_DIR, filename);
 
-        const dataString = JSON.stringify(data, null, 2);
+        let dataString = data;
+        if (extension === ".json") {
+          dataString = JSON.stringify(data, null, 2);
+        }
 
         fs.writeFileSync(filepath, dataString);
 
@@ -89,10 +112,12 @@ async function downloadAndSaveVariant(variantApiId, projects, format, token) {
   }
 }
 
-/**
- * @param {{ meta: Object.<string, string> }} options
- */
-async function downloadAndSaveVariants(projects, format, token, options) {
+async function downloadAndSaveVariants(
+  projects: Project[],
+  format: string | undefined,
+  token?: Token,
+  options?: PullOptions
+) {
   const meta = options ? options.meta : {};
 
   const { data: variants } = await api.get("/variants", {
@@ -105,7 +130,7 @@ async function downloadAndSaveVariants(projects, format, token, options) {
 
   const messages = await Promise.all([
     downloadAndSaveVariant(null, projects, format, token),
-    ...variants.map(({ apiID }) =>
+    ...variants.map(({ apiID }: { apiID: string }) =>
       downloadAndSaveVariant(apiID, projects, format, token)
     ),
   ]);
@@ -113,10 +138,12 @@ async function downloadAndSaveVariants(projects, format, token, options) {
   return messages.join("");
 }
 
-/**
- @param {{ meta: Object.<string, string> }} options
- */
-async function downloadAndSaveBase(projects, format, token, options) {
+async function downloadAndSaveBase(
+  projects: Project[],
+  format: string | undefined,
+  token?: Token,
+  options?: PullOptions
+) {
   const meta = options ? options.meta : {};
 
   const params = {
@@ -126,18 +153,22 @@ async function downloadAndSaveBase(projects, format, token, options) {
     params.format = format;
   }
 
-  if (NON_DEFAULT_FORMATS.includes(format)) {
+  if (format && NON_DEFAULT_FORMATS.includes(format)) {
     const savedMessages = await Promise.all(
-      projects.map(async ({ id, fileName }) => {
+      projects.map(async ({ id, fileName }: Project) => {
         const { data } = await api.get(`/projects/${id}`, {
           params,
           headers: { Authorization: `token ${token}` },
         });
 
-        const filename = `${fileName}.json`;
+        const extension = getExtension(format);
+        const filename = `${fileName}${extension}`;
         const filepath = path.join(consts.TEXT_DIR, filename);
 
-        const dataString = JSON.stringify(data, null, 2);
+        let dataString = data;
+        if (extension === ".json") {
+          dataString = JSON.stringify(data, null, 2);
+        }
 
         fs.writeFileSync(filepath, dataString);
 
@@ -160,7 +191,7 @@ async function downloadAndSaveBase(projects, format, token, options) {
   }
 }
 
-function getSavedMessage(file) {
+function getSavedMessage(file: string) {
   return `Successfully saved to ${output.info(file)}\n`;
 }
 
@@ -171,7 +202,7 @@ function cleanOutputFiles() {
 
   const fileNames = fs.readdirSync(consts.TEXT_DIR);
   fileNames.forEach((fileName) => {
-    if (/\.js(on)?$/.test(fileName)) {
+    if (/\.js(on)?|\.xml|\.strings$/.test(fileName)) {
       fs.unlinkSync(path.resolve(consts.TEXT_DIR, fileName));
     }
   });
@@ -181,7 +212,7 @@ function cleanOutputFiles() {
 
 // compatability with legacy method of specifying project ids
 // that is still used by the default format
-const stringifyProjectId = (projectId) =>
+const stringifyProjectId = (projectId: string) =>
   projectId === "ditto_component_library" ? projectId : `project_${projectId}`;
 
 /**
@@ -195,74 +226,88 @@ const stringifyProjectId = (projectId) =>
  * independent of the CLI configuration used to fetch
  * data from Ditto.
  */
-function generateJsDriver(projects, variants, format) {
+function generateJsDriver(
+  projects: Project[],
+  variants: boolean,
+  format: string | undefined
+) {
   const fileNames = fs
     .readdirSync(consts.TEXT_DIR)
     .filter((fileName) => /\.json$/.test(fileName));
 
-  const projectIdsByName = projects.reduce(
-    (agg, project) => ({ ...agg, [project.fileName]: project.id }),
+  const projectIdsByName: Record<string, string> = projects.reduce(
+    (agg, project) => {
+      if (project.fileName) {
+        return { ...agg, [project.fileName]: project.id };
+      }
+      return agg;
+    },
     {}
   );
 
-  const data = fileNames.reduce((obj, fileName) => {
-    // filename format: {project-name}__{variant-api-id}.json
-    // file format: flat or structured
-    if (variants && format) {
-      const [projectName, rest] = fileName.split("__");
-      const [variantApiId] = rest.split(".");
+  const data = fileNames.reduce(
+    (obj: Record<string, Record<string, string>>, fileName) => {
+      // filename format: {project-name}__{variant-api-id}.json
+      // file format: flat or structured
+      if (variants && format) {
+        const [projectName, rest] = fileName.split("__");
+        const [variantApiId] = rest.split(".");
+
+        const projectId = projectIdsByName[projectName];
+        if (!projectId) {
+          throw new Error(`Couldn't find id for ${projectName}`);
+        }
 
-      const projectId = projectIdsByName[projectName];
-      if (!projectId) {
-        throw new Error(`Couldn't find id for ${projectName}`);
-      }
+        const projectIdStr = stringifyProjectId(projectId);
 
-      const projectIdStr = stringifyProjectId(projectId);
+        if (!obj[projectIdStr]) {
+          obj[projectIdStr] = {};
+        }
 
-      if (!obj[projectIdStr]) {
-        obj[projectIdStr] = {};
+        obj[projectIdStr][variantApiId] = `require('./${fileName}')`;
       }
-
-      obj[projectIdStr][variantApiId] = `require('./${fileName}')`;
-    }
-    // filename format: {variant-api-id}.json
-    // file format: default
-    else if (variants) {
-      const file = require(path.resolve(consts.TEXT_DIR, `./${fileName}`));
-      const [variantApiId] = fileName.split(".");
-
-      Object.keys(file.projects).forEach((projectId) => {
-        if (!obj[projectId]) {
-          obj[projectId] = {};
+      // filename format: {variant-api-id}.json
+      // file format: default
+      else if (variants) {
+        const file = require(path.resolve(consts.TEXT_DIR, `./${fileName}`));
+        const [variantApiId] = fileName.split(".");
+
+        Object.keys(file.projects).forEach((projectId) => {
+          if (!obj[projectId]) {
+            obj[projectId] = {};
+          }
+
+          const project = file.projects[projectId];
+          obj[projectId][variantApiId] = project.frames || project.components;
+        });
+      }
+      // filename format: {project-name}.json
+      // file format: flat or structured
+      else if (format) {
+        const [projectName] = fileName.split(".");
+        const projectId = projectIdsByName[projectName];
+        if (!projectId) {
+          throw new Error(`Couldn't find id for ${projectName}`);
         }
 
-        const project = file.projects[projectId];
-        obj[projectId][variantApiId] = project.frames || project.components;
-      });
-    }
-    // filename format: {project-name}.json
-    // file format: flat or structured
-    else if (format) {
-      const [projectName] = fileName.split(".");
-      const projectId = projectIdsByName[projectName];
-      if (!projectId) {
-        throw new Error(`Couldn't find id for ${projectName}`);
+        obj[stringifyProjectId(projectId)] = {
+          base: `require('./${fileName}')`,
+        };
+      }
+      // filename format: text.json (single file)
+      // file format: default
+      else {
+        const file = require(path.resolve(consts.TEXT_DIR, `./${fileName}`));
+        Object.keys(file.projects).forEach((projectId) => {
+          const project = file.projects[projectId];
+          obj[projectId] = { base: project.frames || project.components };
+        });
       }
 
-      obj[stringifyProjectId(projectId)] = { base: `require('./${fileName}')` };
-    }
-    // filename format: text.json (single file)
-    // file format: default
-    else {
-      const file = require(path.resolve(consts.TEXT_DIR, `./${fileName}`));
-      Object.keys(file.projects).forEach((projectId) => {
-        const project = file.projects[projectId];
-        obj[projectId] = { base: project.frames || project.components };
-      });
-    }
-
-    return obj;
-  }, {});
+      return obj;
+    },
+    {}
+  );
 
   let dataString = `module.exports = ${JSON.stringify(data, null, 2)}`
     // remove quotes around require statements
@@ -274,10 +319,11 @@ function generateJsDriver(projects, variants, format) {
   return `Generated .js SDK driver at ${output.info(filePath)}`;
 }
 
-/**
- * @param {{ meta: Object.<string, string> }} options
- */
-async function downloadAndSave(sourceInformation, token, options) {
+async function downloadAndSave(
+  sourceInformation: SourceInformation,
+  token?: Token,
+  options?: PullOptions
+) {
   const { validProjects, variants, format, shouldFetchComponentLibrary } =
     sourceInformation;
 
@@ -314,7 +360,7 @@ async function downloadAndSave(sourceInformation, token, options) {
 
     spinner.stop();
     return console.log(msg);
-  } catch (e) {
+  } catch (e: any) {
     spinner.stop();
     let error = e.message;
     if (e.response && e.response.status === 404) {
@@ -351,18 +397,19 @@ async function downloadAndSave(sourceInformation, token, options) {
   }
 }
 
-/**
- * @param {{ meta: Object.<string, string> }} options
- */
-function pull(options) {
+interface PullOptions {
+  meta?: Record<string, string>;
+}
+
+export const pull = (options?: PullOptions) => {
   const meta = options ? options.meta : {};
   const token = config.getToken(consts.CONFIG_FILE, consts.API_HOST);
   const sourceInformation = config.parseSourceInformation();
 
   return downloadAndSave(sourceInformation, token, { meta });
-}
+};
 
-module.exports = {
+export default {
   pull,
   _testing: {
     cleanOutputFiles,