@fireproof/core 0.20.0-dev-preview-51 → 0.20.0-dev-preview-53

package/tests/react/useFireproof.test.tsx

@@ -1,22 +1,32 @@
 import { renderHook, waitFor } from "@testing-library/react";
 import { describe, expect, it } from "vitest";
+import { fireproof, useFireproof } from "use-fireproof";
+import type { Database, LiveQueryResult, UseDocumentResult } from "use-fireproof";
 
-import { Database, fireproof, useFireproof } from "use-fireproof";
-import { LiveQueryResult, UseDocumentResult } from "use-fireproof";
+// Test timeout value for CI
+const TEST_TIMEOUT = 45000;
 
 describe("HOOK: useFireproof", () => {
-  it("should be defined", () => {
-    expect(useFireproof).toBeDefined();
-  });
-
-  it("renders the hook correctly and checks types", () => {
-    renderHook(() => {
-      const { database, useLiveQuery, useDocument } = useFireproof("dbname");
-      expect(typeof useLiveQuery).toBe("function");
-      expect(typeof useDocument).toBe("function");
-      expect(database?.constructor.name).toMatch(/^Database/);
-    });
-  });
+  it(
+    "should be defined",
+    () => {
+      expect(useFireproof).toBeDefined();
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "renders the hook correctly and checks types",
+    () => {
+      renderHook(() => {
+        const { database, useLiveQuery, useDocument } = useFireproof("dbname");
+        expect(typeof useLiveQuery).toBe("function");
+        expect(typeof useDocument).toBe("function");
+        expect(database?.constructor.name).toMatch(/^Database/);
+      });
+    },
+    TEST_TIMEOUT,
+  );
 });
 
 describe("HOOK: useFireproof useLiveQuery has results", () => {
@@ -36,32 +46,32 @@ describe("HOOK: useFireproof useLiveQuery has results", () => {
     cnt++;
   });
 
-  it("should have setup data", async () => {
-    const allDocs = await db.allDocs<{ foo: string }>();
-    expect(allDocs.rows.length).toBe(3);
-    expect(allDocs.rows[0].value.foo).toBe("aha");
-    expect(allDocs.rows[1].value.foo).toBe("bar");
-    expect(allDocs.rows[2].value.foo).toBe("caz");
-  });
-
-  it("queries correctly", async () => {
-    renderHook(() => {
-      const result = useFireproof(dbName);
-      database = result.database;
-      useLiveQuery = result.useLiveQuery;
-      query = useLiveQuery<{ foo: string }>("foo");
-    });
-
-    await waitFor(() => {
-      // act(() => {
-      // expect(query.rows).toBe([]);
-      expect(query.rows.length).toBe(3);
-      expect(query.rows[0].doc?.foo).toBe("aha");
-      expect(query.rows[1].doc?.foo).toBe("bar");
-      expect(query.rows[2].doc?.foo).toBe("caz");
-      // });
-    });
-  });
+  it(
+    "should have setup data",
+    async () => {
+      const allDocs = await db.allDocs<{ foo: string }>();
+      const expectedValues = ["aha", "bar", "caz"];
+      expect(allDocs.rows.map((row) => row.value.foo)).toEqual(expectedValues);
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "queries correctly",
+    async () => {
+      renderHook(() => {
+        const result = useFireproof(dbName);
+        database = result.database;
+        useLiveQuery = result.useLiveQuery;
+        query = useLiveQuery<{ foo: string }>("foo");
+      });
+
+      await waitFor(() => {
+        expect(query.rows.map((row) => row.doc?.foo)).toEqual(["aha", "bar", "caz"]);
+      });
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();
@@ -89,93 +99,111 @@ describe("HOOK: useFireproof useDocument has results", () => {
     });
   });
 
-  it("should have empty setup data", async () => {
-    const allDocs = await db.allDocs<{ input: string }>();
-    expect(allDocs.rows.length).toBe(0);
-  });
-
-  it("queries correctly", async () => {
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-  });
-
-  it("handles mutations correctly", async () => {
-    docResult.merge({ input: "new" });
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("new");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-  });
-
-  it("handles save correctly", async () => {
-    docResult.merge({ input: "first" });
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("first");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-
-    renderHook(() => {
-      docResult.save();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc._id).toBeDefined();
-    });
-  });
-
-  it("handles reset after save", async () => {
-    docResult.merge({ input: "new" });
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("new");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-
-    renderHook(() => {
-      docResult.save();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc._id).toBeDefined();
-    });
-
-    const doc1 = await db.get<{ input: string }>(docResult.doc._id);
-    expect(doc1.input).toBe("new");
-
-    renderHook(() => {
-      docResult.reset();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-
-    renderHook(() => {
-      docResult.merge({ input: "fresh" });
-    });
-
-    renderHook(() => {
-      docResult.save();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("fresh");
-      expect(docResult.doc._id).toBeDefined();
-    });
-
-    const doc2 = await db.get<{ input: string }>(docResult.doc._id);
-    expect(doc2.input).toBe("fresh");
-    expect(doc2._id).toBe(docResult.doc._id);
-    expect(doc1._id).not.toBe(doc2._id);
-
-    const allDocs = await db.allDocs<{ input: string }>();
-    expect(allDocs.rows.length).toBe(3);
-    expect(allDocs.rows[0].value.input).toBe("first");
-    expect(allDocs.rows[1].value.input).toBe("new");
-    expect(allDocs.rows[2].value.input).toBe("fresh");
-  });
+  it(
+    "should have empty setup data",
+    async () => {
+      const allDocs = await db.allDocs<{ input: string }>();
+      expect(allDocs.rows.length).toBe(0);
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "queries correctly",
+    async () => {
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles mutations correctly",
+    async () => {
+      docResult.merge({ input: "new" });
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("new");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles save correctly",
+    async () => {
+      docResult.merge({ input: "first" });
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("first");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+
+      renderHook(() => {
+        docResult.save();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc._id).toBeDefined();
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles reset after save",
+    async () => {
+      docResult.merge({ input: "new" });
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("new");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+
+      renderHook(() => {
+        docResult.save();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc._id).toBeDefined();
+      });
+
+      const doc1 = await db.get<{ input: string }>(docResult.doc._id);
+      expect(doc1.input).toBe("new");
+
+      renderHook(() => {
+        docResult.reset();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+
+      renderHook(() => {
+        docResult.merge({ input: "fresh" });
+      });
+
+      renderHook(() => {
+        docResult.save();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("fresh");
+        expect(docResult.doc._id).toBeDefined();
+      });
+
+      const doc2 = await db.get<{ input: string }>(docResult.doc._id);
+      expect(doc2.input).toBe("fresh");
+      expect(doc2._id).toBe(docResult.doc._id);
+      expect(doc1._id).not.toBe(doc2._id);
+
+      const allDocs = await db.allDocs<{ input: string }>();
+      const inputs = allDocs.rows.map((r) => r.value.input);
+      expect(inputs).toEqual(expect.arrayContaining(["first", "new", "fresh"]));
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();
@@ -203,81 +231,101 @@ describe("HOOK: useFireproof useDocument has results reset sync", () => {
     });
   });
 
-  it("should have empty setup data", async () => {
-    const allDocs = await db.allDocs<{ input: string }>();
-    expect(allDocs.rows.length).toBe(0);
-  });
-
-  it("queries correctly", async () => {
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-  });
-
-  it("handles mutations correctly", async () => {
-    docResult.merge({ input: "new" });
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("new");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-  });
-
-  it("handles save correctly", async () => {
-    docResult.merge({ input: "first" });
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("first");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-
-    renderHook(() => {
-      docResult.save();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc._id).toBeDefined();
-    });
-  });
-
-  it("handles reset after save", async () => {
-    docResult.merge({ input: "new" });
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("new");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-
-    renderHook(() => {
-      docResult.save();
-      docResult.reset();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-
-    renderHook(() => {
-      docResult.merge({ input: "fresh" });
-    });
-
-    renderHook(() => {
-      docResult.save();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("fresh");
-      expect(docResult.doc._id).toBeDefined();
-    });
-
-    const doc2 = await db.get<{ input: string }>(docResult.doc._id);
-    expect(doc2.input).toBe("fresh");
-    expect(doc2._id).toBe(docResult.doc._id);
-
-    const allDocs = await db.allDocs<{ input: string }>();
-    expect(allDocs.rows.length).toBe(3);
-    const inputs = allDocs.rows.map((r) => r.value.input);
-    expect(inputs).toEqual(expect.arrayContaining(["first", "new", "fresh"]));
-  });
+  it(
+    "should have empty setup data",
+    async () => {
+      const allDocs = await db.allDocs<{ input: string }>();
+      expect(allDocs.rows.length).toBe(0);
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "queries correctly",
+    async () => {
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles mutations correctly",
+    async () => {
+      docResult.merge({ input: "new" });
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("new");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles save correctly",
+    async () => {
+      docResult.merge({ input: "first" });
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("first");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+
+      renderHook(() => {
+        docResult.save();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc._id).toBeDefined();
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles reset after save",
+    async () => {
+      docResult.merge({ input: "new" });
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("new");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+
+      renderHook(() => {
+        docResult.save();
+        docResult.reset();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+
+      renderHook(() => {
+        docResult.merge({ input: "fresh" });
+      });
+
+      renderHook(() => {
+        docResult.save();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("fresh");
+        expect(docResult.doc._id).toBeDefined();
+      });
+
+      const doc2 = await db.get<{ input: string }>(docResult.doc._id);
+      expect(doc2.input).toBe("fresh");
+      expect(doc2._id).toBe(docResult.doc._id);
+
+      const allDocs = await db.allDocs<{ input: string }>();
+      expect(allDocs.rows.length).toBe(3);
+      const inputs = allDocs.rows.map((r) => r.value.input);
+      expect(inputs).toEqual(expect.arrayContaining(["first", "new", "fresh"]));
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();
@@ -308,38 +356,50 @@ describe("HOOK: useFireproof useDocument with existing document has results", ()
     });
   });
 
-  it("should have setup data", async () => {
-    const allDocs = await db.allDocs<{ input: string }>();
-    expect(allDocs.rows.length).toBe(1);
-    expect(allDocs.rows[0].value.input).toBe("initial");
-    expect(allDocs.rows[0].key).toBe(id);
-  });
-
-  it("queries correctly", async () => {
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("initial");
-      expect(docResult.doc._id).toBe(id);
-    });
-  });
-
-  it("handles mutations correctly", async () => {
-    // First verify initial state
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("initial");
-      expect(docResult.doc._id).toBe(id);
-    });
-
-    // Run merge in hook context
-    renderHook(() => {
-      docResult.merge({ input: "new" });
-    });
-
-    // Then verify the mutation took effect
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("new");
-      expect(docResult.doc._id).toBe(id);
-    });
-  });
+  it(
+    "should have setup data",
+    async () => {
+      const allDocs = await db.allDocs<{ input: string }>();
+      expect(allDocs.rows.length).toBe(1);
+      expect(allDocs.rows[0].value.input).toBe("initial");
+      expect(allDocs.rows[0].key).toBe(id);
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "queries correctly",
+    async () => {
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("initial");
+        expect(docResult.doc._id).toBe(id);
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles mutations correctly",
+    async () => {
+      // First verify initial state
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("initial");
+        expect(docResult.doc._id).toBe(id);
+      });
+
+      // Run merge in hook context
+      renderHook(() => {
+        docResult.merge({ input: "new" });
+      });
+
+      // Then verify the mutation took effect
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("new");
+        expect(docResult.doc._id).toBe(id);
+      });
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();
@@ -370,39 +430,51 @@ describe("HOOK: useFireproof useDocument with existing document handles external
     });
   });
 
-  it("should have setup data", async () => {
-    const allDocs = await db.allDocs<{ input: string }>();
-    expect(allDocs.rows.length).toBe(1);
-    expect(allDocs.rows[0].value.input).toBe("initial");
-    expect(allDocs.rows[0].key).toBe(id);
-  });
-
-  it("queries correctly", async () => {
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("initial");
-      expect(docResult.doc._id).toBe(id);
-    });
-  });
-
-  it("handles mutations correctly", async () => {
-    // First verify initial state
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("initial");
-      expect(docResult.doc._id).toBe(id);
-    });
-
-    // Run merge in hook context
-    renderHook(() => {
-      // docResult.merge({ input: "new" });
-      db.put({ _id: id, input: "external" });
-    });
-
-    // Then verify the mutation took effect
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("external");
-      expect(docResult.doc._id).toBe(id);
-    });
-  });
+  it(
+    "should have setup data",
+    async () => {
+      const allDocs = await db.allDocs<{ input: string }>();
+      expect(allDocs.rows.length).toBe(1);
+      expect(allDocs.rows[0].value.input).toBe("initial");
+      expect(allDocs.rows[0].key).toBe(id);
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "queries correctly",
+    async () => {
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("initial");
+        expect(docResult.doc._id).toBe(id);
+      });
+    },
+    TEST_TIMEOUT,
+  );
+
+  it(
+    "handles mutations correctly",
+    async () => {
+      // First verify initial state
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("initial");
+        expect(docResult.doc._id).toBe(id);
+      });
+
+      // Run merge in hook context
+      renderHook(() => {
+        // docResult.merge({ input: "new" });
+        db.put({ _id: id, input: "external" });
+      });
+
+      // Then verify the mutation took effect
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("external");
+        expect(docResult.doc._id).toBe(id);
+      });
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();
@@ -430,45 +502,49 @@ describe("HOOK: useFireproof bug fix: once the ID is set, it can reset", () => {
     });
   });
 
-  it("ensures save() then reset() yields an ephemeral doc (blank _id)", async () => {
-    // Merge some changes
-    docResult.merge({ input: "temp data" });
-    await waitFor(() => {
-      expect(docResult.doc.input).toBe("temp data");
-      expect(docResult.doc._id).toBeUndefined();
-    });
-
-    // Save
-    renderHook(() => {
-      docResult.save();
-      docResult.reset();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc._id).toBeUndefined();
-      expect(docResult.doc.input).toBe("");
-    });
-
-    renderHook(() => {
-      docResult.merge({ input: "new temp data" });
-    });
-
-    renderHook(() => {
-      docResult.save();
-    });
-
-    await waitFor(() => {
-      expect(docResult.doc._id).toBeDefined();
-      expect(docResult.doc.input).toBe("new temp data");
-    });
-
-    // Confirm it's actually in the DB
-    const allDocs = await db.allDocs<{ input: string }>();
-    expect(allDocs.rows.length).toBe(2);
-    const docInputs = allDocs.rows.map((row) => row.value.input);
-    expect(docInputs).toContain("temp data");
-    expect(docInputs).toContain("new temp data");
-  });
+  it(
+    "ensures save() then reset() yields an ephemeral doc (blank _id)",
+    async () => {
+      // Merge some changes
+      docResult.merge({ input: "temp data" });
+      await waitFor(() => {
+        expect(docResult.doc.input).toBe("temp data");
+        expect(docResult.doc._id).toBeUndefined();
+      });
+
+      // Save
+      renderHook(() => {
+        docResult.save();
+        docResult.reset();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc._id).toBeUndefined();
+        expect(docResult.doc.input).toBe("");
+      });
+
+      renderHook(() => {
+        docResult.merge({ input: "new temp data" });
+      });
+
+      renderHook(() => {
+        docResult.save();
+      });
+
+      await waitFor(() => {
+        expect(docResult.doc._id).toBeDefined();
+        expect(docResult.doc.input).toBe("new temp data");
+      });
+
+      // Confirm it's actually in the DB
+      const allDocs = await db.allDocs<{ input: string }>();
+      expect(allDocs.rows.length).toBe(2);
+      const docInputs = allDocs.rows.map((row) => row.value.input);
+      expect(docInputs).toContain("temp data");
+      expect(docInputs).toContain("new temp data");
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();
@@ -492,24 +568,28 @@ describe("HOOK: useFireproof race condition: calling save() without await overwr
     });
   });
 
-  it("demonstrates that calling docResult.save() and docResult.reset() in the same tick can overwrite reset", async () => {
-    // Merge some changes into doc
-    docResult.merge({ input: "some data" });
+  it(
+    "demonstrates that calling docResult.save() and docResult.reset() in the same tick can overwrite reset",
+    async () => {
+      // Merge some changes into doc
+      docResult.merge({ input: "some data" });
 
-    // Call save() but DO NOT await it, then immediately reset().
-    docResult.save();
-    docResult.reset();
+      // Call save() but DO NOT await it, then immediately reset().
+      docResult.save();
+      docResult.reset();
 
-    // Let the async subscription produce a new doc in case the doc is reloaded with an _id
-    await new Promise((resolve) => setTimeout(resolve, 500));
+      // Let the async subscription produce a new doc in case the doc is reloaded with an _id
+      await new Promise((resolve) => setTimeout(resolve, 500));
 
-    // If the reset worked, doc._id should STILL be undefined.
-    // If the subscription wins, doc._id will be defined => test fails.
-    await waitFor(() => {
-      expect(docResult.doc._id).toBeUndefined();
-      expect(docResult.doc.input).toBe("");
-    });
-  });
+      // If the reset worked, doc._id should STILL be undefined.
+      // If the subscription wins, doc._id will be defined => test fails.
+      await waitFor(() => {
+        expect(docResult.doc._id).toBeUndefined();
+        expect(docResult.doc.input).toBe("");
+      });
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();
@@ -531,22 +611,26 @@ describe("useFireproo calling submit()", () => {
     });
   });
 
-  it("demonstrates that calling docResult.save() and docResult.reset() in the same tick can overwrite reset", async () => {
-    // Merge some changes into doc
-    docResult.merge({ input: "some data" });
+  it(
+    "demonstrates that calling docResult.save() and docResult.reset() in the same tick can overwrite reset",
+    async () => {
+      // Merge some changes into doc
+      docResult.merge({ input: "some data" });
 
-    docResult.submit();
+      docResult.submit();
 
-    // Let the async subscription produce a new doc in case the doc is reloaded with an _id
-    await new Promise((resolve) => setTimeout(resolve, 500));
+      // Let the async subscription produce a new doc in case the doc is reloaded with an _id
+      await new Promise((resolve) => setTimeout(resolve, 500));
 
-    // If the reset worked, doc._id should STILL be undefined.
-    // If the subscription wins, doc._id will be defined => test fails.
-    await waitFor(() => {
-      expect(docResult.doc._id).toBeUndefined();
-      expect(docResult.doc.input).toBe("");
-    });
-  });
+      // If the reset worked, doc._id should STILL be undefined.
+      // If the subscription wins, doc._id will be defined => test fails.
+      await waitFor(() => {
+        expect(docResult.doc._id).toBeUndefined();
+        expect(docResult.doc.input).toBe("");
+      });
+    },
+    TEST_TIMEOUT,
+  );
 
   afterEach(async () => {
     await db.close();