@slicemachine/init 1.1.19 → 2.0.1

package/src/steps/index.ts

@@ -1,10 +0,0 @@
-export { installRequiredDependencies } from "./install-required-dependencies";
-export { validatePkg } from "./validate-pkg";
-export { chooseOrCreateARepository } from "./choose-or-create-a-repository";
-export { detectFramework } from "./detect-framework";
-export { loginOrBypass } from "./loginOrBypass";
-export { configureProject } from "./configure-project";
-export { displayFinalMessage } from "./display-final-message";
-export { installLib } from "./install-lib";
-export { sendStarterData } from "./sendStarterData";
-export { setVersion } from "./set-version";

package/src/steps/install-lib.ts

@@ -1,116 +0,0 @@
-import { Models } from "@slicemachine/core";
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import tmp from "tmp";
-import AdmZip from "adm-zip";
-import fsExtra from "fs-extra";
-import axios from "axios";
-
-import fs from "fs";
-import path from "path";
-import { getOrElseW } from "fp-ts/Either";
-import { PackageManager, Dependencies } from "../utils/PackageManager";
-import Tracker from "../utils/tracker";
-import { logs } from "../utils";
-
-const { PackageJsonHelper } = NodeUtils;
-
-const downloadFile = async (reqUrl: string): Promise<string> => {
-  const res = await axios.get<Buffer>(reqUrl, { responseType: "arraybuffer" });
-
-  return new Promise((resolve, reject) => {
-    if (res.status == 200) {
-      const tmpZipFile = tmp.tmpNameSync();
-      const zip = new AdmZip(res.data);
-      zip.extractAllTo(tmpZipFile);
-      resolve(tmpZipFile);
-    } else {
-      reject();
-    }
-  });
-};
-
-function toGithubSource(githubPath: string, branch: string): string {
-  return `https://codeload.github.com/${githubPath}/zip/${branch}`;
-}
-
-export async function installLib(
-  cwd: string,
-  libGithubPath: string,
-  branch = "HEAD"
-): Promise<string[] | undefined> {
-  const spinner = logs.spinner(
-    `Installing the ${libGithubPath} lib in your project...`
-  );
-
-  try {
-    spinner.start();
-
-    const [githubUserName, githubProjectName] = libGithubPath.split("/");
-    const source = toGithubSource(libGithubPath, branch);
-
-    const zipFilePath = await downloadFile(source);
-    const outputFolder = `${githubProjectName}-${branch}`;
-    const projectPath = path.join(zipFilePath, outputFolder);
-
-    const name = `${githubUserName}-${githubProjectName}`;
-    const libDestinationFolder = path.join(cwd, name);
-
-    // We should be able to offer the ability to override or not an existing library
-    if (fs.existsSync(libDestinationFolder)) {
-      spinner.succeed(`Lib "${libGithubPath}" was already installed (skipped)`);
-      return;
-    }
-
-    // We copy all the slices into the the user project minus the src folder
-    fsExtra.moveSync(path.join(projectPath, "src"), libDestinationFolder);
-
-    // handle dependencies
-    const pkgManager = PackageManager.get(cwd);
-    const pkgJson = PackageJsonHelper.fromPath(
-      path.join(projectPath, "package.json")
-    );
-    if (pkgJson instanceof Error) throw pkgJson;
-
-    const dependencies = Dependencies.fromPkgFormat(pkgJson.dependencies);
-    if (dependencies) await pkgManager.install(dependencies);
-
-    // generate meta file
-    NodeUtils.Files.write(path.join(libDestinationFolder, "meta.json"), {
-      name: pkgJson.name,
-    });
-
-    // retrieve all slices lib paths
-    const manifest = NodeUtils.Files.readEntity<Error | Models.Manifest>(
-      path.join(projectPath, "sm.json"),
-      (payload: unknown) => {
-        return getOrElseW(
-          () => new Error(`Unable to parse sm.json from lib ${libGithubPath}`)
-        )(Models.Manifest.decode(payload));
-      }
-    );
-    if (manifest instanceof Error) throw manifest;
-
-    const localLibs = Models.ManifestHelper.localLibraries(manifest).map(
-      ({ path }) => {
-        return `~/${name}/${path.replace("src/", "")}`;
-      }
-    );
-
-    spinner.succeed(
-      `Slice library "${libGithubPath}" was installed successfully`
-    );
-
-    void Tracker.get().trackDownloadLibrary(libGithubPath);
-    return localLibs;
-  } catch (error) {
-    spinner.fail(`Error installing ${libGithubPath} lib!`);
-    if (error instanceof Error) {
-      console.error(error.message);
-    }
-    await Tracker.get().trackInitEndFail(
-      Models.Frameworks.none,
-      "Failed to install ${libGithubPath} library"
-    );
-    process.exit(-1);
-  }
-}

package/src/steps/install-required-dependencies.ts

@@ -1,106 +0,0 @@
-import path from "path";
-import { checkVersion, execCommand, logs } from "../utils";
-import { CONSTS, Models } from "@slicemachine/core";
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-
-const {
-  PRISMIC_CLIENT,
-  PRISMIC_DOM_PACKAGE_NAME,
-  PRISMIC_REACT_PACKAGE_NAME,
-  PRISMIC_NEXT,
-  SM_PACKAGE_NAME,
-  NUXT_PRISMIC,
-  PRISMIC_VUE,
-  SLICE_SIMULATOR_REACT,
-  SLICE_SIMULATOR_VUE,
-  PRISMIC_HELPERS,
-  PRISMIC_TYPES,
-} = CONSTS;
-
-export function nextDeps(version?: string): string {
-  if (checkVersion(">=13.0.0", version)) {
-    return PRISMIC_NEXT;
-  }
-
-  return "";
-}
-
-function depsForFramework(
-  framework: Models.Frameworks,
-  version?: string
-): string {
-  switch (framework) {
-    case Models.Frameworks.react:
-      return `${PRISMIC_REACT_PACKAGE_NAME} ${PRISMIC_CLIENT} ${PRISMIC_HELPERS}`;
-    case Models.Frameworks.next:
-      return `${PRISMIC_REACT_PACKAGE_NAME} ${nextDeps(
-        version
-      )} ${PRISMIC_CLIENT} ${SLICE_SIMULATOR_REACT} ${PRISMIC_HELPERS}`;
-    case Models.Frameworks.svelte:
-      return `${PRISMIC_DOM_PACKAGE_NAME} ${PRISMIC_CLIENT}`;
-    case Models.Frameworks.nuxt:
-      return `${NUXT_PRISMIC} ${SLICE_SIMULATOR_VUE}`;
-    case Models.Frameworks.vue:
-      return `${PRISMIC_VUE} ${PRISMIC_CLIENT} ${PRISMIC_DOM_PACKAGE_NAME}`;
-    default:
-      return "";
-  }
-}
-
-async function addAndInstallDeps(
-  framework: Models.Frameworks,
-  version?: string,
-  useYarn = false
-): Promise<string> {
-  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} ${PRISMIC_TYPES}`
-  );
-
-  const deps = depsForFramework(framework, version);
-  if (deps) await execCommand(`${installDependencyCommand} ${deps}`);
-
-  return stderr;
-}
-
-async function installDeps(useYarn = false): Promise<string> {
-  const installCommand = useYarn ? "yarn" : "npm install";
-  const { stderr } = await execCommand(installCommand);
-  return stderr;
-}
-
-export async function installRequiredDependencies(
-  cwd: string,
-  framework: Models.Frameworks,
-  skipDependencies: boolean,
-  version?: string
-): Promise<void> {
-  const yarnLock = NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd));
-
-  const spinner = logs.spinner("Installing Slice Machine");
-  spinner.start();
-
-  const stderr = await (skipDependencies
-    ? installDeps(yarnLock)
-    : addAndInstallDeps(framework, version, yarnLock));
-
-  const pathToPkg = path.join(
-    NodeUtils.PackagePaths(cwd).value(),
-    SM_PACKAGE_NAME
-  );
-  const isPackageInstalled = NodeUtils.Files.exists(pathToPkg);
-
-  if (isPackageInstalled || !stderr.length) {
-    spinner.succeed("Slice Machine was installed successfully");
-    return;
-  }
-
-  spinner.fail();
-  logs.writeWarning(
-    `could not install ${SM_PACKAGE_NAME}. Please do it manually!`
-  );
-}

package/src/steps/loginOrBypass.ts

@@ -1,25 +0,0 @@
-import { Models } from "@slicemachine/core";
-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);
-
-  if (user) {
-    const email = user.email;
-    logs.writeCheck(`Logged in as ${logs.bold(email)}`);
-    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,31 +0,0 @@
-import { retrieveManifest, Files } from "@slicemachine/core/build/node-utils";
-import path from "path";
-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(
-  client: InitClient,
-  cwd: string,
-  pushDocuments = true
-) {
-  const manifest = retrieveManifest(cwd);
-  const documentsPath = path.join(cwd, "documents");
-  const hasDocuments = Files.exists(documentsPath);
-
-  if (manifest.exists === false || hasDocuments === false)
-    return Promise.resolve(false);
-
-  if (manifest.content) await sendSlices(client, cwd, manifest.content);
-  await sendCustomTypes(client, 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 sendDocuments(client, cwd);
-}

package/src/steps/set-version.ts

@@ -1,61 +0,0 @@
-import { CONSTS } from "@slicemachine/core";
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import { logs } from "../utils";
-
-const defaultSliceMachineVersion = "0.0.41";
-
-const getTheSliceMachineVersionInstalled = (
-  packageJson: NodeUtils.FileContent<NodeUtils.JsonPackage>
-) => {
-  const sliceMachinePackageInstalled = Object.entries(
-    packageJson.content?.devDependencies || {}
-  ).find((devDependency) => {
-    if (devDependency[0] === CONSTS.SM_PACKAGE_NAME) {
-      return devDependency;
-    }
-  });
-
-  if (!sliceMachinePackageInstalled) {
-    return defaultSliceMachineVersion;
-  }
-
-  const extractedVersion = extractVersionNumberFromSemver(
-    sliceMachinePackageInstalled[1]
-  );
-
-  if (!extractedVersion) {
-    return defaultSliceMachineVersion;
-  }
-
-  return extractedVersion;
-};
-
-const extractVersionNumberFromSemver = (semver: string) => {
-  const versionFound = semver.match(/\d+\.\d+\.\d+/);
-
-  if (versionFound && versionFound.length > 0) {
-    return versionFound[0];
-  }
-
-  return null;
-};
-
-export function setVersion(cwd: string): void {
-  try {
-    const manifest = NodeUtils.retrieveManifest(cwd);
-
-    if (manifest.content?._latest) {
-      return;
-    }
-
-    const packageJson = NodeUtils.retrieveJsonPackage(cwd);
-    const sliceMachineVersionInstalled =
-      getTheSliceMachineVersionInstalled(packageJson);
-
-    NodeUtils.patchManifest(cwd, { _latest: sliceMachineVersionInstalled });
-  } catch {
-    logs.warning(
-      "Could not set _latest to installed slice-machine-ui version in sm.json"
-    );
-  }
-}

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

@@ -1,81 +0,0 @@
-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 { promptToPushCustomTypes } from "./prompts";
-import { InitClient, logs } from "../../utils";
-import { ClientError } from "@slicemachine/client";
-
-export function readLocalCustomTypes(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 sendCustomTypes(client: InitClient, cwd: string) {
-  const localCustomTypes = readLocalCustomTypes(cwd);
-
-  // nothing to push
-  if (localCustomTypes.length === 0) return Promise.resolve(false);
-
-  const remoteCustomTypeIds = await client
-    .getCustomTypes()
-    .then((customTypes) => customTypes.map((customType) => customType.id));
-
-  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 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

@@ -1,95 +0,0 @@
-import path from "path";
-import fs from "fs";
-import type { AxiosError } from "axios";
-import { Models } from "@slicemachine/core";
-
-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";
-import Tracker from "../../utils/tracker";
-
-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(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 {
-        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

@@ -1,29 +0,0 @@
-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 Custom Types?",
-      },
-    ])
-    .then((res) => res.pushCustomTypes);
-}

package/src/steps/starters/s3.ts

@@ -1,70 +0,0 @@
-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";
-
-async function updateVariationWithScreenshot(
-  client: InitClient,
-  acl: Acl,
-  screenshots: ComponentInfo["screenshots"],
-  sliceId: SliceSM["id"],
-  variation: VariationSM
-): Promise<VariationSM> {
-  const screenshot = screenshots[variation.id];
-  if (!screenshot || !screenshot.path) return Promise.resolve(variation);
-
-  return client
-    .uploadScreenshot({
-      acl,
-      sliceId,
-      variationId: variation.id,
-      filePath: screenshot.path,
-    })
-    .then((screenshotUrl) => {
-      return {
-        ...variation,
-        imageUrl: screenshotUrl,
-      };
-    })
-    .catch((error: ClientError) => {
-      writeError(
-        `Couldn't upload screenshot slice: ${sliceId} - variation: ${variation.id}`
-      );
-      writeError(error.message, "Full error:");
-      return variation;
-    });
-}
-
-export async function updateSlicesWithScreenshots(
-  client: InitClient,
-  acl: Acl,
-  components: Array<Component>
-): Promise<Array<SliceSM>> {
-  return Promise.all(
-    components.map(async (component) => {
-      const { screenshots, model } = component;
-
-      const variationsUpdated: VariationSM[] = await Promise.all(
-        model.variations.map(async (variation) =>
-          updateVariationWithScreenshot(
-            client,
-            acl,
-            screenshots,
-            model.id,
-            variation
-          )
-        )
-      );
-
-      return {
-        ...model,
-        variations: variationsUpdated,
-      };
-    })
-  );
-}