@upstash/redis 1.40.0 → 1.41.0

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

@@ -0,0 +1,275 @@
+import type {
+  DescribeFieldInfo,
+  DetailedField,
+  FlatIndexSchema,
+  IndexDescription,
+  Language,
+  QueryOptions,
+  QueryResult,
+} from "./types";
+import { FIELD_TYPES, type FieldType, type NestedIndexSchema } from "./types";
+
+type FlattenedField = {
+  path: string;
+  type: FieldType;
+  fast?: boolean;
+  noTokenize?: boolean;
+  noStem?: boolean;
+  from?: string;
+};
+
+function isFieldType(value: any): value is FieldType {
+  return typeof value === "string" && (FIELD_TYPES as readonly string[]).includes(value);
+}
+
+function isDetailedField(value: any): value is DetailedField {
+  return typeof value === "object" && value !== null && "type" in value && isFieldType(value.type);
+}
+
+function isNestedSchema(value: any): value is NestedIndexSchema {
+  return typeof value === "object" && value !== null && !isDetailedField(value);
+}
+
+export function flattenSchema(
+  schema: NestedIndexSchema | FlatIndexSchema,
+  pathPrefix: string[] = []
+): FlattenedField[] {
+  const fields: FlattenedField[] = [];
+
+  for (const [key, value] of Object.entries(schema)) {
+    const currentPath = [...pathPrefix, key];
+    const pathString = currentPath.join(".");
+
+    if (isFieldType(value)) {
+      fields.push({
+        path: pathString,
+        type: value,
+      });
+    } else if (isDetailedField(value)) {
+      fields.push({
+        path: pathString,
+        type: value.type as FieldType,
+        fast: "fast" in value ? value.fast : undefined,
+        noTokenize: "noTokenize" in value ? value.noTokenize : undefined,
+        noStem: "noStem" in value ? value.noStem : undefined,
+        from: "from" in value ? value.from : undefined,
+      });
+    } else if (isNestedSchema(value)) {
+      const nestedFields = flattenSchema(value, currentPath);
+      fields.push(...nestedFields);
+    }
+  }
+
+  return fields;
+}
+
+export function deserializeQueryResponse<
+  TSchema extends NestedIndexSchema | FlatIndexSchema = any,
+  TOptions extends QueryOptions<TSchema> | undefined = any,
+>(rawResponse: unknown[]): QueryResult<TSchema, TOptions>[] {
+  return rawResponse.map((itemRaw) => {
+    const raw = itemRaw as [string, string, unknown[]?];
+    const key = raw[0];
+    const score = Number(raw[1]);
+    const rawFields = raw[2];
+
+    if (rawFields === undefined) {
+      return { key, score } as QueryResult<TSchema, TOptions>;
+    }
+
+    if (!Array.isArray(rawFields) || rawFields.length === 0) {
+      return { key, score, data: {} } as QueryResult<TSchema, TOptions>;
+    }
+
+    // Merge all field objects into a single object
+    let data: Record<string, unknown> = {};
+
+    for (const fieldRaw of rawFields as [string, unknown][]) {
+      const key = fieldRaw[0];
+      const value = fieldRaw[1];
+
+      const pathParts = key.split(".");
+      if (pathParts.length === 1) {
+        data[key] = value;
+      } else {
+        let currentObj = data;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+          const pathPart = pathParts[i];
+          if (!(pathPart in currentObj)) {
+            currentObj[pathPart] = {};
+          }
+
+          currentObj = currentObj[pathPart] as Record<string, unknown>;
+        }
+
+        currentObj[pathParts.at(-1)!] = value;
+      }
+    }
+
+    // If $ key exists (full document), use its contents directly
+    if ("$" in data) {
+      data = data["$"] as Record<string, unknown>;
+    }
+
+    return { key, score, data } as QueryResult<TSchema, TOptions>;
+  });
+}
+
+export function deserializeDescribeResponse<TSchema extends NestedIndexSchema | FlatIndexSchema>(
+  rawResponse: unknown[]
+): IndexDescription<TSchema> {
+  const description = {} as IndexDescription<TSchema>;
+
+  for (let i = 0; i < rawResponse.length; i += 2) {
+    const descriptor = rawResponse[i] as string;
+    switch (descriptor) {
+      case "name": {
+        description["name"] = rawResponse[i + 1] as string;
+        break;
+      }
+      case "type": {
+        description["dataType"] = (
+          rawResponse[i + 1] as string
+        ).toLowerCase() as IndexDescription<TSchema>["dataType"];
+        break;
+      }
+      case "prefixes": {
+        description["prefixes"] = rawResponse[i + 1] as string[];
+        break;
+      }
+      case "language": {
+        description["language"] = rawResponse[i + 1] as Language;
+        break;
+      }
+      case "schema": {
+        const schema: Record<string, DescribeFieldInfo> = {};
+        for (const fieldDescription of rawResponse[i + 1] as string[][]) {
+          const fieldName = fieldDescription[0];
+          const fieldInfo: DescribeFieldInfo = { type: fieldDescription[1] as FieldType };
+
+          if (fieldDescription.length > 2) {
+            for (let j = 2; j < fieldDescription.length; j++) {
+              const fieldOption = fieldDescription[j];
+              switch (fieldOption) {
+                case "NOSTEM": {
+                  fieldInfo.noStem = true;
+                  break;
+                }
+                case "NOTOKENIZE": {
+                  fieldInfo.noTokenize = true;
+                  break;
+                }
+                case "FAST": {
+                  fieldInfo.fast = true;
+                  break;
+                }
+                case "FROM": {
+                  fieldInfo.from = fieldDescription[++j];
+                  break;
+                }
+              }
+            }
+          }
+
+          schema[fieldName] = fieldInfo;
+        }
+        description["schema"] = schema;
+        break;
+      }
+    }
+  }
+
+  return description;
+}
+
+export function parseCountResponse(rawResponse: any): number {
+  return typeof rawResponse === "number" ? rawResponse : Number.parseInt(rawResponse, 10);
+}
+
+export function deserializeAggregateResponse(rawResponse: any[]): any {
+  // Response is a flat key-value array: [key, val, key, val, ...]
+  return parseAggregationArray(rawResponse);
+}
+
+function parseAggregationArray(arr: any[]): any {
+  const result: any = {};
+
+  for (let i = 0; i < arr.length; i += 2) {
+    const key = arr[i];
+    const value = arr[i + 1];
+
+    if (Array.isArray(value)) {
+      // Check if it's a stats-like array or buckets array
+      if (value.length > 0 && typeof value[0] === "string") {
+        // Stats or buckets format
+        result[key] = value[0] === "buckets" ? parseBucketsValue(value) : parseStatsValue(value);
+      } else {
+        // Nested aggregation
+        result[key] = parseAggregationArray(value);
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+function coerceNumericString(value: any): any {
+  if (typeof value === "string" && value !== "" && !Number.isNaN(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
+
+function parseStatsValue(arr: any[]): any {
+  const result: any = {};
+  for (let i = 0; i < arr.length; i += 2) {
+    const key = arr[i];
+    const value = arr[i + 1];
+
+    if (Array.isArray(value) && value.length > 0) {
+      // Check if it's a single array following key-value format
+      if (typeof value[0] === "string") {
+        result[key] = parseStatsValue(value);
+      }
+      // Check if it's an array of arrays (like percentiles unkeyed format)
+      else if (Array.isArray(value[0]) && typeof value[0][0] === "string") {
+        result[key] = value.map((item: any[]) => parseStatsValue(item));
+      }
+      // Otherwise keep as-is
+      else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = coerceNumericString(value);
+    }
+  }
+  return result;
+}
+
+function parseBucketsValue(arr: any[]): any {
+  // Format: ["buckets", [bucket1_array, bucket2_array, ...], extraKey, extraVal, ...]
+  if (arr[0] === "buckets" && Array.isArray(arr[1])) {
+    const result: any = {
+      buckets: arr[1].map((bucket: any[]) => {
+        const bucketObj: any = {};
+        for (let i = 0; i < bucket.length; i += 2) {
+          const key = bucket[i];
+          const value = bucket[i + 1];
+          bucketObj[key] =
+            Array.isArray(value) && value.length > 0 && typeof value[0] === "string"
+              ? parseStatsValue(value)
+              : value;
+        }
+        return bucketObj;
+      }),
+    };
+    // Parse remaining key-value pairs (e.g. sumOtherDocCount, docCountErrorUpperBound)
+    for (let i = 2; i < arr.length; i += 2) {
+      result[arr[i]] = arr[i + 1];
+    }
+    return result;
+  }
+  return arr;
+}

package/src/pkg/commands/set.ts

@@ -0,0 +1,52 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+
+export type SetCommandOptions = { get?: boolean } & (
+  | { ex: number; px?: never; exat?: never; pxat?: never; keepTtl?: never }
+  | { ex?: never; px: number; exat?: never; pxat?: never; keepTtl?: never }
+  | { ex?: never; px?: never; exat: number; pxat?: never; keepTtl?: never }
+  | { ex?: never; px?: never; exat?: never; pxat: number; keepTtl?: never }
+  | { ex?: never; px?: never; exat?: never; pxat?: never; keepTtl: true }
+  | { ex?: never; px?: never; exat?: never; pxat?: never; keepTtl?: never }
+) &
+  ({ nx: true; xx?: never } | { xx: true; nx?: never } | { xx?: never; nx?: never });
+
+/**
+ * @see https://redis.io/commands/set
+ * @see node_modules/@upstash/redis/docs/commands/string/set.mdx
+ */
+export class SetCommand<TData, TResult = TData | "OK" | null> extends Command<
+  TResult,
+  TData | "OK" | null
+> {
+  constructor(
+    [key, value, opts]: [key: string, value: TData, opts?: SetCommandOptions],
+    cmdOpts?: CommandOptions<TResult, TData>
+  ) {
+    const command: unknown[] = ["set", key, value];
+    if (opts) {
+      if ("nx" in opts && opts.nx) {
+        command.push("nx");
+      } else if ("xx" in opts && opts.xx) {
+        command.push("xx");
+      }
+
+      if ("get" in opts && opts.get) {
+        command.push("get");
+      }
+
+      if ("ex" in opts && typeof opts.ex === "number") {
+        command.push("ex", opts.ex);
+      } else if ("px" in opts && typeof opts.px === "number") {
+        command.push("px", opts.px);
+      } else if ("exat" in opts && typeof opts.exat === "number") {
+        command.push("exat", opts.exat);
+      } else if ("pxat" in opts && typeof opts.pxat === "number") {
+        command.push("pxat", opts.pxat);
+      } else if ("keepTtl" in opts && opts.keepTtl) {
+        command.push("keepTtl");
+      }
+    }
+    super(command, cmdOpts);
+  }
+}

package/src/pkg/commands/setbit.ts

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

package/src/pkg/commands/setex.ts

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

package/src/pkg/commands/setnx.ts

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

package/src/pkg/commands/setrange.ts

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

package/src/pkg/commands/sinter.ts

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

package/src/pkg/commands/sintercard.ts

@@ -0,0 +1,19 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/sintercard
+ */
+export class SInterCardCommand extends Command<number, number> {
+  constructor(
+    cmd: [keys: string[], opts?: { limit?: number }],
+    cmdOpts?: CommandOptions<number, number>
+  ) {
+    const [keys, opts] = cmd;
+
+    const command: unknown[] = ["sintercard", keys.length, ...keys];
+    if (opts?.limit !== undefined) {
+      command.push("LIMIT", opts.limit);
+    }
+    super(command, cmdOpts);
+  }
+}

package/src/pkg/commands/sinterstore.ts

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

package/src/pkg/commands/sismember.ts

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

package/src/pkg/commands/smembers.ts

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

package/src/pkg/commands/smismember.ts

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

package/src/pkg/commands/smove.ts

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

package/src/pkg/commands/spop.ts

@@ -0,0 +1,18 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/spop
+ * @see node_modules/@upstash/redis/docs/commands/set/spop.mdx
+ */
+export class SPopCommand<TData> extends Command<string | string[] | null, TData | null> {
+  constructor(
+    [key, count]: [key: string, count?: number],
+    opts?: CommandOptions<string | string[] | null, TData | null>
+  ) {
+    const command: unknown[] = ["spop", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+}

package/src/pkg/commands/srandmember.ts

@@ -0,0 +1,18 @@
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+/**
+ * @see https://redis.io/commands/srandmember
+ * @see node_modules/@upstash/redis/docs/commands/set/srandmember.mdx
+ */
+export class SRandMemberCommand<TData> extends Command<string | null, TData | null> {
+  constructor(
+    [key, count]: [key: string, count?: number],
+    opts?: CommandOptions<string | null, TData | null>
+  ) {
+    const command: unknown[] = ["srandmember", key];
+    if (typeof count === "number") {
+      command.push(count);
+    }
+    super(command, opts);
+  }
+}

package/src/pkg/commands/srem.ts

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

package/src/pkg/commands/sscan.ts

@@ -0,0 +1,31 @@
+import { deserializeScanResponse } from "../util";
+import type { CommandOptions } from "./command";
+import { Command } from "./command";
+import type { ScanCommandOptions } from "./scan";
+
+/**
+ * @see https://redis.io/commands/sscan
+ * @see node_modules/@upstash/redis/docs/commands/set/sscan.mdx
+ */
+export class SScanCommand extends Command<
+  [string, (string | number)[]],
+  [string, (string | number)[]]
+> {
+  constructor(
+    [key, cursor, opts]: [key: string, cursor: string | number, opts?: ScanCommandOptions],
+    cmdOpts?: CommandOptions<[string, (string | number)[]], [string, (string | number)[]]>
+  ) {
+    const command: (number | string)[] = ["sscan", key, cursor];
+    if (opts?.match) {
+      command.push("match", opts.match);
+    }
+    if (typeof opts?.count === "number") {
+      command.push("count", opts.count);
+    }
+
+    super(command, {
+      deserialize: deserializeScanResponse,
+      ...cmdOpts,
+    });
+  }
+}

package/src/pkg/commands/strlen.ts

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