@slicemachine/init 1.1.9 → 1.1.10-alpha.11

package/src/steps/choose-or-create-a-repository.ts

@@ -1,26 +1,24 @@
 import * as inquirer from "inquirer";
 import Separator from "inquirer/lib/objects/separator";
-import { Utils, Models, CONSTS } from "@slicemachine/core";
-import * as Prismic from "@slicemachine/core/build/prismic";
+import { Models } from "@slicemachine/core";
 import * as NodeUtils from "@slicemachine/core/build/node-utils";
 import { createRepository } from "../utils/create-repo";
-import { logs } from "../utils";
+import { validateRepositoryName } from "../utils/validateRepositoryName";
+import { InitClient, logs } from "../utils";
 
 export const CREATE_REPO = "$_CREATE_REPO"; // not a valid domain name
-const DEFAULT_BASE = CONSTS.DEFAULT_BASE;
 
-export function prettyRepoName(address: URL, value?: string): string {
-  const repoName = value ? logs.cyan(value) : logs.dim.cyan("repo-name");
-  return `${logs.cyan.dim(`${address.protocol}//`)}${repoName}${logs.cyan.dim(
-    `.${address.hostname}`
-  )}`;
+export function prettyRepoName(address: URL, domain: string): string {
+  return `${logs.cyan.dim(`${address.protocol}//`)}${logs.cyan(
+    domain
+  )}${logs.cyan.dim(`.${address.hostname}`)}`;
 }
 
 export async function promptForRepoDomain(
-  base: string,
+  client: InitClient,
   defaultValue?: string
 ): Promise<string> {
-  const address = new URL(base);
+  const address = new URL(client.apisEndpoints.Wroom);
 
   logs.writeInfo(
     "The name acts as a domain/endpoint for your content repo and should be completely unique."
@@ -34,16 +32,9 @@ export async function promptForRepoDomain(
         type: "input",
         required: true,
         default: defaultValue,
-        transformer: (value: string) =>
-          prettyRepoName(address, value || defaultValue),
-        async validate(name: string) {
-          const result = await Prismic.Communication.validateRepositoryName(
-            name,
-            base,
-            false
-          );
-          return result === name || result;
-        },
+        transformer: (value: string | undefined) =>
+          prettyRepoName(address, value || defaultValue || "repository"),
+        validate: (name: string) => validateRepositoryName(client, name),
       },
     ])
     .then((res) => res.repoDomain);
@@ -122,47 +113,57 @@ export function sortReposForPrompt(
 }
 
 export async function chooseOrCreateARepository(
+  client: InitClient,
   cwd: string,
   framework: Models.Frameworks,
-  cookies: string,
-  base = DEFAULT_BASE,
-  domain?: string
+  preSelectedRepository?: string
 ): Promise<string> {
-  const token = Utils.Cookie.parsePrismicAuthToken(cookies);
-  const repos = await Prismic.Communication.listRepositories(token, base);
-
-  const hasRepo = domain && repos.find((d) => d.domain === domain);
-  if (hasRepo) return domain;
-
-  if (repos.length === 0) {
-    const domainName = await promptForRepoDomain(base, domain);
-    return await createRepository(domainName, framework, cookies, base);
+  const repositories: Models.Repository[] = await client.listRepositories();
+
+  const isPreSelectedValid =
+    preSelectedRepository &&
+    repositories.find(
+      (repository) => repository.domain === preSelectedRepository
+    );
+  if (isPreSelectedValid) return preSelectedRepository;
+
+  // No repository to display, ask for a new repository name to create it.
+  if (repositories.length === 0) {
+    const domainName = await promptForRepoDomain(client, preSelectedRepository);
+    await createRepository(client, domainName, framework);
+    return domainName;
   }
 
-  const choices = sortReposForPrompt(repos, base, cwd);
-
+  // prepare the list of repositories to display
+  const choices = sortReposForPrompt(
+    repositories,
+    client.apisEndpoints.Wroom,
+    cwd
+  );
   const numberOfDisabledRepos = choices.filter((repo) => {
     if (repo instanceof Separator) return false;
     return repo.disabled;
   }).length;
 
-  const res = await inquirer.prompt<{ chosenRepo: string }>([
+  // display the list of repositories and wait for the user to choose one.
+  const promptResult = await inquirer.prompt<{ chosenRepository: string }>([
     {
       type: "list",
-      name: "chosenRepo",
+      name: "chosenRepository",
       default: 0,
       required: true,
       message: "Connect a Prismic Repository or create a new one",
       choices,
       pageSize: numberOfDisabledRepos + 2 <= 7 ? 7 : numberOfDisabledRepos + 2,
-      // loop: false
     },
   ]);
 
-  if (res.chosenRepo === CREATE_REPO) {
-    const domainName = await promptForRepoDomain(base, domain);
-    return await createRepository(domainName, framework, cookies, base);
+  // If the user has chosen to create a new repository.
+  if (promptResult.chosenRepository === CREATE_REPO) {
+    const domainName = await promptForRepoDomain(client, preSelectedRepository);
+    await createRepository(client, domainName, framework);
+    return domainName;
   }
 
-  return res.chosenRepo;
+  return promptResult.chosenRepository;
 }

package/src/steps/configure-project.ts

@@ -3,23 +3,22 @@ import type { Models } from "@slicemachine/core";
 import * as Prismic from "@slicemachine/core/build/prismic";
 import * as NodeUtils from "@slicemachine/core/build/node-utils";
 import { FrameworkResult } from "./detect-framework";
-import { logs } from "../utils";
+import { InitClient, logs } from "../utils";
 import Tracker from "../utils/tracker";
 
-type Base = Prismic.Endpoints.Base;
-
 const defaultSliceMachineVersion = "0.0.41";
 
 export async function configureProject(
+  client: InitClient,
   cwd: string,
-  base: Base,
   repositoryDomainName: string,
   framework: FrameworkResult,
   sliceLibPath: string[] = [],
   tracking = true
 ): Promise<void> {
+  const frameworkName = NodeUtils.Framework.fancyName(framework.value);
   const spinner = logs.spinner(
-    `Configuring your ${framework.value} & Prismic project...`
+    `Configuring your ${frameworkName} and Prismic project...`
   );
   spinner.start();
 
@@ -32,15 +31,22 @@ export async function configureProject(
 
     const manifestAlreadyExistWithContent = manifest.exists && manifest.content;
 
+    const libs =
+      manifest.content &&
+      manifest.content.libraries &&
+      manifest.content.libraries.length > 0
+        ? manifest.content.libraries
+        : ["@/slices"];
+
     const manifestUpdated: Models.Manifest = {
       ...(manifestAlreadyExistWithContent
         ? manifest.content
         : { _latest: sliceMachineVersionInstalled }),
       apiEndpoint: Prismic.Endpoints.buildRepositoryEndpoint(
-        base,
+        client.apisEndpoints.Wroom,
         repositoryDomainName
       ),
-      libraries: ["@/slices", ...sliceLibPath],
+      libraries: [...libs, ...sliceLibPath], // odd case here for staters
       ...(framework.manuallyAdded ? { framework: framework.value } : {}),
       ...(!tracking ? { tracking } : {}),
     };
@@ -52,7 +58,10 @@ export async function configureProject(
     const pathToSlicesFolder = NodeUtils.CustomPaths(cwd)
       .library("slices")
       .value();
-    if (!NodeUtils.Files.exists(pathToSlicesFolder)) {
+    if (
+      !NodeUtils.Files.exists(pathToSlicesFolder) &&
+      libs.includes("@/slices")
+    ) {
       NodeUtils.Files.mkdir(pathToSlicesFolder, { recursive: true });
     }
 

package/src/steps/display-final-message.ts

@@ -2,11 +2,30 @@ import { CONSTS } from "@slicemachine/core";
 import * as NodeUtils from "@slicemachine/core/build/node-utils";
 import { logs } from "../utils";
 
-export function displayFinalMessage(cwd: string): void {
+export function displayFinalMessage(
+  cwd: string,
+  wasStarter: boolean,
+  reponame: string,
+  base: string
+): void {
   const yarnLock = NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd));
   const command = `${yarnLock ? "yarn" : "npm"} run ${CONSTS.SCRIPT_NAME}`;
+  console.log();
 
-  console.log(
-    `${logs.white("■")} Run ${logs.purple(command)} to now launch Slice Machine`
-  );
+  if (wasStarter) {
+    const repoUrl = new URL(base);
+    repoUrl.hostname = `${reponame}.${repoUrl.hostname}`;
+    const urlAsString = repoUrl.toString();
+
+    const message = `${logs.white(
+      "■"
+    )} Start editing your content in Prismic ${logs.purple(urlAsString)}`;
+    console.log(message);
+  } else {
+    console.log(
+      `${logs.white("■")} Run ${logs.purple(
+        command
+      )} to launch Slice Machine and create your first Custom Type`
+    );
+  }
 }

package/src/steps/index.ts

@@ -6,3 +6,4 @@ export { loginOrBypass } from "./loginOrBypass";
 export { configureProject } from "./configure-project";
 export { displayFinalMessage } from "./display-final-message";
 export { installLib } from "./install-lib";
+export { sendStarterData } from "./sendStarterData";

package/src/steps/install-required-dependencies.ts

@@ -32,18 +32,14 @@ function depsForFramework(framework: Models.Frameworks): string {
   }
 }
 
-export async function installRequiredDependencies(
-  cwd: string,
-  framework: Models.Frameworks
-): Promise<void> {
-  const yarnLock = NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd));
-  const installDevDependencyCommand = yarnLock
+async function addAndInstallDeps(
+  framework: Models.Frameworks,
+  useYarn = false
+): Promise<string> {
+  const installDevDependencyCommand = useYarn
     ? "yarn add -D"
     : "npm install --save-dev";
-  const installDependencyCommand = yarnLock ? "yarn add" : "npm install --save";
-
-  const spinner = logs.spinner("Downloading Slice Machine");
-  spinner.start();
+  const installDependencyCommand = useYarn ? "yarn add" : "npm install --save";
 
   const { stderr } = await execCommand(
     `${installDevDependencyCommand} ${SM_PACKAGE_NAME}`
@@ -52,6 +48,29 @@ export async function installRequiredDependencies(
   const deps = depsForFramework(framework);
   if (deps) await execCommand(`${installDependencyCommand} ${deps}`);
 
+  return stderr;
+}
+
+async function installDeps(useYarn = false): Promise<string> {
+  const installCommand = useYarn ? "yarn" : "npm install";
+  const { stderr } = await execCommand(installCommand);
+  return stderr;
+}
+
+export async function installRequiredDependencies(
+  cwd: string,
+  framework: Models.Frameworks,
+  skipDependencies: boolean
+): Promise<void> {
+  const yarnLock = NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd));
+
+  const spinner = logs.spinner("Installing Slice Machine");
+  spinner.start();
+
+  const stderr = await (skipDependencies
+    ? installDeps(yarnLock)
+    : addAndInstallDeps(framework, yarnLock));
+
   const pathToPkg = path.join(
     NodeUtils.PackagePaths(cwd).value(),
     SM_PACKAGE_NAME

package/src/steps/loginOrBypass.ts

@@ -1,21 +1,25 @@
 import { Models } from "@slicemachine/core";
-import { validateSessionAndGetProfile } from "../utils/communication";
-import { logs, Auth } from "../utils";
+import { PrismicSharedConfigManager } from "@slicemachine/core/build/prismic";
+import { logs, Auth, InitClient } from "../utils";
+
+export async function loginOrBypass(
+  client: InitClient
+): Promise<Models.UserProfile> {
+  const user: Models.UserProfile | null = await client
+    .profile()
+    .catch(() => null);
 
-export async function loginOrBypass(base: string): Promise<{
-  info: Models.UserInfo;
-  profile: Models.UserProfile | null;
-} | null> {
-  const user = await validateSessionAndGetProfile(base).catch((err) =>
-    console.log(err)
-  );
   if (user) {
-    const email = user.info.email;
+    const email = user.email;
     logs.writeCheck(`Logged in as ${logs.bold(email)}`);
     return user;
-  } else {
-    await Auth.login(base);
-    const user = await validateSessionAndGetProfile(base);
-    return user;
   }
+
+  await Auth.login(client);
+
+  // update token used to make calls.
+  client.updateAuthenticationToken(PrismicSharedConfigManager.getAuth());
+
+  const userAfterLogin: Models.UserProfile = await client.profile();
+  return userAfterLogin;
 }

package/src/steps/sendStarterData.ts

@@ -0,0 +1,31 @@
+import { retrieveManifest, Files } from "@slicemachine/core/build/node-utils";
+import path from "path";
+import fs from "fs";
+import { sendSlices } from "./starters/slices";
+import { sendCustomTypes } from "./starters/custom-types";
+import { sendDocuments } from "./starters/documents";
+import { InitClient } from "../utils";
+
+export async function sendStarterData(
+  client: InitClient,
+  cwd: string,
+  pushDocuments = true
+) {
+  const manifest = retrieveManifest(cwd);
+  const documentsPath = path.join(cwd, "documents");
+  const hasDocuments = Files.exists(documentsPath);
+
+  if (manifest.exists === false || hasDocuments === false)
+    return Promise.resolve(false);
+
+  if (manifest.content) await sendSlices(client, cwd, manifest.content);
+  await sendCustomTypes(client, cwd);
+
+  // If the user choose not to push documents, we still delete the documents folder.
+  if (!pushDocuments) {
+    fs.rmSync(documentsPath, { recursive: true, force: true });
+    return Promise.resolve(true);
+  }
+
+  return sendDocuments(client, cwd);
+}

package/src/steps/starters/custom-types.ts

@@ -0,0 +1,81 @@
+import { CustomType } from "@prismicio/types-internal/lib/customtypes";
+import { Files, CustomTypesPaths } from "@slicemachine/core/build/node-utils";
+import { isLeft } from "fp-ts/lib/Either";
+import { promptToPushCustomTypes } from "./prompts";
+import { InitClient, logs } from "../../utils";
+import { ClientError } from "@slicemachine/client";
+
+export function readLocalCustomTypes(cwd: string): Array<CustomType> {
+  const customTypePaths = CustomTypesPaths(cwd);
+  const dir = customTypePaths.value();
+
+  if (Files.isDirectory(dir) === false) return [];
+
+  const fileNames = Files.readDirectory(dir);
+
+  const files = fileNames.reduce<Array<CustomType>>((acc, fileName) => {
+    const filePath = customTypePaths.customType(fileName).model();
+    const json = Files.safeReadJson(filePath);
+
+    if (!json) return acc;
+
+    const file = CustomType.decode(json);
+
+    if (file instanceof Error) {
+      logs.writeError(`reading ${filePath}: ${file.message}`);
+      return acc;
+    }
+    if (isLeft(file)) {
+      logs.writeError(`validating ${filePath}: ${JSON.stringify(file.left)}`);
+      return acc;
+    }
+
+    return [...acc, file.right];
+  }, []);
+
+  return files;
+}
+
+export async function sendCustomTypes(client: InitClient, cwd: string) {
+  const localCustomTypes = readLocalCustomTypes(cwd);
+
+  // nothing to push
+  if (localCustomTypes.length === 0) return Promise.resolve(false);
+
+  const remoteCustomTypeIds = await client
+    .getCustomTypes()
+    .then((customTypes) => customTypes.map((customType) => customType.id));
+
+  if (remoteCustomTypeIds.length) {
+    const shouldPush = await promptToPushCustomTypes();
+    if (shouldPush === false) return Promise.resolve(false);
+  }
+
+  const spinner = logs.spinner(
+    "Pushing existing custom types to your repository"
+  );
+  spinner.start();
+
+  await Promise.all(
+    localCustomTypes.map(async (customType) => {
+      const promise = remoteCustomTypeIds.includes(customType.id)
+        ? client.updateCustomType(customType)
+        : client.insertCustomType(customType);
+
+      return promise.catch((error: ClientError) => {
+        logs.writeError(
+          `Sending custom type ${customType.id} - ${error.message}`
+        );
+
+        // throwing the error again to stop the Promise.all
+        throw error;
+      });
+    })
+  ).catch(() => {
+    // the error about the custom type that failed to be pushed should be in the terminal already.
+    process.exit(1);
+  });
+
+  spinner.succeed();
+  return Promise.resolve(true);
+}

package/src/steps/starters/documents.ts

@@ -0,0 +1,89 @@
+import path from "path";
+import fs from "fs";
+import type { AxiosError } from "axios";
+
+import * as t from "io-ts";
+import { getOrElseW } from "fp-ts/Either";
+import { InitClient, logs, lsdir, lsfiles } from "../../utils";
+import { PrismicSharedConfigManager } from "@slicemachine/core/build/prismic/SharedConfig";
+
+const SignatureFileReader = t.type({
+  signature: t.string,
+});
+
+type SignatureFile = t.TypeOf<typeof SignatureFileReader>;
+
+export async function readSignatureFile(cwd: string): Promise<SignatureFile> {
+  const pathToFile = path.join(cwd, "documents", "index.json");
+  return fs.promises.readFile(pathToFile, "utf-8").then((res) => {
+    const data = JSON.parse(res) as unknown;
+    return getOrElseW(() => {
+      throw new Error("Unable to read document signature file");
+    })(SignatureFileReader.decode(data));
+  });
+}
+
+export async function readDocuments(
+  cwd: string
+): Promise<Record<string, unknown>> {
+  const documentDir = path.join(cwd, "documents");
+  const dirs = await lsdir(documentDir);
+
+  const files = (await Promise.all(dirs.map((dir) => lsfiles(dir)))).flat();
+
+  const documentObj = files.reduce<Record<string, unknown>>((acc, file) => {
+    const filename: string = path.parse(file).name;
+    const fileContent: string = fs.readFileSync(file, "utf-8");
+    const json = JSON.parse(fileContent) as Record<string, unknown>;
+
+    return { ...acc, [filename]: json };
+  }, {});
+
+  return documentObj;
+}
+
+export async function sendDocuments(
+  client: InitClient,
+  cwd: string
+): Promise<boolean> {
+  const pathToDocuments = path.join(cwd, "documents");
+  const pathToSignatureFile = path.join(pathToDocuments, "index.json");
+
+  // Without the signature, we can't push documents to Prismic.
+  if (!fs.existsSync(pathToSignatureFile)) return Promise.resolve(false);
+
+  const signatureObj = await readSignatureFile(cwd);
+  const documents: Record<string, unknown> = await readDocuments(cwd);
+
+  // No documents to push
+  if (Object.keys(documents).length === 0) return Promise.resolve(false);
+
+  const spinner = logs.spinner("Pushing existing documents to your repository");
+  spinner.start();
+
+  return client
+    .pushDocuments(
+      signatureObj.signature,
+      documents,
+      PrismicSharedConfigManager.get().cookies
+    )
+    .then(() => {
+      spinner.succeed();
+      fs.rmSync(pathToDocuments, { recursive: true, force: true });
+      return true;
+    })
+    .catch((e: AxiosError) => {
+      spinner.fail();
+      if (e.response?.data === "Repository should not contain documents") {
+        logs.writeError(
+          "The selected repository is not empty, documents cannot be uploaded. Please choose an empty repository or delete the documents contained in your repository."
+        );
+      } else {
+        logs.writeError(
+          "Sending documents failed, please try again. If the problem persists, contact us."
+        );
+        logs.writeError(`Full error: ${e.code || 500} - ${e.message}`);
+      }
+      process.exit(1);
+    });
+}

package/src/steps/starters/prompts.ts

@@ -0,0 +1,29 @@
+import inquirer from "inquirer";
+
+export async function promptToPushSlices(): Promise<boolean> {
+  return inquirer
+    .prompt<{ pushSlices: boolean }>([
+      {
+        type: "confirm",
+        name: "pushSlices",
+        default: false,
+        message:
+          "Your repository already contains Slices. Do you want to continue pushing your local Slices?",
+      },
+    ])
+    .then((res) => res.pushSlices);
+}
+
+export async function promptToPushCustomTypes(): Promise<boolean> {
+  return inquirer
+    .prompt<{ pushCustomTypes: boolean }>([
+      {
+        type: "confirm",
+        name: "pushCustomTypes",
+        default: false,
+        message:
+          "Your repository already contains Custom Types. Do you want to continue pushing your local Custom Types?",
+      },
+    ])
+    .then((res) => res.pushCustomTypes);
+}

package/src/steps/starters/s3.ts

@@ -0,0 +1,70 @@
+import { InitClient } from "../../utils";
+import {
+  Component,
+  ComponentInfo,
+  VariationSM,
+  SliceSM,
+} from "@slicemachine/core/build/models";
+import { Acl, ClientError } from "@slicemachine/client";
+import { writeError } from "../../utils/logs";
+
+async function updateVariationWithScreenshot(
+  client: InitClient,
+  acl: Acl,
+  screenshotPaths: ComponentInfo["screenshotPaths"],
+  sliceName: SliceSM["id"],
+  variation: VariationSM
+): Promise<VariationSM> {
+  const screenshot = screenshotPaths[variation.id];
+  if (!screenshot || !screenshot.path) return Promise.resolve(variation);
+
+  return client
+    .uploadScreenshot({
+      acl,
+      sliceName,
+      variationId: variation.id,
+      filePath: screenshot.path,
+    })
+    .then((screenshotUrl) => {
+      return {
+        ...variation,
+        imageUrl: screenshotUrl,
+      };
+    })
+    .catch((error: ClientError) => {
+      writeError(
+        `Couldn't upload screenshot slice: ${sliceName} - variation: ${variation.id}`
+      );
+      writeError(error.message, "Full error:");
+      return variation;
+    });
+}
+
+export async function updateSlicesWithScreenshots(
+  client: InitClient,
+  acl: Acl,
+  components: Array<Component>
+): Promise<Array<SliceSM>> {
+  return Promise.all(
+    components.map(async (component) => {
+      const { screenshotPaths, model } = component;
+
+      const variationsUpdated: VariationSM[] = await Promise.all(
+        model.variations.map(async (variation) =>
+          updateVariationWithScreenshot(
+            client,
+            acl,
+            screenshotPaths,
+            model.id,
+            variation
+          )
+        )
+      );
+
+      return {
+        ...model,
+        variations: variationsUpdated,
+      };
+    })
+  );
+}