@dittowords/cli 4.3.0 → 4.4.1

package/lib/pull.test.ts

@@ -1,330 +1,77 @@
-import fs from "fs";
-import path from "path";
-
-jest.mock("./api", () => ({
-  createApiClient: jest.fn(), // this needs to be mocked in each test that requires it
-}));
-import { createApiClient } from "./api";
-
-const testProjects: Project[] = [
-  {
-    id: "1",
-    name: "Project 1",
-    fileName: "Project 1",
-  },
-  { id: "2", name: "Project 2", fileName: "Project 2" },
-];
-
-// TODO: all tests in this file currently failing because we're re-instantiating the api client
-// everywhere and are unable to mock the return type separately for each instance of usage.
-// We need to refactor to share one api client everywhere instead of always re-creating it.
-const mockApi = createApiClient() as any as jest.Mocked<
-  ReturnType<typeof createApiClient>
->;
-
-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 { pull } from "./pull";
+import { vol } from "memfs";
 import consts from "./consts";
-import allPull, { getFormatDataIsValid } from "./pull";
-import { Project, SupportedExtension, SupportedFormat } from "./types";
-
-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, .strings, .stringsdict files", () => {
-    cleanOutputDir();
+import { jest } from "@jest/globals";
+import axios from "axios";
+const axiosMock = jest.mocked(axios);
+import fs from "fs";
 
-    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");
-    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.stringsdict"), "test");
-    // this file shouldn't be deleted
-    fs.writeFileSync(path.resolve(consts.TEXT_DIR, "test.txt"), "test");
+jest.mock("fs");
+jest.mock("./api");
 
-    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(6);
+jest.mock("./http/fetchComponentFolders");
+jest.mock("./http/fetchComponents");
+jest.mock("./http/fetchVariants");
 
-    cleanOutputFiles();
+const defaultEnv = { ...process.env };
 
-    expect(fs.readdirSync(consts.TEXT_DIR).length).toEqual(1);
-  });
+beforeEach(() => {
+  vol.reset();
+  process.env = { ...defaultEnv };
 });
 
-describe("downloadAndSaveBase", () => {
-  beforeAll(() => {
-    if (!fs.existsSync(consts.TEXT_DIR)) {
-      fs.mkdirSync(consts.TEXT_DIR);
-    }
-  });
-
-  beforeEach(() => {
-    cleanOutputDir();
-  });
-
-  const mockDataFlat = { hello: "world" };
-  const mockDataNested = { hello: { text: "world" } };
-  const mockDataStructured = { hello: { text: "world" } };
-  const mockDataIcu = { hello: "world" };
-  const mockDataAndroid = `
-      <?xml version="1.0" encoding="utf-8"?>
-      <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-          <string name="hello-world" ditto_api_id="hello-world">Hello World</string>
-      </resources>
-    `;
-  const mockDataIosStrings = `
-      "hello" = "world"; 
-    `;
-  const mockDataIosStringsDict = `
-      <?xml version="1.0" encoding="utf-8"?>
-      <plist version="1.0">
-          <dict>
-              <key>hello-world</key>
-              <dict>
-                  <key>NSStringLocalizedFormatKey</key>
-                  <string>%1$#@count@</string>
-                  <key>count</key>
-                  <dict>
-                      <key>NSStringFormatSpecTypeKey</key>
-                      <string>NSStringPluralRuleType</string>
-                      <key>NSStringFormatValueTypeKey</key>
-                      <string>d</string>
-                      <key>other</key>
-                      <string>espanol</string>
-                  </dict>
-              </dict>
-          </dict>
-      </plist>
-    `;
-
-  const formats: Array<{
-    format: SupportedFormat;
-    data: Object;
-    ext: SupportedExtension;
-  }> = [
-    { format: "flat", data: mockDataFlat, ext: ".json" },
-    { format: "nested", data: mockDataNested, ext: ".json" },
-    { format: "structured", data: mockDataStructured, ext: ".json" },
-    { format: "icu", data: mockDataIcu, ext: ".json" },
-    { format: "android", data: mockDataAndroid, ext: ".xml" },
-    { format: "ios-strings", data: mockDataIosStrings, ext: ".strings" },
-    {
-      format: "ios-stringsdict",
-      data: mockDataIosStringsDict,
-      ext: ".stringsdict",
-    },
-  ];
-
-  const mockApiCall = (data: unknown) => {
-    (createApiClient as any).mockImplementation(() => ({
-      get: () => ({ data }),
-    }));
-  };
-
-  const verifySavedData = async (
-    format: SupportedFormat,
-    data: unknown,
-    ext: SupportedExtension
-  ) => {
-    const output = await downloadAndSaveBase({
-      projects: testProjects,
-      format: format,
-    } as any);
-    expect(/successfully saved/i.test(output)).toEqual(true);
-    const directoryContents = fs.readdirSync(consts.TEXT_DIR);
-    expect(directoryContents.length).toEqual(testProjects.length);
-    expect(directoryContents.every((f) => f.endsWith(ext))).toBe(true);
-    const fileDataString = fs.readFileSync(
-      path.resolve(consts.TEXT_DIR, directoryContents[0]),
-      "utf8"
+const mockGlobalConfigFile = `
+api.dittowords.com:
+  - token: xxx-xxx-xxx
+`;
+const mockProjectConfigFile = `
+sources:
+  components: true
+  projects:
+    - id: project-id-1
+      name: Test Project
+variants: true
+`;
+
+describe("pull", () => {
+  it("correctly writes files to disk per source for basic config", async () => {
+    process.env.DITTO_TEXT_DIR = "/ditto";
+    process.env.DITTO_PROJECT_CONFIG_FILE = "/ditto/config.yml";
+
+    // we need to manually mock responses for the http calls that happen
+    // directly within the pull function; we don't need to mock the http
+    // calls that happen by way of http/* function calls since those have
+    // their own mocks already.
+    axiosMock.get.mockImplementation(
+      (): Promise<any> => Promise.resolve({ data: "data" })
     );
 
-    switch (format) {
-      case "android":
-      case "ios-strings":
-      case "ios-stringsdict":
-        expect(typeof data).toBe("string");
-        expect(fileDataString.replace(/\s/g, "")).toEqual(
-          (data as string).replace(/\s/g, "")
-        );
-        break;
-
-      case "flat":
-      case "nested":
-      case "structured":
-      case "icu":
-      default:
-        expect(JSON.parse(fileDataString)).toEqual(data);
-        break;
-    }
-  };
+    vol.fromJSON({
+      [consts.CONFIG_FILE]: mockGlobalConfigFile,
+      [consts.PROJECT_CONFIG_FILE]: mockProjectConfigFile,
+    });
 
-  formats.forEach(({ format, data, ext }) => {
-    it(`writes the ${format} format to disk`, async () => {
-      mockApiCall(data);
-      await verifySavedData(format, data, ext);
+    await pull();
+
+    const filesOnDiskExpected = new Set([
+      "components__example-folder__base.json",
+      "components__example-folder__example-variant-1.json",
+      "components__example-folder__example-variant-2.json",
+      "components__root__base.json",
+      "components__root__example-variant-1.json",
+      "components__root__example-variant-2.json",
+      "test-project__base.json",
+      "test-project__example-variant-1.json",
+      "test-project__example-variant-2.json",
+      "index.d.ts",
+      "index.js",
+    ]);
+
+    const filesOnDisk = fs.readdirSync("/ditto");
+    filesOnDisk.forEach((file) => {
+      filesOnDiskExpected.delete(file);
     });
-  });
-});
 
-describe("getFormatDataIsValid", () => {
-  it("handles flat format appropriately", () => {
-    expect(getFormatDataIsValid.flat("{}")).toBe(false);
-    expect(getFormatDataIsValid.flat(`{ "hello": "world" }`)).toBe(true);
-    expect(
-      getFormatDataIsValid.flat(`{
-      "__variant-name": "English",
-      "__variant-description": ""
-    }`)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid.flat(`{
-      "__variant-name": "English",
-      "__variant-description": "",
-      "hello": "world"
-    }`)
-    ).toBe(true);
-  });
-  it("handles structured format appropriately", () => {
-    expect(getFormatDataIsValid.structured("{}")).toBe(false);
-    expect(
-      getFormatDataIsValid.structured(`{ "hello": { "text": "world" } }`)
-    ).toBe(true);
-    expect(
-      getFormatDataIsValid.structured(`{
-      "__variant-name": "English",
-      "__variant-description": ""
-    }`)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid.structured(`{
-      "__variant-name": "English",
-      "__variant-description": "",
-      "hello": { "text": "world" }
-    }`)
-    ).toBe(true);
-  });
-  it("handles icu format appropriately", () => {
-    expect(getFormatDataIsValid.icu("{}")).toBe(false);
-    expect(getFormatDataIsValid.icu(`{ "hello": "world" }`)).toBe(true);
-    expect(
-      getFormatDataIsValid.icu(`{
-      "__variant-name": "English",
-      "__variant-description": ""
-    }`)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid.icu(`{
-      "__variant-name": "English",
-      "__variant-description": "",
-      "hello": "world"
-    }`)
-    ).toBe(true);
-  });
-  it("handles android format appropriately", () => {
-    expect(
-      getFormatDataIsValid.android(`
-      <?xml version="1.0" encoding="utf-8"?>
-      <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"/>
-    `)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid.android(`
-      <?xml version="1.0" encoding="utf-8"?>
-      <!--Variant Name: English-->
-      <!--Variant Description: -->
-      <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"/>
-    `)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid.android(`
-      <?xml version="1.0" encoding="utf-8"?>
-      <!--Variant Name: English-->
-      <!--Variant Description: -->
-      <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-          <string name="hello-world" ditto_api_id="hello-world">Hello World</string>
-      </resources>
-    `)
-    ).toBe(true);
-  });
-  it("handles ios-strings format appropriately", () => {
-    expect(getFormatDataIsValid["ios-strings"]("")).toBe(false);
-    expect(
-      getFormatDataIsValid["ios-strings"](`
-        /* Variant Name: English */
-        /* Variant Description: */
-      `)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid["ios-strings"](`
-        /* Variant Name: English */
-        /* Variant Description: */
-        "Hello" = "World";
-      `)
-    ).toBe(true);
-  });
-  it("handles ios-stringsdict format appropriately", () => {
-    expect(
-      getFormatDataIsValid["ios-stringsdict"](`
-        <?xml version="1.0" encoding="utf-8"?>
-        <plist version="1.0">
-            <dict/>
-        </plist>
-      `)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid["ios-stringsdict"](`
-        <?xml version="1.0" encoding="utf-8"?>
-        <!--Variant Name: English-->
-        <!--Variant Description: -->
-        <plist version="1.0">
-            <dict/>
-        </plist>
-      `)
-    ).toBe(false);
-    expect(
-      getFormatDataIsValid["ios-stringsdict"](`
-        <?xml version="1.0" encoding="utf-8"?>
-        <!--Variant Name: English-->
-        <!--Variant Description: -->
-        <plist version="1.0">
-            <dict>
-              <key>Hello World</key>
-              <dict>
-                  <key>NSStringLocalizedFormatKey</key>
-                  <string>%1$#@count@</string>
-                  <key>count</key>
-                  <dict>
-                      <key>NSStringFormatSpecTypeKey</key>
-                      <string>NSStringPluralRuleType</string>
-                      <key>NSStringFormatValueTypeKey</key>
-                      <string>d</string>
-                      <key>other</key>
-                      <string>espanol</string>
-                  </dict>
-              </dict>
-            </dict>
-        </plist>
-      `)
-    ).toBe(true);
+    expect(filesOnDiskExpected.size).toBe(0);
   });
 });

package/lib/pull.ts

@@ -327,7 +327,7 @@ async function downloadAndSave(
   spinner.start();
 
   const [variants, allComponentFoldersResponse] = await Promise.all([
-    fetchVariants(source),
+    fetchVariants(source, options),
     fetchComponentFolders({}),
   ]);
 
@@ -578,15 +578,20 @@ async function downloadAndSave(
 
 export interface PullOptions {
   meta?: Record<string, string>;
+  includeSampleData?: boolean;
 }
 
 export const pull = async (options?: PullOptions) => {
   const meta = options ? options.meta : {};
+  const includeSampleData = options?.includeSampleData || false;
   const token = config.getToken(consts.CONFIG_FILE, consts.API_HOST);
   const sourceInformation = config.parseSourceInformation();
 
   try {
-    return await downloadAndSave(sourceInformation, token, { meta });
+    return await downloadAndSave(sourceInformation, token, {
+      meta,
+      includeSampleData,
+    });
   } catch (e) {
     const eventId = Sentry.captureException(e);
     const eventStr = `\n\nError ID: ${output.info(eventId)}`;
@@ -615,3 +620,9 @@ export default {
     downloadAndSaveBase,
   },
 };
+
+export const _test = {
+  getJsonFormat,
+  getJsonFormatIsValid,
+  ensureEndsWithNewLine,
+};

package/lib/replace.test.ts

@@ -1,16 +1,30 @@
-import fs from "fs/promises";
+import fs from "fs";
 import { parseOptions, replaceJSXTextInFile } from "./replace"; // Assuming the function is exported in a separate file
 
+jest.mock("fs");
+
 // Helper function to create a temporary file
 async function createTempJSXFile(content: string): Promise<string> {
-  const tempFile = "tempFile.jsx";
-  await fs.writeFile(tempFile, content);
+  const tempFile = "/tempFile.jsx";
+  await new Promise((resolve, reject) => {
+    try {
+      fs.writeFile(tempFile, content, resolve);
+    } catch (e) {
+      reject(e);
+    }
+  });
   return tempFile;
 }
 
 // Helper function to delete the temporary file
 async function deleteTempFile(filePath: string): Promise<void> {
-  await fs.unlink(filePath);
+  await new Promise((resolve, reject) => {
+    try {
+      fs.unlink(filePath, resolve);
+    } catch (e) {
+      reject(e);
+    }
+  });
 }
 
 describe("parseOptions", () => {
@@ -57,10 +71,9 @@ describe("parseOptions", () => {
   });
 });
 
-// TODO: this is flaky
 describe("replaceJSXTextInFile", () => {
   afterEach(async () => {
-    await deleteTempFile("tempFile.jsx");
+    await deleteTempFile("/tempFile.jsx");
   });
 
   test("should replace JSX text with a DittoComponent", async () => {
@@ -70,7 +83,15 @@ describe("replaceJSXTextInFile", () => {
 
     await replaceJSXTextInFile(tempFile, { searchString, replaceWith }, {});
 
-    const transformedCode = await fs.readFile(tempFile, "utf-8");
+    const transformedCode = await new Promise((resolve, reject) => {
+      fs.readFile(tempFile, "utf-8", (error, data) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(data);
+        }
+      });
+    });
     expect(transformedCode).toContain(
       `<div>Hello, <DittoComponent componentId="${replaceWith}" /></div>`
     );
@@ -89,7 +110,12 @@ describe("replaceJSXTextInFile", () => {
       { lineNumbers: [3] }
     );
 
-    const transformedCode = await fs.readFile(tempFile, "utf-8");
+    const transformedCode = await new Promise((resolve, reject) =>
+      fs.readFile(tempFile, "utf-8", (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      })
+    );
     expect(transformedCode).toContain(
       `<>\n  <div>Hello, world</div>\n  <div>Hello, <DittoComponent componentId=\"some-id\" /></div>\n</>;`
     );
@@ -102,7 +128,12 @@ describe("replaceJSXTextInFile", () => {
 
     await replaceJSXTextInFile(tempFile, { searchString, replaceWith }, {});
 
-    const transformedCode = await fs.readFile(tempFile, "utf-8");
+    const transformedCode = await new Promise((resolve, reject) =>
+      fs.readFile(tempFile, "utf-8", (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      })
+    );
     expect(transformedCode).toContain(
       `<div>HeLLo, <DittoComponent componentId="${replaceWith}" /></div>`
     );
@@ -115,7 +146,12 @@ describe("replaceJSXTextInFile", () => {
 
     await replaceJSXTextInFile(tempFile, { searchString, replaceWith }, {});
 
-    const transformedCode = await fs.readFile(tempFile, "utf-8");
+    const transformedCode = await new Promise((resolve, reject) =>
+      fs.readFile(tempFile, "utf-8", (error, data) => {
+        if (error) reject(error);
+        else resolve(data);
+      })
+    );
     expect(transformedCode).toContain("<div>Hello, world!</div>");
   });
 });

package/lib/replace.ts

@@ -1,4 +1,4 @@
-import fs from "fs-extra";
+import fs from "fs";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
 import * as t from "@babel/types";
@@ -11,7 +11,15 @@ async function replaceJSXTextInFile(
     lineNumbers?: number[];
   }
 ) {
-  const code = await fs.readFile(filePath, "utf-8");
+  const code = await new Promise<string>((resolve, reject) =>
+    fs.readFile(filePath, "utf-8", (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data);
+      }
+    })
+  );
   const ast = parse(code, {
     sourceType: "module",
     plugins: ["jsx", "typescript"],
@@ -69,7 +77,16 @@ async function replaceJSXTextInFile(
     /* @ts-ignore */
     configFile: false,
   });
-  fs.writeFile(filePath, transformedCode);
+
+  await new Promise((resolve, reject) =>
+    fs.writeFile(filePath, transformedCode, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(null);
+      }
+    })
+  );
 }
 
 function splitByCaseInsensitive(str: string, delimiter: string) {

package/lib/utils/determineModuleType.test.ts

@@ -0,0 +1,48 @@
+import { determineModuleType } from "./determineModuleType";
+import { vol } from "memfs";
+
+const defaultEnv = process.env;
+
+jest.mock("fs");
+
+beforeEach(() => {
+  vol.reset();
+  process.env = { ...defaultEnv };
+});
+
+test("'commonjs' if no package.json found", () => {
+  expect(determineModuleType()).toBe("commonjs");
+});
+
+test("'commonjs' if package.json found but no `type` property", () => {
+  vol.fromJSON({ "package.json": JSON.stringify({}) }, process.cwd());
+  expect(determineModuleType()).toBe("commonjs");
+});
+
+test("'commonjs' if package.json found and `type` property is 'commonjs'", () => {
+  vol.fromJSON({ "package.json": JSON.stringify({ type: "commonjs" }) });
+  expect(determineModuleType()).toBe("commonjs");
+});
+
+test("'commonjs' if package.json found and `type` property is invalid", () => {
+  vol.fromJSON({ "package.json": JSON.stringify({ type: "invalid-type" }) });
+  expect(determineModuleType()).toBe("commonjs");
+});
+
+test("'module' if package.json found and `type` property is 'module'", () => {
+  vol.fromJSON({ "package.json": JSON.stringify({ type: "module" }) });
+  expect(determineModuleType()).toBe("module");
+});
+
+test("finds package.json in parent directories", () => {
+  vol.fromJSON({
+    "/some/nested/dir/test.txt": "",
+    "/package.json": JSON.stringify({ type: "module" }),
+  });
+  expect(determineModuleType("/some/nested/dir")).toBe("module");
+});
+
+test("supports explicit specification of module type via environment variable", () => {
+  process.env.DITTO_MODULE_TYPE = "module";
+  expect(determineModuleType()).toBe("module");
+});

package/lib/utils/determineModuleType.ts

@@ -9,18 +9,16 @@ export type ModuleType = "commonjs" | "module";
  * @returns "commonjs" or "module", defaulting to "module" if no `package.json` is found or if the found
  * file does not include a `type` property.
  */
-export function determineModuleType() {
-  const value = getRawTypeFromPackageJson();
+export function determineModuleType(currentDir: string | null = process.cwd()) {
+  const value = getRawTypeFromPackageJson(currentDir);
   return getTypeOrDefault(value);
 }
 
-function getRawTypeFromPackageJson() {
+function getRawTypeFromPackageJson(currentDir: string | null) {
   if (process.env.DITTO_MODULE_TYPE) {
     return process.env.DITTO_MODULE_TYPE;
   }
 
-  let currentDir: string | null = process.cwd(); // Get the current working directory
-
   while (currentDir) {
     const packageJsonPath = path.join(currentDir, "package.json");
     if (fs.existsSync(packageJsonPath)) {
@@ -36,7 +34,7 @@ function getRawTypeFromPackageJson() {
     }
 
     if (currentDir === "/") {
-      return null;
+      break;
     }
 
     // Move up a directory and continue the search

package/lib/utils/getSelectedProjects.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import yaml, { YAMLException } from "js-yaml";
 
-import { PROJECT_CONFIG_FILE } from "../consts";
+import consts from "../consts";
 import { ConfigYAML, Project } from "../types";
 import Config, { DEFAULT_CONFIG_JSON } from "../config";
 
@@ -29,8 +29,8 @@ function yamlToJson(_yaml: string): ConfigYAML | null {
  * Returns an array containing all valid projects ({ id, name })
  * currently contained in the project config file.
  */
-export const getSelectedProjects = (configFile = PROJECT_CONFIG_FILE) =>
+export const getSelectedProjects = (configFile = consts.PROJECT_CONFIG_FILE) =>
   Config.parseSourceInformation(configFile).validProjects;
 
-export const getIsUsingComponents = (configFile = PROJECT_CONFIG_FILE) =>
+export const getIsUsingComponents = (configFile = consts.PROJECT_CONFIG_FILE) =>
   Config.parseSourceInformation(configFile).shouldFetchComponentLibrary;

package/lib/utils/quit.ts

@@ -1,4 +1,4 @@
 export function quit(message: string | null, exitCode = 2) {
   if (message) console.log(`\n${message}\n`);
-  process.exitCode = exitCode;
+  process.exit(exitCode);
 }