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

@@ -32,6 +32,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 +73,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 +88,18 @@
         await getRedisClient().set(p(key), value);
       }
     },
+    setItemRaw:
+      opts.raw === true
+        ? async (key, value, tOptions) => {
+            const _value = normalizeValue(value);
+            const ttl = tOptions?.ttl ?? opts.ttl;
+            if (ttl) {
+              await getRedisClient().set(p(key), _value, "EX", ttl);
+            } else {
+              await getRedisClient().set(p(key), _value);
+            }
+          }
+        : undefined,
     async removeItem(key) {
       await getRedisClient().del(p(key));
     },
@@ -96,3 +121,40 @@
     },
   };
 });
+
+function normalizeValue(value: unknown): Buffer | string | number {
+  const type = typeof value;
+  if (type === "string" || type === "number") {
+    return value as string | number;
+  }
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+  if (isTypedArray(value)) {
+    if (Buffer.copyBytesFrom) {
+      return Buffer.copyBytesFrom(value, value.byteOffset, value.byteLength);
+    } else {
+      return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    }
+  }
+  if (value instanceof ArrayBuffer) {
+    return Buffer.from(value);
+  }
+  return JSON.stringify(value);
+}
+
+function isTypedArray(value: unknown): value is TypedArray {
+  return (
+    value instanceof Int8Array ||
+    value instanceof Uint8Array ||
+    value instanceof Uint8ClampedArray ||
+    value instanceof Int16Array ||
+    value instanceof Uint16Array ||
+    value instanceof Int32Array ||
+    value instanceof Uint32Array ||
+    value instanceof Float32Array ||
+    value instanceof Float64Array ||
+    value instanceof BigInt64Array ||
+    value instanceof BigUint64Array
+  );
+}

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,67 @@ 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();
+      });
+    },
+  });
+});