@upstash/redis 1.40.0 → 1.41.0

package/src/pkg/commands/msetnx.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/msetnx
+ * @see node_modules/@upstash/redis/docs/commands/string/msetnx.mdx
+ */
+export class MSetNXCommand<TData = string> extends Command<number, number> {
+  constructor([kv]: [kv: Record<string, TData>], opts?: CommandOptions<number, number>) {
+    super(["msetnx", ...Object.entries(kv).flat()], opts);
+  }
+}

package/src/pkg/commands/persist.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/persist
+ * @see node_modules/@upstash/redis/docs/commands/generic/persist.mdx
+ */
+export class PersistCommand extends Command<"0" | "1", 0 | 1> {
+  constructor(cmd: [key: string], opts?: CommandOptions<"0" | "1", 0 | 1>) {
+    super(["persist", ...cmd], opts);
+  }
+}

package/src/pkg/commands/pexpire.ts

@@ -0,0 +1,16 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+import type { ExpireOption } from "./expire";
+
+/**
+ * @see https://redis.io/commands/pexpire
+ * @see node_modules/@upstash/redis/docs/commands/generic/pexpire.mdx
+ */
+export class PExpireCommand extends Command<"0" | "1", 0 | 1> {
+  constructor(
+    cmd: [key: string, milliseconds: number, option?: ExpireOption],
+    opts?: CommandOptions<"0" | "1", 0 | 1>
+  ) {
+    super(["pexpire", ...cmd], opts);
+  }
+}

package/src/pkg/commands/pexpireat.ts

@@ -0,0 +1,16 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+import type { ExpireOption } from "./expire";
+
+/**
+ * @see https://redis.io/commands/pexpireat
+ * @see node_modules/@upstash/redis/docs/commands/generic/pexpireat.mdx
+ */
+export class PExpireAtCommand extends Command<"0" | "1", 0 | 1> {
+  constructor(
+    cmd: [key: string, unix: number, option?: ExpireOption],
+    opts?: CommandOptions<"0" | "1", 0 | 1>
+  ) {
+    super(["pexpireat", ...cmd], opts);
+  }
+}

package/src/pkg/commands/pfadd.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+/**
+ * @see https://redis.io/commands/pfadd
+ */
+export class PfAddCommand<TData = string> extends Command<number, number> {
+  constructor(cmd: [string, ...TData[]], opts?: CommandOptions<number, number>) {
+    super(["pfadd", ...cmd], opts);
+  }
+}

package/src/pkg/commands/pfcount.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+/**
+ * @see https://redis.io/commands/pfcount
+ */
+export class PfCountCommand extends Command<number, number> {
+  constructor(cmd: [string, ...string[]], opts?: CommandOptions<number, number>) {
+    super(["pfcount", ...cmd], opts);
+  }
+}

package/src/pkg/commands/pfmerge.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command.ts";
+import { Command } from "./command.ts";
+
+/**
+ * @see https://redis.io/commands/pfmerge
+ */
+export class PfMergeCommand extends Command<"OK", "OK"> {
+  constructor(cmd: [destination_key: string, ...string[]], opts?: CommandOptions<"OK", "OK">) {
+    super(["pfmerge", ...cmd], opts);
+  }
+}

package/src/pkg/commands/ping.ts

@@ -0,0 +1,15 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/ping
+ * @see node_modules/@upstash/redis/docs/commands/auth/ping.mdx
+ */
+export class PingCommand extends Command<string | "PONG", string | "PONG"> {
+  constructor(cmd?: [message?: string], opts?: CommandOptions<string | "PONG", string | "PONG">) {
+    const command: string[] = ["ping"];
+    if (cmd?.[0] !== undefined) {
+      command.push(cmd[0]);
+    }
+    super(command, opts);
+  }
+}

package/src/pkg/commands/psetex.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/psetex
+ */
+export class PSetEXCommand<TData = string> extends Command<string, string> {
+  constructor(
+    cmd: [key: string, ttl: number, value: TData],
+    opts?: CommandOptions<string, string>
+  ) {
+    super(["psetex", ...cmd], opts);
+  }
+}

package/src/pkg/commands/psubscribe.ts

@@ -0,0 +1,26 @@
+import { Command, type CommandOptions } from "./command";
+
+/**
+ * @see https://redis.io/commands/psubscribe
+ * @see node_modules/@upstash/redis/docs/commands/pubsub/psubscribe.mdx
+ */
+export class PSubscribeCommand extends Command<number, number> {
+  constructor(cmd: [...patterns: string[]], opts?: CommandOptions<number, number>) {
+    const sseHeaders = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    };
+
+    super([], {
+      ...opts,
+      headers: sseHeaders,
+      path: ["psubscribe", ...cmd],
+      streamOptions: {
+        isStreaming: true,
+        onMessage: opts?.streamOptions?.onMessage,
+        signal: opts?.streamOptions?.signal,
+      },
+    });
+  }
+}

package/src/pkg/commands/pttl.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/pttl
+ * @see node_modules/@upstash/redis/docs/commands/generic/pttl.mdx
+ */
+export class PTtlCommand extends Command<number, number> {
+  constructor(cmd: [key: string], opts?: CommandOptions<number, number>) {
+    super(["pttl", ...cmd], opts);
+  }
+}

package/src/pkg/commands/publish.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/publish
+ * @see node_modules/@upstash/redis/docs/commands/pubsub/publish.mdx
+ */
+export class PublishCommand<TMessage = unknown> extends Command<number, number> {
+  constructor(cmd: [channel: string, message: TMessage], opts?: CommandOptions<number, number>) {
+    super(["publish", ...cmd], opts);
+  }
+}

package/src/pkg/commands/randomkey.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/randomkey
+ * @see node_modules/@upstash/redis/docs/commands/generic/randomkey.mdx
+ */
+export class RandomKeyCommand extends Command<string | null, string | null> {
+  constructor(opts?: CommandOptions<string | null, string | null>) {
+    super(["randomkey"], opts);
+  }
+}

package/src/pkg/commands/rename.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/rename
+ * @see node_modules/@upstash/redis/docs/commands/generic/rename.mdx
+ */
+export class RenameCommand extends Command<"OK", "OK"> {
+  constructor(cmd: [source: string, destination: string], opts?: CommandOptions<"OK", "OK">) {
+    super(["rename", ...cmd], opts);
+  }
+}

package/src/pkg/commands/renamenx.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/renamenx
+ * @see node_modules/@upstash/redis/docs/commands/generic/renamenx.mdx
+ */
+export class RenameNXCommand extends Command<"0" | "1", 0 | 1> {
+  constructor(cmd: [source: string, destination: string], opts?: CommandOptions<"0" | "1", 0 | 1>) {
+    super(["renamenx", ...cmd], opts);
+  }
+}

package/src/pkg/commands/rpop.ts

@@ -0,0 +1,21 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/rpop
+ * @see node_modules/@upstash/redis/docs/commands/list/rpop.mdx
+ * Responses are JSON-parsed automatically: a stored "123" comes back as the number 123, "true" as
+ * true, and '{"a":1}' as an object. Pass automaticDeserialization: false to the Redis constructor
+ * to receive raw strings.
+ */
+export class RPopCommand<TData extends unknown | unknown[] = string> extends Command<
+  unknown | null,
+  TData | null
+> {
+  constructor(
+    cmd: [key: string, count?: number],
+    opts?: CommandOptions<unknown | null, TData | null>
+  ) {
+    super(["rpop", ...cmd], opts);
+  }
+}

package/src/pkg/commands/rpush.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/rpush
+ * @see node_modules/@upstash/redis/docs/commands/list/rpush.mdx
+ */
+export class RPushCommand<TData = string> extends Command<number, number> {
+  constructor(cmd: [key: string, ...elements: TData[]], opts?: CommandOptions<number, number>) {
+    super(["rpush", ...cmd], opts);
+  }
+}

package/src/pkg/commands/rpushx.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/rpushx
+ * @see node_modules/@upstash/redis/docs/commands/list/rpushx.mdx
+ */
+export class RPushXCommand<TData = string> extends Command<number, number> {
+  constructor(cmd: [key: string, ...elements: TData[]], opts?: CommandOptions<number, number>) {
+    super(["rpushx", ...cmd], opts);
+  }
+}

package/src/pkg/commands/sadd.ts

@@ -0,0 +1,15 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/sadd
+ * @see node_modules/@upstash/redis/docs/commands/set/sadd.mdx
+ */
+export class SAddCommand<TData = string> extends Command<number, number> {
+  constructor(
+    cmd: [key: string, member: TData, ...members: TData[]],
+    opts?: CommandOptions<number, number>
+  ) {
+    super(["sadd", ...cmd], opts);
+  }
+}

package/src/pkg/commands/scan.ts

@@ -0,0 +1,63 @@
+import { deserializeScanResponse, deserializeScanWithTypesResponse } from "../util";
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type ScanCommandOptionsStandard = {
+  match?: string;
+  count?: number;
+  type?: string;
+  withType?: false;
+};
+
+export type ScanCommandOptionsWithType = {
+  match?: string;
+  count?: number;
+  /**
+   * Includes types of each key in the result
+   *
+   * @example
+   * ```typescript
+   * await redis.scan("0", { withType: true })
+   * // ["0", [{ key: "key1", type: "string" }, { key: "key2", type: "list" }]]
+   * ```
+   */
+  withType: true;
+};
+
+export type ScanCommandOptions = ScanCommandOptionsStandard | ScanCommandOptionsWithType;
+
+export type ScanResultStandard = [string, string[]];
+
+export type ScanResultWithType = [string, { key: string; type: string }[]];
+
+/**
+ * @see https://redis.io/commands/scan
+ * @see node_modules/@upstash/redis/docs/commands/generic/scan.mdx
+ */
+export class ScanCommand<TData = ScanResultStandard> extends Command<[string, string[]], TData> {
+  constructor(
+    [cursor, opts]: [cursor: string | number, opts?: ScanCommandOptions],
+    cmdOpts?: CommandOptions<[string, string[]], TData>
+  ) {
+    const command: (number | string)[] = ["scan", cursor];
+    if (opts?.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count);
+    }
+
+    // Handle type and withType options
+    if (opts && "withType" in opts && opts.withType === true) {
+      command.push("withtype");
+    } else if (opts && "type" in opts && opts.type && opts.type.length > 0) {
+      command.push("type", opts.type);
+    }
+
+    super(command, {
+      // @ts-expect-error ignore types here
+      deserialize: opts?.withType ? deserializeScanWithTypesResponse : deserializeScanResponse,
+      ...cmdOpts,
+    });
+  }
+}

package/src/pkg/commands/scard.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/scard
+ * @see node_modules/@upstash/redis/docs/commands/set/scard.mdx
+ */
+export class SCardCommand extends Command<number, number> {
+  constructor(cmd: [key: string], opts?: CommandOptions<number, number>) {
+    super(["scard", ...cmd], opts);
+  }
+}

package/src/pkg/commands/script_exists.ts

@@ -0,0 +1,15 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/script-exists
+ * @see node_modules/@upstash/redis/docs/commands/scripts/script_exists.mdx
+ */
+export class ScriptExistsCommand<T extends string[]> extends Command<string[], number[]> {
+  constructor(hashes: T, opts?: CommandOptions<string[], number[]>) {
+    super(["script", "exists", ...hashes], {
+      deserialize: (result) => result as unknown as number[],
+      ...opts,
+    });
+  }
+}

package/src/pkg/commands/script_flush.ts

@@ -0,0 +1,22 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type ScriptFlushCommandOptions =
+  | { sync: true; async?: never }
+  | { sync?: never; async: true };
+
+/**
+ * @see https://redis.io/commands/script-flush
+ * @see node_modules/@upstash/redis/docs/commands/scripts/script_flush.mdx
+ */
+export class ScriptFlushCommand extends Command<"OK", "OK"> {
+  constructor([opts]: [opts?: ScriptFlushCommandOptions], cmdOpts?: CommandOptions<"OK", "OK">) {
+    const cmd = ["script", "flush"];
+    if (opts?.sync) {
+      cmd.push("sync");
+    } else if (opts?.async) {
+      cmd.push("async");
+    }
+    super(cmd, cmdOpts);
+  }
+}

package/src/pkg/commands/script_load.ts

@@ -0,0 +1,12 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+/**
+ * @see https://redis.io/commands/script-load
+ * @see node_modules/@upstash/redis/docs/commands/scripts/script_load.mdx
+ */
+export class ScriptLoadCommand extends Command<string, string> {
+  constructor(args: [script: string], opts?: CommandOptions<string, string>) {
+    super(["script", "load", ...args], opts);
+  }
+}

package/src/pkg/commands/sdiff.ts

@@ -0,0 +1,11 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/sdiff
+ * @see node_modules/@upstash/redis/docs/commands/set/sdiff.mdx
+ */
+export class SDiffCommand<TData> extends Command<unknown[], TData[]> {
+  constructor(cmd: [key: string, ...keys: string[]], opts?: CommandOptions<unknown[], TData[]>) {
+    super(["sdiff", ...cmd], opts);
+  }
+}

package/src/pkg/commands/sdiffstore.ts

@@ -0,0 +1,14 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/sdiffstore
+ * @see node_modules/@upstash/redis/docs/commands/set/sdiffstore.mdx
+ */
+export class SDiffStoreCommand extends Command<number, number> {
+  constructor(
+    cmd: [destination: string, ...keys: string[]],
+    opts?: CommandOptions<number, number>
+  ) {
+    super(["sdiffstore", ...cmd], opts);
+  }
+}

package/src/pkg/commands/search/command-builder.ts

@@ -0,0 +1,162 @@
+import { flattenSchema } from "./utils";
+import type { CreateIndexParameters } from "./search";
+import type { NestedIndexSchema, FlatIndexSchema, QueryOptions, ScoreBy } from "./types";
+
+export function buildQueryCommand<TSchema extends NestedIndexSchema | FlatIndexSchema>(
+  redisCommand: "SEARCH.QUERY" | "SEARCH.COUNT",
+  name: string,
+  options?: QueryOptions<TSchema>
+): string[] {
+  const query = JSON.stringify(options?.filter ?? {});
+  const command: string[] = [redisCommand, name, query];
+
+  if (options?.limit !== undefined) {
+    command.push("LIMIT", options.limit.toString());
+  }
+
+  if (options?.offset !== undefined) {
+    command.push("OFFSET", options.offset.toString());
+  }
+
+  if (options?.select && Object.keys(options.select).length === 0) {
+    command.push("NOCONTENT");
+  }
+
+  if (options) {
+    if ("orderBy" in options && options.orderBy) {
+      command.push("ORDERBY");
+      for (const [field, direction] of Object.entries(options.orderBy)) {
+        command.push(field, direction as "ASC" | "DESC");
+      }
+    } else if ("scoreFunc" in options && options.scoreFunc) {
+      command.push("SCOREFUNC", ...buildScoreFunc(options.scoreFunc));
+    }
+  }
+
+  if (options?.highlight) {
+    command.push(
+      "HIGHLIGHT",
+      "FIELDS",
+      options.highlight.fields.length.toString(),
+      ...options.highlight.fields
+    );
+    if (options.highlight.preTag && options.highlight.postTag) {
+      command.push("TAGS", options.highlight.preTag, options.highlight.postTag);
+    }
+  }
+
+  if (options?.select && Object.keys(options.select).length > 0) {
+    command.push(
+      "SELECT",
+      Object.keys(options.select).length.toString(),
+      ...Object.keys(options.select)
+    );
+  }
+
+  return command;
+}
+
+function buildScoreFunc(scoreBy: ScoreBy<string>): string[] {
+  const result: string[] = [];
+
+  if (typeof scoreBy === "string") {
+    result.push("FIELDVALUE", scoreBy);
+  } else if ("fields" in scoreBy) {
+    if (scoreBy.combineMode) {
+      result.push("COMBINEMODE", scoreBy.combineMode.toUpperCase());
+    }
+    if (scoreBy.scoreMode) {
+      result.push("SCOREMODE", scoreBy.scoreMode.toUpperCase());
+    }
+
+    for (const field of scoreBy.fields) {
+      result.push(...buildScoreFuncField(field));
+    }
+  } else {
+    result.push(...buildScoreFuncField(scoreBy));
+  }
+  return result;
+}
+
+function buildScoreFuncField(
+  field:
+    | string
+    | { field: string; modifier?: string; factor?: number; missing?: number; scoreMode?: string }
+): string[] {
+  const result: string[] = [];
+
+  if (typeof field === "string") {
+    result.push("FIELDVALUE", field);
+  } else {
+    if (field.scoreMode) {
+      result.push("SCOREMODE", field.scoreMode.toUpperCase());
+    }
+    result.push("FIELDVALUE", field.field);
+    if (field.modifier) {
+      result.push("MODIFIER", field.modifier.toUpperCase());
+    }
+    if (field.factor !== undefined) {
+      result.push("FACTOR", field.factor.toString());
+    }
+    if (field.missing !== undefined) {
+      result.push("MISSING", field.missing.toString());
+    }
+  }
+  return result;
+}
+
+export function buildCreateIndexCommand<TSchema extends NestedIndexSchema | FlatIndexSchema>(
+  params: CreateIndexParameters<TSchema>
+): string[] {
+  const { name, schema, dataType, language, skipInitialScan, existsOk } = params;
+
+  let source: string[];
+  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: string[] = [
+    name,
+    ...(skipInitialScan ? ["SKIPINITIALSCAN"] : []),
+    ...(existsOk ? ["EXISTSOK"] : []),
+    ...source,
+    ...(language ? ["LANGUAGE", language] : []),
+    "SCHEMA",
+  ];
+
+  const fields = flattenSchema(schema);
+
+  for (const field of fields) {
+    payload.push(field.path, field.type);
+
+    if (field.fast) {
+      payload.push("FAST");
+    }
+    if (field.noTokenize) {
+      payload.push("NOTOKENIZE");
+    }
+    if (field.noStem) {
+      payload.push("NOSTEM");
+    }
+    if (field.from) {
+      payload.push("FROM", field.from);
+    }
+  }
+
+  return ["SEARCH.CREATE", ...payload];
+}
+
+export function buildAggregateCommand(name: string, options: any): string[] {
+  const query = JSON.stringify(options?.filter ?? {});
+  const aggregations = JSON.stringify(options.aggregations);
+  return ["SEARCH.AGGREGATE", name, query, aggregations];
+}

package/src/pkg/commands/search/index.ts

@@ -0,0 +1,4 @@
+export { SearchIndex } from "./search";
+export type { SearchIndexParameters, CreateIndexParameters, InferFilterFromSchema } from "./search";
+export { s } from "./schema-builder";
+export type { NestedIndexSchema, FlatIndexSchema, PublicQueryResult as QueryResult } from "./types";