@depup/typesense 3.0.3-depup.0

package/src/Typesense/Keys.ts

@@ -0,0 +1,59 @@
+import { createHmac } from "crypto";
+import ApiCall from "./ApiCall";
+import { KeyCreateSchema, KeySchema } from "./Key";
+import type { DocumentSchema, SearchParams } from "./Documents";
+import { normalizeArrayableParams } from "./Utils";
+
+const RESOURCEPATH = "/keys";
+
+export interface KeysRetrieveSchema {
+  keys: KeySchema[];
+}
+
+export interface GenerateScopedSearchKeyParams<
+  T extends DocumentSchema,
+  Infix extends string,
+> extends Partial<SearchParams<T, Infix>> {
+  expires_at?: number;
+  cache_ttl?: number;
+  limit_multi_searches?: number;
+}
+
+export default class Keys {
+  constructor(private apiCall: ApiCall) {
+    this.apiCall = apiCall;
+  }
+
+  async create(params: KeyCreateSchema): Promise<KeySchema> {
+    return this.apiCall.post<KeySchema>(Keys.RESOURCEPATH, params);
+  }
+
+  async retrieve(): Promise<KeysRetrieveSchema> {
+    return this.apiCall.get<KeysRetrieveSchema>(RESOURCEPATH);
+  }
+
+  generateScopedSearchKey<T extends DocumentSchema, const Infix extends string>(
+    searchKey: string,
+    parameters: GenerateScopedSearchKeyParams<T, Infix>,
+  ): string {
+    // Note: only a key generated with the `documents:search` action will be
+    // accepted by the server, when used with the search endpoint.
+    const normalizedParams = normalizeArrayableParams<
+      T,
+      SearchParams<T, Infix>,
+      Infix
+    >(parameters);
+    const paramsJSON = JSON.stringify(normalizedParams);
+    const digest = Buffer.from(
+      createHmac("sha256", searchKey).update(paramsJSON).digest("base64"),
+    );
+    const keyPrefix = searchKey.substr(0, 4);
+    const rawScopedKey = `${digest}${keyPrefix}${paramsJSON}`;
+
+    return Buffer.from(rawScopedKey).toString("base64");
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/Metrics.ts

@@ -0,0 +1,31 @@
+import ApiCall from "./ApiCall";
+
+const RESOURCEPATH = "/metrics.json";
+
+export interface MetricsResponse {
+  [key: `system_cpu${number}_active_percentage`]: string;
+  system_cpu_active_percentage: string;
+  system_disk_total_bytes: string;
+  system_disk_used_bytes: string;
+  system_memory_total_bytes: string;
+  system_memory_total_swap_bytes?: string;
+  system_memory_used_bytes: string;
+  system_memory_used_swap_bytes?: string;
+  system_network_received_bytes: string;
+  system_network_sent_bytes: string;
+  typesense_memory_active_bytes: string;
+  typesense_memory_allocated_bytes: string;
+  typesense_memory_fragmentation_ratio: string;
+  typesense_memory_mapped_bytes: string;
+  typesense_memory_metadata_bytes: string;
+  typesense_memory_resident_bytes: string;
+  typesense_memory_retained_bytes: string;
+}
+
+export default class Metrics {
+  constructor(private apiCall: ApiCall) {}
+
+  async retrieve(): Promise<MetricsResponse> {
+    return this.apiCall.get(RESOURCEPATH);
+  }
+}

package/src/Typesense/MultiSearch.ts

@@ -0,0 +1,144 @@
+import type ApiCall from "./ApiCall";
+import type Configuration from "./Configuration";
+import RequestWithCache from "./RequestWithCache";
+import type {
+  DocumentSchema,
+  ExtractBaseTypes,
+  SearchOptions,
+  SearchParams,
+  SearchResponse,
+} from "./Documents";
+import { normalizeArrayableParams } from "./Utils";
+import type {
+  MultiSearchRequestsSchema,
+  MultiSearchRequestsWithUnionSchema,
+  MultiSearchResponse,
+  MultiSearchUnionParameters,
+  MultiSearchResultsParameters,
+  UnionSearchResponse,
+  MultiSearchRequestsWithoutUnionSchema,
+} from "./Types";
+import { Logger } from "loglevel";
+
+const RESOURCEPATH = "/multi_search";
+
+export default class MultiSearch {
+  private requestWithCache: RequestWithCache;
+  readonly logger: Logger;
+
+  constructor(
+    private apiCall: ApiCall,
+    private configuration: Configuration,
+    private useTextContentType: boolean = false,
+  ) {
+    this.requestWithCache = new RequestWithCache();
+    this.logger = this.apiCall.logger;
+  }
+
+  clearCache() {
+    this.requestWithCache.clearCache();
+  }
+
+  async perform<
+    const T extends DocumentSchema[] = [],
+    const Infix extends string = string,
+  >(
+    searchRequests: MultiSearchRequestsWithUnionSchema<T[number], Infix>,
+    commonParams?: MultiSearchUnionParameters<T[number], Infix>,
+    options?: SearchOptions,
+  ): Promise<UnionSearchResponse<T[number]>>;
+
+  async perform<
+    const T extends DocumentSchema[] = [],
+    const Infix extends string = string,
+  >(
+    searchRequests: MultiSearchRequestsWithoutUnionSchema<T[number], Infix>,
+    commonParams?: MultiSearchResultsParameters<T, Infix>,
+    options?: SearchOptions,
+  ): Promise<{
+    results: { [Index in keyof T]: SearchResponse<T[Index]> } & {
+      length: T["length"];
+    };
+  }>;
+
+  async perform<
+    const T extends DocumentSchema[] = [],
+    const Infix extends string = string,
+  >(
+    searchRequests: MultiSearchRequestsSchema<T[number], Infix>,
+    commonParams?:
+      | MultiSearchUnionParameters<T[number], Infix>
+      | MultiSearchResultsParameters<T, Infix>,
+    options?: SearchOptions,
+  ): Promise<MultiSearchResponse<T, Infix>> {
+    const params = commonParams ? { ...commonParams } : {};
+    const cacheSearchResultsForSeconds =
+      options?.cacheSearchResultsForSeconds ??
+      this.configuration.cacheSearchResultsForSeconds;
+
+    if (this.configuration.useServerSideSearchCache === true) {
+      params.use_cache = true;
+    }
+
+    if (searchRequests.union === true && this.hasAnySearchObjectPagination(searchRequests)) {
+      this.logger.warn(
+        "Individual `searches` pagination parameters are ignored when `union: true` is set. Use a top-level pagination parameter instead. See https://typesense.org/docs/29.0/api/federated-multi-search.html#union-search"
+      );
+    }
+
+    const normalizedSearchRequests: Omit<typeof searchRequests, "searches"> & {
+      searches: ExtractBaseTypes<SearchParams<T[number], Infix>>[];
+    } = {
+      union: searchRequests.union,
+      searches: searchRequests.searches.map(
+        normalizeArrayableParams<
+          T[number],
+          SearchParams<T[number], Infix>,
+          Infix
+        >,
+      ),
+    };
+
+    const { streamConfig, ...paramsWithoutStream } = params;
+    const normalizedQueryParams = normalizeArrayableParams(
+      paramsWithoutStream as SearchParams<T[number], Infix>,
+    );
+
+    return this.requestWithCache.perform(
+      this.apiCall,
+      "post",
+      {
+        path: RESOURCEPATH,
+        body: normalizedSearchRequests,
+        queryParams: normalizedQueryParams,
+        headers: this.useTextContentType
+          ? { "content-type": "text/plain" }
+          : {},
+        streamConfig,
+        abortSignal: options?.abortSignal,
+        isStreamingRequest: this.isStreamingRequest(params),
+      },
+      cacheSearchResultsForSeconds !== undefined
+        ? { cacheResponseForSeconds: cacheSearchResultsForSeconds }
+        : undefined,
+    );
+  }
+
+  private isStreamingRequest(commonParams: { streamConfig?: unknown }) {
+    return commonParams.streamConfig !== undefined;
+  }
+
+  private hasAnySearchObjectPagination(searchRequests: MultiSearchRequestsSchema<DocumentSchema, string>) {
+    return searchRequests.searches.some(search => search.page !== undefined || search.per_page !== undefined || search.offset !== undefined || search.limit !== undefined || search.limit_hits !== undefined);
+  }
+}
+
+export type {
+  MultiSearchRequestsSchema,
+  MultiSearchRequestsWithUnionSchema,
+  MultiSearchResponse,
+  MultiSearchUnionParameters,
+  MultiSearchResultsParameters,
+  UnionSearchResponse,
+  MultiSearchRequestsWithoutUnionSchema,
+} from "./Types";

package/src/Typesense/NLSearchModel.ts

@@ -0,0 +1,35 @@
+import ApiCall from "./ApiCall";
+import NLSearchModels from "./NLSearchModels";
+import type { NLSearchModelBase, NLSearchModelSchema } from "./NLSearchModels";
+
+type NLSearchModelUpdateSchema = NLSearchModelBase;
+
+export interface NLSearchModelDeleteSchema {
+  id: string;
+}
+
+export default class NLSearchModel {
+  constructor(
+    private id: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async retrieve(): Promise<NLSearchModelSchema> {
+    return this.apiCall.get<NLSearchModelSchema>(this.endpointPath());
+  }
+
+  async update(
+    schema: NLSearchModelUpdateSchema,
+  ): Promise<NLSearchModelSchema> {
+    return this.apiCall.put<NLSearchModelSchema>(this.endpointPath(), schema);
+  }
+
+  async delete(): Promise<NLSearchModelDeleteSchema> {
+    return this.apiCall.delete<NLSearchModelDeleteSchema>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return `${NLSearchModels.RESOURCEPATH}/${encodeURIComponent(this.id)}`;
+  }
+}
+

package/src/Typesense/NLSearchModels.ts

@@ -0,0 +1,61 @@
+import ApiCall from "./ApiCall";
+
+const RESOURCEPATH = "/nl_search_models";
+
+// Base schema with all possible fields
+export interface NLSearchModelBase {
+  model_name: string;
+  api_key?: string;
+  api_url?: string;
+  max_bytes?: number;
+  temperature?: number;
+  system_prompt?: string;
+  // Google-specific parameters
+  top_p?: number;
+  top_k?: number;
+  stop_sequences?: string[];
+  api_version?: string;
+  // GCP Vertex AI specific
+  project_id?: string;
+  access_token?: string;
+  refresh_token?: string;
+  client_id?: string;
+  client_secret?: string;
+  region?: string;
+  max_output_tokens?: number;
+  // Cloudflare specific
+  account_id?: string;
+}
+
+export interface NLSearchModelCreateSchema extends NLSearchModelBase {
+  id?: string;
+}
+
+export interface NLSearchModelSchema extends NLSearchModelBase {
+  id: string;
+}
+
+export type NLSearchModelsRetrieveSchema = NLSearchModelSchema[];
+
+export default class NLSearchModels {
+  constructor(private apiCall: ApiCall) {}
+
+  async create(
+    schema: NLSearchModelCreateSchema,
+  ): Promise<NLSearchModelSchema> {
+    return this.apiCall.post<NLSearchModelSchema>(this.endpointPath(), schema);
+  }
+
+  async retrieve(): Promise<NLSearchModelsRetrieveSchema> {
+    return this.apiCall.get<NLSearchModelsRetrieveSchema>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return NLSearchModels.RESOURCEPATH;
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}
+

package/src/Typesense/Operations.ts

@@ -0,0 +1,35 @@
+import ApiCall from "./ApiCall";
+
+const RESOURCEPATH = "/operations";
+
+export interface SchemaChangeStatus {
+  collection: string;
+  validated_docs: number;
+  altered_docs: number;
+}
+
+export default class Operations {
+  constructor(private apiCall: ApiCall) {}
+
+  async perform(
+    operationName:
+      | "vote"
+      | "snapshot"
+      | "cache/clear"
+      // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- Can't use `object` here, it needs to intersect with `{}`
+      | (string & {}),
+    queryParameters: Record<string, any> = {},
+  ): Promise<any> {
+    return this.apiCall.post(
+      `${RESOURCEPATH}/${operationName}`,
+      {},
+      queryParameters,
+    );
+  }
+
+  async getSchemaChanges(): Promise<SchemaChangeStatus[]> {
+    return this.apiCall.get<SchemaChangeStatus[]>(
+      `${RESOURCEPATH}/schema_changes`,
+    );
+  }
+}

package/src/Typesense/Override.ts

@@ -0,0 +1,31 @@
+import ApiCall from "./ApiCall";
+import Collections from "./Collections";
+import Overrides, { OverrideCreateSchema } from "./Overrides";
+
+export interface OverrideSchema extends OverrideCreateSchema {
+  id: string;
+}
+
+export interface OverrideDeleteSchema {
+  id: string;
+}
+
+export default class Override {
+  constructor(
+    private collectionName: string,
+    private overrideId: string,
+    private apiCall: ApiCall
+  ) {}
+
+  async retrieve(): Promise<OverrideSchema> {
+    return this.apiCall.get<OverrideSchema>(this.endpointPath());
+  }
+
+  async delete(): Promise<OverrideDeleteSchema> {
+    return this.apiCall.delete<OverrideDeleteSchema>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return `${Collections.RESOURCEPATH}/${encodeURIComponent(this.collectionName)}${Overrides.RESOURCEPATH}/${encodeURIComponent(this.overrideId)}`;
+  }
+}

package/src/Typesense/Overrides.ts

@@ -0,0 +1,73 @@
+import ApiCall from "./ApiCall";
+import Collections from "./Collections";
+import { OverrideSchema } from "./Override";
+
+const RESOURCEPATH = "/overrides";
+
+export interface OverrideRuleQuerySchema {
+  query?: string;
+  match?: "exact" | "contains";
+}
+
+export interface OverrideRuleFilterSchema {
+  filter_by?: string;
+}
+
+export interface OverrideRuleTagsSchema {
+  tags?: string[];
+}
+
+export interface OverrideCreateSchema {
+  rule: OverrideRuleQuerySchema &
+    OverrideRuleFilterSchema &
+    OverrideRuleTagsSchema;
+  filter_by?: string;
+  sort_by?: string;
+  remove_matched_tokens?: boolean;
+  replace_query?: string;
+  includes?: Array<{
+    id: string;
+    position: number;
+  }>;
+  excludes?: Array<{ id: string }>;
+  filter_curated_hits?: boolean;
+  effective_from_ts?: number;
+  effective_to_ts?: number;
+  stop_processing?: boolean;
+  metadata?: object;
+}
+
+export interface OverridesRetrieveSchema {
+  overrides: OverrideSchema[];
+}
+
+export default class Overrides {
+  constructor(
+    private collectionName: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async upsert(
+    overrideId: string,
+    params: OverrideCreateSchema,
+  ): Promise<OverrideSchema> {
+    return this.apiCall.put<OverrideSchema>(
+      this.endpointPath(overrideId),
+      params,
+    );
+  }
+
+  async retrieve(): Promise<OverridesRetrieveSchema> {
+    return this.apiCall.get<OverridesRetrieveSchema>(this.endpointPath());
+  }
+
+  private endpointPath(operation?: string): string {
+    return `${Collections.RESOURCEPATH}/${this.collectionName}${
+      Overrides.RESOURCEPATH
+    }${operation === undefined ? "" : "/" + encodeURIComponent(operation)}`;
+  }
+
+  static get RESOURCEPATH(): string {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/Preset.ts

@@ -0,0 +1,31 @@
+import ApiCall from "./ApiCall";
+import { DocumentSchema } from "./Documents";
+import Presets, { PresetCreateSchema } from "./Presets";
+
+export interface PresetSchema<T extends DocumentSchema>
+  extends PresetCreateSchema<T, string> {
+  name: string;
+}
+
+export interface PresetDeleteSchema {
+  name: string;
+}
+
+export default class Preset {
+  constructor(
+    private presetId: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async retrieve<T extends DocumentSchema>(): Promise<PresetSchema<T>> {
+    return this.apiCall.get<PresetSchema<T>>(this.endpointPath());
+  }
+
+  async delete(): Promise<PresetDeleteSchema> {
+    return this.apiCall.delete<PresetDeleteSchema>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return `${Presets.RESOURCEPATH}/${encodeURIComponent(this.presetId)}`;
+  }
+}

package/src/Typesense/Presets.ts

@@ -0,0 +1,62 @@
+import ApiCall from "./ApiCall";
+import { PresetSchema } from "./Preset";
+import type { DocumentSchema, SearchParams } from "./Documents";
+import { MultiSearchRequestsSchema } from "./MultiSearch";
+import { normalizeArrayableParams } from "./Utils";
+
+const RESOURCEPATH = "/presets";
+
+export interface PresetCreateSchema<
+  T extends DocumentSchema,
+  Infix extends string,
+> {
+  value: SearchParams<T, Infix> | MultiSearchRequestsSchema<T, Infix>;
+}
+
+export interface PresetsRetrieveSchema<T extends DocumentSchema> {
+  presets: PresetSchema<T>[];
+}
+
+export default class Presets {
+  constructor(private apiCall: ApiCall) {}
+
+  async upsert<T extends DocumentSchema, const Infix extends string>(
+    presetId: string,
+    params: PresetCreateSchema<T, Infix>,
+  ): Promise<PresetSchema<T>> {
+    if (typeof params.value === "object" && "searches" in params.value) {
+      const normalizedParams = params.value.searches.map((search) =>
+        normalizeArrayableParams<T, SearchParams<T, Infix>, Infix>(search),
+      );
+
+      return this.apiCall.put<PresetSchema<T>>(this.endpointPath(presetId), {
+        value: { searches: normalizedParams },
+      });
+    }
+    const normalizedParams = normalizeArrayableParams<
+      T,
+      SearchParams<T, Infix>,
+      Infix
+    >(params.value);
+
+    return this.apiCall.put<PresetSchema<T>>(this.endpointPath(presetId), {
+      value: normalizedParams,
+    });
+  }
+
+  async retrieve<T extends DocumentSchema>(): Promise<
+    PresetsRetrieveSchema<T>
+  > {
+    return this.apiCall.get<PresetsRetrieveSchema<T>>(this.endpointPath());
+  }
+
+  private endpointPath(operation?: string): string {
+    return `${Presets.RESOURCEPATH}${
+      operation === undefined ? "" : "/" + encodeURIComponent(operation)
+    }`;
+  }
+
+  static get RESOURCEPATH(): string {
+    return RESOURCEPATH;
+  }
+}