@slicemachine/init 1.1.10-alpha.5 → 1.1.11-alpha.2

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,29 @@ import {
   installLib,
   sendStarterData,
 } from "./steps";
-import { findArgument, logs, findFlag } from "./utils";
+import {
+  findArgument,
+  findFlag,
+  logs,
+  getApplicationMode,
+  InitClient,
+} from "./utils";
+import { Models } from "@slicemachine/core";
 
 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 +42,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 +61,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,14 +98,18 @@ async function init() {
   await installRequiredDependencies(cwd, frameworkResult.value, wasStarter);
 
   // Ask the user to run slice-machine.
-  displayFinalMessage(cwd, wasStarter, repositoryDomainName, config.base);
+  displayFinalMessage(cwd, wasStarter, repository, client.apisEndpoints.Wroom);
 }
 
 init()
   .then(() => {
     process.exit(0);
   })
-  .catch((error) => {
+  .catch(async (error) => {
     if (error instanceof Error) logs.writeError(error.message);
     else console.error(error);
+    await Tracker.get().trackInitEndFail(
+      Models.Frameworks.none,
+      "Failed to initialise Slice Machine."
+    );
   });

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
@@ -70,10 +68,14 @@ export async function configureProject(
     // add slicemachine script to package.json.
     NodeUtils.addJsonPackageSmScript(cwd);
 
-    await Tracker.get().trackInitDone(framework.value);
+    await Tracker.get().trackInitEndSuccess(framework.value);
 
     spinner.succeed("Project configured! Ready to start");
-  } catch {
+  } catch (error) {
+    await Tracker.get().trackInitEndFail(
+      framework.value,
+      "Failed to configure Slice Machine"
+    );
     spinner.fail("Failed to configure Slice Machine");
     process.exit(-1);
   }

package/src/steps/detect-framework.ts

@@ -2,6 +2,7 @@ import { Models } from "@slicemachine/core";
 import * as NodeUtils from "@slicemachine/core/build/node-utils";
 import * as inquirer from "inquirer";
 import { logs } from "../utils";
+import Tracker from "../utils/tracker";
 
 export type FrameworkResult = {
   value: Models.Frameworks;
@@ -80,7 +81,10 @@ export async function detectFramework(cwd: string): Promise<FrameworkResult> {
     } else {
       console.log(failMessage);
     }
-
+    await Tracker.get().trackInitEndFail(
+      Models.Frameworks.none,
+      "Framework not detected"
+    );
     process.exit(1);
   }
 }

package/src/steps/install-lib.ts

@@ -107,6 +107,10 @@ export async function installLib(
     if (error instanceof Error) {
       console.error(error.message);
     }
+    await Tracker.get().trackInitEndFail(
+      Models.Frameworks.none,
+      "Failed to install ${libGithubPath} library"
+    );
     process.exit(-1);
   }
 }

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);
 }