@slicemachine/init 1.1.10-alpha.3 → 1.1.10

package/src/index.ts

@@ -1,4 +1,4 @@
-import { CONSTS } from "@slicemachine/core";
+import { ApplicationMode } from "@slicemachine/client";
 import Prismic from "@slicemachine/core/build/prismic";
 import Tracker from "./utils/tracker";
 import {
@@ -12,17 +12,28 @@ import {
   installLib,
   sendStarterData,
 } from "./steps";
-import { findArgument, logs, findFlag } from "./utils";
+import {
+  findArgument,
+  findFlag,
+  logs,
+  getApplicationMode,
+  InitClient,
+} from "./utils";
 
 async function init() {
   const cwd = findArgument(process.argv, "cwd") || process.cwd();
-  const base = findArgument(process.argv, "base") || CONSTS.DEFAULT_BASE;
+  const mode: ApplicationMode =
+    getApplicationMode(findArgument(process.argv, "mode")) ||
+    ApplicationMode.PROD;
   const lib: string | undefined = findArgument(process.argv, "library");
   const branch: string | undefined = findArgument(process.argv, "branch");
-  const isTrackingAvailable =
+  const isTrackingAvailable: boolean =
     findArgument(process.argv, "tracking") !== "false";
-  const maybeRepositorySubdomain = findArgument(process.argv, "repository");
-  const sendDocs = findFlag(process.argv, "no-docs");
+  const preSelectedRepository: string | undefined = findArgument(
+    process.argv,
+    "repository"
+  );
+  const pushDocuments = !findFlag(process.argv, "no-docs");
 
   Tracker.get().initialize(
     process.env.PUBLIC_SM_INIT_SEGMENT_KEY ||
@@ -30,7 +41,14 @@ async function init() {
     isTrackingAvailable
   );
 
-  void Tracker.get().trackInitStart(maybeRepositorySubdomain);
+  void Tracker.get().trackInitStart(preSelectedRepository);
+
+  // initializing the client with what we have for now.
+  const client = new InitClient(
+    mode,
+    null,
+    Prismic.PrismicSharedConfigManager.getAuth()
+  );
 
   console.log(
     logs.purple(
@@ -42,48 +60,34 @@ async function init() {
   validatePkg(cwd);
 
   // login
-  const user = await loginOrBypass(base);
-  if (!user) throw new Error("The user should be logged in!");
-
-  // If we get the info from the profile we want to identify all the previous events sent or continue in anonymous mode
-  if (user.profile) {
-    Tracker.get().identifyUser(user.profile.shortId, user.profile.intercomHash);
-  }
+  const user = await loginOrBypass(client);
 
+  Tracker.get().identifyUser(user.shortId, user.intercomHash);
   void Tracker.get().trackInitIdentify();
 
-  // retrieve tokens for api calls
-  const config = Prismic.PrismicSharedConfigManager.get();
-
   // detect the framework used by the project
   const frameworkResult = await detectFramework(cwd);
 
   // select the repository used with the project.
-  const repositoryDomainName = await chooseOrCreateARepository(
+  const repository = await chooseOrCreateARepository(
+    client,
     cwd,
     frameworkResult.value,
-    config.cookies,
-    config.base,
-    maybeRepositorySubdomain
+    preSelectedRepository
   );
 
-  Tracker.get().setRepository(repositoryDomainName);
+  Tracker.get().setRepository(repository);
+  client.updateRepository(repository);
 
   const sliceLibPath = lib ? await installLib(cwd, lib, branch) : undefined;
 
-  const wasStarter = await sendStarterData(
-    repositoryDomainName,
-    config.base,
-    config.cookies,
-    sendDocs,
-    cwd
-  ); // will be false if no sm.json is found
+  const wasStarter = await sendStarterData(client, cwd, pushDocuments); // will be false if no sm.json is found
 
   // configure the SM.json file and the json package file of the project..
   await configureProject(
+    client,
     cwd,
-    base,
-    repositoryDomainName,
+    repository,
     frameworkResult,
     sliceLibPath,
     isTrackingAvailable
@@ -93,7 +97,7 @@ async function init() {
   await installRequiredDependencies(cwd, frameworkResult.value, wasStarter);
 
   // Ask the user to run slice-machine.
-  displayFinalMessage(cwd);
+  displayFinalMessage(cwd, wasStarter, repository, client.apisEndpoints.Wroom);
 }
 
 init()

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,16 +3,14 @@ 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[] = [],
@@ -45,7 +43,7 @@ export async function configureProject(
         ? manifest.content
         : { _latest: sliceMachineVersionInstalled }),
       apiEndpoint: Prismic.Endpoints.buildRepositoryEndpoint(
-        base,
+        client.apisEndpoints.Wroom,
         repositoryDomainName
       ),
       libraries: [...libs, ...sliceLibPath], // odd case here for staters

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

@@ -2,12 +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 start 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/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

@@ -1,43 +1,31 @@
-import { parsePrismicAuthToken } from "@slicemachine/core/build/utils/cookie";
 import { retrieveManifest, Files } from "@slicemachine/core/build/node-utils";
 import path from "path";
-import { sendSlicesFromStarter } from "./starters/slices";
-import { sendCustomTypesFromStarter } from "./starters/custom-types";
-import { sendDocumentsFromStarter } from "./starters/documents";
 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(
-  repository: string,
-  base: string,
-  cookies: string,
-  sendDocs = true,
-  cwd: string
-): Promise<boolean> {
-  const smJson = retrieveManifest(cwd);
-  const pathToDocuments = path.join(cwd, "documents");
-  const hasDocuments = Files.exists(pathToDocuments);
+  client: InitClient,
+  cwd: string,
+  pushDocuments = true
+) {
+  const manifest = retrieveManifest(cwd);
+  const documentsPath = path.join(cwd, "documents");
+  const hasDocuments = Files.exists(documentsPath);
 
-  if (smJson.exists === false || hasDocuments === false)
+  if (manifest.exists === false || hasDocuments === false)
     return Promise.resolve(false);
 
-  const authTokenFromCookie = parsePrismicAuthToken(cookies);
+  if (manifest.content) await sendSlices(client, cwd, manifest.content);
+  await sendCustomTypes(client, cwd);
 
-  if (smJson.content && smJson.content.libraries) {
-    await sendSlicesFromStarter(
-      base,
-      repository,
-      authTokenFromCookie,
-      smJson.content.libraries,
-      cwd
-    );
-  }
-
-  await sendCustomTypesFromStarter(repository, authTokenFromCookie, base, cwd);
-
-  if (sendDocs === false) {
-    fs.rmSync(pathToDocuments, { recursive: true, force: true });
+  // 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 sendDocumentsFromStarter(repository, cookies, base, cwd);
+  return sendDocuments(client, cwd);
 }

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

@@ -1,15 +1,11 @@
 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 {
-  getRemoteCustomTypeIds,
-  sendManyCustomTypesToPrismic,
-} from "./communication";
 import { promptToPushCustomTypes } from "./prompts";
-import { getEndpointsFromBase } from "./endpoints";
-import { logs } from "../../utils";
+import { InitClient, logs } from "../../utils";
+import { ClientError } from "@slicemachine/client";
 
-export function readCustomTypes(cwd: string): Array<CustomType> {
+export function readLocalCustomTypes(cwd: string): Array<CustomType> {
   const customTypePaths = CustomTypesPaths(cwd);
   const dir = customTypePaths.value();
 
@@ -40,23 +36,15 @@ export function readCustomTypes(cwd: string): Array<CustomType> {
   return files;
 }
 
-export async function sendCustomTypesFromStarter(
-  repository: string,
-  authorization: string,
-  base: string,
-  cwd: string
-) {
-  const customTypeApiEndpoint = getEndpointsFromBase(base).Models;
+export async function sendCustomTypes(client: InitClient, cwd: string) {
+  const localCustomTypes = readLocalCustomTypes(cwd);
 
-  const customTypes = readCustomTypes(cwd);
+  // nothing to push
+  if (localCustomTypes.length === 0) return Promise.resolve(false);
 
-  if (customTypes.length === 0) return Promise.resolve(false);
-
-  const remoteCustomTypeIds = await getRemoteCustomTypeIds(
-    customTypeApiEndpoint,
-    repository,
-    authorization
-  );
+  const remoteCustomTypeIds = await client
+    .getCustomTypes()
+    .then((customTypes) => customTypes.map((customType) => customType.id));
 
   if (remoteCustomTypeIds.length) {
     const shouldPush = await promptToPushCustomTypes();
@@ -68,15 +56,26 @@ export async function sendCustomTypesFromStarter(
   );
   spinner.start();
 
-  await sendManyCustomTypesToPrismic(
-    repository,
-    authorization,
-    customTypeApiEndpoint,
-    remoteCustomTypeIds,
-    customTypes
-  );
+  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

@@ -1,11 +1,11 @@
 import path from "path";
 import fs from "fs";
-import axios, { AxiosError } from "axios";
+import type { AxiosError } from "axios";
 
 import * as t from "io-ts";
 import { getOrElseW } from "fp-ts/Either";
-import { handleErrors } from "./communication";
-import { logs } from "../../utils";
+import { InitClient, logs, lsdir, lsfiles } from "../../utils";
+import { PrismicSharedConfigManager } from "@slicemachine/core/build/prismic/SharedConfig";
 
 const SignatureFileReader = t.type({
   signature: t.string,
@@ -23,74 +23,50 @@ export async function readSignatureFile(cwd: string): Promise<SignatureFile> {
   });
 }
 
-async function lsdir(dir: string): Promise<Array<string>> {
-  return fs.promises.readdir(dir).then((dirs) => {
-    return dirs
-      .filter((name) => fs.statSync(path.join(dir, name)).isDirectory())
-      .map((subdirectory) => path.join(dir, subdirectory));
-  });
-}
-
-async function lsfiles(dir: string): Promise<Array<string>> {
-  return fs.promises.readdir(dir).then((dirs) => {
-    return dirs
-      .filter((name) => fs.statSync(path.join(dir, name)).isFile())
-      .map((file) => path.join(dir, file));
-  });
-}
-
-export async function readDocuments(cwd: string) {
+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 fileContent = fs.readFileSync(file, "utf-8");
-    const filename = path.parse(file).name;
-    acc[filename] = JSON.parse(fileContent);
-    return acc;
+    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 JSON.stringify(documentObj);
+  return documentObj;
 }
 
-export const sendDocumentsFromStarter = async (
-  repository: string,
-  cookies: string,
-  base: string,
+export async function sendDocuments(
+  client: InitClient,
   cwd: string
-): Promise<boolean> => {
+): Promise<boolean> {
   const pathToDocuments = path.join(cwd, "documents");
   const pathToSignatureFile = path.join(pathToDocuments, "index.json");
 
-  if (!fs.existsSync(pathToSignatureFile)) {
-    return Promise.resolve(false);
-  }
+  // Without the signature, we can't push documents to Prismic.
+  if (!fs.existsSync(pathToSignatureFile)) return Promise.resolve(false);
 
   const signatureObj = await readSignatureFile(cwd);
-  const documentsStr = await readDocuments(cwd);
-
-  const payload = {
-    signature: signatureObj.signature,
-    documents: documentsStr,
-  };
+  const documents: Record<string, unknown> = await readDocuments(cwd);
 
-  const prismicUrl = new URL(base);
-  prismicUrl.hostname = `${repository}.${prismicUrl.hostname}`;
-  prismicUrl.pathname = "starter/documents";
-  const endpointURL = prismicUrl.toString();
+  // 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 axios
-    .post(endpointURL, payload, {
-      headers: {
-        "User-Agent": "prismic-cli/0",
-        Cookie: cookies,
-      },
-    })
+  return client
+    .pushDocuments(
+      signatureObj.signature,
+      documents,
+      PrismicSharedConfigManager.get().cookies
+    )
     .then(() => {
       spinner.succeed();
       fs.rmSync(pathToDocuments, { recursive: true, force: true });
@@ -103,12 +79,11 @@ export const sendDocumentsFromStarter = async (
           "The selected repository is not empty, documents cannot be uploaded. Please choose an empty repository or delete the documents contained in your repository."
         );
       } else {
-        handleErrors(
-          "sending documents, please try again. If the problem persists, contact us.",
-          e
+        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

@@ -22,7 +22,7 @@ export async function promptToPushCustomTypes(): Promise<boolean> {
         name: "pushCustomTypes",
         default: false,
         message:
-          "Your repository already contains Custom Types. Do you want to continue pushing your local Slices?",
+          "Your repository already contains Custom Types. Do you want to continue pushing your local Custom Types?",
       },
     ])
     .then((res) => res.pushCustomTypes);