@instantdb/core 0.22.56 → 0.22.57

package/src/index.ts

@@ -10,6 +10,7 @@ import {
 import weakHash from './utils/weakHash.js';
 import id from './utils/uuid.js';
 import IndexedDBStorage from './IndexedDBStorage.ts';
+import { coerceToDate } from './utils/dates.js';
 import WindowNetworkListener from './WindowNetworkListener.js';
 import { i } from './schema.js';
 import { createDevtool } from './devtool.js';
@@ -111,11 +112,25 @@ import type {
 import { InstantAPIError, type InstantIssue } from './utils/fetch.js';
 import { InstantError } from './InstantError.ts';
 import { EventSourceType } from './Connection.ts';
+import { CallbackEventType as SyncTableCallbackEventType } from './SyncTable.ts';
+import type {
+  SyncTableCallback,
+  CallbackEvent as SyncTableCallbackEvent,
+  InitialSyncBatch as SyncTableInitialSyncBatch,
+  InitialSyncComplete as SyncTableInitialSyncComplete,
+  SyncTransaction as SyncTableSyncTransaction,
+  LoadFromStorage as SyncTableLoadFromStorage,
+  SetupError as SyncTableSetupError,
+} from './SyncTable.ts';
 
 const defaultOpenDevtool = true;
 
 // types
 
+type ExactlyOne<T> = {
+  [K in keyof T]: Pick<T, K> & Partial<Record<Exclude<keyof T, K>, never>>;
+}[keyof T];
+
 export type Config = {
   appId: string;
   websocketURI?: string;
@@ -710,6 +725,26 @@ class InstantCoreDatabase<
   }> {
     return this._reactor.queryOnce(query, opts);
   }
+
+  /**
+   * @deprecated This is an experimental function that is not yet ready for production use.
+   * Use this function to sync an entire namespace.
+   * It has many limitations that will be removed in the future:
+   * 1. Must be used with an admin token
+   * 2. Does not support permissions
+   * 3. Does not support where clauses
+   * 4. Does not support links
+   * It also does not support multiple top-level namespaces. For example,
+   *  {posts: {}, users: {}} is invalid. Only `posts` or `users` is allowed, but not both.
+   */
+  _syncTableExperimental<Q extends ValidQuery<Q, Schema>>(
+    query: ExactlyOne<Q>,
+    cb: SyncTableCallback<Schema, Q, UseDates>,
+  ): (
+    opts?: { keepSubscription: boolean | null | undefined } | null | undefined,
+  ) => void {
+    return this._reactor.subscribeTable(query, cb);
+  }
 }
 
 function schemaHash(schema?: InstantSchemaDef<any, any, any>): string {
@@ -862,6 +897,7 @@ export {
   getOps,
   coerceQuery,
   weakHash,
+  coerceToDate,
   IndexedDBStorage,
   WindowNetworkListener,
   InstantCoreDatabase,
@@ -870,6 +906,9 @@ export {
   version,
   InstantError,
 
+  // sync table enums
+  SyncTableCallbackEventType,
+
   // og types
   type IDatabase,
   type RoomSchemaShape,
@@ -963,6 +1002,15 @@ export {
   // SSE
   type EventSourceType,
 
+  // sync table types
+  type SyncTableCallback,
+  type SyncTableCallbackEvent,
+  type SyncTableInitialSyncBatch,
+  type SyncTableInitialSyncComplete,
+  type SyncTableSyncTransaction,
+  type SyncTableLoadFromStorage,
+  type SyncTableSetupError,
+
   // error types
   type InstantIssue,
 };

package/src/instaql.js

@@ -497,7 +497,7 @@ function compareDisparateValues(a, b, dataType) {
   return -1;
 }
 
-function compareOrder([id_a, v_a], [id_b, v_b], dataType) {
+export function compareOrder(id_a, v_a, id_b, v_b, dataType) {
   if (v_a === v_b || (v_a == null && v_b == null)) {
     return uuidCompare(id_a, id_b);
   }
@@ -512,6 +512,10 @@ function compareOrder([id_a, v_a], [id_b, v_b], dataType) {
   return compareDisparateValues(v_a, v_b, dataType);
 }
 
+function compareOrderTriples([id_a, v_a], [id_b, v_b], dataType) {
+  return compareOrder(id_a, v_a, id_b, v_b, dataType);
+}
+
 function comparableDate(x) {
   if (x == null) {
     return x;
@@ -523,14 +527,16 @@ function isBefore(startCursor, orderAttr, direction, idVec) {
   const [c_e, _c_a, c_v, c_t] = startCursor;
   const compareVal = direction === 'desc' ? 1 : -1;
   if (orderAttr['forward-identity']?.[2] === 'id') {
-    return compareOrder(idVec, [c_e, c_t], null) === compareVal;
+    return compareOrderTriples(idVec, [c_e, c_t], null) === compareVal;
   }
   const [e, v] = idVec;
   const dataType = orderAttr['checked-data-type'];
   const v_new = dataType === 'date' ? comparableDate(v) : v;
   const c_v_new = dataType === 'date' ? comparableDate(c_v) : c_v;
 
-  return compareOrder([e, v_new], [c_e, c_v_new], dataType) === compareVal;
+  return (
+    compareOrderTriples([e, v_new], [c_e, c_v_new], dataType) === compareVal
+  );
 }
 
 function orderAttrFromCursor(store, cursor) {
@@ -605,10 +611,10 @@ function runDataloadAndReturnObjects(store, { etype, pageInfo, dq, form }) {
   idVecs.sort(
     direction === 'asc'
       ? function compareIdVecs(a, b) {
-          return compareOrder(a, b, orderAttr?.['checked-data-type']);
+          return compareOrderTriples(a, b, orderAttr?.['checked-data-type']);
         }
       : function compareIdVecs(a, b) {
-          return compareOrder(b, a, orderAttr?.['checked-data-type']);
+          return compareOrderTriples(b, a, orderAttr?.['checked-data-type']);
         },
   );
 

package/src/store.js

@@ -18,7 +18,7 @@ function getAttr(attrs, attrId) {
   return attrs[attrId];
 }
 
-function getInMap(obj, path) {
+export function getInMap(obj, path) {
   return path.reduce((acc, key) => acc && acc.get(key), obj);
 }
 
@@ -126,6 +126,14 @@ export function fromJSON(storeJSON) {
   );
 }
 
+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;
+}
+
 function resetAttrIndexes(store) {
   store.attrIndexes = createAttrIndexes(store.attrs);
 }
@@ -205,7 +213,7 @@ function resolveLookupRefs(store, triple) {
   }
 }
 
-function retractTriple(store, rawTriple) {
+export function retractTriple(store, rawTriple) {
   const triple = resolveLookupRefs(store, rawTriple);
   if (!triple) {
     return;
@@ -256,7 +264,7 @@ function getCreatedAt(store, attr, triple) {
   return createdAt || Date.now() * 10 + _seed++;
 }
 
-function addTriple(store, rawTriple) {
+export function addTriple(store, rawTriple) {
   const triple = resolveLookupRefs(store, rawTriple);
   if (!triple) {
     return;

package/src/utils/PersistedObject.ts

@@ -27,12 +27,12 @@ export class PersistedObject<T> {
   _subs = [];
   _persister: Storage;
   _key: string;
-  _onMerge: (fromStorage: T, inMemoryValue: T) => any;
+  _onMerge: (fromStorage: T, inMemoryValue: T) => T | void;
   _loadedCbs: Array<() => void>;
   _isLoading: boolean;
   currentValue: T;
-  serialize: (T) => any;
-  parse: (any) => T;
+  serialize: (input: T) => any;
+  parse: (input: any) => T;
   _saveThrottleMs: number;
   _idleCallbackMaxWaitMs: number;
   _pendingSaveCbs: Array<() => void>;
@@ -43,7 +43,12 @@ export class PersistedObject<T> {
     persister: Storage,
     key: string,
     defaultValue: T,
-    onMerge: (fromStorage: T, inMemoryValue: T) => any,
+    /**
+     * Merges data from storage with in-memory value on load.
+     * If a value is returned from onMerge, that value that will
+     * become the current value.
+     */
+    onMerge: (fromStorage: T, inMemoryValue: T) => T | void,
     serialize = (x: T): any => {
       return x;
     },
@@ -84,7 +89,10 @@ export class PersistedObject<T> {
     const fromStorage = await this._getFromStorage();
     this._isLoading = false;
 
-    this._onMerge(fromStorage, this.currentValue);
+    const mergeResult = this._onMerge(fromStorage, this.currentValue);
+    if (mergeResult) {
+      this.currentValue = mergeResult;
+    }
     for (const cb of this._loadedCbs) {
       cb();
     }
@@ -149,7 +157,7 @@ export class PersistedObject<T> {
     }, this._saveThrottleMs);
   }
 
-  set(f, cb) {
+  set(f: (prev: T) => T, cb?: () => void): T {
     this._version++;
     this.currentValue = f(this.currentValue);
     if (this._isLoading) {
@@ -160,6 +168,7 @@ export class PersistedObject<T> {
     for (const sub of this._subs) {
       sub(this.currentValue);
     }
+    return this.currentValue;
   }
 
   subscribe(cb) {