@pear-protocol/core-sdk 0.0.1

package/dist/auth/index.d.ts

@@ -0,0 +1,50 @@
+import { HttpTypes } from '@pear-protocol/types';
+import { HttpClient } from '../http.js';
+import { ClientHeaders } from '../types.js';
+
+declare class Auth {
+    private client;
+    constructor(client: HttpClient);
+    me(headers?: ClientHeaders): Promise<{
+        id: string;
+        role: "basic" | "pro";
+    }>;
+    login(body: HttpTypes.LoginRequest, headers?: ClientHeaders): Promise<{
+        user: {
+            id: string;
+            role: "basic" | "pro";
+        };
+    }>;
+    refreshSession(headers?: ClientHeaders): Promise<void>;
+    refreshToken(body: HttpTypes.RefreshTokenRequest, headers?: ClientHeaders): Promise<{
+        accessToken: string;
+        refreshToken: string;
+        tokenType: "Bearer";
+        expiresIn: number;
+    }>;
+    logout(headers?: ClientHeaders): Promise<void>;
+    requestNonce(body: HttpTypes.RequestNonceRequest, headers?: ClientHeaders): Promise<{
+        nonce: string;
+        expiresAt: number;
+    }>;
+    register(body: HttpTypes.EmailRegisterRequest, headers?: ClientHeaders): Promise<{
+        user: {
+            id: string;
+            role: "basic" | "pro";
+        };
+    }>;
+    linkEmail(body: HttpTypes.LinkEmailRequest, headers?: ClientHeaders): Promise<{
+        user: {
+            id: string;
+            role: "basic" | "pro";
+        };
+    }>;
+    linkWallet(body: HttpTypes.LinkWalletRequest, headers?: ClientHeaders): Promise<{
+        user: {
+            id: string;
+            role: "basic" | "pro";
+        };
+    }>;
+}
+
+export { Auth };

package/dist/auth/index.js

@@ -0,0 +1,68 @@
+class Auth {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async me(headers) {
+    return await this.client.fetch(`/auth/me`, {
+      method: "GET",
+      headers
+    });
+  }
+  async login(body, headers) {
+    return await this.client.fetch(`/auth/login`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }
+  async refreshSession(headers) {
+    return await this.client.fetch(`/auth/refresh`, {
+      method: "POST",
+      headers
+    });
+  }
+  async refreshToken(body, headers) {
+    return await this.client.fetch(`/auth/refresh/token`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }
+  async logout(headers) {
+    return await this.client.fetch(`/auth/logout`, {
+      method: "POST",
+      headers
+    });
+  }
+  async requestNonce(body, headers) {
+    return await this.client.fetch(`/auth/nonce`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }
+  async register(body, headers) {
+    return await this.client.fetch(`/auth/register`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }
+  async linkEmail(body, headers) {
+    return await this.client.fetch(`/auth/link/email`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }
+  async linkWallet(body, headers) {
+    return await this.client.fetch(`/auth/link/wallet`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }
+}
+
+export { Auth };

package/dist/http.d.ts

@@ -0,0 +1,28 @@
+import { AuthMode, Logger, RequestMiddleware, ResponseMiddleware, FetchInput, FetchArgs } from './types.js';
+
+declare class HttpClient {
+    private baseUrl;
+    private logger;
+    private authMode;
+    private requestMiddlewares;
+    private responseMiddlewares;
+    constructor(baseUrl: string, authMode?: AuthMode, logger?: Logger, debug?: boolean);
+    /**
+     * Add a request middleware that runs before the request is sent.
+     * Middlewares are executed in order.
+     */
+    useRequest(middleware: RequestMiddleware): void;
+    /**
+     * Add a response middleware that runs after the response is received.
+     * Middlewares are executed in order.
+     * The retry function allows retrying the request.
+     */
+    useResponse(middleware: ResponseMiddleware): void;
+    fetch<T>(input: FetchInput, init?: FetchArgs): Promise<T>;
+    private createDefaultHeaders;
+    private mergeHeaders;
+    private normalizeInput;
+    private logRequest;
+}
+
+export { HttpClient };

package/dist/http.js

@@ -0,0 +1,134 @@
+import { stringify } from 'qs';
+import { getBaseUrl, normalizeRequest, normalizeResponseData } from './utils';
+
+class HttpClient {
+  baseUrl;
+  logger;
+  authMode;
+  requestMiddlewares = [];
+  responseMiddlewares = [];
+  constructor(baseUrl, authMode = "session", logger, debug) {
+    this.baseUrl = getBaseUrl(baseUrl);
+    this.authMode = authMode;
+    const defaultLogger = logger || {
+      error: console.error,
+      warn: console.warn,
+      info: console.info,
+      debug: console.debug
+    };
+    this.logger = {
+      ...defaultLogger,
+      debug: debug ? defaultLogger.debug : () => {
+      }
+    };
+  }
+  /**
+   * Add a request middleware that runs before the request is sent.
+   * Middlewares are executed in order.
+   */
+  useRequest(middleware) {
+    this.requestMiddlewares.push(middleware);
+  }
+  /**
+   * Add a response middleware that runs after the response is received.
+   * Middlewares are executed in order.
+   * The retry function allows retrying the request.
+   */
+  useResponse(middleware) {
+    this.responseMiddlewares.push(middleware);
+  }
+  async fetch(input, init) {
+    const defaultHeaders = this.createDefaultHeaders();
+    const headers = this.mergeHeaders(defaultHeaders, init);
+    const normalizedInput = this.normalizeInput(input, init);
+    this.logRequest(normalizedInput, headers);
+    const request = new Request(normalizedInput, normalizeRequest(init, headers, this.authMode));
+    const executeRequest = async () => {
+      let currentIndex = 0;
+      const next = async () => {
+        if (currentIndex < this.requestMiddlewares.length) {
+          const middleware = this.requestMiddlewares[currentIndex++];
+          if (middleware) {
+            return middleware(request, next);
+          }
+        }
+        return await fetch(request);
+      };
+      return next();
+    };
+    let response = await executeRequest();
+    const executeResponse = async (resp) => {
+      let currentIndex = 0;
+      const processMiddlewares = async () => {
+        if (currentIndex < this.responseMiddlewares.length) {
+          const middleware = this.responseMiddlewares[currentIndex++];
+          if (middleware) {
+            return middleware(
+              resp,
+              async () => {
+                const newResponse = await executeRequest();
+                return executeResponse(newResponse);
+              },
+              request
+            );
+          }
+        }
+        return resp;
+      };
+      return processMiddlewares();
+    };
+    response = await executeResponse(response);
+    this.logger.debug(`Received response with status ${response.status}
+`);
+    return await normalizeResponseData(response, headers);
+  }
+  createDefaultHeaders() {
+    return new Headers({
+      "content-type": "application/json",
+      accept: "application/json"
+    });
+  }
+  mergeHeaders(defaultHeaders, init) {
+    const headers = new Headers(defaultHeaders);
+    const customHeaders = {
+      ...init?.headers
+    };
+    Object.entries(customHeaders).forEach(([key, value]) => {
+      if (value === null) {
+        headers.delete(key);
+      } else {
+        headers.set(key, value);
+      }
+    });
+    return headers;
+  }
+  normalizeInput(input, init) {
+    let normalizedInput = input;
+    if (input instanceof URL || typeof input === "string") {
+      const baseUrl = new URL(this.baseUrl);
+      const fullPath = `${baseUrl.pathname.replace(/\/$/, "")}/${input.toString().replace(/^\//, "")}`;
+      normalizedInput = new URL(fullPath, baseUrl.origin);
+      if (init?.query) {
+        const params = Object.fromEntries(normalizedInput.searchParams.entries());
+        const stringifiedQuery = stringify({ ...params, ...init.query }, { skipNulls: true, arrayFormat: "repeat" });
+        normalizedInput.search = stringifiedQuery;
+      }
+    }
+    return normalizedInput;
+  }
+  logRequest(normalizedInput, headers) {
+    const headersObj = {};
+    headers.forEach((value, key) => {
+      headersObj[key] = value;
+    });
+    this.logger.debug(
+      "Performing request to:\n",
+      `URL: ${normalizedInput.toString()}
+`,
+      `Headers: ${JSON.stringify(headersObj, null, 2)}
+`
+    );
+  }
+}
+
+export { HttpClient };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { Auth } from './auth/index.js';
+import { Info } from './info/index.js';
+import { Trade } from './trade/index.js';
+import { SDKConfig } from './types.js';
+export { HttpTypes } from '@pear-protocol/types';
+export * from '@pear-protocol/utils';
+import './http.js';
+
+declare class PearSDK {
+    auth: Auth;
+    trade: Trade;
+    info: Info;
+    constructor(config: SDKConfig);
+}
+
+export { PearSDK as default };

package/dist/index.js

@@ -0,0 +1,52 @@
+import { Auth } from './auth';
+import { HttpClient } from './http';
+import { Info } from './info';
+import { Trade } from './trade';
+import { FetchError } from './utils';
+export * from '@pear-protocol/utils';
+
+class PearSDK {
+  auth;
+  trade;
+  info;
+  constructor(config) {
+    const authMode = config.auth?.type ?? "session";
+    const apiClient = new HttpClient(config.apiUrl, authMode, config.logger, config.debug);
+    const authClient = new HttpClient(config.authUrl, authMode, config.logger, config.debug);
+    this.auth = new Auth(authClient);
+    this.trade = new Trade(apiClient);
+    this.info = new Info(apiClient);
+    if (authMode === "bearer" && config.auth?.token) {
+      const getToken = config.auth.token;
+      apiClient.useRequest(async (request, next) => {
+        const token = getToken();
+        if (token) {
+          request.headers.set("Authorization", `Bearer ${token}`);
+        }
+        return next();
+      });
+      if (config.onAuthError) {
+        const onAuthError = config.onAuthError;
+        apiClient.useResponse(async (response) => {
+          if (response.status === 401) {
+            onAuthError();
+            throw new FetchError("Unauthorized. Token may be expired or revoked.", "Unauthorized", 401);
+          }
+          return response;
+        });
+      }
+    }
+    if (config.getTradeAccountId) {
+      const getTradeAccountId = config.getTradeAccountId;
+      apiClient.useRequest(async (request, next) => {
+        const tradeAccountId = getTradeAccountId();
+        if (tradeAccountId) {
+          request.headers.set("x-trade-account-id", tradeAccountId);
+        }
+        return next();
+      });
+    }
+  }
+}
+
+export { PearSDK as default };