@hyper-fetch/firebase-admin 7.5.1 → 7.5.3

package/__tests__/features/firestore/admin/constraints.admin.spec.ts

@@ -0,0 +1,23 @@
+/**
+ * @jest-environment node
+ */
+import { Client } from "@hyper-fetch/core";
+
+import { seedFirestoreDatabaseAdmin } from "../../../utils";
+import { firestoreDbAdmin } from "../../../utils/initialize.firestore.admin";
+import { constraintsSharedTestCases } from "../shared/constraints.shared.tests";
+import { FirebaseAdminAdapter } from "adapter";
+
+describe("Firestore Admin [ Constraints ]", () => {
+  const client = new Client({ url: "teas/" }).setAdapter(FirebaseAdminAdapter(firestoreDbAdmin));
+
+  beforeEach(async () => {
+    await seedFirestoreDatabaseAdmin(firestoreDbAdmin);
+  });
+
+  afterEach(async () => {
+    await firestoreDbAdmin.recursiveDelete(firestoreDbAdmin.collection("teas"));
+  });
+
+  constraintsSharedTestCases(client);
+});

package/__tests__/features/firestore/admin/methods.admin.spec.ts

@@ -0,0 +1,20 @@
+/**
+ * @jest-environment node
+ */
+
+import { seedFirestoreDatabaseAdmin } from "../../../utils";
+import { firestoreDbAdmin } from "../../../utils/initialize.firestore.admin";
+import { methodsSharedTestCases } from "../shared/methods.shared.tests";
+import { FirebaseAdminAdapter } from "adapter";
+
+describe("Firestore Admin [ Methods ]", () => {
+  beforeEach(async () => {
+    await firestoreDbAdmin.recursiveDelete(firestoreDbAdmin.collection("teas"));
+    await seedFirestoreDatabaseAdmin(firestoreDbAdmin);
+  });
+
+  afterEach(async () => {
+    await firestoreDbAdmin.recursiveDelete(firestoreDbAdmin.collection("teas"));
+  });
+  methodsSharedTestCases(() => FirebaseAdminAdapter(firestoreDbAdmin));
+});

package/__tests__/features/firestore/admin/sockets.base.spec.ts

@@ -0,0 +1,17 @@
+/**
+ * @jest-environment node
+ */
+
+import { seedFirestoreDatabaseAdmin } from "../../../utils";
+import { firestoreDbAdmin } from "../../../utils/initialize.firestore.admin";
+import { socketsMethodsSharedTestCases } from "../shared/methods.shared.tests";
+import { FirebaseSocketsAdminAdapter, FirebaseAdminAdapter } from "adapter";
+
+describe("Firestore Admin [ Sockets ]", () => {
+  beforeEach(async () => {
+    await firestoreDbAdmin.recursiveDelete(firestoreDbAdmin.collection("teas"));
+    await seedFirestoreDatabaseAdmin(firestoreDbAdmin);
+  });
+
+  socketsMethodsSharedTestCases(FirebaseSocketsAdminAdapter(firestoreDbAdmin), FirebaseAdminAdapter(firestoreDbAdmin));
+});

package/__tests__/features/firestore/shared/constraints.shared.tests.ts

@@ -0,0 +1,72 @@
+import { Client } from "@hyper-fetch/core";
+
+import { FirestoreAdapterType, FirestoreQueryParams } from "adapter";
+import { $limit, $orderBy, $where } from "constraints";
+import { Tea } from "../../../utils";
+
+export const constraintsSharedTestCases = (client: Client<Error, FirestoreAdapterType>) => {
+  describe("filtering", () => {
+    it("should return filtered data based on single filter", async () => {
+      const req = client.createRequest<{ response: Tea[]; queryParams: FirestoreQueryParams }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({ queryParams: { constraints: [$where("type", "==", "Green")] } });
+      expect(data).toHaveLength(3);
+      expect(data?.map((tea) => tea.type)).toStrictEqual(["Green", "Green", "Green"]);
+    });
+    it("should return filtered data based on compound AND filter", async () => {
+      const req = client.createRequest<{ response: Tea[]; queryParams: FirestoreQueryParams }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({
+        queryParams: { constraints: [$where("type", "==", "Green"), $where("amount", ">=", 50)] },
+      });
+      expect(data).toHaveLength(2);
+      expect(data?.map((tea) => tea.type)).toStrictEqual(["Green", "Green"]);
+    });
+  });
+  describe("ordering", () => {
+    it("should allow for returning ordered data", async () => {
+      const req = client.createRequest<{ response: Tea[]; queryParams: FirestoreQueryParams }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({ queryParams: { constraints: [$orderBy("year")] } });
+      expect(data?.map((tea) => tea.year)).toStrictEqual([1980, 2011, 2017, 2021, 2021, 2021, 2022, 2022, 2023, 2023]);
+    });
+  });
+  describe("limiting", () => {
+    it("should allow for limiting returned data", async () => {
+      const req = client.createRequest<{ response: Tea[]; queryParams: FirestoreQueryParams }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({ queryParams: { constraints: [$limit(5)] } });
+
+      expect(data).toHaveLength(5);
+    });
+  });
+  describe("complex contraint", () => {
+    it("should allow for filtering, ordering and limiting in the same query", async () => {
+      const req = client.createRequest<{ response: Tea[]; queryParams: FirestoreQueryParams }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data } = await req.send({
+        queryParams: { constraints: [$where("type", "==", "Green"), $orderBy("year"), $limit(1)] },
+      });
+      expect(data).toHaveLength(1);
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      const { __key, ...rest } = data?.[0] || {};
+      expect(rest).toStrictEqual({
+        name: "Hon.yama Sencha",
+        type: "Green",
+        origin: "Japan",
+        amount: 25,
+        year: 2021,
+      });
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods/add-doc.test.suite.ts

@@ -0,0 +1,29 @@
+import { Client } from "@hyper-fetch/core";
+
+import { FirebaseAdminAdapter } from "adapter";
+import { Tea } from "../../../../utils";
+
+export const addDocTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("addDoc", () => {
+    it("should allow for adding data to a list", async () => {
+      const newData = { origin: "Poland", type: "Green", year: 2023, name: "Pou Ran Do Cha", amount: 100 } as Tea;
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const getReq = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const pushReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: "",
+          method: "addDoc",
+          options: {},
+        })
+        .setPayload(newData);
+      await pushReq.send();
+      const { data } = await getReq.send();
+      const arrayedData = Object.values(data);
+
+      expect(arrayedData).toHaveLength(11);
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods/delete-doc.test.suite.ts

@@ -0,0 +1,52 @@
+import { Client } from "@hyper-fetch/core";
+
+import { FirebaseAdminAdapter } from "adapter";
+import { Tea } from "../../../../utils";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+
+export const deleteDocTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("deleteDoc", () => {
+    it("should allow for removing data", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const getReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+
+      const removeReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "deleteDoc",
+        })
+        .setParams({ teaId: 1 });
+
+      const { data: beforeRemoval } = await getReq.send();
+      await removeReq.send();
+      const { data } = await getReq.send();
+      expect(beforeRemoval).toStrictEqual({
+        __key: "1",
+        amount: 150,
+        year: 2023,
+        origin: "China",
+        name: "Taiping Hou Kui",
+        type: "Green",
+      });
+      expect(data).toBe(null);
+      // expect(extra.snapshot.exists()).toBe(false);
+    });
+    it("should emit lifecycle events", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+
+      const request = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "deleteDoc",
+        })
+        .setParams({ teaId: 1 });
+
+      await testLifecycleEvents(request);
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods/get-doc.test.suite.ts

@@ -0,0 +1,60 @@
+import { Client } from "@hyper-fetch/core";
+
+import { FirebaseAdminAdapter } from "adapter";
+import { Tea } from "../../../../utils";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+
+export const getDocTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("getDoc", () => {
+    it("should return data available for endpoint", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const req = client
+        .createRequest<{ response: Tea[] }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+      const { data, extra, status, success, error } = await req.send();
+      expect(data).toStrictEqual({
+        amount: 150,
+        name: "Taiping Hou Kui",
+        origin: "China",
+        type: "Green",
+        year: 2023,
+        __key: "1",
+      });
+      expect(extra).toHaveProperty("snapshot");
+      expect(extra).toHaveProperty("ref");
+      expect(status).toBe("success");
+      expect(success).toBe(true);
+      expect(error).toBe(null);
+    });
+    it("should return emptyResource status for non existing resource", async () => {
+      const client = new Client({ url: "bees/" }).setAdapter(adapterFunction());
+      const req = client
+        .createRequest<{ response: Tea[] }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+      const { data, extra, status, success, error } = await req.send();
+      expect(data).toStrictEqual(null);
+      expect(extra).toHaveProperty("snapshot");
+      expect(extra).toHaveProperty("ref");
+      expect(status).toBe("emptyResource");
+      expect(success).toBe(true);
+      expect(error).toBe(null);
+    });
+    it("should emit lifecycle events", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const request = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+
+      await testLifecycleEvents(request);
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods/get-docs.test.suite.ts

@@ -0,0 +1,45 @@
+import { Client } from "@hyper-fetch/core";
+
+import { FirebaseAdminAdapter } from "adapter";
+import { Tea } from "../../../../utils";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+
+export const getDocsTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("getDocs", () => {
+    it("should return data available for endpoint", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const req = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data, extra, status, success, error } = await req.send();
+      expect(data).toHaveLength(10);
+      expect(extra).toHaveProperty("snapshot");
+      expect(extra).toHaveProperty("ref");
+      expect(status).toBe("success");
+      expect(success).toBe(true);
+      expect(error).toBe(null);
+    });
+    it("should return emptyResource status for non existing resource", async () => {
+      const client = new Client({ url: "bees/" }).setAdapter(adapterFunction());
+      const req = client.createRequest<{ response: Tea[] }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+      const { data, status, success, error } = await req.send();
+      expect(data).toStrictEqual(null);
+      expect(status).toBe("emptyResource");
+      expect(success).toBe(true);
+      expect(error).toBe(null);
+    });
+    it("should emit lifecycle events", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const request = client.createRequest<{ response: Tea }>()({
+        endpoint: "",
+        method: "getDocs",
+      });
+
+      await testLifecycleEvents(request);
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods/on-snapshot.test.suite.ts

@@ -0,0 +1,290 @@
+import { Client } from "@hyper-fetch/core";
+import { Socket } from "@hyper-fetch/sockets";
+import waitForExpect from "wait-for-expect";
+
+import { FirebaseAdminAdapterTypes, FirebaseAdminSocketAdapterTypes } from "adapter";
+import { $where } from "constraints";
+import { Tea } from "../../../../utils";
+
+export const onSnapshotTestSuite = (
+  adapter: FirebaseAdminSocketAdapterTypes<any>,
+  coreAdapter: FirebaseAdminAdapterTypes<any>,
+) => {
+  const newData = { origin: "Poland", type: "Green", year: 2043, name: "Pou Ran Do Cha", amount: 100 } as Tea;
+  let spy = jest.fn();
+  beforeEach(() => {
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+    spy = jest.fn();
+  });
+  const initialize = async () => {
+    const client = new Client({ url: "teas/" }).setAdapter(coreAdapter);
+    const socket = new Socket({ url: "teas/", adapter });
+    const pushReq = client
+      .createRequest<{ response: Tea; payload: Tea }>()({
+        endpoint: "",
+        method: "addDoc",
+      })
+      .setPayload(newData);
+    const socketBees = new Socket({ url: "bees/", adapter });
+
+    return { client, socket, socketBees, pushReq };
+  };
+  describe("onSnapshot", () => {
+    it("should return unmount function", async () => {
+      const { socket } = await initialize();
+      const onSnapshotReq = socket.createListener<Tea[]>()({
+        topic: "",
+      });
+      const unmount = onSnapshotReq.listen(spy);
+      expect(unmount).toBeFunction();
+    });
+    it("should unmount listeners", async () => {
+      const { socket, pushReq } = await initialize();
+      const onSnapshotReq = socket.createListener<Tea[]>()({
+        topic: "",
+      });
+      const unmount = onSnapshotReq.listen(spy);
+
+      await waitForExpect(async () => {
+        expect(spy).toHaveBeenCalledTimes(1);
+      });
+
+      unmount();
+      await pushReq.send();
+      await pushReq.send();
+
+      await waitForExpect(async () => {
+        expect(spy).toHaveBeenCalledTimes(1);
+      }, 1000);
+
+      expect(socket.adapter.listeners.get(onSnapshotReq.topic)?.size).toBe(0);
+    });
+    it("should return emptyResource status", async () => {
+      const { socketBees } = await initialize();
+      const onSnapshotReq = socketBees.createListener<Tea[]>()({
+        topic: "",
+      });
+
+      let receivedData: any;
+      let receivedExtra: any;
+      let ref: any;
+
+      const unmount = onSnapshotReq.listen(({ data, extra }) => {
+        spy();
+        receivedData = data;
+        receivedExtra = extra;
+        ref = extra.ref;
+      });
+
+      await waitForExpect(async () => {
+        expect(spy).toHaveBeenCalled();
+        expect(ref).toBeDefined();
+        expect(receivedData).toBeNull();
+        expect(receivedExtra.status).toBe("emptyResource");
+      });
+
+      unmount();
+    });
+
+    it("should return data available for collection", async () => {
+      const { socket } = await initialize();
+      const onSnapshotReq = socket.createListener<Tea[]>()({
+        topic: "",
+      });
+
+      let receivedData: any;
+      let receivedExtra: any;
+      const unmount = onSnapshotReq.listen(({ data, extra }) => {
+        spy();
+        receivedData = data;
+        receivedExtra = extra;
+      });
+
+      await waitForExpect(async () => {
+        expect(receivedData).toHaveLength(10);
+        expect(receivedExtra).toHaveProperty("snapshot");
+        expect(receivedExtra).toHaveProperty("ref");
+        expect(receivedExtra.status).toBe("success");
+      });
+
+      unmount();
+    });
+    it("should inform about changes when groupByChangeType option is added", async () => {
+      const newTeaData = {
+        origin: "Poland",
+        type: "Green",
+        year: 2043,
+        name: "Pou Ran Do Cha",
+        amount: 100,
+      } as Tea;
+      const { socket, client } = await initialize();
+      const onSnapshotReq = socket.createListener<Tea[]>()({
+        topic: "",
+        options: { groupByChangeType: true },
+      });
+
+      const receivedData: any[] = [];
+      const receivedExtra: any[] = [];
+      const unmount = onSnapshotReq.listen(({ data, extra }) => {
+        spy();
+        receivedData.push(data);
+        receivedExtra.push(extra);
+      });
+
+      await waitForExpect(async () => {
+        expect(receivedData).toHaveLength(1);
+        expect(receivedData[0]).toHaveLength(10);
+      }, 1000);
+
+      const addTeaReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: "",
+          method: "addDoc",
+        })
+        .setPayload(newTeaData);
+
+      await addTeaReq.send();
+
+      const updateTeaReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "updateDoc",
+        })
+        .setPayload(newTeaData);
+
+      await updateTeaReq.send({ params: { teaId: 1 } });
+
+      const removeReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "deleteDoc",
+        })
+        .setParams({ teaId: 1 });
+      await removeReq.send();
+
+      await waitForExpect(async () => {
+        expect(receivedData).toHaveLength(4);
+        const [, afterAdd, afterModify, afterRemove] = receivedData;
+        const [, afterAddExtra, afterModifyExtra, afterRemoveExtra] = receivedExtra;
+        expect(afterAdd).toHaveLength(11);
+        expect(afterModify).toHaveLength(11);
+        expect(afterRemove).toHaveLength(10);
+        expect(afterAddExtra.groupedResult.added).toHaveLength(1);
+        expect(afterModifyExtra.groupedResult.added).toHaveLength(0);
+        expect(afterModifyExtra.groupedResult.modified).toHaveLength(1);
+        expect(afterModifyExtra.groupedResult.removed).toHaveLength(0);
+        expect(afterRemoveExtra.groupedResult.added).toHaveLength(0);
+        expect(afterRemoveExtra.groupedResult.modified).toHaveLength(0);
+        expect(afterRemoveExtra.groupedResult.removed).toHaveLength(1);
+      });
+
+      unmount();
+    });
+    it("should return data available for doc", async () => {
+      const { socket } = await initialize();
+      const onSnapshotReq = socket
+        .createListener<Tea[]>()({
+          topic: ":teaId",
+        })
+        .setParams({ teaId: 1 });
+
+      let receivedData: any;
+      const unmount = onSnapshotReq.listen(({ data }) => {
+        spy();
+        receivedData = data;
+      });
+
+      await waitForExpect(async () => {
+        expect(receivedData).toStrictEqual({
+          __key: "1",
+          amount: 150,
+          name: "Taiping Hou Kui",
+          origin: "China",
+          type: "Green",
+          year: 2023,
+        });
+      });
+
+      unmount();
+    });
+    it("should allow for listening to multiple documents and change HF cache if data is changed in firebase after onSnapshot listener creation", async () => {
+      const { socket, client } = await initialize();
+      const initialCache = [
+        {
+          __key: "0",
+          amount: 50,
+          year: 2022,
+          origin: "China",
+          name: "Bi Luo Chun",
+          type: "Green",
+        },
+        {
+          __key: "1",
+          amount: 150,
+          year: 2023,
+          origin: "China",
+          name: "Taiping Hou Kui",
+          type: "Green",
+        },
+        {
+          __key: "2",
+          amount: 25,
+          year: 2021,
+          origin: "Japan",
+          name: "Hon.yama Sencha",
+          type: "Green",
+        },
+      ];
+
+      // Should listen for changes only for Green teas
+      const onSnapshotReq = socket.createListener<Tea[]>()({
+        topic: "",
+        options: { constraints: [$where("type", "==", "Green")] },
+      });
+
+      const receivedData: any[] = [];
+      const unmount = onSnapshotReq.listen(({ data }) => {
+        spy();
+        receivedData.push(data);
+      });
+
+      await waitForExpect(async () => {
+        expect(receivedData).toHaveLength(1);
+        expect(receivedData[0]).toIncludeSameMembers(initialCache);
+      }, 1000);
+
+      const shouldCacheData = newData as Tea;
+      const shouldNotCacheData = {
+        ...newData,
+        type: "Oolong",
+      } as Tea;
+
+      const shouldCacheAddDocRequest = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: "",
+          method: "addDoc",
+        })
+        .setPayload(shouldCacheData);
+      const shouldNotCacheAddDocRequest = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: "",
+          method: "addDoc",
+        })
+        .setPayload(shouldNotCacheData);
+
+      const { data } = await shouldCacheAddDocRequest.send();
+
+      await shouldNotCacheAddDocRequest.send();
+
+      unmount();
+
+      await shouldCacheAddDocRequest.send();
+
+      await waitForExpect(async () => {
+        expect(receivedData).toHaveLength(2);
+        expect(receivedData[1]).toIncludeSameMembers([...initialCache, data]);
+      });
+    });
+  });
+};

package/__tests__/features/firestore/shared/methods/set-doc.test.suite.ts

@@ -0,0 +1,70 @@
+import { Client } from "@hyper-fetch/core";
+
+import { Tea } from "../../../../utils";
+import { FirebaseAdminAdapter } from "adapter";
+import { testLifecycleEvents } from "../../../../shared/request-events.shared";
+
+export const setDocTestSuite = (adapterFunction: () => ReturnType<typeof FirebaseAdminAdapter>) => {
+  describe("setDoc", () => {
+    it("should set data", async () => {
+      const newData = { origin: "Poland", type: "Green", year: 2023, name: "Pou Ran Do Cha", amount: 10 } as Tea;
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const getReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+      const setReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "setDoc",
+        })
+        .setParams({ teaId: 1 })
+        .setPayload(newData);
+
+      await setReq.send();
+      const { data } = await getReq.send();
+
+      expect(data).toStrictEqual({ ...newData, __key: "1" });
+    });
+    it("should merge data if merge options is passed", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+      const getReq = client
+        .createRequest<{ response: Tea }>()({
+          endpoint: ":teaId",
+          method: "getDoc",
+        })
+        .setParams({ teaId: 1 });
+      const { data: existingData } = await getReq.send();
+      const setReq = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "setDoc",
+          options: { merge: true },
+        })
+        .setParams({ teaId: 1 })
+        .setPayload({ name: "Pou Ran Do Cha" } as Tea);
+
+      await setReq.send();
+      const { data } = await getReq.send();
+
+      expect(data).toStrictEqual({ ...existingData, name: "Pou Ran Do Cha" });
+      // expect(extra.snapshot.exists()).toBe(true);
+    });
+    it("should emit lifecycle events", async () => {
+      const client = new Client({ url: "teas/" }).setAdapter(adapterFunction());
+
+      const request = client
+        .createRequest<{ response: Tea; payload: Tea }>()({
+          endpoint: ":teaId",
+          method: "setDoc",
+          options: { merge: true },
+        })
+        .setParams({ teaId: 1 })
+        .setPayload({ name: "Pou Ran Do Cha" } as Tea);
+
+      await testLifecycleEvents(request);
+    });
+  });
+};