updated casing

Author: lemon-mario

src/Facade.ts

@@ -0,0 +1,20 @@
+import CountItems from "./functions/countItems";
+import CreateItem from "./functions/createItem";
+import DeleteItem from "./functions/deleteItem";
+import DeleteItems from "./functions/deleteItems";
+import GetItem from "./functions/getItem";
+import GetItems from "./functions/getItems";
+import ReplaceItem from "./functions/replaceItem";
+import UpdateItem from "./functions/updateItem";
+import Item from "./interfaces/item";
+
+export default interface Facade<I extends Item> {
+  readonly createItem: CreateItem<I>;
+  readonly getItem: GetItem<I>;
+  readonly getItems: GetItems<I>;
+  readonly deleteItem: DeleteItem<I>;
+  readonly deleteItems: DeleteItems<I>;
+  readonly updateItem: UpdateItem<I>;
+  readonly replaceItem: ReplaceItem<I>;
+  readonly countItems: CountItems<I>;
+}

src/errors/ConflictingItemError.ts

@@ -0,0 +1,13 @@
+import { BaseError } from "make-error";
+
+export default class ConflictingItemError extends BaseError {
+
+  public readonly itemName: string;
+  public readonly itemId: string;
+  
+  public constructor(itemName: string, itemId: string){
+    super();
+    this.itemName = itemName;
+    this.itemId = itemId;
+  }
+}

src/errors/ItemNotFoundError.ts

@@ -0,0 +1,13 @@
+import { BaseError } from "make-error";
+
+export default class ItemNotFoundError extends BaseError {
+
+  public readonly itemName: string;
+  public readonly itemId: string;
+  
+  public constructor(itemName: string, itemId: string){
+    super();
+    this.itemName = itemName;
+    this.itemId = itemId;
+  }
+}

src/errors/index.ts

@@ -0,0 +1,7 @@
+import ConflictingItemError from "./ConflictingItemError";
+import ItemNotFoundError from "./ItemNotFoundError";
+
+export {
+  ConflictingItemError,
+  ItemNotFoundError
+};

src/functions/CountItems/index.ts

@@ -0,0 +1,14 @@
+import Filter from '../../interfaces/filter';
+import Item from '../../interfaces/item';
+
+export interface Options<I extends Item> {
+  readonly filter?: Filter<I>;
+}
+
+export interface Result {
+  readonly count: number;
+}
+
+export type CountItems<I extends Item> = (options: Options<I>) => Promise<Result>;
+
+export default CountItems;

src/functions/CountItems/test.ts

@@ -0,0 +1,31 @@
+import Options from "../../interfaces/options";
+import { TestItem } from "../utils/testItem";
+import testUsingFilter from "../utils/testUsingFilter";
+
+export default ({ facade }: Options<TestItem>) => {
+  describe("countItems", () => {
+    testUsingFilter({
+      facade,
+      toGetAllItems: async filter => {
+        const { count } = await facade.countItems({ filter });
+        const expectedCount = 2;
+        expect(count).toBe(expectedCount);
+      },
+      toGetFirstItem: async filter => {
+        const { count } = await facade.countItems({ filter });
+        const expectedCount = 1;
+        expect(count).toBe(expectedCount);
+      },
+      toGetNoItems: async filter => {
+        const { count } = await facade.countItems({ filter });
+        const expectedCount = 0;
+        expect(count).toBe(expectedCount);
+      },
+      toGetSecondItem: async filter => {
+        const { count } = await facade.countItems({ filter });
+        const expectedCount = 1;
+        expect(count).toBe(expectedCount);
+      }
+    });
+  });
+};

src/functions/CreateItem/index.ts

@@ -0,0 +1,14 @@
+import Item from '../../interfaces/item';
+
+export interface Options<I extends Item> {
+  readonly id: string;
+  readonly item: I;
+}
+
+export interface Result<I extends Item> {
+  readonly item: I;
+}
+
+export type CreateItems<I extends Item> = (options: Options<I>) => Promise<Result<I>>;
+
+export default CreateItems;

src/functions/CreateItem/test.ts

@@ -0,0 +1,21 @@
+import ConflictingItemError from "../../errors/ConflictingItemError";
+import Options from "../../interfaces/options";
+import testItem, { testId, TestItem } from "../utils/testItem";
+
+export default ({ facade }: Options<TestItem>) => {
+  describe("createItem", () => {
+    it("creates an item", async () => {
+      await facade.createItem({ id: testId, item: testItem });
+    });
+
+    it("does not create an item and it throws error instead", async () => {
+      expect.assertions(1);
+      try {
+        await facade.createItem({ id: testId, item: testItem });
+        await facade.createItem({ id: testId, item: testItem });
+      } catch (e) {
+        expect(e).toBeInstanceOf(ConflictingItemError);
+      }
+    });
+  });
+};

src/functions/DeleteItem/index.ts

@@ -0,0 +1,11 @@
+import Filter from '../../interfaces/filter';
+import Item from '../../interfaces/item';
+
+export interface Options<I extends Item> {
+  readonly id: string;
+  readonly filter?: Filter<I>;
+}
+
+export type DeleteItem<I extends Item> = (options: Options<I>) => Promise<void>;
+
+export default DeleteItem;

src/functions/DeleteItem/test.ts

@@ -0,0 +1,71 @@
+import ItemNotFoundError from "../../errors/itemNotFoundError";
+import Options from "../../interfaces/options";
+import testItem, { testId, TestItem } from "../utils/testItem";
+import testUsingFilter, {
+  firstItemId,
+  secondItemId
+} from "../utils/testUsingFilter";
+
+export default ({ facade }: Options<TestItem>) => {
+  describe("deleteItem", () => {
+    testUsingFilter({
+      facade,
+      toGetAllItems: async filter => {
+        await facade.deleteItem({ id: firstItemId, filter });
+        await facade.deleteItem({ id: secondItemId, filter });
+        try {
+          await facade.getItem({ id: firstItemId });
+        } catch (e) {
+          expect(e).toBeInstanceOf(ItemNotFoundError);
+        }
+        try {
+          await facade.getItem({ id: secondItemId });
+        } catch (e) {
+          expect(e).toBeInstanceOf(ItemNotFoundError);
+        }
+      },
+      toGetFirstItem: async filter => {
+        await facade.deleteItem({ id: firstItemId, filter });
+        try {
+          await facade.getItem({ id: firstItemId });
+        } catch (e) {
+          expect(e).toBeInstanceOf(ItemNotFoundError);
+        }
+      },
+      toGetNoItems: async filter => {
+        try {
+          await facade.deleteItem({ id: secondItemId, filter });
+        } catch (e) {
+          expect(e).toBeInstanceOf(ItemNotFoundError);
+        }
+      },
+      toGetSecondItem: async filter => {
+        await facade.deleteItem({ id: secondItemId, filter });
+        try {
+          await facade.getItem({ id: secondItemId });
+        } catch (e) {
+          expect(e).toBeInstanceOf(ItemNotFoundError);
+        }
+      }
+    });
+
+    it("throws error when trying to delete an item which does not exist", async () => {
+      expect.assertions(1);
+      try {
+        await facade.deleteItem({ id: testId });
+      } catch (e) {
+        expect(e).toBeInstanceOf(ItemNotFoundError);
+      }
+    });
+
+    it("deletes an item which exists", async () => {
+      await facade.createItem({ id: testId, item: testItem });
+      await facade.deleteItem({ id: testId });
+      try {
+        await facade.getItem({ id: testId });
+      } catch (e) {
+        expect(e).toBeInstanceOf(ItemNotFoundError);
+      }
+    });
+  });
+};