@dittowords/cli 4.4.0 → 4.5.0

package/lib/generate-suggestions.ts

@@ -1,4 +1,4 @@
-import fs from "fs-extra";
+import fs from "fs";
 import glob from "glob";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
@@ -43,11 +43,14 @@ async function generateSuggestions(flags: {
   console.log(JSON.stringify(results, null, 2));
 }
 
-async function findComponentsInJSXFiles(params: {
-  directory: string;
-  files?: string[];
-  components: FetchComponentResponse;
-}): Promise<{ [apiId: string]: Result }> {
+async function findComponentsInJSXFiles(
+  params: (
+    | { directory: string; files?: string[] }
+    | { files: string[]; directory?: string }
+  ) & {
+    components: FetchComponentResponse;
+  }
+): Promise<{ [apiId: string]: Result }> {
   const result: { [apiId: string]: Result } = {};
   const files =
     params.files ||
@@ -57,83 +60,90 @@ async function findComponentsInJSXFiles(params: {
 
   const promises: Promise<any>[] = [];
 
-  for (const file of files) {
-    promises.push(
-      fs.readFile(file, "utf-8").then((code) => {
-        const ast = parse(code, {
-          sourceType: "module",
-          plugins: ["jsx", "typescript"],
-        });
-
-        traverse(ast, {
-          JSXText(path) {
-            for (const [compApiId, component] of Object.entries(
-              params.components,
-            )) {
-              // If we haven't seen this component before, add it to the result
-              if (!result[compApiId]) {
-                result[compApiId] = {
-                  apiId: compApiId,
-                  ...component,
-                  occurrences: {},
-                };
-              }
+  async function handleFile(file: string) {
+    const code = await new Promise<string>((resolve, reject) =>
+      fs.readFile(file, "utf-8", (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      })
+    );
+
+    const ast = parse(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+    });
 
-              if (
-                // Skip white space lines
-                !/^\s*$/.test(path.node.value) &&
-                !/^\s*$/.test(component.text) &&
-                path.node.value.includes(component.text)
-              ) {
-                // Escape all special characters from the text so we can use it in a regex
-                const escapedText = component.text.replace(
-                  /[.*+?^${}()|[\]\\]/g,
-                  "\\$&",
-                );
-                const regex = new RegExp(escapedText, "g");
-                let match;
-                while ((match = regex.exec(path.node.value)) !== null) {
-                  const lines = path.node.value
-                    .slice(0, match.index)
-                    .split("\n");
-
-                  if (!path.node.loc) {
-                    continue;
-                  }
-
-                  const lineNumber =
-                    path.node.loc.start.line + lines.length - 1;
-
-                  const codeLines = code.split("\n");
-                  const line = codeLines[lineNumber - 1];
-                  const preview = replaceAt(
-                    line,
-                    match.index,
-                    component.text,
-                    `${component.text}`,
-                  );
-
-                  // Initialize the occurrences array if it doesn't exist
-                  if (!result[compApiId]["occurrences"][file]) {
-                    result[compApiId]["occurrences"][file] = [];
-                  }
-
-                  result[compApiId]["occurrences"][file].push({
-                    lineNumber,
-                    preview,
-                  });
-                }
+    traverse(ast, {
+      JSXText(path) {
+        for (const [compApiId, component] of Object.entries(
+          params.components
+        )) {
+          // If we haven't seen this component before, add it to the result
+          if (!result[compApiId]) {
+            result[compApiId] = {
+              apiId: compApiId,
+              ...component,
+              occurrences: {},
+            };
+          }
+
+          if (
+            // Skip white space lines
+            !/^\s*$/.test(path.node.value) &&
+            !/^\s*$/.test(component.text) &&
+            path.node.value.includes(component.text)
+          ) {
+            // Escape all special characters from the text so we can use it in a regex
+            const escapedText = component.text.replace(
+              /[.*+?^${}()|[\]\\]/g,
+              "\\$&"
+            );
+            const regex = new RegExp(escapedText, "g");
+            let match;
+            while ((match = regex.exec(path.node.value)) !== null) {
+              const lines = path.node.value.slice(0, match.index).split("\n");
+
+              if (!path.node.loc) {
+                continue;
               }
 
-              // Remove from result if no occurrences were found
-              if (Object.keys(result[compApiId]["occurrences"]).length === 0) {
-                delete result[compApiId];
+              const lineNumber = path.node.loc.start.line + lines.length - 1;
+
+              const codeLines = code.split("\n");
+              const line = codeLines[lineNumber - 1];
+              const preview = replaceAt(
+                line,
+                match.index,
+                component.text,
+                `${component.text}`
+              );
+
+              // Initialize the occurrences array if it doesn't exist
+              if (!result[compApiId]["occurrences"][file]) {
+                result[compApiId]["occurrences"][file] = [];
               }
+
+              result[compApiId]["occurrences"][file].push({
+                lineNumber,
+                preview,
+              });
             }
-          },
-        });
-      }),
-    );
+          }
+
+          // Remove from result if no occurrences were found
+          if (Object.keys(result[compApiId]["occurrences"]).length === 0) {
+            delete result[compApiId];
+          }
+        }
+      },
+    });
+  }
+
+  for (const file of files) {
+    promises.push(handleFile(file));
   }
 
   await Promise.all(promises);
@@ -145,7 +155,7 @@ function replaceAt(
   str: string,
   index: number,
   searchString: string,
-  replacement: string,
+  replacement: string
 ) {
   return (
     str.substring(0, index) +

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;
@@ -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);
+  });
+});