@fireproof/core 0.19.0-dev-publish → 0.19.0-dev-use-fix

package/tests/fireproof/indexer.test.ts

@@ -0,0 +1,389 @@
+import { itSkip } from "../helpers.js";
+
+import { rt, Index, index, Database, CRDT, IndexRows } from "@fireproof/core";
+
+interface TestType {
+  readonly title: string;
+  readonly score: number;
+}
+
+describe("basic Index", () => {
+  let db: Database<TestType>;
+  let indexer: Index<string, TestType>;
+  let didMap: boolean;
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+    await indexer.close();
+    await indexer.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    db = new Database("test-indexer");
+    await db.put({ title: "amazing" });
+    await db.put({ title: "creative" });
+    await db.put({ title: "bazillas" });
+    indexer = new Index<string, TestType>(db._crdt, "hello", (doc) => {
+      didMap = true;
+      return doc.title;
+    });
+    await indexer.ready();
+  });
+  it("should have properties", function () {
+    expect(indexer.crdt).toBe(db._crdt);
+    expect(indexer.crdt.name).toBe("test-indexer");
+    expect(indexer.name).toBe("hello");
+    expect(indexer.mapFn).toBeTruthy();
+  });
+  it("should call the map function on first query", async function () {
+    didMap = false;
+    await indexer.query();
+    expect(didMap).toBeTruthy();
+  });
+  it("should not call the map function on second query", async function () {
+    await indexer.query();
+    didMap = false;
+    await indexer.query();
+    expect(didMap).toBeFalsy();
+  });
+  it("should get results", async function () {
+    const result = await indexer.query();
+    expect(result).toBeTruthy();
+    expect(result.rows).toBeTruthy();
+    expect(result.rows.length).toBe(3);
+  });
+  it("should be in order", async function () {
+    const { rows } = await indexer.query();
+    expect(rows[0].key).toBe("amazing");
+  });
+  it("should work with limit", async function () {
+    const { rows } = await indexer.query({ limit: 1 });
+    expect(rows.length).toBe(1);
+  });
+  it("should work with descending", async function () {
+    const { rows } = await indexer.query({ descending: true });
+    expect(rows[0].key).toBe("creative");
+  });
+  it("should range query all", async function () {
+    const { rows } = await indexer.query({ range: ["a", "z"] });
+    expect(rows.length).toBe(3);
+    expect(rows[0].key).toBe("amazing");
+  });
+  it("should range query all twice", async function () {
+    const { rows } = await indexer.query({ range: ["a", "z"] });
+    expect(rows.length).toBe(3);
+    expect(rows[0].key).toBe("amazing");
+    const { rows: rows2 } = await indexer.query({ range: ["a", "z"] });
+    expect(rows2.length).toBe(3);
+    expect(rows2[0].key).toBe("amazing");
+  });
+  it("should range query", async function () {
+    const { rows } = await indexer.query({ range: ["b", "d"] });
+    expect(rows[0].key).toBe("bazillas");
+  });
+  it("should key query", async function () {
+    const { rows } = await indexer.query({ key: "bazillas" });
+    expect(rows.length).toBe(1);
+  });
+  it("should include docs", async function () {
+    const { rows } = await indexer.query({ includeDocs: true });
+    expect(rows[0]).toBeTruthy();
+    expect(rows[0].id).toBeTruthy();
+    expect(rows[0].doc).toBeTruthy();
+    expect(rows[0].doc?._id).toBe(rows[0].id);
+  });
+});
+
+describe("Index query with compound key", function () {
+  let db: Database<TestType>;
+  let indexer: Index<[string, number], TestType>;
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+    await indexer.close();
+    await indexer.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    db = new Database("test-indexer");
+    await db.put({ title: "amazing", score: 1 });
+    await db.put({ title: "creative", score: 2 });
+    await db.put({ title: "creative", score: 20 });
+    await db.put({ title: "bazillas", score: 3 });
+    indexer = new Index<[string, number], TestType>(db._crdt, "hello", (doc) => {
+      return [doc.title, doc.score];
+    });
+    await indexer.ready();
+  });
+  it("should prefix query", async function () {
+    const { rows } = await indexer.query({ prefix: "creative" });
+    expect(rows.length).toBe(2);
+    expect(rows[0].key).toEqual(["creative", 2]);
+    expect(rows[1].key).toEqual(["creative", 20]);
+  });
+});
+
+describe("basic Index with map fun", function () {
+  let db: Database<TestType>;
+  let indexer: Index<string, TestType>;
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+    await indexer.close();
+    await indexer.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    db = new Database("test-indexer");
+    await db.put({ title: "amazing" });
+    await db.put({ title: "creative" });
+    await db.put({ title: "bazillas" });
+    indexer = new Index<string, TestType>(db._crdt, "hello", (doc, map) => {
+      map(doc.title);
+    });
+    await indexer.ready();
+  });
+  it("should get results", async function () {
+    const result = await indexer.query();
+    expect(result).toBeTruthy();
+    expect(result.rows).toBeTruthy();
+    expect(result.rows.length).toBe(3);
+    expect(result.rows[0].key).toBe("amazing");
+  });
+});
+
+describe("basic Index with map fun with value", function () {
+  let db: Database<TestType>;
+  let indexer: Index<string, TestType, number>;
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    db = new Database("test-indexer");
+    await db.put({ title: "amazing" });
+    await db.put({ title: "creative" });
+    await db.put({ title: "bazillas" });
+    indexer = new Index<string, TestType, number>(db._crdt, "hello", (doc, map) => {
+      map(doc.title, doc.title.length);
+    });
+  });
+  it("should get results", async function () {
+    const result = await indexer.query();
+    expect(result).toBeTruthy();
+    expect(result.rows).toBeTruthy();
+    expect(result.rows.length).toBe(3);
+    expect(result.rows[0].key).toBe("amazing");
+    // @jchris why is this not a object?
+    expect(result.rows[0].value).toBe(7);
+  });
+  it("should include docs", async function () {
+    const { rows } = await indexer.query({ includeDocs: true });
+    expect(rows[0].doc).toBeTruthy();
+    expect(rows[0].doc?._id).toBe(rows[0].id);
+    expect(rows.length).toBe(3);
+    expect(rows[0].key).toBe("amazing");
+    // @jchris why is this not a object?
+    expect(rows[0].value).toBe(7);
+  });
+});
+
+describe("Index query with map and compound key", function () {
+  let db: Database<TestType>;
+  let indexer: Index<[string, number], TestType>;
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+    await indexer.close();
+    await indexer.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    db = new Database("test-indexer");
+    await db.put({ title: "amazing", score: 1 });
+    await db.put({ title: "creative", score: 2 });
+    await db.put({ title: "creative", score: 20 });
+    await db.put({ title: "bazillas", score: 3 });
+    indexer = new Index<[string, number], TestType>(db._crdt, "hello", (doc, emit) => {
+      emit([doc.title, doc.score]);
+    });
+    await indexer.ready();
+  });
+  it("should prefix query", async function () {
+    const { rows } = await indexer.query({ prefix: "creative" });
+    expect(rows.length).toBe(2);
+    expect(rows[0].key).toEqual(["creative", 2]);
+    expect(rows[1].key).toEqual(["creative", 20]);
+  });
+});
+
+describe("basic Index with string fun", function () {
+  let db: Database<TestType>;
+  let indexer: Index<string, TestType>;
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+    await indexer.close();
+    await indexer.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    db = new Database("test-indexer");
+    await db.put({ title: "amazing" });
+    await db.put({ title: "creative" });
+    await db.put({ title: "bazillas" });
+    indexer = new Index(db._crdt, "title");
+    await indexer.ready();
+  });
+  it("should get results", async function () {
+    const result = await indexer.query();
+    expect(result).toBeTruthy();
+    expect(result.rows).toBeTruthy();
+    expect(result.rows.length).toBe(3);
+  });
+  it("should include docs", async function () {
+    const { rows } = await indexer.query();
+    expect(rows.length).toBeTruthy();
+    expect(rows[0].doc).toBeTruthy();
+  });
+});
+
+describe("basic Index upon cold start", function () {
+  interface TestType {
+    title: string;
+    score?: number;
+  }
+  let crdt: CRDT<TestType>;
+  let indexer: Index<string, TestType>;
+  let didMap: number;
+  let mapFn: (doc: TestType) => string;
+  let result: IndexRows<string, TestType>;
+  // result, mapFn;
+  afterEach(async function () {
+    await crdt.close();
+    await crdt.destroy();
+    await indexer.close();
+    await indexer.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    // db = database()
+    crdt = new CRDT<TestType>("test-indexer-cold", { persistIndexes: true });
+    await crdt.bulk([
+      { id: "abc1", value: { title: "amazing" } },
+      { id: "abc2", value: { title: "creative" } },
+      { id: "abc3", value: { title: "bazillas" } },
+    ]);
+    didMap = 0;
+    mapFn = (doc) => {
+      didMap++;
+      return doc.title;
+    };
+    indexer = await index<string, TestType>({ _crdt: crdt }, "hello", mapFn);
+    await indexer.ready();
+    // new Index(db._crdt.indexBlockstore, db._crdt, 'hello', mapFn)
+    result = await indexer.query();
+    expect(indexer.indexHead).toEqual(crdt.clock.head);
+  });
+  it("should call map on first query", function () {
+    expect(didMap).toBeTruthy();
+    expect(didMap).toEqual(3);
+  });
+  it("should get results on first query", function () {
+    expect(result).toBeTruthy();
+    expect(result.rows).toBeTruthy();
+    expect(result.rows.length).toEqual(3);
+  });
+  it("should work on cold load", async function () {
+    const crdt2 = new CRDT<TestType>("test-indexer-cold", { persistIndexes: true });
+    await crdt2.ready();
+    const { result, head } = await crdt2.changes();
+    expect(result).toBeTruthy();
+    await crdt2.ready();
+    const indexer2 = await index<string, TestType>({ _crdt: crdt2 }, "hello", mapFn);
+    await indexer2.ready();
+    const result2 = await indexer2.query();
+    expect(indexer2.indexHead).toEqual(head);
+    expect(result2).toBeTruthy();
+    expect(result2.rows.length).toEqual(3);
+    expect(indexer2.indexHead).toEqual(head);
+  });
+  itSkip("should not rerun the map function on seen changes", async function () {
+    didMap = 0;
+    const crdt2 = new CRDT<TestType>("test-indexer-cold", { persistIndexes: true });
+    const indexer2 = await index({ _crdt: crdt2 }, "hello", mapFn);
+    const { result, head } = await crdt2.changes([]);
+    expect(result.length).toEqual(3);
+    expect(head.length).toEqual(1);
+    const { result: ch2, head: h2 } = await crdt2.changes(head);
+    expect(ch2.length).toEqual(0);
+    expect(h2.length).toEqual(1);
+    expect(h2).toEqual(head);
+    const result2 = await indexer2.query();
+    expect(indexer2.indexHead).toEqual(head);
+    expect(result2).toBeTruthy();
+    expect(result2.rows.length).toEqual(3);
+    expect(didMap).toEqual(0);
+    await crdt2.bulk([{ id: "abc4", value: { title: "despicable", score: 0 } }]);
+
+    const { result: ch3, head: h3 } = await crdt2.changes(head);
+    expect(ch3.length).toEqual(1);
+    expect(h3.length).toEqual(1);
+    const result3 = await indexer2.query();
+    expect(result3).toBeTruthy();
+    expect(result3.rows.length).toEqual(4);
+    expect(didMap).toEqual(1);
+  });
+  it("should ignore meta when map function definiton changes", async function () {
+    const crdt2 = new CRDT<TestType>("test-indexer-cold");
+    const result = await index<string, TestType>({ _crdt: crdt2 }, "hello", (doc) =>
+      doc.title.split("").reverse().join(""),
+    ).query();
+    expect(result.rows.length).toEqual(3);
+    expect(result.rows[0].key).toEqual("evitaerc"); // creative
+  });
+});
+
+describe("basic Index with no data", function () {
+  let db: Database<TestType>;
+  let indexer: Index<string, TestType>;
+  let didMap: boolean;
+  afterEach(async function () {
+    await db.close();
+    await db.destroy();
+    await indexer.close();
+    await indexer.destroy();
+  });
+  beforeEach(async function () {
+    await rt.SysContainer.start();
+    db = new Database("test-indexer");
+    indexer = new Index<string, TestType>(db._crdt, "hello", (doc) => {
+      didMap = true;
+      return doc.title;
+    });
+    await indexer.ready();
+  });
+  it("should have properties", function () {
+    expect(indexer.crdt).toEqual(db._crdt);
+    expect(indexer.name).toEqual("hello");
+    expect(indexer.mapFn).toBeTruthy();
+  });
+  it("should not call the map function on first query", async function () {
+    didMap = false;
+    await indexer.query();
+    expect(didMap).toBeFalsy();
+  });
+  it("should not call the map function on second query", async function () {
+    await indexer.query();
+    didMap = false;
+    await indexer.query();
+    expect(didMap).toBeFalsy();
+  });
+  it("should get results", async function () {
+    const result = await indexer.query();
+    expect(result).toBeTruthy();
+    expect(result.rows).toBeTruthy();
+    expect(result.rows.length).toEqual(0);
+  });
+});

package/tests/helpers.ts

@@ -0,0 +1,81 @@
+import { rt } from "@fireproof/core";
+
+const dataDir = rt.dataDir;
+export { dataDir };
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function itSkip(value: string, fn: () => unknown, options?: number) {
+  if (typeof it !== "function") {
+    return;
+  }
+  const mit = it as unknown as { skip: (value: string, fn: () => unknown, options?: unknown) => unknown };
+  if (mit && typeof mit.skip === "function") {
+    mit.skip(value, fn, options);
+    return;
+  }
+  console.warn("itSkip of " + value);
+}
+
+//
+
+// // Function to copy a directory
+// export async function copyDirectory(source: string, destination: string) {
+//   // Ensure the destination directory exists
+//   await rt.SysContainer.mkdir(destination, { recursive: true });
+
+//   // Read the source directory
+//   const entries = await SysContainer.readdirent(source, { withFileTypes: true });
+
+//   // Iterate through each entry in the directory
+//   for (const entry of entries) {
+//     const sourcePath = SysContainer.join(source, entry.name);
+//     const destinationPath = SysContainer.join(destination, entry.name);
+
+//     if (entry.isDirectory()) {
+//       // If the entry is a directory, copy it recursively
+//       await copyDirectory(sourcePath, destinationPath);
+//     } else if (entry.isFile()) {
+//       // If the entry is a file, copy it
+//       await SysContainer.copyFile(sourcePath, destinationPath);
+//     }
+//   }
+// }
+
+// export function getDirectoryName(url: string) {
+//   let path: string;
+//   try {
+//     path = SysContainer.fileURLToPath(url);
+//   } catch (e) {
+//     path = url;
+//   }
+//   if (process && typeof process.cwd === "function") {
+//     const cwd = process.cwd();
+//     if (cwd.endsWith("dist/esm")) {
+//       path = "../../" + path;
+//     }
+//   }
+//   const dir_name = SysContainer.dirname(path);
+//   return dir_name;
+// }
+
+async function toFileWithCid(buffer: Uint8Array, name: string, opts: FilePropertyBag): Promise<FileWithCid> {
+  return {
+    file: new File([new Blob([buffer])], name, opts),
+    cid: (await rt.files.encodeFile(new File([new Blob([buffer])], name, opts))).cid.toString(),
+  };
+}
+
+export interface FileWithCid {
+  file: File;
+  cid: string;
+}
+export async function buildBlobFiles(): Promise<FileWithCid[]> {
+  const cp = rt.crypto.toCryptoOpts();
+  return [
+    await toFileWithCid(cp.randomBytes(Math.random() * 51283), `image.jpg`, { type: "image/jpeg" }),
+    await toFileWithCid(cp.randomBytes(Math.random() * 51283), `fireproof.png`, { type: "image/png" }),
+  ];
+}

package/tests/react/useFireproof.test.tsx

@@ -0,0 +1,19 @@
+import { renderHook } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import { useFireproof } from "use-fireproof";
+
+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).toBe("Database");
+    });
+  });
+});

package/tests/www/gallery.html

@@ -0,0 +1,132 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Fireproof Uploads</title>
+    <script src="./fireproof.iife.js?cache=94"></script>
+    <script type="text/javascript">
+      function testApp() {
+        const { fireproof, connect } = Fireproof;
+        let dbName;
+        let db;
+        let cx;
+
+        let dbUnsubscribe = false;
+
+        function setupDb(name) {
+          if (dbUnsubscribe) {
+            dbUnsubscribe();
+          }
+          dbName = name;
+          db = fireproof(name);
+          window.db = db;
+
+          cx = db.connect("jchris+files-30@fireproof.storage", "todo-test");
+          window.cx = cx;
+
+          dbUnsubscribe = db.subscribe(redraw);
+          return db;
+        }
+
+        let doing;
+        const redraw = async () => {
+          if (doing) {
+            return doing;
+          }
+          doing = draw().finally(() => (doing = null));
+          return doing;
+        };
+
+        const draw = async () => {
+          const result = await db.query("_id", { descending: true, limit: 10 });
+          document.querySelector("ul").innerHTML = "";
+          for (const row of result.rows) {
+            const doc = row.doc;
+            if (doc._publicFiles) {
+              const li = document.querySelector("ul").appendChild(document.createElement("li"));
+              li.appendChild(document.createElement("span")).innerText = row.key;
+              li.appendChild(document.createElement("br"));
+              for (const file of Object.keys(doc._publicFiles)) {
+                (async () => {
+                  const meta = doc._publicFiles[file];
+                  if (meta.file && /image/.test(meta.type)) {
+                    const src = URL.createObjectURL(await meta.file());
+                    const img = document.createElement("img");
+                    img.src = src;
+                    img.height = 100;
+                    img.onload = () => {
+                      URL.revokeObjectURL(img.src);
+                    };
+
+                    console.log("url", meta.url);
+                    li.appendChild(img);
+                  }
+                })();
+              }
+            }
+          }
+        };
+
+        async function changeList(e) {
+          e.preventDefault();
+          const input = document.querySelector("#list");
+          dbName = input.value;
+          history.pushState(null, "", location.pathname + "?db=" + encodeURIComponent(dbName));
+          setupDb(dbName);
+
+          redraw();
+        }
+        window.changeList = changeList;
+
+        async function openDashboard(e) {
+          db.openDashboard();
+        }
+        window.openDashboard = openDashboard;
+
+        function handleFiles() {
+          const fileList = this.files;
+          const doc = {
+            _publicFiles: {},
+          };
+          for (const file of fileList) {
+            doc._publicFiles[file.name] = file;
+          }
+          const ok = db.put(doc);
+        }
+
+        async function initialize() {
+          ps = new URLSearchParams(location.search);
+          const listQ = ps.get("db");
+          setupDb(listQ || "hello-world");
+          const input = document.querySelector("#list");
+          input.value = dbName;
+
+          const inputElement = document.getElementById("files-up");
+          inputElement.addEventListener("change", handleFiles, false);
+          db.subscribe(draw);
+          draw();
+        }
+
+        window.onload = initialize;
+      }
+      testApp();
+    </script>
+  </head>
+
+  <body>
+    List:
+    <input title="gallery" type="text" name="list" id="list" />
+    <button onclick="changeList(event)">Change Gallery</button>
+    <button onclick="openDashboard(event)">🔥 Import to Dashboard</button>
+    <h3>Files</h3>
+    <p>
+      Data is stored locally and encrypted before upload to S3. This is a demo so the encryption key is not managed securely. Read
+      more about <a href="https://use-fireproof.com/docs/database-api/replication">Fireproof replication options.</a> You can also
+      see a demo without images but <a href="https://fireproof.storage/s3up-test.html">with compaction and refresh buttons.</a>
+    </p>
+    <label for="files-up"><strong>Drop files:</strong></label>
+    <input accept="image/*" title="save to Fireproof" type="file" id="files-up" multiple />
+    <ul></ul>
+  </body>
+</html>

package/tests/www/iife.html

@@ -0,0 +1,42 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Fireproof Test</title>
+    <script src="./fireproof.iife.js"></script>
+    <script type="text/javascript">
+      function testApp() {
+        const db = Fireproof.fireproof("iife-test", { persistIndexes: true });
+
+        const draw = async () => {
+          const result = await db.query("sort", { includeDocs: true });
+          document.querySelector("ul").innerHTML = "";
+          for (const row of result.rows) {
+            document.querySelector("ul").appendChild(document.createElement("li")).innerText = JSON.stringify(row.doc);
+          }
+        };
+
+        async function initialize() {
+          console.log("initialize");
+          db.subscribe(draw);
+          draw();
+        }
+
+        async function onButtonClick(e) {
+          e.preventDefault();
+          console.log("put");
+          const ok = await db.put({ sort: Math.random(), test: "test" });
+          console.log("ok", ok.id);
+        }
+        window.onButtonClick = onButtonClick;
+        window.onload = initialize;
+      }
+      testApp();
+    </script>
+  </head>
+  <body>
+    <button onclick="onButtonClick(event)">Click to Run</button>
+    <ul></ul>
+  </body>
+</html>