@plasmicapp/cli 0.1.162

package/src/__tests__/ftue-spec.ts

@@ -0,0 +1,43 @@
+jest.mock("../api");
+import { sync } from "../actions/sync";
+import {
+  expectProject1Components,
+  expectProject1PlasmicJson,
+  opts,
+  standardTestSetup,
+  standardTestTeardown,
+  tmpRepo,
+} from "../test-common/fixtures";
+
+// Reset the test project directory
+beforeEach(() => {
+  standardTestSetup(false);
+});
+
+afterEach(() => {
+  standardTestTeardown();
+});
+
+describe("first-time-user-experience", () => {
+  test("missing auth", async () => {
+    // Trying to sync is going to fail without a valid auth file
+    tmpRepo.deletePlasmicAuth();
+    await expect(sync(opts)).rejects.toThrow();
+  });
+
+  test("no args", async () => {
+    // No projects or components specified
+    await expect(sync(opts)).rejects.toThrow();
+  });
+
+  test("specify project", async () => {
+    opts.projects = ["projectId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    expectProject1Components();
+
+    expect(tmpRepo.checkFile("./src/DepComponent.tsx")).toBeFalsy();
+
+    expectProject1PlasmicJson();
+  });
+});

package/src/__tests__/project-api-token-spec.ts

@@ -0,0 +1,208 @@
+import { sync } from "../actions/sync";
+import {
+  defaultPlasmicJson,
+  expectProject1Components,
+  expectProject1PlasmicJson,
+  expectProjectAndDepPlasmicJson,
+  mockApi,
+  opts,
+  project1Config,
+  standardTestSetup,
+  standardTestTeardown,
+  tmpRepo,
+} from "../test-common/fixtures";
+
+jest.mock("../api");
+
+// Reset the test project directory
+beforeEach(() => {
+  standardTestSetup(false);
+});
+
+afterEach(() => {
+  standardTestTeardown();
+});
+
+function removeAuth() {
+  opts.auth = undefined;
+  // Don't need to remove this file, we just do for good measure.
+  tmpRepo.deletePlasmicAuth();
+}
+
+describe("Project API tokens", () => {
+  test("is filled in by auth'd user so that a second run does not need auth", async () => {
+    opts.projects = ["projectId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    expectProject1Components();
+
+    expectProject1PlasmicJson();
+
+    // Re-run, this time with no auth.
+    removeAuth();
+    await expect(sync(opts)).resolves.toBeUndefined();
+  });
+
+  test("can be passed in from command-line args", async () => {
+    removeAuth();
+
+    // Without specifying version.
+    opts.projects = ["projectId1:abc"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    // Specifying version.
+    opts.projects = ["projectId1:abc@1.2.3"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    // Wrong token (should fail).
+    opts.projects = ["projectId1:123"];
+    await expect(sync(opts)).rejects.toThrow(
+      "No user+token, and project API tokens don't match"
+    );
+  });
+
+  test("is corrected by auth'd user if token was initially incorrect", async () => {
+    opts.projects = ["projectId1"];
+    tmpRepo.writePlasmicJson({
+      ...defaultPlasmicJson,
+      projects: [{ ...project1Config, projectApiToken: "blah" }],
+    });
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    expectProject1Components();
+
+    expectProject1PlasmicJson();
+
+    // Re-run, this time with no auth.
+    removeAuth();
+    await expect(sync(opts)).resolves.toBeUndefined();
+  });
+
+  test("is filled in by auth'd user if project exists but token was initially missing", async () => {
+    opts.projects = ["projectId1"];
+    tmpRepo.writePlasmicJson({
+      ...defaultPlasmicJson,
+      projects: [project1Config],
+    });
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    expectProject1Components();
+
+    expectProject1PlasmicJson();
+
+    // Re-run, this time with no auth.
+    removeAuth();
+    await expect(sync(opts)).resolves.toBeUndefined();
+  });
+
+  test("when not available, should prompt for auth", async () => {
+    opts.projects = ["projectId1"];
+    removeAuth();
+    await expect(sync(opts)).rejects.toThrow("Unable to authenticate");
+  });
+
+  // TODO: Would be nice to eventually make this not fail outright but to prompt for auth.
+  test("when incorrect, should fail", async () => {
+    opts.projects = ["projectId1"];
+    removeAuth();
+    tmpRepo.writePlasmicJson({
+      ...defaultPlasmicJson,
+      projects: [{ ...project1Config, projectApiToken: "blah" }],
+    });
+    await expect(sync(opts)).rejects.toThrow(
+      "No user+token, and project API tokens don't match"
+    );
+  });
+
+  test("works even if you have tokens for base but not deps", async () => {
+    // Make project1 have a dependency.
+    standardTestSetup();
+
+    opts.projects = ["projectId1"];
+    removeAuth();
+    tmpRepo.writePlasmicJson({
+      ...defaultPlasmicJson,
+      projects: [{ ...project1Config, projectApiToken: "abc" }],
+    });
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    expectProject1Components();
+
+    expectProjectAndDepPlasmicJson();
+  });
+
+  test("works even if dependency was determined to not need an update", async () => {
+    // Make project1 have a dependency.
+    standardTestSetup();
+
+    opts.projects = ["projectId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    // We sync project1 which got updated, but the dependency is still same version.
+    opts.force = false;
+    removeAuth();
+    mockApi.getMockProject("projectId1", "1.2.3").version = "1.2.4";
+    await expect(sync(opts)).resolves.toBeUndefined();
+  });
+
+  test("should prompt for auth if you have only irrelevant tokens", async () => {
+    opts.projects = ["dependencyId1"];
+    removeAuth();
+    tmpRepo.writePlasmicJson({
+      ...defaultPlasmicJson,
+      projects: [{ ...project1Config, projectApiToken: "abc" }],
+    });
+    await expect(sync(opts)).rejects.toThrow("Unable to authenticate");
+  });
+
+  test("should use plasmic-loader.json for API tokens in loader mode", async () => {
+    process.env.PLASMIC_LOADER = "1";
+
+    opts.projects = ["projectId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    const loaderConfig = tmpRepo.readPlasmicLoaderJson();
+    expect(loaderConfig).toEqual({
+      projects: [
+        {
+          projectId: "projectId1",
+          projectApiToken: "abc",
+        },
+      ],
+    });
+
+    // Re-run, this time with no auth and no tokens in plasmic.json, only in plasmic-loader.json.
+    removeAuth();
+    tmpRepo.writePlasmicJson(defaultPlasmicJson);
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    delete process.env["PLASMIC_LOADER"];
+  });
+
+  test("works in PlasmicLoader mode even if root project was determined to not need an update", async () => {
+    process.env.PLASMIC_LOADER = "1";
+
+    // Make project1 have a dependency.
+    standardTestSetup();
+
+    // Explicitly sync both - we had a bug writing back the plasmic-loader.json in this case.
+    opts.projects = ["projectId1", "dependencyId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    // We sync project1 which got updated, but the dependency is still same version.
+    opts.force = false;
+    removeAuth();
+    mockApi.getMockProject("projectId1", "1.2.3").version = "1.2.4";
+    await expect(sync(opts)).resolves.toBeUndefined();
+  });
+
+  test("should fail in loader mode if not available", async () => {
+    process.env.PLASMIC_LOADER = "1";
+
+    opts.projects = ["projectId1"];
+    removeAuth();
+    await expect(sync(opts)).rejects.toThrow();
+
+    delete process.env["PLASMIC_LOADER"];
+  });
+});

package/src/__tests__/versioned-sync-spec.ts

@@ -0,0 +1,176 @@
+import { sync } from "../actions/sync";
+import {
+  expectProject1Components,
+  expectProject1PlasmicJson,
+  expectProjectAndDepPlasmicJson,
+  mockApi,
+  opts,
+  project1Config,
+  standardTestSetup,
+  standardTestTeardown,
+  tmpRepo,
+} from "../test-common/fixtures";
+import { MockComponent } from "../__mocks__/api";
+
+jest.mock("../api");
+
+// Reset the test project directory
+beforeEach(() => {
+  standardTestSetup();
+});
+
+afterEach(() => {
+  // Remove the temporary directory
+  // TODO: Comment out to keep files for debugging
+  standardTestTeardown();
+});
+
+describe("versioned-sync", () => {
+  test("syncs non-recursive case", async () => {
+    opts.projects = ["projectId1"];
+    opts.nonRecursive = true;
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    expectProject1Components();
+
+    expect(tmpRepo.checkFile("./src/DepComponent.tsx")).toBeFalsy();
+
+    // Check plasmic.json
+    expectProject1PlasmicJson();
+  });
+
+  test("syncs missing components", async () => {
+    opts.projects = ["projectId1"];
+    opts.nonRecursive = true;
+    // Simulates user deleting files by accident, since the project exists in plasmic.json,
+    // but not in the project directory
+    const plasmicJson = tmpRepo.readPlasmicJson();
+    plasmicJson.projects.push(project1Config);
+    tmpRepo.writePlasmicJson(plasmicJson);
+    await expect(sync(opts)).resolves.toBeUndefined();
+  });
+
+  test("syncs down new names", async () => {
+    opts.projects = ["projectId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+    // Change component name server-side
+    const mockProject = mockApi.getMockProject("projectId1", "1.2.3");
+    const buttonData = mockProject.components.find(
+      (c: MockComponent) => c.id === "buttonId"
+    );
+    buttonData.name = "NewButton";
+    mockProject.version = "2.0.0";
+    mockApi.addMockProject(mockProject);
+    // Try syncing again and see if things show up
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    const plasmicJson = tmpRepo.readPlasmicJson();
+    const projectInConfig = plasmicJson.projects.find(
+      (p) => p.projectId === "projectId1"
+    );
+    const componentInConfig = !!projectInConfig
+      ? projectInConfig.components.find((c) => c.id === buttonData.id)
+      : undefined;
+    expect(componentInConfig).toBeTruthy();
+    expect(componentInConfig?.name).toEqual(buttonData.name);
+  });
+
+  test("syncs latest", async () => {
+    opts.projects = ["projectId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+    // Change component version server-side
+    const mockProject = mockApi.getMockProject("projectId1", "1.2.3");
+    mockProject.version = "1.3.4";
+    mockApi.addMockProject(mockProject);
+    // Try syncing again and see if things show up
+    await expect(sync(opts)).resolves.toBeUndefined();
+    const button = mockApi.stringToMockComponent(
+      tmpRepo.getComponentFileContents("projectId1", "buttonId")
+    );
+    expect(button).toBeTruthy();
+    expect(button?.name).toEqual("Button");
+    expect(button?.version).toEqual("1.3.4");
+  });
+
+  test("syncs exact version", async () => {
+    opts.projects = ["projectId1"];
+    opts.nonRecursive = true;
+    await expect(sync(opts)).resolves.toBeUndefined();
+    // Change component version server-side
+    const mockProject = mockApi.getMockProject("projectId1", "1.2.3");
+    mockProject.version = "2.0.0";
+    mockApi.addMockProject(mockProject);
+    // Read in updated plasmic.json post-sync
+    const plasmicJson = tmpRepo.readPlasmicJson();
+    expect(plasmicJson.projects.length).toEqual(1); // projectId1
+    expect(plasmicJson.projects[0].components.length).toEqual(2); // Container+Button
+    // Try syncing non-existent version
+    plasmicJson.projects[0].version = "1.2.10"; // Doesn't exist
+    tmpRepo.writePlasmicJson(plasmicJson);
+    await expect(sync(opts)).rejects.toThrow();
+    // Try syncing existing version
+    plasmicJson.projects[0].version = "2.0.0"; // Doesn't exist
+    tmpRepo.writePlasmicJson(plasmicJson);
+    await expect(sync(opts)).resolves.toBeUndefined();
+    const button = mockApi.stringToMockComponent(
+      tmpRepo.getComponentFileContents("projectId1", "buttonId")
+    );
+    expect(button).toBeTruthy();
+    expect(button?.name).toEqual("Button");
+    expect(button?.version).toEqual("2.0.0");
+  });
+
+  test("syncs according to semver", async () => {
+    opts.projects = ["projectId1"];
+    opts.nonRecursive = true;
+    await expect(sync(opts)).resolves.toBeUndefined();
+    // Change component version server-side
+    const mockProject = mockApi.getMockProject("projectId1", "1.2.3");
+    mockProject.version = "1.10.1";
+    mockApi.addMockProject(mockProject);
+    // Update plasmic.json to use semver
+    const plasmicJson = tmpRepo.readPlasmicJson();
+    expect(plasmicJson.projects.length).toEqual(1);
+    expect(plasmicJson.projects[0].components.length).toEqual(2);
+    plasmicJson.projects[0].version = "^1.2.3";
+    // Try syncing again and see if things show up
+    await expect(sync(opts)).resolves.toBeUndefined();
+    const button = mockApi.stringToMockComponent(
+      tmpRepo.getComponentFileContents("projectId1", "buttonId")
+    );
+    expect(button).toBeTruthy();
+    expect(button?.name).toEqual("Button");
+    expect(button?.version).toEqual("1.10.1");
+  });
+});
+
+describe("recursive-sync", () => {
+  test("non-recursive base case", async () => {
+    // Should sync both Button+Container because of the dependency
+    opts.projects = ["projectId1"];
+    opts.nonRecursive = true;
+    await expect(sync(opts)).resolves.toBeUndefined();
+
+    expectProject1Components();
+
+    expect(tmpRepo.checkFile("./src/DepComponent.tsx")).toBeFalsy();
+
+    expectProject1PlasmicJson();
+  });
+
+  test("dependencies base case", async () => {
+    opts.projects = ["projectId1"];
+    await expect(sync(opts)).resolves.toBeUndefined();
+    expect(tmpRepo.checkFile("./src/Button.tsx")).toBeTruthy();
+    expect(tmpRepo.checkFile("./src/Container.tsx")).toBeTruthy();
+    const depComponent = mockApi.stringToMockComponent(
+      tmpRepo.getComponentFileContents("dependencyId1", "depComponentId")
+    );
+    expect(depComponent).toBeTruthy();
+    expect(depComponent?.name).toEqual("DepComponent");
+    expect(depComponent?.version).toEqual("2.3.4");
+
+    // Check plasmic.json
+    expectProjectAndDepPlasmicJson();
+  });
+});

package/src/actions/auth.ts

@@ -0,0 +1,43 @@
+import { logger } from "../deps";
+import { getCurrentAuth, startAuth } from "../utils/auth-utils";
+import { HandledError } from "../utils/error";
+
+export type AuthArgs = {
+  host: string;
+  baseDir?: string;
+  check?: boolean;
+  email?: boolean;
+};
+
+export async function checkCredentials() {
+  if (await getCurrentAuth()) {
+    logger.info("Plasmic credentials are ok.");
+    return;
+  }
+  throw new HandledError(
+    "The authentication credentials are missing or invalid."
+  );
+}
+
+async function getEmail() {
+  const authCreds = await getCurrentAuth();
+  if (authCreds) {
+    logger.info(authCreds.user);
+    return authCreds.user;
+  }
+  throw new HandledError(
+    "The authentication credentials are missing or invalid."
+  );
+}
+
+export async function auth(args: AuthArgs) {
+  if (args.check) {
+    return checkCredentials();
+  }
+
+  if (args.email) {
+    return getEmail();
+  }
+
+  return startAuth(args);
+}

package/src/actions/fix-imports.ts

@@ -0,0 +1,13 @@
+import { CommonArgs } from "..";
+import { fixAllImportStatements } from "../utils/code-utils";
+import { fixAllFilePaths } from "../utils/file-utils";
+import { getContext } from "../utils/get-context";
+
+export interface FixImportsArgs extends CommonArgs {}
+export async function fixImports(opts: FixImportsArgs) {
+  if (!opts.baseDir) opts.baseDir = process.cwd();
+  const context = await getContext(opts, { enableSkipAuth: true });
+
+  await fixAllFilePaths(context, opts.baseDir);
+  await fixAllImportStatements(context, opts.baseDir);
+}