@upstash/redis 1.36.0-rc.4 → 1.36.0

package/fastly.js

@@ -98,6 +98,15 @@ 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 {
@@ -345,7 +354,7 @@ var EXCLUDE_COMMANDS = /* @__PURE__ */ new Set([
   "zrange",
   "exec"
 ]);
-function createAutoPipelineProxy(_redis, json) {
+function createAutoPipelineProxy(_redis, namespace = "root") {
   const redis = _redis;
   if (!redis.autoPipelineExecutor) {
     redis.autoPipelineExecutor = new AutoPipelineExecutor(redis);
@@ -355,29 +364,31 @@ function createAutoPipelineProxy(_redis, json) {
       if (command === "pipelineCounter") {
         return redis2.autoPipelineExecutor.pipelineCounter;
       }
-      if (command === "json") {
-        return createAutoPipelineProxy(redis2, true);
+      if (namespace === "root" && command === "json") {
+        return createAutoPipelineProxy(redis2, "json");
       }
-      const commandInRedisButNotPipeline = command in redis2 && !(command in redis2.autoPipelineExecutor.pipeline);
-      const isCommandExcluded = EXCLUDE_COMMANDS.has(command);
-      if (commandInRedisButNotPipeline || isCommandExcluded) {
-        return redis2[command];
+      if (namespace === "root" && command === "functions") {
+        return createAutoPipelineProxy(redis2, "functions");
       }
-      const isFunction = json ? typeof redis2.autoPipelineExecutor.pipeline.json[command] === "function" : typeof redis2.autoPipelineExecutor.pipeline[command] === "function";
+      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 pipeline = redis2.autoPipelineExecutor.pipeline;
+      const targetFunction = namespace === "json" ? pipeline.json[command] : namespace === "functions" ? pipeline.functions[command] : pipeline[command];
+      const isFunction = typeof targetFunction === "function";
       if (isFunction) {
         return (...args) => {
-          return redis2.autoPipelineExecutor.withAutoPipeline((pipeline) => {
-            if (json) {
-              pipeline.json[command](
-                ...args
-              );
-            } else {
-              pipeline[command](...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.pipeline[command];
+      return targetFunction;
     }
   });
 }
@@ -400,7 +411,7 @@ var AutoPipelineExecutor = class {
       this.activePipeline = pipeline;
       this.indexInCurrentPipeline = 0;
     }
-    const index2 = this.indexInCurrentPipeline++;
+    const index = this.indexInCurrentPipeline++;
     executeWithPipeline(pipeline);
     const pipelineDone = this.deferExecution().then(() => {
       if (!this.pipelinePromises.has(pipeline)) {
@@ -412,7 +423,7 @@ var AutoPipelineExecutor = class {
       return this.pipelinePromises.get(pipeline);
     });
     const results = await pipelineDone;
-    const commandResult = results[index2];
+    const commandResult = results[index];
     if (commandResult.error) {
       throw new UpstashError(`Command failed: ${commandResult.error}`);
     }
@@ -670,6 +681,23 @@ 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) {
@@ -692,6 +720,85 @@ 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) {
@@ -1038,7 +1145,7 @@ var HGetCommand = class extends Command {
 };
 
 // pkg/commands/hgetall.ts
-function deserialize(result) {
+function deserialize3(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1058,7 +1165,7 @@ function deserialize(result) {
 var HGetAllCommand = class extends Command {
   constructor(cmd, opts) {
     super(["hgetall", ...cmd], {
-      deserialize: (result) => deserialize(result),
+      deserialize: (result) => deserialize3(result),
       ...opts
     });
   }
@@ -1093,7 +1200,7 @@ var HLenCommand = class extends Command {
 };
 
 // pkg/commands/hmget.ts
-function deserialize2(fields, result) {
+function deserialize4(fields, result) {
   if (result.every((field) => field === null)) {
     return null;
   }
@@ -1110,7 +1217,7 @@ function deserialize2(fields, result) {
 var HMGetCommand = class extends Command {
   constructor([key, ...fields], opts) {
     super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize2(fields, result),
+      deserialize: (result) => deserialize4(fields, result),
       ...opts
     });
   }
@@ -1124,7 +1231,7 @@ var HMSetCommand = class extends Command {
 };
 
 // pkg/commands/hrandfield.ts
-function deserialize3(result) {
+function deserialize5(result) {
   if (result.length === 0) {
     return null;
   }
@@ -1151,7 +1258,7 @@ var HRandFieldCommand = class extends Command {
     }
     super(command, {
       // @ts-expect-error to silence compiler
-      deserialize: cmd[2] ? (result) => deserialize3(result) : opts?.deserialize,
+      deserialize: cmd[2] ? (result) => deserialize5(result) : opts?.deserialize,
       ...opts
     });
   }
@@ -2121,7 +2228,7 @@ var XPendingCommand = class extends Command {
 };
 
 // pkg/commands/xrange.ts
-function deserialize4(result) {
+function deserialize6(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2150,7 +2257,7 @@ var XRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize4(result),
+      deserialize: (result) => deserialize6(result),
       ...opts
     });
   }
@@ -2213,12 +2320,12 @@ var XRevRangeCommand = class extends Command {
       command.push("COUNT", count);
     }
     super(command, {
-      deserialize: (result) => deserialize5(result),
+      deserialize: (result) => deserialize7(result),
       ...opts
     });
   }
 };
-function deserialize5(result) {
+function deserialize7(result) {
   const obj = {};
   for (const e of result) {
     for (let i = 0; i < e.length; i += 2) {
@@ -2488,327 +2595,6 @@ 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
-      });
-    } else if (isNestedSchema(value)) {
-      const nestedFields = flattenSchema(value, currentPath);
-      fields.push(...nestedFields);
-    }
-  }
-  return fields;
-}
-function deserializeQueryResponse(rawResponse, options) {
-  const hasEmptySelect = options?.select && Object.keys(options.select).length === 0;
-  return rawResponse.map((itemRaw) => {
-    const raw = itemRaw;
-    const key = raw[0];
-    const score = raw[1];
-    const rawFields = raw[2];
-    if (hasEmptySelect) {
-      return { key, score };
-    }
-    if (!Array.isArray(rawFields) || rawFields.length === 0) {
-      return { key, score, data: {} };
-    }
-    const mergedFields = {};
-    for (const fieldRaw of rawFields) {
-      const fieldObj = kvArrayToObject(fieldRaw);
-      Object.assign(mergedFields, fieldObj);
-    }
-    if ("$" in mergedFields) {
-      const data2 = mergedFields["$"];
-      return { key, score, data: data2 };
-    }
-    const data = dotNotationToNested(mergedFields);
-    return { key, score, data };
-  });
-}
-function parseFieldInfo(fieldRaw) {
-  const fieldType = fieldRaw[1];
-  const options = fieldRaw.slice(2);
-  const fieldInfo = { type: fieldType };
-  for (const option of options) {
-    switch (option.toUpperCase()) {
-      case "NOTOKENIZE":
-        fieldInfo.noTokenize = true;
-        break;
-      case "NOSTEM":
-        fieldInfo.noStem = true;
-        break;
-      case "FAST":
-        fieldInfo.fast = true;
-        break;
-    }
-  }
-  return fieldInfo;
-}
-function deserializeDescribeResponse(rawResponse) {
-  const raw = kvArrayToObject(rawResponse);
-  const schema = {};
-  if (Array.isArray(raw.schema)) {
-    for (const fieldRaw of raw.schema) {
-      if (Array.isArray(fieldRaw) && fieldRaw.length >= 2) {
-        const fieldName = fieldRaw[0];
-        schema[fieldName] = parseFieldInfo(fieldRaw);
-      }
-    }
-  }
-  return {
-    name: raw.name,
-    dataType: raw.type.toLowerCase(),
-    prefixes: raw.prefixes,
-    ...raw.language && { language: raw.language },
-    schema
-  };
-}
-function parseCountResponse(rawResponse) {
-  return typeof rawResponse === "number" ? rawResponse : parseInt(rawResponse, 10);
-}
-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;
-}
-function dotNotationToNested(obj) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const parts = key.split(".");
-    let current = result;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const part = parts[i];
-      if (!(part in current)) {
-        current[part] = {};
-      }
-      current = current[part];
-    }
-    current[parts[parts.length - 1]] = value;
-  }
-  return result;
-}
-
-// 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");
-    Object.entries(options.orderBy).forEach(([field, direction]) => {
-      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(props) {
-  const { name, schema, dataType, prefix, language } = props;
-  const prefixArray = Array.isArray(prefix) ? prefix : [prefix];
-  const payload = [
-    name,
-    "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");
-    }
-  }
-  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.COMMIT", this.name];
-    const result = await new ExecCommand(command).exec(
-      this.client
-    );
-    return result;
-  }
-  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, options);
-  }
-  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(props) {
-  const { name, schema, client } = props;
-  const createIndexCommand = buildCreateIndexCommand(props);
-  await new ExecCommand(createIndexCommand).exec(client);
-  return index(client, name, schema);
-}
-function index(client, name, schema) {
-  return new SearchIndex({ name, schema, client });
-}
-
-// pkg/commands/search/schema-builder.ts
-var BUILD = Symbol("build");
-var TextFieldBuilder = class _TextFieldBuilder {
-  _noTokenize;
-  _noStem;
-  constructor(noTokenize = { noTokenize: false }, noStem = { noStem: false }) {
-    this._noTokenize = noTokenize;
-    this._noStem = noStem;
-  }
-  noTokenize() {
-    return new _TextFieldBuilder({ noTokenize: true }, this._noStem);
-  }
-  noStem() {
-    return new _TextFieldBuilder(this._noTokenize, { noStem: true });
-  }
-  [BUILD]() {
-    return this._noTokenize.noTokenize || this._noStem.noStem ? {
-      type: "TEXT",
-      ...this._noTokenize.noTokenize ? { noTokenize: true } : {},
-      ...this._noStem.noStem ? { noStem: true } : {}
-    } : "TEXT";
-  }
-};
-var NumericFieldBuilder = class {
-  type;
-  constructor(type) {
-    this.type = type;
-  }
-  [BUILD]() {
-    return {
-      type: this.type,
-      fast: true
-    };
-  }
-};
-var BoolFieldBuilder = class _BoolFieldBuilder {
-  _fast;
-  constructor(fast = { fast: false }) {
-    this._fast = fast;
-  }
-  fast() {
-    return new _BoolFieldBuilder({ fast: true });
-  }
-  [BUILD]() {
-    return this._fast.fast ? {
-      type: "BOOL",
-      fast: true
-    } : "BOOL";
-  }
-};
-var DateFieldBuilder = class _DateFieldBuilder {
-  _fast;
-  constructor(fast = { fast: false }) {
-    this._fast = fast;
-  }
-  fast() {
-    return new _DateFieldBuilder({ fast: true });
-  }
-  [BUILD]() {
-    return this._fast.fast ? {
-      type: "DATE",
-      fast: true
-    } : "DATE";
-  }
-};
-
 // pkg/commands/psubscribe.ts
 var PSubscribeCommand = class extends Command {
   constructor(cmd, opts) {
@@ -3382,7 +3168,7 @@ var Pipeline = class {
   /**
    * @see https://redis.io/commands/lset
    */
-  lset = (key, index2, value) => this.chain(new LSetCommand([key, index2, value], this.commandOptions));
+  lset = (key, index, value) => this.chain(new LSetCommand([key, index, value], this.commandOptions));
   /**
    * @see https://redis.io/commands/ltrim
    */
@@ -3834,6 +3620,38 @@ 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
@@ -3895,8 +3713,8 @@ var Script = class {
   /**
    * Compute the sha1 hash of the script and return its hex representation.
    */
-  async digest(s2) {
-    const data = new TextEncoder().encode(s2);
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
     const hashBuffer = await import_uncrypto.subtle.digest("SHA-1", data);
     const hashArray = [...new Uint8Array(hashBuffer)];
     return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -3959,8 +3777,8 @@ var ScriptRO = class {
   /**
    * Compute the sha1 hash of the script and return its hex representation.
    */
-  async digest(s2) {
-    const data = new TextEncoder().encode(s2);
+  async digest(s) {
+    const data = new TextEncoder().encode(s);
     const hashBuffer = await import_uncrypto2.subtle.digest("SHA-1", data);
     const hashArray = [...new Uint8Array(hashBuffer)];
     return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -4095,6 +3913,40 @@ 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.
    */
@@ -4145,19 +3997,6 @@ var Redis = class {
   createScript(script, opts) {
     return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
   }
-  get search() {
-    return {
-      createIndex: (props) => {
-        return createIndex({
-          ...props,
-          client: this.client
-        });
-      },
-      index: (name, schema) => {
-        return index(this.client, name, schema);
-      }
-    };
-  }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
    *
@@ -4494,7 +4333,7 @@ var Redis = class {
   /**
    * @see https://redis.io/commands/lset
    */
-  lset = (key, index2, value) => new LSetCommand([key, index2, value], this.opts).exec(this.client);
+  lset = (key, index, value) => new LSetCommand([key, index, value], this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/ltrim
    */
@@ -4865,7 +4704,7 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.36.0-rc.4";
+var VERSION = "v1.36.0";
 
 // platforms/fastly.ts
 var Redis2 = class extends Redis {