@plasmicapp/cli 0.1.162

package/src/index.ts

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+import semver from "semver";
+import updateNotifier from "update-notifier";
+import yargs from "yargs";
+import * as auth from "./actions/auth";
+import { fixImports, FixImportsArgs } from "./actions/fix-imports";
+import { getYargsOption, InitArgs, initPlasmic } from "./actions/init";
+import * as projectToken from "./actions/project-token";
+import { sync, SyncArgs } from "./actions/sync";
+import { UploadBundleArgs, uploadJsBundle } from "./actions/upload-bundle";
+import { WatchArgs, watchProjects } from "./actions/watch";
+import { LOADER_CONFIG_FILE_NAME } from "./utils/config-utils";
+import { handleError } from "./utils/error";
+
+if (process.env.DEBUG_CHDIR) {
+  process.chdir(process.env.DEBUG_CHDIR);
+}
+
+// Check once an hour
+const pkg = require("../package.json");
+const notifier = updateNotifier({ pkg, updateCheckInterval: 1000 * 60 * 60 });
+// Workaround for this bug
+// https://github.com/yeoman/update-notifier/issues/181
+if (
+  !!notifier.update &&
+  semver.gt(notifier.update.latest, notifier.update.current)
+) {
+  notifier.notify();
+}
+
+yargs
+  .usage("Usage: $0 <command> [options]")
+  .option("auth", {
+    describe:
+      "Plasmic auth file to use; by default, uses ~/.plasmic.auth, or the first .plasmic.auth file found in current and parent directories",
+  })
+  .option("config", {
+    describe:
+      "Plasmic config file to use; by default, uses the first plasmic.json file found in the current or parent directories",
+  })
+  .option("yes", {
+    type: "boolean",
+    describe: "Automatic yes to prompts.",
+    default: false,
+  })
+  .command<InitArgs>(
+    "init",
+    "Initializes Plasmic for a project.",
+    (yags) => {
+      yags
+        .option("enable-skip-auth", {
+          describe: "Enable skipping auth, just initialize a plasmic.json",
+          type: "boolean",
+          default: false,
+        })
+        .option("host", getYargsOption("host", "https://studio.plasmic.app"))
+        .option("platform", getYargsOption("platform"))
+        .option("code-lang", getYargsOption("codeLang"))
+        .option("code-scheme", getYargsOption("codeScheme"))
+        .option("react-runtime", {
+          describe: "React runtime to use; either classic or automatic",
+          choices: ["classic", "automatic"],
+          default: "classic",
+        })
+        .option("src-dir", getYargsOption("srcDir"))
+        .option("plasmic-dir", getYargsOption("plasmicDir"))
+        .option("pages-dir", getYargsOption("pagesDir"))
+        .option("style-scheme", getYargsOption("styleScheme"))
+        .option("images-scheme", getYargsOption("imagesScheme"))
+        .option("images-public-dir", getYargsOption("imagesPublicDir"))
+        .option(
+          "images-public-url-prefix",
+          getYargsOption("imagesPublicUrlPrefix")
+        );
+    },
+    (argv) => handleError(initPlasmic(argv))
+  )
+  .command<auth.AuthArgs>(
+    "auth",
+    "Authenticates you to plasmic.",
+    (yags) => {
+      yags
+        .option("host", {
+          describe: "Plasmic host to use",
+          type: "string",
+          default: "https://studio.plasmic.app",
+        })
+        .option("check", {
+          alias: "c",
+          describe: "Just verifies if the current credentials are valid.",
+          type: "boolean",
+        })
+        .option("email", {
+          describe:
+            "Print the email of the currently authenticated user and exit.",
+          type: "boolean",
+        });
+    },
+    (argv) => {
+      handleError(auth.auth(argv));
+    }
+  )
+  .command<SyncArgs>(
+    "sync",
+    "Syncs designs from Plasmic to local files.",
+    (yags) => configureSyncArgs(yags),
+    (argv) => {
+      handleError(
+        sync(argv, {
+          source: "cli",
+          scheme: "codegen",
+          command: "sync",
+        })
+      );
+    }
+  )
+  .command<WatchArgs>(
+    "watch",
+    "Watches for updates to projects, and syncs them automatically to local files.",
+    (yags) => configureSyncArgs(yags, false),
+    (argv) => {
+      handleError(
+        watchProjects(argv, {
+          source: "cli",
+          scheme: "codegen",
+          command: "watch",
+        })
+      );
+    }
+  )
+  .command<FixImportsArgs>(
+    "fix-imports",
+    "Fixes import paths after you've moved around Plasmic blackbox files",
+    (yags) => 0,
+    (argv) => handleError(fixImports(argv))
+  )
+  .command<UploadBundleArgs>(
+    "upload-bundle",
+    false,
+    (yargs) =>
+      yargs
+        .option("project", {
+          alias: "p",
+          describe: "ID of Plasmic project to upload the bundle to.",
+          type: "string",
+        })
+        .option("bundleName", {
+          describe: "Name of the bundle",
+          type: "string",
+        })
+        .option("bundleJsFile", {
+          describe: "Path of the bundled Javascript file in AMD format",
+          type: "string",
+        })
+        .option("cssFiles", {
+          describe: "Path of the bundled css files to load",
+          type: "array",
+          default: [],
+        })
+        .option("metaJsonFile", {
+          describe:
+            "Path of the meta data file (in JSON format) describing the component",
+          type: "string",
+        })
+        .option("extraPropMetaJsonFile", {
+          describe:
+            "Path of the extra meta data file (in JSON format) describing the component's additional controlled properties and initial properties",
+          type: "string",
+        })
+        .option("pkgVersion", {
+          describe:
+            "version of the package to include in the generated package.json",
+          type: "string",
+          default: "latest",
+        })
+        .option("genModulePath", {
+          describe:
+            "the path of include when generating import statement and generate package.json for. Default to bundleName.",
+          type: "string",
+        })
+        .option("themeProviderWrapper", {
+          describe: "the wrapper that inject theme to the bundle.",
+          type: "string",
+        })
+        .option("themeModuleFile", {
+          describe:
+            "the typescript file that contains and exports the implementation of themeProviderWrapper. Used for code generation. It must be specified together with themeProviderWrapper.",
+          type: "string",
+        })
+        .option("genCssPaths", {
+          describe:
+            "the list of css paths to import in generate code whenever a component in this bundle is used",
+          type: "array",
+          default: [],
+        }),
+    (argv) => handleError(uploadJsBundle(argv))
+  )
+  .command<projectToken.ProjectTokenArgs>(
+    "project-token <projectId>",
+    "Get projectApiToken for a given project",
+    (yargs) =>
+      yargs
+        .positional("projectId", {
+          describe: "projectId",
+          type: "string",
+        })
+        .option("host", {
+          describe: "Plasmic host to use",
+          type: "string",
+          default: "https://studio.plasmic.app",
+        }),
+    (argv) => handleError(projectToken.projectToken(argv))
+  )
+  .demandCommand()
+  .strict()
+  .help("h")
+  .alias("h", "help").argv;
+
+function configureSyncArgs(
+  yags: yargs.Argv,
+  includeQuietOption: boolean = true
+) {
+  let args = yags
+    .option("projects", {
+      alias: "p",
+      describe:
+        "One or more projects to sync, separated by comma. Version constraints can be specified using @. Example: projectid, projectid@>=version",
+      type: "array",
+      default: [],
+    })
+    .option("force", {
+      type: "boolean",
+      describe: "Force sync to bypass specified version ranges.",
+      default: false,
+    })
+    .option("loader-config", {
+      type: "string",
+      describe:
+        "Path to loader config file, and causes CLI to run in PlasmicLoader mode.",
+      hidden: true,
+      default: LOADER_CONFIG_FILE_NAME,
+    })
+    .option("non-recursive", {
+      type: "boolean",
+      describe:
+        "Do not recursively sync dependencies, only sync the specified projects",
+      default: false,
+    })
+    .option("force-overwrite", {
+      type: "boolean",
+      describe:
+        "Overwrite the skeleton file with newly generated version. Useful when switching between codegen schemes.",
+      default: false,
+    })
+    .option("append-jsx-on-missing-base", {
+      type: "boolean",
+      describe:
+        "When the base metadata is missing to perform the three-way merge for direct edit component, append the jsx of the new version so that user can perform manual merge.",
+      default: false,
+    })
+    .option("new-component-scheme", {
+      type: "string",
+      choices: ["blackbox", "direct"],
+      describe:
+        "Sync the new components using this code scheme rather than the default code scheme.",
+    })
+    .option("ignore-post-sync", {
+      type: "boolean",
+      describe: "Ignore post-sync commands in plasmic.json",
+      default: false,
+    })
+    .option("metadata", {
+      type: "string",
+      describe:
+        "Pass metadata through to the server. Use querystring format (e.g. command=sync&source=cli&cli_version=1.0.0",
+      default: "source=cli",
+      hidden: true,
+    })
+    .option("all-files", {
+      type: "boolean",
+      describe:
+        "Sync all files, including those that haven't changed since last sync",
+      default: "",
+    });
+  if (includeQuietOption) {
+    args = args.option("quiet", {
+      type: "boolean",
+      describe: "Do not inform each asset to be synced",
+      default: false,
+    });
+  }
+  return args;
+}
+
+export interface CommonArgs {
+  baseDir: string;
+  auth?: string;
+  config?: string;
+  yes?: boolean;
+}

package/src/lib.ts

@@ -0,0 +1,10 @@
+export { auth, AuthArgs } from "./actions/auth";
+export { fixImports, FixImportsArgs } from "./actions/fix-imports";
+export { InitArgs, initPlasmic } from "./actions/init";
+export { getProjectApiToken } from "./actions/project-token";
+export { sync, SyncArgs } from "./actions/sync";
+export { UploadBundleArgs, uploadJsBundle } from "./actions/upload-bundle";
+export { WatchArgs, watchProjects } from "./actions/watch";
+export { logger } from "./deps";
+export { HandledError, handleError } from "./utils/error";
+export { Metadata, setMetadataEnv } from "./utils/get-context";

package/src/migrations/0.1.110-fileLocks.ts

@@ -0,0 +1,16 @@
+import { PlasmicLock } from "../utils/config-utils";
+
+export function ensureFileLocks(lock: PlasmicLock) {
+  for (const project of lock.projects) {
+    // Ensure all `ProjectLock`s have `fileLock` array
+    if (!project.fileLocks) {
+      project.fileLocks = [];
+    }
+    // Ensure all `FileLock`s have valid checksums
+    project.fileLocks = project.fileLocks.filter(
+      (fileLock) =>
+        typeof fileLock.checksum === "string" && fileLock.checksum.length === 32
+    );
+  }
+  return lock;
+}

package/src/migrations/0.1.146-addReactRuntime.ts

@@ -0,0 +1,8 @@
+import { PlasmicConfig } from "../utils/config-utils";
+
+export function ensureReactRuntime(config: PlasmicConfig) {
+  if (!config.code.reactRuntime) {
+    config.code.reactRuntime = "classic";
+  }
+  return config;
+}

package/src/migrations/0.1.27-migrateInit.ts

@@ -0,0 +1,4 @@
+export function migrateInit(prev: any) {
+  // Just stamping the first migration
+  return prev;
+}

package/src/migrations/0.1.28-tsToTsx.ts

@@ -0,0 +1,37 @@
+import glob from "glob";
+import L from "lodash";
+import path from "upath";
+import { logger } from "../deps";
+import { PlasmicConfig } from "../utils/config-utils";
+import {
+  existsBuffered,
+  findSrcDirPath,
+  renameFileBuffered,
+} from "../utils/file-utils";
+import { MigrateContext } from "./migrations";
+
+export function tsToTsx(config: PlasmicConfig, context: MigrateContext) {
+  const srcDir = context.absoluteSrcDir;
+  const allFiles = glob.sync(`${srcDir}/**/*.+(ts)`, {
+    ignore: [`${srcDir}/**/node_modules/**/*`],
+  });
+  const existingFiles = L.groupBy(allFiles, (f) => path.basename(f));
+  config.projects.forEach((project) => {
+    project.components.forEach((c) => {
+      if (c.renderModuleFilePath.endsWith("ts")) {
+        const relFilePath = findSrcDirPath(
+          context.absoluteSrcDir,
+          c.renderModuleFilePath,
+          existingFiles
+        );
+        const absFilePath = path.join(context.absoluteSrcDir, relFilePath);
+        if (existsBuffered(absFilePath)) {
+          logger.info(`rename file from ${absFilePath} to ${absFilePath}x`);
+          renameFileBuffered(absFilePath, `${absFilePath}x`);
+        }
+        c.renderModuleFilePath = `${c.renderModuleFilePath}x`;
+      }
+    });
+  });
+  return config;
+}

package/src/migrations/0.1.31-ensureProjectIcons.ts

@@ -0,0 +1,10 @@
+import { PlasmicConfig } from "../utils/config-utils";
+
+export function ensureProjectIcons(config: PlasmicConfig) {
+  for (const proj of config.projects) {
+    if (!proj.icons) {
+      proj.icons = [];
+    }
+  }
+  return config;
+}

package/src/migrations/0.1.42-ensureVersion.ts

@@ -0,0 +1,10 @@
+import { PlasmicConfig } from "../utils/config-utils";
+
+export function ensureVersion(config: PlasmicConfig) {
+  for (const proj of config.projects) {
+    if (!proj.version) {
+      proj.version = "latest";
+    }
+  }
+  return config;
+}

package/src/migrations/0.1.57-ensureJsBundleThemes.ts

@@ -0,0 +1,10 @@
+import { PlasmicConfig } from "../utils/config-utils";
+
+export function ensureJsBundleThemes(config: PlasmicConfig) {
+  for (const proj of config.projects) {
+    if (!proj.jsBundleThemes) {
+      proj.jsBundleThemes = [];
+    }
+  }
+  return config;
+}

package/src/migrations/0.1.64-imageFiles.ts

@@ -0,0 +1,15 @@
+import { PlasmicConfig } from "../utils/config-utils";
+
+export function ensureImageFiles(config: PlasmicConfig) {
+  if (!config.images) {
+    config.images = {
+      scheme: "inlined",
+    };
+  }
+  for (const proj of config.projects) {
+    if (!proj.images) {
+      proj.images = [];
+    }
+  }
+  return config;
+}

package/src/migrations/0.1.95-componentType.ts

@@ -0,0 +1,14 @@
+import { PlasmicConfig } from "../utils/config-utils";
+
+export function ensureComponentType(config: PlasmicConfig) {
+  for (const project of config.projects) {
+    for (const component of project.components) {
+      if (component.componentType) {
+        continue;
+      }
+      const [_, componentPath] = component.importSpec.modulePath.split(/pages/);
+      component.componentType = componentPath ? "page" : "component";
+    }
+  }
+  return config;
+}

package/src/migrations/migrations.ts

@@ -0,0 +1,147 @@
+/**
+ * Super simple migration framework for cli.
+ *
+ * If you want to run some migration script (say, to fix up the schema of plasmic.json, etc),
+ * you should:
+ *
+ * 1. Bump your cli version.
+ * 2. Add a [version]-[desc].ts file to the migrations folder, exporting a function that takes
+ *    the previous version of plasmic.json (or plasmic.lock) blob, and returns the new version
+ *    of plasmic.json (or plasmic.lock) blob.
+ * 3. Add the migration function to the MIGRATIONS (or LOCK_MIGRATIONS) dict in this file.
+ *
+ * The framework will run migrations in sequence, so you are guaranteed that the plasmic.json blob
+ * passed into your migration function is valid as of the previous version.
+ */
+import chalk from "chalk";
+import L from "lodash";
+import semver from "semver";
+import path from "upath";
+import { logger } from "../deps";
+import {
+  PlasmicConfig,
+  PlasmicLock,
+  readConfig,
+  writeConfig,
+  writeLock,
+} from "../utils/config-utils";
+import { HandledError } from "../utils/error";
+import { existsBuffered, readFileText } from "../utils/file-utils";
+import {
+  getCliVersion,
+  installUpgrade,
+  isCliGloballyInstalled,
+} from "../utils/npm-utils";
+import { confirmWithUser } from "../utils/user-utils";
+import { ensureFileLocks } from "./0.1.110-fileLocks";
+import { ensureReactRuntime } from "./0.1.146-addReactRuntime";
+import { migrateInit } from "./0.1.27-migrateInit";
+import { tsToTsx } from "./0.1.28-tsToTsx";
+import { ensureProjectIcons } from "./0.1.31-ensureProjectIcons";
+import { ensureVersion } from "./0.1.42-ensureVersion";
+import { ensureJsBundleThemes } from "./0.1.57-ensureJsBundleThemes";
+import { ensureImageFiles } from "./0.1.64-imageFiles";
+import { ensureComponentType } from "./0.1.95-componentType";
+export interface MigrateContext {
+  absoluteSrcDir: string;
+}
+
+type MigrateConfigFunc = (
+  prev: PlasmicConfig,
+  context: MigrateContext
+) => PlasmicConfig;
+type MigrateLockFunc = (
+  prev: PlasmicLock,
+  context: MigrateContext
+) => PlasmicLock;
+
+export const MIGRATIONS: Record<string, MigrateConfigFunc> = {
+  "0.1.27": migrateInit,
+  "0.1.28": tsToTsx,
+  "0.1.31": ensureProjectIcons,
+  "0.1.42": ensureVersion,
+  "0.1.57": ensureJsBundleThemes,
+  "0.1.64": ensureImageFiles,
+  "0.1.95": ensureComponentType,
+  "0.1.146": ensureReactRuntime,
+};
+
+export const LOCK_MIGRATIONS: Record<string, MigrateLockFunc> = {
+  "0.1.110": ensureFileLocks,
+};
+
+export async function runNecessaryMigrations(
+  configFile: string,
+  lockFile: string,
+  baseDir: string,
+  yes?: boolean
+) {
+  const cliVersion = getCliVersion();
+  // If we don't have a lock file, we don't need to run migrations on it!
+  const maybeReadLock = (): PlasmicLock | undefined => {
+    if (existsBuffered(lockFile)) {
+      return JSON.parse(readFileText(lockFile));
+    }
+    return undefined;
+  };
+  const cur = readConfig(configFile, false);
+  const curVersion: string | undefined = cur.cliVersion;
+
+  if (!!curVersion && semver.lt(cliVersion, curVersion)) {
+    const confirm = await confirmWithUser(
+      `Project requires @plasmicapp/cli>=${curVersion} (You currently have ${cliVersion}). Would you like to upgrade it?`,
+      yes
+    );
+    if (!confirm) {
+      throw new HandledError("Upgrading is required to continue.");
+    }
+
+    const success = installUpgrade("@plasmicapp/cli", baseDir, {
+      global: isCliGloballyInstalled(path.dirname(configFile)),
+      dev: true,
+    });
+
+    logger.info(
+      chalk.bold("@plasmicapp/cli has been upgraded; please try again!")
+    );
+
+    throw new HandledError(success ? "" : "Error upgrading @plasmicapp/cli");
+  }
+
+  const context: MigrateContext = {
+    absoluteSrcDir: path.isAbsolute(cur.srcDir)
+      ? cur.srcDir
+      : path.resolve(path.dirname(configFile), cur.srcDir),
+  };
+  const greaterVersions = semver.sort(
+    [...L.keys(MIGRATIONS), ...L.keys(LOCK_MIGRATIONS)].filter(
+      (v) => !curVersion || semver.gt(v, curVersion)
+    )
+  );
+  for (const version of greaterVersions) {
+    logger.info(`Migrating to plasmic.json version ${version}`);
+    const migrationFunc = MIGRATIONS[version];
+    if (migrationFunc !== undefined) {
+      const prev = readConfig(configFile, false);
+      const next = migrationFunc(prev, context);
+      next.cliVersion = version;
+      await writeConfig(configFile, next, baseDir);
+    }
+
+    const lockMigrationFunc = LOCK_MIGRATIONS[version];
+    if (lockMigrationFunc !== undefined) {
+      const prev = maybeReadLock();
+      if (prev) {
+        const next = lockMigrationFunc(prev, context);
+        await writeLock(lockFile, next, baseDir);
+      }
+    }
+  }
+
+  // Finally, stamp the latest version
+  const latestConfig = readConfig(configFile, false);
+  if (latestConfig.cliVersion !== cliVersion) {
+    latestConfig.cliVersion = cliVersion;
+    await writeConfig(configFile, latestConfig, baseDir);
+  }
+}