@slicemachine/init 1.1.10-alpha.1 → 1.1.10-alpha.10

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,32 +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 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,
-  cwd: string
+  client: InitClient,
+  cwd: string,
+  pushDocuments = true
 ) {
-  const smJson = retrieveManifest(cwd);
-  const hasDocuments = Files.exists(path.join(cwd, "documents"));
+  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
-    );
+  // 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 sendCustomTypesFromStarter(repository, authTokenFromCookie, 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

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