@slicemachine/init 1.1.19 → 2.0.0

package/src/steps/starters/slices.ts

@@ -1,75 +0,0 @@
-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 { promptToPushSlices } from "./prompts";
-import { updateSlicesWithScreenshots } from "./s3";
-import { writeError } from "../../utils/logs";
-
-export async function sendSlices(
-  client: InitClient,
-  cwd: string,
-  manifest: Manifest
-): Promise<boolean> {
-  if (!manifest.libraries) return Promise.resolve(false); // No libraries defined
-
-  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);
-  }
-
-  const spinner = logs.spinner(
-    "Pushing existing Slice models to your repository"
-  );
-  spinner.start();
-
-  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;
-    });
-
-  // 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);
-
-  await Promise.all(
-    models.map(async (model) => {
-      const slice = Slices.fromSM(model);
-
-      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/steps/validate-pkg.ts

@@ -1,14 +0,0 @@
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import { logs } from "../utils";
-
-export function validatePkg(cwd: string): void {
-  const jsonPackage = NodeUtils.retrieveJsonPackage(cwd);
-  if (!jsonPackage.exists) {
-    logs.writeError(`package.json not found. Are you in the right folder?`);
-    return process.exit(-1);
-  }
-  if (!jsonPackage.content) {
-    logs.writeError(`could not parse package.json.`);
-    return process.exit(-1);
-  }
-}

package/src/utils/PackageManager.ts

@@ -1,66 +0,0 @@
-import * as NodeUtils from "@slicemachine/core/build/node-utils";
-import { execCommand } from "../utils";
-
-export type Dependency = string | { name: string; version: string };
-export const Dependencies = {
-  fromPkgFormat(
-    pkgDeps: Record<string, string> | undefined
-  ): ReadonlyArray<Dependency> | undefined {
-    if (!pkgDeps) return;
-
-    return Object.entries(pkgDeps).map(([name, version]) => ({
-      name,
-      version,
-    }));
-  },
-};
-function formatDeps(dependencies: ReadonlyArray<Dependency>): string {
-  return dependencies
-    .map((dep) => {
-      if (typeof dep === "string") return dep;
-      return `${dep.name}@${dep.version}`;
-    })
-    .join(" ");
-}
-
-export interface PackageManager {
-  install(dependencies: ReadonlyArray<Dependency>): Promise<{ stderr: string }>;
-  installDev(
-    dependencies: ReadonlyArray<Dependency>
-  ): Promise<{ stderr: string }>;
-}
-
-export const PackageManager = {
-  get(cwd: string): PackageManager {
-    if (NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd))) {
-      return Yarn;
-    }
-    return Npm;
-  },
-};
-
-export const Yarn: PackageManager = {
-  install(
-    dependencies: ReadonlyArray<Dependency>
-  ): Promise<{ stderr: string }> {
-    return execCommand(`yarn add ${formatDeps(dependencies)}`);
-  },
-  installDev(
-    dependencies: ReadonlyArray<Dependency>
-  ): Promise<{ stderr: string }> {
-    return execCommand(`yarn add --dev ${formatDeps(dependencies)}`);
-  },
-};
-
-export const Npm: PackageManager = {
-  install(
-    dependencies: ReadonlyArray<Dependency>
-  ): Promise<{ stderr: string }> {
-    return execCommand(`npm i --save ${formatDeps(dependencies)}`);
-  },
-  installDev(
-    dependencies: ReadonlyArray<Dependency>
-  ): Promise<{ stderr: string }> {
-    return execCommand(`npm i --save-dev ${formatDeps(dependencies)}`);
-  },
-};

package/src/utils/auth/helpers.ts

@@ -1,168 +0,0 @@
-import * as hapi from "@hapi/hapi";
-import open from "open";
-import * as logs from "../logs";
-import { Utils, CONSTS } from "@slicemachine/core";
-import { PrismicSharedConfigManager } from "@slicemachine/core/build/prismic";
-
-const { Cookie } = Utils;
-const { DEFAULT_BASE, DEFAULT_SERVER_PORT } = CONSTS;
-
-const { bold, underline, spinner, writeError } = logs;
-
-export type HandlerData = { email: string; cookies: ReadonlyArray<string> };
-
-export const isHandlerData = (
-  data: string | Record<string, unknown>
-): data is HandlerData => {
-  if (typeof data != "object") return false;
-
-  const { email, cookies } = data as Partial<HandlerData>;
-  return (
-    Boolean(email && cookies) &&
-    Array.isArray(cookies) &&
-    !cookies.some((c: unknown) => typeof c !== "string")
-  );
-};
-
-const Routes = {
-  authentication:
-    (server: hapi.Server) =>
-    (
-      onSuccess: (data: HandlerData) => void,
-      onFail: () => void
-    ): hapi.ServerRoute => ({
-      method: "POST",
-      path: "/",
-      handler: authenticationHandler(server)(onSuccess, onFail),
-    }),
-
-  notFound: {
-    method: ["GET", "POST"],
-    path: "/{any*}",
-    handler: (
-      request: hapi.Request,
-      h: hapi.ResponseToolkit
-    ): hapi.ResponseObject => {
-      return h
-        .response(`not found: [${request.method}]: ${request.url.toString()}`)
-        .code(404);
-    },
-  },
-};
-
-export function validatePayload(
-  payload: Buffer | string | Record<string, unknown>
-): HandlerData | null {
-  if (Buffer.isBuffer(payload)) return null;
-  return isHandlerData(payload) ? payload : null;
-}
-
-const authenticationHandler =
-  (server: hapi.Server) =>
-  (onSuccess: (data: HandlerData) => void, onFail: () => void) => {
-    return (request: hapi.Request, h: hapi.ResponseToolkit) => {
-      try {
-        const data: HandlerData | null = validatePayload(
-          request.payload as Buffer | string | Record<string, unknown>
-        ); // type coming from the lib
-
-        if (!data) {
-          onFail();
-          h.response("Error with cookies").code(400);
-          throw new Error(
-            "It seems the server didn't respond properly, please contact us."
-          );
-        }
-        onSuccess(data);
-        return h.response(data).code(200);
-      } finally {
-        void server.stop({ timeout: 10000 });
-      }
-    };
-  };
-
-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: [stripTrailingSlash(base)],
-        headers: ["Origin", "X-Requested-With", "Content-Type", "Accept"],
-      },
-    },
-  });
-  return server;
-}
-
-export function askSingleChar(title: string): Promise<string> {
-  return new Promise((resolve) => {
-    process.stdout.write(title);
-    const rawMode: boolean = process.stdin.isRaw;
-    if (process.stdin.setRawMode) process.stdin.setRawMode(true);
-
-    function handler(key: Buffer) {
-      const response: string = key.toString("utf-8");
-      if (process.stdin.setRawMode) process.stdin.setRawMode(Boolean(rawMode));
-      process.stdin.removeListener("data", handler);
-      resolve(response);
-    }
-
-    process.stdin.on("data", handler);
-  });
-}
-
-export async function startServerAndOpenBrowser(
-  url: string,
-  action: "login" | "signup",
-  base: string = DEFAULT_BASE,
-  port: number = DEFAULT_SERVER_PORT
-): Promise<{
-  onLoginFail: () => void;
-}> {
-  const confirmation = await askSingleChar(
-    `>> Press any key to open the browser to ${action} or q to exit:`
-  );
-  if (confirmation === "q" || confirmation === "\u0003")
-    return process.exit(-1);
-
-  const s = spinner("Waiting for the browser response");
-
-  const onLoginFail = () => {
-    s.stop();
-    writeError(`We failed to log you into your Prismic account`);
-    console.log(`Run ${bold("npx slicemachine init")} again!`);
-    process.exit(-1);
-  };
-
-  function onSuccess(data: HandlerData) {
-    s.succeed(`Logged in as ${bold(data.email)}`).stop();
-    PrismicSharedConfigManager.setProperties({
-      cookies: Cookie.serializeCookies(data.cookies),
-      base,
-    });
-  }
-
-  function onFail(): void {
-    onLoginFail();
-  }
-
-  const server = buildServer(base, port, "localhost");
-  server.route([
-    Routes.authentication(server)(onSuccess, onFail),
-    Routes.notFound,
-  ]);
-
-  return server.start().then(() => {
-    console.log("\nOpening browser to " + underline(url));
-    s.start();
-    void open(url);
-    return {
-      onLoginFail,
-    };
-  });
-}

package/src/utils/auth/index.ts

@@ -1,63 +0,0 @@
-import { Utils } from "@slicemachine/core";
-import { startServerAndOpenBrowser } from "./helpers";
-import {
-  Endpoints,
-  PrismicSharedConfigManager,
-} from "@slicemachine/core/build/prismic";
-import { InitClient } from "../client";
-
-async function startAuth({
-  client,
-  url,
-  action,
-}: {
-  client: InitClient;
-  url: string;
-  action: "signup" | "login";
-}): Promise<void> {
-  const { onLoginFail } = await startServerAndOpenBrowser(
-    url,
-    action,
-    client.apisEndpoints.Wroom
-  );
-  try {
-    // We wait 3 minutes before timeout
-    await Utils.Poll.startPolling<boolean, boolean>(
-      () => Auth.validateSession(client),
-      (isSessionValid): isSessionValid is boolean => isSessionValid == true,
-      3000,
-      60
-    );
-    return;
-  } catch (e) {
-    onLoginFail();
-  }
-}
-
-export const Auth = {
-  login: async (client: InitClient): Promise<void> => {
-    const endpoints = Endpoints.buildEndpoints(client.apisEndpoints.Wroom);
-    return startAuth({
-      client,
-      url: endpoints.Dashboard.cliLogin,
-      action: "login",
-    });
-  },
-  validateSession: async (client: InitClient): Promise<boolean> => {
-    const authToken = PrismicSharedConfigManager.getAuth();
-
-    // 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

@@ -1,89 +0,0 @@
-import * as t from "io-ts";
-import { Models } from "@slicemachine/core";
-import { PrismicSharedConfigManager } from "@slicemachine/core/build/prismic";
-import { Client, getAndValidateResponse } from "@slicemachine/client";
-import { parse } from "@slicemachine/core/build/utils/cookie";
-
-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 deleteRepository(
-    domain: string,
-    password: string,
-    cookies: string
-  ): Promise<string> {
-    const repositoryDirectUrl = new URL(this.apisEndpoints.Wroom);
-    repositoryDirectUrl.hostname = `${domain}.${repositoryDirectUrl.hostname}`;
-
-    const token = parse(cookies).X_XSRF;
-
-    return this._fetch({
-      method: "post",
-      url: `${repositoryDirectUrl.toString()}app/settings/delete?_=${token}`,
-      data: { confirm: domain, password },
-      headers: {
-        Cookie: cookies,
-        "User-Agent": "prismic-cli/0", // 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,37 +0,0 @@
-import type { Models } from "@slicemachine/core";
-import * as logs from "./logs";
-import { InitClient } from "./client";
-import Tracker from "../utils/tracker";
-
-export function createRepository(
-  client: InitClient,
-  domain: string,
-  framework: Models.Frameworks
-): Promise<string> {
-  const spinner = logs.spinner("Creating Prismic Repository");
-  spinner.start();
-
-  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 domain;
-    })
-    .catch(async (error: Error) => {
-      spinner.fail(`Error creating repository ${domain}`);
-      await Tracker.get().trackInitEndFail(
-        framework,
-        "Failed to create repository"
-      );
-      if (error.message) {
-        logs.writeError(error.message);
-      }
-      logs.writeError(`We failed to create you new prismic repository`);
-      console.log(`Run ${logs.bold("npx @slicemachine/init")} again!`);
-      process.exit(-1);
-    });
-}

package/src/utils/fs.ts

@@ -1,18 +0,0 @@
-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,42 +0,0 @@
-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 * from "./versionCheck";
-
-export function findArgument(args: string[], name: string): string | undefined {
-  const flagIndex: number = args.indexOf(`--${name}`);
-
-  if (flagIndex === -1) return;
-  if (args.length < flagIndex + 2) return;
-
-  const flagValue = args[flagIndex + 1];
-
-  if (flagValue.startsWith("--")) return;
-  return flagValue;
-}
-
-export function findFlag(args: string[], name: string): boolean {
-  const toFind = `--${name}`;
-  return args.includes(toFind);
-}
-
-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/logs.ts

@@ -1,28 +0,0 @@
-import chalk from "chalk";
-import ora from "ora";
-
-export const purple = chalk.hex("8c76fc");
-export const error = chalk.hex("FF6868");
-export const warning = chalk.hex("F3AD38");
-export const underline = chalk.underline;
-export const bold = chalk.bold;
-export const dim = chalk.dim;
-export const cyan = chalk.cyan;
-export const yellow = chalk.yellow;
-export const white = chalk.white;
-
-export const spinner = ora;
-
-export const writeError = (msg: string, prefix = "Error!"): void =>
-  console.error(`${error(prefix)} ${msg}`);
-
-export const writeWarning = (msg: string, prefix = "Warning!"): void =>
-  console.warn(`${warning(prefix)} ${msg}`);
-
-export const writeCheck = (msg: string): void => {
-  ora().succeed(msg); // using the same check as Ora for coherence
-};
-
-export const writeInfo = (msg: string): void => {
-  console.log(`${yellow("ℹ")} ${dim(msg)}`);
-};

package/src/utils/noop.ts

@@ -1,3 +0,0 @@
-// no op nice to mock in tests
-
-export default () => void 0;