@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/@instantdb/core/dist/esm/Connection.d.ts

@@ -0,0 +1,92 @@
+export interface EventSourceType {
+    readonly url: string;
+    readonly readyState: number;
+    onopen: ((this: EventSourceType, ev: Event) => any) | null;
+    onmessage: ((this: EventSourceType, ev: MessageEvent) => any) | null;
+    onerror: ((this: EventSourceType, ev: Event) => any) | null;
+    close(): void;
+}
+export interface EventSourceConstructor {
+    OPEN: number;
+    CONNECTING: number;
+    CLOSED: number;
+    new (url: string): EventSourceType;
+}
+type Conn = EventSourceType | WebSocket;
+type OpenEvent<T extends Conn> = {
+    target: Connection<T>;
+};
+type MessageData = {
+    op: string;
+    [key: string]: any;
+};
+type SendMessageData = {
+    'client-event-id': string;
+    [key: string]: any;
+};
+type MsgEvent<T extends Conn> = {
+    target: Connection<T>;
+    message: MessageData | MessageData[];
+};
+type CloseEvent<T extends Conn> = {
+    target: Connection<T>;
+};
+interface ErrorEvent<T extends Conn> {
+    target: Connection<T>;
+}
+export type TransportType = 'ws' | 'sse';
+export interface Connection<T extends Conn> {
+    conn: T;
+    type: 'ws' | 'sse';
+    id: string;
+    close(): void;
+    isOpen(): boolean;
+    isConnecting(): boolean;
+    send(msg: SendMessageData): void;
+    onopen: ((event: OpenEvent<T>) => void) | null;
+    onmessage: ((event: MsgEvent<T>) => void) | null;
+    onclose: ((event: CloseEvent<T>) => void) | null;
+    onerror: ((event: ErrorEvent<T>) => void) | null;
+}
+export declare class WSConnection implements Connection<WebSocket> {
+    type: TransportType;
+    conn: WebSocket;
+    id: string;
+    onopen: (event: OpenEvent<WebSocket>) => void;
+    onmessage: (event: MsgEvent<WebSocket>) => void;
+    onclose: (event: CloseEvent<WebSocket>) => void;
+    onerror: (event: ErrorEvent<WebSocket>) => void;
+    constructor(url: string);
+    close(): void;
+    isOpen(): boolean;
+    isConnecting(): boolean;
+    send(msg: SendMessageData): void;
+}
+export declare class SSEConnection implements Connection<EventSourceType> {
+    type: TransportType;
+    private initParams;
+    private sendQueue;
+    private sendPromise;
+    private closeFired;
+    private sseInitTimeout;
+    private ES;
+    private messageUrl;
+    conn: EventSourceType;
+    url: string;
+    id: string;
+    onopen: (event: OpenEvent<EventSourceType>) => void;
+    onmessage: (event: MsgEvent<EventSourceType>) => void;
+    onclose: (event: CloseEvent<EventSourceType>) => void;
+    onerror: (event: ErrorEvent<EventSourceType>) => void;
+    constructor(ES: EventSourceConstructor, url: string, messageUrl?: string);
+    private handleMessage;
+    private handleError;
+    private handleClose;
+    private postMessages;
+    private flushQueue;
+    send(msg: SendMessageData): void;
+    isOpen(): boolean;
+    isConnecting(): boolean;
+    close(): void;
+}
+export {};

package/node_modules/@instantdb/core/dist/esm/Connection.js

@@ -0,0 +1,188 @@
+let _connId = 0;
+export class WSConnection {
+    type = 'ws';
+    conn;
+    id;
+    onopen;
+    onmessage;
+    onclose;
+    onerror;
+    constructor(url) {
+        this.id = `${this.type}_${_connId++}`;
+        this.conn = new WebSocket(url);
+        this.conn.onopen = (_e) => {
+            if (this.onopen) {
+                this.onopen({ target: this });
+            }
+        };
+        this.conn.onmessage = (e) => {
+            if (this.onmessage) {
+                this.onmessage({
+                    target: this,
+                    message: JSON.parse(e.data.toString()),
+                });
+            }
+        };
+        this.conn.onclose = (_e) => {
+            if (this.onclose) {
+                this.onclose({ target: this });
+            }
+        };
+        this.conn.onerror = (_e) => {
+            if (this.onerror) {
+                this.onerror({ target: this });
+            }
+        };
+    }
+    close() {
+        this.conn.close();
+    }
+    isOpen() {
+        return this.conn.readyState === (WebSocket.OPEN ?? 1);
+    }
+    isConnecting() {
+        return this.conn.readyState === (WebSocket.CONNECTING ?? 0);
+    }
+    send(msg) {
+        return this.conn.send(JSON.stringify(msg));
+    }
+}
+export class SSEConnection {
+    type = 'sse';
+    initParams = null;
+    sendQueue = [];
+    sendPromise;
+    closeFired = false;
+    sseInitTimeout = undefined;
+    ES;
+    messageUrl;
+    conn;
+    url;
+    id;
+    onopen;
+    onmessage;
+    onclose;
+    onerror;
+    constructor(ES, url, messageUrl) {
+        this.id = `${this.type}_${_connId++}`;
+        this.url = url;
+        this.messageUrl = messageUrl || this.url;
+        this.ES = ES;
+        this.conn = new ES(url);
+        // Close the connection if we didn't get an init within 10 seconds
+        this.sseInitTimeout = setTimeout(() => {
+            if (!this.initParams) {
+                this.handleError();
+            }
+        }, 10000);
+        this.conn.onmessage = (e) => {
+            const message = JSON.parse(e.data);
+            if (Array.isArray(message)) {
+                for (const msg of message) {
+                    this.handleMessage(msg);
+                }
+            }
+            else {
+                this.handleMessage(message);
+            }
+        };
+        this.conn.onerror = (e) => {
+            this.handleError();
+        };
+    }
+    handleMessage(msg) {
+        if (msg.op === 'sse-init') {
+            this.initParams = {
+                machineId: msg['machine-id'],
+                sessionId: msg['session-id'],
+                sseToken: msg['sse-token'],
+            };
+            if (this.onopen) {
+                this.onopen({ target: this });
+            }
+            clearTimeout(this.sseInitTimeout);
+            return;
+        }
+        if (this.onmessage) {
+            this.onmessage({
+                target: this,
+                message: msg,
+            });
+        }
+    }
+    // Runs the onerror and closes the connection
+    handleError() {
+        try {
+            if (this.onerror) {
+                this.onerror({ target: this });
+            }
+        }
+        finally {
+            this.handleClose();
+        }
+    }
+    handleClose() {
+        this.conn.close();
+        if (this.onclose && !this.closeFired) {
+            this.closeFired = true;
+            this.onclose({ target: this });
+        }
+    }
+    async postMessages(messages) {
+        // TODO(dww): Create a connection with chunked encoding so we can
+        //            send multiple messages over one request
+        try {
+            const resp = await fetch(this.messageUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    machine_id: this.initParams?.machineId,
+                    session_id: this.initParams?.sessionId,
+                    sse_token: this.initParams?.sseToken,
+                    messages,
+                }),
+            });
+            if (!resp.ok) {
+                this.handleError();
+            }
+        }
+        catch (e) {
+            this.handleError();
+        }
+    }
+    async flushQueue() {
+        if (this.sendPromise || !this.sendQueue.length)
+            return;
+        const messages = this.sendQueue;
+        this.sendQueue = [];
+        const sendPromise = this.postMessages(messages);
+        this.sendPromise = sendPromise;
+        sendPromise.then(() => {
+            this.sendPromise = null;
+            this.flushQueue();
+        });
+    }
+    send(msg) {
+        if (!this.isOpen() || !this.initParams) {
+            if (this.isConnecting()) {
+                throw new Error(`Failed to execute 'send' on 'EventSource': Still in CONNECTING state.`);
+            }
+            if (this.conn.readyState === this.ES.CLOSED) {
+                throw new Error(`EventSource is already in CLOSING or CLOSED state.`);
+            }
+            throw new Error(`EventSource is in invalid state.`);
+        }
+        this.sendQueue.push(msg);
+        this.flushQueue();
+    }
+    isOpen() {
+        return this.conn.readyState === this.ES.OPEN && this.initParams !== null;
+    }
+    isConnecting() {
+        return (this.conn.readyState === this.ES.CONNECTING ||
+            (this.conn.readyState === this.ES.OPEN && this.initParams === null));
+    }
+    close() {
+        this.handleClose();
+    }
+}

package/node_modules/@instantdb/core/dist/esm/InMemoryStorage.d.ts

@@ -0,0 +1,10 @@
+import { StoreInterface, StoreInterfaceStoreName } from './utils/PersistedObject.js';
+export default class InMemoryStore extends StoreInterface {
+    private store;
+    constructor(appId: string, dbName: StoreInterfaceStoreName);
+    getItem(k: any): Promise<any>;
+    setItem(k: any, v: any): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    multiSet(keyValuePairs: Array<[string, any]>): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}

package/node_modules/@instantdb/core/dist/esm/InMemoryStorage.js

@@ -0,0 +1,25 @@
+import { StoreInterface, } from './utils/PersistedObject.js';
+export default class InMemoryStore extends StoreInterface {
+    store;
+    constructor(appId, dbName) {
+        super(appId, dbName);
+        this.store = new Map();
+    }
+    async getItem(k) {
+        return this.store.get(k) ?? null;
+    }
+    async setItem(k, v) {
+        this.store.set(k, v);
+    }
+    async getAllKeys() {
+        return [...this.store.keys()];
+    }
+    async multiSet(keyValuePairs) {
+        for (const [k, v] of keyValuePairs) {
+            this.setItem(k, v);
+        }
+    }
+    async removeItem(key) {
+        this.store.delete(key);
+    }
+}

package/node_modules/@instantdb/core/dist/esm/IndexedDBStorage.d.ts

@@ -0,0 +1,17 @@
+import { StoreInterface, StoreInterfaceStoreName } from './utils/PersistedObject.ts';
+export default class IndexedDBStorage extends StoreInterface {
+    dbName: string;
+    _storeName: StoreInterfaceStoreName;
+    _appId: string;
+    _prefix: string;
+    _dbPromise: Promise<IDBDatabase>;
+    constructor(appId: string, storeName: StoreInterfaceStoreName);
+    _init(): Promise<IDBDatabase>;
+    _upgradeStore(event: IDBVersionChangeEvent): void;
+    _withRetry<T>(fn: (db: IDBDatabase) => Promise<T>): Promise<T>;
+    getItem(k: string): Promise<any>;
+    setItem(k: string, v: any): Promise<void>;
+    multiSet(keyValuePairs: Array<[string, any]>): Promise<void>;
+    removeItem(k: string): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+}

package/node_modules/@instantdb/core/dist/esm/IndexedDBStorage.js

@@ -0,0 +1,309 @@
+import { META_KEY, StoreInterface, } from './utils/PersistedObject.js';
+// Any time these are updates to the data format or new stores are added,
+// the version must be updated.
+// onupgradeneeded will be called, which is where you can
+// move objects from one idb to another.
+// We create a new IDB for each version change instead of
+// using their built-in versioning because they have no ability
+// to roll back and if multiple tabs are active, then you'll just
+// be stuck.
+const version = 6;
+const storeNames = ['kv', 'querySubs', 'syncSubs'];
+const _exhaustiveCheck = null;
+function logErrorCb(source) {
+    return function logError(event) {
+        console.error('Error in IndexedDB event', { source, event });
+    };
+}
+async function existingDb(name) {
+    return new Promise((resolve) => {
+        const request = indexedDB.open(name);
+        request.onerror = (_event) => {
+            resolve(null);
+        };
+        request.onsuccess = (event) => {
+            const target = event.target;
+            const db = target.result;
+            resolve(db);
+        };
+        request.onupgradeneeded = (event) => {
+            const target = event.target;
+            target.transaction?.abort();
+            resolve(null);
+        };
+    });
+}
+async function upgradeQuerySubs5To6(hash, value, querySubStore) {
+    const subs = 
+    // Backwards compatibility for older versions where we JSON.stringified before storing
+    typeof value === 'string' ? JSON.parse(value) : value;
+    if (!subs) {
+        return;
+    }
+    const putReqs = new Set();
+    return new Promise((resolve, reject) => {
+        const objects = {};
+        for (const [hash, v] of Object.entries(subs)) {
+            const value = typeof v === 'string' ? JSON.parse(v) : v;
+            if (value.lastAccessed) {
+                const objectMeta = {
+                    createdAt: value.lastAccessed,
+                    updatedAt: value.lastAccessed,
+                    size: value.result?.store?.triples?.length ?? 0,
+                };
+                objects[hash] = objectMeta;
+            }
+            const putReq = querySubStore.put(value, hash);
+            putReqs.add(putReq);
+        }
+        const meta = { objects };
+        const metaPutReq = querySubStore.put(meta, META_KEY);
+        putReqs.add(metaPutReq);
+        for (const r of putReqs) {
+            r.onsuccess = () => {
+                putReqs.delete(r);
+                if (putReqs.size === 0) {
+                    resolve();
+                }
+            };
+            r.onerror = (event) => {
+                logErrorCb(`Move ${hash} to querySubs store failed`);
+                reject(event);
+            };
+        }
+    });
+}
+async function moveKvEntry5To6(k, value, kvStore) {
+    const request = kvStore.put(value, k);
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve();
+        request.onerror = (event) => reject(event);
+    });
+}
+async function upgrade5To6(appId, v6Db) {
+    const v5db = await existingDb(`instant_${appId}_5`);
+    if (!v5db) {
+        return;
+    }
+    const data = await new Promise((resolve, reject) => {
+        const v5Tx = v5db.transaction(['kv'], 'readonly');
+        const objectStore = v5Tx.objectStore('kv');
+        const cursorReq = objectStore.openCursor();
+        cursorReq.onerror = (event) => {
+            reject(event);
+        };
+        const data = [];
+        cursorReq.onsuccess = () => {
+            const cursor = cursorReq.result;
+            if (cursor) {
+                const key = cursor.key;
+                const value = cursor.value;
+                data.push([key, value]);
+                cursor.continue();
+            }
+            else {
+                resolve(data);
+            }
+        };
+        cursorReq.onerror = (event) => {
+            reject(event);
+        };
+    });
+    const v6Tx = v6Db.transaction(['kv', 'querySubs'], 'readwrite');
+    const kvStore = v6Tx.objectStore('kv');
+    const querySubStore = v6Tx.objectStore('querySubs');
+    const promises = [];
+    const kvMeta = { objects: {} };
+    for (const [key, value] of data) {
+        switch (key) {
+            case 'querySubs': {
+                const p = upgradeQuerySubs5To6(key, value, querySubStore);
+                promises.push(p);
+                break;
+            }
+            default: {
+                const p = moveKvEntry5To6(key, value, kvStore);
+                promises.push(p);
+                const objectMeta = {
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                    size: 0,
+                };
+                kvMeta.objects[key] = objectMeta;
+                break;
+            }
+        }
+    }
+    const p = moveKvEntry5To6(META_KEY, kvMeta, kvStore);
+    promises.push(p);
+    await Promise.all(promises);
+    await new Promise((resolve, reject) => {
+        v6Tx.oncomplete = (e) => resolve(e);
+        v6Tx.onerror = (e) => reject(e);
+        v6Tx.onabort = (e) => reject(e);
+    });
+}
+// We create many IndexedDBStorage instances that talk to the same
+// underlying db, but we only get one `onupgradeneeded` event. This holds
+// the upgrade promises so that we wait until upgrade finishes before
+// we start writing.
+const upgradePromises = new Map();
+export default class IndexedDBStorage extends StoreInterface {
+    dbName;
+    _storeName;
+    _appId;
+    _prefix;
+    _dbPromise;
+    constructor(appId, storeName) {
+        super(appId, storeName);
+        this.dbName = `instant_${appId}_${version}`;
+        this._storeName = storeName;
+        this._appId = appId;
+        this._dbPromise = this._init();
+    }
+    _init() {
+        return new Promise((resolve, reject) => {
+            let requiresUpgrade = false;
+            const request = indexedDB.open(this.dbName, 1);
+            request.onerror = (event) => {
+                reject(event);
+            };
+            request.onsuccess = (event) => {
+                const target = event.target;
+                const db = target.result;
+                // Browsers can close IndexedDB connections unexpectedly
+                // (e.g. backgrounded tabs, memory pressure, version changes from
+                // other tabs). Re-init so the next operation gets a fresh connection.
+                db.onclose = () => {
+                    this._dbPromise = this._init();
+                };
+                db.onversionchange = () => {
+                    db.close();
+                };
+                if (!requiresUpgrade) {
+                    const p = upgradePromises.get(this.dbName);
+                    if (!p) {
+                        resolve(db);
+                    }
+                    else {
+                        p.then(() => resolve(db)).catch(() => resolve(db));
+                    }
+                }
+                else {
+                    const p = upgrade5To6(this._appId, db).catch((e) => {
+                        logErrorCb('Error upgrading store from version 5 to 6.')(e);
+                    });
+                    upgradePromises.set(this.dbName, p);
+                    p.then(() => resolve(db)).catch(() => resolve(db));
+                }
+            };
+            request.onupgradeneeded = (event) => {
+                requiresUpgrade = true;
+                this._upgradeStore(event);
+            };
+        });
+    }
+    _upgradeStore(event) {
+        const target = event.target;
+        const db = target.result;
+        for (const storeName of storeNames) {
+            if (!db.objectStoreNames.contains(storeName)) {
+                db.createObjectStore(storeName);
+            }
+        }
+    }
+    // Browsers can close IndexedDB connections unexpectedly (backgrounded tabs,
+    // memory pressure, cross-tab version changes, etc.), causing
+    // `db.transaction()` to throw InvalidStateError. This helper catches that
+    // error and retries once with a fresh connection.
+    async _withRetry(fn) {
+        try {
+            const db = await this._dbPromise;
+            return await fn(db);
+        }
+        catch (e) {
+            if (e instanceof DOMException && e.name === 'InvalidStateError') {
+                this._dbPromise = this._init();
+                const db = await this._dbPromise;
+                return await fn(db);
+            }
+            throw e;
+        }
+    }
+    async getItem(k) {
+        return this._withRetry((db) => {
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([this._storeName], 'readonly');
+                const objectStore = transaction.objectStore(this._storeName);
+                const request = objectStore.get(k);
+                request.onerror = () => {
+                    reject(request.error);
+                };
+                request.onsuccess = () => {
+                    if (request.result) {
+                        resolve(request.result);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                };
+            });
+        });
+    }
+    async setItem(k, v) {
+        return this._withRetry((db) => {
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([this._storeName], 'readwrite');
+                const objectStore = transaction.objectStore(this._storeName);
+                objectStore.put(v, k);
+                transaction.oncomplete = () => resolve();
+                transaction.onerror = () => reject(transaction.error);
+                transaction.onabort = () => reject(transaction.error);
+                transaction.commit?.();
+            });
+        });
+    }
+    async multiSet(keyValuePairs) {
+        return this._withRetry((db) => {
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([this._storeName], 'readwrite');
+                const objectStore = transaction.objectStore(this._storeName);
+                for (const [k, v] of keyValuePairs) {
+                    objectStore.put(v, k);
+                }
+                transaction.oncomplete = () => resolve();
+                transaction.onerror = () => reject(transaction.error);
+                transaction.onabort = () => reject(transaction.error);
+                transaction.commit?.();
+            });
+        });
+    }
+    async removeItem(k) {
+        return this._withRetry((db) => {
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([this._storeName], 'readwrite');
+                const objectStore = transaction.objectStore(this._storeName);
+                objectStore.delete(k);
+                transaction.oncomplete = () => resolve();
+                transaction.onerror = () => reject(transaction.error);
+                transaction.onabort = () => reject(transaction.error);
+                transaction.commit?.();
+            });
+        });
+    }
+    async getAllKeys() {
+        return this._withRetry((db) => {
+            return new Promise((resolve, reject) => {
+                const transaction = db.transaction([this._storeName], 'readonly');
+                const objectStore = transaction.objectStore(this._storeName);
+                const request = objectStore.getAllKeys();
+                request.onerror = () => {
+                    reject(request.error);
+                };
+                request.onsuccess = () => {
+                    resolve(request.result.filter((x) => typeof x === 'string'));
+                };
+            });
+        });
+    }
+}

package/node_modules/@instantdb/core/dist/esm/InstantError.d.ts

@@ -0,0 +1,6 @@
+export declare class InstantError extends Error {
+    hint?: unknown;
+    traceId?: string;
+    constructor(message: string, hint?: unknown, traceId?: string);
+    get [Symbol.toStringTag](): string;
+}

package/node_modules/@instantdb/core/dist/esm/InstantError.js

@@ -0,0 +1,23 @@
+export class InstantError extends Error {
+    hint;
+    traceId;
+    constructor(message, hint, traceId) {
+        super(message);
+        this.hint = hint;
+        if (traceId) {
+            this.traceId = traceId;
+        }
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(this, actualProto);
+        }
+        // Maintain proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, InstantError);
+        }
+        this.name = 'InstantError';
+    }
+    get [Symbol.toStringTag]() {
+        return 'InstantError';
+    }
+}