@slicemachine/init 1.1.10-alpha.5 → 1.1.11-alpha.2

package/src/utils/client.ts

@@ -0,0 +1,67 @@
+import * as t from "io-ts";
+import { Models } from "@slicemachine/core";
+import { PrismicSharedConfigManager } from "@slicemachine/core/build/prismic";
+import { Client, getAndValidateResponse } from "@slicemachine/client";
+
+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 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,33 +1,32 @@
 import type { Models } from "@slicemachine/core";
 import * as logs from "./logs";
-import * as Prismic from "@slicemachine/core/build/prismic";
+import { InitClient } from "./client";
+import Tracker from "../utils/tracker";
 
 export function createRepository(
+  client: InitClient,
   domain: string,
-  framework: Models.Frameworks,
-  cookies: string,
-  base: string
+  framework: Models.Frameworks
 ): Promise<string> {
   const spinner = logs.spinner("Creating Prismic Repository");
   spinner.start();
 
-  return Prismic.Communication.createRepository(
-    domain,
-    cookies,
-    framework,
-    base
-  )
-    .then((res) => {
-      const addressUrl = new URL(base);
-      const repoDomainName = res.data.domain || domain;
-      addressUrl.hostname = `${repoDomainName}.${addressUrl.hostname}`;
+  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 repoDomainName;
+      return domain;
     })
-    .catch((error: Error) => {
+    .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);
       }

package/src/utils/fs.ts

@@ -0,0 +1,18 @@
+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,7 +1,10 @@
+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 function findArgument(args: string[], name: string): string | undefined {
   const flagIndex: number = args.indexOf(`--${name}`);
@@ -23,3 +26,16 @@ export function findFlag(args: string[], name: string): boolean {
 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/tracker.ts

@@ -6,7 +6,7 @@ export enum EventType {
   DownloadLibrary = "SliceMachine Download Library",
   InitStart = "SliceMachine Init Start",
   InitIdentify = "SliceMachine Init Identify",
-  InitDone = "SliceMachine Init Done",
+  InitEnd = "SliceMachine Init End",
 }
 
 type SegmentIdentifier = { userId: string } | { anonymousId: string };
@@ -114,8 +114,21 @@ export class InitTracker {
     return this._trackEvent(EventType.InitStart, { repo: repoDomain });
   }
 
-  trackInitDone(framework: Models.Frameworks): Promise<void> {
-    return this._trackEvent(EventType.InitDone, { framework });
+  trackInitEndSuccess(framework: Models.Frameworks): Promise<void> {
+    return this._trackEvent(EventType.InitEnd, {
+      framework,
+      repo: this.#repository,
+      result: "success",
+    });
+  }
+
+  trackInitEndFail(framework: Models.Frameworks, error: string): Promise<void> {
+    return this._trackEvent(EventType.InitEnd, {
+      framework,
+      repo: this.#repository,
+      result: "error",
+      error,
+    });
   }
 }
 

package/src/utils/validateRepositoryName.ts

@@ -0,0 +1,44 @@
+import { InitClient } from "./client";
+
+export async function validateRepositoryName(
+  client: InitClient,
+  name: string
+): Promise<boolean> {
+  const domain = name.trim();
+  const errors = [];
+
+  const startsWithLetter = /^[a-zA-Z]/.test(domain);
+  if (!startsWithLetter) errors.push("Must start with a letter.");
+
+  const acceptedChars = /^[a-z0-9-]+$/.test(domain);
+  if (!acceptedChars)
+    errors.push("Must contain only lowercase letters, numbers and hyphens.");
+
+  const fourCharactersOrMore = domain.length >= 4;
+  if (!fourCharactersOrMore)
+    errors.push(
+      "Must have four or more alphanumeric characters and/or hyphens."
+    );
+
+  const endsWithALetterOrNumber = /[a-z0-9]$/.test(domain);
+  if (!endsWithALetterOrNumber)
+    errors.push("Must end in a letter or a number.");
+
+  const thirtyCharacterOrLess = domain.length <= 30;
+  if (!thirtyCharacterOrLess) errors.push("Must be 30 characters or less");
+
+  if (errors.length > 0) {
+    const errorString = errors.map((d, i) => `(${i + 1}: ${d}`).join(" ");
+    const msg = `Validation errors: ${errorString}`;
+    return Promise.reject(new Error(msg));
+  }
+
+  return client
+    .domainExist(domain)
+    .then((isAvailable) =>
+      isAvailable
+        ? true
+        : Promise.reject(new Error(`${name} is already in use`))
+    )
+    .catch(() => Promise.reject(new Error(`${name} is already in use`)));
+}

package/src/steps/starters/communication.ts

@@ -1,171 +0,0 @@
-import { CustomType } from "@prismicio/types-internal/lib/customtypes";
-import { Slices, SliceSM } from "@slicemachine/core/build/models";
-import axios from "axios";
-import { logs } from "../../utils";
-import type { ApiEndpoints } from "./endpoints";
-
-export function handleErrors(prefix: string, err: unknown) {
-  if (axios.isAxiosError(err) && err.response) {
-    logs.writeError(
-      `${prefix} | [${err.response.status}]: ${err.response.statusText}`
-    );
-  } else if (err instanceof Error) {
-    logs.writeError(`${prefix} ${err.message}`);
-  } else {
-    logs.writeError(`${prefix} ${String(err)}`);
-  }
-}
-
-export async function getRemoteSliceIds(
-  customTypeApiEndpoint: ApiEndpoints["Models"],
-  repository: string,
-  authorization: string
-): Promise<Array<string>> {
-  const addr = `${stripLastSlash(customTypeApiEndpoint)}/slices`;
-  return axios
-    .get<Array<{ id: string }>>(addr, {
-      headers: {
-        Authorization: `Bearer ${authorization}`,
-        repository,
-      },
-    })
-    .then((res) => {
-      return Array.isArray(res.data) ? res.data.map((model) => model.id) : [];
-    });
-}
-
-async function sendModelToPrismic(
-  repository: string,
-  authorization: string,
-  customTypesApiEndpoint: string,
-  remoteSliceIds: Array<string>,
-  model: SliceSM
-): Promise<void> {
-  const data = Slices.fromSM(model);
-  const updateOrInsertUrl = `${customTypesApiEndpoint}slices/${
-    remoteSliceIds.includes(model.id) ? "update" : "insert"
-  }`;
-
-  return axios
-    .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;
-    });
-}
-
-export async function sendManyModelsToPrismic(
-  repository: string,
-  authorization: string,
-  customTypesApiEndpoint: string,
-  remoteSliceIds: Array<string>,
-  models: Array<SliceSM>
-): Promise<void> {
-  return Promise.all(
-    models.map((model) =>
-      sendModelToPrismic(
-        repository,
-        authorization,
-        customTypesApiEndpoint,
-        remoteSliceIds,
-        model
-      )
-    )
-  )
-    .then(() => {
-      return;
-    })
-    .catch(() => {
-      process.exit(1);
-    });
-}
-
-function stripLastSlash(str: string) {
-  return str.replace(/\/*$/g, "");
-}
-
-export function getRemoteCustomTypeIds(
-  customTypeApiEndpoint: ApiEndpoints["Models"],
-  repository: string,
-  authorization: string
-): Promise<Array<string>> {
-  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes`;
-  return axios
-    .get<CustomType[]>(addr, {
-      headers: {
-        Authorization: `Bearer ${authorization}`,
-        repository,
-      },
-    })
-    .then((res) => {
-      return Array.isArray(res.data) ? res.data.map((ct) => ct.id) : [];
-    });
-}
-
-async function sendCustomTypeToPrismic(
-  repository: string,
-  authorization: string,
-  customTypeApiEndpoint: string,
-  remoteCustomTypeIds: Array<string>,
-  customType: CustomType
-): Promise<void> {
-  const shouldUpdate = remoteCustomTypeIds.includes(customType.id);
-  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes/${
-    shouldUpdate ? "update" : "insert"
-  }`;
-
-  return axios
-    .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;
-    });
-}
-
-export async function sendManyCustomTypesToPrismic(
-  repository: string,
-  authorization: string,
-  customTypeApiEndpoint: string,
-  remoteCustomTypeIds: Array<string>,
-  customTypes: Array<CustomType>
-): Promise<void> {
-  return Promise.all(
-    customTypes.map((customType) =>
-      sendCustomTypeToPrismic(
-        repository,
-        authorization,
-        customTypeApiEndpoint,
-        remoteCustomTypeIds,
-        customType
-      )
-    )
-  )
-    .then(() => {
-      return;
-    })
-    .catch(() => {
-      process.exit(1);
-    });
-}

package/src/steps/starters/endpoints.ts

@@ -1,20 +0,0 @@
-export type ApiEndpoints = {
-  Models: string;
-  AclProvider: string;
-};
-
-const ProductionApisEndpoints: ApiEndpoints = {
-  Models: "https://customtypes.prismic.io/",
-  AclProvider: "https://0yyeb2g040.execute-api.us-east-1.amazonaws.com/prod/",
-};
-
-const StageApisEndpoints: ApiEndpoints = {
-  Models: "https://customtypes.wroom.io/",
-  AclProvider: "https://2iamcvnxf4.execute-api.us-east-1.amazonaws.com/stage/",
-};
-
-export const getEndpointsFromBase = (base: string): ApiEndpoints => {
-  const url = new URL(base);
-  if (url.hostname === "wroom.io") return StageApisEndpoints;
-  return ProductionApisEndpoints;
-};

package/src/utils/communication.ts

@@ -1,72 +0,0 @@
-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, CONSTS } from "@slicemachine/core";
-import * as Prismic from "@slicemachine/core/build/prismic";
-
-export async function getUserProfile(
-  cookies: string,
-  base = CONSTS.DEFAULT_BASE
-): Promise<Models.UserProfile> {
-  const userServiceBase =
-    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);
-  url.pathname = "profile";
-
-  const endpoint = url.toString();
-  const token = Utils.Cookie.parsePrismicAuthToken(cookies);
-
-  return axios
-    .get<Models.UserProfile>(endpoint, {
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
-    })
-    .then((res) =>
-      pipe(
-        Models.UserProfile.decode(res.data),
-        fold<t.Errors, Models.UserProfile, Models.UserProfile>(
-          () => {
-            throw new Error("Can't parse user profile");
-          },
-          (data: Models.UserProfile) => data
-        )
-      )
-    );
-}
-
-export async function validateSessionAndGetProfile(
-  base = CONSTS.DEFAULT_BASE
-): Promise<{
-  info: Models.UserInfo;
-  profile: Models.UserProfile | null;
-} | null> {
-  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 Prismic.Communication.validateSession(
-      config.cookies,
-      base
-    );
-    const profile = await getUserProfile(config.cookies, base).catch(
-      () => null
-    );
-    if (profile?.shortId) {
-      Prismic.PrismicSharedConfigManager.setProperties({
-        shortId: profile.shortId,
-        intercomHash: profile.intercomHash,
-      });
-    }
-    return { info, profile };
-  } catch {
-    return null;
-  }
-}