Site SDK

npm i @spheron/site

yarn add @spheron/site

import { SpheronClient, ProtocolEnum } from "@spheron/site";
 
const client = new SpheronClient({ token });

await spheron.deployments.deploy({
  gitUrl, // the url of the repository
  projectName, // if the project for the repository does not exists, a new project will be created with this name
  environmentVariables: {
    KEY_1: "value1",
  },
  provider: ProviderEnum.GITHUB, // the provider of the git url
  branch: "main", // the branch name that should be deployed
  protocol: ProtocolEnum.IPFS, // the protocol on which the deployment should be uploaded
  configuration: {
    framework: FrameworkEnum.REACT,
    workspace: "",
    installCommand: "yarn install",
    buildCommand: "yarn build",
    publishDir: "build",
    nodeVersion: NodeVersionEnum.V_16,
  },
  gitProviderPreferences: {
    prComments: true;
    commitComments: false;
    buildStatus: false;
    githubDeployment: true;
  }
});

enum ProtocolEnum {
    ARWEAVE,
    FILECOIN,
    IPFS
}

interface DeploymentResponse {
  success: boolean; // indicates if the deployment has been started
  message: string; // holds information about the deployment and more details if the deployment fails
  deploymentId: string; // the id of the newly created deployment
  projectId: string; // the project id of the newly created deployment
  deployment: Deployment; // the newly created deployment
}

const deployment: Deployment = await spheron.deployments.get(deploymentId);

interface Deployment {
  id: string; // the id of the deployment
  status: DeploymentStatusEnum; // the current state of the deployment
  configuration: Configuration; // the specific configuration that was used for the deployment
  buildTime: number; // the time it took for the deployment to finish, represented in seconds
  fileSize: number; // the total file size of the deployment
  deploymentEnvironmentName: string; // the environment of the deployment
  commitId: string; // the commit id of the deployment
  branch: string; // the branch of the deployment
  protocol: ProtocolEnum; // the protocol that was used for the deployment
  sitePreview: string; // the link to the deployed data
}
 
enum DeploymentStatusEnum {
    PRE_QUEUE,
    QUEUED,
    PENDING,
    CANCELED,
    DEPLOYED,
    FAILED,
    AUTHORIZATION_NEEDED,
    KILLING,
    TIMED_OUT
}
 

const logs: DeploymentLog[] = await spheron.deployments.getLogs(deploymentId);

interface DeploymentLog {
  log: string;
  time: string;
}

await spheron.deployments.cancel(deploymentId);

interface CancelDeploymentResponse {
  message: string; // information about the cancellation
  canceled: boolean; // true if deployment was canceled
  killing: boolean; // true if deployment is in the cancellation process.
}

await spheron.deployments.authorize(deploymentId);

interface DeploymentResponse {
  success: boolean;
  message: string;
  deploymentId: string;
  projectId: string;
  deployment: Deployment;
}

await spheron.deployments.redeploy(deploymentId);

interface DeploymentResponse {
  success: boolean;
  message: string;
  deploymentId: string;
  projectId: string;
  deployment: Deployment;
}

const project: Project = await spheron.projects.get(projectId);

interface Project {
  id: string; // the id of a project
  name: string; // the name of a project
  state: ProjectStateEnum; // the state of a project
  url: string; // the url to the git repository of a project
  organizationId: string; // the organizationId in which a project is
  provider: ProviderEnum; // the Git provider of a project
  configuration: Configuration; // the default configuration of a project. This configuration is used for webhook deployments.
}
 
enum ProjectStateEnum {
    MAINTAINED,
    ARCHIVED
}
 
enum ProviderEnum {
    GITHUB,
    GITLAB,
    BITBUCKET
}
 
interface Configuration {
  installCommand: string; // command that will be used to install the dependencies of the repository
  buildCommand: string; // command that will be executed to build the repository
  workspace: string; // the path to the app inside repository
  publishDir: string; // the path to the build directory
  framework: FrameworkEnum; // the framework of a project
  nodeVersion: NodeVersionEnum; // the node version that will be used to build the project
}
 
enum NodeVersionEnum {
    V_12,
    V_14,
    V_16
}
 
enum FrameworkEnum {
    SIMPLE_JAVASCRIPT_APP,
    VUE,
    REACT,
    NEXT,
    ANGULAR,
    PREACT,
    NUXT,
    SVELTE,
    GATSBY,
    ELEVENTY,
    DOCUSAURUS,
    SANITY,
    HUGO,
    IONIC_REACT,
    VITE,
    SCULLY,
    STENCIL,
    BRUNCH,
    IONIC_ANGULAR
}

await spheron.projects.archive(projectId);

await spheron.projects.unarchive(projectId);

const configuration: Configuration = await spheron.projects.updateConfiguration(
  projectId,
  {
    framework: FrameworkEnum.REACT,
    workspace: "",
    installCommand: "yarn install",
    buildCommand: "yarn build",
    publishDir: "build",
    nodeVersion: NodeVersionEnum.V_16,
  }
);

interface Configuration {
  installCommand: string; // command that will be used to install the dependencies of the repository
  buildCommand: string; // command that will be executed to build the repository
  workspace: string; // the path to the app inside repository
  publishDir: string; // the path to the build directory
  framework: FrameworkEnum; // the framework of a project
  nodeVersion: NodeVersionEnum; // the node version that will be used to build the project
}
 
enum NodeVersionEnum {
    V_12,
    V_14,
    V_16
}
 
enum FrameworkEnum {
    SIMPLE_JAVASCRIPT_APP,
    VUE,
    REACT,
    NEXT,
    ANGULAR,
    PREACT,
    NUXT,
    SVELTE,
    GATSBY,
    ELEVENTY,
    DOCUSAURUS,
    SANITY,
    HUGO,
    IONIC_REACT,
    VITE,
    SCULLY,
    STENCIL,
    BRUNCH,
    IONIC_ANGULAR
}

const variables: EnvironmentVariable[] =
  await spheron.projects.getEnvironmentVariables(projectId);

interface EnvironmentVariable {
  id: string; // the id of a environment variable
  name: string; // the name of a environment variable
  value: string; // the value of a environment variable
  environments: string[]; // the deployment environments for which the variable will be used
}

const added: EnvironmentVariable[] =
  await spheron.projects.addEnvironmentVariable(projectId, [
    {
      name: "variable1",
      value: "value1",
      environments: ["Production"],
    },
    {
      name: "variable2",
      value: "value2",
      environments: ["Development", "Production"],
    },
  ]);

const updated = await spheron.projects.updateEnvironmentVariable(
  projectId,
  environmentVariableId,
  {
    name: "updated_name",
    value: "updated_value",
    environments: ["Development", "Production"],
  }
);

await spheron.projects.deleteEnvironmentVariable(
  projectId,
  environmentVariableId
);

const deploymentEnvironments: DeploymentEnvironment[] =
  await spheron.projects.getDeploymentEnvironments(projectId);

interface DeploymentEnvironment {
  id: string; // the id of the deployment environment
  name: string; // the name of the deployment environment
  protocol: ProtocolEnum; // the protocol of the deployment environment
  branches: string[]; // the branches for which the deployment environment
}
 
enum ProtocolEnum {
    ARWEAVE,
    FILECOIN,
    IPFS
}

const created: DeploymentEnvironment =
  await spheron.projects.createDeploymentEnvironment(projectId, {
    name: "Deployment Environment Name",
    branches: ["branch1", "branch2"],
    protocol: ProtocolEnum.IPFS,
  });

const updated: DeploymentEnvironment =
  await spheron.projects.updateDeploymentEnvironment(
    projectId,
    deploymentEnvironmentId,
    {
      name: "Deployment Environment Name Updated",
      branches: ["branch1", "branch2", "branch3"],
      protocol: ProtocolEnum.FILECOIN,
    }
  );

await spheron.projects.deleteDeploymentEnvironment(
  projectId,
  deploymentEnvironmentId
);

const deploymentEnvironment: DeploymentEnvironment =
  await spheron.projects.activateDeploymentEnvironment(
    projectId,
    deploymentEnvironmentId
  );

const deploymentEnvironment: DeploymentEnvironment =
  await spheron.projects.deactivateDeploymentEnvironment(
    projectId,
    deploymentEnvironmentId
  );

const domains: Domain[] = await spheron.projects.getDomains(projectId);

interface Domain {
  id: string; // the id of the domain
  name: string; // the domain name
  verified: boolean; // true means that the domain is verified and that it will start serving the content
  link: string; // the link to which the domain points to
  type: DomainTypeEnum; // the type of the domain
  projectId: string; // the project id of which the domain is
  deploymentEnvironmentIds: string[]; //  the ids of the deployment environments for the domain. Whenever a deployment for the specified environment is done, the domain will be updated to point to the new link of the deployment.
}
 
enum DomainTypeEnum {
    DOMAIN,
    SUBDOMAIN,
    HANDSHAKE_DOMAIN,
    HANDSHAKE_SUBDOMAIN,
    ENS_DOMAIN
}

const domain: Domain = await spheron.projects.getDomain(projectId, "test.com");

const domain: Domain = await spheron.projects.addDomain(projectId, {
  name: "domain.com",
  type: DomainTypeEnum.DOMAIN,
  deploymentEnvironments: ["Production"],
});

const domain: Domain = await spheron.projects.updateDomain(
  projectId,
  domainId,
  {
    name: "test.com",
    deploymentEnvironments: ["Production"],
  }
);

const domain: Domain = await spheron.projects.verifyDomain(projectId, domainId);

const { cdnARecords, cdnCnameRecords } =
  await client.projects.getCdnDnsRecords();

await spheron.projects.deleteDomain(projectId, domainId);

const deployments: Deployment[] = await spheron.projects.getDeployments(
  projectId,
  {
    skip: 0,
    limit: 5,
    status: DeploymentStatusEnum.QUEUED,
  }
);

const deploymentCount: DeploymentCount =
  await spheron.projects.getDeploymentCount(projectId);

interface DeploymentCount {
  total: number; // the total number of deployments
  successful: number; // the number of successful deployments
  failed: number; // the number of failed deployments
  pending: number; // the number of deployments in pending state
}

const organization: Organization = await spheron.organization.get();

interface Organization {
  id: string; // the id of a organization
  profile: {
    name: string, // the name of a organization
    username: string, // the username of a organization
    image: string, // the url to the avatar image of a organization
  };
}

const projects: Project[] = await spheron.organization.getProjects({
  skip: 0,
  limit: 10,
  state: ProjectStateEnum.MAINTAINED,
});

const count: number = await spheron.organization.getProjectCount({
  state: ProjectStateEnum.MAINTAINED,
});

const usage: UsageWithLimits = await spheron.organization.getUsage();

interface UsageWithLimits {
  used: {
    bandwidth: number, // the bytes of bandwidth used for the current subscription
    buildExecution: number, // the seconds of build execution done for the current subscription
    concurrentBuild: number,// the number of concurrent builds in progress
    storageArweave: number, // the bytes of used Arweave storage for the current subscription
    storageIPFS: number, // the bytes of used IPFS storage for the current subscription
    deploymentsPerDay: number, // number of deployments an organization can have one one day
    domains: number, // the number of domains and subdomain an organization has
    hnsDomains: number,// the number of hns domains an organization has
    ensDomains: number,// the number of ens domains an organization has
    environments: number,// the number of deployment environments an organization has
    numberOfRequests: number,// the number of requests the organization has had till now
    passwordProtection: number,; // 1 - if organization has support for password protection, otherwise 0.
  };
  limit: {
    bandwidth: number, // the bandwidth limit for the current subscription
    buildExecution: number,// the build execution limit for the current subscription
    concurrentBuild: number, // how many concurrent builds can the organization have with the current subscription plan
    storageArweave: number,  // the limit in bytes for the Arweave storage for the current subscription
    storageIPFS: number, // the limit in bytes for the IPFS storage for the current subscription
    deploymentsPerDay: number,// the limit of how many deployments can an organization have per day
    domains: number,// the limit on how many domains and subdomains can an organization have
    hnsDomains: number, //  the limit on how many hns domains can an organization have
    ensDomains: number,// the limit on how many ens domains can an organization have
    environments: number, // the limit on how many deployment environment can an organization have
    membersLimit: number,// how many members can an organization have
  };
}