@instantdb/core 0.22.56 → 0.22.57

package/dist/esm/SyncTable.d.ts

@@ -0,0 +1,140 @@
+import { Logger } from './Reactor.js';
+import { InstaQLResponse, ValidQuery } from './queryTypes.ts';
+import { EntitiesDef, IContainEntitiesAndLinks } from './schemaTypes.ts';
+type StartMsg = {
+    op: 'start-sync';
+    q: string;
+};
+type EndMsg = {
+    op: 'remove-sync';
+    'subscription-id': string;
+};
+type ResyncMsg = {
+    op: 'resync-table';
+    'subscription-id': string;
+    'tx-id': number;
+    token: string;
+};
+type SendMsg = StartMsg | EndMsg | ResyncMsg;
+type StartSyncOkMsg = {
+    'subscription-id': string;
+    'client-event-id': string;
+    q: string;
+    token: string;
+};
+type Triple = [string, string, any, number];
+type SyncLoadBatchMsg = {
+    'subscription-id': string;
+    'join-rows': Array<Triple[]>;
+};
+type SyncInitFinishMsg = {
+    'subscription-id': string;
+    'tx-id': number;
+};
+type SyncUpdateTriplesMsg = {
+    'subscription-id': string;
+    txes: {
+        'tx-id': number;
+        changes: {
+            action: 'added' | 'removed';
+            triple: Triple;
+        }[];
+    }[];
+};
+type TrySend = (eventId: string, msg: SendMsg) => void;
+type Config = {
+    useDateObjects: boolean;
+};
+export declare enum CallbackEventType {
+    InitialSyncBatch = "InitialSyncBatch",
+    InitialSyncComplete = "InitialSyncComplete",
+    LoadFromStorage = "LoadFromStorage",
+    SyncTransaction = "SyncTransaction",
+    Error = "Error"
+}
+type QueryEntities<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> = InstaQLResponse<Schema, Q, UseDates>[keyof InstaQLResponse<Schema, Q, UseDates>];
+type QueryEntity<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> = QueryEntities<Schema, Q, UseDates> extends (infer E)[] ? E : never;
+type ChangedFields<Entity> = {
+    [K in keyof Entity]?: {
+        oldValue: Entity[K];
+        newValue: Entity[K];
+    };
+};
+export interface BaseCallbackEvent<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> {
+    type: CallbackEventType;
+    data: InstaQLResponse<Schema, Q, UseDates>;
+}
+export interface InitialSyncBatch<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> extends BaseCallbackEvent<Schema, Q, UseDates> {
+    type: CallbackEventType.InitialSyncBatch;
+    batch: QueryEntities<Schema, Q, UseDates>;
+}
+export interface InitialSyncComplete<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> extends BaseCallbackEvent<Schema, Q, UseDates> {
+    type: CallbackEventType.InitialSyncComplete;
+}
+export interface SyncTransaction<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> extends BaseCallbackEvent<Schema, Q, UseDates> {
+    type: CallbackEventType.SyncTransaction;
+    added: QueryEntities<Schema, Q, UseDates>;
+    removed: QueryEntities<Schema, Q, UseDates>;
+    updated: {
+        oldEntity: QueryEntity<Schema, Q, UseDates>;
+        newEntity: QueryEntity<Schema, Q, UseDates>;
+        changedFields: ChangedFields<QueryEntity<Schema, Q, UseDates>>;
+    }[];
+}
+export interface LoadFromStorage<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> extends BaseCallbackEvent<Schema, Q, UseDates> {
+    type: CallbackEventType.LoadFromStorage;
+}
+export interface SetupError<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> extends BaseCallbackEvent<Schema, Q, UseDates> {
+    type: CallbackEventType.Error;
+    error: {
+        message: string;
+        hint?: any;
+        type: string;
+        status: number;
+    };
+}
+export type CallbackEvent<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> = InitialSyncBatch<Schema, Q, UseDates> | InitialSyncComplete<Schema, Q, UseDates> | SyncTransaction<Schema, Q, UseDates> | LoadFromStorage<Schema, Q, UseDates> | SetupError<Schema, Q, UseDates>;
+export type SyncTableCallback<Schema extends IContainEntitiesAndLinks<EntitiesDef, any>, Q extends ValidQuery<Q, Schema>, UseDates extends boolean> = (event: CallbackEvent<Schema, Q, UseDates>) => void;
+export declare class SyncTable {
+    private trySend;
+    private subs;
+    private callbacks;
+    private config;
+    private idToHash;
+    private log;
+    private createStore;
+    constructor(trySend: TrySend, persister: Storage, config: Config, log: Logger, createStore: (triples: Triple[]) => any);
+    beforeUnload(): void;
+    subscribe(q: any, cb: SyncTableCallback<any, any, any>): (opts?: {
+        keepSubscription?: boolean | null | undefined;
+    } | null | undefined) => void;
+    private unsubscribe;
+    private sendStart;
+    private sendResync;
+    private sendRemove;
+    private initSubscription;
+    flushPending(): Promise<void>;
+    onStartSyncOk(msg: StartSyncOkMsg): void;
+    private notifyCbs;
+    onSyncLoadBatch(msg: SyncLoadBatchMsg): void;
+    onSyncInitFinish(msg: SyncInitFinishMsg): void;
+    onSyncUpdateTriples(msg: SyncUpdateTriplesMsg): void;
+    private clearSubscriptionData;
+    onStartSyncError(msg: {
+        op: 'error';
+        'original-event': StartMsg;
+        'client-event-id': string;
+        status: number;
+        type: string;
+        message?: string;
+        hint?: any;
+    }): void;
+    onResyncError(msg: {
+        op: 'error';
+        'original-event': ResyncMsg;
+        status: number;
+        type: string;
+    }): void;
+}
+export {};
+//# sourceMappingURL=SyncTable.d.ts.map

package/dist/esm/SyncTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncTable.d.ts","sourceRoot":"","sources":["../../src/SyncTable.ts"],"names":[],"mappings":"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"}

package/dist/esm/SyncTable.js

@@ -0,0 +1,498 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PersistedObject } from "./utils/PersistedObject.js";
+import * as s from './store.js';
+import weakHash from "./utils/weakHash.js";
+import uuid from "./utils/uuid.js";
+import instaql, { compareOrder } from './instaql.js';
+// Modifies the data in place because it comes directly from storage
+function syncSubsFromStorage(parsed, useDateObjects) {
+    for (const key in parsed) {
+        const sub = parsed[key];
+        for (const e of sub.entities || []) {
+            e.store.useDateObjects = useDateObjects;
+            e.store = s.fromJSON(e.store);
+        }
+    }
+    return parsed;
+}
+function syncSubsToStorage(subs) {
+    const jsonSubs = {};
+    for (const key in subs) {
+        const sub = subs[key];
+        if (sub.entities) {
+            const entities = [];
+            for (const e of sub.entities) {
+                entities.push(Object.assign(Object.assign({}, e), { store: s.toJSON(e.store) }));
+            }
+            jsonSubs[key] = Object.assign(Object.assign({}, sub), { entities });
+        }
+        else {
+            jsonSubs[key] = sub;
+        }
+    }
+    return jsonSubs;
+}
+function onMergeSubs(storageSubs, inMemorySubs) {
+    const subs = {};
+    for (const [k, v] of Object.entries(inMemorySubs)) {
+        subs[k] = v;
+    }
+    if (storageSubs) {
+        for (const [k, v] of Object.entries(storageSubs)) {
+            subs[k] = v;
+        }
+    }
+    return subs;
+}
+function queryEntity(sub, store) {
+    const res = instaql({ store, pageInfo: null, aggregate: null }, sub.query);
+    return res.data[sub.table][0];
+}
+function getServerCreatedAt(sub, store, entityId) {
+    var _a;
+    const aid = (_a = s.getAttrByFwdIdentName(store, sub.table, 'id')) === null || _a === void 0 ? void 0 : _a.id;
+    if (!aid) {
+        return -1;
+    }
+    const t = s.getInMap(store.eav, [entityId, aid, entityId]);
+    if (!t) {
+        return -1;
+    }
+    return t[3];
+}
+function applyChangesToStore(store, changes) {
+    for (const { action, triple } of changes) {
+        switch (action) {
+            case 'added':
+                s.addTriple(store, triple);
+                break;
+            case 'removed':
+                s.retractTriple(store, triple);
+                break;
+        }
+    }
+}
+function changedFieldsOfChanges(store, changes) {
+    var _a, _b, _c, _d;
+    // This will be more complicated when we include links, we can either add a
+    // changedLinks field or we can have something like 'bookshelves.title`
+    const changedFields = {};
+    for (const { action, triple } of changes) {
+        const [e, a, v] = triple;
+        const field = (_b = (_a = store.attrs[a]) === null || _a === void 0 ? void 0 : _a['forward-identity']) === null || _b === void 0 ? void 0 : _b[2];
+        if (!field)
+            continue;
+        const fields = (_c = changedFields[e]) !== null && _c !== void 0 ? _c : {};
+        changedFields[e] = fields;
+        const oldNew = (_d = fields[field]) !== null && _d !== void 0 ? _d : {};
+        fields[field] = oldNew;
+        switch (action) {
+            case 'added':
+                oldNew.newValue = v;
+                break;
+            case 'removed':
+                // Only take the first thing that was removed, in case we modified things in the middle
+                if (oldNew.oldValue === undefined) {
+                    oldNew.oldValue = v;
+                }
+                break;
+        }
+    }
+    return changedFields;
+}
+function subData(sub, entities) {
+    return { [sub.table]: entities.map((e) => e.entity) };
+}
+function sortEntitiesInPlace(sub, entities) {
+    const dataType = sub.orderFieldType;
+    if (sub.orderField === 'serverCreatedAt') {
+        entities.sort(sub.orderDirection === 'asc'
+            ? function compareEntities(a, b) {
+                return compareOrder(a.entity.id, a.serverCreatedAt, b.entity.id, b.serverCreatedAt, dataType);
+            }
+            : function compareEntities(b, a) {
+                return compareOrder(a.entity.id, a.serverCreatedAt, b.entity.id, b.serverCreatedAt, dataType);
+            });
+        return;
+    }
+    const field = sub.orderField;
+    entities.sort(sub.orderDirection === 'asc'
+        ? function compareEntities(a, b) {
+            return compareOrder(a.entity.id, a.entity[field], b.entity.id, b.entity[field], dataType);
+        }
+        : function compareEntities(b, a) {
+            return compareOrder(a.entity.id, a.entity[field], b.entity.id, b.entity[field], dataType);
+        });
+}
+export var CallbackEventType;
+(function (CallbackEventType) {
+    CallbackEventType["InitialSyncBatch"] = "InitialSyncBatch";
+    CallbackEventType["InitialSyncComplete"] = "InitialSyncComplete";
+    CallbackEventType["LoadFromStorage"] = "LoadFromStorage";
+    CallbackEventType["SyncTransaction"] = "SyncTransaction";
+    CallbackEventType["Error"] = "Error";
+})(CallbackEventType || (CallbackEventType = {}));
+export class SyncTable {
+    constructor(trySend, persister, config, log, createStore) {
+        // Using any for the SyncCallback because we'd need Reactor to be typed
+        this.callbacks = {};
+        this.idToHash = {};
+        this.trySend = trySend;
+        this.config = config;
+        this.log = log;
+        this.createStore = createStore;
+        this.subs = new PersistedObject(persister, 'subs', {}, onMergeSubs, syncSubsToStorage, (x) => syncSubsFromStorage(x, this.config.useDateObjects));
+    }
+    beforeUnload() {
+        this.subs.flush();
+    }
+    subscribe(q, cb) {
+        const hash = weakHash(q);
+        this.callbacks[hash] = this.callbacks[hash] || [];
+        this.callbacks[hash].push(cb);
+        this.initSubscription(q, hash, cb);
+        return (opts) => {
+            this.unsubscribe(hash, cb, opts === null || opts === void 0 ? void 0 : opts.keepSubscription);
+        };
+    }
+    unsubscribe(hash, cb, keepSubscription) {
+        const cbs = (this.callbacks[hash] || []).filter((x) => x !== cb);
+        this.callbacks[hash] = cbs;
+        if (!cbs.length) {
+            delete this.callbacks[hash];
+            if (keepSubscription) {
+                return;
+            }
+            const sub = this.subs.currentValue[hash];
+            if (sub === null || sub === void 0 ? void 0 : sub.state) {
+                this.clearSubscriptionData(sub.state.subscriptionId);
+            }
+            this.subs.set((prev) => {
+                delete prev[hash];
+                return prev;
+            });
+        }
+    }
+    sendStart(query) {
+        this.trySend(uuid(), {
+            op: 'start-sync',
+            q: query,
+        });
+    }
+    sendResync(sub, state) {
+        // Make sure we can find the hash from the subscriptionId
+        this.idToHash[state.subscriptionId] = sub.hash;
+        this.trySend(state.subscriptionId, {
+            op: 'resync-table',
+            'subscription-id': state.subscriptionId,
+            'tx-id': state.txId,
+            token: state.token,
+        });
+    }
+    sendRemove(state) {
+        this.trySend(uuid(), {
+            op: 'remove-sync',
+            'subscription-id': state.subscriptionId,
+        });
+    }
+    initSubscription(query, hash, cb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            // Wait for storage to load so that we know if we already have an existing subscription
+            yield this.subs.waitForLoaded();
+            const existingSub = this.subs.currentValue[hash];
+            if (existingSub && existingSub.state && existingSub.state.txId) {
+                this.sendResync(existingSub, existingSub.state);
+                if (existingSub.entities && cb) {
+                    const k = Object.keys(query)[0];
+                    cb({
+                        type: CallbackEventType.LoadFromStorage,
+                        data: subData(existingSub, existingSub.entities),
+                    });
+                }
+                return;
+            }
+            const table = Object.keys(query)[0];
+            const orderBy = ((_b = (_a = query[table]) === null || _a === void 0 ? void 0 : _a.$) === null || _b === void 0 ? void 0 : _b.order) || { serverCreatedAt: 'asc' };
+            const [orderField, orderDirection] = Object.entries(orderBy)[0];
+            const orderFieldType = orderField === 'serverCreatedAt'
+                ? 'number'
+                : (_c = s.getAttrByFwdIdentName(this.createStore([]), table, orderField)) === null || _c === void 0 ? void 0 : _c['checked-data-type'];
+            this.subs.set((prev) => {
+                prev[hash] = {
+                    query,
+                    hash: hash,
+                    table,
+                    orderDirection,
+                    orderField,
+                    orderFieldType,
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                };
+                return prev;
+            });
+            this.sendStart(query);
+        });
+    }
+    flushPending() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.subs.waitForLoaded();
+            for (const hash of Object.keys(this.callbacks)) {
+                const sub = this.subs.currentValue[hash];
+                if (sub) {
+                    yield this.initSubscription(sub.query, sub.hash);
+                }
+                else {
+                    this.log.error('Missing sub for hash in flushPending', hash);
+                }
+            }
+        });
+    }
+    onStartSyncOk(msg) {
+        const subscriptionId = msg['subscription-id'];
+        const q = msg.q;
+        const hash = weakHash(q);
+        this.idToHash[subscriptionId] = hash;
+        this.subs.set((prev) => {
+            const sub = prev[hash];
+            if (!sub) {
+                this.log.error('Missing sub for hash', hash, 'subscription-id', subscriptionId, 'query', q);
+                return prev;
+            }
+            sub.state = {
+                subscriptionId: subscriptionId,
+                token: msg.token,
+            };
+            return prev;
+        });
+    }
+    notifyCbs(hash, event) {
+        for (const cb of this.callbacks[hash] || []) {
+            cb(event);
+        }
+    }
+    onSyncLoadBatch(msg) {
+        const subscriptionId = msg['subscription-id'];
+        const joinRows = msg['join-rows'];
+        const hash = this.idToHash[subscriptionId];
+        if (!hash) {
+            this.log.error('Missing hash for subscription', msg);
+            return;
+        }
+        const batch = [];
+        const currentValue = this.subs.set((prev) => {
+            var _a;
+            const sub = prev[hash];
+            if (!sub) {
+                this.log.error('Missing sub for hash', hash, msg);
+                return prev;
+            }
+            const entities = (_a = sub.entities) !== null && _a !== void 0 ? _a : [];
+            sub.entities = entities;
+            for (const entRows of joinRows) {
+                const store = this.createStore(entRows);
+                const entity = queryEntity(sub, store);
+                entities.push({
+                    store,
+                    entity,
+                    serverCreatedAt: getServerCreatedAt(sub, store, entity.id),
+                });
+                batch.push(entity);
+            }
+            sub.updatedAt = Date.now();
+            return prev;
+        });
+        const sub = currentValue[hash];
+        if (sub.entities) {
+            this.notifyCbs(hash, {
+                type: CallbackEventType.InitialSyncBatch,
+                data: subData(sub, sub.entities),
+                batch,
+            });
+        }
+    }
+    onSyncInitFinish(msg) {
+        const subscriptionId = msg['subscription-id'];
+        const hash = this.idToHash[subscriptionId];
+        if (!hash) {
+            this.log.error('Missing hash for subscription', msg);
+            return;
+        }
+        this.subs.set((prev) => {
+            const sub = prev[hash];
+            if (!sub) {
+                this.log.error('Missing sub for hash', hash, msg);
+                return prev;
+            }
+            const state = sub.state;
+            if (!state) {
+                this.log.error('Sub never set init, missing result', sub, msg);
+                return prev;
+            }
+            state.txId = msg['tx-id'];
+            sub.updatedAt = Date.now();
+            return prev;
+        });
+        const sub = this.subs.currentValue[hash];
+        if (sub) {
+            this.notifyCbs(hash, {
+                type: CallbackEventType.InitialSyncComplete,
+                data: subData(sub, sub.entities || []),
+            });
+        }
+    }
+    onSyncUpdateTriples(msg) {
+        const subscriptionId = msg['subscription-id'];
+        const hash = this.idToHash[subscriptionId];
+        if (!hash) {
+            this.log.error('Missing hash for subscription', msg);
+            return;
+        }
+        this.subs.set((prev) => {
+            var _a;
+            const sub = prev[hash];
+            if (!sub) {
+                this.log.error('Missing sub for hash', hash, msg);
+                return prev;
+            }
+            const state = sub.state;
+            if (!state) {
+                this.log.error('Missing state for sub', sub, msg);
+                return prev;
+            }
+            for (const tx of msg.txes) {
+                if (state.txId >= tx['tx-id']) {
+                    continue;
+                }
+                state.txId = tx['tx-id'];
+                const idxesToDelete = [];
+                // Note: this won't work as well when links are involved
+                const byEid = {};
+                for (const change of tx.changes) {
+                    const eidChanges = (_a = byEid[change.triple[0]]) !== null && _a !== void 0 ? _a : [];
+                    byEid[change.triple[0]] = eidChanges;
+                    eidChanges.push(change);
+                }
+                const entities = sub.entities || [];
+                sub.entities = entities;
+                const updated = [];
+                // Update the existing stores, if we already know about this entity
+                eidLoop: for (const [eid, changes] of Object.entries(byEid)) {
+                    for (const [entIdx, ent] of Object.entries(entities)) {
+                        if (s.hasEntity(ent.store, eid)) {
+                            applyChangesToStore(ent.store, changes);
+                            const entity = queryEntity(sub, ent.store);
+                            const changedFields = changedFieldsOfChanges(ent.store, changes)[eid];
+                            for (const [k, { oldValue, newValue }] of Object.entries(changedFields || {})) {
+                                if (oldValue === newValue) {
+                                    delete changedFields[k];
+                                }
+                            }
+                            if (entity) {
+                                updated.push({
+                                    oldEntity: ent.entity,
+                                    newEntity: entity,
+                                    changedFields: changedFields || {},
+                                });
+                                ent.entity = entity;
+                            }
+                            else {
+                                idxesToDelete.push(entIdx);
+                            }
+                            delete byEid[eid];
+                            continue eidLoop;
+                        }
+                    }
+                }
+                const added = [];
+                // If we have anything left in byEid, then this must be a new entity we don't know about
+                for (const [_eid, changes] of Object.entries(byEid)) {
+                    const store = this.createStore([]);
+                    applyChangesToStore(store, changes);
+                    const entity = queryEntity(sub, store);
+                    if (!entity) {
+                        this.log.error('No entity found after applying change', {
+                            sub,
+                            changes,
+                            store,
+                        });
+                        1;
+                        continue;
+                    }
+                    entities.push({
+                        store,
+                        entity,
+                        serverCreatedAt: getServerCreatedAt(sub, store, entity.id),
+                    });
+                    added.push(entity);
+                }
+                const removed = [];
+                for (const idx of idxesToDelete.sort().reverse()) {
+                    removed.push(entities[idx].entity);
+                    entities.splice(idx, 1);
+                }
+                sortEntitiesInPlace(sub, entities);
+                this.notifyCbs(hash, {
+                    type: CallbackEventType.SyncTransaction,
+                    data: subData(sub, sub.entities),
+                    added,
+                    removed,
+                    updated,
+                });
+                sub.updatedAt = Date.now();
+            }
+            return prev;
+        });
+    }
+    clearSubscriptionData(subscriptionId) {
+        const hash = this.idToHash[subscriptionId];
+        if (hash) {
+            delete this.idToHash[subscriptionId];
+            const sub = this.subs.currentValue[hash];
+            if (sub.state) {
+                this.sendRemove(sub.state);
+            }
+            this.subs.set((prev) => {
+                delete prev[hash];
+                return prev;
+            });
+            if (sub) {
+                return sub;
+            }
+        }
+    }
+    onStartSyncError(msg) {
+        const hash = weakHash(msg['original-event']['q']);
+        const error = {
+            message: msg.message || 'Uh-oh, something went wrong. Ping Joe & Stopa.',
+            status: msg.status,
+            type: msg.type,
+            hint: msg.hint,
+        };
+        const k = Object.keys(msg['original-event']['q'])[0];
+        this.notifyCbs(hash, {
+            type: CallbackEventType.Error,
+            data: { [k]: [] },
+            error,
+        });
+    }
+    onResyncError(msg) {
+        // Clear the subscription and start from scrath on any resync error
+        // This can happen if the auth changed and we need to refetch with the
+        // new auth or if the subscription is too far behind.
+        const subscriptionId = msg['original-event']['subscription-id'];
+        const removedSub = this.clearSubscriptionData(subscriptionId);
+        if (removedSub) {
+            this.initSubscription(removedSub.query, removedSub.hash);
+        }
+    }
+}
+//# sourceMappingURL=SyncTable.js.map