@fireproof/core 0.21.0-dev-preview-6 → 0.22.0-dev-preview

package/tests/fireproof/hello.test.ts

@@ -1,74 +0,0 @@
-import { fireproof, DocResponse, DocWithId, index, Database, isDatabase } from "@fireproof/core";
-import { mockSuperThis } from "../helpers.js";
-
-describe("Hello World Test", function () {
-  it("should pass the hello world test", function () {
-    const result = fireproof("hello"); // call to your library function
-    expect(result.name).toBe("hello");
-  });
-});
-
-describe("hello public API", () => {
-  interface TestDoc {
-    foo: string;
-  }
-  let db: Database;
-  let ok: DocResponse;
-  let doc: DocWithId<TestDoc>;
-  // let idx: Index<string, TestDoc>;
-  const sthis = mockSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-public-api");
-    index<TestDoc, string>(db, "test-index", (doc) => doc.foo);
-    ok = await db.put({ _id: "test", foo: "bar" });
-    doc = await db.get("test");
-  });
-  it("should have a ledger", function () {
-    expect(db).toBeTruthy();
-    expect(isDatabase(db)).toBeTruthy();
-  });
-  it("should put", function () {
-    expect(ok).toBeTruthy();
-    expect(ok.id).toBe("test");
-  });
-  it("should get", function () {
-    expect(doc.foo).toBe("bar");
-  });
-  it("should get when you open it again", async () => {
-    await db.close();
-    db = fireproof("test-public-api");
-    doc = await db.get("test");
-    expect(doc.foo).toBe("bar");
-  });
-});
-
-describe("Simplified Reopening a ledger", function () {
-  let db: Database;
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-  });
-  beforeEach(async () => {
-    db = fireproof("test-reopen-simple");
-    const ok = await db.put({ _id: "test", foo: "bar" });
-    expect(ok).toBeTruthy();
-    expect(ok.id).toBe("test");
-  });
-
-  it("should persist data", async () => {
-    const doc = await db.get<{ foo: string }>("test");
-    expect(doc.foo).toBe("bar");
-  });
-
-  it("should have the same data on reopen", async () => {
-    const db2 = fireproof("test-reopen-simple");
-    const doc = await db2.get<{ foo: string }>("test");
-    expect(doc.foo).toBe("bar");
-    await db2.close();
-  });
-});

package/tests/fireproof/indexer.test.ts

@@ -1,458 +0,0 @@
-import {
-  Index,
-  index,
-  CRDT,
-  IndexRows,
-  toStoreURIRuntime,
-  bs,
-  rt,
-  defaultWriteQueueOpts,
-  ensureSuperThis,
-  LedgerOpts,
-  Database,
-  CRDTImpl,
-  fireproof,
-} from "@fireproof/core";
-import { tracer } from "../helpers.js";
-import { AppContext } from "@adviser/cement";
-
-interface TestType {
-  readonly title: string;
-  readonly score: number;
-}
-
-describe("basic Index", () => {
-  let db: Database;
-  let indexer: Index<TestType, string>;
-  let didMap: boolean;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-indexer");
-    await db.put({ title: "amazing" });
-    await db.put({ title: "creative" });
-    await db.put({ title: "bazillas" });
-    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "hello", (doc) => {
-      didMap = true;
-      return doc.title;
-    });
-    await indexer.ready();
-  });
-  it("should have properties", function () {
-    expect(indexer.crdt).toBe(db.ledger.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 () => {
-    didMap = false;
-    await indexer.query();
-    expect(didMap).toBeTruthy();
-  });
-  it("should not call the map function on second query", async () => {
-    await indexer.query();
-    didMap = false;
-    await indexer.query();
-    expect(didMap).toBeFalsy();
-  });
-  it("should get results", async () => {
-    const result = await indexer.query();
-    expect(result).toBeTruthy();
-    expect(result.rows).toBeTruthy();
-    expect(result.rows.length).toBe(3);
-  });
-  it("should be in order", async () => {
-    const { rows } = await indexer.query();
-    expect(rows[0].key).toBe("amazing");
-  });
-  it("should work with limit", async () => {
-    const { rows } = await indexer.query({ limit: 1 });
-    expect(rows.length).toBe(1);
-  });
-  it("should work with descending", async () => {
-    const { rows } = await indexer.query({ descending: true });
-    expect(rows[0].key).toBe("creative");
-  });
-  it("should range query all", async () => {
-    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 () => {
-    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 () => {
-    const { rows } = await indexer.query({ range: ["b", "d"] });
-    expect(rows[0].key).toBe("bazillas");
-  });
-  it("should key query", async () => {
-    const { rows } = await indexer.query({ key: "bazillas" });
-    expect(rows.length).toBe(1);
-  });
-  it("should include docs", async () => {
-    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;
-  let indexer: Index<TestType, [string, number]>;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("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<TestType, [string, number]>(sthis, db.ledger.crdt, "hello", (doc) => {
-      return [doc.title, doc.score];
-    });
-    await indexer.ready();
-  });
-  it("should prefix query", async () => {
-    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;
-  let indexer: Index<TestType, string>;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-indexer");
-    await db.put({ title: "amazing" });
-    await db.put({ title: "creative" });
-    await db.put({ title: "bazillas" });
-    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "hello", (doc, map) => {
-      map(doc.title);
-    });
-    await indexer.ready();
-  });
-  it("should get results", async () => {
-    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;
-  let indexer: Index<TestType, string, number>;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-indexer");
-    await db.put({ title: "amazing" });
-    await db.put({ title: "creative" });
-    await db.put({ title: "bazillas" });
-    indexer = new Index<TestType, string, number>(sthis, db.ledger.crdt, "hello", (doc, map) => {
-      map(doc.title, doc.title.length);
-    });
-  });
-  it("should get results", async () => {
-    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 () => {
-    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;
-  let indexer: Index<TestType, [string, number]>;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("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<TestType, [string, number]>(sthis, db.ledger.crdt, "hello", (doc, emit) => {
-      emit([doc.title, doc.score]);
-    });
-    await indexer.ready();
-  });
-  it("should prefix query", async () => {
-    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;
-  let indexer: Index<TestType, string>;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-indexer");
-    await db.put({ title: "amazing" });
-    await db.put({ title: "creative" });
-    await db.put({ title: "bazillas" });
-    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "title");
-    await indexer.ready();
-  });
-  it("should get results", async () => {
-    const result = await indexer.query();
-    expect(result).toBeTruthy();
-    expect(result.rows).toBeTruthy();
-    expect(result.rows.length).toBe(3);
-  });
-  it("should include docs", async () => {
-    const { rows } = await indexer.query();
-    expect(rows.length).toBeTruthy();
-    expect(rows[0].doc).toBeTruthy();
-  });
-});
-
-describe("basic Index with string fun and numeric keys", function () {
-  let db: Database;
-  let indexer: Index<TestType, string>;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-indexer");
-    await db.put({ points: 0 });
-    await db.put({ points: 1 });
-    await db.put({ points: 2 });
-    await db.put({ points: 3 });
-    indexer = new Index<TestType, string>(sthis, db.ledger.crdt, "points");
-    await indexer.ready();
-  });
-  it("should get results", async () => {
-    const result = await indexer.query();
-    expect(result).toBeTruthy();
-    expect(result.rows).toBeTruthy();
-    expect(result.rows.length).toBe(4);
-  });
-  it("should include docs", async () => {
-    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;
-  let indexer: Index<TestType>;
-  let didMap: number;
-  let mapFn: (doc: TestType) => string;
-  let result: IndexRows<TestType>;
-  const sthis = ensureSuperThis();
-  let dbOpts: LedgerOpts;
-  // result, mapFn;
-  afterEach(async () => {
-    await crdt.close();
-    await crdt.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    const logger = sthis.logger.With().Module("IndexerTest").Logger();
-    logger.Debug().Msg("enter beforeEach");
-    dbOpts = {
-      name: "test-indexer-cold",
-      writeQueue: defaultWriteQueueOpts({}),
-      keyBag: rt.kb.defaultKeyBagOpts(sthis),
-      storeUrls: toStoreURIRuntime(sthis, "test-indexer-cold"),
-      storeEnDe: bs.ensureStoreEnDeFile({}),
-      ctx: new AppContext(),
-      tracer,
-    };
-    crdt = new CRDTImpl(sthis, dbOpts);
-    await crdt.bulk([
-      { id: "abc1", value: { title: "amazing" } },
-      { id: "abc2", value: { title: "creative" } },
-      { id: "abc3", value: { title: "bazillas" } },
-    ]);
-    logger.Debug().Msg("post bulk beforeEach");
-    didMap = 0;
-    mapFn = (doc) => {
-      didMap++;
-      return doc.title;
-    };
-    indexer = await index<TestType>(crdt, "hello", mapFn);
-    logger.Debug().Msg("post index beforeEach");
-    await indexer.ready();
-    logger.Debug().Msg("post indexer.ready beforeEach");
-    // new Index(db._crdt.indexBlockstore, db._crdt, 'hello', mapFn)
-    result = await indexer.query();
-
-    logger.Debug().Msg("post indexer.query beforeEach");
-    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 () => {
-    const crdt2 = new CRDTImpl(sthis, dbOpts);
-    await crdt2.ready();
-    const { result, head } = await crdt2.changes();
-    expect(result).toBeTruthy();
-    await crdt2.ready();
-    const indexer2 = await index<TestType>(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);
-  });
-  it.skip("should not rerun the map function on seen changes", async () => {
-    didMap = 0;
-    const crdt2 = new CRDTImpl(sthis, dbOpts);
-    const indexer2 = await index(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 () => {
-    const crdt2 = new CRDTImpl(sthis, dbOpts);
-    const result = await index<TestType>(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;
-  let indexer: Index<TestType>;
-  let didMap: boolean;
-  const sthis = ensureSuperThis();
-  afterEach(async () => {
-    await db.close();
-    await db.destroy();
-    // await indexer.close();
-    // await indexer.destroy();
-  });
-  beforeEach(async () => {
-    await sthis.start();
-    db = fireproof("test-indexer");
-    indexer = new Index<TestType>(sthis, db.ledger.crdt, "hello", (doc) => {
-      didMap = true;
-      return doc.title;
-    });
-    await indexer.ready();
-  });
-  it("should have properties", function () {
-    expect(indexer.crdt).toEqual(db.ledger.crdt);
-    expect(indexer.name).toEqual("hello");
-    expect(indexer.mapFn).toBeTruthy();
-  });
-  it("should not call the map function on first query", async () => {
-    didMap = false;
-    await indexer.query();
-    expect(didMap).toBeFalsy();
-  });
-  it("should not call the map function on second query", async () => {
-    await indexer.query();
-    didMap = false;
-    await indexer.query();
-    expect(didMap).toBeFalsy();
-  });
-  it("should get results", async () => {
-    const result = await indexer.query();
-    expect(result).toBeTruthy();
-    expect(result.rows).toBeTruthy();
-    expect(result.rows.length).toEqual(0);
-  });
-});

package/tests/fireproof/multiple-ledger.test.ts

@@ -1,65 +0,0 @@
-import { Database, ensureSuperThis, fireproof } from "@fireproof/core";
-
-interface DBItem {
-  readonly db: Database;
-  readonly name: string;
-}
-
-function shuffle(ina: DBItem[]): DBItem[] {
-  const array = [...ina];
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [array[j], array[i]];
-  }
-  return array;
-}
-
-describe("Multiple Databases", () => {
-  const dbs: DBItem[] = [];
-  const sthis = ensureSuperThis();
-  const rows = 10;
-  const concurrentDbs = 7;
-  beforeEach(async () => {
-    const group = sthis.nextId().str;
-    await Promise.all(
-      Array(concurrentDbs)
-        .fill(0)
-        .map(async (_, i) => {
-          const name = `db-${group}-${i}`;
-          const db = fireproof(name);
-          dbs.push({ db, name });
-          for (let i = 0; i < rows; i++) {
-            await db.put({ _id: `${name}-${i}`, hello: "world" });
-          }
-        }),
-    );
-  });
-  afterEach(async () => {
-    await Promise.all(
-      dbs.map(async (db) => {
-        await db.db.close();
-        await db.db.destroy();
-      }),
-    );
-    dbs.length = 0;
-  });
-
-  it("random access to multiple databases", async () => {
-    const random = shuffle(dbs);
-    const res = await Promise.all(
-      random.map((di) => {
-        return Promise.all(
-          Array(10)
-            .fill(0)
-            .map(async (_, i) => di.db.get(`${di.name}-${i}`)),
-        );
-      }),
-    );
-    // console.log(res)
-    res.forEach((res, i) => {
-      for (let j = 0; j < rows; j++) {
-        expect(res[j]._id).toBe(`${random[i].name}-${j}`);
-      }
-    });
-  });
-});