@joystick.js/cli-canary 0.0.0-canary.1

package/dist/functions/push/deploy/index.js

@@ -0,0 +1,173 @@
+import fetch from "node-fetch";
+import chalk from "chalk";
+import _ from "lodash";
+import fs from "fs";
+import FormData from "form-data";
+import Loader from "../../lib/loader.js";
+import domains from "./domains.js";
+import checkIfValidJSON from "../../lib/checkIfValidJSON.js";
+import CLILog from "../../lib/CLILog.js";
+import build from "../build/index.js";
+import getAvailableCDN from "../getAvailableCDN.js";
+import initialDeployment from "./initial.js";
+import versionDeployment from "./version.js";
+const getAppSettings = (environment = "") => {
+  try {
+    if (fs.existsSync(`settings.${environment}.json`)) {
+      const file = fs.readFileSync(`settings.${environment}.json`, "utf-8");
+      return file;
+    }
+    return "{}";
+  } catch (exception) {
+    throw new Error(`[initDeployment.getAppSettings] ${exception.message}`);
+  }
+};
+const startDeployment = async ({
+  isInitialDeployment = false,
+  loginSessionToken = "",
+  deployment = {},
+  version = "",
+  appSettings = "",
+  environment = "production",
+  server = "production"
+}) => {
+  try {
+    if (isInitialDeployment) {
+      return initialDeployment({
+        version,
+        deployment,
+        settings: appSettings,
+        environment,
+        loginSessionToken,
+        server
+      });
+    }
+    return versionDeployment({
+      version,
+      deployment,
+      settings: appSettings,
+      environment,
+      loginSessionToken,
+      server
+    });
+  } catch (exception) {
+    throw new Error(`[initDeployment.startDeployment] ${exception.message}`);
+  }
+};
+const uploadBuildToCDN = ({
+  mirror = "",
+  domain = "",
+  loginSessionToken = "",
+  deploymentId = "",
+  version = ""
+}) => {
+  try {
+    const formData = new FormData();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    formData.append(
+      "version_tar",
+      fs.readFileSync(`.build/build.tar.xz`),
+      `${timestamp}.tar.xz`
+    );
+    formData.append("deploymentId", deploymentId);
+    formData.append("version", version);
+    fetch(`${mirror}/api/uploads/receive`, {
+      method: "POST",
+      headers: {
+        ...formData.getHeaders(),
+        "x-deployment-domain": domain,
+        "x-login-session-token": loginSessionToken
+      },
+      body: formData
+    }).then(async (response) => {
+      const data = await response.json();
+      return data?.data;
+    });
+  } catch (exception) {
+    throw new Error(`[initDeployment.uploadBuildToCDN] ${exception.message}`);
+  }
+};
+const uploadVersionToCDN = async ({
+  loader,
+  deployment,
+  loginSessionToken,
+  version
+}) => {
+  try {
+    const availableCDN = await getAvailableCDN();
+    if (!availableCDN) {
+      loader.stop();
+      console.log(chalk.redBright(`
+Unable to upload version. Check status.cheatcode.co for availability.
+`));
+      process.exit();
+    }
+    await uploadBuildToCDN({
+      mirror: availableCDN,
+      domain: deployment?.domain,
+      loginSessionToken,
+      version,
+      deploymentId: deployment?._id
+    });
+  } catch (exception) {
+    throw new Error(`[actionName.uploadVersionToCDN] ${exception.message}`);
+  }
+};
+const buildApp = (environment = "production") => {
+  try {
+    return build({}, { isDeploy: true, type: "tar", environment });
+  } catch (exception) {
+    throw new Error(`[initDeployment.buildApp] ${exception.message}`);
+  }
+};
+const validateOptions = (options) => {
+  try {
+    if (!options)
+      throw new Error("options object is required.");
+    if (!options.loginSessionToken)
+      throw new Error("options.loginSessionToken is required.");
+  } catch (exception) {
+    throw new Error(`[initDeployment.validateOptions] ${exception.message}`);
+  }
+};
+const initDeployment = async (options, { resolve, reject }) => {
+  try {
+    validateOptions(options);
+    console.log("");
+    const loader = new Loader({ padding: "  ", defaultMessage: "Deploying app..." });
+    loader.text("Deploying app...");
+    const deploymentTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    await buildApp(options?.deployment?.environment || options?.environment);
+    const appSettings = getAppSettings(options?.environment);
+    loader.text("Uploading deployment...");
+    await uploadVersionToCDN({
+      loader,
+      loginSessionToken: options?.loginSessionToken,
+      deployment: options?.deployment,
+      version: deploymentTimestamp
+    });
+    loader.text("Starting deployment...");
+    await startDeployment({
+      isInitialDeployment: options?.isInitialDeployment,
+      loginSessionToken: options?.loginSessionToken,
+      deployment: options.deployment,
+      version: deploymentTimestamp,
+      appSettings,
+      environment: options?.environment,
+      server: options?.server
+    });
+    loader.stop();
+    console.log(chalk.greenBright(`Your app is deploying! To monitor progress, head to ${domains?.push}/deployments/${options?.deployment?.domain}
+`));
+    resolve();
+  } catch (exception) {
+    console.warn(exception);
+    reject(`[initDeployment] ${exception.message}`);
+  }
+};
+var deploy_default = (options) => new Promise((resolve, reject) => {
+  initDeployment(options, { resolve, reject });
+});
+export {
+  deploy_default as default
+};

package/dist/functions/push/deploy/initial.js

@@ -0,0 +1,100 @@
+import fs from "fs";
+import fetch from "node-fetch";
+import domains from "../domains.js";
+import checkIfValidJSON from "../../../lib/checkIfValidJSON.js";
+import CLILog from "../../../lib/CLILog.js";
+const pushDeploymentToProvision = ({
+  deploymentPayload = null,
+  loginSessionToken,
+  server = "production"
+}) => {
+  try {
+    return fetch(`${domains?.provision[server][0]}/api/deployments/initial`, {
+      method: "POST",
+      headers: {
+        ...deploymentPayload.getHeaders(),
+        "x-login-session-token": loginSessionToken
+      },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      const data = checkIfValidJSON(text);
+      const isPayloadSizeError = text?.includes("payload");
+      if (data?.error || isPayloadSizeError) {
+        CLILog(
+          data.error?.message || text,
+          {
+            level: "danger",
+            docs: isPayloadSizeError ? "https://cheatcode.co/docs/push/considerations/payload-size" : "https://cheatcode.co/docs/push"
+          }
+        );
+        process.exit(0);
+      }
+      return data?.data;
+    });
+  } catch (exception) {
+    throw new Error(`[initialDeployment.pushDeploymentToProvision] ${exception.message}`);
+  }
+};
+const getDeploymentPayload = ({
+  version,
+  deployment,
+  settings,
+  environment
+}) => {
+  try {
+    const formData2 = new FormData();
+    formData2.append("deployment", JSON.stringify({
+      ...deployment || {},
+      version,
+      settings,
+      environment
+    }));
+    return formData2;
+  } catch (exception) {
+    throw new Error(`[initialDeployment.getDeploymentPayload] ${exception.message}`);
+  }
+};
+const validateOptions = (options) => {
+  try {
+    if (!options)
+      throw new Error("options object is required.");
+    if (!options.version)
+      throw new Error("options.version is required.");
+    if (!options.deployment)
+      throw new Error("options.deployment is required.");
+    if (!options.settings)
+      throw new Error("options.settings is required.");
+    if (!options.environment)
+      throw new Error("options.environment is required.");
+    if (!options.loginSessionToken)
+      throw new Error("options.loginSessionToken is required.");
+  } catch (exception) {
+    throw new Error(`[initialDeployment.validateOptions] ${exception.message}`);
+  }
+};
+const initialDeployment = async (options, { resolve, reject }) => {
+  try {
+    validateOptions(options);
+    const deploymentPayload = getDeploymentPayload({
+      version: options?.version,
+      deployment: options?.deployment,
+      settings: options?.settings,
+      environment: options?.environment
+    });
+    await pushDeploymentToProvision({
+      deploymentPayload,
+      loginSessionToken: options?.loginSessionToken,
+      server: options?.server
+    });
+    resolve();
+  } catch (exception) {
+    reject(`[initialDeployment] ${exception.message}`);
+  }
+};
+var initial_default = (options) => new Promise((resolve, reject) => {
+  initialDeployment(options, { resolve, reject });
+});
+export {
+  initial_default as default
+};

package/dist/functions/push/deploy/version.js

@@ -0,0 +1,100 @@
+import fs from "fs";
+import fetch from "node-fetch";
+import domains from "./domains.js";
+import checkIfValidJSON from "../../../lib/checkIfValidJSON.js";
+import CLILog from "../../../lib/CLILog.js";
+const pushDeploymentToProvision = ({
+  deploymentPayload = null,
+  loginSessionToken,
+  server = "production"
+}) => {
+  try {
+    return fetch(`${domains?.provision[server][0]}/api/deployments/version`, {
+      method: "POST",
+      headers: {
+        ...deploymentPayload.getHeaders(),
+        "x-login-session-token": loginSessionToken
+      },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      const data = checkIfValidJSON(text);
+      const isPayloadSizeError = text?.includes("payload");
+      if (data?.error || isPayloadSizeError) {
+        CLILog(
+          data.error?.message || text,
+          {
+            level: "danger",
+            docs: isPayloadSizeError ? "https://cheatcode.co/docs/push/considerations/payload-size" : "https://cheatcode.co/docs/push"
+          }
+        );
+        process.exit(0);
+      }
+      return data?.data;
+    });
+  } catch (exception) {
+    throw new Error(`[versionDeployment.pushDeploymentToProvision] ${exception.message}`);
+  }
+};
+const getDeploymentPayload = ({
+  version,
+  deployment,
+  settings,
+  environment
+}) => {
+  try {
+    const formData2 = new FormData();
+    formData2.append("deployment", JSON.stringify({
+      ...deployment || {},
+      version,
+      settings,
+      environment
+    }));
+    return formData2;
+  } catch (exception) {
+    throw new Error(`[versionDeployment.getDeploymentPayload] ${exception.message}`);
+  }
+};
+const validateOptions = (options) => {
+  try {
+    if (!options)
+      throw new Error("options object is required.");
+    if (!options.version)
+      throw new Error("options.version is required.");
+    if (!options.deployment)
+      throw new Error("options.deployment is required.");
+    if (!options.settings)
+      throw new Error("options.settings is required.");
+    if (!options.environment)
+      throw new Error("options.environment is required.");
+    if (!options.loginSessionToken)
+      throw new Error("options.loginSessionToken is required.");
+  } catch (exception) {
+    throw new Error(`[versionDeployment.validateOptions] ${exception.message}`);
+  }
+};
+const versionDeployment = async (options, { resolve, reject }) => {
+  try {
+    validateOptions(options);
+    const deploymentPayload = getDeploymentPayload({
+      version: options?.version,
+      deployment: options?.deployment,
+      settings: options?.settings,
+      environment: options?.environment
+    });
+    await pushDeploymentToProvision({
+      deploymentPayload,
+      loginSessionToken: options?.loginSessionToken,
+      server: options?.server
+    });
+    resolve();
+  } catch (exception) {
+    reject(`[versionDeployment] ${exception.message}`);
+  }
+};
+var version_default = (options) => new Promise((resolve, reject) => {
+  versionDeployment(options, { resolve, reject });
+});
+export {
+  version_default as default
+};

package/dist/functions/push/domains.js

@@ -0,0 +1,23 @@
+const push = {
+  local: ["http://localhost:2600"],
+  staging: [],
+  production: ["https://push.cheatcode.co"]
+};
+const provision = {
+  local: ["http://localhost:2602"],
+  staging: [],
+  production: ["https://provision.cheatcode.co"]
+};
+const versions = {
+  local: ["http://localhost:2603", "http://localhost:2604", "http://localhost:2605"],
+  staging: [],
+  production: ["https://push-versions-1.cheatcode.co", "https://push-versions-2.cheatcode.co", "https://push-versions-3.cheatcode.co"]
+};
+var domains_default = {
+  push,
+  provision,
+  versions
+};
+export {
+  domains_default as default
+};

package/dist/functions/push/getAvailableCDN.js

@@ -0,0 +1,23 @@
+import fetch from "node-fetch";
+import _ from "lodash";
+import domains from "./domains.js";
+var getAvailableCDN_default = async () => {
+  const results = (await Promise.allSettled(domains?.versions?.production?.map(async (mirror) => {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), 2e3);
+    const result = await fetch(`${mirror}/api/ping`, { signal: controller.signal }).catch((error) => {
+      return { status: 503 };
+    });
+    return {
+      mirror,
+      status: result.status
+    };
+  })))?.map((result) => {
+    return result.value;
+  });
+  const firstAvailable = _.orderBy(results, ["status", "mirror"])[0];
+  return firstAvailable?.status === 200 ? firstAvailable?.mirror : null;
+};
+export {
+  getAvailableCDN_default as default
+};

package/dist/functions/push/getDeployment.js

@@ -0,0 +1,41 @@
+import fetch from "node-fetch";
+import chalk from "chalk";
+import { URL, URLSearchParams } from "url";
+import domains from "./domains.js";
+import checkIfValidJSON from "./checkIfValidJSON.js";
+import CLILog from "./CLILog.js";
+var getDeployment_default = ({
+  domain = "",
+  environment = "production",
+  loginSessionToken = ""
+}) => {
+  const url = new URL(`${domains?.provision}/api/deployments`);
+  url.search = new URLSearchParams({
+    domain,
+    environment
+  });
+  return fetch(url, {
+    method: "GET",
+    headers: {
+      "x-login-session-token": loginSessionToken,
+      "content-type": "application/json"
+    }
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+    if (data?.error) {
+      CLILog(
+        data?.error?.message,
+        {
+          level: "danger",
+          docs: "https://cheatcode.co/docs/push"
+        }
+      );
+      process.exit(0);
+    }
+    return data?.data?.deployment;
+  });
+};
+export {
+  getDeployment_default as default
+};

package/dist/functions/push/getDeploymentSummary.js

@@ -0,0 +1,38 @@
+import fetch from "node-fetch";
+import domains from "./domains.js";
+import checkIfValidJSON from "../../lib/checkIfValidJSON.js";
+import CLILog from "../../lib/CLILog.js";
+var getDeploymentSummary_default = (answers = {}, loginSessionToken = "", deploymentDomain = "") => {
+  return fetch(`${domains.provision}/api/deployments/summary`, {
+    method: "POST",
+    headers: {
+      "x-login-session-token": loginSessionToken,
+      "x-deployment-domain": deploymentDomain,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      provider: answers?.provider,
+      sizes: [
+        { type: "loadBalancers", quantity: answers?.loadBalancerInstances, id: answers?.loadBalancer_size },
+        { type: "instances", quantity: answers?.appInstances, id: answers?.app_size }
+      ]
+    })
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: "danger",
+          docs: "https://cheatcode.co/docs/push"
+        }
+      );
+      process.exit(0);
+    }
+    return data?.data?.summary;
+  });
+};
+export {
+  getDeploymentSummary_default as default
+};

package/dist/functions/push/getInstanceSizeRegions.js

@@ -0,0 +1,37 @@
+import fetch from "node-fetch";
+import chalk from "chalk";
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from "../../lib/checkIfValidJSON.js";
+var getInstanceSizeRegions_default = (target = "", answers = {}, loginSessionToken = "") => {
+  const url = new URL(`${domains.provision}/api/providers/${answers?.provider}/regions`);
+  const params = new URLSearchParams({
+    size: answers[target],
+    loadBalancerRegion: answers?.loadBalancer_region
+  });
+  url.search = params.toString();
+  return fetch(url, {
+    method: "GET",
+    headers: {
+      "x-login-session-token": loginSessionToken,
+      "content-type": "application/json"
+    }
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: "danger",
+          docs: "https://cheatcode.co/docs/push/deployment-tokens"
+        }
+      );
+      process.exit(0);
+    }
+    return data?.data;
+  });
+};
+export {
+  getInstanceSizeRegions_default as default
+};

package/dist/functions/push/getInstanceSizesForRegion.js

@@ -0,0 +1,34 @@
+import fetch from "node-fetch";
+import chalk from "chalk";
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from "../../lib/checkIfValidJSON.js";
+var getInstanceSizesForRegion_default = (provider = "", region = "", loginSessionToken = "") => {
+  return fetch(
+    `${domains.provision}/api/providers/${provider}/sizes?region=${region}`,
+    {
+      method: "GET",
+      headers: {
+        "x-login-session-token": loginSessionToken,
+        "Content-Type": "application/json"
+      }
+    }
+  ).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: "danger",
+          docs: "https://cheatcode.co/docs/push/deployment-tokens"
+        }
+      );
+      process.exit(0);
+    }
+    return data?.data?.sizes;
+  });
+};
+export {
+  getInstanceSizesForRegion_default as default
+};

package/dist/functions/push/getProviderInstanceSizes.js

@@ -0,0 +1,34 @@
+import fetch from "node-fetch";
+import chalk from "chalk";
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from "../../lib/checkIfValidJSON.js";
+var getProviderInstanceSizes_default = (answers = {}, loginSessionToken = "") => {
+  return fetch(
+    `${domains.provision}/api/providers/${answers?.provider}/sizes`,
+    {
+      method: "GET",
+      headers: {
+        "x-login-session-token": loginSessionToken,
+        "Content-Type": "application/json"
+      }
+    }
+  ).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: "danger",
+          docs: "https://cheatcode.co/docs/push/deployment-tokens"
+        }
+      );
+      process.exit(0);
+    }
+    return data?.data;
+  });
+};
+export {
+  getProviderInstanceSizes_default as default
+};

package/dist/functions/push/getProviderRegions.js

@@ -0,0 +1,36 @@
+import fetch from "node-fetch";
+import chalk from "chalk";
+import domains from "./domains.js";
+import CLILog from "../../lib/CLILog.js";
+import checkIfValidJSON from "../../lib/checkIfValidJSON.js";
+var getProviderRegions_default = (provider = "", loginSessionToken = "") => {
+  const url = new URL(`${domains.provision}/api/providers/${provider}/regions`);
+  const params = new URLSearchParams({
+    provider
+  });
+  url.search = params.toString();
+  return fetch(url, {
+    method: "GET",
+    headers: {
+      "x-login-session-token": loginSessionToken,
+      "content-type": "application/json"
+    }
+  }).then(async (response) => {
+    const text = await response.text();
+    const data = checkIfValidJSON(text);
+    if (data?.error) {
+      CLILog(
+        data.error?.message,
+        {
+          level: "danger",
+          docs: "https://cheatcode.co/docs/push/deployment-tokens"
+        }
+      );
+      process.exit(0);
+    }
+    return data?.data?.regions;
+  });
+};
+export {
+  getProviderRegions_default as default
+};

package/dist/functions/push/getProvidersWithConnectionStatus.js

@@ -0,0 +1,20 @@
+import providers from "./providers.js";
+var getProvidersWithConnectionStatus_default = (user = {}) => {
+  return providers.map((provider) => {
+    return {
+      ...provider,
+      connectedAs: {
+        // aws: user?.aws ? `Connected as ${login?.user?.aws?.username}` : null,
+        digitalOcean: user?.oauth?.digitalOcean ? `\u2714 Connected as ${user?.oauth?.digitalOcean?.info?.email}` : null,
+        // google: user?.aws ? `Connected as ${login?.user?.aws?.username}` : null,
+        // hetzner: user?.aws ? `Connected as ${login?.user?.aws?.username}` : null,
+        linode: user?.oauth?.linode ? `\u2714 Connected as ${user?.oauth?.linode?.account?.email}` : null,
+        // rackspace: user?.aws ? `Connected as ${login?.user?.aws?.username}` : null,
+        vultr: user?.oauth?.vultr ? `\u2714 Connected as ${user?.oauth?.vultr?.email}` : null
+      }[provider?.value] || "\u{1F5D9} Not connected"
+    };
+  });
+};
+export {
+  getProvidersWithConnectionStatus_default as default
+};

package/dist/functions/push/getSessionToken.js

@@ -0,0 +1,23 @@
+import os from "os";
+import fs from "fs";
+import inquirer from "inquirer";
+import prompts from "../functions/push/prompts.js";
+import loginToCheatCode from "./loginToCheatCode.js";
+var getSessionToken_default = async () => {
+  const homeDirectory = os.homedir();
+  const sessionTokenPath = `${homeDirectory}/.cheatcode/session`;
+  const sessionTokenExists = fs.existsSync(sessionTokenPath);
+  if (sessionTokenExists) {
+    return fs.readFileSync(sessionTokenPath, "utf-8");
+  }
+  const promptUserLogin = await inquirer.prompt(prompts.login());
+  const sessionToken = promptUserLogin?.oauth || await loginToCheatCode(promptUserLogin?.emailAddress, promptUserLogin?.password);
+  if (!fs.existsSync(`${homeDirectory}/.cheatcode`)) {
+    fs.mkdirSync(`${homeDirectory}/.cheatcode`);
+  }
+  fs.writeFileSync(`${homeDirectory}/.cheatcode/session`, sessionToken);
+  return sessionToken;
+};
+export {
+  getSessionToken_default as default
+};