nosible 0.1.5

package/src/client.test.ts

@@ -0,0 +1,685 @@
+import {describe, it, expect, beforeEach} from "bun:test";
+import {NosibleClient, type FastSearchesParamsType} from "./client";
+import {Result} from "./search/result";
+import {Search} from "./search/search";
+import {SearchSet} from "./search/searchSet";
+import {type ContinentEnum} from "./api/schemas";
+
+describe("NosibleClient", () => {
+  let client: NosibleClient;
+
+  beforeEach(() => {
+    // Create genuine client - will use environment variable NOSIBLE_API_KEY
+    client = new NosibleClient();
+  });
+
+  describe("fastSearch", () => {
+    it("should return search results", async () => {
+      const searchResultSet = await client.fastSearch({
+        question: "artificial intelligence machine learning",
+        nResults: 10,
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      // Get first result with proper type guard
+      const firstResult = searchResultSet.results[0];
+      if (!firstResult) {
+        throw new Error("Expected first result to be defined");
+      }
+
+      expect(firstResult).toBeInstanceOf(Result);
+      expect(firstResult.url_hash).toBeDefined();
+      expect(firstResult.url).toBeDefined();
+      expect(firstResult.title).toBeDefined();
+      expect(firstResult.content).toBeDefined();
+
+      console.log(
+        `Found ${searchResultSet.results.length} results via fastSearch`
+      );
+      console.log(`First result: ${firstResult.title}`);
+    }, 10000);
+
+    it("should handle different search parameters", async () => {
+      const searchResultSet = await client.fastSearch({
+        question: "blockchain cryptocurrency",
+        nResults: 10,
+        minSimilarity: 0.7,
+        algorithm: "hybrid-2",
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      console.log(
+        `Search with filters returned ${searchResultSet.results.length} results`
+      );
+    }, 10000);
+
+    it("should handle language filters", async () => {
+      const searchResultSet = await client.fastSearch({
+        question: "intelligence artificielle",
+        nResults: 10,
+        language: "fr",
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+
+      console.log(
+        `French search returned ${searchResultSet.results.length} results`
+      );
+    }, 10000);
+
+    it("should work with a Search instance", async () => {
+      const search = new Search({
+        question: "quantum computing technology",
+        nResults: 15,
+        algorithm: "hybrid-2",
+        minSimilarity: 0.7,
+      });
+
+      const searchResultSet = await client.fastSearch({search});
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      const firstResult = searchResultSet.results[0];
+      if (!firstResult) {
+        throw new Error("Expected first result to be defined");
+      }
+
+      expect(firstResult).toBeInstanceOf(Result);
+      expect(firstResult.url_hash).toBeDefined();
+      expect(firstResult.url).toBeDefined();
+      expect(firstResult.title).toBeDefined();
+      expect(firstResult.content).toBeDefined();
+
+      console.log(
+        `Found ${searchResultSet.results.length} results via fastSearch with Search instance`
+      );
+      console.log(`First result: ${firstResult.title}`);
+    }, 10000);
+
+    it("should work with a Search instance and complex filters", async () => {
+      const search = new Search({
+        question: "renewable energy solutions",
+        nResults: 20,
+        algorithm: "hybrid-3",
+        minSimilarity: 0.6,
+        mustInclude: ["solar", "wind"],
+        mustExclude: ["nuclear"],
+        continent: "Europe",
+        language: "en",
+      });
+
+      const searchResultSet = await client.fastSearch({search});
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+
+      console.log(
+        `Search instance with complex filters returned ${searchResultSet.results.length} results`
+      );
+    }, 10000);
+  });
+
+  describe("fastSearches", () => {
+    it("should handle questions array with shared parameters and return multiple result sets", async () => {
+      const params = {
+        questions: [
+          "artificial intelligence",
+          "machine learning",
+          "neural networks",
+        ],
+        nResults: 10,
+      };
+
+      const results = await client.fastSearches(params);
+
+      expect(results).toBeDefined();
+      expect(results).toBeInstanceOf(Array);
+      expect(results.length).toBe(3);
+
+      // Check each result set
+      results.forEach((resultSet, index) => {
+        expect(resultSet).toBeDefined();
+        expect(resultSet.results).toBeDefined();
+        expect(resultSet.results.length).toBeGreaterThan(0);
+
+        const firstResult = resultSet.results[0];
+        if (!firstResult) {
+          throw new Error(
+            `Expected first result to be defined for question ${index}`
+          );
+        }
+
+        expect(firstResult).toBeInstanceOf(Result);
+        expect(firstResult.url_hash).toBeDefined();
+        expect(firstResult.url).toBeDefined();
+        expect(firstResult.title).toBeDefined();
+        expect(firstResult.content).toBeDefined();
+      });
+
+      console.log(
+        `fastSearches with questions returned ${results.length} result sets`
+      );
+      results.forEach((resultSet, index) => {
+        console.log(
+          `Question ${index + 1}: ${resultSet.results.length} results`
+        );
+      });
+    }, 10000);
+
+    it("should handle SearchSet input and return multiple result sets", async () => {
+      const searches = [
+        new Search({question: "blockchain technology", nResults: 10}),
+        new Search({question: "cryptocurrency", nResults: 10}),
+        new Search({question: "decentralized finance", nResults: 10}),
+      ];
+
+      const searchSet = new SearchSet(searches);
+      const results = await client.fastSearches(searchSet);
+
+      expect(results).toBeDefined();
+      expect(results).toBeInstanceOf(Array);
+      expect(results.length).toBe(3);
+
+      // Check each result set
+      results.forEach((resultSet, index) => {
+        expect(resultSet).toBeDefined();
+        expect(resultSet.results).toBeDefined();
+        expect(resultSet.results.length).toBeGreaterThan(0);
+
+        const firstResult = resultSet.results[0];
+        if (!firstResult) {
+          throw new Error(
+            `Expected first result to be defined for search ${index}`
+          );
+        }
+
+        expect(firstResult).toBeInstanceOf(Result);
+        expect(firstResult.url_hash).toBeDefined();
+        expect(firstResult.url).toBeDefined();
+        expect(firstResult.title).toBeDefined();
+      });
+
+      console.log(
+        `fastSearches with SearchSet returned ${results.length} result sets`
+      );
+      results.forEach((resultSet, index) => {
+        console.log(`Search ${index + 1}: ${resultSet.results.length} results`);
+      });
+    }, 10000);
+
+    it("should handle questions array with complex shared parameters", async () => {
+      const params = {
+        questions: ["renewable energy", "electric vehicles"],
+        nResults: 10,
+        algorithm: "hybrid-2",
+        minSimilarity: 0.7,
+        continent: "Europe",
+      };
+
+      const results = await client.fastSearches(
+        params as FastSearchesParamsType
+      );
+
+      expect(results).toBeDefined();
+      expect(results.length).toBe(2);
+
+      results.forEach((resultSet, index) => {
+        expect(resultSet).toBeDefined();
+        expect(resultSet.results).toBeDefined();
+        expect(resultSet.results.length).toBeGreaterThan(0);
+
+        const firstResult = resultSet.results[0];
+        if (!firstResult) {
+          throw new Error(
+            `Expected first result to be defined for question ${index}`
+          );
+        }
+
+        expect(firstResult).toBeInstanceOf(Result);
+        expect(firstResult.url_hash).toBeDefined();
+        expect(firstResult.url).toBeDefined();
+        expect(firstResult.title).toBeDefined();
+      });
+
+      console.log(
+        `fastSearches with complex shared parameters returned ${results.length} result sets`
+      );
+      results.forEach((resultSet, index) => {
+        console.log(
+          `Question ${index + 1}: ${resultSet.results.length} results`
+        );
+      });
+    }, 10000);
+
+    it("should handle single question in array", async () => {
+      const params = {
+        questions: ["quantum computing"],
+        nResults: 10,
+      };
+
+      const results = await client.fastSearches(params);
+
+      expect(results).toBeDefined();
+      expect(results.length).toBe(1);
+
+      const firstResultSet = results[0];
+      if (!firstResultSet) {
+        throw new Error("Expected first result set to be defined");
+      }
+
+      expect(firstResultSet.results.length).toBeGreaterThan(0);
+
+      const firstResult = firstResultSet.results[0];
+      if (!firstResult) {
+        throw new Error("Expected first result to be defined");
+      }
+
+      expect(firstResult).toBeInstanceOf(Result);
+      expect(firstResult.url_hash).toBeDefined();
+      expect(firstResult.title).toBeDefined();
+
+      console.log(
+        `fastSearches with single question returned ${firstResultSet.results.length} results`
+      );
+    }, 10000);
+
+    it("should handle empty questions array", async () => {
+      const params = {
+        questions: [] as string[],
+        nResults: 10,
+      };
+
+      const results = await client.fastSearches(params);
+
+      expect(results).toBeDefined();
+      expect(results).toBeInstanceOf(Array);
+      expect(results.length).toBe(0);
+
+      console.log(
+        "fastSearches with empty questions array returned empty array"
+      );
+    }, 10000);
+
+    it("should execute searches in parallel and return results in correct order", async () => {
+      const params = {
+        questions: [
+          "first search query",
+          "second search query",
+          "third search query",
+        ],
+        nResults: 10,
+      };
+
+      const startTime = Date.now();
+      const results = await client.fastSearches(params);
+      const endTime = Date.now();
+
+      expect(results).toBeDefined();
+      expect(results.length).toBe(3);
+
+      // Verify results are in the same order as questions
+      results.forEach((resultSet, index) => {
+        expect(resultSet).toBeDefined();
+        expect(resultSet.results).toBeDefined();
+      });
+
+      console.log(
+        `Parallel fastSearches completed in ${endTime - startTime}ms`
+      );
+      console.log(`Returned ${results.length} result sets in correct order`);
+    }, 10000);
+
+    it("should work with SearchSet containing complex Search instances", async () => {
+      const searches = [
+        new Search({
+          question: "climate change solutions",
+          nResults: 10,
+          algorithm: "hybrid-2" as const,
+          minSimilarity: 0.65,
+          mustInclude: ["carbon", "renewable"],
+          mustExclude: ["politics"],
+          language: "en",
+        }),
+        new Search({
+          question: "sustainable technology",
+          nResults: 10,
+          algorithm: "hybrid-3" as const,
+          minSimilarity: 0.6,
+          continent: "Europe" as ContinentEnum,
+          sector: "Energy",
+        }),
+      ];
+
+      const searchSet = new SearchSet(searches);
+      const results = await client.fastSearches(searchSet);
+
+      expect(results).toBeDefined();
+      expect(results.length).toBe(2);
+
+      results.forEach((resultSet, index) => {
+        expect(resultSet).toBeDefined();
+        expect(resultSet.results).toBeDefined();
+        expect(resultSet.results.length).toBeGreaterThan(0);
+
+        const firstResult = resultSet.results[0];
+        if (!firstResult) {
+          throw new Error(
+            `Expected first result to be defined for complex search ${index}`
+          );
+        }
+
+        expect(firstResult).toBeInstanceOf(Result);
+        expect(firstResult.url_hash).toBeDefined();
+        expect(firstResult.title).toBeDefined();
+      });
+
+      console.log(
+        `fastSearches with complex SearchSet returned ${results.length} result sets`
+      );
+      results.forEach((resultSet, index) => {
+        console.log(
+          `Complex search ${index + 1}: ${resultSet.results.length} results`
+        );
+      });
+    }, 10000);
+  });
+
+  describe("aiSearch", () => {
+    it("should return AI-powered search results", async () => {
+      const searchResultSet = await client.aiSearch({
+        prompt: "What are the latest developments in quantum computing?",
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      // Get first result with proper type guard
+      const firstResult = searchResultSet.results[0];
+      if (!firstResult) {
+        throw new Error("Expected first result to be defined");
+      }
+
+      expect(firstResult).toBeInstanceOf(Result);
+      expect(firstResult.url_hash).toBeDefined();
+      expect(firstResult.url).toBeDefined();
+      expect(firstResult.title).toBeDefined();
+
+      console.log(
+        `Found ${searchResultSet.results.length} results via aiSearch`
+      );
+      console.log(`First result: ${firstResult.title}`);
+    }, 30000);
+
+    it("should handle complex AI search instructions", async () => {
+      const searchResultSet = await client.aiSearch({
+        prompt: "Compare renewable energy sources",
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+
+      console.log(
+        `Complex AI search returned ${searchResultSet.results.length} results`
+      );
+    }, 30000);
+  });
+
+  describe("bulkSearch", () => {
+    it("should return bulk search results", async () => {
+      // Note: This test may take longer due to bulk processing
+      const searchResultSet = await client.bulkSearch({
+        question: "climate change renewable energy",
+        nResults: 1000,
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      console.log(
+        `Bulk search returned ${searchResultSet.results.length} results`
+      );
+    }, 20000);
+
+    it("should handle bulk search with filters", async () => {
+      const searchResultSet = await client.bulkSearch({
+        question: "technology startups funding",
+        nResults: 5000,
+        continent: "North America" as ContinentEnum,
+        minSimilarity: 0.6,
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+
+      console.log(
+        `Filtered bulk search returned ${searchResultSet.results.length} results`
+      );
+    }, 20000); // Longer timeout for bulk search
+
+    it("should work with a Search instance", async () => {
+      const search = new Search({
+        question: "artificial intelligence research papers",
+        nResults: 2000,
+        algorithm: "hybrid-2",
+        minSimilarity: 0.65,
+        language: "en",
+      });
+
+      const searchResultSet = await client.bulkSearch({search});
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      const firstResult = searchResultSet.results[0];
+      if (!firstResult) {
+        throw new Error("Expected first result to be defined");
+      }
+
+      expect(firstResult).toBeInstanceOf(Result);
+      expect(firstResult.url_hash).toBeDefined();
+      expect(firstResult.url).toBeDefined();
+      expect(firstResult.title).toBeDefined();
+      expect(firstResult.content).toBeDefined();
+
+      console.log(
+        `Found ${searchResultSet.results.length} results via bulkSearch with Search instance`
+      );
+      console.log(`First result: ${firstResult.title}`);
+    }, 25000);
+
+    it("should work with a Search instance and comprehensive filters", async () => {
+      const search = new Search({
+        question: "electric vehicle market analysis",
+        nResults: 3000,
+        algorithm: "hybrid-3",
+        minSimilarity: 0.6,
+        mustInclude: ["Tesla", "market share", "sales"],
+        mustExclude: ["toy review"],
+        continent: "North America",
+        country: "United States",
+        sector: "Consumer Discretionary",
+      });
+
+      const searchResultSet = await client.bulkSearch({search});
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+
+      console.log(
+        `Bulk search instance with comprehensive filters returned ${searchResultSet.results.length} results`
+      );
+    }, 30000);
+  });
+
+  describe("scrapeUrl", () => {
+    it("should scrape content from a URL", async () => {
+      // First get a URL from search results
+      const searchResultSet = await client.fastSearch({
+        question: "technology news",
+        nResults: 10,
+      });
+
+      if (searchResultSet.results.length > 0) {
+        const firstResult = searchResultSet.results[0];
+        if (!firstResult) {
+          throw new Error("Expected first result to be defined");
+        }
+
+        const urlToScrape = firstResult.url;
+
+        const webPage = await client.scrapeUrl(urlToScrape);
+
+        expect(webPage).toBeDefined();
+
+        expect(webPage.data.request.url).toBe(urlToScrape);
+        expect(webPage.data.page.title).toBeDefined();
+        expect(webPage.data.full_text).toBeDefined();
+        expect(webPage.data.snippets).toBeDefined();
+
+        console.log(`Successfully scraped: ${webPage.data.page.title}`);
+        console.log(
+          `Content length: ${webPage.data.full_text.length} characters`
+        );
+      } else {
+        console.log("No URLs found to scrape");
+      }
+    }, 10000);
+
+    it("should handle invalid URLs gracefully", async () => {
+      await expect(
+        client.scrapeUrl("https://invalid-url-12345.com")
+      ).rejects.toThrow();
+    }, 10000);
+  });
+
+  describe("topicTrend", () => {
+    it("should return trend analysis for a topic", async () => {
+      const topicTrend = await client.topicTrend("artificial intelligence");
+
+      expect(topicTrend).toBeDefined();
+      expect(topicTrend.data).toBeDefined();
+      expect(typeof topicTrend.data.response).toBe("object");
+
+      const responseData = topicTrend.data.response;
+      const dataPoints = Object.keys(responseData);
+
+      console.log(
+        `Topic trend for "${topicTrend.data.query.query}" returned ${dataPoints.length} data points`
+      );
+
+      if (dataPoints.length > 0) {
+        const firstDate = dataPoints[0];
+        if (!firstDate) {
+          throw new Error("Expected first date to be defined");
+        }
+
+        const firstPopularity = responseData[firstDate];
+        expect(firstDate).toBeDefined();
+        expect(firstPopularity).toBeDefined();
+        console.log(
+          `First data point: ${firstDate} - popularity: ${firstPopularity}`
+        );
+      }
+    }, 10000);
+
+    it("should handle trend analysis with SQL filter", async () => {
+      const topicTrend = await client.topicTrend("machine learning");
+
+      expect(topicTrend).toBeDefined();
+      expect(topicTrend.data).toBeDefined();
+
+      const responseData = topicTrend.data.response;
+      const dataPoints = Object.keys(responseData);
+
+      console.log(
+        `Filtered trend analysis returned ${dataPoints.length} data points`
+      );
+    }, 10000);
+  });
+
+  describe("defaultSearch", () => {
+    it("should apply default search parameters when provided", async () => {
+      const clientWithDefaults = new NosibleClient({
+        apiKey: process.env.NOSIBLE_API_KEY || "test-key",
+        searchDefaults: {
+          nResults: 15,
+          algorithm: "hybrid-2",
+          continent: "North America",
+        },
+      });
+
+      // This should use the default parameters
+      const searchResultSet = await clientWithDefaults.fastSearch({
+        question: "artificial intelligence",
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      console.log(
+        `Default search returned ${searchResultSet.results.length} results`
+      );
+    }, 10000);
+
+    it("should override default parameters with provided parameters", async () => {
+      const clientWithDefaults = new NosibleClient({
+        apiKey: process.env.NOSIBLE_API_KEY || "test-key",
+        searchDefaults: {
+          nResults: 15,
+          algorithm: "hybrid-2",
+          continent: "North America",
+        },
+      });
+
+      // This should override the default nResults
+      const searchResultSet = await clientWithDefaults.fastSearch({
+        question: "machine learning",
+        nResults: 20, // This should override the default of 15
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet.results).toBeDefined();
+      expect(searchResultSet.results.length).toBeGreaterThan(0);
+
+      console.log(
+        `Override search returned ${searchResultSet.results.length} results`
+      );
+    }, 10000);
+
+    it("should work with fastSearches using default parameters", async () => {
+      const clientWithDefaults = new NosibleClient({
+        apiKey: process.env.NOSIBLE_API_KEY || "test-key",
+        searchDefaults: {
+          nResults: 10,
+          algorithm: "hybrid-2",
+        },
+      });
+
+      const searchResultSet = await clientWithDefaults.fastSearches({
+        questions: ["AI", "machine learning"],
+      });
+
+      expect(searchResultSet).toBeDefined();
+      expect(searchResultSet).toHaveLength(2);
+      expect(searchResultSet[0]?.results).toBeDefined();
+      expect(searchResultSet[1]?.results).toBeDefined();
+
+      console.log(
+        `Default fastSearches returned ${searchResultSet.length} result sets`
+      );
+    }, 10000);
+  });
+});