@slicemachine/init 1.1.10-alpha.3 → 1.1.10

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

package/src/utils/client.ts

@@ -0,0 +1,67 @@
+import * as t from "io-ts";
+import { Models } from "@slicemachine/core";
+import { PrismicSharedConfigManager } from "@slicemachine/core/build/prismic";
+import { Client, getAndValidateResponse } from "@slicemachine/client";
+
+export class InitClient extends Client {
+  async listRepositories(): Promise<Models.Repository[]> {
+    return getAndValidateResponse<Models.Repository[]>(
+      this._get(`${this.apisEndpoints.Users}repositories`),
+      "repository list",
+      t.array(Models.Repository)
+    );
+  }
+
+  async createRepository(
+    domain: string,
+    framework: Models.Frameworks
+  ): Promise<string> {
+    const data = {
+      domain,
+      framework,
+      plan: "personal",
+      isAnnual: "false",
+      role: "developer",
+    };
+
+    return this._fetch({
+      method: "post",
+      url: `${this.apisEndpoints.Wroom}authentication/newrepository?app=slicemachine`,
+      data: data,
+      headers: {
+        Cookie: PrismicSharedConfigManager.get().cookies,
+        "User-Agent": "prismic-cli/sm", // special user agent just for this route.
+      },
+    }).then(() => domain);
+  }
+
+  async domainExist(domain: string): Promise<boolean> {
+    return getAndValidateResponse<boolean>(
+      this._get(
+        `${this.apisEndpoints.Wroom}app/dashboard/repositories/${domain}/exists`
+      ),
+      "repository exists",
+      t.boolean
+    );
+  }
+
+  async pushDocuments(
+    signature: string,
+    documents: Record<string, unknown>,
+    cookies: string
+  ) {
+    if (!this.repository) throw new Error("Repository undefined in the client");
+    const repositoryDirectUrl = new URL(this.apisEndpoints.Wroom);
+    repositoryDirectUrl.hostname = `${this.repository}.${repositoryDirectUrl.hostname}`;
+
+    return this._fetch({
+      method: "post",
+      url: `${repositoryDirectUrl.toString()}starter/documents`,
+      data: { signature, documents: JSON.stringify(documents) },
+      headers: {
+        Cookie: cookies,
+        "User-Agent": "prismic-cli/0", // special user agent just for this route.
+      },
+    });
+  }
+}

package/src/utils/create-repo.ts

@@ -1,30 +1,24 @@
 import type { Models } from "@slicemachine/core";
 import * as logs from "./logs";
-import * as Prismic from "@slicemachine/core/build/prismic";
+import { InitClient } from "./client";
 
 export function createRepository(
+  client: InitClient,
   domain: string,
-  framework: Models.Frameworks,
-  cookies: string,
-  base: string
+  framework: Models.Frameworks
 ): Promise<string> {
   const spinner = logs.spinner("Creating Prismic Repository");
   spinner.start();
 
-  return Prismic.Communication.createRepository(
-    domain,
-    cookies,
-    framework,
-    base
-  )
-    .then((res) => {
-      const addressUrl = new URL(base);
-      const repoDomainName = res.data.domain || domain;
-      addressUrl.hostname = `${repoDomainName}.${addressUrl.hostname}`;
+  return client
+    .createRepository(domain, framework)
+    .then((domain: string) => {
+      const addressUrl = new URL(client.apisEndpoints.Wroom);
+      addressUrl.hostname = `${domain}.${addressUrl.hostname}`;
       const address = addressUrl.toString();
       spinner.succeed(`We created your new repository ${address}`);
 
-      return repoDomainName;
+      return domain;
     })
     .catch((error: Error) => {
       spinner.fail(`Error creating repository ${domain}`);

package/src/utils/fs.ts

@@ -0,0 +1,18 @@
+import fs from "fs";
+import path from "path";
+
+export 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));
+  });
+}
+
+export 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));
+  });
+}

package/src/utils/index.ts

@@ -1,7 +1,10 @@
+import { ApplicationMode } from "@slicemachine/client";
 import util from "util";
 import { exec } from "child_process";
 export * as logs from "./logs";
 export { Auth } from "./auth";
+export * from "./client";
+export * from "./fs";
 
 export function findArgument(args: string[], name: string): string | undefined {
   const flagIndex: number = args.indexOf(`--${name}`);
@@ -23,3 +26,16 @@ export function findFlag(args: string[], name: string): boolean {
 export const execCommand: (
   command: string
 ) => Promise<{ stderr: string; stdout: string }> = util.promisify(exec);
+
+export function getApplicationMode(
+  argumentValue: string | undefined
+): ApplicationMode | null {
+  switch (argumentValue) {
+    case ApplicationMode.PROD:
+    case ApplicationMode.STAGE:
+    case ApplicationMode.DEV:
+      return argumentValue;
+    default:
+      return null;
+  }
+}

package/src/utils/validateRepositoryName.ts

@@ -0,0 +1,44 @@
+import { InitClient } from "./client";
+
+export async function validateRepositoryName(
+  client: InitClient,
+  name: string
+): Promise<boolean> {
+  const domain = name.trim();
+  const errors = [];
+
+  const startsWithLetter = /^[a-zA-Z]/.test(domain);
+  if (!startsWithLetter) errors.push("Must start with a letter.");
+
+  const acceptedChars = /^[a-z0-9-]+$/.test(domain);
+  if (!acceptedChars)
+    errors.push("Must contain only lowercase letters, numbers and hyphens.");
+
+  const fourCharactersOrMore = domain.length >= 4;
+  if (!fourCharactersOrMore)
+    errors.push(
+      "Must have four or more alphanumeric characters and/or hyphens."
+    );
+
+  const endsWithALetterOrNumber = /[a-z0-9]$/.test(domain);
+  if (!endsWithALetterOrNumber)
+    errors.push("Must end in a letter or a number.");
+
+  const thirtyCharacterOrLess = domain.length <= 30;
+  if (!thirtyCharacterOrLess) errors.push("Must be 30 characters or less");
+
+  if (errors.length > 0) {
+    const errorString = errors.map((d, i) => `(${i + 1}: ${d}`).join(" ");
+    const msg = `Validation errors: ${errorString}`;
+    return Promise.reject(new Error(msg));
+  }
+
+  return client
+    .domainExist(domain)
+    .then((isAvailable) =>
+      isAvailable
+        ? true
+        : Promise.reject(new Error(`${name} is already in use`))
+    )
+    .catch(() => Promise.reject(new Error(`${name} is already in use`)));
+}