@upstash/redis 1.36.0 → 1.37.0-rc

package/cloudflare.js

@@ -98,15 +98,6 @@ function mergeHeaders(...headers) {
   }
   return merged;
 }
-function kvArrayToObject(v) {
-  if (typeof v === "object" && v !== null && !Array.isArray(v)) return v;
-  if (!Array.isArray(v)) return {};
-  const obj = {};
-  for (let i = 0; i < v.length; i += 2) {
-    if (typeof v[i] === "string") obj[v[i]] = v[i + 1];
-  }
-  return obj;
-}
 
 // pkg/http.ts
 var HttpClient = class {
@@ -354,7 +345,7 @@ var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
   "zrange",
   "exec"
 ]);
-function createAutoPipelineProxy(_redis, namespace = "root") {
+function createAutoPipelineProxy(_redis, json) {
   const redis = _redis;
   if (!redis.autoPipelineExecutor) {
     redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
@@ -364,31 +355,29 @@ function createAutoPipelineProxy(_redis, namespace = "root") {
       if (command === "pipelineCounter") {
         return redis2.autoPipelineExecutor.pipelineCounter;
       }
-      if (namespace === "root" && command === "json") {
-        return createAutoPipelineProxy(redis2, "json");
-      }
-      if (namespace === "root" && command === "functions") {
-        return createAutoPipelineProxy(redis2, "functions");
+      if (command === "json") {
+        return createAutoPipelineProxy(redis2, true);
       }
-      if (namespace === "root") {
-        const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
-        const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
-        if (commandInRedisButNotPipeline || isCommandExcluded) {
-          return redis2[command];
-        }
+      const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
+      const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
+      if (commandInRedisButNotPipeline || isCommandExcluded) {
+        return redis2[command];
       }
-      const pipeline = redis2.autoPipelineExecutor.pipeline;
-      const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
-      const isFunction = typeof targetFunction === "function";
+      const isFunction = json ? typeof redis2.autoPipelineExecutor.pipeline.json[command] === "function" : typeof redis2.autoPipelineExecutor.pipeline[command] === "function";
       if (isFunction) {
         return (...args) => {
-          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline2) => {
-            const targetFunction2 = namespace === "json" ? pipeline2.json[command] : namespace === "functions" ? pipeline2.functions[command] : pipeline2[command];
-            targetFunction2(...args);
+          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline) => {
+            if (json) {
+              pipeline.json[command](
+                ...args
+              );
+            } else {
+              pipeline[command](...args);
+            }
           });
         };
       }
-      return targetFunction;
+      return redis2.autoPipelineExecutor.pipeline[command];
     }
   });
 }
@@ -681,23 +670,6 @@ var ExpireAtCommand = class extends Command {
   }
 };
 
-// pkg/commands/fcall.ts
-var FCallCommand = class extends Command {
-  constructor([functionName, keys, args], opts) {
-    super(["fcall", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []], opts);
-  }
-};
-
-// pkg/commands/fcall_ro.ts
-var FCallRoCommand = class extends Command {
-  constructor([functionName, keys, args], opts) {
-    super(
-      ["fcall_ro", functionName, ...keys ? [keys.length, ...keys] : [0], ...args ?? []],
-      opts
-    );
-  }
-};
-
 // pkg/commands/flushall.ts
 var FlushAllCommand = class extends Command {
   constructor(args, opts) {
@@ -720,85 +692,6 @@ var FlushDBCommand = class extends Command {
   }
 };
 
-// pkg/commands/function_delete.ts
-var FunctionDeleteCommand = class extends Command {
-  constructor([libraryName], opts) {
-    super(["function", "delete", libraryName], opts);
-  }
-};
-
-// pkg/commands/function_flush.ts
-var FunctionFlushCommand = class extends Command {
-  constructor(opts) {
-    super(["function", "flush"], opts);
-  }
-};
-
-// pkg/commands/function_list.ts
-var FunctionListCommand = class extends Command {
-  constructor([args], opts) {
-    const command = ["function", "list"];
-    if (args?.libraryName) {
-      command.push("libraryname", args.libraryName);
-    }
-    if (args?.withCode) {
-      command.push("withcode");
-    }
-    super(command, { deserialize, ...opts });
-  }
-};
-function deserialize(result) {
-  if (!Array.isArray(result)) return [];
-  return result.map((libRaw) => {
-    const lib = kvArrayToObject(libRaw);
-    const functionsParsed = lib.functions.map(
-      (fnRaw) => kvArrayToObject(fnRaw)
-    );
-    return {
-      libraryName: lib.library_name,
-      engine: lib.engine,
-      functions: functionsParsed.map((fn) => ({
-        name: fn.name,
-        description: fn.description ?? void 0,
-        flags: fn.flags
-      })),
-      libraryCode: lib.library_code
-    };
-  });
-}
-
-// pkg/commands/function_load.ts
-var FunctionLoadCommand = class extends Command {
-  constructor([args], opts) {
-    super(["function", "load", ...args.replace ? ["replace"] : [], args.code], opts);
-  }
-};
-
-// pkg/commands/function_stats.ts
-var FunctionStatsCommand = class extends Command {
-  constructor(opts) {
-    super(["function", "stats"], { deserialize: deserialize2, ...opts });
-  }
-};
-function deserialize2(result) {
-  const rawEngines = kvArrayToObject(kvArrayToObject(result).engines);
-  const parsedEngines = Object.fromEntries(
-    Object.entries(rawEngines).map(([key, value]) => [key, kvArrayToObject(value)])
-  );
-  const final = {
-    engines: Object.fromEntries(
-      Object.entries(parsedEngines).map(([key, value]) => [
-        key,
-        {
-          librariesCount: value.libraries_count,
-          functionsCount: value.functions_count
-        }
-      ])
-    )
-  };
-  return final;
-}
-
 // pkg/commands/geo_add.ts
 var GeoAddCommand = class extends Command {
   constructor([key, arg1, ...arg2], opts) {
@@ -1145,7 +1038,7 @@ var HGetCommand = class extends Command {
 };
 
 // pkg/commands/hgetall.ts
-function deserialize3(result) {
+function deserialize(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1165,7 +1058,7 @@ function deserialize3(result) {
 var HGetAllCommand = class extends Command {
   constructor(cmd, opts) {
     super(["hgetall", ...cmd], {
-      deserialize: (result) => deserialize3(result),
+      deserialize: (result) => deserialize(result),
       ...opts
     });
   }
@@ -1200,7 +1093,7 @@ var HLenCommand = class extends Command {
 };
 
 // pkg/commands/hmget.ts
-function deserialize4(fields, result) {
+function deserialize2(fields, result) {
   if (result.every((field) => field === null)) {
     return null;
   }
@@ -1217,7 +1110,7 @@ function deserialize4(fields, result) {
 var HMGetCommand = class extends Command {
   constructor([key, ...fields], opts) {
     super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize4(fields, result),
+      deserialize: (result) => deserialize2(fields, result),
       ...opts
     });
   }
@@ -1231,7 +1124,7 @@ var HMSetCommand = class extends Command {
 };
 
 // pkg/commands/hrandfield.ts
-function deserialize5(result) {
+function deserialize3(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1258,7 +1151,7 @@ var HRandFieldCommand = class extends Command {
     }
     super(command, {
       // @ts-expect-error to silence compiler
-      deserialize: cmd[2] ? (result) => deserialize5(result) : opts?.deserialize,
+      deserialize: cmd[2] ? (result) => deserialize3(result) : opts?.deserialize,
       ...opts
     });
   }
@@ -2228,7 +2121,7 @@ var XPendingCommand = class extends Command {
 };
 
 // pkg/commands/xrange.ts
-function deserialize6(result) {
+function deserialize4(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2257,7 +2150,7 @@ var XRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize6(result),
+      deserialize: (result) => deserialize4(result),
       ...opts
     });
   }
@@ -2320,12 +2213,12 @@ var XRevRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize7(result),
+      deserialize: (result) => deserialize5(result),
       ...opts
     });
   }
 };
-function deserialize7(result) {
+function deserialize5(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2595,6 +2488,265 @@ var ZUnionStoreCommand = class extends Command {
   }
 };
 
+// pkg/commands/search/types.ts
+var FIELD_TYPES = ["TEXT", "U64", "I64", "F64", "BOOL", "DATE"];
+
+// pkg/commands/search/utils.ts
+function isFieldType(value) {
+  return typeof value === "string" && FIELD_TYPES.includes(value);
+}
+function isDetailedField(value) {
+  return typeof value === "object" && value !== null && "type" in value && isFieldType(value.type);
+}
+function isNestedSchema(value) {
+  return typeof value === "object" && value !== null && !isDetailedField(value);
+}
+function flattenSchema(schema, pathPrefix = []) {
+  const fields = [];
+  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,
+        fast: "fast" in value ? value.fast : void 0,
+        noTokenize: "noTokenize" in value ? value.noTokenize : void 0,
+        noStem: "noStem" in value ? value.noStem : void 0,
+        from: "from" in value ? value.from : void 0
+      });
+    } else if (isNestedSchema(value)) {
+      const nestedFields = flattenSchema(value, currentPath);
+      fields.push(...nestedFields);
+    }
+  }
+  return fields;
+}
+function deserializeQueryResponse(rawResponse) {
+  return rawResponse.map((itemRaw) => {
+    const raw = itemRaw;
+    const key = raw[0];
+    const score = raw[1];
+    const rawFields = raw[2];
+    if (rawFields === void 0) {
+      return { key, score };
+    }
+    if (!Array.isArray(rawFields) || rawFields.length === 0) {
+      return { key, score, data: {} };
+    }
+    let data = {};
+    for (const fieldRaw of rawFields) {
+      const key2 = fieldRaw[0];
+      const value = fieldRaw[1];
+      const pathParts = key2.split(".");
+      if (pathParts.length == 1) {
+        data[key2] = 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];
+        }
+        currentObj[pathParts.at(-1)] = value;
+      }
+    }
+    if ("$" in data) {
+      data = data["$"];
+    }
+    return { key, score, data };
+  });
+}
+function deserializeDescribeResponse(rawResponse) {
+  const description = {};
+  for (let i = 0; i < rawResponse.length; i += 2) {
+    const descriptor = rawResponse[i];
+    switch (descriptor) {
+      case "name": {
+        description["name"] = rawResponse[i + 1];
+        break;
+      }
+      case "type": {
+        description["dataType"] = rawResponse[i + 1].toLowerCase();
+        break;
+      }
+      case "prefixes": {
+        description["prefixes"] = rawResponse[i + 1];
+        break;
+      }
+      case "language": {
+        description["language"] = rawResponse[i + 1];
+        break;
+      }
+      case "schema": {
+        const schema = {};
+        for (const fieldDescription of rawResponse[i + 1]) {
+          const fieldName = fieldDescription[0];
+          const fieldInfo = { type: fieldDescription[1] };
+          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;
+                }
+              }
+            }
+          }
+          schema[fieldName] = fieldInfo;
+        }
+        description["schema"] = schema;
+        break;
+      }
+    }
+  }
+  return description;
+}
+function parseCountResponse(rawResponse) {
+  return typeof rawResponse === "number" ? rawResponse : Number.parseInt(rawResponse, 10);
+}
+
+// pkg/commands/search/command-builder.ts
+function buildQueryCommand(redisCommand, name, options) {
+  const query = JSON.stringify(options?.filter ?? {});
+  const command = [redisCommand, name, query];
+  if (options?.limit !== void 0) {
+    command.push("LIMIT", options.limit.toString());
+  }
+  if (options?.offset !== void 0) {
+    command.push("OFFSET", options.offset.toString());
+  }
+  if (options?.select && Object.keys(options.select).length === 0) {
+    command.push("NOCONTENT");
+  }
+  if (options?.orderBy) {
+    command.push("SORTBY");
+    for (const [field, direction] of Object.entries(options.orderBy)) {
+      command.push(field, direction);
+    }
+  }
+  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(
+      "RETURN",
+      Object.keys(options.select).length.toString(),
+      ...Object.keys(options.select)
+    );
+  }
+  return command;
+}
+function buildCreateIndexCommand(params) {
+  const { name, schema, dataType, prefix, language, skipInitialScan, existsOk } = params;
+  const prefixArray = Array.isArray(prefix) ? prefix : [prefix];
+  const payload = [
+    name,
+    ...skipInitialScan ? ["SKIPINITIALSCAN"] : [],
+    ...existsOk ? ["EXISTSOK"] : [],
+    "ON",
+    dataType.toUpperCase(),
+    "PREFIX",
+    prefixArray.length.toString(),
+    ...prefixArray,
+    ...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];
+}
+
+// pkg/commands/search/search.ts
+var SearchIndex = class {
+  name;
+  schema;
+  client;
+  constructor({ name, schema, client }) {
+    this.name = name;
+    this.schema = schema;
+    this.client = client;
+  }
+  async waitIndexing() {
+    const command = ["SEARCH.WAITINDEXING", this.name];
+    await new ExecCommand(command).exec(this.client);
+  }
+  async describe() {
+    const command = ["SEARCH.DESCRIBE", this.name];
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return deserializeDescribeResponse(rawResult);
+  }
+  async query(options) {
+    const command = buildQueryCommand("SEARCH.QUERY", this.name, options);
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return deserializeQueryResponse(rawResult);
+  }
+  async count({ filter }) {
+    const command = buildQueryCommand("SEARCH.COUNT", this.name, { filter });
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    return { count: parseCountResponse(rawResult) };
+  }
+  async drop() {
+    const command = ["SEARCH.DROP", this.name];
+    const result = await new ExecCommand(command).exec(this.client);
+    return result;
+  }
+};
+async function createIndex(client, params) {
+  const { name, schema } = params;
+  const createIndexCommand = buildCreateIndexCommand(params);
+  await new ExecCommand(createIndexCommand).exec(client);
+  return initIndex(client, { name, schema });
+}
+function initIndex(client, params) {
+  const { name, schema } = params;
+  return new SearchIndex({ name, schema, client });
+}
+
 // pkg/commands/psubscribe.ts
 var PSubscribeCommand = class extends Command {
   constructor(cmd, opts) {
@@ -3620,38 +3772,6 @@ var Pipeline = class {
       type: (...args) => this.chain(new JsonTypeCommand(args, this.commandOptions))
     };
   }
-  get functions() {
-    return {
-      /**
-       * @see https://redis.io/docs/latest/commands/function-load/
-       */
-      load: (...args) => this.chain(new FunctionLoadCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-list/
-       */
-      list: (...args) => this.chain(new FunctionListCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-delete/
-       */
-      delete: (...args) => this.chain(new FunctionDeleteCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-flush/
-       */
-      flush: () => this.chain(new FunctionFlushCommand(this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-stats/
-       */
-      stats: () => this.chain(new FunctionStatsCommand(this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall/
-       */
-      call: (...args) => this.chain(new FCallCommand(args, this.commandOptions)),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall_ro/
-       */
-      callRo: (...args) => this.chain(new FCallRoCommand(args, this.commandOptions))
-    };
-  }
 };
 
 // pkg/script.ts
@@ -3913,40 +4033,6 @@ var Redis = class {
       type: (...args) => new JsonTypeCommand(args, this.opts).exec(this.client)
     };
   }
-  get functions() {
-    return {
-      /**
-       * @see https://redis.io/docs/latest/commands/function-load/
-       */
-      load: (...args) => new FunctionLoadCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-list/
-       */
-      list: (...args) => new FunctionListCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-delete/
-       */
-      delete: (...args) => new FunctionDeleteCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-flush/
-       */
-      flush: () => new FunctionFlushCommand(this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/function-stats/
-       *
-       * Note: `running_script` field is not supported and therefore not included in the type.
-       */
-      stats: () => new FunctionStatsCommand(this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall/
-       */
-      call: (...args) => new FCallCommand(args, this.opts).exec(this.client),
-      /**
-       * @see https://redis.io/docs/latest/commands/fcall_ro/
-       */
-      callRo: (...args) => new FCallRoCommand(args, this.opts).exec(this.client)
-    };
-  }
   /**
    * Wrap a new middleware around the HTTP client.
    */
@@ -3997,6 +4083,16 @@ var Redis = class {
   createScript(script, opts) {
     return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
   }
+  get search() {
+    return {
+      createIndex: (params) => {
+        return createIndex(this.client, params);
+      },
+      index: (params) => {
+        return initIndex(this.client, params);
+      }
+    };
+  }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
    *
@@ -4704,7 +4800,7 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.36.0";
+var VERSION = "v1.37.0-rc";
 
 // platforms/cloudflare.ts
 var Redis2 = class _Redis extends Redis {
@@ -4773,20 +4869,16 @@ var Redis2 = class _Redis extends Redis {
    * ```
    */
   static fromEnv(env, opts) {
-    const url = env?.UPSTASH_REDIS_REST_URL ?? // @ts-expect-error These will be defined by cloudflare
-    (typeof UPSTASH_REDIS_REST_URL === "string" ? (
-      // @ts-expect-error These will be defined by cloudflare
-      UPSTASH_REDIS_REST_URL
-    ) : void 0);
-    const token = env?.UPSTASH_REDIS_REST_TOKEN ?? // @ts-expect-error These will be defined by cloudflare
-    (typeof UPSTASH_REDIS_REST_TOKEN === "string" ? (
-      // @ts-expect-error These will be defined by cloudflare
-      UPSTASH_REDIS_REST_TOKEN
-    ) : void 0);
-    const messageInfo = !url && !token ? "Unable to find environment variables: `UPSTASH_REDIS_REST_URL` and `UPSTASH_REDIS_REST_TOKEN`" : url ? token ? void 0 : "Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`" : "Unable to find environment variable: `UPSTASH_REDIS_REST_URL`";
-    if (messageInfo) {
+    const url = env?.UPSTASH_REDIS_REST_URL ?? UPSTASH_REDIS_REST_URL;
+    const token = env?.UPSTASH_REDIS_REST_TOKEN ?? UPSTASH_REDIS_REST_TOKEN;
+    if (!url) {
+      console.warn(
+        "[Upstash Redis] Unable to find environment variable: `UPSTASH_REDIS_REST_URL`. Please add it via `wrangler secret put UPSTASH_REDIS_REST_URL`"
+      );
+    }
+    if (!token) {
       console.warn(
-        `[Upstash Redis] ${messageInfo}. Please add it via \`wrangler secret put ${url ? "UPSTASH_REDIS_REST_TOKEN" : "UPSTASH_REDIS_REST_URL"}\` and provide it as an argument to the \`Redis.fromEnv\` function`
+        "[Upstash Redis] Unable to find environment variable: `UPSTASH_REDIS_REST_TOKEN`. Please add it via `wrangler secret put UPSTASH_REDIS_REST_TOKEN`"
       );
     }
     return new _Redis({ ...opts, url, token }, env);