Add XTRIM command

pkg/commands/mod.ts

@@ -135,6 +135,7 @@ export * from "./xdel";
 export * from "./xlen";
 export * from "./xrange";
 export * from "./xrevrange";
+export * from "./xtrim";
 export * from "./zadd";
 export * from "./zcard";
 export * from "./zcount";

pkg/commands/xrange.test.ts

@@ -18,7 +18,11 @@ describe("without options", () => {
     const field2 = "field2";
     const member2 = randomID();
 
-    await new XAddCommand([key, "*", { [field1]: member1, [field2]: member2 }]).exec(client);
+    await new XAddCommand([
+      key,
+      "*",
+      { [field1]: member1, [field2]: member2 },
+    ]).exec(client);
 
     const res = await new XRangeCommand([key, "-", "+"]).exec(client);
     expect(Object.keys(res).length).toBe(1);
@@ -49,7 +53,7 @@ describe("limit", () => {
   });
 });
 
-test("many fields", () => {
+describe("many fields", () => {
   test("returns all fields", async () => {
     const key = newKey();
 

pkg/commands/xtrim.test.ts

@@ -0,0 +1,107 @@
+import { keygen, newHttpClient, randomID } from "../test-utils";
+
+import { afterAll, describe, expect, test } from "bun:test";
+import { XAddCommand } from "./xadd";
+import { XLenCommand } from "./xlen";
+import { XTrimCommand } from "./xtrim";
+
+const client = newHttpClient();
+
+const { newKey, cleanup } = keygen();
+afterAll(cleanup);
+
+describe("XLEN", () => {
+  test(
+    "should approximately trim stream to 300 items",
+    async () => {
+      const key = newKey();
+
+      const promises = [];
+      for (let i = 1; i <= 10000; i++) {
+        promises.push(
+          new XAddCommand([key, "*", { [randomID()]: randomID() }]).exec(client)
+        );
+      }
+      await Promise.all(promises);
+
+      await new XTrimCommand([
+        key,
+        { strategy: "MAXLEN", threshold: 300, exactness: "~" },
+      ]).exec(client);
+
+      const len = await new XLenCommand([key]).exec(client);
+
+      expect(len).toBeGreaterThanOrEqual(290);
+      expect(len).toBeLessThanOrEqual(310);
+    },
+    { timeout: 1000 * 60 }
+  );
+
+  test("should trim with zero threshold and remove everything", async () => {
+    const key = newKey();
+
+    const promises = [];
+    for (let i = 1; i <= 50; i++) {
+      promises.push(
+        new XAddCommand([key, "*", { [randomID()]: randomID() }]).exec(client)
+      );
+    }
+    await Promise.all(promises);
+
+    await new XTrimCommand([
+      key,
+      { strategy: "MAXLEN", threshold: 0, exactness: "=" },
+    ]).exec(client);
+
+    const len = await new XLenCommand([key]).exec(client);
+    expect(len).toBeLessThanOrEqual(1);
+  });
+
+  test(
+    "should trim with MINID and a limit and only remove 10 items that satisfies MINID",
+    async () => {
+      const key = newKey();
+      const baseTimestamp = Date.now();
+
+      for (let i = 0; i < 100; i++) {
+        const id = `${baseTimestamp}-${i}`;
+        await new XAddCommand([key, id, { data: `value${i}` }]).exec(client);
+      }
+
+      const midRangeId = `${baseTimestamp}-50`;
+
+      await new XTrimCommand([
+        key,
+        { strategy: "MINID", threshold: midRangeId, limit: 10 },
+      ]).exec(client);
+
+      const len = await new XLenCommand([key]).exec(client);
+      expect(len).toBeLessThanOrEqual(100);
+    },
+    { timeout: 20000 }
+  );
+
+  test(
+    "should trim with MINID and a without limit and delete half of the elements",
+    async () => {
+      const key = newKey();
+      const baseTimestamp = Date.now();
+
+      for (let i = 0; i < 100; i++) {
+        const id = `${baseTimestamp}-${i}`;
+        await new XAddCommand([key, id, { data: `value${i}` }]).exec(client);
+      }
+
+      const midRangeId = `${baseTimestamp}-50`;
+
+      await new XTrimCommand([
+        key,
+        { strategy: "MINID", threshold: midRangeId },
+      ]).exec(client);
+
+      const len = await new XLenCommand([key]).exec(client);
+      expect(len).toBeLessThanOrEqual(50);
+    },
+    { timeout: 20000 }
+  );
+});

pkg/commands/xtrim.ts

@@ -0,0 +1,33 @@
+import { Command, CommandOptions } from "./command";
+
+/**
+ * @see https://redis.io/commands/xtrim
+ */
+
+type XTrimOptions = {
+  strategy: "MAXLEN" | "MINID";
+  exactness?: "~" | "=";
+  threshold: number | string;
+  limit?: number;
+};
+
+export class XTrimCommand extends Command<number, number> {
+  constructor(
+    [key, options]: [key: string, options: XTrimOptions],
+    opts?: CommandOptions<number, number>
+  ) {
+    const { limit, strategy, threshold, exactness = "~" } = options;
+
+    super(
+      [
+        "XTRIM",
+        key,
+        strategy,
+        exactness,
+        threshold,
+        ...(limit ? ["LIMIT", limit] : []),
+      ],
+      opts
+    );
+  }
+}

pkg/pipeline.ts

@@ -138,6 +138,7 @@ import {
   XLenCommand,
   XRangeCommand,
   XRevRangeCommand,
+  XTrimCommand,
   ZAddCommand,
   ZAddCommandOptions,
   ZCardCommand,
@@ -1015,6 +1016,12 @@ export class Pipeline<TCommands extends Command<any, any>[] = []> {
   xlen = (...args: CommandArgs<typeof XLenCommand>) =>
     this.chain(new XLenCommand(args, this.commandOptions));
 
+  /**
+   * @see https://redis.io/commands/xtrim
+   */
+  xtrim = (...args: CommandArgs<typeof XTrimCommand>) =>
+    this.chain(new XTrimCommand(args, this.commandOptions));
+
   /**
    * @see https://redis.io/commands/xrange
    */

pkg/redis.ts

@@ -138,6 +138,7 @@ import {
   XLenCommand,
   XRangeCommand,
   XRevRangeCommand,
+  XTrimCommand,
   ZAddCommand,
   ZAddCommandOptions,
   ZCardCommand,
@@ -1109,6 +1110,12 @@ export class Redis {
   xlen = (...args: CommandArgs<typeof XLenCommand>) =>
     new XLenCommand(args, this.opts).exec(this.client);
 
+  /**
+   * @see https://redis.io/commands/xtrim
+   */
+  xtrim = (...args: CommandArgs<typeof XTrimCommand>) =>
+    new XTrimCommand(args, this.opts).exec(this.client);
+
   /**
    * @see https://redis.io/commands/xrange
    */