@upstash/redis 0.0.0-ci.e9b0c868305a820aaed7d68c8407b277da5a093e-20241008121230 → 0.0.0-ci.ea9f0853d6a86e6b7809a21bff609de1b6e9291d-20250414063537

package/{chunk-3A3BS427.mjs → chunk-Q222GATB.mjs}

@@ -25,6 +25,43 @@ var UrlError = class extends Error {
   }
 };
 
+// pkg/util.ts
+function parseRecursive(obj) {
+  const parsed = Array.isArray(obj) ? obj.map((o) => {
+    try {
+      return parseRecursive(o);
+    } catch {
+      return o;
+    }
+  }) : JSON.parse(obj);
+  if (typeof parsed === "number" && parsed.toString() !== obj) {
+    return obj;
+  }
+  return parsed;
+}
+function parseResponse(result) {
+  try {
+    return parseRecursive(result);
+  } catch {
+    return result;
+  }
+}
+function deserializeScanResponse(result) {
+  return [result[0], ...parseResponse(result.slice(1))];
+}
+function mergeHeaders(...headers) {
+  const merged = {};
+  for (const header of headers) {
+    if (!header) continue;
+    for (const [key, value] of Object.entries(header)) {
+      if (value !== void 0 && value !== null) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+
 // pkg/http.ts
 var HttpClient = class {
   baseUrl;
@@ -46,7 +83,7 @@ var HttpClient = class {
     };
     this.upstashSyncToken = "";
     this.readYourWrites = config.readYourWrites ?? true;
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.baseUrl = (config.baseUrl || "").replace(/\/$/, "");
     const urlRegex = /^https?:\/\/[^\s#$./?].\S*$/;
     if (this.baseUrl && !urlRegex.test(this.baseUrl)) {
       throw new UrlError(this.baseUrl);
@@ -73,22 +110,25 @@ var HttpClient = class {
     this.headers = merge(this.headers, "Upstash-Telemetry-Sdk", telemetry.sdk);
   }
   async request(req) {
+    const requestHeaders = mergeHeaders(this.headers, req.headers ?? {});
+    const requestUrl = [this.baseUrl, ...req.path ?? []].join("/");
+    const isEventStream = requestHeaders.Accept === "text/event-stream";
     const requestOptions = {
       //@ts-expect-error this should throw due to bun regression
       cache: this.options.cache,
       method: "POST",
-      headers: this.headers,
+      headers: requestHeaders,
       body: JSON.stringify(req.body),
       keepalive: this.options.keepAlive,
       agent: this.options.agent,
-      signal: this.options.signal,
+      signal: req.signal ?? this.options.signal,
       /**
        * Fastly specific
        */
       backend: this.options.backend
     };
     if (!this.hasCredentials) {
-      throw new Error(
+      console.warn(
         "[Upstash Redis] Redis client was initialized without url or token. Failed to execute command."
       );
     }
@@ -100,7 +140,7 @@ var HttpClient = class {
     let error = null;
     for (let i = 0; i <= this.retry.attempts; i++) {
       try {
-        res = await fetch([this.baseUrl, ...req.path ?? []].join("/"), requestOptions);
+        res = await fetch(requestUrl, requestOptions);
         break;
       } catch (error_) {
         if (this.options.signal?.aborted) {
@@ -115,20 +155,54 @@ var HttpClient = class {
           break;
         }
         error = error_;
-        await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+        if (i < this.retry.attempts) {
+          await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+        }
       }
     }
     if (!res) {
       throw error ?? new Error("Exhausted all retries");
     }
-    const body = await res.json();
     if (!res.ok) {
-      throw new UpstashError(`${body.error}, command was: ${JSON.stringify(req.body)}`);
+      const body2 = await res.json();
+      throw new UpstashError(`${body2.error}, command was: ${JSON.stringify(req.body)}`);
     }
     if (this.readYourWrites) {
       const headers = res.headers;
       this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
     }
+    if (isEventStream && req && req.onMessage && res.body) {
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      (async () => {
+        try {
+          while (true) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            const chunk = decoder.decode(value);
+            const lines = chunk.split("\n");
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                req.onMessage?.(data);
+              }
+            }
+          }
+        } catch (error2) {
+          if (error2 instanceof Error && error2.name === "AbortError") {
+          } else {
+            console.error("Stream reading error:", error2);
+          }
+        } finally {
+          try {
+            await reader.cancel();
+          } catch {
+          }
+        }
+      })();
+      return { result: 1 };
+    }
+    const body = await res.json();
     if (this.readYourWrites) {
       const headers = res.headers;
       this.upstashSyncToken = headers.get("upstash-sync-token") ?? "";
@@ -199,31 +273,6 @@ function merge(obj, key, value) {
   return obj;
 }
 
-// pkg/util.ts
-function parseRecursive(obj) {
-  const parsed = Array.isArray(obj) ? obj.map((o) => {
-    try {
-      return parseRecursive(o);
-    } catch {
-      return o;
-    }
-  }) : JSON.parse(obj);
-  if (typeof parsed === "number" && parsed.toString() !== obj) {
-    return obj;
-  }
-  return parsed;
-}
-function parseResponse(result) {
-  try {
-    return parseRecursive(result);
-  } catch {
-    return result;
-  }
-}
-function deserializeScanResponse(result) {
-  return [result[0], ...parseResponse(result.slice(1))];
-}
-
 // pkg/commands/command.ts
 var defaultSerializer = (c) => {
   switch (typeof c) {
@@ -241,6 +290,11 @@ var Command = class {
   command;
   serialize;
   deserialize;
+  headers;
+  path;
+  onMessage;
+  isStreaming;
+  signal;
   /**
    * Create a new command instance.
    *
@@ -250,6 +304,11 @@ var Command = class {
     this.serialize = defaultSerializer;
     this.deserialize = opts?.automaticDeserialization === void 0 || opts.automaticDeserialization ? opts?.deserialize ?? parseResponse : (x) => x;
     this.command = command.map((c) => this.serialize(c));
+    this.headers = opts?.headers;
+    this.path = opts?.path;
+    this.onMessage = opts?.streamOptions?.onMessage;
+    this.isStreaming = opts?.streamOptions?.isStreaming ?? false;
+    this.signal = opts?.streamOptions?.signal;
     if (opts?.latencyLogging) {
       const originalExec = this.exec.bind(this);
       this.exec = async (client) => {
@@ -270,7 +329,12 @@ var Command = class {
   async exec(client) {
     const { result, error } = await client.request({
       body: this.command,
-      upstashSyncToken: client.upstashSyncToken
+      path: this.path,
+      upstashSyncToken: client.upstashSyncToken,
+      headers: this.headers,
+      onMessage: this.onMessage,
+      isStreaming: this.isStreaming,
+      signal: this.signal
     });
     if (error) {
       throw new UpstashError(error);
@@ -288,9 +352,9 @@ function deserialize(result) {
     return null;
   }
   const obj = {};
-  while (result.length >= 2) {
-    const key = result.shift();
-    const value = result.shift();
+  for (let i = 0; i < result.length; i += 2) {
+    const key = result[i];
+    const value = result[i + 1];
     try {
       obj[key] = JSON.parse(value);
     } catch {
@@ -432,6 +496,13 @@ var EchoCommand = class extends Command {
   }
 };
 
+// pkg/commands/evalRo.ts
+var EvalROCommand = class extends Command {
+  constructor([script, keys, args], opts) {
+    super(["eval_ro", script, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+
 // pkg/commands/eval.ts
 var EvalCommand = class extends Command {
   constructor([script, keys, args], opts) {
@@ -439,6 +510,13 @@ var EvalCommand = class extends Command {
   }
 };
 
+// pkg/commands/evalshaRo.ts
+var EvalshaROCommand = class extends Command {
+  constructor([sha, keys, args], opts) {
+    super(["evalsha_ro", sha, keys.length, ...keys, ...args ?? []], opts);
+  }
+};
+
 // pkg/commands/evalsha.ts
 var EvalshaCommand = class extends Command {
   constructor([sha, keys, args], opts) {
@@ -446,6 +524,14 @@ 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) {
@@ -662,6 +748,27 @@ var GetDelCommand = class extends Command {
   }
 };
 
+// pkg/commands/getex.ts
+var GetExCommand = class extends Command {
+  constructor([key, opts], cmdOpts) {
+    const command = ["getex", key];
+    if (opts) {
+      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");
+      }
+    }
+    super(command, cmdOpts);
+  }
+};
+
 // pkg/commands/getrange.ts
 var GetRangeCommand = class extends Command {
   constructor(cmd, opts) {
@@ -690,6 +797,122 @@ var HExistsCommand = class extends Command {
   }
 };
 
+// pkg/commands/hexpire.ts
+var HExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, seconds, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hexpire",
+        key,
+        seconds,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hexpireat.ts
+var HExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, timestamp, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hexpireat",
+        key,
+        timestamp,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hexpiretime.ts
+var HExpireTimeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
+// pkg/commands/hpersist.ts
+var HPersistCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpersist", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
+// pkg/commands/hpexpire.ts
+var HPExpireCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, milliseconds, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hpexpire",
+        key,
+        milliseconds,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hpexpireat.ts
+var HPExpireAtCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields, timestamp, option] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(
+      [
+        "hpexpireat",
+        key,
+        timestamp,
+        ...option ? [option] : [],
+        "FIELDS",
+        fieldArray.length,
+        ...fieldArray
+      ],
+      opts
+    );
+  }
+};
+
+// pkg/commands/hpexpiretime.ts
+var HPExpireTimeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpexpiretime", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
+// pkg/commands/hpttl.ts
+var HPTtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["hpttl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
 // pkg/commands/hget.ts
 var HGetCommand = class extends Command {
   constructor(cmd, opts) {
@@ -703,9 +926,9 @@ function deserialize2(result) {
     return null;
   }
   const obj = {};
-  while (result.length >= 2) {
-    const key = result.shift();
-    const value = result.shift();
+  for (let i = 0; i < result.length; i += 2) {
+    const key = result[i];
+    const value = result[i + 1];
     try {
       const valueIsNumberAndNotSafeInteger = !Number.isNaN(Number(value)) && !Number.isSafeInteger(Number(value));
       obj[key] = valueIsNumberAndNotSafeInteger ? value : JSON.parse(value);
@@ -821,6 +1044,15 @@ var HStrLenCommand = class extends Command {
   }
 };
 
+// pkg/commands/httl.ts
+var HTtlCommand = class extends Command {
+  constructor(cmd, opts) {
+    const [key, fields] = cmd;
+    const fieldArray = Array.isArray(fields) ? fields : [fields];
+    super(["httl", key, "FIELDS", fieldArray.length, ...fieldArray], opts);
+  }
+};
+
 // pkg/commands/hvals.ts
 var HValsCommand = class extends Command {
   constructor(cmd, opts) {
@@ -940,6 +1172,14 @@ var JsonGetCommand = class extends Command {
   }
 };
 
+// pkg/commands/json_merge.ts
+var JsonMergeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const command = ["JSON.MERGE", ...cmd];
+    super(command, opts);
+  }
+};
+
 // pkg/commands/json_mget.ts
 var JsonMGetCommand = class extends Command {
   constructor(cmd, opts) {
@@ -1730,15 +1970,15 @@ var XPendingCommand = class extends Command {
 function deserialize4(result) {
   const obj = {};
   for (const e of result) {
-    while (e.length >= 2) {
-      const streamId = e.shift();
-      const entries = e.shift();
+    for (let i = 0; i < e.length; i += 2) {
+      const streamId = e[i];
+      const entries = e[i + 1];
       if (!(streamId in obj)) {
         obj[streamId] = {};
       }
-      while (entries.length >= 2) {
-        const field = entries.shift();
-        const value = entries.shift();
+      for (let j = 0; j < entries.length; j += 2) {
+        const field = entries[j];
+        const value = entries[j + 1];
         try {
           obj[streamId][field] = JSON.parse(value);
         } catch {
@@ -1827,15 +2067,15 @@ var XRevRangeCommand = class extends Command {
 function deserialize5(result) {
   const obj = {};
   for (const e of result) {
-    while (e.length >= 2) {
-      const streamId = e.shift();
-      const entries = e.shift();
+    for (let i = 0; i < e.length; i += 2) {
+      const streamId = e[i];
+      const entries = e[i + 1];
       if (!(streamId in obj)) {
         obj[streamId] = {};
       }
-      while (entries.length >= 2) {
-        const field = entries.shift();
-        const value = entries.shift();
+      for (let j = 0; j < entries.length; j += 2) {
+        const field = entries[j];
+        const value = entries[j + 1];
         try {
           obj[streamId][field] = JSON.parse(value);
         } catch {
@@ -2122,9 +2362,9 @@ var Pipeline = class {
     this.multiExec = opts.multiExec ?? false;
     if (this.commandOptions?.latencyLogging) {
       const originalExec = this.exec.bind(this);
-      this.exec = async () => {
+      this.exec = async (options) => {
         const start = performance.now();
-        const result = await originalExec();
+        const result = await (options ? originalExec(options) : originalExec());
         const end = performance.now();
         const loggerResult = (end - start).toFixed(2);
         console.log(
@@ -2134,19 +2374,7 @@ var Pipeline = class {
       };
     }
   }
-  /**
-   * Send the pipeline request to upstash.
-   *
-   * Returns an array with the results of all pipelined commands.
-   *
-   * If all commands are statically chained from start to finish, types are inferred. You can still define a return type manually if necessary though:
-   * ```ts
-   * const p = redis.pipeline()
-   * p.get("key")
-   * const result = p.exec<[{ greeting: string }]>()
-   * ```
-   */
-  exec = async () => {
+  exec = async (options) => {
     if (this.commands.length === 0) {
       throw new Error("Pipeline is empty");
     }
@@ -2155,7 +2383,12 @@ var Pipeline = class {
       path,
       body: Object.values(this.commands).map((c) => c.command)
     });
-    return res.map(({ error, result }, i) => {
+    return options?.keepErrors ? res.map(({ error, result }, i) => {
+      return {
+        error,
+        result: this.commands[i].deserialize(result)
+      };
+    }) : res.map(({ error, result }, i) => {
       if (error) {
         throw new UpstashError(
           `Command ${i + 1} [ ${this.commands[i].command[0]} ] failed: ${error}`
@@ -2241,10 +2474,18 @@ var Pipeline = class {
    * @see https://redis.io/commands/echo
    */
   echo = (...args) => this.chain(new EchoCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/eval_ro
+   */
+  evalRo = (...args) => this.chain(new EvalROCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/eval
    */
   eval = (...args) => this.chain(new EvalCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/evalsha_ro
+   */
+  evalshaRo = (...args) => this.chain(new EvalshaROCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/evalsha
    */
@@ -2305,6 +2546,10 @@ var Pipeline = class {
    * @see https://redis.io/commands/getdel
    */
   getdel = (...args) => this.chain(new GetDelCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/getex
+   */
+  getex = (...args) => this.chain(new GetExCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/getrange
    */
@@ -2321,6 +2566,42 @@ var Pipeline = class {
    * @see https://redis.io/commands/hexists
    */
   hexists = (...args) => this.chain(new HExistsCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hexpire
+   */
+  hexpire = (...args) => this.chain(new HExpireCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hexpireat
+   */
+  hexpireat = (...args) => this.chain(new HExpireAtCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hexpiretime
+   */
+  hexpiretime = (...args) => this.chain(new HExpireTimeCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/httl
+   */
+  httl = (...args) => this.chain(new HTtlCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpexpire
+   */
+  hpexpire = (...args) => this.chain(new HPExpireCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpexpireat
+   */
+  hpexpireat = (...args) => this.chain(new HPExpireAtCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpexpiretime
+   */
+  hpexpiretime = (...args) => this.chain(new HPExpireTimeCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpttl
+   */
+  hpttl = (...args) => this.chain(new HPTtlCommand(args, this.commandOptions));
+  /**
+   * @see https://redis.io/commands/hpersist
+   */
+  hpersist = (...args) => this.chain(new HPersistCommand(args, this.commandOptions));
   /**
    * @see https://redis.io/commands/hget
    */
@@ -2838,6 +3119,10 @@ var Pipeline = class {
        * @see https://redis.io/commands/json.get
        */
       get: (...args) => this.chain(new JsonGetCommand(args, this.commandOptions)),
+      /**
+       * @see https://redis.io/commands/json.merge
+       */
+      merge: (...args) => this.chain(new JsonMergeCommand(args, this.commandOptions)),
       /**
        * @see https://redis.io/commands/json.mget
        */
@@ -2949,7 +3234,7 @@ var AutoPipelineExecutor = class {
     executeWithPipeline(pipeline);
     const pipelineDone = this.deferExecution().then(() => {
       if (!this.pipelinePromises.has(pipeline)) {
-        const pipelinePromise = pipeline.exec();
+        const pipelinePromise = pipeline.exec({ keepErrors: true });
         this.pipelineCounter += 1;
         this.pipelinePromises.set(pipeline, pipelinePromise);
         this.activePipeline = null;
@@ -2957,7 +3242,11 @@ var AutoPipelineExecutor = class {
       return this.pipelinePromises.get(pipeline);
     });
     const results = await pipelineDone;
-    return results[index];
+    const commandResult = results[index];
+    if (commandResult.error) {
+      throw new UpstashError(`Command failed: ${commandResult.error}`);
+    }
+    return commandResult.result;
   }
   async deferExecution() {
     await Promise.resolve();
@@ -2965,6 +3254,183 @@ var AutoPipelineExecutor = class {
   }
 };
 
+// pkg/commands/psubscribe.ts
+var PSubscribeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const sseHeaders = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    };
+    super([], {
+      ...opts,
+      headers: sseHeaders,
+      path: ["psubscribe", ...cmd],
+      streamOptions: {
+        isStreaming: true,
+        onMessage: opts?.streamOptions?.onMessage,
+        signal: opts?.streamOptions?.signal
+      }
+    });
+  }
+};
+
+// pkg/commands/subscribe.ts
+var Subscriber = class extends EventTarget {
+  subscriptions;
+  client;
+  listeners;
+  constructor(client, channels, isPattern = false) {
+    super();
+    this.client = client;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    for (const channel of channels) {
+      if (isPattern) {
+        this.subscribeToPattern(channel);
+      } else {
+        this.subscribeToChannel(channel);
+      }
+    }
+  }
+  subscribeToChannel(channel) {
+    const controller = new AbortController();
+    const command = new SubscribeCommand([channel], {
+      streamOptions: {
+        signal: controller.signal,
+        onMessage: (data) => this.handleMessage(data, false)
+      }
+    });
+    command.exec(this.client).catch((error) => {
+      if (error.name !== "AbortError") {
+        this.dispatchToListeners("error", error);
+      }
+    });
+    this.subscriptions.set(channel, {
+      command,
+      controller,
+      isPattern: false
+    });
+  }
+  subscribeToPattern(pattern) {
+    const controller = new AbortController();
+    const command = new PSubscribeCommand([pattern], {
+      streamOptions: {
+        signal: controller.signal,
+        onMessage: (data) => this.handleMessage(data, true)
+      }
+    });
+    command.exec(this.client).catch((error) => {
+      if (error.name !== "AbortError") {
+        this.dispatchToListeners("error", error);
+      }
+    });
+    this.subscriptions.set(pattern, {
+      command,
+      controller,
+      isPattern: true
+    });
+  }
+  handleMessage(data, isPattern) {
+    const messageData = data.replace(/^data:\s*/, "");
+    const firstCommaIndex = messageData.indexOf(",");
+    const secondCommaIndex = messageData.indexOf(",", firstCommaIndex + 1);
+    const thirdCommaIndex = isPattern ? messageData.indexOf(",", secondCommaIndex + 1) : -1;
+    if (firstCommaIndex !== -1 && secondCommaIndex !== -1) {
+      const type = messageData.slice(0, firstCommaIndex);
+      if (isPattern && type === "pmessage" && thirdCommaIndex !== -1) {
+        const pattern = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
+        const channel = messageData.slice(secondCommaIndex + 1, thirdCommaIndex);
+        const messageStr = messageData.slice(thirdCommaIndex + 1);
+        try {
+          const message = JSON.parse(messageStr);
+          this.dispatchToListeners("pmessage", { pattern, channel, message });
+          this.dispatchToListeners(`pmessage:${pattern}`, { pattern, channel, message });
+        } catch (error) {
+          this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
+        }
+      } else {
+        const channel = messageData.slice(firstCommaIndex + 1, secondCommaIndex);
+        const messageStr = messageData.slice(secondCommaIndex + 1);
+        try {
+          if (type === "subscribe" || type === "psubscribe" || type === "unsubscribe" || type === "punsubscribe") {
+            const count = Number.parseInt(messageStr);
+            this.dispatchToListeners(type, count);
+          } else {
+            const message = JSON.parse(messageStr);
+            this.dispatchToListeners(type, { channel, message });
+            this.dispatchToListeners(`${type}:${channel}`, { channel, message });
+          }
+        } catch (error) {
+          this.dispatchToListeners("error", new Error(`Failed to parse message: ${error}`));
+        }
+      }
+    }
+  }
+  dispatchToListeners(type, data) {
+    const listeners = this.listeners.get(type);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(data);
+      }
+    }
+  }
+  on(type, listener) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(type)?.add(listener);
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+  async unsubscribe(channels) {
+    if (channels) {
+      for (const channel of channels) {
+        const subscription = this.subscriptions.get(channel);
+        if (subscription) {
+          try {
+            subscription.controller.abort();
+          } catch {
+          }
+          this.subscriptions.delete(channel);
+        }
+      }
+    } else {
+      for (const subscription of this.subscriptions.values()) {
+        try {
+          subscription.controller.abort();
+        } catch {
+        }
+      }
+      this.subscriptions.clear();
+      this.removeAllListeners();
+    }
+  }
+  getSubscribedChannels() {
+    return [...this.subscriptions.keys()];
+  }
+};
+var SubscribeCommand = class extends Command {
+  constructor(cmd, opts) {
+    const sseHeaders = {
+      Accept: "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    };
+    super([], {
+      ...opts,
+      headers: sseHeaders,
+      path: ["subscribe", ...cmd],
+      streamOptions: {
+        isStreaming: true,
+        onMessage: opts?.streamOptions?.onMessage,
+        signal: opts?.streamOptions?.signal
+      }
+    });
+  }
+};
+
 // pkg/script.ts
 import Hex from "crypto-js/enc-hex.js";
 import sha1 from "crypto-js/sha1.js";
@@ -3012,6 +3478,53 @@ var Script = class {
   }
 };
 
+// pkg/scriptRo.ts
+import Hex2 from "crypto-js/enc-hex.js";
+import sha12 from "crypto-js/sha1.js";
+var ScriptRO = class {
+  script;
+  sha1;
+  redis;
+  constructor(redis, script) {
+    this.redis = redis;
+    this.sha1 = this.digest(script);
+    this.script = script;
+  }
+  /**
+   * Send an `EVAL_RO` command to redis.
+   */
+  async evalRo(keys, args) {
+    return await this.redis.evalRo(this.script, keys, args);
+  }
+  /**
+   * Calculates the sha1 hash of the script and then calls `EVALSHA_RO`.
+   */
+  async evalshaRo(keys, args) {
+    return await this.redis.evalshaRo(this.sha1, keys, args);
+  }
+  /**
+   * Optimistically try to run `EVALSHA_RO` first.
+   * If the script is not loaded in redis, it will fall back and try again with `EVAL_RO`.
+   *
+   * Following calls will be able to use the cached script
+   */
+  async exec(keys, args) {
+    const res = await this.redis.evalshaRo(this.sha1, keys, args).catch(async (error) => {
+      if (error instanceof Error && error.message.toLowerCase().includes("noscript")) {
+        return await this.redis.evalRo(this.script, keys, args);
+      }
+      throw error;
+    });
+    return res;
+  }
+  /**
+   * Compute the sha1 hash of the script and return its hex representation.
+   */
+  digest(s) {
+    return Hex2.stringify(sha12(s));
+  }
+};
+
 // pkg/redis.ts
 var Redis = class {
   client;
@@ -3086,6 +3599,10 @@ var Redis = class {
        * @see https://redis.io/commands/json.get
        */
       get: (...args) => new JsonGetCommand(args, this.opts).exec(this.client),
+      /**
+       * @see https://redis.io/commands/json.merge
+       */
+      merge: (...args) => new JsonMergeCommand(args, this.opts).exec(this.client),
       /**
        * @see https://redis.io/commands/json.mget
        */
@@ -3155,8 +3672,36 @@ var Redis = class {
     } catch {
     }
   };
-  createScript(script) {
-    return new Script(this, script);
+  /**
+   * Creates a new script.
+   *
+   * Scripts offer the ability to optimistically try to execute a script without having to send the
+   * entire script to the server. If the script is loaded on the server, it tries again by sending
+   * the entire script. Afterwards, the script is cached on the server.
+   *
+   * @param script - The script to create
+   * @param opts - Optional options to pass to the script `{ readonly?: boolean }`
+   * @returns A new script
+   *
+   * @example
+   * ```ts
+   * const redis = new Redis({...})
+   *
+   * const script = redis.createScript<string>("return ARGV[1];")
+   * const arg1 = await script.eval([], ["Hello World"])
+   * expect(arg1, "Hello World")
+   * ```
+   * @example
+   * ```ts
+   * const redis = new Redis({...})
+   *
+   * const script = redis.createScript<string>("return ARGV[1];", { readonly: true })
+   * const arg1 = await script.evalRo([], ["Hello World"])
+   * expect(arg1, "Hello World")
+   * ```
+   */
+  createScript(script, opts) {
+    return opts?.readonly ? new ScriptRO(this, script) : new Script(this, script);
   }
   /**
    * Create a new pipeline that allows you to send requests in bulk.
@@ -3243,14 +3788,26 @@ var Redis = class {
    * @see https://redis.io/commands/echo
    */
   echo = (...args) => new EchoCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/eval_ro
+   */
+  evalRo = (...args) => new EvalROCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/eval
    */
   eval = (...args) => new EvalCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/evalsha_ro
+   */
+  evalshaRo = (...args) => new EvalshaROCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/evalsha
    */
   evalsha = (...args) => new EvalshaCommand(args, this.opts).exec(this.client);
+  /**
+   * Generic method to execute any Redis command.
+   */
+  exec = (args) => new ExecCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/exists
    */
@@ -3307,6 +3864,10 @@ var Redis = class {
    * @see https://redis.io/commands/getdel
    */
   getdel = (...args) => new GetDelCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/getex
+   */
+  getex = (...args) => new GetExCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/getrange
    */
@@ -3323,6 +3884,42 @@ var Redis = class {
    * @see https://redis.io/commands/hexists
    */
   hexists = (...args) => new HExistsCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hexpire
+   */
+  hexpire = (...args) => new HExpireCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hexpireat
+   */
+  hexpireat = (...args) => new HExpireAtCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hexpiretime
+   */
+  hexpiretime = (...args) => new HExpireTimeCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/httl
+   */
+  httl = (...args) => new HTtlCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpexpire
+   */
+  hpexpire = (...args) => new HPExpireCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpexpireat
+   */
+  hpexpireat = (...args) => new HPExpireAtCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpexpiretime
+   */
+  hpexpiretime = (...args) => new HPExpireTimeCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpttl
+   */
+  hpttl = (...args) => new HPTtlCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/hpersist
+   */
+  hpersist = (...args) => new HPersistCommand(args, this.opts).exec(this.client);
   /**
    * @see https://redis.io/commands/hget
    */
@@ -3491,6 +4088,13 @@ var Redis = class {
    * @see https://redis.io/commands/psetex
    */
   psetex = (key, ttl, value) => new PSetEXCommand([key, ttl, value], this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/psubscribe
+   */
+  psubscribe = (patterns) => {
+    const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+    return new Subscriber(this.client, patternArray, true);
+  };
   /**
    * @see https://redis.io/commands/pttl
    */
@@ -3619,6 +4223,13 @@ var Redis = class {
    * @see https://redis.io/commands/strlen
    */
   strlen = (...args) => new StrLenCommand(args, this.opts).exec(this.client);
+  /**
+   * @see https://redis.io/commands/subscribe
+   */
+  subscribe = (channels) => {
+    const channelArray = Array.isArray(channels) ? channels : [channels];
+    return new Subscriber(this.client, channelArray);
+  };
   /**
    * @see https://redis.io/commands/sunion
    */