@limitless-exchange/sdk 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -352,6 +352,42 @@ var HttpClient = class {
       }
     );
   }
+  /**
+   * Extracts a human-readable error message from API response payload.
+   * @internal
+   */
+  extractErrorMessage(data, fallback) {
+    if (!data) {
+      return fallback;
+    }
+    if (typeof data === "object") {
+      if (Array.isArray(data.message)) {
+        const messages = data.message.map((err) => {
+          const details = Object.entries(err || {}).filter(([_key, val]) => val !== "" && val !== null && val !== void 0).map(([key, val]) => `${key}: ${val}`).join(", ");
+          return details || JSON.stringify(err);
+        }).filter((msg) => msg.trim() !== "").join(" | ");
+        return messages || data.error || JSON.stringify(data);
+      }
+      return data.message || data.error || data.msg || data.errors && JSON.stringify(data.errors) || JSON.stringify(data);
+    }
+    return String(data);
+  }
+  /**
+   * Creates a typed API error class from status code.
+   * @internal
+   */
+  createTypedApiError(status, message, data, url, method) {
+    if (status === 429) {
+      return new RateLimitError(message, status, data, url, method);
+    }
+    if (status === 401 || status === 403) {
+      return new AuthenticationError(message, status, data, url, method);
+    }
+    if (status === 400) {
+      return new ValidationError(message, status, data, url, method);
+    }
+    return new APIError(message, status, data, url, method);
+  }
   /**
    * Sets the API key for authenticated requests.
    *
@@ -377,6 +413,28 @@ var HttpClient = class {
     const response = await this.client.get(url, config);
     return response.data;
   }
+  /**
+   * Performs a GET request and returns raw response metadata.
+   *
+   * @remarks
+   * Use this when callers need access to status code or headers (e.g. redirect `Location`).
+   *
+   * @param url - Request URL
+   * @param config - Additional request configuration
+   * @returns Promise resolving to status, headers, and response data
+   */
+  async getRaw(url, config) {
+    const response = await this.client.get(url, config);
+    if (response.status >= 400) {
+      const message = this.extractErrorMessage(response.data, `Request failed with status ${response.status}`);
+      throw this.createTypedApiError(response.status, message, response.data, url, "GET");
+    }
+    return {
+      status: response.status,
+      headers: response.headers,
+      data: response.data
+    };
+  }
   /**
    * Performs a POST request.
    *
@@ -1023,7 +1081,7 @@ var OrderValidationError = class extends Error {
   }
 };
 function isFOKOrder(args) {
-  return "amount" in args;
+  return "makerAmount" in args;
 }
 function validateOrderArgs(args) {
   if (!args.tokenId) {
@@ -1811,6 +1869,174 @@ var OrderClient = class {
   }
 };
 
+// src/market-pages/fetcher.ts
+var MAX_REDIRECT_DEPTH = 3;
+var MarketPageFetcher = class {
+  /**
+   * Creates a new market-pages fetcher.
+   *
+   * @param httpClient - HTTP client for API calls
+   * @param logger - Optional logger
+   */
+  constructor(httpClient, logger) {
+    this.httpClient = httpClient;
+    this.logger = logger || new NoOpLogger();
+  }
+  /**
+   * Gets the navigation tree.
+   */
+  async getNavigation() {
+    this.logger.debug("Fetching navigation tree");
+    return this.httpClient.get("/navigation");
+  }
+  /**
+   * Resolves a market page by path.
+   *
+   * @remarks
+   * Handles 301 redirects manually by re-requesting `/market-pages/by-path` with the
+   * redirected path value from `Location` header.
+   */
+  async getMarketPageByPath(path) {
+    return this.getMarketPageByPathInternal(path, 0);
+  }
+  async getMarketPageByPathInternal(path, depth) {
+    const query = new URLSearchParams({ path }).toString();
+    const endpoint = `/market-pages/by-path?${query}`;
+    const requestConfig = {
+      maxRedirects: 0,
+      validateStatus: (status) => status === 200 || status === 301
+    };
+    this.logger.debug("Resolving market page by path", { path, depth });
+    const response = await this.httpClient.getRaw(endpoint, requestConfig);
+    if (response.status === 200) {
+      return response.data;
+    }
+    if (response.status !== 301) {
+      throw new Error(`Unexpected response status: ${response.status}`);
+    }
+    if (depth >= MAX_REDIRECT_DEPTH) {
+      throw new Error(
+        `Too many redirects while resolving market page path '${path}' (max ${MAX_REDIRECT_DEPTH})`
+      );
+    }
+    const locationHeader = response.headers?.location;
+    const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+    if (!location || typeof location !== "string") {
+      throw new Error("Redirect response missing valid Location header");
+    }
+    const redirectedPath = this.extractRedirectPath(location);
+    this.logger.info("Following market page redirect", {
+      from: path,
+      to: redirectedPath,
+      depth: depth + 1
+    });
+    return this.getMarketPageByPathInternal(redirectedPath, depth + 1);
+  }
+  extractRedirectPath(location) {
+    const directByPathPrefix = "/market-pages/by-path";
+    if (location.startsWith(directByPathPrefix)) {
+      const url = new URL(location, "https://api.limitless.exchange");
+      const path = url.searchParams.get("path");
+      if (!path) {
+        throw new Error("Redirect location '/market-pages/by-path' is missing required 'path' query parameter");
+      }
+      return path;
+    }
+    if (/^https?:\/\//i.test(location)) {
+      const url = new URL(location);
+      if (url.pathname === directByPathPrefix) {
+        const path = url.searchParams.get("path");
+        if (!path) {
+          throw new Error("Redirect location '/market-pages/by-path' is missing required 'path' query parameter");
+        }
+        return path;
+      }
+      return url.pathname || "/";
+    }
+    return location;
+  }
+  /**
+   * Gets markets for a market page with optional filtering and pagination.
+   */
+  async getMarkets(pageId, params = {}) {
+    if (params.cursor !== void 0 && params.page !== void 0) {
+      throw new Error("Parameters `cursor` and `page` are mutually exclusive");
+    }
+    const query = new URLSearchParams();
+    if (params.page !== void 0) {
+      query.append("page", String(params.page));
+    }
+    if (params.limit !== void 0) {
+      query.append("limit", String(params.limit));
+    }
+    if (params.sort) {
+      query.append("sort", params.sort);
+    }
+    if (params.cursor !== void 0) {
+      query.append("cursor", params.cursor);
+    }
+    if (params.filters) {
+      for (const [key, value] of Object.entries(params.filters)) {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            query.append(key, this.stringifyFilterValue(item));
+          }
+        } else {
+          query.append(key, this.stringifyFilterValue(value));
+        }
+      }
+    }
+    const queryString = query.toString();
+    const endpoint = `/market-pages/${pageId}/markets${queryString ? `?${queryString}` : ""}`;
+    this.logger.debug("Fetching market-page markets", { pageId, params });
+    const response = await this.httpClient.get(endpoint);
+    const markets = (response.data || []).map((marketData) => new Market(marketData, this.httpClient));
+    if (response.pagination) {
+      return {
+        data: markets,
+        pagination: response.pagination
+      };
+    }
+    if (response.cursor) {
+      return {
+        data: markets,
+        cursor: response.cursor
+      };
+    }
+    throw new Error("Invalid market-page response: expected `pagination` or `cursor` metadata");
+  }
+  /**
+   * Lists all property keys with options.
+   */
+  async getPropertyKeys() {
+    return this.httpClient.get("/property-keys");
+  }
+  /**
+   * Gets a single property key by ID.
+   */
+  async getPropertyKey(id) {
+    return this.httpClient.get(`/property-keys/${id}`);
+  }
+  /**
+   * Lists options for a property key, optionally filtered by parent option ID.
+   */
+  async getPropertyOptions(keyId, parentId) {
+    const query = new URLSearchParams();
+    if (parentId) {
+      query.append("parentId", parentId);
+    }
+    const queryString = query.toString();
+    const endpoint = `/property-keys/${keyId}/options${queryString ? `?${queryString}` : ""}`;
+    return this.httpClient.get(endpoint);
+  }
+  stringifyFilterValue(value) {
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    return String(value);
+  }
+};
+
 // src/websocket/client.ts
 import { io } from "socket.io-client";
 var WebSocketClient = class {
@@ -2193,6 +2419,7 @@ export {
   HttpClient,
   Market,
   MarketFetcher,
+  MarketPageFetcher,
   NoOpLogger,
   OrderBuilder,
   OrderClient,