applesauce-core 0.0.0-next-20241103143210

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# applesauce-core
+
+AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/modules/Queries)
+
+# Example
+
+```js
+import { EventStore, QueryStore } from "applesauce-core";
+import { Relay } from "nostr-tools/relay";
+
+// The EventStore handles all the events
+const eventStore = new EventStore();
+
+// The QueryStore handles queries and makes sure not to run multiple of the same query
+const queryStore = new QueryStore(eventStore);
+
+// Use nostr-tools or anything else to talk to relays
+const relay = await Relay.connect("wss://relay.example.com");
+
+const sub = relay.subscribe([{ authors: ["266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5"] }], {
+  onevent(event) {
+    eventStore.add(event);
+  },
+});
+
+// This will return an Observable<ProfileContent | undefined> of the parsed metadata
+const profile = queryStore.profile("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+
+profile.subscribe((parsed) => {
+  if (parsed) console.log(parsed);
+});
+
+// This will return an Observable<NostrEvent[]> of all kind 1 events sorted by created_at
+const timeline = queryStore.timeline({ kinds: [1] });
+
+timeline.subscribe((events) => {
+  console.log(events);
+});
+```

package/dist/event-store/common.d.ts

@@ -0,0 +1 @@
+export declare const INDEXABLE_TAGS: Set<string>;

package/dist/event-store/common.js

@@ -0,0 +1,2 @@
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+export const INDEXABLE_TAGS = new Set((LETTERS + LETTERS.toUpperCase()).split(""));

package/dist/event-store/database.d.ts

@@ -0,0 +1,60 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Subject } from "rxjs";
+import { LRU } from "../helpers/lru.js";
+/**
+ * An in-memory database for nostr events
+ */
+export declare class Database {
+    protected log: import("debug").Debugger;
+    /** Indexes */
+    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
+    protected authors: Map<string, Set<import("nostr-tools").Event>>;
+    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected created_at: NostrEvent[];
+    /** LRU cache of last events touched */
+    events: LRU<import("nostr-tools").Event>;
+    /** A stream of events inserted into the database */
+    inserted: Subject<import("nostr-tools").Event>;
+    /** A stream of events that have been updated */
+    updated: Subject<import("nostr-tools").Event>;
+    /** A stream of events removed of the database */
+    deleted: Subject<import("nostr-tools").Event>;
+    get size(): number;
+    protected claims: WeakMap<import("nostr-tools").Event, any>;
+    /** Index helper methods */
+    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
+    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /** Moves an event to the top of the LRU cache */
+    touch(event: NostrEvent): void;
+    hasEvent(uid: string): import("nostr-tools").Event | undefined;
+    getEvent(uid: string): import("nostr-tools").Event | undefined;
+    /** Checks if the database contains a replaceable event without touching it */
+    hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
+    /** Gets a replaceable event and touches it */
+    getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
+    /** Inserts an event into the database and notifies all subscriptions */
+    addEvent(event: NostrEvent): import("nostr-tools").Event;
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    updateEvent(event: NostrEvent): import("nostr-tools").Event;
+    /** Deletes an event from the database and notifies all subscriptions */
+    deleteEvent(eventOrUID: string | NostrEvent): boolean;
+    /** Sets the claim on the event and touches it */
+    claimEvent(event: NostrEvent, claim: any): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): boolean;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): void;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): void;
+    iterateAuthors(authors: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    iterateTag(tag: string, values: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    iterateKinds(kinds: Iterable<number>): Generator<import("nostr-tools").Event, void, unknown>;
+    iterateTime(since: number | undefined, until: number | undefined): Generator<never, Set<import("nostr-tools").Event>, unknown>;
+    iterateIds(ids: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter: Filter): Set<NostrEvent>;
+    getForFilters(filters: Filter[]): Set<import("nostr-tools").Event>;
+    /** Remove the oldest events that are not claimed */
+    prune(limit?: number): number;
+}

package/dist/event-store/database.js

@@ -0,0 +1,294 @@
+import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import { Subject } from "rxjs";
+import { FromCacheSymbol, getEventUID, getIndexableTags, getReplaceableUID } from "../helpers/event.js";
+import { INDEXABLE_TAGS } from "./common.js";
+import { logger } from "../logger.js";
+import { LRU } from "../helpers/lru.js";
+/**
+ * An in-memory database for nostr events
+ */
+export class Database {
+    log = logger.extend("Database");
+    /** Indexes */
+    kinds = new Map();
+    authors = new Map();
+    tags = new LRU();
+    created_at = [];
+    /** LRU cache of last events touched */
+    events = new LRU();
+    /** A stream of events inserted into the database */
+    inserted = new Subject();
+    /** A stream of events that have been updated */
+    updated = new Subject();
+    /** A stream of events removed of the database */
+    deleted = new Subject();
+    get size() {
+        return this.events.size;
+    }
+    claims = new WeakMap();
+    /** Index helper methods */
+    getKindIndex(kind) {
+        if (!this.kinds.has(kind))
+            this.kinds.set(kind, new Set());
+        return this.kinds.get(kind);
+    }
+    getAuthorsIndex(author) {
+        if (!this.authors.has(author))
+            this.authors.set(author, new Set());
+        return this.authors.get(author);
+    }
+    getTagIndex(tagAndValue) {
+        if (!this.tags.has(tagAndValue)) {
+            // build new tag index from existing events
+            const events = new Set();
+            const ts = Date.now();
+            for (const event of this.events.values()) {
+                if (getIndexableTags(event).has(tagAndValue)) {
+                    events.add(event);
+                }
+            }
+            const took = Date.now() - ts;
+            if (took > 100)
+                this.log(`Built index ${tagAndValue} took ${took}ms`);
+            this.tags.set(tagAndValue, events);
+        }
+        return this.tags.get(tagAndValue);
+    }
+    /** Moves an event to the top of the LRU cache */
+    touch(event) {
+        this.events.set(getEventUID(event), event);
+    }
+    hasEvent(uid) {
+        return this.events.get(uid);
+    }
+    getEvent(uid) {
+        return this.events.get(uid);
+    }
+    /** Checks if the database contains a replaceable event without touching it */
+    hasReplaceable(kind, pubkey, d) {
+        return this.events.has(getReplaceableUID(kind, pubkey, d));
+    }
+    /** Gets a replaceable event and touches it */
+    getReplaceable(kind, pubkey, d) {
+        return this.events.get(getReplaceableUID(kind, pubkey, d));
+    }
+    /** Inserts an event into the database and notifies all subscriptions */
+    addEvent(event) {
+        const uid = getEventUID(event);
+        const current = this.events.get(uid);
+        if (current && event.created_at <= current.created_at) {
+            // if this is a duplicate event, transfer some import symbols
+            if (current.id === event.id) {
+                if (event[FromCacheSymbol])
+                    current[FromCacheSymbol] = event[FromCacheSymbol];
+            }
+            return current;
+        }
+        this.events.set(uid, event);
+        this.getKindIndex(event.kind).add(event);
+        this.getAuthorsIndex(event.pubkey).add(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).add(event);
+            }
+        }
+        insertEventIntoDescendingList(this.created_at, event);
+        this.inserted.next(event);
+        return event;
+    }
+    /** Inserts and event into the database and notifies all subscriptions that the event has updated */
+    updateEvent(event) {
+        const inserted = this.addEvent(event);
+        this.updated.next(inserted);
+        return inserted;
+    }
+    /** Deletes an event from the database and notifies all subscriptions */
+    deleteEvent(eventOrUID) {
+        let event = typeof eventOrUID === "string" ? this.events.get(eventOrUID) : eventOrUID;
+        if (!event)
+            throw new Error("Missing event");
+        const uid = getEventUID(event);
+        // only remove events that are known
+        if (!this.events.has(uid))
+            return false;
+        this.getAuthorsIndex(event.pubkey).delete(event);
+        this.getKindIndex(event.kind).delete(event);
+        for (const tag of getIndexableTags(event)) {
+            if (this.tags.has(tag)) {
+                this.getTagIndex(tag).delete(event);
+            }
+        }
+        // remove from created_at index
+        const i = this.created_at.indexOf(event);
+        this.created_at.splice(i, 1);
+        this.events.delete(uid);
+        this.deleted.next(event);
+        return true;
+    }
+    /** Sets the claim on the event and touches it */
+    claimEvent(event, claim) {
+        if (!this.claims.has(event)) {
+            this.claims.set(event, claim);
+        }
+        // always touch event
+        this.touch(event);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.claims.has(event);
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        const current = this.claims.get(event);
+        if (current === claim)
+            this.claims.delete(event);
+    }
+    /** Removes all claims on an event */
+    clearClaim(event) {
+        this.claims.delete(event);
+    }
+    *iterateAuthors(authors) {
+        for (const author of authors) {
+            const events = this.authors.get(author);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateTag(tag, values) {
+        for (const value of values) {
+            const events = this.getTagIndex(tag + ":" + value);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateKinds(kinds) {
+        for (const kind of kinds) {
+            const events = this.kinds.get(kind);
+            if (events) {
+                for (const event of events)
+                    yield event;
+            }
+        }
+    }
+    *iterateTime(since, until) {
+        let untilIndex = 0;
+        let sinceIndex = this.created_at.length - 1;
+        let start = until
+            ? binarySearch(this.created_at, (mid) => {
+                if (mid.created_at === until)
+                    return -1;
+                return mid.created_at - until;
+            })
+            : undefined;
+        if (start && start[1])
+            untilIndex = start[0];
+        const end = since
+            ? binarySearch(this.created_at, (mid) => {
+                if (mid.created_at === since)
+                    return 1;
+                return since - mid.created_at;
+            })
+            : undefined;
+        if (end && end[1])
+            sinceIndex = end[0];
+        const events = new Set();
+        for (let i = untilIndex; i <= sinceIndex; i++) {
+            events.add(this.created_at[i]);
+        }
+        return events;
+    }
+    *iterateIds(ids) {
+        for (const id of ids) {
+            if (this.events.has(id))
+                yield this.events.get(id);
+        }
+    }
+    /** Returns all events that match the filter */
+    getEventsForFilter(filter) {
+        // search is not supported, return an empty set
+        if (filter.search)
+            return new Set();
+        let first = true;
+        let events = new Set();
+        const and = (iterable) => {
+            const set = iterable instanceof Set ? iterable : new Set(iterable);
+            if (first) {
+                events = set;
+                first = false;
+            }
+            else {
+                for (const event of events) {
+                    if (!set.has(event))
+                        events.delete(event);
+                }
+            }
+            return events;
+        };
+        if (filter.ids)
+            and(this.iterateIds(filter.ids));
+        let time = null;
+        // query for time first if since is set
+        if (filter.since !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        for (const t of INDEXABLE_TAGS) {
+            const key = `#${t}`;
+            const values = filter[key];
+            if (values?.length)
+                and(this.iterateTag(t, values));
+        }
+        if (filter.authors)
+            and(this.iterateAuthors(filter.authors));
+        if (filter.kinds)
+            and(this.iterateKinds(filter.kinds));
+        // query for time last if only until is set
+        if (filter.since === undefined && filter.until !== undefined) {
+            time = Array.from(this.iterateTime(filter.since, filter.until));
+            and(time);
+        }
+        // if the filter queried on time and has a limit. truncate the events now
+        if (filter.limit && time) {
+            const limited = new Set();
+            for (const event of time) {
+                if (limited.size >= filter.limit)
+                    break;
+                if (events.has(event))
+                    limited.add(event);
+            }
+            return limited;
+        }
+        return events;
+    }
+    getForFilters(filters) {
+        if (filters.length === 0)
+            throw new Error("No Filters");
+        let events = new Set();
+        for (const filter of filters) {
+            const filtered = this.getEventsForFilter(filter);
+            for (const event of filtered)
+                events.add(event);
+        }
+        return events;
+    }
+    /** Remove the oldest events that are not claimed */
+    prune(limit = 1000) {
+        let removed = 0;
+        let cursor = this.events.first;
+        while (cursor) {
+            const event = cursor.value;
+            if (!this.isClaimed(event)) {
+                this.deleteEvent(event);
+                removed++;
+                if (removed >= limit)
+                    break;
+            }
+            cursor = cursor.next;
+        }
+        return removed;
+    }
+}

package/dist/event-store/event-store.d.ts

@@ -0,0 +1,26 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+import { Database } from "./database.js";
+export declare class EventStore {
+    database: Database;
+    constructor();
+    /** Adds an event to the database */
+    add(event: NostrEvent, fromRelay?: string): import("nostr-tools").Event;
+    /** Add an event to the store and notifies all subscribes it has updated */
+    update(event: NostrEvent): import("nostr-tools").Event;
+    getAll(filters: Filter[]): Set<import("nostr-tools").Event>;
+    hasEvent(uid: string): import("nostr-tools").Event | undefined;
+    getEvent(uid: string): import("nostr-tools").Event | undefined;
+    hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
+    getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
+    /** Creates an observable that updates a single event */
+    event(uid: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates an observable that subscribes to multiple events */
+    events(uids: string[]): Observable<Map<string, import("nostr-tools").Event>>;
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates an observable that streams all events that match the filter */
+    stream(filters: Filter[]): Observable<import("nostr-tools").Event>;
+    /** Creates an observable that updates with an array of sorted events */
+    timeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
+}

package/dist/event-store/event-store.js

@@ -0,0 +1,236 @@
+import { insertEventIntoDescendingList } from "nostr-tools/utils";
+import { Observable } from "rxjs";
+import { Database } from "./database.js";
+import { getEventUID, getReplaceableUID } from "../helpers/event.js";
+import { matchFilters } from "../helpers/filter.js";
+import { addSeenRelay } from "../helpers/relays.js";
+export class EventStore {
+    database;
+    constructor() {
+        this.database = new Database();
+    }
+    /** Adds an event to the database */
+    add(event, fromRelay) {
+        const inserted = this.database.addEvent(event);
+        if (fromRelay)
+            addSeenRelay(inserted, fromRelay);
+        return inserted;
+    }
+    /** Add an event to the store and notifies all subscribes it has updated */
+    update(event) {
+        return this.database.updateEvent(event);
+    }
+    getAll(filters) {
+        return this.database.getForFilters(filters);
+    }
+    hasEvent(uid) {
+        return this.database.hasEvent(uid);
+    }
+    getEvent(uid) {
+        return this.database.getEvent(uid);
+    }
+    hasReplaceable(kind, pubkey, d) {
+        return this.database.hasReplaceable(kind, pubkey, d);
+    }
+    getReplaceable(kind, pubkey, d) {
+        return this.database.getReplaceable(kind, pubkey, d);
+    }
+    /** Creates an observable that updates a single event */
+    event(uid) {
+        return new Observable((observer) => {
+            let current = this.database.getEvent(uid);
+            if (current) {
+                observer.next(current);
+                this.database.claimEvent(current, observer);
+            }
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                if (getEventUID(event) === uid && (!current || event.created_at > current.created_at)) {
+                    // remove old claim
+                    if (current)
+                        this.database.removeClaim(current, observer);
+                    current = event;
+                    observer.next(event);
+                    // claim new event
+                    this.database.claimEvent(current, observer);
+                }
+            });
+            // subscribe to updates
+            const updated = this.database.updated.subscribe((event) => {
+                if (event === current)
+                    observer.next(event);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                if (getEventUID(event) === uid && current) {
+                    this.database.removeClaim(current, observer);
+                    current = undefined;
+                    observer.next(undefined);
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                if (current)
+                    this.database.removeClaim(current, observer);
+            };
+        });
+    }
+    /** Creates an observable that subscribes to multiple events */
+    events(uids) {
+        return new Observable((observer) => {
+            const events = new Map();
+            for (const uid of uids) {
+                const e = this.getEvent(uid);
+                if (e) {
+                    events.set(uid, e);
+                    this.database.claimEvent(e, observer);
+                }
+            }
+            observer.next(events);
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                const uid = getEventUID(event);
+                if (uids.includes(uid)) {
+                    const current = events.get(uid);
+                    // remove old claim
+                    if (!current || event.created_at > current.created_at) {
+                        if (current)
+                            this.database.removeClaim(current, observer);
+                        events.set(uid, event);
+                        observer.next(events);
+                        // claim new event
+                        this.database.claimEvent(event, observer);
+                    }
+                }
+            });
+            // subscribe to updates
+            const updated = this.database.updated.subscribe((event) => {
+                const uid = getEventUID(event);
+                if (uids.includes(uid))
+                    observer.next(events);
+            });
+            // subscribe to deleted events
+            const deleted = this.database.deleted.subscribe((event) => {
+                const uid = getEventUID(event);
+                if (uids.includes(uid)) {
+                    const current = events.get(uid);
+                    if (current) {
+                        this.database.removeClaim(current, observer);
+                        events.delete(uid);
+                        observer.next(events);
+                    }
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                for (const [_uid, event] of events) {
+                    this.database.removeClaim(event, observer);
+                }
+            };
+        });
+    }
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind, pubkey, d) {
+        return this.event(getReplaceableUID(kind, pubkey, d));
+    }
+    /** Creates an observable that streams all events that match the filter */
+    stream(filters) {
+        return new Observable((observer) => {
+            let claimed = new Set();
+            let events = this.database.getForFilters(filters);
+            for (const event of events) {
+                observer.next(event);
+                this.database.claimEvent(event, observer);
+                claimed.add(event);
+            }
+            // subscribe to future events
+            const sub = this.database.inserted.subscribe((event) => {
+                if (matchFilters(filters, event)) {
+                    observer.next(event);
+                    this.database.claimEvent(event, observer);
+                    claimed.add(event);
+                }
+            });
+            return () => {
+                sub.unsubscribe();
+                // remove all claims
+                for (const event of claimed)
+                    this.database.removeClaim(event, observer);
+                claimed.clear();
+            };
+        });
+    }
+    /** Creates an observable that updates with an array of sorted events */
+    timeline(filters) {
+        return new Observable((observer) => {
+            const seen = new Map();
+            const timeline = [];
+            // build initial timeline
+            const events = this.database.getForFilters(filters);
+            for (const event of events) {
+                insertEventIntoDescendingList(timeline, event);
+                this.database.claimEvent(event, observer);
+                seen.set(getEventUID(event), event);
+            }
+            observer.next([...timeline]);
+            // subscribe to future events
+            const inserted = this.database.inserted.subscribe((event) => {
+                if (matchFilters(filters, event)) {
+                    const uid = getEventUID(event);
+                    let current = seen.get(uid);
+                    if (current) {
+                        if (event.created_at > current.created_at) {
+                            // replace event
+                            timeline.splice(timeline.indexOf(current), 1, event);
+                            observer.next([...timeline]);
+                            // update the claim
+                            seen.set(uid, event);
+                            this.database.removeClaim(current, observer);
+                            this.database.claimEvent(event, observer);
+                        }
+                    }
+                    else {
+                        insertEventIntoDescendingList(timeline, event);
+                        observer.next([...timeline]);
+                        // claim new event
+                        this.database.claimEvent(event, observer);
+                        seen.set(getEventUID(event), event);
+                    }
+                }
+            });
+            // subscribe to updates
+            const updated = this.database.updated.subscribe((event) => {
+                if (seen.has(getEventUID(event))) {
+                    observer.next([...timeline]);
+                }
+            });
+            // subscribe to removed events
+            const deleted = this.database.deleted.subscribe((event) => {
+                const uid = getEventUID(event);
+                let current = seen.get(uid);
+                if (current) {
+                    // remove the event
+                    timeline.splice(timeline.indexOf(current), 1);
+                    observer.next([...timeline]);
+                    // remove the claim
+                    seen.delete(uid);
+                    this.database.removeClaim(current, observer);
+                }
+            });
+            return () => {
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                updated.unsubscribe();
+                // remove all claims
+                for (const [_, event] of seen) {
+                    this.database.removeClaim(event, observer);
+                }
+                seen.clear();
+            };
+        });
+    }
+}

package/dist/event-store/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./event-store.js";
+export * from "./database.js";