cloreai 2.0.0 → 4.0.0

package/README.md

@@ -4,10 +4,11 @@
 
 Features:
 
-- Based on [axios](https://github.com/axios/axios)
-- Protects from rate limit exceeded (429 errors) via
+- Based on native fetch
+- Protects against rate limit exceeded (429 errors) through
   [p-queue](https://github.com/sindresorhus/p-queue)
-- Error handling via try...catch and instanceof
+- Convenient error handling
+- Full type safety
 - Supports GigaSPOT
 
 Official documentation: [clore.ai/api-docs](https://clore.ai/api-docs)
@@ -26,13 +27,14 @@ npm install cloreai
 ### Creating an instance
 
 ```typescript
-import CloreAI from 'cloreai'
+import Cloreai from 'cloreai'
 
-const cloreai = new CloreAI('<API_KEY>', {
-  axiosOptions: {}, // (optional) Axios instance options https://github.com/axios/axios
+const cloreai = new Cloreai('API_KEY', {
+  baseURL: 'https://api.clore.ai/v1', // (optional) Override the default base URL for the API
+  fetch: globalThis.fetch, // (optional) Specify a custom `fetch` function implementation
+  fetchOptions: {}, // (optional) Additional `RequestInit` options to be passed to `fetch` calls
   queueOptions: {}, // (optional) Queue instance options https://github.com/sindresorhus/p-queue
-  queueOptionsCreateOrder: {}, // (optional) Create order queue instance options https://github.com/sindresorhus/p-queue
-  queueOptionsGigaspot: {}, // (optional) Gigaspot queue instance options https://github.com/sindresorhus/p-queue
+  queueCreateOrderOptions: {}, // (optional) Create order queue instance options https://github.com/sindresorhus/p-queue
 })
 ```
 
@@ -52,7 +54,7 @@ const myServers = await cloreai.myServers()
 
 ```typescript
 const serverConfig = await cloreai.serverConfig({
-  server_name: 'server_name',
+  server_name: 'SERVER_NAME',
 })
 ```
 
@@ -81,13 +83,28 @@ const spotMarketplace = await cloreai.spotMarketplace({
 
 ```typescript
 await cloreai.setServerSettings({
-  'name': 'name', // Server name
+  'name': 'NAME', // Server name
   'availability': true,
   'mrl': 24,
-  'on_demand': 50,
-  'spot': 50,
-  'CLORE-Blockchain_on_demand': 50,
-  'CLORE-Blockchain_spot': 50,
+  'bitcoin_on_demand': 1,
+  'bitcoin_spot': 1,
+  'CLORE-Blockchain_on_demand': 1,
+  'CLORE-Blockchain_spot': 1,
+  'USD-Blockchain_on_demand': 1,
+  'USD-Blockchain_spot': 1,
+  'enabled-USD-Blockchain': true,
+  'enabled-CLORE-Blockchain': true,
+  'enabled-bitcoin': true,
+  'autoprice': {
+    'CLORE-Blockchain': 'usd',
+    'USD-Blockchain': 'usd',
+    'bitcoin': 'usd',
+  },
+  'usd_pricing': {
+    'CLORE-Blockchain': { on_demand: 1, spot: 1 },
+    'USD-Blockchain': { on_demand: 1, spot: 1 },
+    'bitcoin': { on_demand: 1, spot: 1 },
+  },
 })
 ```
 
@@ -119,19 +136,25 @@ await cloreai.createOrder({
   renting_server: 5738,
   ports: { 22: 'tcp', 8888: 'http' },
   env: { SSH_PASSWORD: 'SSH_PASSWORD', JUPYTER_TOKEN: 'JUPYTER_TOKEN' },
-  jupyter_token: 'jupyter_token',
-  ssh_password: 'ssh_password',
+  jupyter_token: 'JUPYTER_TOKEN',
+  ssh_password: 'SSH_PASSWORD',
   required_price: 50,
   remember_password: true,
 })
 ```
 
-### 11. PoH Info
+### 11. poh_balance
 
 ```typescript
 const pohBalance = await cloreai.pohBalance()
 ```
 
+### 12. renter_fees
+
+```typescript
+const renterFees = await cloreai.renterFees()
+```
+
 ### GigaSPOT
 
 #### getGigaspot
@@ -184,102 +207,115 @@ await cloreai.gigaspot.cancelOrders({
 })
 ```
 
-### Request Configuration
+## Fetch Options
 
-All methods accept an optional request configuration for axios as the last
-parameter, for example:
+All methods accept fetch options as the last parameter, for example:
 
 ```typescript
 const marketplace = await cloreai.marketplace({
-  // axios config
+  // `RequestInit` options
 })
 ```
 
-### Access to axios instance
-
-Use the field `cloreai.axios`.
-
-Refer to the documentation [axios](https://github.com/axios/axios).
-
-### Access to p-queue instances
-
-Use the fields:
-
-- `cloreai.queue` - for main request queue
-- `cloreai.queueCreateOrder` - for createOrder request queue
-- `cloreai.gigaspot.queue` - for gigaspot request queue
+## Error Handling
 
-Refer to the documentation [p-queue](https://github.com/sindresorhus/p-queue).
+Use the `CloreaiError` class for error handling.
 
-### Error Handling
+Errors have fields with information `error.statusCode` and `error.description`.
 
-The library exports the following error types:
-
-- `DatabaseError`
-- `InvalidInputDataError`
-- `InvalidApiTokenError`
-- `InvalidEndpointError`
-- `ExceededError`
-- `OtherError`
-- `UnknownError`
-
-All these errors inherit from `AxiosError`.
-
-Check the error type via the `instanceof` operator:
+Use the constant `statusCodes` to check the error type.
 
 ```typescript
-import { AxiosError } from 'axios'
-import { ExceededError } from 'cloreai'
+import { CloreaiError, statusCodes } from 'cloreai'
 
 try {
   const marketplace = await cloreai.marketplace()
 } catch (error) {
-  if (error instanceof AxiosError) {
-    console.log('AxiosError')
-  }
-
-  if (error instanceof ExceededError) {
-    console.log('ExceededError')
+  if (error instanceof CloreaiError) {
+    console.log(error.statusCode, error.description)
+
+    if (error.statusCode === statusCodes.EXCEEDED) {
+      console.log('Rate limit exceeded error')
+    }
+  } else {
+    throw error
   }
-
-  throw error
 }
 ```
 
-### Rate limit
+## Rate limit
 
-All methods are protected from rate limit exceeded via
-[p-queue](https://github.com/sindresorhus/p-queue), they automatically pause for
-the required time to avoid exceeding the limit.
+All methods are protected from rate limit exceeded through
+[p-queue](https://github.com/sindresorhus/p-queue), they automatically delay for
+the needed time to avoid exceeding the limit.
 
 Default rate limit values are available as constants:
 
 ```typescript
-import {
-  RATE_LIMIT,
-  RATE_LIMIT_CREATE_ORDER,
-  RATE_LIMIT_GIGASPOT,
-} from 'cloreai'
+import { RATE_LIMIT, RATE_LIMIT_CREATE_ORDER } from 'cloreai'
 
 console.log(RATE_LIMIT)
 console.log(RATE_LIMIT_CREATE_ORDER)
-console.log(RATE_LIMIT_GIGASPOT)
 ```
 
 You can set your own rate limit values for each request queue:
 
 ```typescript
-import CloreAI from 'cloreai'
-
-const cloreai = new CloreAI('<API_KEY>', {
+const cloreai = new Cloreai('API_KEY', {
   queueOptions: {
     interval: 2000, // For example 2 seconds
   },
-  queueOptionsCreateOrder: {
+  queueCreateOrderOptions: {
     interval: 6000, // For example 6 seconds
   },
-  queueOptionsGigaspot: {
-    interval: 2000, // For example 2 seconds
+})
+```
+
+Access to p-queue instances:
+
+- `cloreai.queue` - main request queue
+- `cloreai.queueCreateOrder` - createOrder request queue
+
+## Retries
+
+For retrying, it's recommended to use
+[p-retry](https://github.com/sindresorhus/p-retry):
+
+```typescript
+import pRetry from 'p-retry'
+
+const marketplace = await pRetry(
+  async () => {
+    return await cloreai.marketplace()
+  },
+  {
+    retries: 5,
   },
+)
+```
+
+## Timeouts
+
+Use `AbortSignal.timeout`.
+
+Options signal from fetchOptions and request options are combined. In the
+following example, the request will be aborted after 5 seconds, but it can also
+be aborted earlier by calling `controller.abort()`.
+
+```typescript
+const cloreai = new Cloreai('API_KEY', {
+  fetchOptions: {
+    signal: AbortSignal.timeout(5000),
+  },
+})
+
+const controller = new AbortController()
+
+setTimeout(() => {
+  controller.abort()
+}, 10000)
+
+const marketplace = await cloreai.marketplace({
+  signal: controller.signal, // Combined with `AbortSignal.timeout(5000)`
 })
 ```

package/dist/Cloreai.d.ts

@@ -0,0 +1,42 @@
+import PQueue, { type Options as PQueueOptions, type Queue, type QueueAddOptions } from 'p-queue';
+import type { CancelOrderRequestData, CancelOrderResponseData } from './resources/cancelOrder.ts';
+import type { CreateOrderRequestData, CreateOrderResponseData } from './resources/createOrder.ts';
+import type { MarketplaceResponseData } from './resources/marketplace.ts';
+import type { MyOrdersRequestParams, MyOrdersResponseData } from './resources/myOrders.ts';
+import type { MyServersResponseData } from './resources/myServers.ts';
+import type { PohBalanceResponseData } from './resources/pohBalance.ts';
+import type { RenterFeesResponseData } from './resources/renterFees.ts';
+import type { ServerConfigRequestData, ServerConfigResponseData } from './resources/serverConfig.ts';
+import type { SetServerSettingsRequestData, SetServerSettingsResponseData } from './resources/setServerSettings.ts';
+import type { SetSpotPriceRequestData, SetSpotPriceResponseData } from './resources/setSpotPrice.ts';
+import type { SpotMarketplaceRequestParams, SpotMarketplaceResponseData } from './resources/spotMarketplace.ts';
+import type { WalletsResponseData } from './resources/wallets.ts';
+import Gigaspot from './Gigaspot.ts';
+export interface Options {
+    baseURL?: string;
+    fetch?: typeof fetch;
+    fetchOptions?: RequestInit;
+    queueOptions?: QueueOptions;
+    queueCreateOrderOptions?: QueueOptions;
+}
+export type QueueOptions = PQueueOptions<Queue<() => Promise<unknown>, QueueAddOptions>, QueueAddOptions>;
+declare class Cloreai {
+    #private;
+    queue: PQueue;
+    queueCreateOrder: PQueue;
+    gigaspot: Gigaspot;
+    constructor(apiKey: string, options?: Options);
+    wallets(init?: RequestInit): Promise<WalletsResponseData>;
+    myServers(init?: RequestInit): Promise<MyServersResponseData>;
+    serverConfig(data: ServerConfigRequestData, init?: RequestInit): Promise<ServerConfigResponseData>;
+    marketplace(init?: RequestInit): Promise<MarketplaceResponseData>;
+    myOrders(params?: MyOrdersRequestParams, init?: RequestInit): Promise<MyOrdersResponseData>;
+    spotMarketplace(params: SpotMarketplaceRequestParams, init?: RequestInit): Promise<SpotMarketplaceResponseData>;
+    setServerSettings(data: SetServerSettingsRequestData, init?: RequestInit): Promise<SetServerSettingsResponseData>;
+    setSpotPrice(data: SetSpotPriceRequestData, init?: RequestInit): Promise<SetSpotPriceResponseData>;
+    cancelOrder(data: CancelOrderRequestData, init?: RequestInit): Promise<CancelOrderResponseData>;
+    createOrder(data: CreateOrderRequestData, init?: RequestInit): Promise<CreateOrderResponseData>;
+    pohBalance(init?: RequestInit): Promise<PohBalanceResponseData>;
+    renterFees(init?: RequestInit): Promise<RenterFeesResponseData>;
+}
+export default Cloreai;

package/dist/Cloreai.js

@@ -0,0 +1,267 @@
+import PQueue, {} from 'p-queue';
+import { CloreaiError } from "./CloreaiError.js";
+import { priorityLevels, RATE_LIMIT, RATE_LIMIT_CREATE_ORDER, statusCodes } from "./constants.js";
+import Gigaspot from "./Gigaspot.js";
+class Cloreai {
+    queue;
+    queueCreateOrder;
+    gigaspot;
+    #baseURL;
+    #fetch;
+    constructor(apiKey, options = {}) {
+        this.#baseURL = options.baseURL ?? 'https://api.clore.ai/v1';
+        const fetchFunction = options.fetch ?? fetch;
+        const fetchOptions = options.fetchOptions ?? {};
+        this.#fetch = async (input, init = {}) => {
+            if (input instanceof Request) {
+                throw new TypeError('Input must be a string or URL');
+            }
+            const headers = new Headers({
+                'Content-Type': 'application/json',
+                'auth': apiKey,
+            });
+            for (const [key, value] of new Headers(fetchOptions.headers)) {
+                headers.set(key, value);
+            }
+            for (const [key, value] of new Headers(init.headers)) {
+                headers.set(key, value);
+            }
+            const signal = AbortSignal.any([
+                ...(fetchOptions.signal ? [fetchOptions.signal] : []),
+                ...(init.signal ? [init.signal] : []),
+            ]);
+            const mergedInit = {
+                ...fetchOptions,
+                ...init,
+                headers,
+                signal,
+            };
+            const url = new URL(input);
+            const request = new Request(url, mergedInit);
+            let response;
+            try {
+                response = await fetchFunction(request);
+            }
+            catch (error) {
+                throw new CloreaiError(error instanceof Error ? error.message : String(error), {
+                    cause: error,
+                    init: mergedInit,
+                    request,
+                });
+            }
+            const originalJson = response.json;
+            // @ts-expect-error: json is readonly
+            response.json = async () => {
+                let data;
+                try {
+                    data = await originalJson.call(response);
+                }
+                catch (error) {
+                    throw new CloreaiError(error instanceof Error ? error.message : String(error), {
+                        cause: error,
+                        init: mergedInit,
+                        request,
+                        response,
+                    });
+                }
+                if (data.code === statusCodes.NORMAL) {
+                    return data;
+                }
+                const hasError = Boolean(data.error);
+                const errorMessage = hasError
+                    ? `Code "${data.code}, error "${data.error}"`
+                    : `Code "${data.code}"`;
+                throw new CloreaiError(errorMessage, {
+                    init: mergedInit,
+                    request,
+                    response,
+                    statusCode: data.code,
+                    description: data.error ?? '',
+                    data,
+                });
+            };
+            return response;
+        };
+        this.queue = new PQueue({
+            interval: RATE_LIMIT,
+            intervalCap: 1,
+            concurrency: 1,
+            ...options.queueOptions,
+        });
+        this.queueCreateOrder = new PQueue({
+            interval: RATE_LIMIT_CREATE_ORDER,
+            intervalCap: 1,
+            concurrency: 1,
+            ...options.queueCreateOrderOptions,
+        });
+        this.gigaspot = new Gigaspot(this.queue, this.#baseURL, this.#fetch);
+    }
+    async wallets(init = {}) {
+        const url = new URL(this.#baseURL + '/wallets');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async myServers(init = {}) {
+        const url = new URL(this.#baseURL + '/my_servers');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async serverConfig(data, init = {}) {
+        const url = new URL(this.#baseURL + '/server_config');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+                body: JSON.stringify(data),
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async marketplace(init = {}) {
+        const url = new URL(this.#baseURL + '/marketplace');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async myOrders(params = {}, init = {}) {
+        const url = new URL(this.#baseURL + '/my_orders');
+        for (const [key, value] of Object.entries(params)) {
+            url.searchParams.set(key, String(value));
+        }
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async spotMarketplace(params, init = {}) {
+        const url = new URL(this.#baseURL + '/spot_marketplace');
+        for (const [key, value] of Object.entries(params)) {
+            url.searchParams.set(key, String(value));
+        }
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async setServerSettings(data, init = {}) {
+        const url = new URL(this.#baseURL + '/set_server_settings');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'POST',
+                body: JSON.stringify(data),
+            });
+        }, {
+            priority: priorityLevels.HIGH,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async setSpotPrice(data, init = {}) {
+        const url = new URL(this.#baseURL + '/set_spot_price');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'POST',
+                body: JSON.stringify(data),
+            });
+        }, {
+            priority: priorityLevels.HIGH,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async cancelOrder(data, init = {}) {
+        const url = new URL(this.#baseURL + '/cancel_order');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'POST',
+                body: JSON.stringify(data),
+            });
+        }, {
+            priority: priorityLevels.HIGH,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async createOrder(data, init = {}) {
+        const url = new URL(this.#baseURL + '/create_order');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'POST',
+                body: JSON.stringify(data),
+            });
+        }, {
+            priority: priorityLevels.HIGHEST,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async pohBalance(init = {}) {
+        const url = new URL(this.#baseURL + '/poh_balance');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+    async renterFees(init = {}) {
+        const url = new URL(this.#baseURL + '/renter_fees');
+        const response = await this.queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        return await response.json();
+    }
+}
+export default Cloreai;

package/dist/CloreaiError.d.ts

@@ -0,0 +1,17 @@
+export interface CloreaiErrorOptions extends ErrorOptions {
+    init?: RequestInit;
+    request?: Request;
+    response?: Response;
+    statusCode?: number;
+    description?: string;
+    data?: unknown;
+}
+export declare class CloreaiError extends Error {
+    init?: RequestInit;
+    request?: Request;
+    response?: Response;
+    statusCode?: number;
+    description?: string;
+    data?: unknown;
+    constructor(message?: string, options?: CloreaiErrorOptions);
+}

package/dist/CloreaiError.js

@@ -0,0 +1,13 @@
+export class CloreaiError extends Error {
+    init;
+    request;
+    response;
+    statusCode;
+    description;
+    data;
+    constructor(message, options) {
+        super(message);
+        this.name = 'CloreaiError';
+        Object.assign(this, options);
+    }
+}

package/dist/Gigaspot.d.ts

@@ -0,0 +1,14 @@
+import type PQueue from 'p-queue';
+import type { CancelOrdersRequestData, CancelOrdersResponseData } from './resources/cancelOrders.ts';
+import type { CreateGigaspotOrdersRequestData, CreateGigaspotOrdersResponseData } from './resources/createGigaspotOrders.ts';
+import type { EditGigaspotOrdersRequestData, EditGigaspotOrdersResponseData } from './resources/editGigaspotOrders.ts';
+import type { GetGigaspotResponseData } from './resources/getGigaspot.ts';
+declare class Gigaspot {
+    #private;
+    constructor(queue: PQueue, baseURL: string, fetchFunction: typeof fetch);
+    getGigaspot(init?: RequestInit): Promise<GetGigaspotResponseData>;
+    createGigaspotOrders(data: CreateGigaspotOrdersRequestData, init?: RequestInit): Promise<CreateGigaspotOrdersResponseData>;
+    editGigaspotOrders(data: EditGigaspotOrdersRequestData, init?: RequestInit): Promise<EditGigaspotOrdersResponseData>;
+    cancelOrders(data: CancelOrdersRequestData, init?: RequestInit): Promise<CancelOrdersResponseData>;
+}
+export default Gigaspot;