@plasmicapp/cli 0.1.162

package/src/utils/npm-utils.ts

@@ -0,0 +1,223 @@
+import { spawnSync } from "child_process";
+import glob from "fast-glob";
+import findupSync from "findup-sync";
+import latest from "latest-version";
+import path from "path";
+import semver from "semver";
+import { logger } from "../deps";
+import { PlasmicContext } from "./config-utils";
+import { findFile, readFileText } from "./file-utils";
+import { confirmWithUser } from "./user-utils";
+
+export function getParsedCliPackageJson() {
+  const packageJson = findupSync("package.json", { cwd: __dirname });
+  if (!packageJson) {
+    throw new Error(`Cannot find package.json in ancestors of ${__dirname}`);
+  }
+  return parsePackageJson(packageJson);
+}
+
+export function getCliVersion() {
+  const j = getParsedCliPackageJson();
+  return j.version as string;
+}
+
+/**
+ * Call this to check if we match the engine policy
+ */
+export function checkEngineStrict(): boolean {
+  const pkg = getParsedCliPackageJson();
+  const minNodeVersion = pkg?.engines?.node;
+  if (!!minNodeVersion && !semver.satisfies(process.version, minNodeVersion)) {
+    logger.warn(`Plasmic only works on Node ${minNodeVersion}`);
+    return false;
+  }
+  return true;
+}
+
+export function getParsedPackageJson() {
+  const packageJson = findupSync("package.json");
+  if (!packageJson) {
+    throw new Error(`Cannot find package.json`);
+  }
+  return parsePackageJson(packageJson);
+}
+
+// @TODO: is this function still used?
+export async function warnLatest(
+  context: PlasmicContext,
+  pkg: string,
+  baseDir: string,
+  msgs: {
+    requiredMsg: () => string;
+    updateMsg: (curVersion: string, latestVersion: string) => string;
+  },
+  yes?: boolean
+) {
+  const check = await checkVersion(context, pkg);
+  if (check.type === "up-to-date") {
+    return;
+  } else if (check.type === "wrong-npm-registry") {
+    logger.warn(
+      `${msgs.requiredMsg()} Unable to find this package in your npm registry. Please update this dependency manually.`
+    );
+    return;
+  }
+
+  if (
+    await confirmWithUser(
+      `${
+        check.type === "not-installed"
+          ? msgs.requiredMsg()
+          : msgs.updateMsg(check.current, check.latest)
+      }  Do you want to ${
+        check.type === "not-installed" ? "add" : "update"
+      } it now?`,
+      yes
+    )
+  ) {
+    installUpgrade(pkg, baseDir);
+  }
+}
+
+async function checkVersion(context: PlasmicContext, pkg: string) {
+  // Try to get the latest version from npm
+  let last = null;
+  try {
+    last = await latest(pkg);
+  } catch (e) {
+    // This is likely because .npmrc is set to a different registry
+    return { type: "wrong-npm-registry" } as const;
+  }
+
+  const cur = findInstalledVersion(context, pkg);
+  if (!cur) {
+    return { type: "not-installed" } as const;
+  }
+  if (semver.gt(last, cur)) {
+    return {
+      type: "obsolete",
+      latest: last,
+      current: cur,
+    } as const;
+  }
+  return { type: "up-to-date" } as const;
+}
+
+export function findInstalledVersion(context: PlasmicContext, pkg: string) {
+  const filename = findInstalledPackageJsonFile(context, pkg);
+  if (filename) {
+    const json = parsePackageJson(filename);
+    if (json && json.name === pkg) {
+      return json.version as string;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Detects if the cli is globally installed.  `rootDir` is the folder
+ * where plasmic.json is
+ */
+export function isCliGloballyInstalled(rootDir: string) {
+  const packageJsonFile = findPackageJsonPath(rootDir);
+  if (!packageJsonFile) {
+    // We assume global, as instructions state global and we can't really
+    // do better
+    return true;
+  }
+  const installedDir = __dirname;
+
+  // Else, we assume it is local if the installedDir is a subfolder of
+  // the root project dir
+  return !installedDir.startsWith(path.dirname(packageJsonFile));
+}
+
+function findPackageJsonPath(dir: string) {
+  return findFile(dir, (f) => f === "package.json", {
+    traverseParents: true,
+  });
+}
+
+export function findPackageJsonDir(rootDir: string) {
+  const filePath = findPackageJsonPath(rootDir);
+  return filePath ? path.dirname(filePath) : undefined;
+}
+
+function findInstalledPackageJsonFile(context: PlasmicContext, pkg: string) {
+  const packageJsonPath = findPackageJsonPath(context.rootDir);
+  const rootDir = packageJsonPath
+    ? path.dirname(packageJsonPath)
+    : context.rootDir;
+  const files = glob.sync(`${rootDir}/**/node_modules/${pkg}/package.json`);
+  return files.length > 0 ? files[0] : undefined;
+}
+
+function parsePackageJson(path: string) {
+  try {
+    return JSON.parse(readFileText(path));
+  } catch (e) {
+    return undefined;
+  }
+}
+
+export function installUpgrade(
+  pkg: string,
+  baseDir: string,
+  opts: { global?: boolean; dev?: boolean } = {}
+) {
+  const cmd = installCommand(pkg, baseDir, opts);
+  if (!process.env.QUIET) {
+    logger.info(cmd);
+  }
+  const r = spawnSync(cmd, {
+    shell: true,
+    stdio: process.env.QUIET ? "ignore" : "inherit",
+    cwd: baseDir,
+  });
+  if (r.status === 0) {
+    if (!process.env.QUIET) {
+      logger.info(`Successfully added ${pkg} dependency.`);
+    }
+    return true;
+  } else {
+    logger.warn(
+      `Cannot add ${pkg} to your project dependencies. Please add it manually.`
+    );
+    return false;
+  }
+}
+
+export function installCommand(
+  pkg: string,
+  baseDir: string,
+  opts: { global?: boolean; dev?: boolean } = {}
+) {
+  const mgr = detectPackageManager(baseDir);
+  if (mgr === "yarn") {
+    if (opts.global) {
+      return `yarn global add ${pkg}`;
+    } else if (opts.dev) {
+      return `yarn add --dev --ignore-scripts -W ${pkg}`;
+    } else {
+      return `yarn add --ignore-scripts -W ${pkg}`;
+    }
+  } else {
+    if (opts.global) {
+      return `npm install -g ${pkg}`;
+    } else if (opts.dev) {
+      return `npm install --save-dev --ignore-scripts ${pkg}`;
+    } else {
+      return `npm install --ignore-scripts ${pkg}`;
+    }
+  }
+}
+
+export function detectPackageManager(baseDir: string) {
+  const yarnLock = findupSync("yarn.lock", { cwd: baseDir });
+  if (yarnLock) {
+    return "yarn";
+  } else {
+    return "npm";
+  }
+}

package/src/utils/prompts.ts

@@ -0,0 +1,22 @@
+import inquirer from "inquirer";
+
+export function askChoice<T>(question: {
+  message: string;
+  choices: T[];
+  defaultAnswer: T;
+  hidePrompt: boolean;
+}) {
+  if (question.hidePrompt) {
+    return question.defaultAnswer;
+  }
+  return inquirer
+    .prompt([
+      {
+        name: "answer",
+        type: "list",
+        message: question.message,
+        choices: question.choices,
+      },
+    ])
+    .then((answer) => answer.answer as T);
+}

package/src/utils/resolve-utils.ts

@@ -0,0 +1,245 @@
+import L from "lodash";
+import { SyncArgs } from "../actions/sync";
+import { ProjectVersionMeta, VersionResolution } from "../api";
+import { logger } from "../deps";
+import { CONFIG_FILE_NAME, PlasmicContext } from "./config-utils";
+import { HandledError } from "./error";
+import { ensure } from "./lang-utils";
+import * as semver from "./semver";
+import { confirmWithUser } from "./user-utils";
+
+/**
+ * Starting at the root, do a BFS of the full dependency tree
+ * Because ProjectVersionMeta only stores the (projectId, version),
+ * we need to search for the full ProjectVersionMeta of dependencies from `available`
+ * @param root
+ * @param versionResolution
+ */
+function walkDependencyTree(
+  root: ProjectVersionMeta,
+  available: ProjectVersionMeta[]
+): ProjectVersionMeta[] {
+  const queue: ProjectVersionMeta[] = [root];
+  const result: ProjectVersionMeta[] = [];
+
+  const getMeta = (projectId: string, version: string): ProjectVersionMeta => {
+    const meta = available.find(
+      (m) => m.projectId === projectId && m.version === version
+    );
+    if (!meta) {
+      throw new Error(
+        `Cannot find projectId=${projectId}, version=${version} in the sync resolution results.`
+      );
+    }
+    return meta;
+  };
+
+  while (queue.length > 0) {
+    const curr = ensure(queue.shift());
+    result.push(curr);
+    queue.push(
+      ...L.toPairs(curr.dependencies).map(([projectId, version]) =>
+        getMeta(projectId, version)
+      )
+    );
+  }
+
+  return result;
+}
+
+/**
+ * For a given project, check if its compatible with plasmic.json, plasmic.lock, and user
+ * @param meta
+ * @param context
+ */
+async function checkProjectMeta(
+  meta: ProjectVersionMeta,
+  root: ProjectVersionMeta,
+  context: PlasmicContext,
+  opts: SyncArgs
+): Promise<boolean> {
+  const projectId = meta.projectId;
+  const projectName = meta.projectName;
+  const newVersion = meta.version;
+
+  // Checks newVersion against plasmic.lock
+  const checkVersionLock = async (): Promise<boolean> => {
+    const projectLock = context.lock.projects.find(
+      (p) => p.projectId === projectId
+    );
+    const versionOnDisk = projectLock?.version;
+
+    if (!versionOnDisk) {
+      // Always sync if we haven't seen sync'ed before
+      return true;
+    }
+
+    if (
+      semver.isLatest(versionOnDisk) &&
+      semver.isLatest(newVersion) &&
+      meta !== root
+    ) {
+      // If this is a dependency (not root), and we're dealing with latest dep version
+      // just skip, it's confusing
+      logger.warn(
+        `'${root.projectName}' depends on ${projectName}@${newVersion}. To update this project, explicitly specify this project for sync. Skipping...`
+      );
+      return false;
+    }
+
+    if (semver.isLatest(newVersion)) {
+      // Always sync when version set to "latest"
+      return true;
+    }
+
+    if (semver.isLatest(versionOnDisk)) {
+      // Explicitly allow downgrades from "latest" to published version
+      return true;
+    }
+
+    // At this point, we can assume newVersion is always X.Y.Z (not latest)
+    if (semver.eq(newVersion, versionOnDisk)) {
+      if (opts.force) {
+        logger.info(
+          `Project '${projectName}'@${newVersion} is already up to date, but syncing anyway because --force is used`
+        );
+        return true;
+      } else {
+        logger.info(
+          `Project '${projectName}'@${newVersion} is already up to date; skipping. (To force an update, run again with "--force")`
+        );
+        return false;
+      }
+    }
+
+    if (semver.lt(newVersion, versionOnDisk)) {
+      meta === root
+        ? logger.warn(
+            `The local version of '${projectName}' (${versionOnDisk}) is higher than requested version @${newVersion}. Plasmic does not support downgrading a project. You should consider updating the version range in ${CONFIG_FILE_NAME}.`
+          )
+        : logger.warn(
+            `'${root.projectName}' uses '${projectName}'@${newVersion}, but your code has '${projectName}'@${versionOnDisk}. You should consider upgrading this dependency in Plasmic Studio.`
+          );
+      return false;
+    }
+
+    if (semver.gt(newVersion, versionOnDisk)) {
+      if (meta === root) {
+        return true;
+      } else {
+        logger.info(
+          `'${root.projectName}' uses '${projectName}'@${newVersion}, but your code has version ${versionOnDisk}`
+        );
+        return await confirmWithUser(
+          `Do you want to upgrade '${projectName}' to ${newVersion}?`,
+          opts.yes
+        );
+      }
+    }
+
+    throw new Error(
+      `Error comparing version=${newVersion} with the version found in plasmic.lock (${versionOnDisk}) for '${projectName}'`
+    );
+  };
+
+  // Checks newVersion against plasmic.json
+  const checkVersionRange = async (): Promise<boolean> => {
+    const projectConfig = context.config.projects.find(
+      (p) => p.projectId === projectId
+    );
+    const versionRange = projectConfig?.version;
+    // If haven't seen this before
+    if (!versionRange) {
+      // Always sync down dependencies if it's the first time to avoid compile/fix-imports error
+      projectId !== root.projectId
+        ? logger.info(
+            `'${root.projectName}' uses '${projectName}', which has never been synced before. We will also sync '${projectName}'@${newVersion}.`
+          )
+        : logger.info(
+            `'${projectName} has never been synced before. Syncing...'`
+          );
+      return true;
+    }
+
+    // If satisfies range in plasmic.json
+    if (semver.satisfies(newVersion, versionRange)) {
+      logger.info(`Updating project '${projectName}' to ${newVersion}`);
+      return true;
+    }
+
+    logger.warn(
+      `${projectName}@${newVersion} falls outside the range specified in ${CONFIG_FILE_NAME} (${versionRange})\nTip: To avoid this warning in the future, update your ${CONFIG_FILE_NAME}.`
+    );
+    return await confirmWithUser(
+      "Do you want to force it?",
+      opts.force || opts.yes,
+      "n"
+    );
+  };
+
+  const projectIds =
+    opts.projects.length > 0
+      ? opts.projects
+      : context.config.projects.map((p) => p.projectId);
+
+  if (projectIds.includes(projectId) && opts.force) {
+    // if --force is used, and this is in the list of projects to sync, then
+    // we should always sync it, even if nothing has changed
+    return true;
+  }
+
+  return (await checkVersionLock()) && (await checkVersionRange());
+}
+
+/**
+ * Checks the versionResolution with plasmic.json, plasmic.lock, and user prompts
+ * to compute which projects should be synced
+ * @param versionResolution
+ * @param context
+ */
+export async function checkVersionResolution(
+  versionResolution: VersionResolution,
+  context: PlasmicContext,
+  opts: SyncArgs
+): Promise<ProjectVersionMeta[]> {
+  // Fail if there's nothing to sync
+  if (versionResolution.projects.length <= 0) {
+    throw new HandledError(
+      `Found nothing to sync. Make sure the projectId and version values are valid in ${CONFIG_FILE_NAME}.`
+    );
+  }
+
+  const seen: ProjectVersionMeta[] = [];
+  const result: ProjectVersionMeta[] = [];
+  for (const root of versionResolution.projects) {
+    const queue = opts.nonRecursive
+      ? [root]
+      : walkDependencyTree(root, versionResolution.dependencies).reverse();
+    for (const m of queue) {
+      // If we haven't seen this yet
+      if (!seen.find((p) => p.projectId === m.projectId)) {
+        if (await checkProjectMeta(m, root, context, opts)) {
+          result.push(m);
+        }
+        seen.push(m);
+      }
+    }
+  }
+
+  // Ignore repeats
+  return result;
+}
+
+export function getDependencies(
+  projectId: string,
+  version: string,
+  versionResolution: VersionResolution
+) {
+  const filterFn = (m: ProjectVersionMeta) =>
+    m.projectId === projectId && m.version === version;
+  const meta =
+    versionResolution.projects.find(filterFn) ??
+    versionResolution.dependencies.find(filterFn);
+
+  return meta?.dependencies;
+}

package/src/utils/semver.ts

@@ -0,0 +1,67 @@
+import L from "lodash";
+import * as semverlib from "semver";
+
+/**
+ * Wrap `semver` with support for understanding "latest"
+ * - "latest" is both a version and a range
+ * - "latest" range will match any valid version number
+ * - "latest" version will only match "latest" version range
+ **/
+
+export type Version = semverlib.SemVer | "latest";
+export const latestTag = "latest";
+export const isLatest = (v: string) => v === latestTag;
+export const valid = (v: string) =>
+  isLatest(v) ? latestTag : semverlib.valid(v);
+export const inc = (v: string, release: semverlib.ReleaseType) =>
+  isLatest(v) ? latestTag : semverlib.inc(v, release);
+export const prerelease = (v: string) =>
+  isLatest(v) ? [] : semverlib.prerelease(v);
+export const major = (v: string) =>
+  isLatest(v) ? latestTag : semverlib.major(v);
+export const minor = (v: string) =>
+  isLatest(v) ? latestTag : semverlib.minor(v);
+export const patch = (v: string) =>
+  isLatest(v) ? latestTag : semverlib.patch(v);
+export const eq = (v1: string, v2: string) =>
+  (isLatest(v1) && isLatest(v2)) ||
+  (!isLatest(v1) && !isLatest(v2) && semverlib.eq(v1, v2));
+export const gt = (v1: string, v2: string) =>
+  (isLatest(v1) && !isLatest(v2)) ||
+  (!isLatest(v1) && !isLatest(v2) && semverlib.gt(v1, v2));
+export const lt = (v1: string, v2: string) =>
+  (!isLatest(v1) && isLatest(v2)) ||
+  (!isLatest(v1) && !isLatest(v2) && semverlib.lt(v1, v2));
+export const validRange = (range: string) =>
+  isLatest(range) ? latestTag : semverlib.validRange(range);
+export const satisfies = (v: string, range: string) =>
+  (isLatest(range) && !!valid(v)) ||
+  (!isLatest(v) && !isLatest(range) && semverlib.satisfies(v, range));
+export const toTildeRange = (v: string) =>
+  isLatest(v) ? latestTag : !!semverlib.valid(v) ? "~" + v : null;
+export const toCaretRange = (v: string) =>
+  isLatest(v) ? latestTag : !!semverlib.valid(v) ? "^" + v : null;
+export const gte = (v1: string, v2: string) => eq(v1, v2) || gt(v1, v2);
+export const lte = (v1: string, v2: string) => eq(v1, v2) || lt(v1, v2);
+export const neq = (v1: string, v2: string) => !eq(v1, v2);
+export const sortAsc = (versions: string[]) =>
+  L.cloneDeep(versions).sort((v1, v2) =>
+    gt(v1, v2) ? +1 : eq(v1, v2) ? 0 : -1
+  );
+export const sortDesc = (versions: string[]) => sortAsc(versions).reverse();
+export const minSatisfying = (versions: string[], range: string) =>
+  sortAsc(versions).find((v) => satisfies(v, range)) ?? null;
+export const maxSatisfying = (versions: string[], range: string) =>
+  sortDesc(versions).find((v) => satisfies(v, range)) ?? null;
+export const coerce = (v: string) =>
+  isLatest(v) ? latestTag : semverlib.coerce(v)?.version;
+export const gtr = (version: string, range: string) =>
+  (isLatest(version) && !isLatest(range)) ||
+  (!isLatest(version) && !isLatest(range) && semverlib.gtr(version, range));
+export const ltr = (version: string, range: string) =>
+  (!isLatest(version) && isLatest(range)) ||
+  (!isLatest(version) && !isLatest(range) && semverlib.ltr(version, range));
+export const outside = (version: string, range: string, hilo?: ">" | "<") =>
+  (hilo === ">" && gtr(version, range)) ||
+  (hilo === "<" && ltr(version, range)) ||
+  (!hilo && (gtr(version, range) || ltr(version, range)));

package/src/utils/test-utils.ts

@@ -0,0 +1,116 @@
+import fs from "fs";
+import * as path from "path";
+import * as tmp from "tmp";
+import {
+  AuthConfig,
+  AUTH_FILE_NAME,
+  CONFIG_FILE_NAME,
+  LOADER_CONFIG_FILE_NAME,
+  PlasmicConfig,
+  PlasmicLoaderConfig,
+} from "../utils/config-utils";
+import { deleteFileBuffered, readFileText, writeFileText } from "./file-utils";
+
+export class TempRepo {
+  tmpDir: tmp.DirResult; // Temporary directory used for tests
+
+  constructor() {
+    this.tmpDir = tmp.dirSync({ unsafeCleanup: true });
+  }
+
+  destroy() {
+    this.tmpDir.removeCallback();
+  }
+
+  resolveFile(relativePath: string): string {
+    return path.resolve(this.tmpDir.name, relativePath);
+  }
+
+  readFile(relativePath: string): string {
+    const absPath = this.resolveFile(relativePath);
+    const buf = readFileText(absPath);
+    return buf.toString();
+  }
+
+  writeFile(relativePath: string, data: string) {
+    const absPath = this.resolveFile(relativePath);
+    writeFileText(absPath, data);
+  }
+
+  deleteFile(relativePath: string) {
+    const absPath = this.resolveFile(relativePath);
+    deleteFileBuffered(absPath);
+  }
+
+  checkFile(relativePath: string): boolean {
+    const absPath = this.resolveFile(relativePath);
+    try {
+      const stats = fs.statSync(absPath);
+      return !!stats ? true : false;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  getComponentFileContents(
+    projectId: string,
+    componentId: string
+  ): string | undefined {
+    const plasmicJson: PlasmicConfig = JSON.parse(
+      this.readFile(CONFIG_FILE_NAME)
+    );
+    const srcDir = plasmicJson.srcDir;
+    const projectConfig = plasmicJson.projects.find(
+      (p) => p.projectId === projectId
+    );
+    if (!projectConfig) {
+      return;
+    }
+    const componentConfig = projectConfig.components.find(
+      (c) => c.id === componentId
+    );
+    if (!componentConfig) {
+      return;
+    }
+    const data = this.readFile(
+      path.join(srcDir, componentConfig.renderModuleFilePath)
+    );
+    return data;
+  }
+
+  plasmicAuthPath(): string {
+    return this.resolveFile(AUTH_FILE_NAME);
+  }
+
+  writePlasmicAuth(json: AuthConfig) {
+    this.writeFile(AUTH_FILE_NAME, JSON.stringify(json));
+  }
+
+  deletePlasmicAuth() {
+    this.deleteFile(AUTH_FILE_NAME);
+  }
+
+  plasmicJsonPath(): string {
+    return this.resolveFile(CONFIG_FILE_NAME);
+  }
+
+  readPlasmicJson(): PlasmicConfig {
+    return JSON.parse(this.readFile(CONFIG_FILE_NAME));
+  }
+
+  writePlasmicJson(json: PlasmicConfig) {
+    this.writeFile(CONFIG_FILE_NAME, JSON.stringify(json));
+  }
+
+  deletePlasmicJson() {
+    this.deleteFile(CONFIG_FILE_NAME);
+  }
+
+  plasmicLoaderJsonPath() {
+    return this.resolveFile(LOADER_CONFIG_FILE_NAME);
+  }
+
+  readPlasmicLoaderJson(): PlasmicLoaderConfig {
+    return JSON.parse(this.readFile(LOADER_CONFIG_FILE_NAME));
+  }
+}

package/src/utils/user-utils.ts

@@ -0,0 +1,37 @@
+import inquirer from "inquirer";
+import { logger } from "../deps";
+
+/**
+ * Provide a standardized way to ask user to continue
+ * @param message
+ * @param yes - If true, always return true without prompting.
+ * @param default - Override the default value returned if the user presses enter
+ */
+export async function confirmWithUser(
+  message: string,
+  yes?: boolean,
+  defaultAnswer?: "y" | "n"
+): Promise<boolean> {
+  if (process.env.QUIET) {
+    return true;
+  }
+
+  if (!!yes) {
+    if (!process.env.QUIET) {
+      logger.info(`${message} (Y/n): y`);
+    }
+    return true;
+  }
+
+  defaultAnswer = defaultAnswer ?? "y";
+  const isDefaultYes = defaultAnswer === "y";
+  const choices = `(${isDefaultYes ? "Y" : "y"}/${isDefaultYes ? "n" : "N"})`;
+  const res = await inquirer.prompt([
+    {
+      name: "continue",
+      message: `${message} ${choices}`,
+      default: defaultAnswer,
+    },
+  ]);
+  return ["y", "yes"].includes(res.continue.toLowerCase());
+}