feat(redis): opt-in raw support

docs/2.drivers/redis.md

@@ -30,6 +30,7 @@ import redisDriver from "unstorage/drivers/redis";
 
 const storage = createStorage({
   driver: redisDriver({
+    raw: true,
     base: "unstorage",
     host: 'HOSTNAME',
     tls: true as any,
@@ -46,6 +47,7 @@ Usage with Redis cluster (e.g. AWS ElastiCache or Azure Redis Cache):
 ```js
 const storage = createStorage({
   driver: redisDriver({
+    raw: true,
     base: "{unstorage}",
     cluster: [
       {
@@ -70,6 +72,7 @@ const storage = createStorage({
 - `cluster`: List of redis nodes to use for cluster mode. Takes precedence over `url` and `host` options.
 - `clusterOptions`: Options to use for cluster mode.
 - `ttl`: Default TTL for all items in **seconds**.
+- `raw`: If enabled, `getItemRaw` and `setItemRaw` will use binary data instead of base64 encoded strings. (this option will be enabled by default in the next major version.)
 
 See [ioredis](https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options) for all available options.
 

src/drivers/redis.ts

@@ -1,4 +1,5 @@
-import { defineDriver, joinKeys } from "./utils";
+import type { TransactionOptions } from "../types";
+import { defineDriver, joinKeys, createError } from "./utils";
 // TODO: use named import in v2
 import Redis, {
   Cluster,
@@ -32,6 +33,12 @@
    * Default TTL for all items in seconds.
    */
   ttl?: number;
+
+  /**
+   * If enabled, `getItemRaw` and `setItemRaw` will use binary data instead of base64 encoded strings.
+   * This option will be enabled by default in the next major version.
+   */
+  raw?: boolean;
 }
 
 const DRIVER_NAME = "redis";
@@ -67,6 +74,13 @@
       const value = await getRedisClient().get(p(key));
       return value ?? null;
     },
+    getItemRaw:
+      opts.raw === true
+        ? async (key: string) => {
+            const value = await getRedisClient().getBuffer(p(key));
+            return value ?? null;
+          }
+        : undefined,
     async setItem(key, value, tOptions) {
       const ttl = tOptions?.ttl ?? opts.ttl;
       if (ttl) {
@@ -75,6 +89,36 @@
         await getRedisClient().set(p(key), value);
       }
     },
+    setItemRaw:
+      opts.raw === true
+        ? async (
+            key: string,
+            value: Uint8Array,
+            tOptions: TransactionOptions
+          ) => {
+            let valueToSave: Buffer;
+            if (value instanceof Uint8Array) {
+              if (value instanceof Buffer) {
+                valueToSave = value;
+              } else {
+                valueToSave = Buffer.copyBytesFrom(
+                  value,
+                  value.byteOffset,
+                  value.byteLength
+                );
+              }
+            } else {
+              throw createError(DRIVER_NAME, "Expected Buffer or Uint8Array");
+            }
+
+            const ttl = tOptions?.ttl ?? opts.ttl;
+            if (ttl) {
+              await getRedisClient().set(p(key), valueToSave, "EX", ttl);
+            } else {
+              await getRedisClient().set(p(key), valueToSave);
+            }
+          }
+        : undefined,
     async removeItem(key) {
       await getRedisClient().del(p(key));
     },

test/drivers/redis.test.ts

@@ -5,7 +5,7 @@ import { testDriver } from "./utils";
 
 vi.mock("ioredis", () => ioredis);
 
-describe("drivers: redis", () => {
+describe("drivers: redis (raw: false)", () => {
   const driver = redisDriver({
     base: "test:",
     url: "ioredis://localhost:6379/0",
@@ -32,9 +32,79 @@ describe("drivers: redis", () => {
         await client.disconnect();
       });
 
+      it("saves raw data as a base64 string", async () => {
+        const helloBuffer = Buffer.from("Hello, world!", "utf8");
+        const byteArray = new Uint8Array(4);
+        byteArray[0] = 2;
+        byteArray[1] = 0;
+        byteArray[2] = 2;
+        byteArray[3] = 5;
+
+        await ctx.storage.setItemRaw("s4:a", helloBuffer);
+        await ctx.storage.setItemRaw("s5:a", byteArray);
+
+        const client = new ioredis.default("ioredis://localhost:6379/0");
+
+        const bufferValue = await client.get("test:s4:a");
+        expect(bufferValue).toEqual("base64:SGVsbG8sIHdvcmxkIQ==");
+
+        const byteArrayValue = await client.get("test:s5:a");
+        expect(byteArrayValue).toEqual("base64:AgACBQ==");
+
+        await client.disconnect();
+      });
+
       it("exposes instance", () => {
         expect(driver.getInstance?.()).toBeInstanceOf(ioredis.default);
       });
     },
   });
 });
+
+describe("drivers: redis (raw: true)", () => {
+  const binaryDriver = redisDriver({
+    base: "test:",
+    url: "ioredis://localhost:6379/0",
+    lazyConnect: false,
+    raw: true,
+  });
+
+  testDriver({
+    driver: binaryDriver,
+    additionalTests(ctx) {
+      it("saves raw data as binary", async () => {
+        const helloBuffer = Buffer.from("Hello, world!", "utf8");
+        const byteArray = new Uint8Array(4);
+        byteArray[0] = 2;
+        byteArray[1] = 0;
+        byteArray[2] = 2;
+        byteArray[3] = 5;
+
+        await ctx.storage.setItemRaw("s4:a", helloBuffer);
+        await ctx.storage.setItemRaw("s5:a", byteArray);
+
+        const client = new ioredis.default("ioredis://localhost:6379/0");
+
+        const bufferValue = await client.getBuffer("test:s4:a");
+        expect(bufferValue).toEqual(helloBuffer);
+
+        const byteArrayValue = await client.getBuffer("test:s5:a");
+        expect(byteArrayValue).toEqual(Buffer.from([2, 0, 2, 5]));
+
+        await client.disconnect();
+      });
+
+      it("expects binary data to be sent to setItemRaw", async () => {
+        expect(() =>
+          ctx.storage.setItemRaw("s4:a", "Hello, world!")
+        ).rejects.toThrow("Expected Buffer or Uint8Array");
+        expect(() => ctx.storage.setItemRaw("s5:a", 100)).rejects.toThrow(
+          "Expected Buffer or Uint8Array"
+        );
+        expect(() =>
+          ctx.storage.setItemRaw("s5:a", { foo: "bar" })
+        ).rejects.toThrow("Expected Buffer or Uint8Array");
+      });
+    },
+  });
+});