@tsed/adapters-redis 8.0.1 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/adapters-redis",
   "description": "Redis adapter for Ts.ED",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -22,25 +23,25 @@
     "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
-    "@tsed/adapters": "8.0.1",
-    "@tsed/ioredis": "8.0.1",
+    "@tsed/adapters": "8.0.2",
+    "@tsed/ioredis": "8.0.2",
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/hooks": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/hooks": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/adapters": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/hooks": "8.0.1",
-    "@tsed/platform-http": "8.0.1",
+    "@tsed/adapters": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/hooks": "8.0.2",
+    "@tsed/platform-http": "8.0.2",
     "ioredis": ">=5.2.3",
     "ioredis-mock": ">=8.2.2",
     "uuid": "^10.0.0"

package/src/adapters/OIDCRedisAdapter.spec.ts

@@ -0,0 +1,184 @@
+import {Adapters} from "@tsed/adapters";
+import {IORedisTest, registerConnectionProvider} from "@tsed/ioredis";
+import {Redis} from "ioredis";
+// @ts-ignore
+import IORedisMock from "ioredis-mock";
+import moment from "moment";
+
+import {OIDCRedisAdapter} from "./OIDCRedisAdapter.js";
+
+const REDIS_CONNECTION = Symbol.for("redis_connection");
+
+registerConnectionProvider({
+  token: REDIS_CONNECTION
+});
+function createAdapterFixture(collectionName: string) {
+  const adapter = IORedisTest.get<Adapters>(Adapters).invokeAdapter({
+    collectionName,
+    model: Object,
+    adapter: OIDCRedisAdapter
+  }) as OIDCRedisAdapter<any>;
+
+  const redis = IORedisTest.get<Redis>(REDIS_CONNECTION);
+
+  return {adapter, redis};
+}
+
+async function createInitialDBFixture() {
+  const {adapter} = await createAdapterFixture("AccessToken");
+
+  const payload = {
+    grantId: "grantId",
+    userCode: "userCode",
+    uid: "uid",
+    _id: "id"
+  };
+
+  await adapter.upsert("id", payload);
+
+  return adapter;
+}
+
+describe("OIDCRedisAdapter", () => {
+  beforeEach(() => IORedisTest.create());
+  afterEach(() => IORedisTest.reset());
+
+  describe("onInsert()", () => {
+    it("should test if the table is grantable and add index for grantId and the current payload", async () => {
+      const {adapter, redis} = await createAdapterFixture("AccessToken");
+
+      const payload = {
+        grantId: "grantId",
+        userCode: "userCode",
+        uid: "uid",
+        _id: "id"
+      };
+
+      await adapter.upsert("id", payload);
+
+      const keys = await redis.keys("$oidc:*");
+
+      expect(await redis.get("$oidc:grant:grantId")).toEqual(["AccessToken:id"]);
+      expect(keys).toEqual(["$oidc:grant:grantId", "$oidc:userCode:userCode", "$oidc:uid:uid"]);
+    });
+    it("should set the expiration ttl", async () => {
+      const {adapter, redis} = await createAdapterFixture("AccessToken");
+
+      const payload = {
+        grantId: "grantId",
+        userCode: "userCode",
+        uid: "uid",
+        _id: "id"
+      };
+
+      await adapter.upsert("id", payload, moment().add(2, "days").toDate());
+
+      const ttl = await redis.ttl("$oidc:grant:grantId");
+
+      expect(ttl).toBeGreaterThan(100000);
+    });
+    it("should create grant indexes if the payload type isn't grantable", async () => {
+      const {adapter, redis} = await createAdapterFixture("Other");
+
+      const payload = {
+        grantId: "grantId",
+        userCode: "userCode",
+        uid: "uid",
+        _id: "id"
+      };
+
+      await adapter.upsert("id", payload);
+
+      const keys = await redis.keys("$oidc:*");
+
+      expect(keys).toEqual(["$oidc:userCode:userCode", "$oidc:uid:uid"]);
+    });
+  });
+
+  describe("findByUid()", () => {
+    it("should retrieve the payload by his uid", async () => {
+      const adapter = await createInitialDBFixture();
+
+      const result = await adapter.findByUid("uid");
+
+      expect(result).toEqual({
+        _id: "id",
+        grantId: "grantId",
+        uid: "uid",
+        userCode: "userCode"
+      });
+    });
+    it("should not retrieve the payload by his uid", async () => {
+      const adapter = await createInitialDBFixture();
+
+      const result = await adapter.findByUid("wrong");
+
+      expect(result).toEqual(null);
+    });
+  });
+
+  describe("findByUserCode()", () => {
+    it("should retrieve the payload by his userCode", async () => {
+      const adapter = await createInitialDBFixture();
+
+      const result = await adapter.findByUserCode("userCode");
+
+      expect(result).toEqual({
+        _id: "id",
+        grantId: "grantId",
+        uid: "uid",
+        userCode: "userCode"
+      });
+    });
+
+    it("should not retrieve the payload by his userCode", async () => {
+      const adapter = await createInitialDBFixture();
+
+      const result = await adapter.findByUserCode("wrong");
+
+      expect(result).toEqual(null);
+    });
+  });
+
+  describe("destroy()", () => {
+    it("should retrieve the payload by his userCode", async () => {
+      const adapter = await createInitialDBFixture();
+
+      await adapter.destroy("id");
+
+      const result = await adapter.findById("id");
+
+      expect(result).toEqual(undefined);
+    });
+  });
+
+  describe("revokeGrantId()", () => {
+    it("should retrieve the payload by his userCode", async () => {
+      const adapter = await createInitialDBFixture();
+
+      const keys = await adapter.db.lrange("$oidc:grant:grantId", 0, -1);
+
+      expect(keys).toEqual(["AccessToken:id"]);
+
+      expect(await adapter.db.get("AccessToken:id")).toEqual('{"grantId":"grantId","userCode":"userCode","uid":"uid","_id":"id"}');
+      expect(await adapter.db.get("$oidc:grant:grantId")).toEqual(["AccessToken:id"]);
+
+      await adapter.revokeByGrantId("grantId");
+
+      expect(await adapter.db.get("AccessToken:id")).toEqual(null);
+      expect(await adapter.db.get("$oidc:grant:grantId")).toEqual(null);
+    });
+  });
+
+  describe("consumes()", () => {
+    it("should set a consume flag in redis", async () => {
+      const {adapter} = await createAdapterFixture("AuthorizationCode");
+
+      await adapter.consume("codeId");
+
+      const result = await adapter.db.hget("AuthorizationCode:codeId", "consumed");
+
+      expect(!isNaN(Number(result))).toBe(true);
+    });
+  });
+});

package/src/adapters/OIDCRedisAdapter.ts

@@ -0,0 +1,103 @@
+import {AdapterModel} from "@tsed/adapters";
+import {Configuration, Inject, Opts} from "@tsed/di";
+import {IORedis, IOREDIS_CONNECTIONS} from "@tsed/ioredis";
+import {ChainableCommander} from "ioredis";
+
+import {RedisAdapter, RedisAdapterConstructorOptions} from "./RedisAdapter.js";
+
+const GRANTABLE = new Set(["AccessToken", "AuthorizationCode", "RefreshToken", "DeviceCode", "BackchannelAuthenticationRequest"]);
+const CONSUMABLE = new Set(["AuthorizationCode", "RefreshToken", "DeviceCode", "BackchannelAuthenticationRequest"]);
+
+function grantKeyFor(id: string) {
+  return `$oidc:grant:${id}`;
+}
+
+function userCodeKeyFor(userCode: string) {
+  return `$oidc:userCode:${userCode}`;
+}
+
+function uidKeyFor(uid: string) {
+  return `$oidc:uid:${uid}`;
+}
+
+export class OIDCRedisAdapter<T extends AdapterModel> extends RedisAdapter<T> {
+  protected isGrantable: boolean;
+
+  constructor(
+    @Opts options: RedisAdapterConstructorOptions,
+    @Inject(IOREDIS_CONNECTIONS) connections: IORedis[],
+    @Configuration() protected configuration: Configuration
+  ) {
+    super(options, connections, configuration);
+
+    this.useHash = CONSUMABLE.has(this.collectionName);
+    this.isGrantable = GRANTABLE.has(this.collectionName);
+    this.hooks.on("insert", this.onInsert.bind(this));
+  }
+
+  async onInsert(multi: ChainableCommander, payload: T, expiresIn: number) {
+    const id = payload._id;
+
+    const key = this.key(id);
+
+    if (this.isGrantable && payload.grantId) {
+      const grantKey = grantKeyFor(payload.grantId);
+
+      multi.rpush(grantKey, key);
+      // if you're seeing grant key lists growing out of acceptable proportions consider using LTRIM
+      // here to trim the list to an appropriate length
+      const ttl = await this.db.ttl(grantKey);
+
+      if (expiresIn && expiresIn > ttl) {
+        multi.expire(grantKey, expiresIn);
+      }
+    }
+
+    if (payload.userCode) {
+      const userCodeKey = userCodeKeyFor(payload.userCode);
+
+      multi.set(userCodeKey, id);
+      expiresIn && multi.expire(userCodeKey, expiresIn);
+    }
+
+    if (payload.uid) {
+      const uidKey = uidKeyFor(payload.uid);
+
+      multi.set(uidKey, id);
+      expiresIn && multi.expire(uidKey, expiresIn);
+    }
+
+    return multi;
+  }
+
+  async findByUid(uid: string) {
+    const id = await this.db.get(uidKeyFor(uid));
+
+    return id && this.findById(id);
+  }
+
+  async findByUserCode(userCode: string) {
+    const id = await this.db.get(userCodeKeyFor(userCode));
+    return id && this.findById(id);
+  }
+
+  async destroy(id: string) {
+    const key = this.key(id);
+    await this.db.del(key);
+  }
+
+  async revokeByGrantId(grantId: string) {
+    const multi = this.db.multi();
+    const key = grantKeyFor(grantId);
+    const tokens = await this.db.lrange(key, 0, -1);
+
+    tokens.forEach((token) => multi.del(token));
+    multi.del(grantKeyFor(grantId));
+
+    await multi.exec();
+  }
+
+  async consume(id: string) {
+    await this.db.hset(this.key(id), "consumed", Math.floor(Date.now() / 1000));
+  }
+}

package/src/adapters/RedisAdapter.spec.ts

@@ -0,0 +1,413 @@
+import {AdapterModel, Adapters, Indexed} from "@tsed/adapters";
+import {IORedisTest, registerConnectionProvider} from "@tsed/ioredis";
+import {deserialize} from "@tsed/json-mapper";
+import {Property, Required} from "@tsed/schema";
+
+import {RedisAdapter} from "./RedisAdapter.js";
+
+const REDIS_CONNECTION = Symbol.for("redis_connection");
+
+registerConnectionProvider({
+  token: REDIS_CONNECTION
+});
+
+class Client {
+  @Property()
+  _id: string;
+
+  @Indexed()
+  name: string;
+
+  @Property()
+  @Required()
+  secret: string;
+}
+
+function createAdapterFixture<Model extends AdapterModel = Client>({
+  collectionName = "client",
+  model = Client
+}: {collectionName?: string; model?: any} = {}) {
+  const adapter = IORedisTest.get<Adapters>(Adapters).invokeAdapter<Model>({
+    collectionName,
+    model,
+    adapter: RedisAdapter,
+    useHash: collectionName === "AuthorizationCode"
+  }) as RedisAdapter<Model>;
+
+  return {adapter};
+}
+
+describe("RedisAdapter", () => {
+  beforeEach(() => IORedisTest.create());
+  afterEach(() => IORedisTest.reset());
+
+  describe("create()", () => {
+    it("should create a new instance", async () => {
+      const {adapter} = await createAdapterFixture();
+
+      const base = {
+        name: "name",
+        secret: "secret"
+      };
+
+      const client = await adapter.create(base, new Date(Date.now() + 3000));
+
+      expect(client).toBeInstanceOf(Client);
+      expect(typeof client._id).toBe("string");
+      expect(client.name).toBe(base.name);
+
+      const keys = await adapter.db.keys("*");
+
+      expect(keys).toContain("client:" + client._id);
+      expect(keys).toContain(`$idx:client:${client._id}:name(${base.name})`);
+    });
+  });
+  describe("upsert()", () => {
+    it("should upsert a new instance", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret"
+        },
+        {type: Client}
+      );
+      const id = "uuid";
+
+      const client = await adapter.upsert(id, base);
+      const client2 = await adapter.upsert(id, base);
+
+      expect(client).toBeInstanceOf(Client);
+      expect(typeof client._id).toBe("string");
+      expect(client._id).toBe(client2._id);
+      expect(client.name).toBe(base.name);
+
+      const keys = await adapter.db.keys("*");
+
+      expect(keys).toContain("client:" + client._id);
+      expect(keys).toContain(`$idx:client:${client._id}:name(${base.name})`);
+    });
+  });
+  describe("findById()", () => {
+    it("should find item by id (get)", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret"
+      };
+
+      const client = await adapter.create(base);
+      const result = await adapter.findById(client._id);
+
+      expect(result).toBeInstanceOf(Client);
+      expect(result?._id).toBe(client._id);
+      expect(result?.name).toBe(base.name);
+    });
+    it("should handle no item found by id (get)", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const result = await adapter.findById("does not exist");
+
+      expect(result).toBeFalsy();
+    });
+    it("should find item by id (hgetall)", async () => {
+      const {adapter} = await createAdapterFixture<any>({
+        collectionName: "AuthorizationCode",
+        model: Object
+      });
+
+      const base = {
+        key: "value"
+      };
+
+      const token = await adapter.create(base);
+      const result = await adapter.findById(token._id);
+
+      expect(result.key).toEqual(token.key);
+    });
+    it("should handle no item found by id (hgetall)", async () => {
+      const {adapter} = await createAdapterFixture<any>({
+        collectionName: "AuthorizationCode",
+        model: Object
+      });
+
+      const result = await adapter.findById("does not exist");
+
+      expect(result).toBeFalsy();
+    });
+  });
+  describe("findOne()", () => {
+    it("should find instance", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret"
+      };
+
+      const client = await adapter.create(base);
+
+      const result = await adapter.findOne({
+        name: base.name
+      });
+
+      expect(result).toBeInstanceOf(Client);
+      expect(result?.name).toBe(base.name);
+      expect(result?._id).toBe(client._id);
+    });
+    it("should find instance by id", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret"
+      };
+
+      const client = await adapter.create(base);
+
+      const result = await adapter.findOne({
+        _id: client._id,
+        name: base.name
+      });
+
+      expect(result).toBeInstanceOf(Client);
+      expect(result?._id).toBe(client._id);
+      expect(result?.name).toBe(base.name);
+    });
+    it("should not find data", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret",
+        otherProp: "name"
+      };
+
+      await adapter.create(base);
+
+      const result = await adapter.findOne({
+        name: base.name,
+        otherProp: base.otherProp
+      });
+
+      expect(result).toBeUndefined();
+    });
+  });
+  describe("findAll()", () => {
+    it("should find all data (one prop)", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret"
+      };
+
+      const client = await adapter.create(base);
+
+      const result = await adapter.findAll({
+        name: base.name
+      });
+
+      expect(result[0]).toBeInstanceOf(Client);
+      expect(result[0]?._id).toBe(client._id);
+      expect(result[0]?.name).toBe(base.name);
+    });
+    it("should find all by id (one prop)", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret"
+      };
+
+      const client = await adapter.create(base);
+
+      const result = await adapter.findAll({
+        _id: client._id
+      });
+
+      expect(result[0]).toBeInstanceOf(Client);
+      expect(result[0]?._id).toBe(client._id);
+      expect(result[0]?.name).toBe(base.name);
+    });
+    it("should find all items", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret"
+      };
+
+      const client = await adapter.create(base);
+
+      const result = await adapter.findAll({});
+
+      expect(result[0]).toBeInstanceOf(Client);
+      expect(result[0]?._id).toBe(client._id);
+      expect(result[0]?.name).toBe(base.name);
+    });
+    it("should not find data when predicate has an unknown prop", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = {
+        name: "name",
+        secret: "secret",
+        otherProp: "name"
+      };
+
+      await adapter.create(base);
+
+      const result = await adapter.findAll({
+        name: base.name,
+        otherProp: base.otherProp
+      });
+
+      expect(result).toEqual([]);
+    });
+  });
+  describe("updateOne()", () => {
+    it("should update one item and merge props (undefined props are filtered)", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret"
+        },
+        {type: Client}
+      );
+
+      const majItem = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret2"
+        },
+        {type: Client}
+      );
+
+      const client = await adapter.create(base);
+      const result = await adapter.updateOne(
+        {
+          name: base.name
+        },
+        majItem
+      );
+
+      expect(client).toBeInstanceOf(Client);
+      expect(typeof client._id).toBe("string");
+      expect(client._id).toBe(result?._id);
+      expect(client.name).toBe(base.name);
+      expect(client.secret).toBe("secret");
+    });
+    it("should not update item", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret"
+        },
+        {type: Client}
+      );
+
+      const client = await adapter.create(base);
+      const result = await adapter.updateOne(
+        {
+          name: `${base.name}2`
+        },
+        base
+      );
+
+      expect(result).toBeUndefined();
+      expect(client.name).toBe(base.name);
+    });
+  });
+  describe("deleteOne()", () => {
+    it("should remove one item", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret"
+        },
+        {type: Client}
+      );
+
+      const client = await adapter.create(base);
+      const result = await adapter.deleteOne({
+        name: base.name
+      });
+
+      expect(client).toBeInstanceOf(Client);
+      expect(typeof client._id).toBe("string");
+      expect(client._id).toBe(result?._id);
+      expect(client.name).toBe(base.name);
+    });
+    it("should not remove item", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret"
+        },
+        {type: Client}
+      );
+
+      const client = await adapter.create(base);
+      const result = await adapter.deleteOne({
+        name: `${base.name}2`
+      });
+
+      expect(result).toBeUndefined();
+      expect(client.name).toBe(base.name);
+    });
+  });
+  describe("deleteById()", () => {
+    it("should remove one item", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret"
+        },
+        {type: Client}
+      );
+
+      const client = await adapter.create(base);
+      const result = await adapter.deleteById(client._id);
+
+      expect(client).toBeInstanceOf(Client);
+      expect(typeof client._id).toBe("string");
+      expect(client._id).toBe(result?._id);
+      expect(client.name).toBe(base.name);
+    });
+  });
+  describe("deleteMany()", () => {
+    it("should remove items", async () => {
+      const {adapter} = await createAdapterFixture({});
+
+      const base = deserialize<Client>(
+        {
+          name: "name",
+          secret: "secret"
+        },
+        {type: Client}
+      );
+
+      const client = await adapter.create(base);
+      const result = await adapter.deleteMany({
+        name: base.name
+      });
+
+      expect(result[0]).toBeInstanceOf(Client);
+      expect(typeof result[0]._id).toBe("string");
+      expect(result[0]._id).toBe(client?._id);
+      expect(result[0].name).toBe(base.name);
+    });
+  });
+});

package/src/adapters/RedisAdapter.ts

@@ -0,0 +1,280 @@
+import {Adapter, AdapterConstructorOptions, AdapterModel} from "@tsed/adapters";
+import {cleanObject, isObject, isString} from "@tsed/core";
+import {Configuration, Inject, Opts} from "@tsed/di";
+import {Hooks} from "@tsed/hooks";
+import {IORedis, IOREDIS_CONNECTIONS} from "@tsed/ioredis";
+import type {ChainableCommander, Redis} from "ioredis";
+import {v4 as uuid} from "uuid";
+
+const getId = (key: string) => key.split(":")[2];
+const flatKeys = (keys: [Error | null, string[]][]): string[] => {
+  return keys.flatMap(([, result]) => result).filter(Boolean);
+};
+
+export interface RedisAdapterConstructorOptions extends AdapterConstructorOptions {
+  connectionName?: string;
+  useHash?: boolean;
+}
+
+export class RedisAdapter<Model extends AdapterModel> extends Adapter<Model> {
+  readonly hooks = new Hooks();
+  readonly connectionName: string;
+  readonly connection: IORedis;
+  protected useHash: boolean = false;
+
+  constructor(
+    @Opts options: RedisAdapterConstructorOptions,
+    @Inject(IOREDIS_CONNECTIONS) connections: IORedis[],
+    @Configuration() protected configuration: Configuration
+  ) {
+    super(options, configuration);
+
+    this.useHash = Boolean(options.useHash);
+    this.connectionName = options.connectionName || "default";
+    this.connection = connections.find((connection) => connection.name === this.connectionName)!; // || connections[0];
+  }
+
+  get db(): Redis {
+    return this.connection;
+  }
+
+  key(id: string) {
+    return `${this.collectionName}:${id}`;
+  }
+
+  public create(payload: Partial<Model>, expiresAt?: Date): Promise<Model> {
+    delete payload._id;
+    return this.insert(payload, expiresAt);
+  }
+
+  public async upsert(id: string, payload: Model, expiresAt?: Date): Promise<Model> {
+    const item = await this.findById(id);
+
+    if (!item) {
+      payload._id = id;
+
+      return this.insert(payload, expiresAt);
+    }
+
+    return this.update(id, payload, expiresAt) as unknown as Promise<Model>;
+  }
+
+  public update(id: string, payload: Model, expiresAt?: Date): Promise<Model | undefined> {
+    return this.updateOne({_id: id}, payload, expiresAt);
+  }
+
+  public async updateOne(predicate: Partial<Model & any>, payload: Model, expiresAt?: Date): Promise<Model | undefined> {
+    const item = await this.findOne(predicate);
+
+    if (!item) {
+      return undefined;
+    }
+
+    Object.assign(item, cleanObject(payload), {
+      _id: item._id
+    });
+
+    return this.insert(item, expiresAt);
+  }
+
+  async findOne(predicate: Partial<Model & any>): Promise<Model | undefined> {
+    const {_id, ...props} = predicate;
+
+    if (_id) {
+      return this.findById(_id);
+    }
+
+    const keys = Object.keys(props);
+    let foundKeys = await this.findKeys(props);
+
+    if (foundKeys.length < keys.length) {
+      return undefined;
+    }
+
+    const getId = (key: string) => key.split(":")[2];
+    const id = getId(foundKeys[0]);
+
+    foundKeys = foundKeys.filter((key) => id === getId(key));
+
+    return keys.length === foundKeys.length ? this.findById(id) : undefined;
+  }
+
+  async findById(_id: string): Promise<Model | undefined> {
+    const key = this.key(_id);
+
+    const item = this.useHash ? await this.db.hgetall(key) : await this.db.get(key);
+
+    // hgetall returns an empty object when there are no results, so we need to check for that.
+    if (!item || (this.useHash && isObject(item) && Object.keys(item).length === 0)) {
+      return undefined;
+    }
+
+    if (isString(item)) {
+      return this.deserialize(JSON.parse(item));
+    }
+
+    const {payload, ...rest} = item;
+
+    return {
+      ...rest,
+      ...(payload ? JSON.parse(payload) : {})
+    };
+  }
+
+  public async findAll(predicate: Partial<Model & any> = {}): Promise<Model[]> {
+    const {_id, ...props} = predicate;
+
+    if (_id) {
+      const item = await this.findById(_id);
+      return item ? [item] : [];
+    }
+
+    const keys = Object.keys(props);
+
+    if (keys.length === 0) {
+      return this.getAll();
+    }
+
+    return this.findAllBy(props);
+  }
+
+  public async deleteOne(predicate: Partial<Model & any>): Promise<Model | undefined> {
+    const item = await this.findOne(predicate);
+
+    if (item) {
+      const id = this.key(item._id);
+      const indexIds = await this.getAllIndex(item._id);
+
+      await this.db.del([id, ...indexIds]);
+
+      return this.deserialize(item);
+    }
+  }
+
+  public deleteById(_id: string): Promise<Model | undefined> {
+    return this.deleteOne({_id} as any);
+  }
+
+  public async deleteMany(predicate: Partial<Model>): Promise<Model[]> {
+    const items = await this.findAll(predicate);
+
+    const pipeline = this.db.pipeline();
+    const ids: string[] = [];
+
+    const results = items.map((item) => {
+      ids.push(this.key(item._id));
+
+      this.getAllIndex(item._id, pipeline);
+
+      return this.deserialize(item);
+    });
+
+    const keys = await pipeline.exec();
+
+    this.db.del([...ids, ...flatKeys(keys as any)]);
+
+    return results;
+  }
+
+  protected async findKeys(props: any): Promise<string[]> {
+    const keys: any[] = Object.keys(props);
+    const pipeline = this.db.pipeline();
+
+    this.indexes
+      .filter(({propertyKey}) => keys.includes(propertyKey))
+      .forEach(({propertyKey}) => {
+        const value = props[propertyKey];
+        const patterns = this.getIndexedKey("*", propertyKey, value);
+
+        pipeline.keys(patterns);
+      });
+
+    const results = await pipeline.exec();
+
+    return flatKeys(results as any[]);
+  }
+
+  protected async insert(payload: Partial<Model>, expiresAt?: Date) {
+    const id = (payload._id = payload._id || uuid());
+
+    const expiresIn = expiresAt ? expiresAt.getTime() - Date.now() : null;
+
+    await this.validate(payload as Model);
+
+    const multi = this.db.multi();
+    const key = this.key(id);
+
+    const strPayload = JSON.stringify(this.serialize(payload));
+
+    this.useHash ? await multi.hset(key, {payload: strPayload}) : await multi.set(key, strPayload);
+
+    if (expiresIn) {
+      multi.expire(key, expiresIn);
+    }
+
+    this.indexes.forEach(({propertyKey}) => {
+      const value = payload[propertyKey];
+      const indexedKey = this.getIndexedKey(id, propertyKey, value);
+
+      multi.set(indexedKey, id);
+      expiresIn && multi.expire(indexedKey, expiresIn);
+    });
+
+    await this.hooks.asyncAlter("insert", multi, [payload, expiresIn]);
+
+    await multi.exec();
+
+    const result = this.deserialize(payload, {useAlias: false});
+
+    await this.hooks.asyncEmit("afterInsert", [result]);
+
+    return result;
+  }
+
+  protected getAllIndex(id: string): Promise<string[]>;
+  protected getAllIndex(id: string, pipeline: ChainableCommander): ChainableCommander;
+  protected getAllIndex(id: string, pipeline?: ChainableCommander) {
+    const key = ["$idx", this.key(id), "*"].join(":");
+
+    return (pipeline || this.db).keys(key);
+  }
+
+  protected getIndexedKey(id: string, propertyKey: string, value: any): string {
+    const key = this.key(id);
+    return ["$idx", key, `${propertyKey}(${value})`].map(String).join(":");
+  }
+
+  protected async getAll(): Promise<Model[]> {
+    const keys = await this.db.keys(`${this.collectionName}:*`);
+    const pipeline = this.db.pipeline();
+
+    keys.forEach((key) => {
+      pipeline.get(key);
+    });
+
+    const result = await pipeline.exec();
+    return (result || []).map(([, data]: [any, string]) => this.deserialize(JSON.parse(data))).filter(Boolean);
+  }
+
+  protected async findAllBy(props: Partial<Model & any>): Promise<Model[]> {
+    const keys = Object.keys(props);
+    const foundKeys = await this.findKeys(props);
+
+    if (foundKeys.length < keys.length) {
+      return [];
+    }
+
+    const map = foundKeys.reduce((map: Map<string, number>, key) => {
+      const id = getId(key);
+      const value = map.get(id) || 0;
+
+      return map.set(id, value + 1);
+    }, new Map());
+
+    const promises = [...map.entries()].filter(([, num]) => num === keys.length).map(([id]) => this.findById(id));
+
+    const result = await Promise.all(promises);
+
+    return result.filter(Boolean) as Model[];
+  }
+}

package/src/domain/RedisAdaptersSettings.ts

@@ -0,0 +1,12 @@
+import {AdaptersSettings} from "@tsed/adapters";
+import {RedisOptions} from "ioredis";
+
+declare global {
+  namespace TsED {
+    interface AdaptersOptions extends AdaptersSettings {
+      redis: RedisOptions & {
+        indexes?: {[propertyKey: string]: Record<string, any>};
+      };
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./adapters/OIDCRedisAdapter.js";
+export * from "./adapters/RedisAdapter.js";
+export * from "./domain/RedisAdaptersSettings.js";