@tsed/adapters 8.11.0 → 8.11.2-rc.1

package/src/adapters/LowDbAdapter.ts

@@ -1,135 +0,0 @@
-import {cleanObject} from "@tsed/core";
-import _ from "lodash";
-import isMatch from "lodash/isMatch.js";
-import type {Low, LowSync} from "lowdb";
-import {v4 as uuid} from "uuid";
-
-import {Adapter} from "../domain/Adapter.js";
-
-export interface AdapterModel {
-  _id: string;
-  expires_at?: Date;
-
-  [key: string]: any;
-}
-
-export interface LowModel<T> {
-  collection: T[];
-  collectionName?: string;
-  modelName?: string;
-}
-
-export class LowDbAdapter<T extends AdapterModel> extends Adapter<T> {
-  protected db: LowSync<LowModel<T>> | Low<LowModel<T>>;
-
-  get collection() {
-    return this.db.data!.collection!;
-  }
-
-  protected get dbFilePath() {
-    const lowdbDir = this.configuration.get("adapters.lowdbDir", ".db");
-    return `${lowdbDir}/${this.collectionName}.json`;
-  }
-
-  public async create(payload: Partial<T>, expiresAt?: Date): Promise<T> {
-    if (expiresAt) {
-      payload.expires_at = expiresAt;
-    }
-
-    payload._id = uuid();
-
-    await this.validate(payload as T);
-
-    await this.db.update(({collection}) => collection.push(this.serialize(payload)));
-
-    return this.deserialize(payload);
-  }
-
-  public async upsert(id: string, payload: T, expiresAt?: Date): Promise<T> {
-    let item = await this.findById(id);
-
-    if (!item) {
-      payload._id = id || uuid();
-
-      await this.validate(payload as T);
-
-      const item = this.serialize(payload);
-      item.expires_at = expiresAt;
-
-      await this.db.update(({collection}) => collection.push(item));
-
-      return this.deserialize(item);
-    }
-
-    return (await this.update(id, payload, expiresAt)) as T;
-  }
-
-  update(id: string, payload: T, expiresAt?: Date): Promise<T | undefined> {
-    return this.updateOne({_id: id}, payload, expiresAt);
-  }
-
-  public async updateOne(predicate: Partial<T & any>, payload: T, expiresAt?: Date): Promise<T | undefined> {
-    let index = _.findIndex(this.collection, cleanObject(predicate));
-
-    if (index === -1) {
-      return;
-    }
-
-    let item = this.deserialize(this.collection[index]);
-
-    Object.assign(item, payload, {_id: item._id});
-
-    await this.validate(item as T);
-
-    item.expires_at = expiresAt || item.expires_at;
-    this.db.update(({collection}) => (collection[index] = item));
-
-    return this.deserialize(item);
-  }
-
-  findOne(predicate: Partial<T & any>): Promise<T | undefined> {
-    const item = _.find(this.collection, cleanObject(predicate));
-
-    return this.deserialize(item);
-  }
-
-  findById(_id: string): Promise<T | undefined> {
-    return this.findOne({_id});
-  }
-
-  public async findAll(predicate: Partial<T & any> = {}): Promise<T[]> {
-    return _.filter(this.collection, cleanObject(predicate)).map((item) => this.deserialize(item));
-  }
-
-  public deleteOne(predicate: Partial<T & any>): Promise<T | undefined> {
-    const item = _.find<T>(this.collection, cleanObject(predicate));
-
-    if (item) {
-      _.remove(this.collection, ({_id}) => _id === item._id);
-
-      return Promise.resolve(this.deserialize(item));
-    }
-
-    return Promise.resolve(undefined);
-  }
-
-  public deleteById(_id: string): Promise<T | undefined> {
-    return this.deleteOne({_id} as any);
-  }
-
-  public async deleteMany(predicate: Partial<T>): Promise<T[]> {
-    let removedItems: T[] = [];
-
-    this.db.update((data) => {
-      _.remove(data.collection, (item) => {
-        if (isMatch(item, cleanObject(predicate))) {
-          removedItems.push(this.deserialize(item));
-          return true;
-        }
-        return false;
-      });
-    });
-
-    return removedItems;
-  }
-}

package/src/adapters/MemoryAdapter.spec.ts

@@ -1,226 +0,0 @@
-import {faker} from "@faker-js/faker";
-import {deserialize} from "@tsed/json-mapper";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {Format, getJsonSchema, Name, Property} from "@tsed/schema";
-
-import {Adapter} from "../domain/Adapter.js";
-import {Adapters} from "../services/Adapters.js";
-import {MemoryAdapter} from "./MemoryAdapter.js";
-
-class BaseClient {
-  @Format("date-time")
-  createdAt: Date;
-}
-
-class Client extends BaseClient {
-  @Name("id")
-  _id: string;
-
-  @Property()
-  name: string;
-}
-
-describe("MemoryAdapter", () => {
-  let adapter: Adapter<Client>;
-  beforeEach(() => PlatformTest.create());
-  afterEach(() => PlatformTest.reset());
-  beforeEach(() => {
-    adapter = PlatformTest.get<Adapters>(Adapters).invokeAdapter<any>({
-      collectionName: "clients",
-      model: Client,
-      adapter: MemoryAdapter
-    });
-  });
-  describe("getSchema", () => {
-    it("should", () => {
-      expect(getJsonSchema(Client)).toEqual({
-        properties: {
-          createdAt: {
-            format: "date-time",
-            type: "string"
-          },
-          id: {
-            type: "string"
-          },
-          name: {
-            type: "string"
-          }
-        },
-        type: "object"
-      });
-    });
-  });
-
-  describe("create()", () => {
-    it("should create a new instance", async () => {
-      const base = deserialize(
-        {
-          name: faker.person.jobTitle(),
-          createdAt: faker.date.past()
-        },
-        {type: Client}
-      );
-
-      const client = await adapter.create(base);
-
-      expect(client).toBeInstanceOf(Client);
-      expect(typeof client._id).toBe("string");
-      expect(client.name).toBe(base.name);
-      expect(client.createdAt).toEqual(base.createdAt);
-    });
-
-    it("should create a new instance with expireAt", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.create(base, new Date());
-
-      expect(client).toBeInstanceOf(Client);
-      expect(typeof client._id).toBe("string");
-      expect(client.name).toBe(base.name);
-    });
-  });
-
-  describe("upsert()", () => {
-    it("should create a new instance if not exists", async () => {
-      const base: any = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.upsert(base._id, base);
-
-      expect(client).toBeInstanceOf(Client);
-      expect(typeof client._id).toBe("string");
-      expect(client.name).toBe(base.name);
-    });
-
-    it("should update instance if exists", async () => {
-      const base: any = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.upsert(base._id, base);
-      const client2 = await adapter.upsert(client._id, client);
-
-      expect(client2).toBeInstanceOf(Client);
-      expect(typeof client2._id).toBe("string");
-      expect(client2.name).toBe(base.name);
-    });
-  });
-
-  describe("updateOne()", () => {
-    it("should update an instance", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.create(base);
-
-      const update = {
-        _id: client._id,
-        name: faker.person.jobTitle()
-      };
-
-      const client2 = await adapter.updateOne({_id: client._id}, update);
-
-      expect(client2).toBeInstanceOf(Client);
-      expect(typeof client2?._id).toBe("string");
-      expect(client2?.name).not.toBe(base.name);
-      expect(client2?.name).toBe(update.name);
-    });
-    it("should return undefined", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.updateOne({_id: faker.string.uuid()}, base);
-
-      expect(client).toBeUndefined();
-    });
-  });
-
-  describe("findById()", () => {
-    it("should find by ID", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      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);
-    });
-  });
-
-  describe("findOne()", () => {
-    it("should find one item", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.create(base);
-
-      const result = await adapter.findOne({
-        name: base.name
-      });
-
-      expect(result).toBeInstanceOf(Client);
-      expect(result?._id).toBe(client._id);
-      expect(result?.name).toBe(base.name);
-    });
-  });
-  describe("findAll()", () => {
-    it("should find all items", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      await adapter.create(base);
-
-      const result = await adapter.findAll({
-        name: base.name
-      });
-
-      expect(result[0]).toBeInstanceOf(Client);
-      expect(result[0].name).toBe(base.name);
-    });
-  });
-  describe("deleteById()", () => {
-    it("should delete an item by id", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.create(base);
-
-      const result = await adapter.deleteById(client._id);
-
-      expect(result).toBeInstanceOf(Client);
-      expect(result?.name).toBe(base.name);
-    });
-  });
-  describe("deleteMany()", () => {
-    it("should delete many", async () => {
-      const base = {
-        name: faker.person.jobTitle()
-      };
-
-      const client = await adapter.create(base);
-
-      await adapter.create({
-        name: faker.person.jobTitle()
-      });
-      await adapter.create({
-        name: faker.person.jobTitle()
-      });
-
-      const result = await adapter.deleteMany(client);
-
-      expect(result[0]).toBeInstanceOf(Client);
-      expect(result[0]?.name).toBe(base.name);
-    });
-  });
-});

package/src/adapters/MemoryAdapter.ts

@@ -1,20 +0,0 @@
-import {Configuration, Injectable, Opts, ProviderScope, Scope} from "@tsed/di";
-import {Low, Memory} from "lowdb";
-
-import {AdapterModel, LowDbAdapter} from "./LowDbAdapter.js";
-
-@Injectable()
-@Scope(ProviderScope.INSTANCE)
-export class MemoryAdapter<T extends AdapterModel> extends LowDbAdapter<T> {
-  constructor(@Opts options: any, @Configuration() configuration: Configuration) {
-    super(options, configuration);
-
-    this.db = new Low(new Memory(), {
-      collection: []
-    });
-  }
-
-  $onInit() {
-    return this.db.write();
-  }
-}

package/src/decorators/indexed.spec.ts

@@ -1,74 +0,0 @@
-import {Injectable} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {Property} from "@tsed/schema";
-
-import {MemoryAdapter} from "../adapters/MemoryAdapter.js";
-import {Adapter} from "../domain/Adapter.js";
-import {Indexed} from "./indexed.js";
-import {InjectAdapter} from "./injectAdapter.js";
-
-describe("Indexed", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(() => PlatformTest.create());
-  it("should inject adapter with indexed keys", async () => {
-    class Client {
-      @Indexed()
-      prop: string;
-    }
-
-    const stub = vi.fn();
-    @Injectable()
-    class Clients {
-      @InjectAdapter("client", Client)
-      adapter: Adapter<Client>;
-
-      $onInit() {
-        stub();
-      }
-    }
-
-    const clients = await PlatformTest.invoke<Clients>(Clients);
-
-    expect(clients.adapter).toBeInstanceOf(MemoryAdapter);
-    expect(stub).toHaveBeenCalledWith();
-    expect(clients.adapter.collectionName).toBe("client");
-    expect(clients.adapter.model).toBe(Client);
-    expect(clients.adapter.indexes).toEqual([
-      {
-        options: {},
-        propertyKey: "prop"
-      }
-    ]);
-  });
-  it("should inject adapter with indexed keys (by decorator)", async () => {
-    class Client {
-      @Property()
-      prop: string;
-    }
-
-    const stub = vi.fn();
-
-    @Injectable()
-    class Clients {
-      @InjectAdapter({model: Client, indexes: {prop: {}}})
-      adapter: Adapter<Client>;
-
-      $onInit() {
-        stub();
-      }
-    }
-
-    const clients = await PlatformTest.invoke<Clients>(Clients);
-
-    expect(clients.adapter).toBeInstanceOf(MemoryAdapter);
-    expect(stub).toHaveBeenCalledWith();
-    expect(clients.adapter.collectionName).toBe("Clients");
-    expect(clients.adapter.model).toBe(Client);
-    expect(clients.adapter.indexes).toEqual([
-      {
-        options: {},
-        propertyKey: "prop"
-      }
-    ]);
-  });
-});

package/src/decorators/indexed.ts

@@ -1,7 +0,0 @@
-import {JsonEntityFn} from "@tsed/schema";
-
-export function Indexed(): PropertyDecorator {
-  return JsonEntityFn((entity) => {
-    entity.store.set("adapter:indexed", {});
-  });
-}