@dittowords/cli 4.3.0 → 4.4.1

package/lib/http/__mocks__/fetchComponentFolders.ts

@@ -0,0 +1,23 @@
+import type { FetchComponentFoldersResponse } from "../fetchComponentFolders";
+
+export const MOCK_COMPONENT_FOLDERS: FetchComponentFoldersResponse = {
+  example_folder: "Example Folder",
+};
+
+export const MOCK_COMPONENT_FOLDERS_WITH_SAMPLE_DATA: FetchComponentFoldersResponse =
+  {
+    example_folder: "Example Folder",
+    example_folder_sample: "Sample Example Folder",
+  };
+
+export async function fetchComponentFolders(
+  _options: {
+    showSampleData?: boolean;
+  } = {}
+): Promise<FetchComponentFoldersResponse> {
+  if (_options.showSampleData) {
+    return MOCK_COMPONENT_FOLDERS_WITH_SAMPLE_DATA;
+  }
+
+  return MOCK_COMPONENT_FOLDERS;
+}

package/lib/http/__mocks__/fetchComponents.ts

@@ -0,0 +1,24 @@
+import { FetchComponentResponse } from "../fetchComponents";
+
+export const MOCK_COMPONENTS_RESPONSE: FetchComponentResponse = {
+  "component-1": {
+    name: "Example Component 1",
+    text: "This is example component text.",
+    status: "NONE",
+    folder: null,
+  },
+  "component-2": {
+    name: "Example Component 2",
+    text: "This is example component text.",
+    status: "NONE",
+    folder: null,
+  },
+};
+
+export async function fetchComponents(
+  _options: {
+    componentFolder?: string;
+  } = {}
+): Promise<FetchComponentResponse> {
+  return MOCK_COMPONENTS_RESPONSE;
+}

package/lib/http/__mocks__/fetchVariants.ts

@@ -0,0 +1,21 @@
+import { IVariant } from "../fetchVariants";
+
+export const MOCK_VARIANTS_RESPONSE: IVariant[] = [
+  {
+    name: "Example Variant 1",
+    description: "This is example variant 1.",
+    apiID: "example-variant-1",
+  },
+  {
+    name: "Example Variant 2",
+    description: "This is example variant 2.",
+    apiID: "example-variant-2",
+  },
+];
+
+export async function fetchVariants(
+  _source: any,
+  _options: any = {}
+): Promise<IVariant[] | null> {
+  return MOCK_VARIANTS_RESPONSE;
+}

package/lib/http/fetchComponentFolders.ts

@@ -1,12 +1,14 @@
 import { createApiClient } from "../api";
 
-interface FetchComponentFoldersResponse {
+export interface FetchComponentFoldersResponse {
   [id: string]: string;
 }
 
-export async function fetchComponentFolders(options: {
-  showSampleData?: boolean;
-}): Promise<FetchComponentFoldersResponse> {
+export async function fetchComponentFolders(
+  options: {
+    showSampleData?: boolean;
+  } = {}
+): Promise<FetchComponentFoldersResponse> {
   const api = createApiClient();
 
   let url = "/v1/component-folders";

package/lib/http/fetchComponents.ts

@@ -11,9 +11,11 @@ export interface FetchComponentResponse {
   [compApiId: string]: FetchComponentResponseComponent;
 }
 
-export async function fetchComponents(options: {
-  componentFolder?: string;
-}): Promise<FetchComponentResponse> {
+export async function fetchComponents(
+  options: {
+    componentFolder?: string;
+  } = {}
+): Promise<FetchComponentResponse> {
   const api = createApiClient();
 
   if (options.componentFolder) {

package/lib/http/fetchVariants.ts

@@ -3,10 +3,21 @@ import { createApiClient } from "../api";
 import { PullOptions } from "../pull";
 import { SourceInformation } from "../types";
 
+export interface IVariant {
+  name: string;
+  description: string;
+  apiID: string;
+}
+
+type SourceArg = Pick<
+  SourceInformation,
+  "shouldFetchComponentLibrary" | "validProjects" | "variants"
+>;
+
 export async function fetchVariants(
-  source: SourceInformation,
+  source: SourceArg,
   options: PullOptions = {}
-) {
+): Promise<IVariant[] | null> {
   const api = createApiClient();
   if (!source.variants) {
     return null;
@@ -15,7 +26,7 @@ export async function fetchVariants(
   const { shouldFetchComponentLibrary, validProjects } = source;
 
   const config: AxiosRequestConfig = {
-    params: { ...options?.meta },
+    params: { ...options?.meta, showSampleData: options.includeSampleData },
   };
 
   // if we're not syncing from the component library, then we pass the project ids
@@ -25,7 +36,7 @@ export async function fetchVariants(
     config.params.projectIds = validProjects.map(({ id }) => id);
   }
 
-  const { data } = await api.get<{ apiID: string }[]>("/v1/variants", config);
+  const { data } = await api.get<IVariant[]>("/v1/variants", config);
 
   return data;
 }

package/lib/http/http.test.ts

@@ -0,0 +1,122 @@
+import { fetchComponentFolders } from "./fetchComponentFolders";
+import { fetchComponents } from "./fetchComponents";
+import { fetchVariants } from "./fetchVariants";
+import { importComponents } from "./importComponents";
+import { jest } from "@jest/globals";
+import axios from "axios";
+import { vol } from "memfs";
+
+jest.mock("../api");
+jest.mock("fs");
+
+const axiosMocked = jest.mocked(axios);
+
+describe("fetchComponentFolders", () => {
+  it("fetches component folders without error", async () => {
+    axiosMocked.get.mockResolvedValueOnce({
+      data: { "folder-id": "folder-name" },
+    });
+    const result = await fetchComponentFolders();
+    expect(result["folder-id"]).toBe("folder-name");
+  });
+  it("supports showSampleData option", async () => {
+    axiosMocked.get.mockResolvedValueOnce({
+      data: { "folder-id": "folder-name" },
+    });
+    const result = await fetchComponentFolders({ showSampleData: true });
+    expect(result["folder-id"]).toBe("folder-name");
+  });
+});
+
+describe("fetchComponents", () => {
+  it("fetches components without error", async () => {
+    axiosMocked.get.mockResolvedValueOnce({
+      data: {
+        "component-id": {
+          name: "component-name",
+          text: "component-text",
+          status: "NONE",
+          folder: null,
+        },
+      },
+    });
+    const result = await fetchComponents();
+    expect(result["component-id"]).toBeDefined();
+    expect(result["component-id"].name).toBe("component-name");
+    expect(result["component-id"].text).toBe("component-text");
+  });
+});
+
+describe("fetchVariants", () => {
+  it("fetches variants without error", async () => {
+    axiosMocked.get.mockResolvedValueOnce({
+      data: [
+        {
+          name: "variant-name",
+          description: "variant-description",
+          apiID: "variant-api-id",
+        },
+      ],
+    });
+    const result = await fetchVariants({
+      shouldFetchComponentLibrary: true,
+      validProjects: [],
+      variants: true,
+    });
+    expect(result).toBeTruthy();
+    expect(result![0]).toBeDefined();
+    expect(result![0].name).toBe("variant-name");
+    expect(result![0].description).toBe("variant-description");
+    expect(result![0].apiID).toBe("variant-api-id");
+  });
+  it("returns null if `variants` isn't in config", async () => {
+    const result = await fetchVariants({
+      shouldFetchComponentLibrary: true,
+      validProjects: [],
+      variants: false,
+    });
+    expect(result).toBe(null);
+  });
+});
+
+describe("importComponents", () => {
+  beforeEach(() => {
+    vol.reset();
+  });
+  it("imports components from existing file without error", async () => {
+    vol.fromJSON({
+      "/file.csv": "id,name,text\n1,one1,not empty\n2,two1,empty",
+    });
+
+    axiosMocked.mockResolvedValueOnce({
+      data: {
+        componentsInserted: 2,
+        firstImportedId: "1",
+      },
+    });
+
+    const result = await importComponents("/file.csv", {
+      csvColumnMapping: {
+        name: "name",
+        text: 2,
+        componentId: 0,
+      },
+    });
+
+    expect(result.componentsInserted).toBe(2);
+    expect(result.firstImportedId).toBe("1");
+  });
+
+  it("returns null firstImportedId if file doesn't exist", async () => {
+    const result = await importComponents("/file.csv", {
+      csvColumnMapping: {
+        name: "name",
+        text: 2,
+        componentId: 0,
+      },
+    });
+
+    expect(result.componentsInserted).toBe(0);
+    expect(result.firstImportedId).toBe("null");
+  });
+});

package/lib/http/importComponents.ts

@@ -24,6 +24,14 @@ export async function importComponents(
 ): Promise<ImportComponentResponse> {
   const api = createApiClient();
 
+  if (!fs.existsSync(path)) {
+    console.error("Failed to import file: couldn't find file at path " + path);
+    return {
+      componentsInserted: 0,
+      firstImportedId: "null",
+    };
+  }
+
   const form = new FormData();
   form.append("import", fs.createReadStream(path));
 

package/lib/init/project.test.ts

@@ -1,44 +1,21 @@
 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"
-);
+const fakeProjectDir = "/";
+
+jest.mock("fs");
 
 describe("saveProject", () => {
-  const configFile = path.join(fakeProjectDir, "ditto/config.yml");
+  const configFile = "/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);

package/lib/init/token.test.ts

@@ -1,22 +1,51 @@
-import tempy from "tempy";
-
+import fs from "fs";
 import config from "../config";
+import { randomUUID } from "crypto";
 import { needsToken } from "./token";
+import { _test } from "./token";
+import { vol } from "memfs";
+import { jest } from "@jest/globals";
+import axios from "axios";
+
+jest.mock("fs");
+jest.mock("../api");
+
+const axiosMocked = jest.mocked(axios);
+
+const defaultEnv = { ...process.env };
 
-describe("needsToken()", () => {
+beforeEach(() => {
+  vol.reset();
+  process.env = { ...defaultEnv };
+});
+
+describe("needsToken", () => {
   it("is true if there is no config file", () => {
-    expect(needsToken(tempy.file())).toBeTruthy();
+    expect(needsToken(randomUUID())).toBeTruthy();
+  });
+
+  it("is false if there is a token in the environment", () => {
+    process.env.DITTO_API_KEY = "xxx-xxx-xxx";
+    expect(needsToken(randomUUID())).toBe(false);
   });
 
   describe("with a config file", () => {
     let configFile = "";
 
-    beforeEach(() => {
-      configFile = tempy.writeSync("");
+    beforeEach(async () => {
+      configFile = `/${randomUUID()}`;
+      await new Promise((resolve, reject) =>
+        fs.writeFile(configFile, "", (err) => {
+          if (err) reject(err);
+          else {
+            resolve(null);
+          }
+        })
+      );
     });
 
     it("returns true if empty", () => {
-      expect(needsToken(configFile, "testing.dittowrods.com")).toBeTruthy();
+      expect(needsToken(configFile, "testing.dittowords.com")).toBeTruthy();
     });
 
     describe("with some data", () => {
@@ -49,3 +78,22 @@ describe("needsToken()", () => {
     });
   });
 });
+
+const { verifyTokenUsingTokenCheck } = _test;
+describe("verifyTokenUsingTokenCheck", () => {
+  it("returns success: true for api success response", async () => {
+    axiosMocked.get.mockResolvedValueOnce({ status: 200 });
+    const result = await verifyTokenUsingTokenCheck("xxx-xxx");
+    expect(result.success).toBe(true);
+  });
+  it("returns success: false for api unauthorized response", async () => {
+    axiosMocked.get.mockResolvedValueOnce({ status: 401 });
+    const result = await verifyTokenUsingTokenCheck("xxx-xxx");
+    expect(result.success).toBe(false);
+  });
+  it("returns success: false for api invalid response", async () => {
+    axiosMocked.get.mockResolvedValueOnce("error");
+    const result = await verifyTokenUsingTokenCheck("xxx-xxx");
+    expect(result.success).toBe(false);
+  });
+});

package/lib/init/token.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import * as Sentry from "@sentry/node";
 
 import chalk from "chalk";
 
@@ -9,6 +10,7 @@ import consts from "../consts";
 import output from "../output";
 import config from "../config";
 import { quit } from "../utils/quit";
+import { AxiosError, AxiosResponse } from "axios";
 
 export const needsToken = (configFile?: string, host = consts.API_HOST) => {
   if (config.getTokenFromEnv()) {
@@ -26,51 +28,82 @@ export const needsToken = (configFile?: string, host = consts.API_HOST) => {
   return false;
 };
 
-// Returns true if valid, otherwise an error message.
-async function checkToken(token: string): Promise<any> {
+async function verifyTokenUsingTokenCheck(
+  token: string
+): Promise<{ success: true } | { success: false; output: string[] }> {
   const axios = createApiClient(token);
   const endpoint = "/token-check";
 
-  let resOrError;
+  let resOrError: AxiosResponse<any> | undefined;
   try {
-    resOrError = await axios.get(endpoint).catch((error: any) => {
-      if (error.code === "ENOTFOUND") {
-        return output.errorText(
-          `Can't connect to API: ${output.url(error.hostname)}`
-        );
-      }
-      if (error.response.status === 401 || error.response.status === 404) {
-        return output.errorText(
-          "This API key isn't valid. Please try another."
-        );
-      }
-      return output.warnText("We're having trouble reaching the Ditto API.");
-    });
+    resOrError = await axios.get(endpoint);
   } catch (e: unknown) {
-    output.errorText(e as any);
-    output.errorText("Sorry! We're having trouble reaching the Ditto API.");
+    if (!(e instanceof AxiosError)) {
+      return {
+        success: false,
+        output: [
+          output.warnText(
+            "Sorry! We're having trouble reaching the Ditto API."
+          ),
+        ],
+      };
+    }
+
+    if (e.code === "ENOTFOUND") {
+      return {
+        success: false,
+        output: [
+          output.errorText(
+            `Can't connect to API: ${output.url(consts.API_HOST)}`
+          ),
+        ],
+      };
+    }
+
+    if (e.response?.status === 401 || e.response?.status === 404) {
+      return {
+        success: false,
+        output: [
+          output.errorText("This API key isn't valid. Please try another."),
+        ],
+      };
+    }
   }
 
   if (typeof resOrError === "string") {
-    return resOrError;
+    return {
+      success: false,
+      output: [resOrError],
+    };
   }
 
   if (resOrError?.status === 200) {
-    return true;
+    return { success: true };
   }
 
-  return output.errorText("This API key isn't valid. Please try another.");
+  return {
+    success: false,
+    output: [output.errorText("This API key isn't valid. Please try another.")],
+  };
+}
+
+// Returns true if valid, otherwise an error message.
+async function checkToken(token: string): Promise<any> {
+  const result = await verifyTokenUsingTokenCheck(token);
+  if (!result.success) {
+    return result.output.join("\n");
+  }
+
+  return true;
 }
 
 async function collectToken(message: string | null) {
   const blue = output.info;
-  const apiUrl = output.url("https://app.dittowords.com/account/user");
-  const breadcrumbs = `${blue("User")}`;
+  const apiUrl = output.url("https://app.dittowords.com/account/devtools");
+  const breadcrumbs = `${chalk.bold(blue("API Keys"))}`;
   const tokenDescription =
     message ||
-    `To get started, you'll need your Ditto API key. You can find this at: ${apiUrl} > ${breadcrumbs} under "${chalk.bold(
-      "API Keys"
-    )}".`;
+    `To get started, you'll need your Ditto API key. You can find this at: ${apiUrl} under "${breadcrumbs}".`;
   console.log(tokenDescription);
 
   const response = await prompt<{ token: string }>({
@@ -100,8 +133,24 @@ export const collectAndSaveToken = async (message: string | null = null) => {
     config.saveToken(consts.CONFIG_FILE, consts.API_HOST, token);
     return token;
   } catch (error) {
-    quit("API token was not saved");
+    // https://github.com/enquirer/enquirer/issues/225#issue-516043136
+    // Empty string corresponds to the user hitting Ctrl + C
+    if (error === "") {
+      quit("", 0);
+      return;
+    }
+
+    const eventId = Sentry.captureException(error);
+    const eventStr = `\n\nError ID: ${output.info(eventId)}`;
+
+    return quit(
+      output.errorText(
+        "Something went wrong. Please contact support or try again later."
+      ) + eventStr
+    );
   }
 };
 
 export default { needsToken, collectAndSaveToken };
+
+export const _test = { verifyTokenUsingTokenCheck };