@dittowords/cli 4.0.0 → 4.1.0-alpha

package/lib/utils/generateJsDriver.ts

@@ -4,6 +4,9 @@ import consts from "../consts";
 import output from "../output";
 import { Source } from "../types";
 import { cleanFileName } from "./cleanFileName";
+import { ModuleType, determineModuleType } from "./determineModuleType";
+import { generateJsDriverTypeFile } from "./generateJsDriverTypeFile";
+import { JSONFormat } from "../pull";
 
 // compatability with legacy method of specifying project ids
 // that is still used by the default format
@@ -20,77 +23,67 @@ const stringifySourceId = (projectId: string) =>
  * The generated file will have a unified format
  * independent of the CLI configuration used to fetch
  * data from Ditto.
+ *
  */
+type DriverFile = Record<string, Record<string, string | object>>;
+export function generateJsDriver(sources: Source[], format: JSONFormat) {
+  const moduleType = determineModuleType();
 
-// TODO: support ESM
-export function generateJsDriver(sources: Source[]) {
-  const sourceIdsByName: Record<string, string> = sources.reduce(
-    (agg, source) => {
-      if (source.fileName) {
-        return { ...agg, [cleanFileName(source.fileName)]: source.id };
-      }
+  const fullyQualifiedSources = getFullyQualifiedJSONSources(sources);
 
-      return agg;
-    },
-    {}
-  );
+  const variableNameGenerator = createVariableNameGenerator();
+  const importStatements: string[] = [];
 
-  const projectFileNames = fs
-    .readdirSync(consts.TEXT_DIR)
-    .filter(
-      (fileName) => /\.json$/.test(fileName) && !/^components__/.test(fileName)
-    );
+  const data: DriverFile = {};
+  const dataComponents: Record<string, string[]> = {};
 
-  type DriverFile = Record<string, Record<string, string | object>>;
-  const data: DriverFile = projectFileNames.reduce(
-    (obj: Record<string, Record<string, string>>, fileName) => {
-      const [sourceId, rest] = fileName.split("__");
-      const [variantApiId] = rest.split(".");
+  fullyQualifiedSources.forEach((source) => {
+    let variableName: string;
+    if (source.type === "components") {
+      variableName = variableNameGenerator.generate(
+        source.fileName.split(".")[0]
+      );
+    } else {
+      const fileNameWithoutExtension = source.fileName.split(".")[0];
+      variableName = variableNameGenerator.generate(
+        fileNameWithoutExtension.split("__")[0]
+      );
+    }
 
-      const projectId = sourceIdsByName[sourceId];
-      const projectIdStr = stringifySourceId(projectId);
+    importStatements.push(
+      getImportStatement(source.fileName, variableName, moduleType)
+    );
 
-      if (!obj[projectIdStr]) {
-        obj[projectIdStr] = {};
-      }
+    if (source.type === "project") {
+      const { variantApiId } = source;
+      const projectId = stringifySourceId(source.projectId);
+      data[projectId] ??= {};
+      data[projectId][variantApiId] = `{...${variableName}}`;
+    } else {
+      dataComponents[source.variantApiId] ??= [];
+      dataComponents[source.variantApiId].push(`...${variableName}`);
+    }
+  });
 
-      obj[projectIdStr][variantApiId] = `require('./${fileName}')`;
-      return obj;
-    },
-    {}
-  );
-
-  // Create arrays of stringified "...require()" statements,
-  // each of which corresponds to one of the component files
-  // (which are created on a per-component-folder basis)
-  const componentData: Record<string, string[]> = {};
-  sources
-    .filter((s) => s.type === "components")
-    .forEach((componentSource) => {
-      if (componentSource.type !== "components") return;
-      componentData[componentSource.variant] ??= [];
-      componentData[componentSource.variant].push(
-        `...require('./${componentSource.fileName}')`
-      );
-    });
   // Convert each array of stringified "...require()" statements
   // into a unified string, and set it on the final data object
   // that will be written to the driver file
-  Object.keys(componentData).forEach((key) => {
+  Object.keys(dataComponents).forEach((key) => {
     data.ditto_component_library ??= {};
 
     let str = "{";
-    componentData[key].forEach((k, i) => {
+    dataComponents[key].forEach((k: any, i: any) => {
       str += k;
-      if (i < componentData[key].length - 1) str += ", ";
+      if (i < dataComponents[key].length - 1) str += ", ";
     });
     str += "}";
     data.ditto_component_library[key] = str;
   });
 
-  let dataString = `module.exports = ${JSON.stringify(data, null, 2)}`
-    // remove quotes around require statements
-    .replace(/"require\((.*)\)"/g, "require($1)")
+  let dataString = "";
+  dataString += importStatements.join("\n") + "\n\n";
+  dataString += `${getExportPrefix(moduleType)}`;
+  dataString += `${JSON.stringify(data, null, 2)}`
     // remove quotes around opening & closing curlies
     .replace(/"\{/g, "{")
     .replace(/\}"/g, "}");
@@ -98,5 +91,117 @@ export function generateJsDriver(sources: Source[]) {
   const filePath = path.resolve(consts.TEXT_DIR, "index.js");
   fs.writeFileSync(filePath, dataString, { encoding: "utf8" });
 
+  generateJsDriverTypeFile({
+    format,
+    moduleType,
+  });
+
   return `Generated .js SDK driver at ${output.info(filePath)}`;
 }
+
+type IFullyQualifiedJSONSource =
+  | {
+      type: "components";
+      variantApiId: string;
+      folderApiId: string;
+      fileName: string;
+    }
+  | {
+      type: "project";
+      projectId: string;
+      projectName: string;
+      variantApiId: string;
+      fileName: string;
+    };
+
+/**
+ * Upstream source data is a mess - this function is an attempt at cleaning it up
+ * so that it can be used in a more straightforward way to generate the driver file.
+ */
+function getFullyQualifiedJSONSources(
+  sources: Source[]
+): IFullyQualifiedJSONSource[] {
+  const projectIdsByCleanedFileName = new Map<string, string>();
+  sources.forEach((source) => {
+    if (!source.fileName || source.type === "components") {
+      return;
+    }
+    projectIdsByCleanedFileName.set(cleanFileName(source.fileName), source.id);
+  });
+
+  const fileNames = fs.readdirSync(consts.TEXT_DIR);
+  return fileNames
+    .filter((f) => path.extname(f) === ".json")
+    .map((fileName) => {
+      const parts = fileName.split("__");
+
+      if (parts.length === 3) {
+        const [, folderApiId, rest] = parts;
+        const [variantApiId] = rest.split(".");
+        return {
+          type: "components",
+          variantApiId,
+          folderApiId,
+          fileName,
+        };
+      }
+
+      if (parts.length === 2) {
+        const [projectName, rest] = parts;
+        const [variantApiId] = rest.split(".");
+        const key = cleanFileName(fileName.split("__")[0]);
+        const projectId = projectIdsByCleanedFileName.get(key) || "";
+        return {
+          type: "project",
+          projectId,
+          projectName,
+          variantApiId,
+          fileName,
+        };
+      }
+
+      throw new Error("Invalid JSON file generated: " + fileName);
+    });
+}
+
+function createVariableNameGenerator() {
+  const variableNames = new Set<string>();
+
+  return {
+    generate: (str: string) => {
+      const baseName = str.replace(/(\W|-)/g, "_");
+      let name = baseName;
+      let i = 1;
+      while (variableNames.has(name)) {
+        name = `${baseName}${i}`;
+        i++;
+      }
+      variableNames.add(name);
+      return name;
+    },
+  };
+}
+
+function getExportPrefix(moduleType: ModuleType) {
+  if (moduleType === "commonjs") {
+    return "module.exports = ";
+  }
+  if (moduleType === "module") {
+    return "export default ";
+  }
+  throw new Error("Unknown module type: " + moduleType);
+}
+
+function getImportStatement(
+  fileName: string,
+  variableName: string,
+  moduleType: ModuleType
+) {
+  if (moduleType === "commonjs") {
+    return `const ${variableName} = require('./${fileName}');`;
+  }
+  if (moduleType === "module") {
+    return `import ${variableName} from './${fileName}';`;
+  }
+  throw new Error("Unknown module type: " + moduleType);
+}

package/lib/utils/generateJsDriverTypeFile.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { ModuleType } from "./determineModuleType";
+import { JSONFormat } from "../pull";
+import consts from "../consts";
+
+function getFormatString(format: JSONFormat) {
+  switch (format) {
+    case "flat":
+      return "IJSONFlat";
+    case "nested":
+      return "IJSONNested";
+    case "structured":
+      return "IJSONStructured";
+    case "icu":
+      return "IJSONICU";
+    default:
+      return "_JSON";
+  }
+}
+
+function getExportString(exportedValue: string, moduleType: ModuleType) {
+  if (moduleType === "commonjs") {
+    return `export = ${exportedValue};`;
+  }
+
+  return `export default ${exportedValue};`;
+}
+
+function getTypesString(options: IOptions) {
+  return `
+interface IJSONFlat {
+  [key: string]: string;
+}
+
+interface IJSONStructured {
+  [key: string]: {
+    text: string;
+    status?: string;
+    notes?: string;
+    [property: string]: any;
+  };
+}
+
+interface IJSONNested {
+  [key: string]: string | IJSONNested;
+}
+
+type _JSON = IJSONFlat | IJSONStructured | IJSONNested;
+
+interface IDriverFile {
+  [sourceKey: string]: {
+    [variantKey: string]: ${getFormatString(options.format)};
+  };
+}
+
+declare const driver: IDriverFile;
+
+${getExportString("driver", options.moduleType)}
+`.trim();
+}
+
+interface IOptions {
+  format: JSONFormat;
+  moduleType: ModuleType;
+}
+
+export function generateJsDriverTypeFile(options: IOptions) {
+  const typeFileString = getTypesString(options);
+  fs.writeFileSync(
+    path.resolve(consts.TEXT_DIR, "index.d.ts"),
+    typeFileString + "\n",
+    "utf8"
+  );
+}

package/lib/utils/generateSwiftDriver.ts

@@ -0,0 +1,48 @@
+import path from "path";
+import { writeFile } from "../pull";
+import { SourceInformation } from "../types";
+import { createApiClient } from "../api";
+import consts from "../consts";
+import output from "../output";
+
+interface IArg {
+  variants: boolean;
+  components?:
+    | boolean
+    | {
+        root?: boolean | { status?: string };
+        folders?: string[] | { id: string | null; status?: string }[];
+      };
+  projects?: string[] | { id: string; status?: string }[];
+  localeByVariantId?: Record<string, string>;
+}
+
+export async function generateSwiftDriver(source: SourceInformation) {
+  const client = createApiClient();
+
+  const body: IArg = {
+    variants: source.variants,
+    localeByVariantId: source.localeByVariantApiId,
+  };
+
+  if (source.componentFolders || source.componentRoot) {
+    body.components = {};
+    if (source.componentFolders) {
+      body.components.folders = source.componentFolders;
+    }
+    if (source.componentRoot) {
+      body.components.root = source.componentRoot;
+    }
+  } else if (source.shouldFetchComponentLibrary) {
+    body.components = true;
+  }
+
+  if (source.validProjects) body.projects = source.validProjects;
+
+  const { data } = await client.post<string>("/v1/ios/swift-driver", body);
+
+  const filePath = path.join(consts.TEXT_DIR, "Ditto.swift");
+  await writeFile(filePath, data);
+
+  return `Successfully saved Swift driver to ${output.info("Ditto.swift")}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dittowords/cli",
-  "version": "4.0.0",
+  "version": "4.1.0-alpha",
   "description": "Command Line Interface for Ditto (dittowords.com).",
   "license": "MIT",
   "main": "bin/index.js",