cloreai 3.0.0 → 4.0.0

package/README.md

@@ -4,11 +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)
-- User-friendly error handling
-- Full typing
+- Convenient error handling
+- Full type safety
 - Supports GigaSPOT
 
 Official documentation: [clore.ai/api-docs](https://clore.ai/api-docs)
@@ -30,10 +30,11 @@ npm install cloreai
 import Cloreai from 'cloreai'
 
 const cloreai = new Cloreai('API_KEY', {
-  axiosOptions: {}, // (optional) Axios instance options https://github.com/axios/axios
+  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
   queueCreateOrderOptions: {}, // (optional) Create order queue instance options https://github.com/sindresorhus/p-queue
-  queueGigaspotOptions: {}, //  (optional) Gigaspot queue instance options https://github.com/sindresorhus/p-queue
 })
 ```
 
@@ -142,7 +143,7 @@ await cloreai.createOrder({
 })
 ```
 
-### 11. PoH Info
+### 11. poh_balance
 
 ```typescript
 const pohBalance = await cloreai.pohBalance()
@@ -206,41 +207,23 @@ 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 the main request queue
-- `cloreai.queueCreateOrder` - for the createOrder request queue
-- `cloreai.gigaspot.queue` - for the gigaspot request queue
-
-Refer to the documentation [p-queue](https://github.com/sindresorhus/p-queue).
-
-### Error Handling
+## Error Handling
 
 Use the `CloreaiError` class for error handling.
 
-This class inherits from `AxiosError` and has additional fields with error
-information `error.code` and `error.error`.
+Errors have fields with information `error.statusCode` and `error.description`.
 
-To check the error type use the constant `statusCodes`.
+Use the constant `statusCodes` to check the error type.
 
 ```typescript
 import { CloreaiError, statusCodes } from 'cloreai'
@@ -249,9 +232,9 @@ try {
   const marketplace = await cloreai.marketplace()
 } catch (error) {
   if (error instanceof CloreaiError) {
-    console.log(error.code, error.error)
+    console.log(error.statusCode, error.description)
 
-    if (error.code === statusCodes.EXCEEDED) {
+    if (error.statusCode === statusCodes.EXCEEDED) {
       console.log('Rate limit exceeded error')
     }
   } else {
@@ -260,31 +243,24 @@ try {
 }
 ```
 
-### Rate limit
+## Rate limit
 
-All methods are protected from rate limit exceeded via
+All methods are protected from rate limit exceeded through
 [p-queue](https://github.com/sindresorhus/p-queue), they automatically delay for
-the required time to avoid exceeding the limit.
+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 custom rate limit values for each request queue:
+You can set your own rate limit values for each request queue:
 
 ```typescript
-import Cloreai from 'cloreai'
-
 const cloreai = new Cloreai('API_KEY', {
   queueOptions: {
     interval: 2000, // For example 2 seconds
@@ -292,8 +268,54 @@ const cloreai = new Cloreai('API_KEY', {
   queueCreateOrderOptions: {
     interval: 6000, // For example 6 seconds
   },
-  queueGigaspotOptions: {
-    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/{build → dist}/Cloreai.d.ts

@@ -1,4 +1,3 @@
-import { type AxiosInstance, type AxiosRequestConfig, type CreateAxiosDefaults } from 'axios';
 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';
@@ -13,30 +12,31 @@ import type { SetSpotPriceRequestData, SetSpotPriceResponseData } from './resour
 import type { SpotMarketplaceRequestParams, SpotMarketplaceResponseData } from './resources/spotMarketplace.ts';
 import type { WalletsResponseData } from './resources/wallets.ts';
 import Gigaspot from './Gigaspot.ts';
-export type QueueOptions = PQueueOptions<Queue<() => Promise<unknown>, QueueAddOptions>, QueueAddOptions>;
 export interface Options {
-    axiosOptions?: CreateAxiosDefaults;
+    baseURL?: string;
+    fetch?: typeof fetch;
+    fetchOptions?: RequestInit;
     queueOptions?: QueueOptions;
     queueCreateOrderOptions?: QueueOptions;
-    queueGigaspotOptions?: QueueOptions;
 }
+export type QueueOptions = PQueueOptions<Queue<() => Promise<unknown>, QueueAddOptions>, QueueAddOptions>;
 declare class Cloreai {
-    axios: AxiosInstance;
+    #private;
     queue: PQueue;
     queueCreateOrder: PQueue;
     gigaspot: Gigaspot;
     constructor(apiKey: string, options?: Options);
-    wallets(config?: AxiosRequestConfig): Promise<WalletsResponseData>;
-    myServers(config?: AxiosRequestConfig): Promise<MyServersResponseData>;
-    serverConfig(data: ServerConfigRequestData, config?: AxiosRequestConfig): Promise<ServerConfigResponseData>;
-    marketplace(config?: AxiosRequestConfig): Promise<MarketplaceResponseData>;
-    myOrders(params?: MyOrdersRequestParams, config?: AxiosRequestConfig): Promise<MyOrdersResponseData>;
-    spotMarketplace(params: SpotMarketplaceRequestParams, config?: AxiosRequestConfig): Promise<SpotMarketplaceResponseData>;
-    setServerSettings(data: SetServerSettingsRequestData, config?: AxiosRequestConfig): Promise<SetServerSettingsResponseData>;
-    setSpotPrice(data: SetSpotPriceRequestData, config?: AxiosRequestConfig): Promise<SetSpotPriceResponseData>;
-    cancelOrder(data: CancelOrderRequestData, config?: AxiosRequestConfig): Promise<CancelOrderResponseData>;
-    createOrder(data: CreateOrderRequestData, config?: AxiosRequestConfig): Promise<CreateOrderResponseData>;
-    pohBalance(config?: AxiosRequestConfig): Promise<PohBalanceResponseData>;
-    renterFees(config?: AxiosRequestConfig): Promise<RenterFeesResponseData>;
+    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;

package/dist/Gigaspot.js

@@ -0,0 +1,74 @@
+import { priorityLevels } from "./constants.js";
+/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
+class Gigaspot {
+    #queue;
+    #baseURL;
+    #fetch;
+    constructor(queue, baseURL, fetchFunction) {
+        this.#queue = queue;
+        this.#baseURL = baseURL;
+        this.#fetch = fetchFunction;
+    }
+    async getGigaspot(init = {}) {
+        const url = new URL(this.#baseURL + '/get_gigaspot');
+        const response = await this.#queue.add(async () => {
+            return await this.#fetch(url, {
+                ...init,
+                method: 'GET',
+            });
+        }, {
+            priority: priorityLevels.NORMAL,
+            signal: init.signal ?? undefined,
+        });
+        const data = await response.json();
+        const snapshotResponse = await fetch(data.v1_snapshot_url);
+        const snapshotData = await snapshotResponse.json();
+        return {
+            ...data,
+            snapshot: snapshotData,
+        };
+    }
+    async createGigaspotOrders(data, init = {}) {
+        const url = new URL(this.#baseURL + '/create_gigaspot_orders');
+        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 editGigaspotOrders(data, init = {}) {
+        const url = new URL(this.#baseURL + '/edit_gigaspot_orders');
+        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 cancelOrders(data, init = {}) {
+        const url = new URL(this.#baseURL + '/cancel_orders');
+        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();
+    }
+}
+export default Gigaspot;

package/{build → dist}/constants.d.ts

@@ -1,6 +1,5 @@
 export declare const RATE_LIMIT = 1000;
 export declare const RATE_LIMIT_CREATE_ORDER = 5000;
-export declare const RATE_LIMIT_GIGASPOT = 1000;
 export declare const gigaspotBaseImages: Readonly<{
     UBUNTU: "a3f9c4d7e5b088d8a0bff880";
     HIVEOS: "c9a4e2f6b7d488d8f0bab0ff";

package/{build → dist}/constants.js

@@ -1,6 +1,5 @@
 export const RATE_LIMIT = 1000;
 export const RATE_LIMIT_CREATE_ORDER = 5000;
-export const RATE_LIMIT_GIGASPOT = 1000;
 export const gigaspotBaseImages = Object.freeze({
     UBUNTU: 'a3f9c4d7e5b088d8a0bff880',
     HIVEOS: 'c9a4e2f6b7d488d8f0bab0ff',