@opensea/cli 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,18 +1,15 @@
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.opensea.io";
-var DEFAULT_GRAPHQL_URL = "https://gql.opensea.io/graphql";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var OpenSeaClient = class {
   apiKey;
   baseUrl;
-  graphqlUrl;
   defaultChain;
   timeoutMs;
   verbose;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
-    this.graphqlUrl = config.graphqlUrl ?? DEFAULT_GRAPHQL_URL;
     this.defaultChain = config.chain ?? "ethereum";
     this.timeoutMs = config.timeout ?? DEFAULT_TIMEOUT_MS;
     this.verbose = config.verbose ?? false;
@@ -80,40 +77,6 @@ var OpenSeaClient = class {
     }
     return response.json();
   }
-  async graphql(query, variables) {
-    if (this.verbose) {
-      console.error(`[verbose] POST ${this.graphqlUrl}`);
-    }
-    const response = await fetch(this.graphqlUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "x-api-key": this.apiKey
-      },
-      body: JSON.stringify({ query, variables }),
-      signal: AbortSignal.timeout(this.timeoutMs)
-    });
-    if (this.verbose) {
-      console.error(`[verbose] ${response.status} ${response.statusText}`);
-    }
-    if (!response.ok) {
-      const body = await response.text();
-      throw new OpenSeaAPIError(response.status, body, "graphql");
-    }
-    const json = await response.json();
-    if (json.errors?.length) {
-      throw new OpenSeaAPIError(
-        400,
-        json.errors.map((e) => e.message).join("; "),
-        "graphql"
-      );
-    }
-    if (!json.data) {
-      throw new OpenSeaAPIError(500, "GraphQL response missing data", "graphql");
-    }
-    return json.data;
-  }
   getDefaultChain() {
     return this.defaultChain;
   }
@@ -128,98 +91,320 @@ var OpenSeaAPIError = class extends Error {
   }
 };
 
-// src/queries.ts
-var SEARCH_COLLECTIONS_QUERY = `
-query SearchCollections($query: String!, $limit: Int, $chains: [ChainIdentifier!]) {
-  collectionsByQuery(query: $query, limit: $limit, chains: $chains) {
-    slug
-    name
-    description
-    imageUrl
-    chain {
-      identifier
-      name
+// src/toon.ts
+var INDENT = "  ";
+var NUMERIC_RE = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i;
+var LEADING_ZERO_RE = /^0\d+$/;
+var UNQUOTED_KEY_RE = /^[A-Za-z_][A-Za-z0-9_.]*$/;
+function escapeString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function needsQuoting(value, delimiter) {
+  if (value === "") return true;
+  if (value !== value.trim()) return true;
+  if (value === "true" || value === "false" || value === "null") return true;
+  if (NUMERIC_RE.test(value) || LEADING_ZERO_RE.test(value)) return true;
+  if (/[:"\\[\]{}]/.test(value)) return true;
+  if (/[\n\r\t]/.test(value)) return true;
+  if (value.includes(delimiter)) return true;
+  if (value.startsWith("-")) return true;
+  return false;
+}
+function encodeKey(key) {
+  if (UNQUOTED_KEY_RE.test(key)) return key;
+  return `"${escapeString(key)}"`;
+}
+function encodePrimitive(value, delimiter) {
+  if (value === null) return "null";
+  if (value === void 0) return "null";
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") {
+    if (needsQuoting(value, delimiter)) {
+      return `"${escapeString(value)}"`;
     }
-    stats {
-      totalSupply
-      ownerCount
-      volume {
-        usd
-      }
-      sales
+    return value;
+  }
+  return `"${escapeString(String(value))}"`;
+}
+function isPrimitive(value) {
+  return value === null || value === void 0 || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
+}
+function isTabular(arr) {
+  if (arr.length === 0) return false;
+  const first = arr[0];
+  if (first === null || typeof first !== "object" || Array.isArray(first))
+    return false;
+  const keys = Object.keys(first).sort();
+  for (const item of arr) {
+    if (item === null || typeof item !== "object" || Array.isArray(item))
+      return false;
+    const itemKeys = Object.keys(item).sort();
+    if (itemKeys.length !== keys.length) return false;
+    for (let i = 0; i < keys.length; i++) {
+      if (itemKeys[i] !== keys[i]) return false;
     }
-    floorPrice {
-      pricePerItem {
-        usd
-        native {
-          unit
-          symbol
-        }
-      }
+    for (const k of keys) {
+      if (!isPrimitive(item[k])) return false;
     }
   }
-}`;
-var SEARCH_NFTS_QUERY = `
-query SearchItems($query: String!, $collectionSlug: String, $limit: Int, $chains: [ChainIdentifier!]) {
-  itemsByQuery(query: $query, collectionSlug: $collectionSlug, limit: $limit, chains: $chains) {
-    tokenId
-    name
-    description
-    imageUrl
-    contractAddress
-    collection {
-      slug
-      name
+  return true;
+}
+function isPrimitiveArray(arr) {
+  return arr.every(isPrimitive);
+}
+function encodeValue(value, depth, delimiter) {
+  if (isPrimitive(value)) {
+    return encodePrimitive(value, delimiter);
+  }
+  if (Array.isArray(value)) {
+    return encodeArray(value, depth, delimiter);
+  }
+  if (typeof value === "object" && value !== null) {
+    return encodeObject(value, depth, delimiter);
+  }
+  return encodePrimitive(value, delimiter);
+}
+function encodeObject(obj, depth, delimiter) {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return "";
+  const lines = [];
+  const prefix = INDENT.repeat(depth);
+  for (const [key, value] of entries) {
+    const encodedKey = encodeKey(key);
+    if (isPrimitive(value)) {
+      lines.push(`${prefix}${encodedKey}: ${encodePrimitive(value, delimiter)}`);
+    } else if (Array.isArray(value)) {
+      lines.push(encodeArrayField(encodedKey, value, depth, delimiter));
+    } else if (typeof value === "object" && value !== null) {
+      const nested = value;
+      if (Object.keys(nested).length === 0) {
+        lines.push(`${prefix}${encodedKey}:`);
+      } else {
+        lines.push(`${prefix}${encodedKey}:`);
+        lines.push(encodeObject(nested, depth + 1, delimiter));
+      }
     }
-    chain {
-      identifier
-      name
+  }
+  return lines.join("\n");
+}
+function encodeArrayField(encodedKey, arr, depth, delimiter) {
+  const prefix = INDENT.repeat(depth);
+  if (arr.length === 0) {
+    return `${prefix}${encodedKey}[0]:`;
+  }
+  if (isPrimitiveArray(arr)) {
+    const values = arr.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+    return `${prefix}${encodedKey}[${arr.length}]: ${values}`;
+  }
+  if (isTabular(arr)) {
+    const firstObj = arr[0];
+    const fields = Object.keys(firstObj);
+    const fieldHeader = fields.map(encodeKey).join(delimiter);
+    const lines = [];
+    lines.push(`${prefix}${encodedKey}[${arr.length}]{${fieldHeader}}:`);
+    const rowPrefix = INDENT.repeat(depth + 1);
+    for (const item of arr) {
+      const obj = item;
+      const row = fields.map((f) => encodePrimitive(obj[f], delimiter)).join(delimiter);
+      lines.push(`${rowPrefix}${row}`);
     }
-    bestListing {
-      pricePerItem {
-        usd
-        native {
-          unit
-          symbol
+    return lines.join("\n");
+  }
+  return encodeExpandedList(encodedKey, arr, depth, delimiter);
+}
+function encodeExpandedList(encodedKey, arr, depth, delimiter) {
+  const prefix = INDENT.repeat(depth);
+  const itemPrefix = INDENT.repeat(depth + 1);
+  const lines = [];
+  lines.push(`${prefix}${encodedKey}[${arr.length}]:`);
+  for (const item of arr) {
+    if (isPrimitive(item)) {
+      lines.push(`${itemPrefix}- ${encodePrimitive(item, delimiter)}`);
+    } else if (Array.isArray(item)) {
+      if (isPrimitiveArray(item)) {
+        const values = item.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+        lines.push(`${itemPrefix}- [${item.length}]: ${values}`);
+      } else {
+        lines.push(`${itemPrefix}- [${item.length}]:`);
+        for (const inner of item) {
+          lines.push(encodeValue(inner, depth + 2, delimiter));
+        }
+      }
+    } else if (typeof item === "object" && item !== null) {
+      const obj = item;
+      const entries = Object.entries(obj);
+      if (entries.length === 0) {
+        lines.push(`${itemPrefix}-`);
+      } else {
+        const [firstKey, firstValue] = entries[0];
+        const ek = encodeKey(firstKey);
+        if (Array.isArray(firstValue)) {
+          const arrayLine = encodeArrayField(ek, firstValue, 0, delimiter);
+          lines.push(`${itemPrefix}- ${arrayLine.trimStart()}`);
+        } else if (isPrimitive(firstValue)) {
+          lines.push(
+            `${itemPrefix}- ${ek}: ${encodePrimitive(firstValue, delimiter)}`
+          );
+        } else {
+          lines.push(`${itemPrefix}- ${ek}:`);
+          lines.push(
+            encodeObject(
+              firstValue,
+              depth + 2,
+              delimiter
+            )
+          );
+        }
+        for (let i = 1; i < entries.length; i++) {
+          const [k, v] = entries[i];
+          const encodedK = encodeKey(k);
+          if (isPrimitive(v)) {
+            lines.push(
+              `${INDENT.repeat(depth + 2)}${encodedK}: ${encodePrimitive(v, delimiter)}`
+            );
+          } else if (Array.isArray(v)) {
+            lines.push(encodeArrayField(encodedK, v, depth + 2, delimiter));
+          } else if (typeof v === "object" && v !== null) {
+            lines.push(`${INDENT.repeat(depth + 2)}${encodedK}:`);
+            lines.push(
+              encodeObject(v, depth + 3, delimiter)
+            );
+          }
         }
       }
-    }
-    owner {
-      address
-      displayName
     }
   }
-}`;
-var SEARCH_TOKENS_QUERY = `
-query SearchCurrencies($query: String!, $limit: Int, $chain: ChainIdentifier) {
-  currenciesByQuery(query: $query, limit: $limit, chain: $chain, allowlistOnly: false) {
-    name
-    symbol
-    imageUrl
-    usdPrice
-    contractAddress
-    chain {
-      identifier
-      name
+  return lines.join("\n");
+}
+function encodeArray(arr, depth, delimiter) {
+  const prefix = INDENT.repeat(depth);
+  if (arr.length === 0) {
+    return `${prefix}[0]:`;
+  }
+  if (isPrimitiveArray(arr)) {
+    const values = arr.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+    return `${prefix}[${arr.length}]: ${values}`;
+  }
+  if (isTabular(arr)) {
+    const firstObj = arr[0];
+    const fields = Object.keys(firstObj);
+    const fieldHeader = fields.map(encodeKey).join(delimiter);
+    const lines2 = [];
+    lines2.push(`${prefix}[${arr.length}]{${fieldHeader}}:`);
+    const rowPrefix = INDENT.repeat(depth + 1);
+    for (const item of arr) {
+      const obj = item;
+      const row = fields.map((f) => encodePrimitive(obj[f], delimiter)).join(delimiter);
+      lines2.push(`${rowPrefix}${row}`);
     }
-    stats {
-      marketCapUsd
-      oneDay {
-        priceChange
-        volume
+    return lines2.join("\n");
+  }
+  const lines = [];
+  lines.push(`${prefix}[${arr.length}]:`);
+  const itemPrefix = INDENT.repeat(depth + 1);
+  for (const item of arr) {
+    if (isPrimitive(item)) {
+      lines.push(`${itemPrefix}- ${encodePrimitive(item, delimiter)}`);
+    } else if (Array.isArray(item)) {
+      if (isPrimitiveArray(item)) {
+        const values = item.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+        lines.push(`${itemPrefix}- [${item.length}]: ${values}`);
+      } else {
+        lines.push(`${itemPrefix}- [${item.length}]:`);
+      }
+    } else if (typeof item === "object" && item !== null) {
+      const obj = item;
+      const entries = Object.entries(obj);
+      if (entries.length > 0) {
+        const [firstKey, firstValue] = entries[0];
+        const ek = encodeKey(firstKey);
+        if (isPrimitive(firstValue)) {
+          lines.push(
+            `${itemPrefix}- ${ek}: ${encodePrimitive(firstValue, delimiter)}`
+          );
+        } else {
+          lines.push(`${itemPrefix}- ${ek}:`);
+          lines.push(encodeValue(firstValue, depth + 2, delimiter));
+        }
+        for (let i = 1; i < entries.length; i++) {
+          const [k, v] = entries[i];
+          const encodedK = encodeKey(k);
+          if (isPrimitive(v)) {
+            lines.push(
+              `${INDENT.repeat(depth + 2)}${encodedK}: ${encodePrimitive(v, delimiter)}`
+            );
+          } else if (Array.isArray(v)) {
+            lines.push(encodeArrayField(encodedK, v, depth + 2, delimiter));
+          } else if (typeof v === "object" && v !== null) {
+            lines.push(`${INDENT.repeat(depth + 2)}${encodedK}:`);
+            lines.push(
+              encodeObject(v, depth + 3, delimiter)
+            );
+          }
+        }
       }
     }
   }
-}`;
-var SEARCH_ACCOUNTS_QUERY = `
-query SearchAccounts($query: String!, $limit: Int) {
-  accountsByQuery(query: $query, limit: $limit) {
-    address
-    username
-    imageUrl
-    isVerified
+  return lines.join("\n");
+}
+function formatToon(data) {
+  if (isPrimitive(data)) {
+    return encodePrimitive(data, ",");
+  }
+  if (Array.isArray(data)) {
+    return encodeArray(data, 0, ",");
   }
-}`;
+  if (typeof data === "object" && data !== null) {
+    return encodeObject(data, 0, ",");
+  }
+  return String(data);
+}
+
+// src/output.ts
+function formatOutput(data, format) {
+  if (format === "table") {
+    return formatTable(data);
+  }
+  if (format === "toon") {
+    return formatToon(data);
+  }
+  return JSON.stringify(data, null, 2);
+}
+function formatTable(data) {
+  if (Array.isArray(data)) {
+    if (data.length === 0) return "(empty)";
+    const keys = Object.keys(data[0]);
+    const widths = keys.map(
+      (key) => Math.max(
+        key.length,
+        ...data.map((row) => {
+          const val = row[key];
+          return String(val ?? "").length;
+        })
+      )
+    );
+    const header = keys.map((key, i) => key.padEnd(widths[i])).join("  ");
+    const separator = widths.map((w) => "-".repeat(w)).join("  ");
+    const rows = data.map(
+      (row) => keys.map((key, i) => {
+        const val = row[key];
+        return String(val ?? "").padEnd(widths[i]);
+      }).join("  ")
+    );
+    return [header, separator, ...rows].join("\n");
+  }
+  if (data && typeof data === "object") {
+    const entries = Object.entries(data);
+    if (entries.length === 0) return "(empty)";
+    const maxKeyLength = Math.max(...entries.map(([k]) => k.length));
+    return entries.map(([key, value]) => {
+      const displayValue = typeof value === "object" && value !== null ? JSON.stringify(value) : String(value ?? "");
+      return `${key.padEnd(maxKeyLength)}  ${displayValue}`;
+    }).join("\n");
+  }
+  return String(data);
+}
 
 // src/sdk.ts
 var OpenSeaCLI = class {
@@ -435,37 +620,13 @@ var SearchAPI = class {
   constructor(client) {
     this.client = client;
   }
-  async collections(query, options) {
-    const result = await this.client.graphql(SEARCH_COLLECTIONS_QUERY, {
-      query,
-      limit: options?.limit,
-      chains: options?.chains
-    });
-    return result.collectionsByQuery;
-  }
-  async nfts(query, options) {
-    const result = await this.client.graphql(SEARCH_NFTS_QUERY, {
-      query,
-      collectionSlug: options?.collection,
-      limit: options?.limit,
-      chains: options?.chains
-    });
-    return result.itemsByQuery;
-  }
-  async tokens(query, options) {
-    const result = await this.client.graphql(SEARCH_TOKENS_QUERY, {
-      query,
-      limit: options?.limit,
-      chain: options?.chain
-    });
-    return result.currenciesByQuery;
-  }
-  async accounts(query, options) {
-    const result = await this.client.graphql(SEARCH_ACCOUNTS_QUERY, {
+  async query(query, options) {
+    return this.client.get("/api/v2/search", {
       query,
+      asset_types: options?.assetTypes?.join(","),
+      chains: options?.chains?.join(","),
       limit: options?.limit
     });
-    return result.accountsByQuery;
   }
 };
 var SwapsAPI = class {
@@ -488,6 +649,8 @@ var SwapsAPI = class {
 export {
   OpenSeaAPIError,
   OpenSeaCLI,
-  OpenSeaClient
+  OpenSeaClient,
+  formatOutput,
+  formatToon
 };
 //# sourceMappingURL=index.js.map