@depup/typesense 3.0.3-depup.0

package/src/Typesense/Configuration.ts

@@ -0,0 +1,328 @@
+import * as logger from "loglevel";
+import { Logger, LogLevelDesc } from "loglevel";
+import { MissingConfigurationError } from "./Errors";
+import type { Agent as HTTPAgent } from "http";
+import type { Agent as HTTPSAgent } from "https";
+import type { AxiosRequestConfig } from "axios";
+import { DocumentSchema, SearchResponse } from "./Documents";
+
+export interface NodeConfiguration {
+  host: string;
+  port: number;
+  protocol: string;
+  path?: string;
+  url?: string;
+}
+
+export interface NodeConfigurationWithHostname {
+  host: string;
+  port: number;
+  protocol: string;
+  path?: string;
+}
+
+export interface NodeConfigurationWithUrl {
+  url: string;
+}
+
+export interface ConfigurationOptions {
+  apiKey: string;
+  nodes:
+    | NodeConfiguration[]
+    | NodeConfigurationWithHostname[]
+    | NodeConfigurationWithUrl[];
+  randomizeNodes?: boolean;
+  /**
+   * @deprecated
+   * masterNode is now consolidated to nodes, starting with Typesense Server v0.12'
+   */
+  masterNode?:
+    | NodeConfiguration
+    | NodeConfigurationWithHostname
+    | NodeConfigurationWithUrl;
+  /**
+   * @deprecated
+   * readReplicaNodes is now consolidated to nodes, starting with Typesense Server v0.12'
+   */
+  readReplicaNodes?:
+    | NodeConfiguration[]
+    | NodeConfigurationWithHostname[]
+    | NodeConfigurationWithUrl[];
+  nearestNode?:
+    | NodeConfiguration
+    | NodeConfigurationWithHostname
+    | NodeConfigurationWithUrl;
+  connectionTimeoutSeconds?: number;
+  timeoutSeconds?: number;
+  healthcheckIntervalSeconds?: number;
+  numRetries?: number;
+  retryIntervalSeconds?: number;
+  sendApiKeyAsQueryParam?: boolean | undefined;
+  useServerSideSearchCache?: boolean;
+  cacheSearchResultsForSeconds?: number;
+  additionalHeaders?: Record<string, string>;
+
+  logLevel?: LogLevelDesc;
+  logger?: Logger;
+
+  /**
+   * Set a custom HTTP Agent
+   *
+   * This is helpful for eg, to enable keepAlive which helps prevents ECONNRESET socket hang up errors
+   *    Usage:
+   *      const { Agent: HTTPAgent } = require("http");
+   *      ...
+   *      httpAgent: new HTTPAgent({ keepAlive: true }),
+   * @type {HTTPAgent}
+   */
+  httpAgent?: HTTPAgent;
+
+  /**
+   * Set a custom HTTPS Agent
+   *
+   * This is helpful for eg, to enable keepAlive which helps prevents ECONNRESET socket hang up errors
+   *    Usage:
+   *      const { Agent: HTTPSAgent } = require("https");
+   *      ...
+   *      httpsAgent: new HTTPSAgent({ keepAlive: true }),
+   * @type {HTTPSAgent}
+   */
+  httpsAgent?: HTTPSAgent;
+
+  /**
+   * Set a custom paramsSerializer
+   *
+   * See axios documentation for more information on how to use this parameter: https://axios-http.com/docs/req_config
+   *  This is helpful for handling React Native issues like this: https://github.com/axios/axios/issues/6102#issuecomment-2085301397
+   * @type {any}
+   */
+  paramsSerializer?: any;
+
+  /**
+   * Set a custom axios adapter
+   *
+   * Useful for customizing the underlying HTTP client library used by Typesense.
+   *
+   * For example, you can use this to use a custom HTTP client library like `fetch`, in order for the library to work on the edge.
+   * Related GiHub issue: https://github.com/typesense/typesense-js/issues/161
+   *
+   * See axios documentation for more information on how to use this parameter: https://axios-http.com/docs/req_config
+   */
+  axiosAdapter?: AxiosRequestConfig["adapter"];
+}
+
+/**
+ * Configuration options for streaming responses
+ */
+export interface BaseStreamConfig {
+  /**
+   * Callback function that will be called for each chunk of data received
+   * during streaming
+   */
+  onChunk?: (data: { conversation_id: string; message: string }) => void;
+  /**
+   * Callback function that will be called if there is an error during streaming
+   */
+  onError?: (error: Error) => void;
+}
+
+/**
+ * Stream configuration for standard search responses
+ * For specialized responses like MultiSearch, extend BaseStreamConfig with the appropriate onComplete signature
+ */
+export interface StreamConfig<T extends DocumentSchema>
+  extends BaseStreamConfig {
+  /**
+   * Callback function that will be called when the streaming is complete
+   */
+  onComplete?: (data: SearchResponse<T>) => void;
+}
+
+export default class Configuration {
+  readonly nodes:
+    | NodeConfiguration[]
+    | NodeConfigurationWithHostname[]
+    | NodeConfigurationWithUrl[];
+  readonly nearestNode?:
+    | NodeConfiguration
+    | NodeConfigurationWithHostname
+    | NodeConfigurationWithUrl;
+  readonly connectionTimeoutSeconds: number;
+  readonly healthcheckIntervalSeconds: number;
+  readonly numRetries: number;
+  readonly retryIntervalSeconds: number;
+  readonly apiKey: string;
+  readonly sendApiKeyAsQueryParam?: boolean;
+  readonly cacheSearchResultsForSeconds: number;
+  readonly useServerSideSearchCache: boolean;
+  readonly logger: Logger;
+  readonly logLevel: LogLevelDesc;
+  readonly additionalHeaders?: Record<string, string>;
+  readonly httpAgent?: HTTPAgent;
+  readonly httpsAgent?: HTTPSAgent;
+  readonly paramsSerializer?: any;
+  readonly axiosAdapter?: AxiosRequestConfig["adapter"];
+
+  constructor(options: ConfigurationOptions) {
+    this.nodes = options.nodes || [];
+    this.nodes = this.nodes
+      .map((node) => this.setDefaultPathInNode(node))
+      .map((node) => this.setDefaultPortInNode(node))
+      .map((node) => ({ ...node })) as NodeConfiguration[]; // Make a deep copy
+
+    if (options.randomizeNodes == null) {
+      options.randomizeNodes = true;
+    }
+
+    if (options.randomizeNodes === true) {
+      this.shuffleArray(this.nodes);
+    }
+
+    this.nearestNode = options.nearestNode;
+    this.nearestNode = this.setDefaultPathInNode(this.nearestNode);
+    this.nearestNode = this.setDefaultPortInNode(this.nearestNode);
+
+    this.connectionTimeoutSeconds =
+      options.connectionTimeoutSeconds || options.timeoutSeconds || 5;
+    this.healthcheckIntervalSeconds = options.healthcheckIntervalSeconds || 60;
+    this.numRetries =
+      (options.numRetries !== undefined && options.numRetries >= 0
+        ? options.numRetries
+        : this.nodes.length + (this.nearestNode == null ? 0 : 1)) || 3;
+    this.retryIntervalSeconds = options.retryIntervalSeconds || 0.1;
+
+    this.apiKey = options.apiKey;
+    this.sendApiKeyAsQueryParam = options.sendApiKeyAsQueryParam; // We will set a default for this in Client and SearchClient
+
+    this.cacheSearchResultsForSeconds =
+      options.cacheSearchResultsForSeconds || 0; // Disable client-side cache by default
+    this.useServerSideSearchCache = options.useServerSideSearchCache || false;
+
+    this.axiosAdapter = options.axiosAdapter;
+    this.logger = options.logger || logger;
+    this.logLevel = options.logLevel || "warn";
+    this.logger.setLevel(this.logLevel);
+
+    this.additionalHeaders = options.additionalHeaders;
+
+    this.httpAgent = options.httpAgent;
+    this.httpsAgent = options.httpsAgent;
+
+    this.paramsSerializer = options.paramsSerializer;
+
+    this.showDeprecationWarnings(options);
+    this.validate();
+  }
+
+  validate(): boolean {
+    if (this.nodes == null || this.nodes.length === 0 || this.validateNodes()) {
+      throw new MissingConfigurationError(
+        "Ensure that nodes[].protocol, nodes[].host and nodes[].port are set",
+      );
+    }
+
+    if (
+      this.nearestNode != null &&
+      this.isNodeMissingAnyParameters(this.nearestNode)
+    ) {
+      throw new MissingConfigurationError(
+        "Ensure that nearestNodes.protocol, nearestNodes.host and nearestNodes.port are set",
+      );
+    }
+
+    if (this.apiKey == null) {
+      throw new MissingConfigurationError("Ensure that apiKey is set");
+    }
+
+    return true;
+  }
+
+  private validateNodes(): boolean {
+    return this.nodes.some((node) => {
+      return this.isNodeMissingAnyParameters(node);
+    });
+  }
+
+  private isNodeMissingAnyParameters(
+    node:
+      | NodeConfiguration
+      | NodeConfigurationWithHostname
+      | NodeConfigurationWithUrl,
+  ): boolean {
+    return (
+      !["protocol", "host", "port", "path"].every((key) => {
+        return node.hasOwnProperty(key);
+      }) && node["url"] == null
+    );
+  }
+
+  private setDefaultPathInNode(
+    node:
+      | NodeConfiguration
+      | NodeConfigurationWithHostname
+      | NodeConfigurationWithUrl
+      | undefined,
+  ):
+    | NodeConfiguration
+    | NodeConfigurationWithHostname
+    | NodeConfigurationWithUrl
+    | undefined {
+    if (node != null && !node.hasOwnProperty("path")) {
+      node["path"] = "";
+    }
+    return node;
+  }
+
+  private setDefaultPortInNode(
+    node:
+      | NodeConfiguration
+      | NodeConfigurationWithHostname
+      | NodeConfigurationWithUrl
+      | undefined,
+  ):
+    | NodeConfiguration
+    | NodeConfigurationWithHostname
+    | NodeConfigurationWithUrl
+    | undefined {
+    if (
+      node != null &&
+      !node.hasOwnProperty("port") &&
+      node.hasOwnProperty("protocol")
+    ) {
+      switch (node["protocol"]) {
+        case "https":
+          node["port"] = 443;
+          break;
+        case "http":
+          node["port"] = 80;
+          break;
+      }
+    }
+    return node;
+  }
+
+  private showDeprecationWarnings(options: ConfigurationOptions): void {
+    if (options.timeoutSeconds) {
+      this.logger.warn(
+        "Deprecation warning: timeoutSeconds is now renamed to connectionTimeoutSeconds",
+      );
+    }
+    if (options.masterNode) {
+      this.logger.warn(
+        "Deprecation warning: masterNode is now consolidated to nodes, starting with Typesense Server v0.12",
+      );
+    }
+    if (options.readReplicaNodes) {
+      this.logger.warn(
+        "Deprecation warning: readReplicaNodes is now consolidated to nodes, starting with Typesense Server v0.12",
+      );
+    }
+  }
+
+  private shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [array[i], array[j]] = [array[j], array[i]];
+    }
+  }
+}

package/src/Typesense/Conversation.ts

@@ -0,0 +1,45 @@
+import ApiCall from "./ApiCall";
+import Conversations from "./Conversations";
+
+export interface ConversationDeleteSchema {
+  id: number;
+}
+
+export interface ConversationUpdateSchema {
+  ttl: number;
+}
+
+export interface ConversationSchema {
+  id: number;
+  conversation: object[];
+  last_updated: number;
+  ttl: number;
+}
+
+export default class Conversation {
+  constructor(
+    private id: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async retrieve(): Promise<ConversationSchema[]> {
+    return this.apiCall.get<ConversationSchema[]>(this.endpointPath());
+  }
+
+  async update(
+    params: ConversationUpdateSchema,
+  ): Promise<ConversationUpdateSchema> {
+    return this.apiCall.put<ConversationUpdateSchema>(
+      this.endpointPath(),
+      params,
+    );
+  }
+
+  async delete(): Promise<ConversationDeleteSchema> {
+    return this.apiCall.delete<ConversationDeleteSchema>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return `${Conversations.RESOURCEPATH}/${encodeURIComponent(this.id)}`;
+  }
+}

package/src/Typesense/ConversationModel.ts

@@ -0,0 +1,55 @@
+import ApiCall from "./ApiCall";
+import ConversationModels from "./ConversationModels";
+
+export interface ConversationModelCreateSchema {
+  id?: string;
+  model_name: string;
+  api_key?: string;
+  system_prompt?: string;
+  max_bytes: number;
+  history_collection?: string;
+  account_id?: string;
+  url?: string;
+  ttl?: number;
+  vllm_url?: string;
+  openai_url?: string;
+  openai_path?: string;
+}
+
+export interface ConversationModelDeleteSchema {
+  id: string;
+}
+
+export interface ConversationModelSchema extends ConversationModelCreateSchema {
+  id: string;
+}
+
+export default class ConversationModel {
+  constructor(
+    private id: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async update(
+    params: ConversationModelCreateSchema,
+  ): Promise<ConversationModelCreateSchema> {
+    return this.apiCall.put<ConversationModelCreateSchema>(
+      this.endpointPath(),
+      params,
+    );
+  }
+
+  async retrieve(): Promise<ConversationModelSchema> {
+    return this.apiCall.get<ConversationModelSchema>(this.endpointPath());
+  }
+
+  async delete(): Promise<ConversationModelDeleteSchema> {
+    return this.apiCall.delete<ConversationModelDeleteSchema>(
+      this.endpointPath(),
+    );
+  }
+
+  private endpointPath(): string {
+    return `${ConversationModels.RESOURCEPATH}/${encodeURIComponent(this.id)}`;
+  }
+}

package/src/Typesense/ConversationModels.ts

@@ -0,0 +1,38 @@
+import ApiCall from "./ApiCall";
+import {
+  ConversationModelCreateSchema,
+  ConversationModelSchema,
+} from "./ConversationModel";
+
+const RESOURCEPATH = "/conversations/models";
+
+export default class ConversationModels {
+  constructor(private readonly apiCall: ApiCall) {
+    this.apiCall = apiCall;
+  }
+
+  async create(
+    params: ConversationModelCreateSchema,
+  ): Promise<ConversationModelCreateSchema> {
+    return this.apiCall.post<ConversationModelCreateSchema>(
+      this.endpointPath(),
+      params,
+    );
+  }
+
+  async retrieve(): Promise<ConversationModelSchema[]> {
+    return this.apiCall.get<ConversationModelSchema[]>(
+      this.endpointPath(),
+    );
+  }
+
+  private endpointPath(operation?: string): string {
+    return `${ConversationModels.RESOURCEPATH}${
+      operation === undefined ? "" : "/" + encodeURIComponent(operation)
+    }`;
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/Conversations.ts

@@ -0,0 +1,47 @@
+import ApiCall from "./ApiCall";
+import ConversationModels from "./ConversationModels";
+import ConversationModel from "./ConversationModel";
+import { ConversationSchema } from "./Conversation";
+
+const RESOURCEPATH = "/conversations";
+
+export interface ConversationsRetrieveSchema {
+  conversations: ConversationSchema[];
+}
+
+export default class Conversations {
+  private readonly _conversationsModels: ConversationModels;
+  private readonly individualConversationModels: Record<
+    string,
+    ConversationModel
+  > = {};
+
+  constructor(private readonly apiCall: ApiCall) {
+    this.apiCall = apiCall;
+    this._conversationsModels = new ConversationModels(this.apiCall);
+  }
+
+  async retrieve(): Promise<ConversationsRetrieveSchema> {
+    return this.apiCall.get<ConversationsRetrieveSchema>(RESOURCEPATH);
+  }
+
+  models(): ConversationModels;
+  models(id: string): ConversationModel;
+  models(id?: string): ConversationModels | ConversationModel {
+    if (id === undefined) {
+      return this._conversationsModels;
+    } else {
+      if (this.individualConversationModels[id] === undefined) {
+        this.individualConversationModels[id] = new ConversationModel(
+          id,
+          this.apiCall,
+        );
+      }
+      return this.individualConversationModels[id];
+    }
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/CurationSet.ts

@@ -0,0 +1,56 @@
+import ApiCall from "./ApiCall";
+import CurationSets from "./CurationSets";
+import type {
+  CurationSetDeleteResponseSchema,
+  CurationSetSchema,
+  CurationSetUpsertSchema,
+} from "./CurationSets";
+import CurationSetItems from "./CurationSetItems";
+import CurationSetItem from "./CurationSetItem";
+
+export default class CurationSet {
+  private readonly _items: CurationSetItems;
+  private individualItems: Record<string, CurationSetItem> = {};
+
+  constructor(
+    private name: string,
+    private apiCall: ApiCall,
+  ) {
+    this._items = new CurationSetItems(this.name, apiCall);
+  }
+
+  async upsert(params: CurationSetUpsertSchema): Promise<CurationSetSchema> {
+    return this.apiCall.put<CurationSetSchema>(this.endpointPath(), params);
+  }
+
+  async retrieve(): Promise<CurationSetSchema> {
+    return this.apiCall.get<CurationSetSchema>(this.endpointPath());
+  }
+
+  async delete(): Promise<CurationSetDeleteResponseSchema> {
+    return this.apiCall.delete<CurationSetDeleteResponseSchema>(
+      this.endpointPath(),
+    );
+  }
+
+  items(): CurationSetItems;
+  items(itemId: string): CurationSetItem;
+  items(itemId?: string): CurationSetItems | CurationSetItem {
+    if (itemId === undefined) {
+      return this._items;
+    } else {
+      if (this.individualItems[itemId] === undefined) {
+        this.individualItems[itemId] = new CurationSetItem(
+          this.name,
+          itemId,
+          this.apiCall,
+        );
+      }
+      return this.individualItems[itemId];
+    }
+  }
+
+  private endpointPath(): string {
+    return `${CurationSets.RESOURCEPATH}/${encodeURIComponent(this.name)}`;
+  }
+}

package/src/Typesense/CurationSetItem.ts

@@ -0,0 +1,35 @@
+import ApiCall from "./ApiCall";
+import CurationSets from "./CurationSets";
+import type { CurationObjectSchema } from "./CurationSets";
+
+export interface CurationItemDeleteResponseSchema {
+  id: string;
+}
+
+export default class CurationSetItem {
+  constructor(
+    private name: string,
+    private itemId: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async retrieve(): Promise<CurationObjectSchema> {
+    return this.apiCall.get<CurationObjectSchema>(this.endpointPath());
+  }
+
+  async upsert(params: CurationObjectSchema): Promise<CurationObjectSchema> {
+    return this.apiCall.put<CurationObjectSchema>(this.endpointPath(), params);
+  }
+
+  async delete(): Promise<CurationItemDeleteResponseSchema> {
+    return this.apiCall.delete<CurationItemDeleteResponseSchema>(
+      this.endpointPath(),
+    );
+  }
+
+  private endpointPath(): string {
+    return `${CurationSets.RESOURCEPATH}/${encodeURIComponent(
+      this.name,
+    )}/items/${encodeURIComponent(this.itemId)}`;
+  }
+}

package/src/Typesense/CurationSetItems.ts

@@ -0,0 +1,18 @@
+import ApiCall from "./ApiCall";
+import CurationSets, { CurationObjectSchema } from "./CurationSets";
+
+export default class CurationSetItems {
+  constructor(private name: string, private apiCall: ApiCall) {}
+
+  async retrieve(): Promise<CurationObjectSchema[]> {
+    return this.apiCall.get<CurationObjectSchema[]>(this.endpointPath());
+  }
+
+  private endpointPath(operation?: string): string {
+    return `${CurationSets.RESOURCEPATH}/${encodeURIComponent(this.name)}/items${
+      operation === undefined ? "" : "/" + encodeURIComponent(operation)
+    }`;
+  }
+}
+
+

package/src/Typesense/CurationSets.ts

@@ -0,0 +1,60 @@
+import ApiCall from "./ApiCall";
+
+export type CurationRuleSchema =
+  | { tags: string[]; query?: never; match?: never; filter_by?: never }
+  | {
+      query: string;
+      match: "exact" | "contains";
+      tags?: never;
+      filter_by?: never;
+    }
+  | { filter_by: string; tags?: never; query?: never; match?: never };
+
+export interface CurationObjectSchema {
+  id: string;
+  rule: CurationRuleSchema;
+  includes?: {
+    id: string;
+    position: number;
+  }[];
+  excludes?: {
+    id: string;
+  }[];
+  filter_by?: string;
+  sort_by?: string;
+  replace_query?: string;
+  remove_matched_tokens?: boolean;
+  filter_curated_hits?: boolean;
+  stop_processing?: boolean;
+  effective_from_ts?: number;
+  effective_to_ts?: number;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CurationSetUpsertSchema {
+  items: CurationObjectSchema[];
+}
+
+export interface CurationSetSchema extends CurationSetUpsertSchema {
+  name?: string;
+}
+
+export interface CurationSetsListEntrySchema {
+  name: string;
+  items: CurationObjectSchema[];
+}
+
+export interface CurationSetDeleteResponseSchema {
+  name: string;
+}
+
+export default class CurationSets {
+  constructor(private apiCall: ApiCall) {}
+  static readonly RESOURCEPATH = "/curation_sets";
+
+  async retrieve(): Promise<CurationSetsListEntrySchema[]> {
+    return this.apiCall.get<CurationSetsListEntrySchema[]>(
+      CurationSets.RESOURCEPATH,
+    );
+  }
+}

package/src/Typesense/Debug.ts

@@ -0,0 +1,16 @@
+import ApiCall from "./ApiCall";
+
+const RESOURCEPATH = "/debug";
+
+export interface DebugResponseSchema {
+  state: number;
+  version: string;
+}
+
+export default class Debug {
+  constructor(private apiCall: ApiCall) {}
+
+  async retrieve(): Promise<DebugResponseSchema> {
+    return this.apiCall.get<DebugResponseSchema>(RESOURCEPATH);
+  }
+}