@astrogate/sdk 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,722 @@
+import { create } from 'mutative';
+import { immutableDeepMerge } from './utils/object.js';
+import { coerceToDate } from './utils/dates.js';
+export class AttrsStoreClass {
+    attrs;
+    linkIndex;
+    _blobAttrs = null;
+    _primaryKeys = null;
+    _forwardIdents = null;
+    _revIdents = null;
+    constructor(attrs, linkIndex) {
+        this.attrs = attrs;
+        this.linkIndex = linkIndex;
+    }
+    resetAttrIndexes() {
+        this._blobAttrs = null;
+        this._primaryKeys = null;
+        this._forwardIdents = null;
+        this._revIdents = null;
+    }
+    addAttr(attr) {
+        this.attrs[attr.id] = attr;
+        this.resetAttrIndexes();
+    }
+    deleteAttr(attrId) {
+        delete this.attrs[attrId];
+        this.resetAttrIndexes();
+    }
+    updateAttr(partialAttr) {
+        const attr = this.attrs[partialAttr.id];
+        if (!attr)
+            return;
+        this.attrs[partialAttr.id] = { ...attr, ...partialAttr };
+        this.resetAttrIndexes();
+    }
+    getAttr(id) {
+        return this.attrs[id];
+    }
+    get blobAttrs() {
+        if (this._blobAttrs) {
+            return this._blobAttrs;
+        }
+        this._blobAttrs = new Map();
+        for (const attr of Object.values(this.attrs)) {
+            if (isBlob(attr)) {
+                const [_, fwdEtype, fwdLabel] = attr['forward-identity'];
+                setInMap(this.blobAttrs, [fwdEtype, fwdLabel], attr);
+            }
+        }
+        return this._blobAttrs;
+    }
+    get primaryKeys() {
+        if (this._primaryKeys) {
+            return this._primaryKeys;
+        }
+        this._primaryKeys = new Map();
+        for (const attr of Object.values(this.attrs)) {
+            if (attr['primary?']) {
+                const [_, fwdEtype] = attr['forward-identity'];
+                setInMap(this._primaryKeys, [fwdEtype], attr);
+            }
+        }
+        return this._primaryKeys;
+    }
+    get forwardIdents() {
+        if (this._forwardIdents) {
+            return this._forwardIdents;
+        }
+        this._forwardIdents = new Map();
+        for (const attr of Object.values(this.attrs)) {
+            const fwdIdent = attr['forward-identity'];
+            const [_, fwdEtype, fwdLabel] = fwdIdent;
+            setInMap(this._forwardIdents, [fwdEtype, fwdLabel], attr);
+        }
+        return this._forwardIdents;
+    }
+    get revIdents() {
+        if (this._revIdents) {
+            return this._revIdents;
+        }
+        this._revIdents = new Map();
+        for (const attr of Object.values(this.attrs)) {
+            const revIdent = attr['reverse-identity'];
+            if (revIdent) {
+                const [_, revEtype, revLabel] = revIdent;
+                setInMap(this._revIdents, [revEtype, revLabel], attr);
+            }
+        }
+        return this._revIdents;
+    }
+    toJSON() {
+        return { attrs: this.attrs, linkIndex: this.linkIndex };
+    }
+}
+function hasEA(attr) {
+    return attr['cardinality'] === 'one';
+}
+function isRef(attr) {
+    return attr['value-type'] === 'ref';
+}
+export function isBlob(attr) {
+    return attr['value-type'] === 'blob';
+}
+function getAttr(attrs, attrId) {
+    return attrs[attrId];
+}
+export function getInMap(obj, path) {
+    return path.reduce((acc, key) => acc && acc.get(key), obj);
+}
+function deleteInMap(m, path) {
+    if (path.length === 0)
+        throw new Error('path must have at least one element');
+    if (path.length === 1) {
+        m.delete(path[0]);
+        return;
+    }
+    const [head, ...tail] = path;
+    if (!m.has(head))
+        return;
+    deleteInMap(m.get(head), tail);
+}
+function setInMap(m, path, value) {
+    let current = m;
+    const lastI = path.length - 1;
+    for (let i = 0; i < lastI; i++) {
+        const part = path[i];
+        let nextMap = current.get(part);
+        if (nextMap === undefined) {
+            nextMap = new Map();
+            current.set(part, nextMap);
+        }
+        current = nextMap;
+    }
+    if (lastI > -1) {
+        current.set(path[lastI], value);
+    }
+}
+function isDateAttr(attr) {
+    return attr['checked-data-type'] === 'date';
+}
+function createTripleIndexes(attrsStore, triples, useDateObjects) {
+    const eav = new Map();
+    const aev = new Map();
+    const vae = new Map();
+    for (const triple of triples) {
+        let [eid, aid, v] = triple;
+        const attr = attrsStore.getAttr(aid);
+        if (!attr) {
+            console.warn('no such attr', aid, eid);
+            continue;
+        }
+        if (attr['checked-data-type'] === 'date' && useDateObjects) {
+            v = coerceToDate(v);
+            triple[2] = v;
+        }
+        if (isRef(attr)) {
+            setInMap(vae, [v, aid, eid], triple);
+        }
+        setInMap(eav, [eid, aid, v], triple);
+        setInMap(aev, [aid, eid, v], triple);
+    }
+    return { eav, aev, vae };
+}
+function createAttrIndexes(attrs) {
+    const blobAttrs = new Map();
+    const primaryKeys = new Map();
+    const forwardIdents = new Map();
+    const revIdents = new Map();
+    for (const attr of Object.values(attrs)) {
+        const fwdIdent = attr['forward-identity'];
+        const [_, fwdEtype, fwdLabel] = fwdIdent;
+        const revIdent = attr['reverse-identity'];
+        setInMap(forwardIdents, [fwdEtype, fwdLabel], attr);
+        if (isBlob(attr)) {
+            setInMap(blobAttrs, [fwdEtype, fwdLabel], attr);
+        }
+        if (attr['primary?']) {
+            setInMap(primaryKeys, [fwdEtype], attr);
+        }
+        if (revIdent) {
+            const [_, revEtype, revLabel] = revIdent;
+            setInMap(revIdents, [revEtype, revLabel], attr);
+        }
+    }
+    return { blobAttrs, primaryKeys, forwardIdents, revIdents };
+}
+export function toJSON(store) {
+    return {
+        triples: allMapValues(store.eav, 3),
+        cardinalityInference: store.cardinalityInference,
+        useDateObjects: store.useDateObjects,
+        version: 1,
+    };
+}
+export function fromJSON(attrsStore, storeJSON) {
+    return createStore(attrsStore, storeJSON.triples, storeJSON.cardinalityInference, storeJSON.useDateObjects);
+}
+export function attrsStoreFromJSON(attrsStoreJSON, storeJSON) {
+    if (attrsStoreJSON) {
+        return new AttrsStoreClass(attrsStoreJSON.attrs, attrsStoreJSON.linkIndex);
+    }
+    if (storeJSON && '__type' in storeJSON) {
+        return new AttrsStoreClass(storeJSON.attrs, storeJSON.linkIndex);
+    }
+}
+export function hasTriple(store, [e, a, v]) {
+    return getInMap(store.eav, [e, a, v]) !== undefined;
+}
+export function hasEntity(store, e) {
+    return getInMap(store.eav, [e]) !== undefined;
+}
+export function createStore(attrsStore, triples, enableCardinalityInference, useDateObjects) {
+    const store = createTripleIndexes(attrsStore, triples, useDateObjects);
+    store.cardinalityInference = enableCardinalityInference;
+    store.useDateObjects = useDateObjects;
+    return store;
+}
+// We may have local triples with lookup refs in them,
+// we need to convert those lookup refs to eids to insert them
+// into the store. If we can't find the lookup ref locally,
+// then we drop the triple and have to wait for the server response
+// to see the optimistic updates.
+function resolveLookupRefs(store, triple) {
+    let eid;
+    // Check if `e` is a lookup ref
+    if (Array.isArray(triple[0])) {
+        const [a, v] = triple[0];
+        const eMaps = store.aev.get(a);
+        if (!eMaps) {
+            // We don't have the attr, so don't try to add the
+            // triple to the store
+            return null;
+        }
+        // This would be a lot more efficient with a ave index
+        const triples = allMapValues(eMaps, 2);
+        eid = triples.find((x) => x[2] === v)?.[0];
+    }
+    else {
+        eid = triple[0];
+    }
+    if (!eid) {
+        // We don't know the eid that the ref refers to, so
+        // we can't add the triple to the store.
+        return null;
+    }
+    // Check if v is a lookup ref
+    const lookupV = triple[2];
+    if (Array.isArray(lookupV) &&
+        lookupV.length === 2 &&
+        store.aev.get(lookupV[0])) {
+        const [a, v] = lookupV;
+        const eMaps = store.aev.get(a);
+        if (!eMaps) {
+            // We don't have the attr, so don't try to add the
+            // triple to the store
+            return null;
+        }
+        const triples = allMapValues(eMaps, 2);
+        const value = triples.find((x) => x[2] === v)?.[0];
+        if (!value) {
+            return null;
+        }
+        const [_e, aid, _v, ...rest] = triple;
+        return [eid, aid, value, ...rest];
+    }
+    else {
+        const [_, ...rest] = triple;
+        return [eid, ...rest];
+    }
+}
+export function retractTriple(store, attrsStore, rawTriple) {
+    const triple = resolveLookupRefs(store, rawTriple);
+    if (!triple) {
+        return;
+    }
+    const [eid, aid, v] = triple;
+    const attr = attrsStore.getAttr(aid);
+    if (!attr) {
+        return;
+    }
+    deleteInMap(store.eav, [eid, aid, v]);
+    deleteInMap(store.aev, [aid, eid, v]);
+    if (isRef(attr)) {
+        deleteInMap(store.vae, [v, aid, eid]);
+    }
+}
+let _seed = 0;
+function getCreatedAt(store, attr, triple) {
+    const [eid, aid, v] = triple;
+    let createdAt;
+    const t = getInMap(store.eav, [eid, aid, v]);
+    if (t) {
+        createdAt = t[3];
+    }
+    /**
+     * (XXX)
+     * Two hacks here, for generating a `createdAt`
+     *
+     * 1. We multiply Date.now() by 10, to make sure that
+     *  `createdAt` is always greater than anything the server
+     *   could return
+     *
+     *   We do this because right now we know we _only_ insert
+     *   triples as optimistic updates.
+     *
+     * 2. We increment by `_seed`, to make sure there are no
+     *    two triples with the same `createdAt`. This is
+     *    done to make tests more predictable.
+     *
+     * We may need to rethink this. Because we * 10, we can't
+     * use this value as an _actual_ `createdAt` timestamp.
+     * Eventually we may want too though; For example, we could
+     * use `createdAt` for each triple, to infer a `createdAt` and
+     * `updatedAt` value for each object.
+     */
+    return createdAt || Date.now() * 10 + _seed++;
+}
+export function addTriple(store, attrsStore, rawTriple) {
+    const triple = resolveLookupRefs(store, rawTriple);
+    if (!triple) {
+        return;
+    }
+    let [eid, aid, v] = triple;
+    const attr = attrsStore.getAttr(aid);
+    if (!attr) {
+        // (XXX): Due to the way we're handling attrs, it's
+        // possible to enter a state where we receive a triple without an attr.
+        // See: https://github.com/jsventures/instant-local/pull/132 for details.
+        // For now, if we receive a command without an attr, we no-op.
+        return;
+    }
+    if (attr['checked-data-type'] === 'date' && store.useDateObjects) {
+        v = coerceToDate(v);
+    }
+    const existingTriple = getInMap(store.eav, [eid, aid, v]);
+    // Reuse the created_at for a triple if it's already in the store.
+    // Prevents updates from temporarily pushing an entity to the top
+    // while waiting for the server response.
+    const t = existingTriple?.[3] ?? getCreatedAt(store, attr, triple);
+    const enhancedTriple = [eid, aid, v, t];
+    if (hasEA(attr)) {
+        setInMap(store.eav, [eid, aid], new Map([[v, enhancedTriple]]));
+        setInMap(store.aev, [aid, eid], new Map([[v, enhancedTriple]]));
+    }
+    else {
+        setInMap(store.eav, [eid, aid, v], enhancedTriple);
+        setInMap(store.aev, [aid, eid, v], enhancedTriple);
+    }
+    if (isRef(attr)) {
+        setInMap(store.vae, [v, aid, eid], enhancedTriple);
+    }
+}
+function mergeTriple(store, attrsStore, rawTriple) {
+    const triple = resolveLookupRefs(store, rawTriple);
+    if (!triple) {
+        return;
+    }
+    const [eid, aid, update] = triple;
+    const attr = attrsStore.getAttr(aid);
+    if (!attr)
+        return;
+    if (!isBlob(attr))
+        throw new Error('merge operation is not supported for links');
+    const eavValuesMap = getInMap(store.eav, [eid, aid]);
+    if (!eavValuesMap)
+        return;
+    const currentTriple = eavValuesMap.values().next()?.value;
+    if (!currentTriple)
+        return;
+    const currentValue = currentTriple[2];
+    const updatedValue = immutableDeepMerge(currentValue, update);
+    const enhancedTriple = [
+        eid,
+        aid,
+        updatedValue,
+        getCreatedAt(store, attr, currentTriple),
+    ];
+    setInMap(store.eav, [eid, aid], new Map([[updatedValue, enhancedTriple]]));
+    setInMap(store.aev, [aid, eid], new Map([[updatedValue, enhancedTriple]]));
+}
+function deleteEntity(store, attrsStore, args) {
+    const [lookup, etype] = args;
+    const triple = resolveLookupRefs(store, [lookup]);
+    if (!triple) {
+        return;
+    }
+    const [id] = triple;
+    // delete forward links and attributes + cardinality one links
+    const eMap = store.eav.get(id);
+    if (eMap) {
+        for (const a of eMap.keys()) {
+            const attr = attrsStore.getAttr(a);
+            // delete cascade refs
+            if (attr && attr['on-delete-reverse'] === 'cascade') {
+                allMapValues(eMap.get(a), 1).forEach(([e, a, v]) => deleteEntity(store, attrsStore, [v, attr['reverse-identity']?.[1]]));
+            }
+            if (
+            // Fall back to deleting everything if we've rehydrated tx-steps from
+            // the store that didn't set `etype` in deleteEntity
+            !etype ||
+                // If we don't know about the attr, let's just get rid of it
+                !attr ||
+                // Make sure it matches the etype
+                attr['forward-identity']?.[1] === etype) {
+                deleteInMap(store.aev, [a, id]);
+                deleteInMap(store.eav, [id, a]);
+            }
+        }
+        // Clear out the eav index for `id` if we deleted all of the attributes
+        if (eMap.size === 0) {
+            deleteInMap(store.eav, [id]);
+        }
+    }
+    // delete reverse links
+    const vaeTriples = store.vae.get(id) && allMapValues(store.vae.get(id), 2);
+    if (vaeTriples) {
+        vaeTriples.forEach((triple) => {
+            const [e, a, v] = triple;
+            const attr = attrsStore.getAttr(a);
+            if (!etype || !attr || attr['reverse-identity']?.[1] === etype) {
+                deleteInMap(store.eav, [e, a, v]);
+                deleteInMap(store.aev, [a, e, v]);
+                deleteInMap(store.vae, [v, a, e]);
+            }
+            if (attr &&
+                attr['on-delete'] === 'cascade' &&
+                attr['reverse-identity']?.[1] === etype) {
+                deleteEntity(store, attrsStore, [e, attr['forward-identity']?.[1]]);
+            }
+        });
+    }
+    // Clear out vae index for `id` if we deleted all the reverse attributes
+    if (store.vae.get(id)?.size === 0) {
+        deleteInMap(store.vae, [id]);
+    }
+}
+// (XXX): Whenever we change/delete attrs,
+// We indiscriminately reset the index map.
+// There are lots of opportunities for optimization:
+// * We _only_ need to run this indexes change. We could detect that
+// * We could batch this reset at the end
+// * We could add an ave index for all triples, so removing the
+//   right triples is easy and fast.
+function resetIndexMap(store, attrsStore, newTriples) {
+    const newIndexMap = createTripleIndexes(attrsStore, newTriples, store.useDateObjects);
+    Object.keys(newIndexMap).forEach((key) => {
+        store[key] = newIndexMap[key];
+    });
+}
+function addAttr(attrsStore, [attr]) {
+    attrsStore.addAttr(attr);
+}
+function getAllTriples(store) {
+    return allMapValues(store.eav, 3);
+}
+function deleteAttr(store, attrsStore, [id]) {
+    if (!attrsStore.getAttr(id))
+        return;
+    const newTriples = getAllTriples(store).filter(([_, aid]) => aid !== id);
+    attrsStore.deleteAttr(id);
+    resetIndexMap(store, attrsStore, newTriples);
+}
+function updateAttr(store, attrsStore, [partialAttr]) {
+    const attr = attrsStore.getAttr(partialAttr.id);
+    if (!attr)
+        return;
+    attrsStore.updateAttr(partialAttr);
+    resetIndexMap(store, attrsStore, getAllTriples(store));
+}
+function applyTxStep(store, attrsStore, txStep) {
+    const [action, ...args] = txStep;
+    switch (action) {
+        case 'add-triple':
+            addTriple(store, attrsStore, args);
+            break;
+        case 'deep-merge-triple':
+            mergeTriple(store, attrsStore, args);
+            break;
+        case 'retract-triple':
+            retractTriple(store, attrsStore, args);
+            break;
+        case 'delete-entity':
+            deleteEntity(store, attrsStore, args);
+            break;
+        case 'add-attr':
+            addAttr(attrsStore, args);
+            break;
+        case 'delete-attr':
+            deleteAttr(store, attrsStore, args);
+            break;
+        case 'update-attr':
+            updateAttr(store, attrsStore, args);
+            break;
+        case 'restore-attr':
+            break;
+        case 'rule-params':
+            break;
+        default:
+            throw new Error(`unhandled transaction action: ${action}`);
+    }
+}
+export function allMapValues(m, level, res = []) {
+    if (!m) {
+        return res;
+    }
+    if (level === 0) {
+        return res;
+    }
+    if (level === 1) {
+        for (const v of m.values()) {
+            res.push(v);
+        }
+        return res;
+    }
+    for (const v of m.values()) {
+        allMapValues(v, level - 1, res);
+    }
+    return res;
+}
+function triplesByValue(store, m, v) {
+    const res = [];
+    if (v?.hasOwnProperty('$not')) {
+        for (const candidate of m.keys()) {
+            if (v.$not !== candidate) {
+                res.push(m.get(candidate));
+            }
+        }
+        return res;
+    }
+    if (v?.hasOwnProperty('$isNull')) {
+        const { attrId, isNull, reverse } = v.$isNull;
+        if (reverse) {
+            for (const candidate of m.keys()) {
+                const vMap = store.vae.get(candidate);
+                const isValNull = !vMap || !vMap.get(attrId);
+                if (isNull ? isValNull : !isValNull) {
+                    res.push(m.get(candidate));
+                }
+            }
+        }
+        else {
+            const aMap = store.aev.get(attrId);
+            for (const candidate of m.keys()) {
+                const isValNull = !aMap || aMap.get(candidate)?.get(null) || !aMap.get(candidate);
+                if (isNull ? isValNull : !isValNull) {
+                    res.push(m.get(candidate));
+                }
+            }
+        }
+        return res;
+    }
+    if (v?.$comparator) {
+        // TODO: A sorted index would be nice here
+        return allMapValues(m, 1).filter(v.$op);
+    }
+    const values = v.in || v.$in || [v];
+    for (const value of values) {
+        const triple = m.get(value);
+        if (triple) {
+            res.push(triple);
+        }
+    }
+    return res;
+}
+// A poor man's pattern matching
+// Returns either eav, ea, ev, av, v, or ''
+function whichIdx(e, a, v) {
+    let res = '';
+    if (e !== undefined) {
+        res += 'e';
+    }
+    if (a !== undefined) {
+        res += 'a';
+    }
+    if (v !== undefined) {
+        res += 'v';
+    }
+    return res;
+}
+export function getTriples(store, [e, a, v]) {
+    const idx = whichIdx(e, a, v);
+    switch (idx) {
+        case 'e': {
+            const eMap = store.eav.get(e);
+            return allMapValues(eMap, 2);
+        }
+        case 'ea': {
+            const aMap = store.eav.get(e)?.get(a);
+            return allMapValues(aMap, 1);
+        }
+        case 'eav': {
+            const aMap = store.eav.get(e)?.get(a);
+            if (!aMap) {
+                return [];
+            }
+            return triplesByValue(store, aMap, v);
+        }
+        case 'ev': {
+            const eMap = store.eav.get(e);
+            if (!eMap) {
+                return [];
+            }
+            const res = [];
+            for (const aMap of eMap.values()) {
+                res.push(...triplesByValue(store, aMap, v));
+            }
+            return res;
+        }
+        case 'a': {
+            const aMap = store.aev.get(a);
+            return allMapValues(aMap, 2);
+        }
+        case 'av': {
+            const aMap = store.aev.get(a);
+            if (!aMap) {
+                return [];
+            }
+            const res = [];
+            for (const eMap of aMap.values()) {
+                res.push(...triplesByValue(store, eMap, v));
+            }
+            return res;
+        }
+        case 'v': {
+            const res = [];
+            for (const eMap of store.eav.values()) {
+                for (const aMap of eMap.values()) {
+                    res.push(...triplesByValue(store, aMap, v));
+                }
+            }
+            return res;
+        }
+        default: {
+            return allMapValues(store.eav, 3);
+        }
+    }
+}
+export function getAsObject(store, attrs, e) {
+    const obj = {};
+    if (!attrs) {
+        return obj;
+    }
+    for (const [label, attr] of attrs.entries()) {
+        const aMap = store.eav.get(e)?.get(attr.id);
+        const triples = allMapValues(aMap, 1);
+        for (const triple of triples) {
+            obj[label] = triple[2];
+        }
+    }
+    return obj;
+}
+export function getAttrByFwdIdentName(attrsStore, inputEtype, inputLabel) {
+    return attrsStore.forwardIdents.get(inputEtype)?.get(inputLabel);
+}
+export function getAttrByReverseIdentName(attrsStore, inputEtype, inputLabel) {
+    return attrsStore.revIdents.get(inputEtype)?.get(inputLabel);
+}
+export function getBlobAttrs(attrsStore, etype) {
+    return attrsStore.blobAttrs.get(etype);
+}
+export function getPrimaryKeyAttr(attrsStore, etype) {
+    const fromPrimary = attrsStore.primaryKeys.get(etype);
+    if (fromPrimary) {
+        return fromPrimary;
+    }
+    return attrsStore.forwardIdents.get(etype)?.get('id');
+}
+function findTriple(store, attrsStore, rawTriple) {
+    const triple = resolveLookupRefs(store, rawTriple);
+    if (!triple) {
+        return;
+    }
+    const [eid, aid, v] = triple;
+    const attr = attrsStore.getAttr(aid);
+    if (!attr) {
+        // (XXX): Due to the way we're handling attrs, it's
+        // possible to enter a state where we receive a triple without an attr.
+        // See: https://github.com/jsventures/instant-local/pull/132 for details.
+        // For now, if we receive a command without an attr, we no-op.
+        return;
+    }
+    return getInMap(store.eav, [eid, aid]);
+}
+export function transact(store, attrsStore, txSteps) {
+    const txStepsFiltered = txSteps.filter(([action, eid, attrId, value, opts]) => {
+        if (action !== 'add-triple' && action !== 'deep-merge-triple') {
+            return true;
+        }
+        const mode = opts?.mode;
+        if (mode !== 'create' && mode !== 'update') {
+            return true;
+        }
+        let exists = false;
+        const attr = attrsStore.getAttr(attrId);
+        if (attr) {
+            const idAttr = getPrimaryKeyAttr(attrsStore, attr['forward-identity'][1]);
+            exists = !!findTriple(store, attrsStore, [
+                eid,
+                idAttr?.id,
+                eid,
+            ]);
+        }
+        if (mode === 'create' && exists) {
+            return false;
+        }
+        if (mode === 'update' && !exists) {
+            return false;
+        }
+        return true;
+    });
+    return create({ store, attrsStore }, (draft) => {
+        txStepsFiltered.forEach((txStep) => {
+            applyTxStep(draft.store, draft.attrsStore, txStep);
+        });
+    }, {
+        mark: (target) => {
+            if (target instanceof AttrsStoreClass) {
+                return 'immutable';
+            }
+        },
+    });
+}