@bodil/bdb 0.1.0

package/src/index.test.ts

@@ -0,0 +1,200 @@
+import "temporal-polyfill/global";
+import "fake-indexeddb/auto";
+
+import { time } from "@bodil/core";
+import { sleep } from "@bodil/core/async";
+import { Signal } from "@bodil/signal";
+import { expect, expectTypeOf, test } from "vitest";
+
+import { arrayIndex, compoundIndex, createTable, index, timeIndex } from ".";
+import { IndexedDBBackend } from "./backend";
+import type { IndexablesOf } from "./types";
+
+test("indexable", () => {
+    type IndexableTest = {
+        key: string;
+        value: number;
+        stamp: Temporal.Instant;
+        object: { foo: string; bar: number };
+        valueOfObject: { foo: number; valueOf(): number };
+        goodArray: Array<string>;
+        tuple: [string, number];
+        badArray: Array<Element>;
+    };
+    expectTypeOf<IndexablesOf<IndexableTest>>().toEqualTypeOf<
+        "key" | "value" | "goodArray" | "tuple"
+    >();
+});
+
+test("memdb basics", () => {
+    type TestItem = {
+        id: string;
+        created: Temporal.Instant;
+        uri: string;
+        tags: Array<string>;
+    };
+
+    const table = createTable<TestItem>()(index<TestItem>()("id"))
+        .withIndex(timeIndex<TestItem>()("created"))
+        .withIndex(index<TestItem>()("uri"))
+        .withIndex(arrayIndex<TestItem>()("tags"))
+        .withIndex(compoundIndex<TestItem>()("id", "uri"));
+
+    const now = time.now();
+    const [welp, wolp, wulp, wilp] = [
+        {
+            id: "welp",
+            created: now.add(time.seconds(1)),
+            uri: "http://lol.com",
+            tags: ["bar", "foo"],
+            stamp: time.now(),
+        },
+        {
+            id: "wolp",
+            created: now,
+            uri: "https://rofl.com",
+            tags: ["foo"],
+            stamp: time.now(),
+        },
+        {
+            id: "wulp",
+            created: now.add(time.seconds(2)),
+            uri: "ftp://ftp.lol.gov",
+            tags: ["bar"],
+            stamp: time.now(),
+        },
+        {
+            id: "wilp",
+            created: now.add(time.seconds(1)),
+            uri: "http://altavista.com",
+            tags: [],
+            stamp: time.now(),
+        },
+    ];
+
+    table.add(welp, wolp, wulp, wilp);
+
+    // Lookup should return the exact same objects.
+    expect(table.get("welp")).equal(welp);
+    expect(table.get("wolp")).equal(wolp);
+    expect(table.get("wulp")).equal(wulp);
+    expect(table.get("wilp")).equal(wilp);
+
+    // The objects should be frozen when added to the database.
+    expect(() => {
+        welp.id = "walp";
+    }).throw(TypeError);
+
+    // Index equal query should return all relevant matches.
+    let query = table.where("created").equals(now.add(time.seconds(1)));
+    expect(Array.from(query)).deep.equal([welp, wilp]);
+
+    query = table.where("uri").equals("ftp://ftp.lol.gov");
+    expect(Array.from(query)).deep.equal([wulp]);
+
+    query = table.where("*tags").equals("foo");
+    expect(Array.from(query)).deep.equal([welp, wolp]);
+    query = table.where("*tags").equals("bar");
+    expect(Array.from(query)).deep.equal([welp, wulp]);
+
+    query = table.where("id&uri").equals(["welp", "http://lol.com"]);
+    expect(Array.from(query)).deep.equal([welp]);
+    query = table.where("id&uri").equals(["welp", "http://lol.org"]);
+    expect(Array.from(query)).empty;
+    query = table.where("id&uri").equals(["wolp", "https://rofl.com"]);
+    expect(Array.from(query)).deep.equal([wolp]);
+
+    // Query should correctly infer type of key.
+    const _checkCreatedQueryType = table.where("created").equals;
+    expectTypeOf<Parameters<typeof _checkCreatedQueryType>>().toEqualTypeOf<[Temporal.Instant]>();
+    const _checkTagsQueryType = table.where("*tags").equals;
+    expectTypeOf<Parameters<typeof _checkTagsQueryType>>().toEqualTypeOf<[string]>();
+    const _checkCompoundQueryType = table.where("id&uri").equals;
+    expectTypeOf<Parameters<typeof _checkCompoundQueryType>>().toEqualTypeOf<[[string, string]]>();
+});
+
+test("memdb index dupes", () => {
+    type Account = { id: string; order: number };
+    const accounts = createTable<Account>()(index<Account>()("id")).withIndex(
+        index<Account>()("order")
+    );
+
+    const account = { id: "test@test.com", order: 1 };
+    accounts.add({ ...account });
+    expect(accounts.orderBy("order").toArray()).length(1);
+    accounts.add({ ...account });
+    expect(accounts.orderBy("order").toArray()).length(1);
+});
+
+test("memdb signals", () => {
+    type Thing = { name: string; counter: number };
+    const things = createTable<Thing>()(index<Thing>()("name"));
+
+    type ThingMap = { id: number; name: string };
+    const thingMaps = createTable<ThingMap>()(index<ThingMap>()("id"));
+    thingMaps.add({ id: 1, name: "Mike" }, { id: 2, name: "Robert" });
+
+    const joe = things.signal("Joe");
+    expect(joe.value).toBeUndefined();
+
+    things.add({ name: "Joe", counter: 1 });
+    expect(joe.value).not.toBeUndefined();
+
+    const joeCounter = Signal.computed(() => joe.value?.counter);
+    expect(joeCounter.value).toEqual(1);
+
+    const mappedCounter = Signal.computed(() => {
+        const c = joe.value?.counter;
+        return c === undefined ? undefined : thingMaps.signal(c)?.value?.name;
+    });
+    expect(mappedCounter.value).toEqual("Mike");
+
+    things.add({ name: "Joe", counter: 2 });
+    expect(joeCounter.value).toEqual(2);
+    expect(mappedCounter.value).toEqual("Robert");
+
+    thingMaps.add({ id: 2, name: "Bjarne" });
+    expect(mappedCounter.value).toEqual("Bjarne");
+
+    things.delete("Joe");
+    expect(joeCounter.value).toBeUndefined();
+    expect(mappedCounter.value).toBeUndefined();
+});
+
+test("failed update shouldn't change anything", () => {
+    type Thing = { name: string; counter: number };
+    const things = createTable<Thing>()(index<Thing>()("name"));
+
+    things.add({ name: "Joe", counter: 321 });
+    expect(() =>
+        things.update("Joe", (item) => {
+            item.counter = 123;
+            throw new TypeError("welp!");
+        })
+    ).toThrowError(new TypeError("welp!"));
+    expect(things.get("Joe")?.counter).toEqual(321);
+});
+
+test("IndexedDB", async () => {
+    type Thing = { key: string; value: string };
+    {
+        const store = await IndexedDBBackend.open({ name: "test", version: 1 });
+        const things = createTable<Thing>()(index<Thing>()("key")).withStorage(store, "things");
+        await things.ready;
+        things.add(
+            { key: "Joe", value: "Armstrong" },
+            { key: "Robert", value: "Virding" },
+            { key: "Mike", value: "Williams" }
+        );
+        expect(things.get("Joe")).deep.equal({ key: "Joe", value: "Armstrong" });
+        expect(things.get("Bjarne")).toBeUndefined();
+        await sleep(1);
+    }
+    {
+        const store = await IndexedDBBackend.open({ name: "test", version: 1 });
+        const things = createTable<Thing>()(index<Thing>()("key")).withStorage(store, "things");
+        await things.ready;
+        expect(things.get("Joe")).deep.equal({ key: "Joe", value: "Armstrong" });
+        expect(things.get("Bjarne")).toBeUndefined();
+    }
+});

package/src/index.ts

@@ -0,0 +1,76 @@
+import type { OrderFn } from "@bodil/core/order";
+import BTree from "sorted-btree";
+
+import { ArrayIndex, CompoundIndex, CustomIndex, PrimitiveIndex, type UnitIndex } from "./indices";
+import { Table } from "./table";
+import type { ArrayIndexablesOf, CustomIndexablesOf, PrimitiveIndexablesOf } from "./types";
+
+export type {
+    Index,
+    ArrayIndex,
+    CompoundIndex,
+    CustomIndex,
+    PrimitiveIndex,
+    UnitIndex,
+} from "./indices";
+export type {
+    IndexablePrimitive,
+    ArrayIndexablesOf,
+    CustomIndexablesOf,
+    PrimitiveIndexablesOf,
+} from "./types";
+export type { Table, TableEvent } from "./table";
+export type { IndexQuery, ArrayQuery, ChainQuery } from "./query";
+export type { Broadcaster } from "./broadcast";
+export type { IndexedDBBackendConfig, DatabaseBroadcast } from "./backend";
+
+export { StorageBackend, IndexedDBBackend } from "./backend";
+
+export function createTable<A extends object>(): <PI extends UnitIndex<A>>(
+    primaryIndex: PI,
+) => Table<A, PI, PI["record"]> {
+    return (primaryIndex) => new Table(primaryIndex);
+}
+
+export function index<A extends object>(): <I extends PrimitiveIndexablesOf<A>>(
+    key: I,
+) => PrimitiveIndex<A, I> {
+    return (key) => new PrimitiveIndex(key);
+}
+
+export function timeIndex<A extends object>(): <I extends CustomIndexablesOf<A, Temporal.Instant>>(
+    key: I,
+) => CustomIndex<A, Temporal.Instant, I> {
+    return (key) =>
+        new CustomIndex(
+            key,
+            () => new BTree(undefined, Temporal.Instant.compare as OrderFn<A[typeof key]>),
+        );
+}
+
+export function arrayIndex<A extends object>(): <
+    I extends ArrayIndexablesOf<A>,
+    L extends A[I] & Array<unknown>,
+>(
+    key: I,
+) => ArrayIndex<A, I, L> {
+    return (key) => new ArrayIndex(key);
+}
+
+export function compoundIndex<A extends object>(): <
+    I extends PrimitiveIndexablesOf<A>,
+    J extends Exclude<PrimitiveIndexablesOf<A>, I>,
+>(
+    leftKey: I,
+    rightKey: J,
+) => CompoundIndex<A, I, J> {
+    return (leftKey, rightKey) => new CompoundIndex(leftKey, rightKey);
+}
+
+export function customIndex<A extends object, T>(): <I extends CustomIndexablesOf<A, T>>(
+    key: I,
+    orderFn: OrderFn<T>,
+) => CustomIndex<A, T, I> {
+    return (key, orderFn: OrderFn<T>) =>
+        new CustomIndex(key, () => new BTree(undefined, orderFn as OrderFn<A[typeof key]>));
+}

package/src/indices.ts

@@ -0,0 +1,108 @@
+import type BTree from "sorted-btree";
+
+import type { ArrayIndexablesOf, CustomIndexablesOf, PrimitiveIndexablesOf } from "./types";
+
+export abstract class Index<A extends object> {
+    readonly name!: string;
+    readonly keyType!: unknown;
+    readonly record!: object;
+    abstract extractKeys(value: A): Array<typeof this.keyType>;
+}
+
+export abstract class UnitIndex<A extends object> extends Index<A> {
+    abstract extractKey(value: A): typeof this.keyType;
+}
+
+export class CustomIndex<A extends object, T, I extends CustomIndexablesOf<A, T>>
+    implements Index<A>, UnitIndex<A>
+{
+    readonly keyType!: A[I];
+    readonly record!: { [K in I]: this };
+
+    constructor(
+        public readonly index: I,
+        public readonly makeIndex: () => BTree<A[I], Array<A>>,
+    ) {}
+
+    get name(): I {
+        return this.index;
+    }
+
+    extractKey(value: A): A[I] {
+        return value[this.index];
+    }
+
+    extractKeys(value: A): Array<A[I]> {
+        return [value[this.index]];
+    }
+}
+
+export class PrimitiveIndex<A extends object, I extends PrimitiveIndexablesOf<A>>
+    implements Index<A>, UnitIndex<A>
+{
+    readonly keyType!: A[I];
+    readonly record!: { [K in I]: this };
+
+    constructor(public readonly index: I) {}
+
+    get name(): I {
+        return this.index;
+    }
+
+    extractKey(value: A): A[I] {
+        return value[this.index];
+    }
+
+    extractKeys(value: A): Array<A[I]> {
+        return [value[this.index]];
+    }
+}
+
+export class ArrayIndex<
+    A extends object,
+    I extends ArrayIndexablesOf<A>,
+    L extends A[I] & Array<unknown>,
+> implements Index<A>
+{
+    readonly index: I;
+    readonly name: `*${I}`;
+    readonly keyType!: L[number];
+    readonly record!: { [K in `*${I}`]: this };
+
+    constructor(index: I) {
+        this.index = index;
+        this.name = `*${index}`;
+    }
+
+    extractKeys(value: A): L {
+        return value[this.index] as L;
+    }
+}
+
+export class CompoundIndex<
+        A extends object,
+        I extends PrimitiveIndexablesOf<A>,
+        J extends Exclude<PrimitiveIndexablesOf<A>, I>,
+    >
+    implements Index<A>, UnitIndex<A>
+{
+    readonly leftIndex: I;
+    readonly rightIndex: J;
+    readonly name: `${I}&${J}`;
+    readonly keyType!: [A[I], A[J]];
+    readonly record!: { [K in `${I}&${J}`]: this };
+
+    constructor(leftIndex: I, rightIndex: J) {
+        this.leftIndex = leftIndex;
+        this.rightIndex = rightIndex;
+        this.name = `${leftIndex}&${rightIndex}`;
+    }
+
+    extractKey(value: A): [A[I], A[J]] {
+        return [value[this.leftIndex], value[this.rightIndex]];
+    }
+
+    extractKeys(value: A): Array<[A[I], A[J]]> {
+        return [[value[this.leftIndex], value[this.rightIndex]]];
+    }
+}

package/src/query.ts

@@ -0,0 +1,233 @@
+import { assert } from "@bodil/core/assert";
+import { Option } from "@bodil/opt";
+import { Signal } from "@bodil/signal";
+import type BTree from "sorted-btree";
+
+import type { Index, UnitIndex } from "./indices";
+import type { Table } from "./table";
+
+export enum IteratorDirection {
+    Ascending = 0,
+    Descending = 1,
+    DescendingExclusive = 2,
+}
+
+function* indexIterator<A extends object, I extends Index<A>>(
+    table: BTree<I["keyType"], Array<A>>,
+    direction: IteratorDirection,
+    start?: I["keyType"],
+): Generator<Readonly<A>> {
+    if (table.isEmpty) {
+        return;
+    }
+    if (direction === IteratorDirection.Ascending) {
+        for (const items of table.values(start)) {
+            for (const item of items) {
+                yield item;
+            }
+        }
+    } else {
+        for (const entry of table.entriesReversed(
+            start,
+            undefined,
+            direction === IteratorDirection.DescendingExclusive,
+        )) {
+            for (const item of entry[1]) {
+                yield item;
+            }
+        }
+    }
+}
+
+function* primaryIndexIterator<A extends object, I extends UnitIndex<A>>(
+    table: BTree<I["keyType"], Readonly<A>>,
+    direction: IteratorDirection,
+    start?: I["keyType"],
+): Generator<Readonly<A>> {
+    if (table.isEmpty) {
+        return;
+    }
+    if (direction === IteratorDirection.Ascending) {
+        for (const item of table.values(start)) {
+            yield item;
+        }
+    } else {
+        for (const entry of table.entriesReversed(
+            start,
+            undefined,
+            direction === IteratorDirection.DescendingExclusive,
+        )) {
+            yield entry[1];
+        }
+    }
+}
+
+export abstract class Query<A extends object> implements Iterable<Readonly<A>> {
+    abstract [Symbol.iterator](): IterableIterator<Readonly<A>>;
+    abstract signal(): Signal.Computed<Array<Readonly<A>>>;
+
+    map<B>(mapFn: (item: Readonly<A>) => B): IterableIterator<B> {
+        return Iterator.from(this).map(mapFn);
+    }
+
+    forEach(action: (item: A) => void): void {
+        for (const item of this) {
+            action(item);
+        }
+    }
+
+    toArray(): Array<Readonly<A>> {
+        return Array.from(this);
+    }
+}
+
+export abstract class TableQuery<
+    A extends object,
+    PI extends UnitIndex<A>,
+    Ix extends object,
+> extends Query<A> {
+    table: Table<A, PI, Ix>;
+
+    constructor(table: Table<A, PI, Ix>) {
+        super();
+        this.table = table;
+    }
+
+    signal(): Signal.Computed<Array<Readonly<A>>> {
+        return Signal.computed(() => {
+            this.table.changed.get();
+            return Array.from(this);
+        });
+    }
+
+    delete(): number {
+        return this.table.delete(...Array.from(this));
+    }
+
+    filter(predicate: (item: Readonly<A>) => boolean): ChainQuery<A, PI, Ix> {
+        return new ChainQuery(this.table, this, (iter) => Iterator.from(iter).filter(predicate));
+    }
+
+    limit(count: number): ChainQuery<A, PI, Ix> {
+        return new ChainQuery(this.table, this, (iter) => Iterator.from(iter).take(count));
+    }
+}
+
+export class IndexQuery<
+    A extends object,
+    PI extends UnitIndex<A>,
+    I extends Index<A>,
+    Ix extends object,
+> extends TableQuery<A, PI, Ix> {
+    private readonly index: I;
+    private readonly indexTable?: BTree<I["keyType"], Array<A>>;
+    private readonly isPrimary: boolean;
+    private start?: I["keyType"];
+    private direction: IteratorDirection;
+
+    constructor(
+        table: Table<A, PI, Ix>,
+        indexKey: keyof Ix & string,
+        direction: IteratorDirection,
+        start?: I["keyType"],
+    ) {
+        super(table);
+        this.isPrimary = table.primaryIndex.name === indexKey;
+        if (this.isPrimary) {
+            this.index = table.primaryIndex as unknown as I;
+        } else {
+            this.index = (table.indices as any)[indexKey];
+            assert(this.index !== undefined, `Undefined index "${indexKey}"`);
+            this.indexTable = (table.indexTables as any)[indexKey];
+        }
+        this.direction = direction;
+        this.start = start;
+    }
+
+    [Symbol.iterator](): IterableIterator<Readonly<A>> {
+        return this.isPrimary
+            ? primaryIndexIterator(this.table.primary, this.direction, this.start)
+            : indexIterator(this.indexTable!, this.direction, this.start);
+    }
+
+    reverse(): this {
+        switch (this.direction) {
+            case IteratorDirection.Ascending:
+                this.direction = IteratorDirection.Descending;
+                return this;
+            case IteratorDirection.Descending:
+                this.direction = IteratorDirection.Ascending;
+                return this;
+            case IteratorDirection.DescendingExclusive:
+                throw new Error("not sure how to reverse IteratorDirection.DescendingExclusive");
+        }
+    }
+
+    equals(value: I["keyType"]): ArrayQuery<A, PI, Ix> {
+        if (this.isPrimary) {
+            const item = this.table.get(value);
+            return new ArrayQuery(this.table, item === undefined ? [] : [item]);
+        }
+        return new ArrayQuery(this.table, this.indexTable!.get(value) ?? []);
+    }
+
+    below(value: I["keyType"]): this {
+        this.start = value;
+        this.direction = IteratorDirection.DescendingExclusive;
+        return this;
+    }
+
+    max(): Option<I["keyType"]> {
+        return Option.from(
+            this.isPrimary ? this.table.primary.maxKey() : this.indexTable!.maxKey(),
+        );
+    }
+
+    min(): Option<I["keyType"]> {
+        return Option.from(
+            this.isPrimary ? this.table.primary.minKey() : this.indexTable!.minKey(),
+        );
+    }
+}
+
+export class ChainQuery<
+    A extends object,
+    PI extends UnitIndex<A>,
+    Ix extends object,
+> extends TableQuery<A, PI, Ix> {
+    private readonly parent: Query<A>;
+    private readonly iterator: (
+        parentIterator: IterableIterator<Readonly<A>>,
+    ) => IterableIterator<Readonly<A>>;
+
+    constructor(
+        table: Table<A, PI, Ix>,
+        parent: Query<A>,
+        iterator: (parentIterator: IterableIterator<Readonly<A>>) => IterableIterator<Readonly<A>>,
+    ) {
+        super(table);
+        this.parent = parent;
+        this.iterator = iterator;
+    }
+
+    [Symbol.iterator](): IterableIterator<Readonly<A>> {
+        return this.iterator(this.parent[Symbol.iterator]());
+    }
+}
+
+export class ArrayQuery<
+    A extends object,
+    PI extends UnitIndex<A>,
+    Ix extends object,
+> extends TableQuery<A, PI, Ix> {
+    private readonly values: Array<Readonly<A>>;
+
+    constructor(table: Table<A, PI, Ix>, values: Array<Readonly<A>>) {
+        super(table);
+        this.values = values;
+    }
+
+    [Symbol.iterator](): IterableIterator<Readonly<A>> {
+        return this.values[Symbol.iterator]();
+    }
+}