@windrun-huaiin/backend-core 13.0.0 → 14.1.0

package/dist/node_modules/.pnpm/{@upstash_redis@1.36.1/node_modules/@upstash/redis/chunk-LLI2WIYN.mjs → @upstash_redis@1.37.0/node_modules/@upstash/redis/chunk-IH7W44G6.mjs}

@@ -144,7 +144,6 @@ var HttpClient = class {
     const signal = req.signal ?? this.options.signal;
     const isSignalFunction = typeof signal === "function";
     const requestOptions = {
-      //@ts-expect-error this should throw due to bun regression
       cache: this.options.cache,
       method: "POST",
       headers: requestHeaders,
@@ -391,6 +390,442 @@ var Command = class {
   }
 };
 
+// pkg/commands/exec.ts
+var ExecCommand = class extends Command {
+  constructor(cmd, opts) {
+    const normalizedCmd = cmd.map((arg) => typeof arg === "string" ? arg : String(arg));
+    super(normalizedCmd, opts);
+  }
+};
+
+// pkg/commands/search/types.ts
+var FIELD_TYPES = [
+  "TEXT",
+  "U64",
+  "I64",
+  "F64",
+  "BOOL",
+  "DATE",
+  "KEYWORD",
+  "FACET"
+];
+
+// 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 = Number(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;
+                }
+                case "FROM": {
+                  fieldInfo.from = fieldDescription[++j];
+                  break;
+                }
+              }
+            }
+          }
+          schema[fieldName] = fieldInfo;
+        }
+        description["schema"] = schema;
+        break;
+      }
+    }
+  }
+  return description;
+}
+function parseCountResponse(rawResponse) {
+  return typeof rawResponse === "number" ? rawResponse : Number.parseInt(rawResponse, 10);
+}
+function deserializeAggregateResponse(rawResponse) {
+  return parseAggregationArray(rawResponse);
+}
+function parseAggregationArray(arr) {
+  const result = {};
+  for (let i = 0; i < arr.length; i += 2) {
+    const key = arr[i];
+    const value = arr[i + 1];
+    if (Array.isArray(value)) {
+      if (value.length > 0 && typeof value[0] === "string") {
+        result[key] = value[0] === "buckets" ? parseBucketsValue(value) : parseStatsValue(value);
+      } else {
+        result[key] = parseAggregationArray(value);
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function coerceNumericString(value) {
+  if (typeof value === "string" && value !== "" && !Number.isNaN(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
+function parseStatsValue(arr) {
+  const result = {};
+  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) {
+      if (typeof value[0] === "string") {
+        result[key] = parseStatsValue(value);
+      } else if (Array.isArray(value[0]) && typeof value[0][0] === "string") {
+        result[key] = value.map((item) => parseStatsValue(item));
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = coerceNumericString(value);
+    }
+  }
+  return result;
+}
+function parseBucketsValue(arr) {
+  if (arr[0] === "buckets" && Array.isArray(arr[1])) {
+    const result = {
+      buckets: arr[1].map((bucket) => {
+        const bucketObj = {};
+        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;
+      })
+    };
+    for (let i = 2; i < arr.length; i += 2) {
+      result[arr[i]] = arr[i + 1];
+    }
+    return result;
+  }
+  return arr;
+}
+
+// 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) {
+    if ("orderBy" in options && options.orderBy) {
+      command.push("ORDERBY");
+      for (const [field, direction] of Object.entries(options.orderBy)) {
+        command.push(field, direction);
+      }
+    } 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) {
+  const result = [];
+  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) {
+  const result = [];
+  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 !== void 0) {
+      result.push("FACTOR", field.factor.toString());
+    }
+    if (field.missing !== void 0) {
+      result.push("MISSING", field.missing.toString());
+    }
+  }
+  return result;
+}
+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];
+}
+function buildAggregateCommand(name, options) {
+  const query = JSON.stringify(options?.filter ?? {});
+  const aggregations = JSON.stringify(options.aggregations);
+  return ["SEARCH.AGGREGATE", name, query, aggregations];
+}
+
+// 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];
+    return await new ExecCommand(command).exec(this.client);
+  }
+  async describe() {
+    const command = ["SEARCH.DESCRIBE", this.name];
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    if (!rawResult) return null;
+    return deserializeDescribeResponse(rawResult);
+  }
+  async query(options) {
+    const command = buildQueryCommand("SEARCH.QUERY", this.name, options);
+    const rawResult = await new ExecCommand(command).exec(
+      this.client
+    );
+    if (!rawResult) return rawResult;
+    return deserializeQueryResponse(rawResult);
+  }
+  async aggregate(options) {
+    const command = buildAggregateCommand(this.name, options);
+    const rawResult = await new ExecCommand(
+      command
+    ).exec(this.client);
+    return deserializeAggregateResponse(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 addAlias({ alias }) {
+    const command = ["SEARCH.ALIASADD", alias, 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 });
+}
+async function listAliases(client) {
+  const command = ["SEARCH.LISTALIASES"];
+  const rawResult = await new ExecCommand(command).exec(client);
+  if (rawResult === 0 || Array.isArray(rawResult) && rawResult.length === 0) {
+    return {};
+  }
+  if (!Array.isArray(rawResult)) {
+    return {};
+  }
+  const aliases = {};
+  for (const pair of rawResult) {
+    if (Array.isArray(pair) && pair.length === 2) {
+      const [alias, index] = pair;
+      aliases[alias] = index;
+    }
+  }
+  return aliases;
+}
+async function addAlias(client, { indexName, alias }) {
+  const command = ["SEARCH.ALIASADD", alias, indexName];
+  const result = await new ExecCommand(command).exec(client);
+  return result;
+}
+async function delAlias(client, { alias }) {
+  const command = ["SEARCH.ALIASDEL", alias];
+  const result = await new ExecCommand(command).exec(client);
+  return result;
+}
+
 // pkg/commands/hrandfield.ts
 function deserialize(result) {
   if (result.length === 0) {
@@ -491,6 +926,13 @@ var BitPosCommand = class extends Command {
   }
 };
 
+// pkg/commands/client_setinfo.ts
+var ClientSetInfoCommand = class extends Command {
+  constructor([attribute, value], opts) {
+    super(["CLIENT", "SETINFO", attribute.toUpperCase(), value], opts);
+  }
+};
+
 // pkg/commands/copy.ts
 var CopyCommand = class extends Command {
   constructor([key, destinationKey, opts], commandOptions) {
@@ -569,14 +1011,6 @@ var EvalshaCommand = class extends Command {
   }
 };
 
-// pkg/commands/exec.ts
-var ExecCommand = class extends Command {
-  constructor(cmd, opts) {
-    const normalizedCmd = cmd.map((arg) => typeof arg === "string" ? arg : String(arg));
-    super(normalizedCmd, opts);
-  }
-};
-
 // pkg/commands/exists.ts
 var ExistsCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1088,6 +1522,63 @@ var HGetAllCommand = class extends Command {
   }
 };
 
+// pkg/commands/hmget.ts
+function deserialize5(fields, result) {
+  if (result.every((field) => field === null)) {
+    return null;
+  }
+  const obj = {};
+  for (const [i, field] of fields.entries()) {
+    try {
+      obj[field] = JSON.parse(result[i]);
+    } catch {
+      obj[field] = result[i];
+    }
+  }
+  return obj;
+}
+var HMGetCommand = class extends Command {
+  constructor([key, ...fields], opts) {
+    super(["hmget", key, ...fields], {
+      deserialize: (result) => deserialize5(fields, result),
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/hgetdel.ts
+var HGetDelCommand = class extends Command {
+  constructor([key, ...fields], opts) {
+    super(["hgetdel", key, "FIELDS", fields.length, ...fields], {
+      deserialize: (result) => deserialize5(fields.map(String), result),
+      ...opts
+    });
+  }
+};
+
+// pkg/commands/hgetex.ts
+var HGetExCommand = class extends Command {
+  constructor([key, opts, ...fields], cmdOpts) {
+    const command = ["hgetex", key];
+    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 ("persist" in opts && opts.persist) {
+      command.push("PERSIST");
+    }
+    command.push("FIELDS", fields.length, ...fields);
+    super(command, {
+      deserialize: (result) => deserialize5(fields.map(String), result),
+      ...cmdOpts
+    });
+  }
+};
+
 // pkg/commands/hincrby.ts
 var HIncrByCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1116,30 +1607,6 @@ var HLenCommand = class extends Command {
   }
 };
 
-// pkg/commands/hmget.ts
-function deserialize5(fields, result) {
-  if (result.every((field) => field === null)) {
-    return null;
-  }
-  const obj = {};
-  for (const [i, field] of fields.entries()) {
-    try {
-      obj[field] = JSON.parse(result[i]);
-    } catch {
-      obj[field] = result[i];
-    }
-  }
-  return obj;
-}
-var HMGetCommand = class extends Command {
-  constructor([key, ...fields], opts) {
-    super(["hmget", key, ...fields], {
-      deserialize: (result) => deserialize5(fields, result),
-      ...opts
-    });
-  }
-};
-
 // pkg/commands/hmset.ts
 var HMSetCommand = class extends Command {
   constructor([key, kv], opts) {
@@ -1171,6 +1638,35 @@ var HSetCommand = class extends Command {
   }
 };
 
+// pkg/commands/hsetex.ts
+var HSetExCommand = class extends Command {
+  constructor([key, opts, kv], cmdOpts) {
+    const command = ["hsetex", key];
+    if (opts.conditional) {
+      command.push(opts.conditional.toUpperCase());
+    }
+    if (opts.expiration) {
+      if ("ex" in opts.expiration && typeof opts.expiration.ex === "number") {
+        command.push("EX", opts.expiration.ex);
+      } else if ("px" in opts.expiration && typeof opts.expiration.px === "number") {
+        command.push("PX", opts.expiration.px);
+      } else if ("exat" in opts.expiration && typeof opts.expiration.exat === "number") {
+        command.push("EXAT", opts.expiration.exat);
+      } else if ("pxat" in opts.expiration && typeof opts.expiration.pxat === "number") {
+        command.push("PXAT", opts.expiration.pxat);
+      } else if ("keepttl" in opts.expiration && opts.expiration.keepttl) {
+        command.push("KEEPTTL");
+      }
+    }
+    const entries = Object.entries(kv);
+    command.push("FIELDS", entries.length);
+    for (const [field, value] of entries) {
+      command.push(field, value);
+    }
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/hsetnx.ts
 var HSetNXCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1809,6 +2305,18 @@ var SInterCommand = class extends Command {
   }
 };
 
+// pkg/commands/sintercard.ts
+var SInterCardCommand = class extends Command {
+  constructor(cmd, cmdOpts) {
+    const [keys, opts] = cmd;
+    const command = ["sintercard", keys.length, ...keys];
+    if (opts?.limit !== void 0) {
+      command.push("LIMIT", opts.limit);
+    }
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/sinterstore.ts
 var SInterStoreCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1954,6 +2462,15 @@ var XAckCommand = class extends Command {
   }
 };
 
+// pkg/commands/xackdel.ts
+var XAckDelCommand = class extends Command {
+  constructor([key, group, opts, ...ids], cmdOpts) {
+    const command = ["XACKDEL", key, group];
+    command.push(opts.toUpperCase(), "IDS", ids.length, ...ids);
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/xadd.ts
 var XAddCommand = class extends Command {
   constructor([key, id, entries, opts], commandOptions) {
@@ -2026,6 +2543,18 @@ var XDelCommand = class extends Command {
   }
 };
 
+// pkg/commands/xdelex.ts
+var XDelExCommand = class extends Command {
+  constructor([key, opts, ...ids], cmdOpts) {
+    const command = ["XDELEX", key];
+    if (opts) {
+      command.push(opts.toUpperCase());
+    }
+    command.push("IDS", ids.length, ...ids);
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/xgroup.ts
 var XGroupCommand = class extends Command {
   constructor([key, opts], commandOptions) {
@@ -2590,6 +3119,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/bitpos
    */
   bitpos = (...args) => this.chain(new BitPosCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/client-setinfo
+   */
+  clientSetinfo = (...args) => this.chain(new ClientSetInfoCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/copy
    */
@@ -2754,6 +3287,14 @@ var Pipeline = class {
    * @see https://redis.io/commands/hgetall
    */
   hgetall = (...args) => this.chain(new HGetAllCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hgetdel
+   */
+  hgetdel = (...args) => this.chain(new HGetDelCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hgetex
+   */
+  hgetex = (...args) => this.chain(new HGetExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/hincrby
    */
@@ -2790,6 +3331,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/hset
    */
   hset = (key, kv) => this.chain(new HSetCommand([key, kv], this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hsetex
+   */
+  hsetex = (...args) => this.chain(new HSetExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/hsetnx
    */
@@ -3002,6 +3547,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/sinter
    */
   sinter = (...args) => this.chain(new SInterCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/sintercard
+   */
+  sintercard = (...args) => this.chain(new SInterCardCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/sinterstore
    */
@@ -3094,10 +3643,18 @@ var Pipeline = class {
    * @see https://redis.io/commands/xack
    */
   xack = (...args) => this.chain(new XAckCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xackdel
+   */
+  xackdel = (...args) => this.chain(new XAckDelCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/xdel
    */
   xdel = (...args) => this.chain(new XDelCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/xdelex
+   */
+  xdelex = (...args) => this.chain(new XDelExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/xgroup
    */
@@ -3646,6 +4203,7 @@ var Script = class {
    * future major release.
    */
   sha1;
+  initPromise;
   redis;
   constructor(redis, script) {
     this.redis = redis;
@@ -3656,9 +4214,13 @@ var Script = class {
   /**
    * Initialize the script by computing its SHA-1 hash.
    */
-  async init(script) {
-    if (this.sha1) return;
-    this.sha1 = await this.digest(script);
+  init(script) {
+    if (!this.initPromise) {
+      this.initPromise = this.digest(script).then((sha1) => {
+        this.sha1 = sha1;
+      });
+    }
+    return this.initPromise;
   }
   /**
    * Send an `EVAL` command to redis.
@@ -3710,6 +4272,7 @@ var ScriptRO = class {
    * future major release.
    */
   sha1;
+  initPromise;
   redis;
   constructor(redis, script) {
     this.redis = redis;
@@ -3717,9 +4280,13 @@ var ScriptRO = class {
     this.script = script;
     void this.init(script);
   }
-  async init(script) {
-    if (this.sha1) return;
-    this.sha1 = await this.digest(script);
+  init(script) {
+    if (!this.initPromise) {
+      this.initPromise = this.digest(script).then((sha1) => {
+        this.sha1 = sha1;
+      });
+    }
+    return this.initPromise;
   }
   /**
    * Send an `EVAL_RO` command to redis.
@@ -3974,6 +4541,27 @@ 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);
+      },
+      alias: {
+        list: () => {
+          return listAliases(this.client);
+        },
+        add: ({ indexName, alias }) => {
+          return addAlias(this.client, { indexName, alias });
+        },
+        delete: ({ alias }) => {
+          return delAlias(this.client, { alias });
+        }
+      }
+    };
+  }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
    *
@@ -4035,6 +4623,10 @@ var Redis = class {
    * @see https://redis.io/commands/bitpos
    */
   bitpos = (...args) => new BitPosCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/client-setinfo
+   */
+  clientSetinfo = (...args) => new ClientSetInfoCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/copy
    */
@@ -4199,6 +4791,14 @@ var Redis = class {
    * @see https://redis.io/commands/hgetall
    */
   hgetall = (...args) => new HGetAllCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hgetdel
+   */
+  hgetdel = (...args) => new HGetDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hgetex
+   */
+  hgetex = (...args) => new HGetExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/hincrby
    */
@@ -4235,6 +4835,10 @@ var Redis = class {
    * @see https://redis.io/commands/hset
    */
   hset = (key, kv) => new HSetCommand([key, kv], this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hsetex
+   */
+  hsetex = (...args) => new HSetExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/hsetnx
    */
@@ -4453,6 +5057,10 @@ var Redis = class {
    * @see https://redis.io/commands/sinter
    */
   sinter = (...args) => new SInterCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/sintercard
+   */
+  sintercard = (...args) => new SInterCardCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/sinterstore
    */
@@ -4536,10 +5144,18 @@ var Redis = class {
    * @see https://redis.io/commands/xack
    */
   xack = (...args) => new XAckCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xackdel
+   */
+  xackdel = (...args) => new XAckDelCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/xdel
    */
   xdel = (...args) => new XDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/xdelex
+   */
+  xdelex = (...args) => new XDelExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/xgroup
    */
@@ -4681,6 +5297,6 @@ var Redis = class {
 };
 
 // version.ts
-var VERSION = "v1.36.1";
+var VERSION = "v1.30.2";
 
-export { HttpClient, Redis, VERSION, error_exports };
+export { HttpClient, Redis, SearchIndex, VERSION, error_exports };