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

package/build/index.js

@@ -23,6 +23,16 @@ const tmp = require('tmp');
 const AdmZip = require('adm-zip');
 const fsExtra = require('fs-extra');
 const fs = require('fs');
+const cookie = require('@slicemachine/core/build/utils/cookie');
+const Libraries = require('@slicemachine/core/build/libraries');
+const models = require('@slicemachine/core/build/models');
+const mime = require('mime');
+const snakeCase = require('lodash.snakecase');
+const FormData = require('form-data');
+const uniqid = require('uniqid');
+const customtypes = require('@prismicio/types-internal/lib/customtypes');
+const Either$1 = require('fp-ts/lib/Either');
+const t = require('io-ts');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -55,12 +65,19 @@ const hapi__namespace = /*#__PURE__*/_interopNamespace(hapi);
 const open__default = /*#__PURE__*/_interopDefaultLegacy(open);
 const NodeUtils__namespace = /*#__PURE__*/_interopNamespace(NodeUtils);
 const inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
+const inquirer__default = /*#__PURE__*/_interopDefaultLegacy(inquirer);
 const Separator__default = /*#__PURE__*/_interopDefaultLegacy(Separator);
 const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 const tmp__default = /*#__PURE__*/_interopDefaultLegacy(tmp);
 const AdmZip__default = /*#__PURE__*/_interopDefaultLegacy(AdmZip);
 const fsExtra__default = /*#__PURE__*/_interopDefaultLegacy(fsExtra);
 const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+const Libraries__namespace = /*#__PURE__*/_interopNamespace(Libraries);
+const mime__default = /*#__PURE__*/_interopDefaultLegacy(mime);
+const snakeCase__default = /*#__PURE__*/_interopDefaultLegacy(snakeCase);
+const FormData__default = /*#__PURE__*/_interopDefaultLegacy(FormData);
+const uniqid__default = /*#__PURE__*/_interopDefaultLegacy(uniqid);
+const t__namespace = /*#__PURE__*/_interopNamespace(t);
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -403,16 +420,25 @@ function depsForFramework(framework) {
       return "";
   }
 }
-async function installRequiredDependencies(cwd, framework) {
-  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
-  const installDevDependencyCommand = yarnLock ? "yarn add -D" : "npm install --save-dev";
-  const installDependencyCommand = yarnLock ? "yarn add" : "npm install --save";
-  const spinner = spinner$1("Downloading Slice Machine");
-  spinner.start();
+async function addAndInstallDeps(framework, useYarn = false) {
+  const installDevDependencyCommand = useYarn ? "yarn add -D" : "npm install --save-dev";
+  const installDependencyCommand = useYarn ? "yarn add" : "npm install --save";
   const { stderr } = await execCommand(`${installDevDependencyCommand} ${SM_PACKAGE_NAME}`);
   const deps = depsForFramework(framework);
   if (deps)
     await execCommand(`${installDependencyCommand} ${deps}`);
+  return stderr;
+}
+async function installDeps(useYarn = false) {
+  const installCommand = useYarn ? "yarn" : "npm install";
+  const { stderr } = await execCommand(installCommand);
+  return stderr;
+}
+async function installRequiredDependencies(cwd, framework, skipDependencies) {
+  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
+  const spinner = spinner$1("Installing Slice Machine");
+  spinner.start();
+  const stderr = await (skipDependencies ? installDeps(yarnLock) : addAndInstallDeps(framework, yarnLock));
   const pathToPkg = path__default["default"].join(NodeUtils__namespace.PackagePaths(cwd).value(), SM_PACKAGE_NAME);
   const isPackageInstalled = NodeUtils__namespace.Files.exists(pathToPkg);
   if (isPackageInstalled || !stderr.length) {
@@ -672,17 +698,19 @@ async function loginOrBypass(base) {
 
 const defaultSliceMachineVersion = "0.0.41";
 async function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
-  const spinner = spinner$1(`Configuring your ${framework.value} & Prismic project...`);
+  const frameworkName = NodeUtils__namespace.Framework.fancyName(framework.value);
+  const spinner = spinner$1(`Configuring your ${frameworkName} and Prismic project...`);
   spinner.start();
   try {
     const manifest = NodeUtils__namespace.retrieveManifest(cwd);
     const packageJson = NodeUtils__namespace.retrieveJsonPackage(cwd);
     const sliceMachineVersionInstalled = getTheSliceMachineVersionInstalled(packageJson);
     const manifestAlreadyExistWithContent = manifest.exists && manifest.content;
+    const libs = manifest.content && manifest.content.libraries && manifest.content.libraries.length > 0 ? manifest.content.libraries : ["@/slices"];
     const manifestUpdated = {
       ...manifestAlreadyExistWithContent ? manifest.content : { _latest: sliceMachineVersionInstalled },
       apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(base, repositoryDomainName),
-      libraries: ["@/slices", ...sliceLibPath],
+      libraries: [...libs, ...sliceLibPath],
       ...framework.manuallyAdded ? { framework: framework.value } : {},
       ...!tracking ? { tracking } : {}
     };
@@ -691,7 +719,7 @@ async function configureProject(cwd, base, repositoryDomainName, framework, slic
     else
       NodeUtils__namespace.patchManifest(cwd, manifestUpdated);
     const pathToSlicesFolder = NodeUtils__namespace.CustomPaths(cwd).library("slices").value();
-    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder)) {
+    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder) && libs.includes("@/slices")) {
       NodeUtils__namespace.Files.mkdir(pathToSlicesFolder, { recursive: true });
     }
     NodeUtils__namespace.addJsonPackageSmScript(cwd);
@@ -729,7 +757,8 @@ const extractVersionNumberFromSemver = (semver) => {
 function displayFinalMessage(cwd) {
   const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
   const command = `${yarnLock ? "yarn" : "npm"} run ${core.CONSTS.SCRIPT_NAME}`;
-  console.log(`${white("\u25A0")} Run ${purple(command)} to now launch Slice Machine`);
+  console.log();
+  console.log(`${white("\u25A0")} Run ${purple(command)} to start Slice Machine`);
 }
 
 const Dependencies = {
@@ -837,6 +866,364 @@ async function installLib(cwd, libGithubPath, branch = "HEAD") {
   }
 }
 
+function handleErrors(prefix, err) {
+  if (axios__default["default"].isAxiosError(err) && err.response) {
+    writeError$1(`${prefix} | [${err.response.status}]: ${err.response.statusText}`);
+  } else if (err instanceof Error) {
+    writeError$1(`${prefix} ${err.message}`);
+  } else {
+    writeError$1(`${prefix} ${String(err)}`);
+  }
+}
+async function getRemoteSliceIds(customTypeApiEndpoint, repository, authorization) {
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/slices`;
+  return axios__default["default"].get(addr, {
+    headers: {
+      Authorization: `Bearer ${authorization}`,
+      repository
+    }
+  }).then((res) => {
+    return Array.isArray(res.data) ? res.data.map((model) => model.id) : [];
+  });
+}
+async function sendModelToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, model) {
+  const data = models.Slices.fromSM(model);
+  const updateOrInsertUrl = `${customTypesApiEndpoint}slices/${remoteSliceIds.includes(model.id) ? "update" : "insert"}`;
+  return axios__default["default"].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;
+  });
+}
+async function sendManyModelsToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, models) {
+  return Promise.all(models.map((model) => sendModelToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, model))).then(() => {
+    return;
+  }).catch(() => {
+    process.exit(1);
+  });
+}
+function stripLastSlash(str) {
+  return str.replace(/\/*$/g, "");
+}
+function getRemoteCustomTypeIds(customTypeApiEndpoint, repository, authorization) {
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes`;
+  return axios__default["default"].get(addr, {
+    headers: {
+      Authorization: `Bearer ${authorization}`,
+      repository
+    }
+  }).then((res) => {
+    return Array.isArray(res.data) ? res.data.map((ct) => ct.id) : [];
+  });
+}
+async function sendCustomTypeToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customType) {
+  const shouldUpdate = remoteCustomTypeIds.includes(customType.id);
+  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes/${shouldUpdate ? "update" : "insert"}`;
+  return axios__default["default"].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;
+  });
+}
+async function sendManyCustomTypesToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customTypes) {
+  return Promise.all(customTypes.map((customType) => sendCustomTypeToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customType))).then(() => {
+    return;
+  }).catch(() => {
+    process.exit(1);
+  });
+}
+
+const ProductionApisEndpoints = {
+  Models: "https://customtypes.prismic.io/",
+  AclProvider: "https://0yyeb2g040.execute-api.us-east-1.amazonaws.com/prod/"
+};
+const StageApisEndpoints = {
+  Models: "https://customtypes.wroom.io/",
+  AclProvider: "https://2iamcvnxf4.execute-api.us-east-1.amazonaws.com/stage/"
+};
+const getEndpointsFromBase = (base) => {
+  const url = new URL(base);
+  if (url.hostname === "wroom.io")
+    return StageApisEndpoints;
+  return ProductionApisEndpoints;
+};
+
+async function promptToPushSlices() {
+  return inquirer__default["default"].prompt([
+    {
+      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);
+}
+async function promptToPushCustomTypes() {
+  return inquirer__default["default"].prompt([
+    {
+      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);
+}
+
+async function createAcl(address, repository, authorization) {
+  return axios__default["default"].get(address + "create", {
+    headers: {
+      repository,
+      Authorization: `Bearer ${authorization}`,
+      "User-Agent": "slice-machine"
+    }
+  }).then((res) => res.data);
+}
+async function createFormForS3(key, filename, filePath, acl) {
+  const form = new FormData__default["default"]();
+  Object.entries(acl.values.fields).forEach(([k, value]) => {
+    form.append(k, value);
+  });
+  form.append("key", key);
+  const contentType = mime__default["default"].getType(filePath);
+  contentType && form.append("Content-Type", contentType);
+  return fs__default["default"].promises.readFile(filePath).then((file) => {
+    form.append("file", file, { filename });
+    return form;
+  }).catch(() => {
+    writeError$1(`Error reading preview image: ${filename}`);
+    return null;
+  });
+}
+function createS3Key(repository, sliceName, variationId, filename) {
+  return `${repository}/shared-slices/${snakeCase__default["default"](sliceName)}/${snakeCase__default["default"](variationId)}-${uniqid__default["default"]()}/${filename}`;
+}
+async function sendVariationPreviewToS3(acl, repository, sliceName, variationId, filePath) {
+  const filename = path__default["default"].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) {
+    writeError$1(`[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__default["default"].post(acl.values.url, form, {
+    headers: {
+      ...form.getHeaders(),
+      "Content-Length": String(form.getLengthSync())
+    }
+  }).then((res) => {
+    if (res.status !== 204) {
+      writeError$1(errorMessage);
+      writeError$1(`${res.status}: ${res.statusText}`);
+      return null;
+    } else {
+      return `${acl.imgixEndpoint}/${key}`;
+    }
+  }).catch((err) => {
+    writeError$1(errorMessage);
+    if (axios__default["default"].isAxiosError(err) && err.response) {
+      writeError$1(`${err.response.status}: ${err.response.statusText}`);
+    } else if (err instanceof Error) {
+      writeError$1(err.message);
+    } else {
+      writeError$1(String(err));
+    }
+    return null;
+  });
+}
+async function maybeAddImageUrlToVariation(acl, repository, modelId, pathToScreenShot, variation) {
+  const imageUrl = await sendVariationPreviewToS3(acl, repository, modelId, variation.id, pathToScreenShot);
+  if (!imageUrl)
+    return variation;
+  return {
+    ...variation,
+    imageUrl
+  };
+}
+async function addImageUrlsToVariations(acl, repository, modelId, screenshotPaths, variations) {
+  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, repository, component) {
+  const { screenshotPaths, model } = component;
+  const variations = await addImageUrlsToVariations(acl, repository, model.id, screenshotPaths, model.variations);
+  return {
+    ...model,
+    variations
+  };
+}
+async function addImageUrlsToModelVariations(acl, repository, components) {
+  return Promise.all(components.map(async (component) => maybeUpdateModelVariationsWithImageUrl(acl, repository, component)));
+}
+
+async function sendSlicesFromStarter(base, repository, authorization, libraryPaths, cwd) {
+  const endpoints = getEndpointsFromBase(base);
+  const libraries = Libraries__namespace.libraries(cwd, libraryPaths);
+  if (libraries.length === 0)
+    return Promise.resolve(false);
+  const remoteSlices = await getRemoteSliceIds(endpoints.Models, repository, authorization);
+  if (remoteSlices.length) {
+    const pushAnyway = await promptToPushSlices();
+    if (pushAnyway === false)
+      return Promise.resolve(true);
+  }
+  const spinner = spinner$1("Pushing existing Slice models to your repository");
+  spinner.start();
+  const acl = await createAcl(endpoints.AclProvider, repository, authorization);
+  const components = libraries.reduce((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);
+}
+
+function readCustomTypes(cwd) {
+  const customTypePaths = NodeUtils.CustomTypesPaths(cwd);
+  const dir = customTypePaths.value();
+  if (NodeUtils.Files.isDirectory(dir) === false)
+    return [];
+  const fileNames = NodeUtils.Files.readDirectory(dir);
+  const files = fileNames.reduce((acc, fileName) => {
+    const filePath = customTypePaths.customType(fileName).model();
+    const json = NodeUtils.Files.safeReadJson(filePath);
+    if (!json)
+      return acc;
+    const file = customtypes.CustomType.decode(json);
+    if (file instanceof Error) {
+      writeError$1(`reading ${filePath}: ${file.message}`);
+      return acc;
+    }
+    if (Either$1.isLeft(file)) {
+      writeError$1(`validating ${filePath}: ${JSON.stringify(file.left)}`);
+      return acc;
+    }
+    return [...acc, file.right];
+  }, []);
+  return files;
+}
+async function sendCustomTypesFromStarter(repository, authorization, base, cwd) {
+  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 = spinner$1("Pushing existing custom types to your repository");
+  spinner.start();
+  await sendManyCustomTypesToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customTypes);
+  spinner.succeed();
+  return Promise.resolve(true);
+}
+
+const SignatureFileReader = t__namespace.type({
+  signature: t__namespace.string
+});
+async function readSignatureFile(cwd) {
+  const pathToFile = path__default["default"].join(cwd, "documents", "index.json");
+  return fs__default["default"].promises.readFile(pathToFile, "utf-8").then((res) => {
+    const data = JSON.parse(res);
+    return Either.getOrElseW(() => {
+      throw new Error("Unable to read document signature file");
+    })(SignatureFileReader.decode(data));
+  });
+}
+async function lsdir(dir) {
+  return fs__default["default"].promises.readdir(dir).then((dirs) => {
+    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isDirectory()).map((subdirectory) => path__default["default"].join(dir, subdirectory));
+  });
+}
+async function lsfiles(dir) {
+  return fs__default["default"].promises.readdir(dir).then((dirs) => {
+    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isFile()).map((file) => path__default["default"].join(dir, file));
+  });
+}
+async function readDocuments(cwd) {
+  const documentDir = path__default["default"].join(cwd, "documents");
+  const dirs = await lsdir(documentDir);
+  const files = (await Promise.all(dirs.map((dir) => lsfiles(dir)))).flat();
+  const documentObj = files.reduce((acc, file) => {
+    const fileContent = fs__default["default"].readFileSync(file, "utf-8");
+    const filename = path__default["default"].parse(file).name;
+    acc[filename] = JSON.parse(fileContent);
+    return acc;
+  }, {});
+  return JSON.stringify(documentObj);
+}
+const sendDocumentsFromStarter = async (repository, cookies, base, cwd) => {
+  const pathToDocuments = path__default["default"].join(cwd, "documents");
+  const pathToSignatureFile = path__default["default"].join(pathToDocuments, "index.json");
+  if (!fs__default["default"].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 = spinner$1("Pushing existing documents to your repository");
+  spinner.start();
+  return axios__default["default"].post(endpointURL, payload, {
+    headers: {
+      "User-Agent": "prismic-cli/0",
+      Cookie: cookies
+    }
+  }).then(() => {
+    spinner.succeed();
+    fs__default["default"].rmSync(pathToDocuments, { recursive: true, force: true });
+    return true;
+  }).catch((e) => {
+    var _a;
+    spinner.fail();
+    if (((_a = e.response) == null ? void 0 : _a.data) === "Repository should not contain documents") {
+      writeError$1("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);
+  });
+};
+
+async function sendStarterData(repository, base, cookies, cwd) {
+  const smJson = NodeUtils.retrieveManifest(cwd);
+  const hasDocuments = NodeUtils.Files.exists(path__default["default"].join(cwd, "documents"));
+  if (smJson.exists === false || hasDocuments === false)
+    return Promise.resolve(false);
+  const authTokenFromCookie = cookie.parsePrismicAuthToken(cookies);
+  if (smJson.content && smJson.content.libraries) {
+    await sendSlicesFromStarter(base, repository, authTokenFromCookie, smJson.content.libraries, cwd);
+  }
+  await sendCustomTypesFromStarter(repository, authTokenFromCookie, base, cwd);
+  return sendDocumentsFromStarter(repository, cookies, base, cwd);
+}
+
 async function init() {
   const cwd = findArgument(process.argv, "cwd") || process.cwd();
   const base = findArgument(process.argv, "base") || core.CONSTS.DEFAULT_BASE;
@@ -859,9 +1246,10 @@ async function init() {
   const frameworkResult = await detectFramework(cwd);
   const repositoryDomainName = await chooseOrCreateARepository(cwd, frameworkResult.value, config.cookies, config.base, maybeRepositorySubdomain);
   Tracker.get().setRepository(repositoryDomainName);
-  await installRequiredDependencies(cwd, frameworkResult.value);
   const sliceLibPath = lib ? await installLib(cwd, lib, branch) : void 0;
+  const wasStarter = await sendStarterData(repositoryDomainName, config.base, config.cookies, cwd);
   await configureProject(cwd, base, repositoryDomainName, frameworkResult, sliceLibPath, isTrackingAvailable);
+  await installRequiredDependencies(cwd, frameworkResult.value, wasStarter);
   displayFinalMessage(cwd);
 }
 init().then(() => {