@nirvana-labs/nirvana 0.1.0-alpha.10

package/src/error.ts

@@ -0,0 +1,130 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { castToError, Headers } from './core';
+
+export class NirvanaLabsError extends Error {}
+
+export class APIError<
+  TStatus extends number | undefined = number | undefined,
+  THeaders extends Headers | undefined = Headers | undefined,
+  TError extends Object | undefined = Object | undefined,
+> extends NirvanaLabsError {
+  /** HTTP status for the response that caused the error */
+  readonly status: TStatus;
+  /** HTTP headers for the response that caused the error */
+  readonly headers: THeaders;
+  /** JSON body of the response that caused the error */
+  readonly error: TError;
+
+  constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
+    super(`${APIError.makeMessage(status, error, message)}`);
+    this.status = status;
+    this.headers = headers;
+    this.error = error;
+  }
+
+  private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
+    const msg =
+      error?.message ?
+        typeof error.message === 'string' ?
+          error.message
+        : JSON.stringify(error.message)
+      : error ? JSON.stringify(error)
+      : message;
+
+    if (status && msg) {
+      return `${status} ${msg}`;
+    }
+    if (status) {
+      return `${status} status code (no body)`;
+    }
+    if (msg) {
+      return msg;
+    }
+    return '(no status code or body)';
+  }
+
+  static generate(
+    status: number | undefined,
+    errorResponse: Object | undefined,
+    message: string | undefined,
+    headers: Headers | undefined,
+  ): APIError {
+    if (!status || !headers) {
+      return new APIConnectionError({ message, cause: castToError(errorResponse) });
+    }
+
+    const error = errorResponse as Record<string, any>;
+
+    if (status === 400) {
+      return new BadRequestError(status, error, message, headers);
+    }
+
+    if (status === 401) {
+      return new AuthenticationError(status, error, message, headers);
+    }
+
+    if (status === 403) {
+      return new PermissionDeniedError(status, error, message, headers);
+    }
+
+    if (status === 404) {
+      return new NotFoundError(status, error, message, headers);
+    }
+
+    if (status === 409) {
+      return new ConflictError(status, error, message, headers);
+    }
+
+    if (status === 422) {
+      return new UnprocessableEntityError(status, error, message, headers);
+    }
+
+    if (status === 429) {
+      return new RateLimitError(status, error, message, headers);
+    }
+
+    if (status >= 500) {
+      return new InternalServerError(status, error, message, headers);
+    }
+
+    return new APIError(status, error, message, headers);
+  }
+}
+
+export class APIUserAbortError extends APIError<undefined, undefined, undefined> {
+  constructor({ message }: { message?: string } = {}) {
+    super(undefined, undefined, message || 'Request was aborted.', undefined);
+  }
+}
+
+export class APIConnectionError extends APIError<undefined, undefined, undefined> {
+  constructor({ message, cause }: { message?: string | undefined; cause?: Error | undefined }) {
+    super(undefined, undefined, message || 'Connection error.', undefined);
+    // in some environments the 'cause' property is already declared
+    // @ts-ignore
+    if (cause) this.cause = cause;
+  }
+}
+
+export class APIConnectionTimeoutError extends APIConnectionError {
+  constructor({ message }: { message?: string } = {}) {
+    super({ message: message ?? 'Request timed out.' });
+  }
+}
+
+export class BadRequestError extends APIError<400, Headers> {}
+
+export class AuthenticationError extends APIError<401, Headers> {}
+
+export class PermissionDeniedError extends APIError<403, Headers> {}
+
+export class NotFoundError extends APIError<404, Headers> {}
+
+export class ConflictError extends APIError<409, Headers> {}
+
+export class UnprocessableEntityError extends APIError<422, Headers> {}
+
+export class RateLimitError extends APIError<429, Headers> {}
+
+export class InternalServerError extends APIError<number, Headers> {}

package/src/index.ts

@@ -0,0 +1,198 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { type Agent } from './_shims/index';
+import * as Core from './core';
+import * as Errors from './error';
+import * as Uploads from './uploads';
+import * as API from './resources/index';
+import { Operations } from './resources/operations';
+import { Compute } from './resources/compute/compute';
+import { Networking } from './resources/networking/networking';
+
+export interface ClientOptions {
+  /**
+   * Defaults to process.env['NIRVANA_LABS_AUTH_TOKEN'].
+   */
+  authToken?: string | undefined;
+
+  /**
+   * Override the default base URL for the API, e.g., "https://api.example.com/v2/"
+   *
+   * Defaults to process.env['NIRVANA_LABS_BASE_URL'].
+   */
+  baseURL?: string | null | undefined;
+
+  /**
+   * The maximum amount of time (in milliseconds) that the client should wait for a response
+   * from the server before timing out a single request.
+   *
+   * Note that request timeouts are retried by default, so in a worst-case scenario you may wait
+   * much longer than this timeout before the promise succeeds or fails.
+   */
+  timeout?: number | undefined;
+
+  /**
+   * An HTTP agent used to manage HTTP(S) connections.
+   *
+   * If not provided, an agent will be constructed by default in the Node.js environment,
+   * otherwise no agent is used.
+   */
+  httpAgent?: Agent | undefined;
+
+  /**
+   * Specify a custom `fetch` function implementation.
+   *
+   * If not provided, we use `node-fetch` on Node.js and otherwise expect that `fetch` is
+   * defined globally.
+   */
+  fetch?: Core.Fetch | undefined;
+
+  /**
+   * The maximum number of times that the client will retry a request in case of a
+   * temporary failure, like a network error or a 5XX error from the server.
+   *
+   * @default 2
+   */
+  maxRetries?: number | undefined;
+
+  /**
+   * Default headers to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * header to `undefined` or `null` in request options.
+   */
+  defaultHeaders?: Core.Headers | undefined;
+
+  /**
+   * Default query parameters to include with every request to the API.
+   *
+   * These can be removed in individual requests by explicitly setting the
+   * param to `undefined` in request options.
+   */
+  defaultQuery?: Core.DefaultQuery | undefined;
+}
+
+/**
+ * API Client for interfacing with the Nirvana Labs API.
+ */
+export class NirvanaLabs extends Core.APIClient {
+  authToken: string;
+
+  private _options: ClientOptions;
+
+  /**
+   * API Client for interfacing with the Nirvana Labs API.
+   *
+   * @param {string | undefined} [opts.authToken=process.env['NIRVANA_LABS_AUTH_TOKEN'] ?? undefined]
+   * @param {string} [opts.baseURL=process.env['NIRVANA_LABS_BASE_URL'] ?? https://api.nirvanalabs.io/] - Override the default base URL for the API.
+   * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+   * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+   * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+   * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+   * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+   * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+   */
+  constructor({
+    baseURL = Core.readEnv('NIRVANA_LABS_BASE_URL'),
+    authToken = Core.readEnv('NIRVANA_LABS_AUTH_TOKEN'),
+    ...opts
+  }: ClientOptions = {}) {
+    if (authToken === undefined) {
+      throw new Errors.NirvanaLabsError(
+        "The NIRVANA_LABS_AUTH_TOKEN environment variable is missing or empty; either provide it, or instantiate the NirvanaLabs client with an authToken option, like new NirvanaLabs({ authToken: 'My Auth Token' }).",
+      );
+    }
+
+    const options: ClientOptions = {
+      authToken,
+      ...opts,
+      baseURL: baseURL || `https://api.nirvanalabs.io/`,
+    };
+
+    super({
+      baseURL: options.baseURL!,
+      timeout: options.timeout ?? 60000 /* 1 minute */,
+      httpAgent: options.httpAgent,
+      maxRetries: options.maxRetries,
+      fetch: options.fetch,
+    });
+
+    this._options = options;
+
+    this.authToken = authToken;
+  }
+
+  operations: API.Operations = new API.Operations(this);
+  compute: API.Compute = new API.Compute(this);
+  networking: API.Networking = new API.Networking(this);
+
+  protected override defaultQuery(): Core.DefaultQuery | undefined {
+    return this._options.defaultQuery;
+  }
+
+  protected override defaultHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    return {
+      ...super.defaultHeaders(opts),
+      ...this._options.defaultHeaders,
+    };
+  }
+
+  protected override authHeaders(opts: Core.FinalRequestOptions): Core.Headers {
+    return { Authorization: `Bearer ${this.authToken}` };
+  }
+
+  static NirvanaLabs = this;
+  static DEFAULT_TIMEOUT = 60000; // 1 minute
+
+  static NirvanaLabsError = Errors.NirvanaLabsError;
+  static APIError = Errors.APIError;
+  static APIConnectionError = Errors.APIConnectionError;
+  static APIConnectionTimeoutError = Errors.APIConnectionTimeoutError;
+  static APIUserAbortError = Errors.APIUserAbortError;
+  static NotFoundError = Errors.NotFoundError;
+  static ConflictError = Errors.ConflictError;
+  static RateLimitError = Errors.RateLimitError;
+  static BadRequestError = Errors.BadRequestError;
+  static AuthenticationError = Errors.AuthenticationError;
+  static InternalServerError = Errors.InternalServerError;
+  static PermissionDeniedError = Errors.PermissionDeniedError;
+  static UnprocessableEntityError = Errors.UnprocessableEntityError;
+
+  static toFile = Uploads.toFile;
+  static fileFromPath = Uploads.fileFromPath;
+}
+
+NirvanaLabs.Operations = Operations;
+NirvanaLabs.Compute = Compute;
+NirvanaLabs.Networking = Networking;
+export declare namespace NirvanaLabs {
+  export type RequestOptions = Core.RequestOptions;
+
+  export { Operations as Operations };
+
+  export { Compute as Compute };
+
+  export { Networking as Networking };
+
+  export type RegionName = API.RegionName;
+  export type ResourceStatus = API.ResourceStatus;
+}
+
+export { toFile, fileFromPath } from './uploads';
+export {
+  NirvanaLabsError,
+  APIError,
+  APIConnectionError,
+  APIConnectionTimeoutError,
+  APIUserAbortError,
+  NotFoundError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  AuthenticationError,
+  InternalServerError,
+  PermissionDeniedError,
+  UnprocessableEntityError,
+} from './error';
+
+export default NirvanaLabs;

package/src/lib/.keep

@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.

package/src/resource.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { NirvanaLabs } from './index';
+
+export class APIResource {
+  protected _client: NirvanaLabs;
+
+  constructor(client: NirvanaLabs) {
+    this._client = client;
+  }
+}

package/src/resources/compute/compute.ts

@@ -0,0 +1,49 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../resource';
+import * as VolumesAPI from './volumes';
+import {
+  StorageType,
+  Volume,
+  VolumeCreateParams,
+  VolumeDeleteParams,
+  VolumeKind,
+  VolumeListResponse,
+  VolumeUpdateParams,
+  Volumes,
+} from './volumes';
+import * as VMsAPI from './vms/vms';
+import { CPU, OSImage, Ram, SSHKey, VM, VMCreateParams, VMList, VMUpdateParams, VMs } from './vms/vms';
+
+export class Compute extends APIResource {
+  vms: VMsAPI.VMs = new VMsAPI.VMs(this._client);
+  volumes: VolumesAPI.Volumes = new VolumesAPI.Volumes(this._client);
+}
+
+Compute.VMs = VMs;
+Compute.Volumes = Volumes;
+
+export declare namespace Compute {
+  export {
+    VMs as VMs,
+    type CPU as CPU,
+    type OSImage as OSImage,
+    type Ram as Ram,
+    type SSHKey as SSHKey,
+    type VM as VM,
+    type VMList as VMList,
+    type VMCreateParams as VMCreateParams,
+    type VMUpdateParams as VMUpdateParams,
+  };
+
+  export {
+    Volumes as Volumes,
+    type StorageType as StorageType,
+    type Volume as Volume,
+    type VolumeKind as VolumeKind,
+    type VolumeListResponse as VolumeListResponse,
+    type VolumeCreateParams as VolumeCreateParams,
+    type VolumeUpdateParams as VolumeUpdateParams,
+    type VolumeDeleteParams as VolumeDeleteParams,
+  };
+}

package/src/resources/compute/index.ts

@@ -0,0 +1,24 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Compute } from './compute';
+export {
+  VMs,
+  type CPU,
+  type OSImage,
+  type Ram,
+  type SSHKey,
+  type VM,
+  type VMList,
+  type VMCreateParams,
+  type VMUpdateParams,
+} from './vms/index';
+export {
+  Volumes,
+  type StorageType,
+  type Volume,
+  type VolumeKind,
+  type VolumeListResponse,
+  type VolumeCreateParams,
+  type VolumeUpdateParams,
+  type VolumeDeleteParams,
+} from './volumes';

package/src/resources/compute/vms/index.ts

@@ -0,0 +1,14 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { OSImages, type OSImageListResponse } from './os-images';
+export {
+  VMs,
+  type CPU,
+  type OSImage,
+  type Ram,
+  type SSHKey,
+  type VM,
+  type VMList,
+  type VMCreateParams,
+  type VMUpdateParams,
+} from './vms';

package/src/resources/compute/vms/os-images.ts

@@ -0,0 +1,20 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+import * as VMsAPI from './vms';
+
+export class OSImages extends APIResource {
+  /**
+   * List all OS Images
+   */
+  list(options?: Core.RequestOptions): Core.APIPromise<OSImageListResponse> {
+    return this._client.get('/compute/vms/os_images', options);
+  }
+}
+
+export type OSImageListResponse = Array<VMsAPI.OSImage>;
+
+export declare namespace OSImages {
+  export { type OSImageListResponse as OSImageListResponse };
+}

package/src/resources/compute/vms/vms.ts

@@ -0,0 +1,239 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+import * as OperationsAPI from '../../operations';
+import * as Shared from '../../shared';
+import * as VolumesAPI from '../volumes';
+import * as OSImagesAPI from './os-images';
+import { OSImageListResponse, OSImages } from './os-images';
+
+export class VMs extends APIResource {
+  osImages: OSImagesAPI.OSImages = new OSImagesAPI.OSImages(this._client);
+
+  /**
+   * Create a VM
+   */
+  create(body: VMCreateParams, options?: Core.RequestOptions): Core.APIPromise<OperationsAPI.Operation> {
+    return this._client.post('/compute/vms', { body, ...options });
+  }
+
+  /**
+   * Update a VM
+   */
+  update(
+    vmId: string,
+    body: VMUpdateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<OperationsAPI.Operation> {
+    return this._client.patch(`/compute/vms/${vmId}`, { body, ...options });
+  }
+
+  /**
+   * List all VMs
+   */
+  list(options?: Core.RequestOptions): Core.APIPromise<VMList> {
+    return this._client.get('/compute/vms', options);
+  }
+
+  /**
+   * Delete a VM
+   */
+  delete(vmId: string, options?: Core.RequestOptions): Core.APIPromise<OperationsAPI.Operation> {
+    return this._client.delete(`/compute/vms/${vmId}`, options);
+  }
+
+  /**
+   * Get details about a VM
+   */
+  get(vmId: string, options?: Core.RequestOptions): Core.APIPromise<VM> {
+    return this._client.get(`/compute/vms/${vmId}`, options);
+  }
+}
+
+/**
+ * CPU details.
+ */
+export interface CPU {
+  cores: number;
+}
+
+export interface OSImage {
+  created_at: string;
+
+  display_name: string;
+
+  name: string;
+}
+
+/**
+ * RAM details.
+ */
+export interface Ram {
+  /**
+   * RAM size
+   */
+  size: number;
+}
+
+/**
+ * SSH key details.
+ */
+export interface SSHKey {
+  public_key: string;
+}
+
+/**
+ * VM details.
+ */
+export interface VM {
+  id: string;
+
+  boot_volume_id: string;
+
+  /**
+   * CPU details.
+   */
+  cpu_config: CPU;
+
+  created_at: string;
+
+  data_volume_ids: Array<string>;
+
+  /**
+   * RAM details.
+   */
+  mem_config: Ram;
+
+  name: string;
+
+  public_ip: string;
+
+  region: Shared.RegionName;
+
+  status: Shared.ResourceStatus;
+
+  updated_at: string;
+
+  vpc_id: string;
+}
+
+export interface VMList {
+  items: Array<VM>;
+}
+
+export interface VMCreateParams {
+  /**
+   * Boot volume create request.
+   */
+  boot_volume: VMCreateParams.BootVolume;
+
+  /**
+   * CPU details.
+   */
+  cpu: CPU;
+
+  name: string;
+
+  os_image_name: string;
+
+  ports: Array<string>;
+
+  public_ip_enabled: boolean;
+
+  /**
+   * RAM details.
+   */
+  ram: Ram;
+
+  region: Shared.RegionName;
+
+  source_address: string;
+
+  /**
+   * SSH key details.
+   */
+  ssh_key: SSHKey;
+
+  data_volumes?: Array<VMCreateParams.DataVolume>;
+
+  subnet_id?: string;
+}
+
+export namespace VMCreateParams {
+  /**
+   * Boot volume create request.
+   */
+  export interface BootVolume {
+    size: number;
+  }
+
+  /**
+   * VM data volume create request.
+   */
+  export interface DataVolume {
+    size: number;
+
+    /**
+     * Storage type.
+     */
+    type?: VolumesAPI.StorageType;
+  }
+}
+
+export interface VMUpdateParams {
+  /**
+   * Boot volume create request.
+   */
+  boot_volume?: VMUpdateParams.BootVolume;
+
+  /**
+   * CPU details.
+   */
+  cpu?: CPU;
+
+  data_volumes?: Array<VMUpdateParams.DataVolume>;
+
+  /**
+   * RAM details.
+   */
+  ram?: Ram;
+}
+
+export namespace VMUpdateParams {
+  /**
+   * Boot volume create request.
+   */
+  export interface BootVolume {
+    size: number;
+  }
+
+  /**
+   * VM data volume create request.
+   */
+  export interface DataVolume {
+    size: number;
+
+    /**
+     * Storage type.
+     */
+    type?: VolumesAPI.StorageType;
+  }
+}
+
+VMs.OSImages = OSImages;
+
+export declare namespace VMs {
+  export {
+    type CPU as CPU,
+    type OSImage as OSImage,
+    type Ram as Ram,
+    type SSHKey as SSHKey,
+    type VM as VM,
+    type VMList as VMList,
+    type VMCreateParams as VMCreateParams,
+    type VMUpdateParams as VMUpdateParams,
+  };
+
+  export { OSImages as OSImages, type OSImageListResponse as OSImageListResponse };
+}