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

package/src/steps/starters/documents.ts

@@ -1,11 +1,13 @@
 import path from "path";
 import fs from "fs";
-import axios, { AxiosError } from "axios";
+import type { AxiosError } from "axios";
+import { Models } from "@slicemachine/core";
 
 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";
+import Tracker from "../../utils/tracker";
 
 const SignatureFileReader = t.type({
   signature: t.string,
@@ -23,92 +25,71 @@ 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 });
       return true;
     })
-    .catch((e: AxiosError) => {
+    .catch(async (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 {
-        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}`);
       }
-
+      await Tracker.get().trackInitEndFail(
+        Models.Frameworks.none,
+        "Failed to push documents"
+      );
       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);

package/src/steps/starters/s3.ts

@@ -1,201 +1,70 @@
-import fs from "fs";
-import axios from "axios";
-import mime from "mime";
-import snakeCase from "lodash.snakecase";
-import path from "path";
-import FormData from "form-data";
-import uniqid from "uniqid";
-import { logs } from "../../utils";
+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";
 
-export type ALC = {
-  values: {
-    url: string;
-    fields: Record<string, string>;
-  };
-  imgixEndpoint: string;
-  err: null | string;
-};
-
-export async function createAcl(
-  address: string,
-  repository: string,
-  authorization: string
-): Promise<ALC> {
-  return axios
-    .get<ALC>(address + "create", {
-      headers: {
-        repository,
-        Authorization: `Bearer ${authorization}`,
-        "User-Agent": "slice-machine",
-      },
-    })
-    .then((res) => res.data);
-}
-
-async function createFormForS3(
-  key: string,
-  filename: string,
-  filePath: string,
-  acl: ALC
-): Promise<FormData | null> {
-  const form = new FormData();
-  Object.entries(acl.values.fields).forEach(([k, value]) => {
-    form.append(k, value);
-  });
-  form.append("key", key);
-  const contentType = mime.getType(filePath);
-  contentType && form.append("Content-Type", contentType);
-
-  return fs.promises
-    .readFile(filePath)
-    .then((file) => {
-      form.append("file", file, { filename });
-      return form;
-    })
-    .catch(() => {
-      logs.writeError(`Error reading preview image: ${filename}`);
-      return null;
-    });
-}
-
-function createS3Key(
-  repository: string,
-  sliceName: string,
-  variationId: string,
-  filename: string
-): string {
-  return `${repository}/shared-slices/${snakeCase(sliceName)}/${snakeCase(
-    variationId
-  )}-${uniqid()}/${filename}`;
-}
-
-async function sendVariationPreviewToS3(
-  acl: ALC,
-  repository: string,
-  sliceName: string,
-  variationId: string,
-  filePath: string
-): Promise<string | null> {
-  const filename = path.basename(filePath);
-  const key = createS3Key(repository, sliceName, variationId, filename);
-  const form = await createFormForS3(key, filename, filePath, acl);
-  if (form === null) return null;
-  if (form.hasKnownLength() === false) {
-    logs.writeError(
-      `[slice/push] An error occurred while uploading preview image ${filePath} as length in unknown`
-    );
-  }
-
-  const errorMessage = `[slice/push] An error occurred while uploading preview images for ${sliceName}-${variationId} - please contact support`;
+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 axios
-    .post(acl.values.url, form, {
-      headers: {
-        ...form.getHeaders(),
-        "Content-Length": String(form.getLengthSync()),
-      },
+  return client
+    .uploadScreenshot({
+      acl,
+      sliceName,
+      variationId: variation.id,
+      filePath: screenshot.path,
     })
-    .then((res) => {
-      if (res.status !== 204) {
-        logs.writeError(errorMessage);
-        logs.writeError(`${res.status}: ${res.statusText}`);
-        return null;
-      } else {
-        return `${acl.imgixEndpoint}/${key}`;
-      }
+    .then((screenshotUrl) => {
+      return {
+        ...variation,
+        imageUrl: screenshotUrl,
+      };
     })
-    .catch((err) => {
-      logs.writeError(errorMessage);
-      if (axios.isAxiosError(err) && err.response) {
-        logs.writeError(`${err.response.status}: ${err.response.statusText}`);
-      } else if (err instanceof Error) {
-        logs.writeError(err.message);
-      } else {
-        logs.writeError(String(err));
-      }
-      return null;
+    .catch((error: ClientError) => {
+      writeError(
+        `Couldn't upload screenshot slice: ${sliceName} - variation: ${variation.id}`
+      );
+      writeError(error.message, "Full error:");
+      return variation;
     });
 }
 
-async function maybeAddImageUrlToVariation(
-  acl: ALC,
-  repository: string,
-  modelId: string,
-  pathToScreenShot: string,
-  variation: VariationSM
-): Promise<VariationSM> {
-  const imageUrl = await sendVariationPreviewToS3(
-    acl,
-    repository,
-    modelId,
-    variation.id,
-    pathToScreenShot
-  );
-  if (!imageUrl) return variation;
-
-  return {
-    ...variation,
-    imageUrl,
-  };
-}
-
-async function addImageUrlsToVariations(
-  acl: ALC,
-  repository: string,
-  modelId: string,
-  screenshotPaths: ComponentInfo["screenshotPaths"],
-  variations: Array<VariationSM>
-): Promise<Array<VariationSM>> {
+export async function updateSlicesWithScreenshots(
+  client: InitClient,
+  acl: Acl,
+  components: Array<Component>
+): Promise<Array<SliceSM>> {
   return Promise.all(
-    variations.map(async (variation) => {
-      const screenshot = screenshotPaths[variation.id];
-      if (!screenshot || !screenshot.path) return variation;
+    components.map(async (component) => {
+      const { screenshotPaths, model } = component;
 
-      return maybeAddImageUrlToVariation(
-        acl,
-        repository,
-        modelId,
-        screenshot.path,
-        variation
+      const variationsUpdated: VariationSM[] = await Promise.all(
+        model.variations.map(async (variation) =>
+          updateVariationWithScreenshot(
+            client,
+            acl,
+            screenshotPaths,
+            model.id,
+            variation
+          )
+        )
       );
-    })
-  );
-}
-
-async function maybeUpdateModelVariationsWithImageUrl(
-  acl: ALC,
-  repository: string,
-  component: Component
-): Promise<SliceSM> {
-  const { screenshotPaths, model } = component;
-  const variations = await addImageUrlsToVariations(
-    acl,
-    repository,
-    model.id,
-    screenshotPaths,
-    model.variations
-  );
-
-  return {
-    ...model,
-    variations,
-  };
-}
 
-export async function addImageUrlsToModelVariations(
-  acl: ALC,
-  repository: string,
-  components: Array<Component>
-): Promise<Array<SliceSM>> {
-  return Promise.all(
-    components.map(async (component) =>
-      maybeUpdateModelVariationsWithImageUrl(acl, repository, component)
-    )
+      return {
+        ...model,
+        variations: variationsUpdated,
+      };
+    })
   );
 }

package/src/steps/starters/slices.ts

@@ -1,34 +1,32 @@
-import { Component } from "@slicemachine/core/build/models";
+import { Component, Manifest, Slices } from "@slicemachine/core/build/models";
+import { Acl, ClientError } from "@slicemachine/client";
+import { InitClient, logs } from "../../utils";
 import * as Libraries from "@slicemachine/core/build/libraries";
-import { logs } from "../../utils";
-import { getRemoteSliceIds, sendManyModelsToPrismic } from "./communication";
-import { getEndpointsFromBase } from "./endpoints";
 import { promptToPushSlices } from "./prompts";
-import { addImageUrlsToModelVariations, createAcl } from "./s3";
-
-export async function sendSlicesFromStarter(
-  base: string,
-  repository: string,
-  authorization: string,
-  libraryPaths: Array<string>,
-  cwd: string
-) {
-  const endpoints = getEndpointsFromBase(base);
-  const libraries = Libraries.libraries(cwd, libraryPaths);
-
-  if (libraries.length === 0) return Promise.resolve(false);
-
-  const remoteSlices = await getRemoteSliceIds(
-    endpoints.Models,
-    repository,
-    authorization
-  );
+import { updateSlicesWithScreenshots } from "./s3";
+import { writeError } from "../../utils/logs";
 
-  if (remoteSlices.length) {
-    // do prompt about slices
+export async function sendSlices(
+  client: InitClient,
+  cwd: string,
+  manifest: Manifest
+): Promise<boolean> {
+  if (!manifest.libraries) return Promise.resolve(false); // No libraries defined
 
-    const pushAnyway = await promptToPushSlices();
+  const libraries = Libraries.libraries(cwd, manifest.libraries);
+  const components = libraries.reduce<Array<Component>>((acc, lib) => {
+    return [...acc, ...lib.components];
+  }, []);
+
+  if (components.length === 0) return Promise.resolve(false); // No slices to send found in the libraries
 
+  const remoteSlicesIds: string[] = await client
+    .getSlices()
+    .then((slices) => slices.map((slice) => slice.id));
+
+  // If the repository already has Slices, ask the user to confirm.
+  if (remoteSlicesIds.length) {
+    const pushAnyway = await promptToPushSlices();
     if (pushAnyway === false) return Promise.resolve(true);
   }
 
@@ -37,25 +35,40 @@ export async function sendSlicesFromStarter(
   );
   spinner.start();
 
-  const acl = await createAcl(endpoints.AclProvider, repository, authorization);
+  const acl: Acl | null = await client
+    .createAcl()
+    .catch((error: ClientError) => {
+      writeError(
+        "Uploading screenshots for your slices failed, please contact us."
+      );
+      writeError(error.message, "Full error:");
+      return null;
+    });
 
-  const components = libraries.reduce<Array<Component>>((acc, lib) => {
-    return [...acc, ...lib.components];
-  }, []);
+  // If the acl failed to be created, don't mind the screenshots.
+  const models = acl
+    ? await updateSlicesWithScreenshots(client, acl, components)
+    : components.map((component) => component.model);
 
-  const models = await addImageUrlsToModelVariations(
-    acl,
-    repository,
-    components
-  );
+  await Promise.all(
+    models.map(async (model) => {
+      const slice = Slices.fromSM(model);
 
-  await sendManyModelsToPrismic(
-    repository,
-    authorization,
-    endpoints.Models,
-    remoteSlices,
-    models
-  );
+      const promise = remoteSlicesIds.includes(slice.id)
+        ? client.updateSlice(slice)
+        : client.insertSlice(slice);
+
+      return promise.catch((error: ClientError) => {
+        logs.writeError(`Sending slice ${model.id} - ${error.message}`);
+
+        // throwing the error again to stop the Promise.all
+        throw error;
+      });
+    })
+  ).catch(() => {
+    // the error about the slice that failed to be pushed should be in the terminal already.
+    process.exit(1);
+  });
 
   spinner.succeed();
   return Promise.resolve(true);

package/src/utils/auth/helpers.ts

@@ -81,13 +81,17 @@ const authenticationHandler =
     };
   };
 
+function stripTrailingSlash(str: string) {
+  return str.endsWith("/") ? str.slice(0, -1) : str;
+}
+
 function buildServer(base: string, port: number, host: string): hapi.Server {
   const server = hapi.server({
     port,
     host,
     routes: {
       cors: {
-        origin: [base],
+        origin: [stripTrailingSlash(base)],
         headers: ["Origin", "X-Requested-With", "Content-Type", "Accept"],
       },
     },

package/src/utils/auth/index.ts

@@ -1,26 +1,30 @@
-import { Utils, Models } from "@slicemachine/core";
+import { Utils } from "@slicemachine/core";
 import { startServerAndOpenBrowser } from "./helpers";
 import {
-  Communication,
   Endpoints,
   PrismicSharedConfigManager,
 } from "@slicemachine/core/build/prismic";
+import { InitClient } from "../client";
 
 async function startAuth({
-  base,
+  client,
   url,
   action,
 }: {
-  base: string;
+  client: InitClient;
   url: string;
   action: "signup" | "login";
 }): Promise<void> {
-  const { onLoginFail } = await startServerAndOpenBrowser(url, action, base);
+  const { onLoginFail } = await startServerAndOpenBrowser(
+    url,
+    action,
+    client.apisEndpoints.Wroom
+  );
   try {
     // We wait 3 minutes before timeout
-    await Utils.Poll.startPolling<Models.UserInfo | null, Models.UserInfo>(
-      () => Auth.validateSession(base),
-      (user): user is Models.UserInfo => !!user,
+    await Utils.Poll.startPolling<boolean, boolean>(
+      () => Auth.validateSession(client),
+      (isSessionValid): isSessionValid is boolean => isSessionValid == true,
       3000,
       60
     );
@@ -31,33 +35,29 @@ async function startAuth({
 }
 
 export const Auth = {
-  login: async (base: string): Promise<void> => {
-    const endpoints = Endpoints.buildEndpoints(base);
+  login: async (client: InitClient): Promise<void> => {
+    const endpoints = Endpoints.buildEndpoints(client.apisEndpoints.Wroom);
     return startAuth({
-      base,
+      client,
       url: endpoints.Dashboard.cliLogin,
       action: "login",
     });
   },
-  signup: async (base: string): Promise<void> => {
-    const endpoints = Endpoints.buildEndpoints(base);
-    return startAuth({
-      base,
-      url: endpoints.Dashboard.cliSignup,
-      action: "signup",
-    });
-  },
-  logout: (): void => PrismicSharedConfigManager.remove(),
-  validateSession: async (
-    requiredBase: string
-  ): Promise<Models.UserInfo | null> => {
-    const config = PrismicSharedConfigManager.get();
+  validateSession: async (client: InitClient): Promise<boolean> => {
+    const authToken = PrismicSharedConfigManager.getAuth();
 
-    if (!config.cookies.length) return Promise.resolve(null); // default config, logged out.
-    if (requiredBase != config.base) return Promise.resolve(null); // not the same base so it doesn't count.
-
-    return Communication.validateSession(config.cookies, requiredBase).catch(
-      () => null
-    );
+    // verify token is by retrieving the profile, update the config if need be.
+    return client
+      .updateAuthenticationToken(authToken)
+      .profile()
+      .then((userProfile) => {
+        // settings shortId and IntercomHash as we switch between dev and prod.
+        PrismicSharedConfigManager.setProperties({
+          shortId: userProfile.shortId,
+          intercomHash: userProfile.intercomHash,
+        });
+        return true;
+      })
+      .catch(() => false);
   },
 };