@upstash/redis 1.38.4 → 1.39.0

package/{chunk-2JFYL2VL.mjs → chunk-4WQYU7T6.mjs}

@@ -705,17 +705,25 @@ function buildScoreFuncField(field) {
   return result;
 }
 function buildCreateIndexCommand(params) {
-  const { name, schema, dataType, prefix, language, skipInitialScan, existsOk } = params;
-  const prefixArray = Array.isArray(prefix) ? prefix : [prefix];
+  const { name, schema, dataType, language, skipInitialScan, existsOk } = params;
+  let source;
+  if (params.dataType === "stream") {
+    source = ["ON", "STREAM", params.stream];
+  } else {
+    const prefixArray = Array.isArray(params.prefix) ? params.prefix : [params.prefix];
+    source = [
+      "ON",
+      dataType.toUpperCase(),
+      "PREFIX",
+      prefixArray.length.toString(),
+      ...prefixArray
+    ];
+  }
   const payload = [
     name,
     ...skipInitialScan ? ["SKIPINITIALSCAN"] : [],
     ...existsOk ? ["EXISTSOK"] : [],
-    "ON",
-    dataType.toUpperCase(),
-    "PREFIX",
-    prefixArray.length.toString(),
-    ...prefixArray,
+    ...source,
     ...language ? ["LANGUAGE", language] : [],
     "SCHEMA"
   ];
@@ -837,6 +845,202 @@ async function delAlias(client, { alias }) {
   return result;
 }
 
+// pkg/commands/vector/utils.ts
+function float32ToBase64(vector) {
+  const bytes = new Uint8Array(vector.length * 4);
+  const view = new DataView(bytes.buffer);
+  for (const [i, value] of vector.entries()) {
+    view.setFloat32(i * 4, value, true);
+  }
+  let binary = "";
+  const chunkSize = 32768;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    binary += String.fromCodePoint(...bytes.subarray(i, i + chunkSize));
+  }
+  return btoa(binary);
+}
+function serializeVector(vector) {
+  if (Array.isArray(vector)) {
+    return ["VALUES", vector.length, ...vector];
+  }
+  if (vector instanceof Float32Array) {
+    return ["BASE64-FP32", float32ToBase64(vector)];
+  }
+  return ["BASE64-FP32", vector.base64];
+}
+function deserializeVectorValues(result) {
+  if (result === null) {
+    return null;
+  }
+  return result.map(Number);
+}
+function deserializeVectorQueryResponse(result) {
+  return result.map(([id, score]) => ({ id: String(id), score: Number(score) }));
+}
+function deserializeVectorInfoResponse(result) {
+  if (result === null) {
+    return null;
+  }
+  const fields = Array.isArray(result) ? Object.fromEntries(
+    Array.from({ length: Math.floor(result.length / 2) }, (_, i) => [
+      String(result[i * 2]),
+      result[i * 2 + 1]
+    ])
+  ) : result;
+  return {
+    dimension: Number(fields.dimension),
+    metric: String(fields.metric).toUpperCase()
+  };
+}
+
+// pkg/commands/vector_add.ts
+var VectorAddCommand = class extends Command {
+  constructor([index, id, vector], cmdOpts) {
+    super(["VECTOR.ADD", index, id, ...serializeVector(vector)], cmdOpts);
+  }
+};
+
+// pkg/commands/vector_count.ts
+var VectorCountCommand = class extends Command {
+  constructor([index], cmdOpts) {
+    super(["VECTOR.COUNT", index], cmdOpts);
+  }
+};
+
+// pkg/commands/vector_create.ts
+var VectorCreateCommand = class extends Command {
+  constructor([index, opts], cmdOpts) {
+    const command = [
+      "VECTOR.CREATE",
+      index,
+      "DIM",
+      opts.dimension,
+      "METRIC",
+      opts.metric
+    ];
+    if (opts.existsOk) {
+      command.push("EXISTSOK");
+    }
+    super(command, cmdOpts);
+  }
+};
+
+// pkg/commands/vector_del.ts
+var VectorDelCommand = class extends Command {
+  constructor([index, id], cmdOpts) {
+    super(["VECTOR.DEL", index, id], cmdOpts);
+  }
+};
+
+// pkg/commands/vector_drop.ts
+var VectorDropCommand = class extends Command {
+  constructor([index], cmdOpts) {
+    super(["VECTOR.DROP", index], cmdOpts);
+  }
+};
+
+// pkg/commands/vector_get.ts
+var VectorGetCommand = class extends Command {
+  constructor([index, id], cmdOpts) {
+    super(["VECTOR.GET", index, id], {
+      deserialize: deserializeVectorValues,
+      ...cmdOpts
+    });
+  }
+};
+
+// pkg/commands/vector_info.ts
+var VectorInfoCommand = class extends Command {
+  constructor([index], cmdOpts) {
+    super(["VECTOR.INFO", index], {
+      deserialize: deserializeVectorInfoResponse,
+      ...cmdOpts
+    });
+  }
+};
+
+// pkg/commands/vector_query.ts
+var VectorQueryCommand = class extends Command {
+  constructor([index, opts], cmdOpts) {
+    const command = ["VECTOR.QUERY", index, "TOPK", opts.topK];
+    if (opts.profile) {
+      command.push("PROFILE", opts.profile);
+    }
+    command.push(...serializeVector(opts.vector));
+    super(command, {
+      deserialize: deserializeVectorQueryResponse,
+      ...cmdOpts
+    });
+  }
+};
+
+// pkg/commands/vector/vector.ts
+var VectorIndex = class {
+  name;
+  client;
+  commandOptions;
+  constructor({ name, client, commandOptions }) {
+    this.name = name;
+    this.client = client;
+    this.commandOptions = commandOptions;
+  }
+  /**
+   * Adds a vector to the index, or overwrites the vector stored under `id`.
+   *
+   * @returns `1` if a new vector was inserted, `0` if an existing one was overwritten.
+   */
+  add(id, vector) {
+    return new VectorAddCommand([this.name, id, vector], this.commandOptions).exec(this.client);
+  }
+  /**
+   * Returns the vector stored under `id`, or `null` if it does not exist.
+   */
+  get(id) {
+    return new VectorGetCommand([this.name, id], this.commandOptions).exec(this.client);
+  }
+  /**
+   * Returns the `topK` nearest neighbours of the query vector.
+   */
+  query(options) {
+    return new VectorQueryCommand([this.name, options], this.commandOptions).exec(this.client);
+  }
+  /**
+   * Deletes the vector stored under `id`.
+   *
+   * @returns `1` if the vector existed and was removed, `0` otherwise.
+   */
+  delete(id) {
+    return new VectorDelCommand([this.name, id], this.commandOptions).exec(this.client);
+  }
+  /**
+   * Returns the number of vectors in the index.
+   */
+  count() {
+    return new VectorCountCommand([this.name], this.commandOptions).exec(this.client);
+  }
+  /**
+   * Returns the dimension and metric of the index, or `null` if it does not exist.
+   */
+  info() {
+    return new VectorInfoCommand([this.name], this.commandOptions).exec(this.client);
+  }
+  /**
+   * Drops the index and all vectors in it.
+   *
+   * @returns `1` if the index existed and was dropped, `0` otherwise.
+   */
+  drop() {
+    return new VectorDropCommand([this.name], this.commandOptions).exec(this.client);
+  }
+};
+async function createVectorIndex(client, { name, ...opts }, commandOptions) {
+  await new VectorCreateCommand([name, opts], commandOptions).exec(client);
+  return new VectorIndex({ name, client, commandOptions });
+}
+function initVectorIndex(client, name, commandOptions) {
+  return new VectorIndex({ name, client, commandOptions });
+}
+
 // pkg/commands/hrandfield.ts
 function deserialize(result) {
   if (result.length === 0) {
@@ -878,6 +1082,225 @@ var AppendCommand = class extends Command {
   }
 };
 
+// pkg/commands/arcount.ts
+var ArCountCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARCOUNT", ...cmd], opts);
+  }
+};
+
+// pkg/commands/ardel.ts
+var ArDelCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARDEL", ...cmd], opts);
+  }
+};
+
+// pkg/commands/ardelrange.ts
+var ArDelRangeCommand = class extends Command {
+  constructor([key, ...ranges], opts) {
+    super(["ARDELRANGE", key, ...ranges.flat()], opts);
+  }
+};
+
+// pkg/commands/arget.ts
+var ArGetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARGET", ...cmd], opts);
+  }
+};
+
+// pkg/commands/argetrange.ts
+var ArGetRangeCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARGETRANGE", ...cmd], opts);
+  }
+};
+
+// pkg/commands/argrep.ts
+var ArGrepCommand = class extends Command {
+  constructor([key, start, end, opts], cmdOpts) {
+    const command = ["ARGREP", key, start, end];
+    for (const predicate of opts.predicates) {
+      if ("exact" in predicate) {
+        command.push("EXACT", predicate.exact);
+      } else if ("match" in predicate) {
+        command.push("MATCH", predicate.match);
+      } else if ("glob" in predicate) {
+        command.push("GLOB", predicate.glob);
+      } else {
+        command.push("RE", predicate.re);
+      }
+    }
+    if (opts.combine) {
+      command.push(opts.combine.toUpperCase());
+    }
+    if (opts.noCase) {
+      command.push("NOCASE");
+    }
+    if (opts.withValues) {
+      command.push("WITHVALUES");
+    }
+    if (opts.limit !== void 0) {
+      command.push("LIMIT", opts.limit);
+    }
+    super(command, {
+      deserialize: (result) => parseResponse(result).map(
+        (item) => Array.isArray(item) ? [String(item[0]), item[1]] : String(item)
+      ),
+      ...cmdOpts
+    });
+  }
+};
+
+// pkg/commands/arinfo.ts
+function toCamelCase(field) {
+  return field.replaceAll(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function deserializeArInfoResponse(result) {
+  const entries = Array.isArray(result) ? Array.from({ length: Math.floor(result.length / 2) }, (_, i) => [
+    result[i * 2],
+    result[i * 2 + 1]
+  ]) : Object.entries(result);
+  const indexFields = /* @__PURE__ */ new Set(["len", "nextInsertIndex"]);
+  const info = {};
+  for (const [field, value] of entries) {
+    const name = toCamelCase(String(field));
+    if (indexFields.has(name)) {
+      info[name] = String(value);
+      continue;
+    }
+    const numeric = typeof value === "number" ? value : Number(value);
+    info[name] = Number.isNaN(numeric) ? value : numeric;
+  }
+  return info;
+}
+var ArInfoCommand = class extends Command {
+  constructor([key, opts], cmdOpts) {
+    const command = ["ARINFO", key];
+    if (opts?.full) {
+      command.push("FULL");
+    }
+    super(command, {
+      deserialize: deserializeArInfoResponse,
+      ...cmdOpts
+    });
+  }
+};
+
+// pkg/commands/arinsert.ts
+var ArInsertCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARINSERT", ...cmd], {
+      deserialize: String,
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/arlastitems.ts
+var ArLastItemsCommand = class extends Command {
+  constructor([key, count, opts], cmdOpts) {
+    const command = ["ARLASTITEMS", key, count];
+    if (opts?.rev) {
+      command.push("REV");
+    }
+    super(command, cmdOpts);
+  }
+};
+
+// pkg/commands/arlen.ts
+var ArLenCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARLEN", ...cmd], {
+      deserialize: String,
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/armget.ts
+var ArMGetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARMGET", ...cmd], opts);
+  }
+};
+
+// pkg/commands/armset.ts
+var ArMSetCommand = class extends Command {
+  constructor([key, values], opts) {
+    const pairs = Array.isArray(values) ? values : Object.entries(values);
+    super(["ARMSET", key, ...pairs.flatMap(([index, value]) => [index, value])], opts);
+  }
+};
+
+// pkg/commands/arnext.ts
+var ArNextCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARNEXT", ...cmd], {
+      deserialize: (result) => result === null ? null : String(result),
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/arop.ts
+var ArOpCommand = class extends Command {
+  constructor([key, start, end, operation], opts) {
+    const command = ["AROP", key, start, end];
+    if (typeof operation === "string") {
+      command.push(operation.toUpperCase());
+    } else {
+      command.push("MATCH", operation.match);
+    }
+    super(command, {
+      deserialize: (result) => result === null ? null : Number(result),
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/arring.ts
+var ArRingCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARRING", ...cmd], {
+      deserialize: String,
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/arscan.ts
+var ArScanCommand = class extends Command {
+  constructor([key, start, end, opts], cmdOpts) {
+    const command = ["ARSCAN", key, start, end];
+    if (opts?.limit !== void 0) {
+      command.push("LIMIT", opts.limit);
+    }
+    super(command, {
+      deserialize: (result) => parseResponse(result).map(([index, value]) => [
+        String(index),
+        value
+      ]),
+      ...cmdOpts
+    });
+  }
+};
+
+// pkg/commands/arseek.ts
+var ArSeekCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARSEEK", ...cmd], opts);
+  }
+};
+
+// pkg/commands/arset.ts
+var ArSetCommand = class extends Command {
+  constructor(cmd, opts) {
+    super(["ARSET", ...cmd], opts);
+  }
+};
+
 // pkg/commands/bitcount.ts
 var BitCountCommand = class extends Command {
   constructor([key, start, end], opts) {
@@ -3099,6 +3522,78 @@ var Pipeline = class {
    * @see https://redis.io/commands/append
    */
   append = (...args) => this.chain(new AppendCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arcount
+   */
+  arcount = (...args) => this.chain(new ArCountCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/ardel
+   */
+  ardel = (...args) => this.chain(new ArDelCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/ardelrange
+   */
+  ardelrange = (...args) => this.chain(new ArDelRangeCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arget
+   */
+  arget = (...args) => this.chain(new ArGetCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/argetrange
+   */
+  argetrange = (...args) => this.chain(new ArGetRangeCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/argrep
+   */
+  argrep = (key, start, end, opts) => this.chain(new ArGrepCommand([key, start, end, opts], this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arinfo
+   */
+  arinfo = (...args) => this.chain(new ArInfoCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arinsert
+   */
+  arinsert = (key, ...values) => this.chain(new ArInsertCommand([key, ...values], this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arlastitems
+   */
+  arlastitems = (...args) => this.chain(new ArLastItemsCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arlen
+   */
+  arlen = (...args) => this.chain(new ArLenCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/armget
+   */
+  armget = (...args) => this.chain(new ArMGetCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/armset
+   */
+  armset = (key, values) => this.chain(new ArMSetCommand([key, values], this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arnext
+   */
+  arnext = (...args) => this.chain(new ArNextCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arop
+   */
+  arop = (key, start, end, operation) => this.chain(new ArOpCommand([key, start, end, operation], this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arring
+   */
+  arring = (key, size, ...values) => this.chain(new ArRingCommand([key, size, ...values], this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arscan
+   */
+  arscan = (...args) => this.chain(new ArScanCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arseek
+   */
+  arseek = (...args) => this.chain(new ArSeekCommand(args, this.commandOptions));
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arset
+   */
+  arset = (key, index, ...values) => this.chain(new ArSetCommand([key, index, ...values], this.commandOptions));
   /**
    * @see https://redis.io/commands/bitcount
    */
@@ -3922,6 +4417,18 @@ var Pipeline = class {
 // pkg/auto-pipeline.ts
 var MAX_PIPELINE_SIZE = 1e3;
 var READ_COMMANDS = /* @__PURE__ */ new Set([
+  // Array
+  "arcount",
+  "arget",
+  "argetrange",
+  "argrep",
+  "arinfo",
+  "arlastitems",
+  "arlen",
+  "armget",
+  "arnext",
+  "arop",
+  "arscan",
   // String
   "get",
   "getrange",
@@ -4695,6 +5202,32 @@ var Redis = class {
       }
     };
   }
+  /**
+   * Vector index commands.
+   *
+   * @example
+   * ```typescript
+   * const index = await redis.vector.createIndex({ name: "docs", dimension: 3, metric: "COSINE" });
+   * await index.add("doc-1", [0.1, 0.2, 0.3]);
+   * const hits = await index.query({ vector: [0.1, 0.2, 0.3], topK: 5 });
+   * ```
+   */
+  get vector() {
+    return {
+      /**
+       * Creates a vector index and returns a handle to it.
+       */
+      createIndex: (params) => {
+        return createVectorIndex(this.client, params, this.opts);
+      },
+      /**
+       * Returns a handle to an existing vector index without sending any command.
+       */
+      index: (name) => {
+        return initVectorIndex(this.client, name, this.opts);
+      }
+    };
+  }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
    *
@@ -4742,6 +5275,78 @@ var Redis = class {
    * @see https://redis.io/commands/append
    */
   append = (...args) => new AppendCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arcount
+   */
+  arcount = (...args) => new ArCountCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/ardel
+   */
+  ardel = (...args) => new ArDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/ardelrange
+   */
+  ardelrange = (...args) => new ArDelRangeCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arget
+   */
+  arget = (...args) => new ArGetCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/argetrange
+   */
+  argetrange = (...args) => new ArGetRangeCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/argrep
+   */
+  argrep = (key, start, end, opts) => new ArGrepCommand([key, start, end, opts], this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arinfo
+   */
+  arinfo = (...args) => new ArInfoCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arinsert
+   */
+  arinsert = (key, ...values) => new ArInsertCommand([key, ...values], this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arlastitems
+   */
+  arlastitems = (...args) => new ArLastItemsCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arlen
+   */
+  arlen = (...args) => new ArLenCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/armget
+   */
+  armget = (...args) => new ArMGetCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/armset
+   */
+  armset = (key, values) => new ArMSetCommand([key, values], this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arnext
+   */
+  arnext = (...args) => new ArNextCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arop
+   */
+  arop = (key, start, end, operation) => new ArOpCommand([key, start, end, operation], this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arring
+   */
+  arring = (key, size, ...values) => new ArRingCommand([key, size, ...values], this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arscan
+   */
+  arscan = (...args) => new ArScanCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arseek
+   */
+  arseek = (...args) => new ArSeekCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://upstash.com/docs/redis/commands/array/arset
+   */
+  arset = (key, index, ...values) => new ArSetCommand([key, index, ...values], this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/bitcount
    */
@@ -5430,12 +6035,13 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.38.4";
+var VERSION = "v1.39.0";
 
 export {
   error_exports,
   HttpClient,
   SearchIndex,
+  VectorIndex,
   Redis,
   VERSION
 };