@slicemachine/init 1.1.19-dev-release-feb.2 → 2.0.0

package/siroc.config.js

@@ -1,19 +0,0 @@
-import { defineSirocConfig } from "siroc";
-import replace from "@rollup/plugin-replace";
-
-export default defineSirocConfig({
-  rollup: {
-    output: {
-      sourcemap: true,
-    },
-    plugins: [
-      replace({
-        "process.env.PUBLIC_SM_INIT_SEGMENT_KEY": `"${
-          process.env.PUBLIC_SM_INIT_SEGMENT_KEY ||
-          "JfTfmHaATChc4xueS7RcCBsixI71dJIJ"
-        }"`,
-        preventAssignment: true,
-      }),
-    ],
-  },
-});

package/src/steps/choose-or-create-a-repository.ts

@@ -1,169 +0,0 @@
-import * as inquirer from "inquirer";
-import Separator from "inquirer/lib/objects/separator";
-import { Models } from "@slicemachine/core";
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import { createRepository } from "../utils/create-repo";
-import { validateRepositoryName } from "../utils/validateRepositoryName";
-import { InitClient, logs } from "../utils";
-
-export const CREATE_REPO = "$_CREATE_REPO"; // not a valid domain name
-
-export function prettyRepoName(address: URL, domain: string): string {
-  return `${logs.cyan.dim(`${address.protocol}//`)}${logs.cyan(
-    domain
-  )}${logs.cyan.dim(`.${address.hostname}`)}`;
-}
-
-export async function promptForRepoDomain(
-  client: InitClient,
-  defaultValue?: string
-): Promise<string> {
-  const address = new URL(client.apisEndpoints.Wroom);
-
-  logs.writeInfo(
-    "The name acts as a domain/endpoint for your content repo and should be completely unique."
-  );
-
-  return inquirer
-    .prompt<Record<string, string>>([
-      {
-        name: "repoDomain",
-        message: "Name your Prismic repository",
-        type: "input",
-        required: true,
-        default: defaultValue,
-        transformer: (value: string | undefined) =>
-          prettyRepoName(address, value || defaultValue || "repository"),
-        validate: (name: string) => validateRepositoryName(client, name),
-      },
-    ])
-    .then((res) => res.repoDomain);
-}
-
-export type RepoPrompt = { name: string; value: string; disabled?: string };
-
-export type PromptOrSeparator = RepoPrompt | Separator;
-
-export type RepoPrompts = Array<PromptOrSeparator>;
-
-export function makeReposPretty(base: string) {
-  return function ({ name, domain, role }: Models.Repository): RepoPrompt {
-    const address = new URL(base);
-    address.hostname = `${domain}.${address.hostname}`;
-    if (Models.canUpdateCustomTypes(role) === false) {
-      return {
-        name: `${logs.purple.dim("Use")} ${logs.bold.dim(
-          name
-        )} ${logs.purple.dim(`"${address.hostname}"`)}`,
-        value: domain,
-        disabled: "Unauthorized",
-      };
-    }
-
-    return {
-      name: `${logs.purple("Use")} ${logs.bold(name)} ${logs.purple(
-        `"${address.hostname}"`
-      )}`,
-      value: domain,
-    };
-  };
-}
-
-export function orderPrompts(maybeName?: string | null) {
-  return (a: PromptOrSeparator, b: PromptOrSeparator): number => {
-    if (a instanceof Separator || b instanceof Separator) return 0;
-    if (maybeName && (a.value === maybeName || b.value === maybeName)) return 0;
-    if (a.value === CREATE_REPO || b.value === CREATE_REPO) return 0;
-    if (a.disabled && !b.disabled) return 1;
-    if (!a.disabled && b.disabled) return -1;
-    return 0;
-  };
-}
-
-export function maybeStickTheRepoToTheTopOfTheList(repoName?: string | null) {
-  return (acc: RepoPrompts, curr: RepoPrompt): RepoPrompts => {
-    if (repoName && curr.value === repoName) {
-      return [curr, ...acc];
-    }
-    return [...acc, curr];
-  };
-}
-
-export function sortReposForPrompt(
-  repos: Models.Repositories,
-  base: string,
-  cwd: string
-): RepoPrompts {
-  const createNew = {
-    name: `${logs.purple("Create a")} ${logs.bold("new")} ${logs.purple(
-      "Repository"
-    )}`,
-    value: CREATE_REPO,
-  };
-
-  const maybeConfiguredRepoName = NodeUtils.maybeRepoNameFromSMFile(cwd, base);
-
-  return repos
-    .reverse()
-    .map(makeReposPretty(base))
-    .reduce(maybeStickTheRepoToTheTopOfTheList(maybeConfiguredRepoName), [
-      createNew,
-    ])
-    .sort(orderPrompts(maybeConfiguredRepoName));
-}
-
-export async function chooseOrCreateARepository(
-  client: InitClient,
-  cwd: string,
-  framework: Models.Frameworks,
-  preSelectedRepository?: string
-): Promise<string> {
-  const repositories: Models.Repository[] = await client.listRepositories();
-
-  const isPreSelectedValid =
-    preSelectedRepository &&
-    repositories.find(
-      (repository) => repository.domain === preSelectedRepository
-    );
-  if (isPreSelectedValid) return preSelectedRepository;
-
-  // No repository to display, ask for a new repository name to create it.
-  if (repositories.length === 0) {
-    const domainName = await promptForRepoDomain(client, preSelectedRepository);
-    await createRepository(client, domainName, framework);
-    return domainName;
-  }
-
-  // prepare the list of repositories to display
-  const choices = sortReposForPrompt(
-    repositories,
-    client.apisEndpoints.Wroom,
-    cwd
-  );
-  const numberOfDisabledRepos = choices.filter((repo) => {
-    if (repo instanceof Separator) return false;
-    return repo.disabled;
-  }).length;
-
-  // display the list of repositories and wait for the user to choose one.
-  const promptResult = await inquirer.prompt<{ chosenRepository: string }>([
-    {
-      type: "list",
-      name: "chosenRepository",
-      default: 0,
-      required: true,
-      message: "Connect a Prismic Repository or create a new one",
-      choices,
-      pageSize: numberOfDisabledRepos + 2 <= 7 ? 7 : numberOfDisabledRepos + 2,
-    },
-  ]);
-
-  // If the user has chosen to create a new repository.
-  if (promptResult.chosenRepository === CREATE_REPO) {
-    const domainName = await promptForRepoDomain(client, preSelectedRepository);
-    await createRepository(client, domainName, framework);
-    return domainName;
-  }
-
-  return promptResult.chosenRepository;
-}

package/src/steps/configure-project.ts

@@ -1,72 +0,0 @@
-import type { Models } from "@slicemachine/core";
-import * as Prismic from "@slicemachine/core/build/prismic";
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import { FrameworkResult } from "./detect-framework";
-import { InitClient, logs } from "../utils";
-import Tracker from "../utils/tracker";
-
-export async function configureProject(
-  client: InitClient,
-  cwd: string,
-  repositoryDomainName: string,
-  framework: FrameworkResult,
-  sliceLibPath: string[] = [],
-  tracking = true
-): Promise<void> {
-  const frameworkName = NodeUtils.Framework.fancyName(framework.value);
-  const spinner = logs.spinner(
-    `Configuring your ${frameworkName} and Prismic project...`
-  );
-  spinner.start();
-
-  try {
-    const manifest = NodeUtils.retrieveManifest(cwd);
-    const manifestAlreadyExistWithContent = manifest.exists && manifest.content;
-
-    const libs =
-      manifest.content &&
-      manifest.content.libraries &&
-      manifest.content.libraries.length > 0
-        ? manifest.content.libraries
-        : ["@/slices"];
-
-    const manifestUpdated: Models.Manifest = {
-      ...(manifestAlreadyExistWithContent ? manifest.content : {}),
-      apiEndpoint: Prismic.Endpoints.buildRepositoryEndpoint(
-        client.apisEndpoints.Wroom,
-        repositoryDomainName
-      ),
-      libraries: [...libs, ...sliceLibPath], // odd case here for staters
-      ...(framework.manuallyAdded ? { framework: framework.value } : {}),
-      ...(!tracking ? { tracking } : {}),
-    };
-
-    if (!manifest.exists) NodeUtils.createManifest(cwd, manifestUpdated);
-    else NodeUtils.patchManifest(cwd, manifestUpdated);
-
-    // create the default slices folder if it doesn't exist.
-    const pathToSlicesFolder = NodeUtils.CustomPaths(cwd)
-      .library("slices")
-      .value();
-    if (
-      !NodeUtils.Files.exists(pathToSlicesFolder) &&
-      libs.includes("@/slices")
-    ) {
-      NodeUtils.Files.mkdir(pathToSlicesFolder, { recursive: true });
-    }
-
-    // add slicemachine script to package.json.
-    NodeUtils.addJsonPackageSmScript(cwd);
-
-    await Tracker.get().trackInitEndSuccess(framework.value);
-
-    spinner.succeed("Project configured! Ready to start");
-  } catch (error) {
-    await Tracker.get().trackInitEndFail(
-      framework.value,
-      "Failed to configure Slice Machine"
-    );
-    spinner.fail("Failed to configure Slice Machine");
-    process.exit(-1);
-  }
-}

package/src/steps/detect-framework.ts

@@ -1,94 +0,0 @@
-import { Models } from "@slicemachine/core";
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import * as inquirer from "inquirer";
-import { logs } from "../utils";
-import Tracker from "../utils/tracker";
-
-export type FrameworkResult = {
-  value: Models.Frameworks;
-  manuallyAdded: boolean;
-  version?: string;
-};
-
-export async function promptForFramework(): Promise<FrameworkResult> {
-  const choices = Models.SupportedFrameworks.map((framework) => {
-    return {
-      name: NodeUtils.Framework.fancyName(framework),
-      value: framework,
-    };
-  });
-
-  return inquirer
-    .prompt<{ framework: Models.Frameworks }>([
-      {
-        name: "framework",
-        type: "list",
-        message: "Select a framework to use",
-        required: true,
-        choices,
-      },
-    ])
-    .then((res) => {
-      return {
-        value: res.framework,
-        manuallyAdded: true,
-        version: undefined,
-      };
-    });
-}
-
-export async function detectFramework(cwd: string): Promise<FrameworkResult> {
-  const failMessage = `Please run ${logs.bold(
-    "npx @slicemachine/init"
-  )} in a Nuxt or Next.js project`;
-
-  const spinner = logs.spinner(
-    "Detecting framework to install correct dependencies"
-  );
-
-  spinner.start();
-
-  try {
-    const { framework, version } =
-      NodeUtils.Framework.defineFrameworkWithVersion({
-        cwd,
-        supportedFrameworks: Object.values(Models.Frameworks),
-      });
-
-    spinner.stop();
-
-    if (!framework || framework === Models.Frameworks.vanillajs) {
-      logs.writeError("Framework not detected");
-      return await promptForFramework();
-    }
-
-    const nameToPrint = NodeUtils.Framework.fancyName(framework);
-
-    if (!NodeUtils.Framework.isFrameworkSupported(framework)) {
-      logs.writeError(`${nameToPrint} is currently not supported`);
-      console.log(failMessage);
-      process.exit(1);
-    }
-
-    logs.writeCheck(`${nameToPrint} detected`);
-
-    return {
-      value: framework,
-      manuallyAdded: false,
-      version,
-    };
-  } catch (error) {
-    spinner.fail("package.json not found");
-
-    if (error instanceof Error && error.message) {
-      logs.writeError(error.message);
-    } else {
-      console.log(failMessage);
-    }
-    await Tracker.get().trackInitEndFail(
-      Models.Frameworks.none,
-      "Framework not detected"
-    );
-    process.exit(1);
-  }
-}

package/src/steps/display-final-message.ts

@@ -1,31 +0,0 @@
-import { CONSTS } from "@slicemachine/core";
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import { logs } from "../utils";
-
-export function displayFinalMessage(
-  cwd: string,
-  wasStarter: boolean,
-  reponame: string,
-  base: string
-): void {
-  const yarnLock = NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd));
-  const command = `${yarnLock ? "yarn" : "npm"} run ${CONSTS.SCRIPT_NAME}`;
-  console.log();
-
-  if (wasStarter) {
-    const repoUrl = new URL(base);
-    repoUrl.hostname = `${reponame}.${repoUrl.hostname}`;
-    const urlAsString = repoUrl.toString();
-
-    const message = `${logs.white(
-      "■"
-    )} Start editing your content in Prismic ${logs.purple(urlAsString)}`;
-    console.log(message);
-  } else {
-    console.log(
-      `${logs.white("■")} Run ${logs.purple(
-        command
-      )} to launch Slice Machine and create your first Custom Type`
-    );
-  }
-}

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