@slicemachine/init 1.1.5-alpha.4 → 1.1.5-alpha.7

package/src/steps/install-lib.ts

@@ -1,4 +1,5 @@
-import { Utils } from "@slicemachine/core";
+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";
@@ -8,13 +9,10 @@ import fs from "fs";
 import path from "path";
 import { getOrElseW } from "fp-ts/Either";
 import { PackageManager, Dependencies } from "../utils/PackageManager";
-import { PackageJsonHelper } from "@slicemachine/core/build/src/utils/PackageJson";
-import {
-  Manifest,
-  ManifestHelper,
-} from "@slicemachine/core/build/src/models/Manifest";
-import Files from "@slicemachine/core/build/src/utils/files";
 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" });
@@ -40,7 +38,7 @@ export async function installLib(
   libGithubPath: string,
   branch = "HEAD"
 ): Promise<string[] | undefined> {
-  const spinner = Utils.spinner(
+  const spinner = logs.spinner(
     `Installing the ${libGithubPath} lib in your project...`
   );
 
@@ -77,22 +75,22 @@ export async function installLib(
     if (dependencies) await pkgManager.install(dependencies);
 
     // generate meta file
-    Files.write(path.join(libDestinationFolder, "meta.json"), {
+    NodeUtils.Files.write(path.join(libDestinationFolder, "meta.json"), {
       name: pkgJson.name,
     });
 
     // retrieve all slices lib paths
-    const manifest = Files.readEntity<Error | Manifest>(
+    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}`)
-        )(Manifest.decode(payload));
+        )(Models.Manifest.decode(payload));
       }
     );
     if (manifest instanceof Error) throw manifest;
 
-    const localLibs = ManifestHelper.localLibraries(manifest).map(
+    const localLibs = Models.ManifestHelper.localLibraries(manifest).map(
       ({ path }) => {
         return `~/${name}/${path.replace("src/", "")}`;
       }

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

@@ -1,6 +1,7 @@
 import path from "path";
-import { execCommand } from "../utils";
-import { Utils, FileSystem, Models } from "@slicemachine/core";
+import { execCommand, logs } from "../utils";
+import { CONSTS, Models } from "@slicemachine/core";
+import * as NodeUtils from "@slicemachine/core/build/node-utils";
 
 const {
   PRISMIC_CLIENT,
@@ -12,7 +13,7 @@ const {
   SLICE_SIMULATOR_REACT,
   SLICE_SIMULATOR_VUE,
   PRISMIC_HELPERS,
-} = Utils.CONSTS;
+} = CONSTS;
 
 function depsForFramework(framework: Models.Frameworks): string {
   switch (framework) {
@@ -35,13 +36,13 @@ export async function installRequiredDependencies(
   cwd: string,
   framework: Models.Frameworks
 ): Promise<void> {
-  const yarnLock = Utils.Files.exists(FileSystem.YarnLockPath(cwd));
+  const yarnLock = NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd));
   const installDevDependencyCommand = yarnLock
     ? "yarn add -D"
     : "npm install --save-dev";
   const installDependencyCommand = yarnLock ? "yarn add" : "npm install --save";
 
-  const spinner = Utils.spinner("Downloading Slice Machine");
+  const spinner = logs.spinner("Downloading Slice Machine");
   spinner.start();
 
   const { stderr } = await execCommand(
@@ -52,10 +53,10 @@ export async function installRequiredDependencies(
   if (deps) await execCommand(`${installDependencyCommand} ${deps}`);
 
   const pathToPkg = path.join(
-    FileSystem.PackagePaths(cwd).value(),
+    NodeUtils.PackagePaths(cwd).value(),
     SM_PACKAGE_NAME
   );
-  const isPackageInstalled = Utils.Files.exists(pathToPkg);
+  const isPackageInstalled = NodeUtils.Files.exists(pathToPkg);
 
   if (isPackageInstalled || !stderr.length) {
     spinner.succeed("Slice Machine was installed successfully");
@@ -63,7 +64,7 @@ export async function installRequiredDependencies(
   }
 
   spinner.fail();
-  Utils.writeWarning(
+  logs.writeWarning(
     `could not install ${SM_PACKAGE_NAME}. Please do it manually!`
   );
 }

package/src/steps/loginOrBypass.ts

@@ -1,5 +1,6 @@
-import { Utils, Auth, Models } from "@slicemachine/core";
+import { Models } from "@slicemachine/core";
 import { validateSessionAndGetProfile } from "../utils/communication";
+import { logs, Auth } from "../utils";
 
 export async function loginOrBypass(base: string): Promise<{
   info: Models.UserInfo;
@@ -10,7 +11,7 @@ export async function loginOrBypass(base: string): Promise<{
   );
   if (user) {
     const email = user.info.email;
-    Utils.writeCheck(`Logged in as ${Utils.bold(email)}`);
+    logs.writeCheck(`Logged in as ${logs.bold(email)}`);
     return user;
   } else {
     await Auth.login(base);

package/src/steps/validate-pkg.ts

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

package/src/utils/PackageManager.ts

@@ -1,4 +1,4 @@
-import { Utils, FileSystem } from "@slicemachine/core";
+import * as NodeUtils from "@slicemachine/core/build/node-utils";
 import { execCommand } from "../utils";
 
 export type Dependency = string | { name: string; version: string };
@@ -32,7 +32,7 @@ export interface PackageManager {
 
 export const PackageManager = {
   get(cwd: string): PackageManager {
-    if (Utils.Files.exists(FileSystem.YarnLockPath(cwd))) {
+    if (NodeUtils.Files.exists(NodeUtils.YarnLockPath(cwd))) {
       return Yarn;
     }
     return Npm;

package/src/utils/auth/helpers.ts

@@ -0,0 +1,164 @@
+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 buildServer(base: string, port: number, host: string): hapi.Server {
+  const server = hapi.server({
+    port,
+    host,
+    routes: {
+      cors: {
+        origin: [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

@@ -0,0 +1,63 @@
+import { Utils, Models } from "@slicemachine/core";
+import { startServerAndOpenBrowser } from "./helpers";
+import {
+  Communication,
+  Endpoints,
+  PrismicSharedConfigManager,
+} from "@slicemachine/core/build/prismic";
+
+async function startAuth({
+  base,
+  url,
+  action,
+}: {
+  base: string;
+  url: string;
+  action: "signup" | "login";
+}): Promise<void> {
+  const { onLoginFail } = await startServerAndOpenBrowser(url, action, base);
+  try {
+    // We wait 3 minutes before timeout
+    await Utils.Poll.startPolling<Models.UserInfo | null, Models.UserInfo>(
+      () => Auth.validateSession(base),
+      (user): user is Models.UserInfo => !!user,
+      3000,
+      60
+    );
+    return;
+  } catch (e) {
+    onLoginFail();
+  }
+}
+
+export const Auth = {
+  login: async (base: string): Promise<void> => {
+    const endpoints = Endpoints.buildEndpoints(base);
+    return startAuth({
+      base,
+      url: endpoints.Dashboard.cliLogin,
+      action: "login",
+    });
+  },
+  signup: async (base: string): Promise<void> => {
+    const endpoints = Endpoints.buildEndpoints(base);
+    return startAuth({
+      base,
+      url: endpoints.Dashboard.cliSignup,
+      action: "signup",
+    });
+  },
+  logout: (): void => PrismicSharedConfigManager.remove(),
+  validateSession: async (
+    requiredBase: string
+  ): Promise<Models.UserInfo | null> => {
+    const config = PrismicSharedConfigManager.get();
+
+    if (!config.cookies.length) return Promise.resolve(null); // default config, logged out.
+    if (requiredBase != config.base) return Promise.resolve(null); // not the same base so it doesn't count.
+
+    return Communication.validateSession(config.cookies, requiredBase).catch(
+      () => null
+    );
+  },
+};

package/src/utils/communication.ts

@@ -2,16 +2,17 @@ import axios from "axios";
 import * as t from "io-ts";
 import { pipe } from "fp-ts/function";
 import { fold } from "fp-ts/Either";
-import { Utils, Models, Communication, FileSystem } from "@slicemachine/core";
+import { Utils, Models, CONSTS } from "@slicemachine/core";
+import * as Prismic from "@slicemachine/core/build/prismic";
 
 export async function getUserProfile(
   cookies: string,
-  base = Utils.CONSTS.DEFAULT_BASE
+  base = CONSTS.DEFAULT_BASE
 ): Promise<Models.UserProfile> {
   const userServiceBase =
-    Utils.CONSTS.DEFAULT_BASE === base
-      ? Utils.CONSTS.USER_SERVICE_BASE
-      : Utils.CONSTS.USER_SERVICE_STAGING_BASE;
+    CONSTS.DEFAULT_BASE === base
+      ? CONSTS.USER_SERVICE_BASE
+      : CONSTS.USER_SERVICE_STAGING_BASE;
 
   // note the auth server also provides a userId
   const url = new URL(userServiceBase);
@@ -40,23 +41,26 @@ export async function getUserProfile(
 }
 
 export async function validateSessionAndGetProfile(
-  base = Utils.CONSTS.DEFAULT_BASE
+  base = CONSTS.DEFAULT_BASE
 ): Promise<{
   info: Models.UserInfo;
   profile: Models.UserProfile | null;
 } | null> {
-  const config = FileSystem.PrismicSharedConfigManager.get();
+  const config = Prismic.PrismicSharedConfigManager.get();
 
   if (!config.cookies.length) return Promise.resolve(null); // default config, logged out.
   if (base != config.base) return Promise.resolve(null); // not the same base so it doesn't
 
   try {
-    const info = await Communication.validateSession(config.cookies, base);
+    const info = await Prismic.Communication.validateSession(
+      config.cookies,
+      base
+    );
     const profile = await getUserProfile(config.cookies, base).catch(
       () => null
     );
     if (profile?.shortId) {
-      FileSystem.PrismicSharedConfigManager.setProperties({
+      Prismic.PrismicSharedConfigManager.setProperties({
         shortId: profile.shortId,
       });
     }

package/src/utils/create-repo.ts

@@ -1,5 +1,6 @@
-import { Communication, Utils } from "@slicemachine/core";
 import type { Models } from "@slicemachine/core";
+import * as logs from "./logs";
+import * as Prismic from "@slicemachine/core/build/prismic";
 
 export function createRepository(
   domain: string,
@@ -7,10 +8,15 @@ export function createRepository(
   cookies: string,
   base: string
 ): Promise<string> {
-  const spinner = Utils.spinner("Creating Prismic Repository");
+  const spinner = logs.spinner("Creating Prismic Repository");
   spinner.start();
 
-  return Communication.createRepository(domain, cookies, framework, base)
+  return Prismic.Communication.createRepository(
+    domain,
+    cookies,
+    framework,
+    base
+  )
     .then((res) => {
       const addressUrl = new URL(base);
       const repoDomainName = res.data.domain || domain;
@@ -23,10 +29,10 @@ export function createRepository(
     .catch((error: Error) => {
       spinner.fail(`Error creating repository ${domain}`);
       if (error.message) {
-        Utils.writeError(error.message);
+        logs.writeError(error.message);
       }
-      Utils.writeError(`We failed to create you new prismic repository`);
-      console.log(`Run ${Utils.bold("npx @slicemachine/init")} again!`);
+      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/index.ts

@@ -1,5 +1,7 @@
 import util from "util";
 import { exec } from "child_process";
+export * as logs from "./logs";
+export { Auth } from "./auth";
 
 export function findArgument(args: string[], name: string): string | undefined {
   const flagIndex: number = args.indexOf(`--${name}`);

package/src/utils/logs.ts

@@ -0,0 +1,28 @@
+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/tracker.ts

@@ -1,6 +1,6 @@
 import ServerAnalytics from "analytics-node";
 import { v4 as uuidv4 } from "uuid";
-import { Frameworks } from "@slicemachine/core/build/src/models";
+import { Models } from "@slicemachine/core";
 
 export enum EventType {
   DownloadLibrary = "SliceMachine Download Library",
@@ -90,11 +90,11 @@ export class InitTracker {
     this._trackEvent(EventType.DownloadLibrary, { library });
   }
 
-  trackInitStart(): void {
-    this._trackEvent(EventType.InitStart);
+  trackInitStart(repoDomain: string | undefined): void {
+    this._trackEvent(EventType.InitStart, { repo: repoDomain });
   }
 
-  trackInitDone(framework: Frameworks, repoDomain: string): void {
+  trackInitDone(framework: Models.Frameworks, repoDomain: string): void {
     this._trackEvent(EventType.InitDone, { framework, repo: repoDomain });
   }
 }