@slicemachine/init 1.1.9-alpha.3 → 1.1.10-alpha.2

package/src/steps/starters/communication.ts

@@ -0,0 +1,171 @@
+import { CustomType } from "@prismicio/types-internal/lib/customtypes";
+import { Slices, SliceSM } from "@slicemachine/core/build/models";
+import axios from "axios";
+import { logs } from "../../utils";
+import type { ApiEndpoints } from "./endpoints";
+
+export function handleErrors(prefix: string, err: unknown) {
+  if (axios.isAxiosError(err) && err.response) {
+    logs.writeError(
+      `${prefix} | [${err.response.status}]: ${err.response.statusText}`
+    );
+  } else if (err instanceof Error) {
+    logs.writeError(`${prefix} ${err.message}`);
+  } else {
+    logs.writeError(`${prefix} ${String(err)}`);
+  }
+}
+
+export async function getRemoteSliceIds(
+  customTypeApiEndpoint: ApiEndpoints["Models"],
+  repository: string,
+  authorization: string
+): Promise<Array<string>> {
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/slices`;
+  return axios
+    .get<Array<{ id: string }>>(addr, {
+      headers: {
+        Authorization: `Bearer ${authorization}`,
+        repository,
+      },
+    })
+    .then((res) => {
+      return Array.isArray(res.data) ? res.data.map((model) => model.id) : [];
+    });
+}
+
+async function sendModelToPrismic(
+  repository: string,
+  authorization: string,
+  customTypesApiEndpoint: string,
+  remoteSliceIds: Array<string>,
+  model: SliceSM
+): Promise<void> {
+  const data = Slices.fromSM(model);
+  const updateOrInsertUrl = `${customTypesApiEndpoint}slices/${
+    remoteSliceIds.includes(model.id) ? "update" : "insert"
+  }`;
+
+  return axios
+    .post(updateOrInsertUrl, data, {
+      headers: {
+        Authorization: `Bearer ${authorization}`,
+        repository,
+      },
+    })
+    .then(() => {
+      return;
+    })
+    .catch((err) => {
+      handleErrors(
+        `sending slice ${model.id},  please try again. If the problem persists, contact us.`,
+        err
+      );
+      throw err;
+    });
+}
+
+export async function sendManyModelsToPrismic(
+  repository: string,
+  authorization: string,
+  customTypesApiEndpoint: string,
+  remoteSliceIds: Array<string>,
+  models: Array<SliceSM>
+): Promise<void> {
+  return Promise.all(
+    models.map((model) =>
+      sendModelToPrismic(
+        repository,
+        authorization,
+        customTypesApiEndpoint,
+        remoteSliceIds,
+        model
+      )
+    )
+  )
+    .then(() => {
+      return;
+    })
+    .catch(() => {
+      process.exit(1);
+    });
+}
+
+function stripLastSlash(str: string) {
+  return str.replace(/\/*$/g, "");
+}
+
+export function getRemoteCustomTypeIds(
+  customTypeApiEndpoint: ApiEndpoints["Models"],
+  repository: string,
+  authorization: string
+): Promise<Array<string>> {
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes`;
+  return axios
+    .get<CustomType[]>(addr, {
+      headers: {
+        Authorization: `Bearer ${authorization}`,
+        repository,
+      },
+    })
+    .then((res) => {
+      return Array.isArray(res.data) ? res.data.map((ct) => ct.id) : [];
+    });
+}
+
+async function sendCustomTypeToPrismic(
+  repository: string,
+  authorization: string,
+  customTypeApiEndpoint: string,
+  remoteCustomTypeIds: Array<string>,
+  customType: CustomType
+): Promise<void> {
+  const shouldUpdate = remoteCustomTypeIds.includes(customType.id);
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes/${
+    shouldUpdate ? "update" : "insert"
+  }`;
+
+  return axios
+    .post(addr, customType, {
+      headers: {
+        repository,
+        Authorization: `Bearer ${authorization}`,
+      },
+    })
+    .then(() => {
+      return;
+    })
+    .catch((err) => {
+      handleErrors(
+        `sending custom type ${customType.id}, please try again. If the problem persists, contact us.`,
+        err
+      );
+      throw err;
+    });
+}
+
+export async function sendManyCustomTypesToPrismic(
+  repository: string,
+  authorization: string,
+  customTypeApiEndpoint: string,
+  remoteCustomTypeIds: Array<string>,
+  customTypes: Array<CustomType>
+): Promise<void> {
+  return Promise.all(
+    customTypes.map((customType) =>
+      sendCustomTypeToPrismic(
+        repository,
+        authorization,
+        customTypeApiEndpoint,
+        remoteCustomTypeIds,
+        customType
+      )
+    )
+  )
+    .then(() => {
+      return;
+    })
+    .catch(() => {
+      process.exit(1);
+    });
+}

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

@@ -0,0 +1,82 @@
+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";
+
+export function readCustomTypes(cwd: string): Array<CustomType> {
+  const customTypePaths = CustomTypesPaths(cwd);
+  const dir = customTypePaths.value();
+
+  if (Files.isDirectory(dir) === false) return [];
+
+  const fileNames = Files.readDirectory(dir);
+
+  const files = fileNames.reduce<Array<CustomType>>((acc, fileName) => {
+    const filePath = customTypePaths.customType(fileName).model();
+    const json = Files.safeReadJson(filePath);
+
+    if (!json) return acc;
+
+    const file = CustomType.decode(json);
+
+    if (file instanceof Error) {
+      logs.writeError(`reading ${filePath}: ${file.message}`);
+      return acc;
+    }
+    if (isLeft(file)) {
+      logs.writeError(`validating ${filePath}: ${JSON.stringify(file.left)}`);
+      return acc;
+    }
+
+    return [...acc, file.right];
+  }, []);
+
+  return files;
+}
+
+export async function sendCustomTypesFromStarter(
+  repository: string,
+  authorization: string,
+  base: string,
+  cwd: string
+) {
+  const customTypeApiEndpoint = getEndpointsFromBase(base).Models;
+
+  const customTypes = readCustomTypes(cwd);
+
+  if (customTypes.length === 0) return Promise.resolve(false);
+
+  const remoteCustomTypeIds = await getRemoteCustomTypeIds(
+    customTypeApiEndpoint,
+    repository,
+    authorization
+  );
+
+  if (remoteCustomTypeIds.length) {
+    const shouldPush = await promptToPushCustomTypes();
+    if (shouldPush === false) return Promise.resolve(false);
+  }
+
+  const spinner = logs.spinner(
+    "Pushing existing custom types to your repository"
+  );
+  spinner.start();
+
+  await sendManyCustomTypesToPrismic(
+    repository,
+    authorization,
+    customTypeApiEndpoint,
+    remoteCustomTypeIds,
+    customTypes
+  );
+
+  spinner.succeed();
+
+  return Promise.resolve(true);
+}

package/src/steps/starters/documents.ts

@@ -0,0 +1,114 @@
+import path from "path";
+import fs from "fs";
+import axios, { AxiosError } from "axios";
+
+import * as t from "io-ts";
+import { getOrElseW } from "fp-ts/Either";
+import { handleErrors } from "./communication";
+import { logs } from "../../utils";
+
+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));
+  });
+}
+
+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) {
+  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;
+  }, {});
+
+  return JSON.stringify(documentObj);
+}
+
+export const sendDocumentsFromStarter = async (
+  repository: string,
+  cookies: string,
+  base: string,
+  cwd: string
+): Promise<boolean> => {
+  const pathToDocuments = path.join(cwd, "documents");
+  const pathToSignatureFile = path.join(pathToDocuments, "index.json");
+
+  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 prismicUrl = new URL(base);
+  prismicUrl.hostname = `${repository}.${prismicUrl.hostname}`;
+  prismicUrl.pathname = "starter/documents";
+  const endpointURL = prismicUrl.toString();
+
+  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,
+      },
+    })
+    .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 {
+        handleErrors(
+          "sending documents, please try again. If the problem persists, contact us.",
+          e
+        );
+      }
+
+      process.exit(1);
+    });
+};

package/src/steps/starters/endpoints.ts

@@ -0,0 +1,20 @@
+export type ApiEndpoints = {
+  Models: string;
+  AclProvider: string;
+};
+
+const ProductionApisEndpoints: ApiEndpoints = {
+  Models: "https://customtypes.prismic.io/",
+  AclProvider: "https://0yyeb2g040.execute-api.us-east-1.amazonaws.com/prod/",
+};
+
+const StageApisEndpoints: ApiEndpoints = {
+  Models: "https://customtypes.wroom.io/",
+  AclProvider: "https://2iamcvnxf4.execute-api.us-east-1.amazonaws.com/stage/",
+};
+
+export const getEndpointsFromBase = (base: string): ApiEndpoints => {
+  const url = new URL(base);
+  if (url.hostname === "wroom.io") return StageApisEndpoints;
+  return ProductionApisEndpoints;
+};

package/src/steps/starters/prompts.ts

@@ -0,0 +1,29 @@
+import inquirer from "inquirer";
+
+export async function promptToPushSlices(): Promise<boolean> {
+  return inquirer
+    .prompt<{ pushSlices: boolean }>([
+      {
+        type: "confirm",
+        name: "pushSlices",
+        default: false,
+        message:
+          "Your repository already contains Slices. Do you want to continue pushing your local Slices?",
+      },
+    ])
+    .then((res) => res.pushSlices);
+}
+
+export async function promptToPushCustomTypes(): Promise<boolean> {
+  return inquirer
+    .prompt<{ pushCustomTypes: boolean }>([
+      {
+        type: "confirm",
+        name: "pushCustomTypes",
+        default: false,
+        message:
+          "Your repository already contains Custom Types. Do you want to continue pushing your local Slices?",
+      },
+    ])
+    .then((res) => res.pushCustomTypes);
+}

package/src/steps/starters/s3.ts

@@ -0,0 +1,201 @@
+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 {
+  Component,
+  ComponentInfo,
+  VariationSM,
+  SliceSM,
+} from "@slicemachine/core/build/models";
+
+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`;
+
+  return axios
+    .post(acl.values.url, form, {
+      headers: {
+        ...form.getHeaders(),
+        "Content-Length": String(form.getLengthSync()),
+      },
+    })
+    .then((res) => {
+      if (res.status !== 204) {
+        logs.writeError(errorMessage);
+        logs.writeError(`${res.status}: ${res.statusText}`);
+        return null;
+      } else {
+        return `${acl.imgixEndpoint}/${key}`;
+      }
+    })
+    .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;
+    });
+}
+
+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>> {
+  return Promise.all(
+    variations.map(async (variation) => {
+      const screenshot = screenshotPaths[variation.id];
+      if (!screenshot || !screenshot.path) return variation;
+
+      return maybeAddImageUrlToVariation(
+        acl,
+        repository,
+        modelId,
+        screenshot.path,
+        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)
+    )
+  );
+}

package/src/steps/starters/slices.ts

@@ -0,0 +1,62 @@
+import { Component } from "@slicemachine/core/build/models";
+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
+  );
+
+  if (remoteSlices.length) {
+    // do prompt about slices
+
+    const pushAnyway = await promptToPushSlices();
+
+    if (pushAnyway === false) return Promise.resolve(true);
+  }
+
+  const spinner = logs.spinner(
+    "Pushing existing Slice models to your repository"
+  );
+  spinner.start();
+
+  const acl = await createAcl(endpoints.AclProvider, repository, authorization);
+
+  const components = libraries.reduce<Array<Component>>((acc, lib) => {
+    return [...acc, ...lib.components];
+  }, []);
+
+  const models = await addImageUrlsToModelVariations(
+    acl,
+    repository,
+    components
+  );
+
+  await sendManyModelsToPrismic(
+    repository,
+    authorization,
+    endpoints.Models,
+    remoteSlices,
+    models
+  );
+
+  spinner.succeed();
+  return Promise.resolve(true);
+}