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

package/build/index.js

@@ -2,7 +2,7 @@
 
 'use strict';
 
-const core = require('@slicemachine/core');
+const client = require('@slicemachine/client');
 const Prismic = require('@slicemachine/core/build/prismic');
 const ServerAnalytics = require('analytics-node');
 const uuid = require('uuid');
@@ -11,28 +11,24 @@ const util = require('util');
 const child_process = require('child_process');
 const chalk = require('chalk');
 const ora = require('ora');
+const core = require('@slicemachine/core');
 const hapi = require('@hapi/hapi');
 const open = require('open');
+const t = require('io-ts');
+const fs = require('fs');
 const NodeUtils = require('@slicemachine/core/build/node-utils');
 const inquirer = require('inquirer');
 const Separator = require('inquirer/lib/objects/separator');
-const axios = require('axios');
-const _function = require('fp-ts/function');
-const Either = require('fp-ts/Either');
 const tmp = require('tmp');
 const AdmZip = require('adm-zip');
 const fsExtra = require('fs-extra');
-const fs = require('fs');
-const cookie = require('@slicemachine/core/build/utils/cookie');
-const Libraries = require('@slicemachine/core/build/libraries');
+const axios = require('axios');
+const Either = require('fp-ts/Either');
 const models = require('@slicemachine/core/build/models');
-const mime = require('mime');
-const snakeCase = require('lodash.snakecase');
-const FormData = require('form-data');
-const uniqid = require('uniqid');
+const Libraries = require('@slicemachine/core/build/libraries');
 const customtypes = require('@prismicio/types-internal/lib/customtypes');
 const Either$1 = require('fp-ts/lib/Either');
-const t = require('io-ts');
+const SharedConfig = require('@slicemachine/core/build/prismic/SharedConfig');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -63,21 +59,17 @@ const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
 const ora__default = /*#__PURE__*/_interopDefaultLegacy(ora);
 const hapi__namespace = /*#__PURE__*/_interopNamespace(hapi);
 const open__default = /*#__PURE__*/_interopDefaultLegacy(open);
+const t__namespace = /*#__PURE__*/_interopNamespace(t);
+const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 const NodeUtils__namespace = /*#__PURE__*/_interopNamespace(NodeUtils);
 const inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
 const inquirer__default = /*#__PURE__*/_interopDefaultLegacy(inquirer);
 const Separator__default = /*#__PURE__*/_interopDefaultLegacy(Separator);
-const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 const tmp__default = /*#__PURE__*/_interopDefaultLegacy(tmp);
 const AdmZip__default = /*#__PURE__*/_interopDefaultLegacy(AdmZip);
 const fsExtra__default = /*#__PURE__*/_interopDefaultLegacy(fsExtra);
-const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 const Libraries__namespace = /*#__PURE__*/_interopNamespace(Libraries);
-const mime__default = /*#__PURE__*/_interopDefaultLegacy(mime);
-const snakeCase__default = /*#__PURE__*/_interopDefaultLegacy(snakeCase);
-const FormData__default = /*#__PURE__*/_interopDefaultLegacy(FormData);
-const uniqid__default = /*#__PURE__*/_interopDefaultLegacy(uniqid);
-const t__namespace = /*#__PURE__*/_interopNamespace(t);
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -98,6 +90,13 @@ var __privateSet = (obj, member, value, setter) => {
   return value;
 };
 var _client, _isTrackingActive, _anonymousId, _userId, _repository;
+var EventType;
+(function(EventType2) {
+  EventType2["DownloadLibrary"] = "SliceMachine Download Library";
+  EventType2["InitStart"] = "SliceMachine Init Start";
+  EventType2["InitIdentify"] = "SliceMachine Init Identify";
+  EventType2["InitEnd"] = "SliceMachine Init End";
+})(EventType || (EventType = {}));
 class InitTracker {
   constructor() {
     __privateAdd(this, _client, null);
@@ -164,16 +163,28 @@ class InitTracker {
     return this._identifyEvent(userId, intercomHash);
   }
   trackDownloadLibrary(library) {
-    return this._trackEvent("SliceMachine Download Library" /* DownloadLibrary */, { library });
+    return this._trackEvent(EventType.DownloadLibrary, { library });
   }
   trackInitIdentify() {
-    return this._trackEvent("SliceMachine Init Identify" /* InitIdentify */);
+    return this._trackEvent(EventType.InitIdentify);
   }
   trackInitStart(repoDomain) {
-    return this._trackEvent("SliceMachine Init Start" /* InitStart */, { repo: repoDomain });
+    return this._trackEvent(EventType.InitStart, { repo: repoDomain });
   }
-  trackInitDone(framework) {
-    return this._trackEvent("SliceMachine Init Done" /* InitDone */, { framework });
+  trackInitEndSuccess(framework) {
+    return this._trackEvent(EventType.InitEnd, {
+      framework,
+      repo: __privateGet(this, _repository),
+      result: "success"
+    });
+  }
+  trackInitEndFail(framework, error) {
+    return this._trackEvent(EventType.InitEnd, {
+      framework,
+      repo: __privateGet(this, _repository),
+      result: "error",
+      error
+    });
   }
 }
 _client = new WeakMap();
@@ -231,7 +242,7 @@ const logs = /*#__PURE__*/Object.freeze({
 });
 
 const { Cookie } = core.Utils;
-const { DEFAULT_BASE: DEFAULT_BASE$1, DEFAULT_SERVER_PORT } = core.CONSTS;
+const { DEFAULT_BASE, DEFAULT_SERVER_PORT } = core.CONSTS;
 const { bold, underline, spinner, writeError } = logs;
 const isHandlerData = (data) => {
   if (typeof data != "object")
@@ -274,13 +285,16 @@ const authenticationHandler = (server) => (onSuccess, onFail) => {
     }
   };
 };
+function stripTrailingSlash(str) {
+  return str.endsWith("/") ? str.slice(0, -1) : str;
+}
 function buildServer(base, port, host) {
   const server = hapi__namespace.server({
     port,
     host,
     routes: {
       cors: {
-        origin: [base],
+        origin: [stripTrailingSlash(base)],
         headers: ["Origin", "X-Requested-With", "Content-Type", "Accept"]
       }
     }
@@ -303,7 +317,7 @@ function askSingleChar(title) {
     process.stdin.on("data", handler);
   });
 }
-async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE$1, port = DEFAULT_SERVER_PORT) {
+async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE, port = DEFAULT_SERVER_PORT) {
   const confirmation = await askSingleChar(`>> Press any key to open the browser to ${action} or q to exit:`);
   if (confirmation === "q" || confirmation === "")
     return process.exit(-1);
@@ -340,46 +354,92 @@ async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE$1, por
 }
 
 async function startAuth({
-  base,
+  client,
   url,
   action
 }) {
-  const { onLoginFail } = await startServerAndOpenBrowser(url, action, base);
+  const { onLoginFail } = await startServerAndOpenBrowser(url, action, client.apisEndpoints.Wroom);
   try {
-    await core.Utils.Poll.startPolling(() => Auth.validateSession(base), (user) => !!user, 3e3, 60);
+    await core.Utils.Poll.startPolling(() => Auth.validateSession(client), (isSessionValid) => isSessionValid == true, 3e3, 60);
     return;
   } catch (e) {
     onLoginFail();
   }
 }
 const Auth = {
-  login: async (base) => {
-    const endpoints = Prismic.Endpoints.buildEndpoints(base);
+  login: async (client) => {
+    const endpoints = Prismic.Endpoints.buildEndpoints(client.apisEndpoints.Wroom);
     return startAuth({
-      base,
+      client,
       url: endpoints.Dashboard.cliLogin,
       action: "login"
     });
   },
-  signup: async (base) => {
-    const endpoints = Prismic.Endpoints.buildEndpoints(base);
-    return startAuth({
-      base,
-      url: endpoints.Dashboard.cliSignup,
-      action: "signup"
-    });
-  },
-  logout: () => Prismic.PrismicSharedConfigManager.remove(),
-  validateSession: async (requiredBase) => {
-    const config = Prismic.PrismicSharedConfigManager.get();
-    if (!config.cookies.length)
-      return Promise.resolve(null);
-    if (requiredBase != config.base)
-      return Promise.resolve(null);
-    return Prismic.Communication.validateSession(config.cookies, requiredBase).catch(() => null);
+  validateSession: async (client) => {
+    const authToken = Prismic.PrismicSharedConfigManager.getAuth();
+    return client.updateAuthenticationToken(authToken).profile().then((userProfile) => {
+      Prismic.PrismicSharedConfigManager.setProperties({
+        shortId: userProfile.shortId,
+        intercomHash: userProfile.intercomHash
+      });
+      return true;
+    }).catch(() => false);
   }
 };
 
+class InitClient extends client.Client {
+  async listRepositories() {
+    return client.getAndValidateResponse(this._get(`${this.apisEndpoints.Users}repositories`), "repository list", t__namespace.array(core.Models.Repository));
+  }
+  async createRepository(domain, framework) {
+    const data = {
+      domain,
+      framework,
+      plan: "personal",
+      isAnnual: "false",
+      role: "developer"
+    };
+    return this._fetch({
+      method: "post",
+      url: `${this.apisEndpoints.Wroom}authentication/newrepository?app=slicemachine`,
+      data,
+      headers: {
+        Cookie: Prismic.PrismicSharedConfigManager.get().cookies,
+        "User-Agent": "prismic-cli/sm"
+      }
+    }).then(() => domain);
+  }
+  async domainExist(domain) {
+    return client.getAndValidateResponse(this._get(`${this.apisEndpoints.Wroom}app/dashboard/repositories/${domain}/exists`), "repository exists", t__namespace.boolean);
+  }
+  async pushDocuments(signature, documents, cookies) {
+    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"
+      }
+    });
+  }
+}
+
+async function lsdir(dir) {
+  return fs__default["default"].promises.readdir(dir).then((dirs) => {
+    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isDirectory()).map((subdirectory) => path__default["default"].join(dir, subdirectory));
+  });
+}
+async function lsfiles(dir) {
+  return fs__default["default"].promises.readdir(dir).then((dirs) => {
+    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isFile()).map((file) => path__default["default"].join(dir, file));
+  });
+}
+
 function findArgument(args, name) {
   const flagIndex = args.indexOf(`--${name}`);
   if (flagIndex === -1)
@@ -396,6 +456,16 @@ function findFlag(args, name) {
   return args.includes(toFind);
 }
 const execCommand = util__default["default"].promisify(child_process.exec);
+function getApplicationMode(argumentValue) {
+  switch (argumentValue) {
+    case client.ApplicationMode.PROD:
+    case client.ApplicationMode.STAGE:
+    case client.ApplicationMode.DEV:
+      return argumentValue;
+    default:
+      return null;
+  }
+}
 
 const {
   PRISMIC_CLIENT,
@@ -465,18 +535,18 @@ function validatePkg(cwd) {
   }
 }
 
-function createRepository(domain, framework, cookies, base) {
+function createRepository(client, domain, framework) {
   const spinner = spinner$1("Creating Prismic Repository");
   spinner.start();
-  return Prismic__namespace.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((domain2) => {
+    const addressUrl = new URL(client.apisEndpoints.Wroom);
+    addressUrl.hostname = `${domain2}.${addressUrl.hostname}`;
     const address = addressUrl.toString();
     spinner.succeed(`We created your new repository ${address}`);
-    return repoDomainName;
-  }).catch((error) => {
+    return domain2;
+  }).catch(async (error) => {
     spinner.fail(`Error creating repository ${domain}`);
+    await Tracker.get().trackInitEndFail(framework, "Failed to create repository");
     if (error.message) {
       writeError$1(error.message);
     }
@@ -486,14 +556,38 @@ function createRepository(domain, framework, cookies, base) {
   });
 }
 
+async function validateRepositoryName(client, name) {
+  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`)));
+}
+
 const CREATE_REPO = "$_CREATE_REPO";
-const DEFAULT_BASE = core.CONSTS.DEFAULT_BASE;
-function prettyRepoName(address, value) {
-  const repoName = value ? cyan(value) : dim.cyan("repo-name");
-  return `${cyan.dim(`${address.protocol}//`)}${repoName}${cyan.dim(`.${address.hostname}`)}`;
+function prettyRepoName(address, domain) {
+  return `${cyan.dim(`${address.protocol}//`)}${cyan(domain)}${cyan.dim(`.${address.hostname}`)}`;
 }
-async function promptForRepoDomain(base, defaultValue) {
-  const address = new URL(base);
+async function promptForRepoDomain(client, defaultValue) {
+  const address = new URL(client.apisEndpoints.Wroom);
   writeInfo("The name acts as a domain/endpoint for your content repo and should be completely unique.");
   return inquirer__namespace.prompt([
     {
@@ -502,11 +596,8 @@ async function promptForRepoDomain(base, defaultValue) {
       type: "input",
       required: true,
       default: defaultValue,
-      transformer: (value) => prettyRepoName(address, value || defaultValue),
-      async validate(name) {
-        const result = await Prismic__namespace.Communication.validateRepositoryName(name, base, false);
-        return result === name || result;
-      }
+      transformer: (value) => prettyRepoName(address, value || defaultValue || "repository"),
+      validate: (name) => validateRepositoryName(client, name)
     }
   ]).then((res) => res.repoDomain);
 }
@@ -560,26 +651,26 @@ function sortReposForPrompt(repos, base, cwd) {
     createNew
   ]).sort(orderPrompts(maybeConfiguredRepoName));
 }
-async function chooseOrCreateARepository(cwd, framework, cookies, base = DEFAULT_BASE, domain) {
-  const token = core.Utils.Cookie.parsePrismicAuthToken(cookies);
-  const repos = await Prismic__namespace.Communication.listRepositories(token, base);
-  const hasRepo = domain && repos.find((d) => d.domain === domain);
-  if (hasRepo)
-    return domain;
-  if (repos.length === 0) {
-    const domainName = await promptForRepoDomain(base, domain);
-    return await createRepository(domainName, framework, cookies, base);
+async function chooseOrCreateARepository(client, cwd, framework, preSelectedRepository) {
+  const repositories = await client.listRepositories();
+  const isPreSelectedValid = preSelectedRepository && repositories.find((repository) => repository.domain === preSelectedRepository);
+  if (isPreSelectedValid)
+    return preSelectedRepository;
+  if (repositories.length === 0) {
+    const domainName = await promptForRepoDomain(client, preSelectedRepository);
+    await createRepository(client, domainName, framework);
+    return domainName;
   }
-  const choices = sortReposForPrompt(repos, base, cwd);
+  const choices = sortReposForPrompt(repositories, client.apisEndpoints.Wroom, cwd);
   const numberOfDisabledRepos = choices.filter((repo) => {
     if (repo instanceof Separator__default["default"])
       return false;
     return repo.disabled;
   }).length;
-  const res = await inquirer__namespace.prompt([
+  const promptResult = await inquirer__namespace.prompt([
     {
       type: "list",
-      name: "chosenRepo",
+      name: "chosenRepository",
       default: 0,
       required: true,
       message: "Connect a Prismic Repository or create a new one",
@@ -587,11 +678,12 @@ async function chooseOrCreateARepository(cwd, framework, cookies, base = DEFAULT
       pageSize: numberOfDisabledRepos + 2 <= 7 ? 7 : numberOfDisabledRepos + 2
     }
   ]);
-  if (res.chosenRepo === CREATE_REPO) {
-    const domainName = await promptForRepoDomain(base, domain);
-    return await createRepository(domainName, framework, cookies, base);
+  if (promptResult.chosenRepository === CREATE_REPO) {
+    const domainName = await promptForRepoDomain(client, preSelectedRepository);
+    await createRepository(client, domainName, framework);
+    return domainName;
   }
-  return res.chosenRepo;
+  return promptResult.chosenRepository;
 }
 
 async function promptForFramework() {
@@ -648,60 +740,26 @@ async function detectFramework(cwd) {
     } else {
       console.log(failMessage);
     }
+    await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Framework not detected");
     process.exit(1);
   }
 }
 
-async function getUserProfile(cookies, base = core.CONSTS.DEFAULT_BASE) {
-  const userServiceBase = core.CONSTS.DEFAULT_BASE === base ? core.CONSTS.USER_SERVICE_BASE : core.CONSTS.USER_SERVICE_STAGING_BASE;
-  const url = new URL(userServiceBase);
-  url.pathname = "profile";
-  const endpoint = url.toString();
-  const token = core.Utils.Cookie.parsePrismicAuthToken(cookies);
-  return axios__default["default"].get(endpoint, {
-    headers: {
-      Authorization: `Bearer ${token}`
-    }
-  }).then((res) => _function.pipe(core.Models.UserProfile.decode(res.data), Either.fold(() => {
-    throw new Error("Can't parse user profile");
-  }, (data) => data)));
-}
-async function validateSessionAndGetProfile(base = core.CONSTS.DEFAULT_BASE) {
-  const config = Prismic__namespace.PrismicSharedConfigManager.get();
-  if (!config.cookies.length)
-    return Promise.resolve(null);
-  if (base != config.base)
-    return Promise.resolve(null);
-  try {
-    const info = await Prismic__namespace.Communication.validateSession(config.cookies, base);
-    const profile = await getUserProfile(config.cookies, base).catch(() => null);
-    if (profile == null ? void 0 : profile.shortId) {
-      Prismic__namespace.PrismicSharedConfigManager.setProperties({
-        shortId: profile.shortId,
-        intercomHash: profile.intercomHash
-      });
-    }
-    return { info, profile };
-  } catch (e) {
-    return null;
-  }
-}
-
-async function loginOrBypass(base) {
-  const user = await validateSessionAndGetProfile(base).catch((err) => console.log(err));
+async function loginOrBypass(client) {
+  const user = await client.profile().catch(() => null);
   if (user) {
-    const email = user.info.email;
+    const email = user.email;
     writeCheck(`Logged in as ${bold$1(email)}`);
     return user;
-  } else {
-    await Auth.login(base);
-    const user2 = await validateSessionAndGetProfile(base);
-    return user2;
   }
+  await Auth.login(client);
+  client.updateAuthenticationToken(Prismic.PrismicSharedConfigManager.getAuth());
+  const userAfterLogin = await client.profile();
+  return userAfterLogin;
 }
 
 const defaultSliceMachineVersion = "0.0.41";
-async function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
+async function configureProject(client, cwd, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
   const frameworkName = NodeUtils__namespace.Framework.fancyName(framework.value);
   const spinner = spinner$1(`Configuring your ${frameworkName} and Prismic project...`);
   spinner.start();
@@ -713,7 +771,7 @@ async function configureProject(cwd, base, repositoryDomainName, framework, slic
     const libs = manifest.content && manifest.content.libraries && manifest.content.libraries.length > 0 ? manifest.content.libraries : ["@/slices"];
     const manifestUpdated = {
       ...manifestAlreadyExistWithContent ? manifest.content : { _latest: sliceMachineVersionInstalled },
-      apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(base, repositoryDomainName),
+      apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(client.apisEndpoints.Wroom, repositoryDomainName),
       libraries: [...libs, ...sliceLibPath],
       ...framework.manuallyAdded ? { framework: framework.value } : {},
       ...!tracking ? { tracking } : {}
@@ -727,9 +785,10 @@ async function configureProject(cwd, base, repositoryDomainName, framework, slic
       NodeUtils__namespace.Files.mkdir(pathToSlicesFolder, { recursive: true });
     }
     NodeUtils__namespace.addJsonPackageSmScript(cwd);
-    await Tracker.get().trackInitDone(framework.value);
+    await Tracker.get().trackInitEndSuccess(framework.value);
     spinner.succeed("Project configured! Ready to start");
-  } catch (e) {
+  } catch (error) {
+    await Tracker.get().trackInitEndFail(framework.value, "Failed to configure Slice Machine");
     spinner.fail("Failed to configure Slice Machine");
     process.exit(-1);
   }
@@ -874,104 +933,11 @@ async function installLib(cwd, libGithubPath, branch = "HEAD") {
     if (error instanceof Error) {
       console.error(error.message);
     }
+    await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Failed to install ${libGithubPath} library");
     process.exit(-1);
   }
 }
 
-function handleErrors(prefix, err) {
-  if (axios__default["default"].isAxiosError(err) && err.response) {
-    writeError$1(`${prefix} | [${err.response.status}]: ${err.response.statusText}`);
-  } else if (err instanceof Error) {
-    writeError$1(`${prefix} ${err.message}`);
-  } else {
-    writeError$1(`${prefix} ${String(err)}`);
-  }
-}
-async function getRemoteSliceIds(customTypeApiEndpoint, repository, authorization) {
-  const addr = `${stripLastSlash(customTypeApiEndpoint)}/slices`;
-  return axios__default["default"].get(addr, {
-    headers: {
-      Authorization: `Bearer ${authorization}`,
-      repository
-    }
-  }).then((res) => {
-    return Array.isArray(res.data) ? res.data.map((model) => model.id) : [];
-  });
-}
-async function sendModelToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, model) {
-  const data = models.Slices.fromSM(model);
-  const updateOrInsertUrl = `${customTypesApiEndpoint}slices/${remoteSliceIds.includes(model.id) ? "update" : "insert"}`;
-  return axios__default["default"].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;
-  });
-}
-async function sendManyModelsToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, models) {
-  return Promise.all(models.map((model) => sendModelToPrismic(repository, authorization, customTypesApiEndpoint, remoteSliceIds, model))).then(() => {
-    return;
-  }).catch(() => {
-    process.exit(1);
-  });
-}
-function stripLastSlash(str) {
-  return str.replace(/\/*$/g, "");
-}
-function getRemoteCustomTypeIds(customTypeApiEndpoint, repository, authorization) {
-  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes`;
-  return axios__default["default"].get(addr, {
-    headers: {
-      Authorization: `Bearer ${authorization}`,
-      repository
-    }
-  }).then((res) => {
-    return Array.isArray(res.data) ? res.data.map((ct) => ct.id) : [];
-  });
-}
-async function sendCustomTypeToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customType) {
-  const shouldUpdate = remoteCustomTypeIds.includes(customType.id);
-  const addr = `${stripLastSlash(customTypeApiEndpoint)}/customtypes/${shouldUpdate ? "update" : "insert"}`;
-  return axios__default["default"].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;
-  });
-}
-async function sendManyCustomTypesToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customTypes) {
-  return Promise.all(customTypes.map((customType) => sendCustomTypeToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customType))).then(() => {
-    return;
-  }).catch(() => {
-    process.exit(1);
-  });
-}
-
-const ProductionApisEndpoints = {
-  Models: "https://customtypes.prismic.io/",
-  AclProvider: "https://0yyeb2g040.execute-api.us-east-1.amazonaws.com/prod/"
-};
-const StageApisEndpoints = {
-  Models: "https://customtypes.wroom.io/",
-  AclProvider: "https://2iamcvnxf4.execute-api.us-east-1.amazonaws.com/stage/"
-};
-const getEndpointsFromBase = (base) => {
-  const url = new URL(base);
-  if (url.hostname === "wroom.io")
-    return StageApisEndpoints;
-  return ProductionApisEndpoints;
-};
-
 async function promptToPushSlices() {
   return inquirer__default["default"].prompt([
     {
@@ -988,127 +954,80 @@ async function promptToPushCustomTypes() {
       type: "confirm",
       name: "pushCustomTypes",
       default: false,
-      message: "Your repository already contains Custom Types. Do you want to continue pushing your local Slices?"
+      message: "Your repository already contains Custom Types. Do you want to continue pushing your local Custom Types?"
     }
   ]).then((res) => res.pushCustomTypes);
 }
 
-async function createAcl(address, repository, authorization) {
-  return axios__default["default"].get(address + "create", {
-    headers: {
-      repository,
-      Authorization: `Bearer ${authorization}`,
-      "User-Agent": "slice-machine"
-    }
-  }).then((res) => res.data);
-}
-async function createFormForS3(key, filename, filePath, acl) {
-  const form = new FormData__default["default"]();
-  Object.entries(acl.values.fields).forEach(([k, value]) => {
-    form.append(k, value);
-  });
-  form.append("key", key);
-  const contentType = mime__default["default"].getType(filePath);
-  contentType && form.append("Content-Type", contentType);
-  return fs__default["default"].promises.readFile(filePath).then((file) => {
-    form.append("file", file, { filename });
-    return form;
-  }).catch(() => {
-    writeError$1(`Error reading preview image: ${filename}`);
-    return null;
-  });
-}
-function createS3Key(repository, sliceName, variationId, filename) {
-  return `${repository}/shared-slices/${snakeCase__default["default"](sliceName)}/${snakeCase__default["default"](variationId)}-${uniqid__default["default"]()}/${filename}`;
-}
-async function sendVariationPreviewToS3(acl, repository, sliceName, variationId, filePath) {
-  const filename = path__default["default"].basename(filePath);
-  const key = createS3Key(repository, sliceName, variationId, filename);
-  const form = await createFormForS3(key, filename, filePath, acl);
-  if (form === null)
-    return null;
-  if (form.hasKnownLength() === false) {
-    writeError$1(`[slice/push] An error occurred while uploading preview image ${filePath} as length in unknown`);
-  }
-  const errorMessage = `[slice/push] An error occurred while uploading preview images for ${sliceName}-${variationId} - please contact support`;
-  return axios__default["default"].post(acl.values.url, form, {
-    headers: {
-      ...form.getHeaders(),
-      "Content-Length": String(form.getLengthSync())
-    }
-  }).then((res) => {
-    if (res.status !== 204) {
-      writeError$1(errorMessage);
-      writeError$1(`${res.status}: ${res.statusText}`);
-      return null;
-    } else {
-      return `${acl.imgixEndpoint}/${key}`;
-    }
-  }).catch((err) => {
-    writeError$1(errorMessage);
-    if (axios__default["default"].isAxiosError(err) && err.response) {
-      writeError$1(`${err.response.status}: ${err.response.statusText}`);
-    } else if (err instanceof Error) {
-      writeError$1(err.message);
-    } else {
-      writeError$1(String(err));
-    }
-    return null;
-  });
-}
-async function maybeAddImageUrlToVariation(acl, repository, modelId, pathToScreenShot, variation) {
-  const imageUrl = await sendVariationPreviewToS3(acl, repository, modelId, variation.id, pathToScreenShot);
-  if (!imageUrl)
+async function updateVariationWithScreenshot(client, acl, screenshotPaths, sliceName, variation) {
+  const screenshot = screenshotPaths[variation.id];
+  if (!screenshot || !screenshot.path)
+    return Promise.resolve(variation);
+  return client.uploadScreenshot({
+    acl,
+    sliceName,
+    variationId: variation.id,
+    filePath: screenshot.path
+  }).then((screenshotUrl) => {
+    return {
+      ...variation,
+      imageUrl: screenshotUrl
+    };
+  }).catch((error) => {
+    writeError$1(`Couldn't upload screenshot slice: ${sliceName} - variation: ${variation.id}`);
+    writeError$1(error.message, "Full error:");
     return variation;
-  return {
-    ...variation,
-    imageUrl
-  };
+  });
 }
-async function addImageUrlsToVariations(acl, repository, modelId, screenshotPaths, variations) {
-  return Promise.all(variations.map(async (variation) => {
-    const screenshot = screenshotPaths[variation.id];
-    if (!screenshot || !screenshot.path)
-      return variation;
-    return maybeAddImageUrlToVariation(acl, repository, modelId, screenshot.path, variation);
+async function updateSlicesWithScreenshots(client, acl, components) {
+  return Promise.all(components.map(async (component) => {
+    const { screenshotPaths, model } = component;
+    const variationsUpdated = await Promise.all(model.variations.map(async (variation) => updateVariationWithScreenshot(client, acl, screenshotPaths, model.id, variation)));
+    return {
+      ...model,
+      variations: variationsUpdated
+    };
   }));
 }
-async function maybeUpdateModelVariationsWithImageUrl(acl, repository, component) {
-  const { screenshotPaths, model } = component;
-  const variations = await addImageUrlsToVariations(acl, repository, model.id, screenshotPaths, model.variations);
-  return {
-    ...model,
-    variations
-  };
-}
-async function addImageUrlsToModelVariations(acl, repository, components) {
-  return Promise.all(components.map(async (component) => maybeUpdateModelVariationsWithImageUrl(acl, repository, component)));
-}
 
-async function sendSlicesFromStarter(base, repository, authorization, libraryPaths, cwd) {
-  const endpoints = getEndpointsFromBase(base);
-  const libraries = Libraries__namespace.libraries(cwd, libraryPaths);
-  if (libraries.length === 0)
+async function sendSlices(client, cwd, manifest) {
+  if (!manifest.libraries)
     return Promise.resolve(false);
-  const remoteSlices = await getRemoteSliceIds(endpoints.Models, repository, authorization);
-  if (remoteSlices.length) {
+  const libraries = Libraries__namespace.libraries(cwd, manifest.libraries);
+  const components = libraries.reduce((acc, lib) => {
+    return [...acc, ...lib.components];
+  }, []);
+  if (components.length === 0)
+    return Promise.resolve(false);
+  const remoteSlicesIds = await client.getSlices().then((slices) => slices.map((slice) => slice.id));
+  if (remoteSlicesIds.length) {
     const pushAnyway = await promptToPushSlices();
     if (pushAnyway === false)
       return Promise.resolve(true);
   }
   const spinner = spinner$1("Pushing existing Slice models to your repository");
   spinner.start();
-  const acl = await createAcl(endpoints.AclProvider, repository, authorization);
-  const components = libraries.reduce((acc, lib) => {
-    return [...acc, ...lib.components];
-  }, []);
-  const models = await addImageUrlsToModelVariations(acl, repository, components);
-  await sendManyModelsToPrismic(repository, authorization, endpoints.Models, remoteSlices, models);
+  const acl = await client.createAcl().catch((error) => {
+    writeError$1("Uploading screenshots for your slices failed, please contact us.");
+    writeError$1(error.message, "Full error:");
+    return null;
+  });
+  const models$1 = acl ? await updateSlicesWithScreenshots(client, acl, components) : components.map((component) => component.model);
+  await Promise.all(models$1.map(async (model) => {
+    const slice = models.Slices.fromSM(model);
+    const promise = remoteSlicesIds.includes(slice.id) ? client.updateSlice(slice) : client.insertSlice(slice);
+    return promise.catch((error) => {
+      writeError$1(`Sending slice ${model.id} - ${error.message}`);
+      throw error;
+    });
+  })).catch(() => {
+    process.exit(1);
+  });
   spinner.succeed();
   return Promise.resolve(true);
 }
 
-function readCustomTypes(cwd) {
+function readLocalCustomTypes(cwd) {
   const customTypePaths = NodeUtils.CustomTypesPaths(cwd);
   const dir = customTypePaths.value();
   if (NodeUtils.Files.isDirectory(dir) === false)
@@ -1132,12 +1051,11 @@ function readCustomTypes(cwd) {
   }, []);
   return files;
 }
-async function sendCustomTypesFromStarter(repository, authorization, base, cwd) {
-  const customTypeApiEndpoint = getEndpointsFromBase(base).Models;
-  const customTypes = readCustomTypes(cwd);
-  if (customTypes.length === 0)
+async function sendCustomTypes(client, cwd) {
+  const localCustomTypes = readLocalCustomTypes(cwd);
+  if (localCustomTypes.length === 0)
     return Promise.resolve(false);
-  const remoteCustomTypeIds = await getRemoteCustomTypeIds(customTypeApiEndpoint, repository, authorization);
+  const remoteCustomTypeIds = await client.getCustomTypes().then((customTypes) => customTypes.map((customType) => customType.id));
   if (remoteCustomTypeIds.length) {
     const shouldPush = await promptToPushCustomTypes();
     if (shouldPush === false)
@@ -1145,7 +1063,15 @@ async function sendCustomTypesFromStarter(repository, authorization, base, cwd)
   }
   const spinner = spinner$1("Pushing existing custom types to your repository");
   spinner.start();
-  await sendManyCustomTypesToPrismic(repository, authorization, customTypeApiEndpoint, remoteCustomTypeIds, customTypes);
+  await Promise.all(localCustomTypes.map(async (customType) => {
+    const promise = remoteCustomTypeIds.includes(customType.id) ? client.updateCustomType(customType) : client.insertCustomType(customType);
+    return promise.catch((error) => {
+      writeError$1(`Sending custom type ${customType.id} - ${error.message}`);
+      throw error;
+    });
+  })).catch(() => {
+    process.exit(1);
+  });
   spinner.succeed();
   return Promise.resolve(true);
 }
@@ -1162,120 +1088,96 @@ async function readSignatureFile(cwd) {
     })(SignatureFileReader.decode(data));
   });
 }
-async function lsdir(dir) {
-  return fs__default["default"].promises.readdir(dir).then((dirs) => {
-    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isDirectory()).map((subdirectory) => path__default["default"].join(dir, subdirectory));
-  });
-}
-async function lsfiles(dir) {
-  return fs__default["default"].promises.readdir(dir).then((dirs) => {
-    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isFile()).map((file) => path__default["default"].join(dir, file));
-  });
-}
 async function readDocuments(cwd) {
   const documentDir = path__default["default"].join(cwd, "documents");
   const dirs = await lsdir(documentDir);
   const files = (await Promise.all(dirs.map((dir) => lsfiles(dir)))).flat();
   const documentObj = files.reduce((acc, file) => {
-    const fileContent = fs__default["default"].readFileSync(file, "utf-8");
     const filename = path__default["default"].parse(file).name;
-    acc[filename] = JSON.parse(fileContent);
-    return acc;
+    const fileContent = fs__default["default"].readFileSync(file, "utf-8");
+    const json = JSON.parse(fileContent);
+    return { ...acc, [filename]: json };
   }, {});
-  return JSON.stringify(documentObj);
+  return documentObj;
 }
-const sendDocumentsFromStarter = async (repository, cookies, base, cwd) => {
+async function sendDocuments(client, cwd) {
   const pathToDocuments = path__default["default"].join(cwd, "documents");
   const pathToSignatureFile = path__default["default"].join(pathToDocuments, "index.json");
-  if (!fs__default["default"].existsSync(pathToSignatureFile)) {
+  if (!fs__default["default"].existsSync(pathToSignatureFile))
     return Promise.resolve(false);
-  }
   const signatureObj = await readSignatureFile(cwd);
-  const documentsStr = await readDocuments(cwd);
-  const payload = {
-    signature: signatureObj.signature,
-    documents: documentsStr
-  };
-  const prismicUrl = new URL(base);
-  prismicUrl.hostname = `${repository}.${prismicUrl.hostname}`;
-  prismicUrl.pathname = "starter/documents";
-  const endpointURL = prismicUrl.toString();
+  const documents = await readDocuments(cwd);
+  if (Object.keys(documents).length === 0)
+    return Promise.resolve(false);
   const spinner = spinner$1("Pushing existing documents to your repository");
   spinner.start();
-  return axios__default["default"].post(endpointURL, payload, {
-    headers: {
-      "User-Agent": "prismic-cli/0",
-      Cookie: cookies
-    }
-  }).then(() => {
+  return client.pushDocuments(signatureObj.signature, documents, SharedConfig.PrismicSharedConfigManager.get().cookies).then(() => {
     spinner.succeed();
     fs__default["default"].rmSync(pathToDocuments, { recursive: true, force: true });
     return true;
-  }).catch((e) => {
+  }).catch(async (e) => {
     var _a;
     spinner.fail();
     if (((_a = e.response) == null ? void 0 : _a.data) === "Repository should not contain documents") {
       writeError$1("The selected repository is not empty, documents cannot be uploaded. Please choose an empty repository or delete the documents contained in your repository.");
     } else {
-      handleErrors("sending documents, please try again. If the problem persists, contact us.", e);
+      writeError$1("Sending documents failed, please try again. If the problem persists, contact us.");
+      writeError$1(`Full error: ${e.code || 500} - ${e.message}`);
     }
+    await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Failed to push documents");
     process.exit(1);
   });
-};
+}
 
-async function sendStarterData(repository, base, cookies, sendDocs = true, cwd) {
-  const smJson = NodeUtils.retrieveManifest(cwd);
-  const pathToDocuments = path__default["default"].join(cwd, "documents");
-  const hasDocuments = NodeUtils.Files.exists(pathToDocuments);
-  if (smJson.exists === false || hasDocuments === false)
+async function sendStarterData(client, cwd, pushDocuments = true) {
+  const manifest = NodeUtils.retrieveManifest(cwd);
+  const documentsPath = path__default["default"].join(cwd, "documents");
+  const hasDocuments = NodeUtils.Files.exists(documentsPath);
+  if (manifest.exists === false || hasDocuments === false)
     return Promise.resolve(false);
-  const authTokenFromCookie = cookie.parsePrismicAuthToken(cookies);
-  if (smJson.content && smJson.content.libraries) {
-    await sendSlicesFromStarter(base, repository, authTokenFromCookie, smJson.content.libraries, cwd);
-  }
-  await sendCustomTypesFromStarter(repository, authTokenFromCookie, base, cwd);
-  if (sendDocs === false) {
-    fs__default["default"].rmSync(pathToDocuments, { recursive: true, force: true });
+  if (manifest.content)
+    await sendSlices(client, cwd, manifest.content);
+  await sendCustomTypes(client, cwd);
+  if (!pushDocuments) {
+    fs__default["default"].rmSync(documentsPath, { recursive: true, force: true });
     return Promise.resolve(true);
   }
-  return sendDocumentsFromStarter(repository, cookies, base, cwd);
+  return sendDocuments(client, cwd);
 }
 
 async function init() {
   const cwd = findArgument(process.argv, "cwd") || process.cwd();
-  const base = findArgument(process.argv, "base") || core.CONSTS.DEFAULT_BASE;
+  const mode = getApplicationMode(findArgument(process.argv, "mode")) || client.ApplicationMode.PROD;
   const lib = findArgument(process.argv, "library");
   const branch = findArgument(process.argv, "branch");
   const isTrackingAvailable = findArgument(process.argv, "tracking") !== "false";
-  const maybeRepositorySubdomain = findArgument(process.argv, "repository");
-  const sendDocs = !findFlag(process.argv, "no-docs");
+  const preSelectedRepository = findArgument(process.argv, "repository");
+  const pushDocuments = !findFlag(process.argv, "no-docs");
   Tracker.get().initialize("JfTfmHaATChc4xueS7RcCBsixI71dJIJ" , isTrackingAvailable);
-  void Tracker.get().trackInitStart(maybeRepositorySubdomain);
+  void Tracker.get().trackInitStart(preSelectedRepository);
+  const client$1 = new InitClient(mode, null, Prismic__default["default"].PrismicSharedConfigManager.getAuth());
   console.log(purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
   validatePkg(cwd);
-  const user = await loginOrBypass(base);
-  if (!user)
-    throw new Error("The user should be logged in!");
-  if (user.profile) {
-    Tracker.get().identifyUser(user.profile.shortId, user.profile.intercomHash);
-  }
+  const user = await loginOrBypass(client$1);
+  Tracker.get().identifyUser(user.shortId, user.intercomHash);
   void Tracker.get().trackInitIdentify();
-  const config = Prismic__default["default"].PrismicSharedConfigManager.get();
   const frameworkResult = await detectFramework(cwd);
-  const repositoryDomainName = await chooseOrCreateARepository(cwd, frameworkResult.value, config.cookies, config.base, maybeRepositorySubdomain);
-  Tracker.get().setRepository(repositoryDomainName);
+  const repository = await chooseOrCreateARepository(client$1, cwd, frameworkResult.value, preSelectedRepository);
+  Tracker.get().setRepository(repository);
+  client$1.updateRepository(repository);
   const sliceLibPath = lib ? await installLib(cwd, lib, branch) : void 0;
-  const wasStarter = await sendStarterData(repositoryDomainName, config.base, config.cookies, sendDocs, cwd);
-  await configureProject(cwd, base, repositoryDomainName, frameworkResult, sliceLibPath, isTrackingAvailable);
+  const wasStarter = await sendStarterData(client$1, cwd, pushDocuments);
+  await configureProject(client$1, cwd, repository, frameworkResult, sliceLibPath, isTrackingAvailable);
   await installRequiredDependencies(cwd, frameworkResult.value, wasStarter);
-  displayFinalMessage(cwd, wasStarter, repositoryDomainName, config.base);
+  displayFinalMessage(cwd, wasStarter, repository, client$1.apisEndpoints.Wroom);
 }
 init().then(() => {
   process.exit(0);
-}).catch((error) => {
+}).catch(async (error) => {
   if (error instanceof Error)
     writeError$1(error.message);
   else
     console.error(error);
+  await Tracker.get().trackInitEndFail(core.Models.Frameworks.none, "Failed to initialise Slice Machine.");
 });
 //# sourceMappingURL=index.js.map