cloreai 3.0.0 → 4.0.1

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
+  fetchOptions: {}, // (optional) Additional `RequestInit` options to be passed to `fetch` calls
+  fetch: globalThis.fetch, // (optional) Specify a custom `fetch` function implementation
   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,53 @@ 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`:
+
+```typescript
+const marketplace = await cloreai.marketplace({
+  signal: AbortSignal.timeout(5000),
+})
+```
+
+Combine signals using `AbortSignal.any`. In the following example, the request
+will be aborted after 5 seconds, but can also be aborted earlier by calling
+`controller.abort()`:
+
+```typescript
+const controller = new AbortController()
+
+// You can abort by event
+// controller.abort()
+
+const marketplace = await cloreai.marketplace({
+  signal: AbortSignal.any([AbortSignal.timeout(5000), controller.signal]),
 })
 ```

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,34 @@ 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;
+    fetchOptions?: RequestInit;
+    fetch?: typeof fetch;
     queueOptions?: QueueOptions;
     queueCreateOrderOptions?: QueueOptions;
-    queueGigaspotOptions?: QueueOptions;
 }
+export type QueueOptions = PQueueOptions<Queue<() => Promise<unknown>, QueueAddOptions>, QueueAddOptions>;
 declare class Cloreai {
-    axios: AxiosInstance;
+    #private;
+    baseURL: string;
+    fetchOptions: RequestInit;
+    fetch: typeof fetch;
     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 {
+    baseURL;
+    fetchOptions;
+    fetch;
+    queue;
+    queueCreateOrder;
+    gigaspot;
+    #apiKey;
+    constructor(apiKey, options = {}) {
+        this.baseURL = options.baseURL ?? 'https://api.clore.ai/v1';
+        this.fetchOptions = options.fetchOptions ?? {};
+        this.fetch = options.fetch ?? fetch;
+        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, this.#fetch.bind(this));
+        this.#apiKey = apiKey;
+    }
+    async #fetch(input, init = {}) {
+        const headers = new Headers({
+            'Content-Type': 'application/json',
+            'auth': this.#apiKey,
+        });
+        for (const [key, value] of new Headers(this.fetchOptions.headers)) {
+            headers.set(key, value);
+        }
+        for (const [key, value] of new Headers(init.headers)) {
+            headers.set(key, value);
+        }
+        const signal = AbortSignal.any([
+            ...(this.fetchOptions.signal ? [this.fetchOptions.signal] : []),
+            ...(init.signal ? [init.signal] : []),
+        ]);
+        const mergedInit = {
+            ...this.fetchOptions,
+            ...init,
+            headers,
+            signal,
+        };
+        const url = new URL(input);
+        const request = new Request(url, mergedInit);
+        let response;
+        try {
+            response = await this.fetch(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;
+    }
+    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,15 @@
+import type Cloreai from './Cloreai.ts';
+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';
+type Fetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+declare class Gigaspot {
+    #private;
+    constructor(cloreai: Cloreai, fetch: 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,71 @@
+import { priorityLevels } from "./constants.js";
+class Gigaspot {
+    #cloreai;
+    #fetch;
+    constructor(cloreai, fetch) {
+        this.#cloreai = cloreai;
+        this.#fetch = fetch;
+    }
+    async getGigaspot(init = {}) {
+        const url = new URL(this.#cloreai.baseURL + '/get_gigaspot');
+        const response = await this.#cloreai.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.#cloreai.baseURL + '/create_gigaspot_orders');
+        const response = await this.#cloreai.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.#cloreai.baseURL + '/edit_gigaspot_orders');
+        const response = await this.#cloreai.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.#cloreai.baseURL + '/cancel_orders');
+        const response = await this.#cloreai.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',