@antfly/sdk 0.0.7 → 0.0.8

package/dist/index.cjs

@@ -161,14 +161,87 @@ var AntflyClient = class {
       },
       /**
        * Lookup a specific key in a table
+       * @param tableName - Name of the table
+       * @param key - Key of the record to lookup
+       * @param options - Optional parameters
+       * @param options.fields - Comma-separated list of fields to include (e.g., "title,author,metadata.tags")
        */
-      lookup: async (tableName, key) => {
+      lookup: async (tableName, key, options) => {
         const { data, error } = await this.client.GET("/tables/{tableName}/lookup/{key}", {
-          params: { path: { tableName, key } }
+          params: {
+            path: { tableName, key },
+            query: options?.fields ? { fields: options.fields } : void 0
+          }
         });
         if (error) throw new Error(`Key lookup failed: ${error.error}`);
         return data;
       },
+      /**
+       * Scan keys in a table within a key range
+       * Returns documents as an async iterable, streaming results as NDJSON.
+       * @param tableName - Name of the table
+       * @param request - Scan request with optional key range, field projection, and filtering
+       * @returns AsyncGenerator yielding documents with their keys
+       */
+      scan: (tableName, request) => {
+        const config = this.config;
+        async function* scanGenerator() {
+          const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/x-ndjson"
+          };
+          if (config.auth) {
+            const auth = btoa(`${config.auth.username}:${config.auth.password}`);
+            headers["Authorization"] = `Basic ${auth}`;
+          }
+          Object.assign(headers, config.headers);
+          const response = await fetch(`${config.baseUrl}/tables/${tableName}/lookup`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(request || {})
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Scan failed: ${response.status} ${errorText}`);
+          }
+          if (!response.body) {
+            throw new Error("Response body is null");
+          }
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (line.trim()) {
+                yield JSON.parse(line);
+              }
+            }
+          }
+          if (buffer.trim()) {
+            yield JSON.parse(buffer);
+          }
+        }
+        return scanGenerator();
+      },
+      /**
+       * Scan keys in a table and collect all results into an array
+       * Convenience method that consumes the scan AsyncGenerator
+       * @param tableName - Name of the table
+       * @param request - Scan request with optional key range, field projection, and filtering
+       * @returns Promise with array of all matching documents
+       */
+      scanAll: async (tableName, request) => {
+        const results = [];
+        for await (const doc of this.tables.scan(tableName, request)) {
+          results.push(doc);
+        }
+        return results;
+      },
       /**
        * RAG (Retrieval-Augmented Generation) query on a specific table with streaming or citations
        * @param tableName - Name of the table to query