@depup/typesense 3.0.3-depup.0

package/package.json

@@ -0,0 +1,141 @@
+{
+  "name": "@depup/typesense",
+  "version": "3.0.3-depup.0",
+  "description": "[DepUp] Javascript Library for Typesense",
+  "homepage": "https://github.com/typesense/typesense-js",
+  "author": {
+    "name": "Typesense, Inc.",
+    "email": "contact@typesense.org",
+    "url": "https://typesense.org"
+  },
+  "contributors": [
+    {
+      "name": "Nick Kamer",
+      "email": "nick@ziaomedia.com",
+      "url": "https://github.com/ziao"
+    },
+    {
+      "name": "Damian Cantu",
+      "email": "damian@release-next.com",
+      "url": "https://github.com/dcantu476"
+    }
+  ],
+  "main": "lib/Typesense.js",
+  "types": "lib/Typesense.d.ts",
+  "browser": {
+    "crypto": false,
+    "http": false,
+    "https": false
+  },
+  "files": [
+    "lib/",
+    "dist/",
+    "src/",
+    "changes.json",
+    "README.md"
+  ],
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "typesense",
+    "api",
+    "sdk",
+    "client",
+    "wrapper",
+    "server",
+    "search"
+  ],
+  "devDependencies": {
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/eslint-parser": "^7.28.6",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+    "@babel/plugin-transform-destructuring": "^7.28.5",
+    "@babel/plugin-transform-runtime": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
+    "@babel/preset-typescript": "^7.28.5",
+    "@babel/register": "^7.28.6",
+    "@types/node": "^25.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "@vitest/browser": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
+    "axios-curlirize": "^2.0.0",
+    "axios-mock-adapter": "^2.1.0",
+    "babel-loader": "^10.0.0",
+    "babel-plugin-istanbul": "^7.0.1",
+    "babelify": "^10.0.0",
+    "browserify": "^17.0.1",
+    "common-shakeify": "^1.1.2",
+    "core-js": "^3.48.0",
+    "del": "^8.0.1",
+    "dotenv": "^17.3.1",
+    "eslint": "^9.39.3",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-promise": "^6.6.0",
+    "eslint-plugin-standard": "^5.0.0",
+    "jsdom": "^28.1.0",
+    "mocha": "^11.7.5",
+    "mocha-junit-reporter": "^2.2.1",
+    "prettier": "^3.8.1",
+    "timekeeper": "^2.3.1",
+    "ts-loader": "^9.5.4",
+    "tsify": "^5.0.4",
+    "typescript": "^5.9.3",
+    "vinyl-buffer": "^1.0.1",
+    "vinyl-source-stream": "^2.0.0",
+    "vitest": "^4.0.18",
+    "webpack": "^5.105.2",
+    "webpack-cli": "^6.0.1"
+  },
+  "scripts": {
+    "format": "prettier --write \"(src|test|doc)/**/*.(ts|json|js)\"",
+    "pretest": "eslint .",
+    "test": "vitest",
+    "test:local": "npm run test:typesenseServer:start && vitest run; npm run test:typesenseServer:stop",
+    "test:typesenseServer:start": "docker rm -f typesense-test 2>/dev/null || true; TMPDIR=$(mktemp -d) && docker run -d --name typesense-test -p 8108:8108 -v$TMPDIR:/data typesense/typesense:29.0 --data-dir /data --api-key=xyz --listen-port 8108 --enable-cors && echo 'Waiting for Typesense to be ready...' && until curl -s http://localhost:8108/health | grep -q '\"ok\":true'; do sleep 1; done && echo 'Typesense is ready!'",
+    "test:typesenseServer:stop": "docker stop typesense-test && docker rm typesense-test",
+    "build": "npm run build:tsc && npm run build:web:dev && npm run build:web:prod",
+    "build:tsc": "tsc",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "build:web:dev": "webpack --config webpack.config.js --mode development",
+    "build:web:prod": "webpack --config webpack.config.js --mode production",
+    "build:tsc:watch": "tsc --watch",
+    "ci-lint": "eslint .",
+    "typesenseServer": "docker run -i -p 8108:8108 -v/tmp/typesense-server-data-1c/:/data typesense/typesense:27.0.rc26 --data-dir /data --api-key=xyz --listen-port 8108 --enable-cors",
+    "createServerNodesFile": "echo '172.17.0.2:8107:8108,172.17.0.3:7107:7108,172.17.0.4:9107:9108' > `pwd`/typesense-server-nodes",
+    "typesenseServer:0": "docker run -i -p 8108:8108 -p 8107:8107 -v/tmp/typesense-server-data-1b/:/data -v`pwd`/typesense-server-nodes:/typesense-server-nodes typesense/typesense:27.0.rc26 --data-dir /data --api-key=xyz --listen-port 8108 --peering-port 8107 --enable-cors --nodes=/typesense-server-nodes",
+    "typesenseServer:1": "docker run -i -p 7108:7108 -p 7107:7107 -v/tmp/typesense-server-data-2b/:/data -v`pwd`/typesense-server-nodes:/typesense-server-nodes typesense/typesense:27.0.rc26 --data-dir /data --api-key=xyz --listen-port 7108 --peering-port 7107 --enable-cors --nodes=/typesense-server-nodes",
+    "typesenseServer:2": "docker run -i -p 9108:9108 -p 9107:9107 -v/tmp/typesense-server-data-3b/:/data -v`pwd`/typesense-server-nodes:/typesense-server-nodes typesense/typesense:27.0.rc26 --data-dir /data --api-key=xyz --listen-port 9108 --peering-port 9107 --enable-cors --nodes=/typesense-server-nodes"
+  },
+  "repository": "typesense/typesense-js",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "axios": "^1.13.6",
+    "loglevel": "^1.9.2",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@babel/runtime": "^7.23.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "depup": {
+    "changes": {
+      "axios": {
+        "from": "^1.13.5",
+        "to": "^1.13.6"
+      }
+    },
+    "depsUpdated": 1,
+    "originalPackage": "typesense",
+    "originalVersion": "3.0.3",
+    "processedAt": "2026-03-17T19:33:29.787Z",
+    "smokeTest": "passed"
+  }
+}

package/src/Typesense/Alias.ts

@@ -0,0 +1,18 @@
+import Aliases, { CollectionAliasSchema } from "./Aliases";
+import ApiCall from "./ApiCall";
+
+export default class Alias {
+  constructor(private name: string, private apiCall: ApiCall) {}
+
+  async retrieve(): Promise<CollectionAliasSchema> {
+    return this.apiCall.get<CollectionAliasSchema>(this.endpointPath());
+  }
+
+  async delete(): Promise<CollectionAliasSchema> {
+    return this.apiCall.delete<CollectionAliasSchema>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return `${Aliases.RESOURCEPATH}/${encodeURIComponent(this.name)}`;
+  }
+}

package/src/Typesense/Aliases.ts

@@ -0,0 +1,41 @@
+import ApiCall from "./ApiCall";
+
+const RESOURCEPATH = "/aliases";
+
+export interface CollectionAliasCreateSchema {
+  collection_name: string;
+}
+
+export interface CollectionAliasSchema extends CollectionAliasCreateSchema {
+  name: string;
+}
+
+export interface CollectionAliasesResponseSchema {
+  aliases: CollectionAliasSchema[];
+}
+
+export default class Aliases {
+  constructor(private apiCall: ApiCall) {}
+
+  async upsert(
+    name: string,
+    mapping: CollectionAliasCreateSchema
+  ): Promise<CollectionAliasSchema> {
+    return this.apiCall.put<CollectionAliasSchema>(
+      this.endpointPath(name),
+      mapping
+    );
+  }
+
+  async retrieve(): Promise<CollectionAliasesResponseSchema> {
+    return this.apiCall.get<CollectionAliasesResponseSchema>(RESOURCEPATH);
+  }
+
+  private endpointPath(aliasName): string {
+    return `${Aliases.RESOURCEPATH}/${encodeURIComponent(aliasName)}`;
+  }
+
+  static get RESOURCEPATH(): string {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/Analytics.ts

@@ -0,0 +1,39 @@
+import ApiCall from "./ApiCall";
+import AnalyticsRules from "./AnalyticsRules";
+import AnalyticsRule from "./AnalyticsRule";
+import AnalyticsEvents from "./AnalyticsEvents";
+
+const RESOURCEPATH = "/analytics";
+
+export default class Analytics {
+  private readonly _analyticsRules: AnalyticsRules;
+  private readonly individualAnalyticsRules: Record<string, AnalyticsRule> = {};
+  private readonly _analyticsEvents: AnalyticsEvents;
+
+  constructor(private readonly apiCall: ApiCall) {
+    this.apiCall = apiCall;
+    this._analyticsRules = new AnalyticsRules(this.apiCall);
+    this._analyticsEvents = new AnalyticsEvents(this.apiCall);
+  }
+
+  rules(): AnalyticsRules;
+  rules(id: string): AnalyticsRule;
+  rules(id?: string): AnalyticsRules | AnalyticsRule {
+    if (id === undefined) {
+      return this._analyticsRules;
+    } else {
+      if (this.individualAnalyticsRules[id] === undefined) {
+        this.individualAnalyticsRules[id] = new AnalyticsRule(id, this.apiCall);
+      }
+      return this.individualAnalyticsRules[id];
+    }
+  }
+
+  events(): AnalyticsEvents {
+    return this._analyticsEvents;
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/AnalyticsEvent.ts

@@ -0,0 +1,5 @@
+export interface AnalyticsEventCreateSchema {
+  type?: string;
+  name: string;
+  data: Record<string, unknown>;
+}

package/src/Typesense/AnalyticsEvents.ts

@@ -0,0 +1,53 @@
+import ApiCall from "./ApiCall";
+import { AnalyticsEventCreateSchema } from "./AnalyticsEvent";
+
+const RESOURCEPATH = "/analytics/events";
+
+export interface AnalyticsEventsRetrieveSchema {
+  events: {
+    name: string;
+    event_type: string;
+    collection: string;
+    timestamp: number;
+    user_id: string;
+    doc_id?: string;
+    doc_ids?: string[];
+    query?: string;
+  }[];
+}
+
+export default class AnalyticsEvents {
+  constructor(private readonly apiCall: ApiCall) {
+    this.apiCall = apiCall;
+  }
+
+  async create(
+    params: AnalyticsEventCreateSchema,
+  ): Promise<AnalyticsEventCreateSchema> {
+    return this.apiCall.post<AnalyticsEventCreateSchema>(
+      this.endpointPath(),
+      params,
+    );
+  }
+
+  async retrieve(params: {
+    user_id: string;
+    name: string;
+    n: number;
+  }): Promise<AnalyticsEventsRetrieveSchema> {
+    return this.apiCall.get<AnalyticsEventsRetrieveSchema>(
+      this.endpointPath(),
+      params,
+    );
+  }
+
+  private endpointPath(operation?: string): string {
+    return `${AnalyticsEvents.RESOURCEPATH}${
+      operation === undefined ? "" : "/" + encodeURIComponent(operation)
+    }`;
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/AnalyticsRule.ts

@@ -0,0 +1,63 @@
+import ApiCall from "./ApiCall";
+import AnalyticsRules from "./AnalyticsRules";
+
+export interface AnalyticsRuleCreateSchema {
+  name: string;
+  type: string;
+  collection: string;
+  event_type: string;
+  rule_tag?: string;
+  params?: {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: string[];
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+  };
+}
+
+export interface AnalyticsRuleUpsertSchema {
+  name?: string;
+  type?: string;
+  collection?: string;
+  event_type?: string;
+  rule_tag?: string;
+  params?: {
+    destination_collection?: string;
+    limit?: number;
+    capture_search_requests?: boolean;
+    meta_fields?: string[];
+    expand_query?: boolean;
+    counter_field?: string;
+    weight?: number;
+  };
+}
+
+export interface AnalyticsRuleDeleteSchema {
+  name: string;
+}
+
+export interface AnalyticsRuleSchema extends AnalyticsRuleCreateSchema {
+  name: string;
+}
+
+export default class AnalyticsRule {
+  constructor(
+    private name: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async retrieve(): Promise<AnalyticsRuleSchema> {
+    return this.apiCall.get<AnalyticsRuleSchema>(this.endpointPath());
+  }
+
+  async delete(): Promise<AnalyticsRuleDeleteSchema> {
+    return this.apiCall.delete<AnalyticsRuleDeleteSchema>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return `${AnalyticsRules.RESOURCEPATH}/${encodeURIComponent(this.name)}`;
+  }
+}

package/src/Typesense/AnalyticsRuleV1.ts

@@ -0,0 +1,52 @@
+import ApiCall from "./ApiCall";
+import AnalyticsRulesV1 from "./AnalyticsRulesV1";
+
+export interface AnalyticsRuleCreateSchemaV1 {
+  type: "popular_queries" | "nohits_queries" | "counter" | "log";
+  params: {
+    enable_auto_aggregation?: boolean;
+    source: {
+      collections: string[];
+      events?: {
+        type: string;
+        weight?: number;
+        name: string;
+      }[];
+    };
+    expand_query?: boolean;
+    destination?: {
+      collection: string;
+      counter_field?: string;
+    };
+    limit?: number;
+  };
+}
+
+export interface AnalyticsRuleDeleteSchemaV1 {
+  name: string;
+}
+
+export interface AnalyticsRuleSchemaV1 extends AnalyticsRuleCreateSchemaV1 {
+  name: string;
+}
+
+export default class AnalyticsRuleV1 {
+  constructor(
+    private name: string,
+    private apiCall: ApiCall,
+  ) {}
+
+  async retrieve(): Promise<AnalyticsRuleSchemaV1> {
+    return this.apiCall.get<AnalyticsRuleSchemaV1>(this.endpointPath());
+  }
+
+  async delete(): Promise<AnalyticsRuleDeleteSchemaV1> {
+    return this.apiCall.delete<AnalyticsRuleDeleteSchemaV1>(this.endpointPath());
+  }
+
+  private endpointPath(): string {
+    return `${AnalyticsRulesV1.RESOURCEPATH}/${encodeURIComponent(this.name)}`;
+  }
+}
+
+

package/src/Typesense/AnalyticsRules.ts

@@ -0,0 +1,67 @@
+import ApiCall from "./ApiCall";
+import {
+  AnalyticsRuleCreateSchema,
+  AnalyticsRuleSchema,
+  AnalyticsRuleUpsertSchema,
+} from "./AnalyticsRule";
+
+export interface AnalyticsRulesRetrieveSchema {
+  rules: AnalyticsRuleSchema[];
+}
+
+const RESOURCEPATH = "/analytics/rules";
+
+export default class AnalyticsRules {
+  constructor(private readonly apiCall: ApiCall) {
+    this.apiCall = apiCall;
+  }
+
+  async create(
+    params:
+      | AnalyticsRuleCreateSchema
+      | AnalyticsRuleCreateSchema[],
+  ): Promise<
+    | AnalyticsRuleSchema
+    | (
+        | AnalyticsRuleSchema
+        | {
+            error?: string;
+          }
+      )[]
+  > {
+    return this.apiCall.post(
+      this.endpointPath(),
+      params,
+      {},
+      {},
+    );
+  }
+
+  async upsert(
+    name: string,
+    params: AnalyticsRuleUpsertSchema
+  ): Promise<AnalyticsRuleSchema> {
+    return this.apiCall.put<AnalyticsRuleSchema>(
+      this.endpointPath(name),
+      params
+    );
+  }
+
+  async retrieve(ruleTag?: string): Promise<AnalyticsRuleSchema[]> {
+    const query: Record<string, string> = {};
+    if (ruleTag) {
+      query["rule_tag"] = ruleTag;
+    }
+    return this.apiCall.get<AnalyticsRuleSchema[]>(this.endpointPath(), query);
+  }
+
+  private endpointPath(operation?: string): string {
+    return `${AnalyticsRules.RESOURCEPATH}${
+      operation === undefined ? "" : "/" + encodeURIComponent(operation)
+    }`;
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}

package/src/Typesense/AnalyticsRulesV1.ts

@@ -0,0 +1,43 @@
+import ApiCall from "./ApiCall";
+import {
+  AnalyticsRuleCreateSchemaV1,
+  AnalyticsRuleSchemaV1,
+} from "./AnalyticsRuleV1";
+
+export interface AnalyticsRulesRetrieveSchemaV1 {
+  rules: AnalyticsRuleSchemaV1[];
+}
+
+const RESOURCEPATH = "/analytics/rules";
+
+export default class AnalyticsRulesV1 {
+  constructor(private readonly apiCall: ApiCall) {
+    this.apiCall = apiCall;
+  }
+
+  async upsert(
+    name: string,
+    params: AnalyticsRuleCreateSchemaV1
+  ): Promise<AnalyticsRuleSchemaV1> {
+    return this.apiCall.put<AnalyticsRuleSchemaV1>(
+      this.endpointPath(name),
+      params
+    );
+  }
+
+  async retrieve(): Promise<AnalyticsRulesRetrieveSchemaV1> {
+    return this.apiCall.get<AnalyticsRulesRetrieveSchemaV1>(this.endpointPath());
+  }
+
+  private endpointPath(operation?: string): string {
+    return `${AnalyticsRulesV1.RESOURCEPATH}${
+      operation === undefined ? "" : "/" + encodeURIComponent(operation)
+    }`;
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}
+
+

package/src/Typesense/AnalyticsV1.ts

@@ -0,0 +1,52 @@
+import ApiCall from "./ApiCall";
+import AnalyticsRulesV1 from "./AnalyticsRulesV1";
+import AnalyticsRuleV1 from "./AnalyticsRuleV1";
+import AnalyticsEvents from "./AnalyticsEvents";
+
+const RESOURCEPATH = "/analytics";
+
+/**
+ * @deprecated Deprecated starting with Typesense Server v30. Please migrate to `client.analytics` (new Analytics APIs).
+ */
+export default class AnalyticsV1 {
+  private static hasWarnedDeprecation = false;
+  private readonly _analyticsRules: AnalyticsRulesV1;
+  private readonly individualAnalyticsRules: Record<string, AnalyticsRuleV1> = {};
+  private readonly _analyticsEvents: AnalyticsEvents;
+
+  constructor(private readonly apiCall: ApiCall) {
+    this.apiCall = apiCall;
+    this._analyticsRules = new AnalyticsRulesV1(this.apiCall);
+    this._analyticsEvents = new AnalyticsEvents(this.apiCall);
+  }
+
+  rules(): AnalyticsRulesV1;
+  rules(id: string): AnalyticsRuleV1;
+  rules(id?: string): AnalyticsRulesV1 | AnalyticsRuleV1 {
+    if (!AnalyticsV1.hasWarnedDeprecation) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        "[typesense] 'analyticsV1' is deprecated starting with Typesense Server v30 and will be removed in a future release. Please use 'analytics' instead.",
+      );
+      AnalyticsV1.hasWarnedDeprecation = true;
+    }
+    if (id === undefined) {
+      return this._analyticsRules;
+    } else {
+      if (this.individualAnalyticsRules[id] === undefined) {
+        this.individualAnalyticsRules[id] = new AnalyticsRuleV1(id, this.apiCall);
+      }
+      return this.individualAnalyticsRules[id];
+    }
+  }
+
+  events(): AnalyticsEvents {
+    return this._analyticsEvents;
+  }
+
+  static get RESOURCEPATH() {
+    return RESOURCEPATH;
+  }
+}
+
+