@instantdb/core 0.22.89 → 0.22.90-experimental.drewh-ssr.20286580593.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instantdb/core",
-  "version": "0.22.89",
+  "version": "0.22.90-experimental.drewh-ssr.20286580593.1",
   "description": "Instant's core local abstraction",
   "homepage": "https://github.com/instantdb/instant/tree/main/client/packages/core",
   "repository": {
@@ -53,7 +53,7 @@
   "dependencies": {
     "mutative": "^1.0.10",
     "uuid": "^11.1.0",
-    "@instantdb/version": "0.22.89"
+    "@instantdb/version": "0.22.90-experimental.drewh-ssr.20286580593.1"
   },
   "scripts": {
     "test": "vitest",

package/src/Reactor.js

@@ -3,7 +3,7 @@ import weakHash from './utils/weakHash.ts';
 import instaql from './instaql.ts';
 import * as instaml from './instaml.ts';
 import * as s from './store.ts';
-import uuid from './utils/uuid.ts';
+import uuid from './utils/id.ts';
 import IndexedDBStorage from './IndexedDBStorage.ts';
 import WindowNetworkListener from './WindowNetworkListener.js';
 import * as authAPI from './authAPI.ts';
@@ -348,7 +348,17 @@ export default class Reactor {
     this._oauthCallbackResponse = this._oauthLoginInit();
 
     // kick off a request to cache it
-    this.getCurrentUser();
+    this.getCurrentUser().then((userInfo) => {
+      this.syncUserToEndpoint(userInfo.user);
+    });
+
+    setInterval(
+      async () => {
+        const currentUser = await this.getCurrentUser();
+        this.syncUserToEndpoint(currentUser.user);
+      },
+      1000 * 60 * 20,
+    );
 
     NetworkListener.getIsOnline().then((isOnline) => {
       this._isOnline = isOnline;
@@ -549,6 +559,43 @@ export default class Reactor {
     }
   }
 
+  /**
+   * Does the same thing as add-query-ok
+   * but called as a result of receiving query info from ssr
+   * @param {any} q
+   * @param {{ triples: any; pageInfo: any; }} result
+   * @param {boolean} enableCardinalityInference
+   */
+  _addQueryData(q, result, enableCardinalityInference) {
+    if (!this.attrs) {
+      throw new Error('Attrs in reactor have not been set');
+    }
+    const queryHash = weakHash(q);
+    const attrsStore = this.ensureAttrs();
+    const store = s.createStore(
+      this.attrs,
+      result.triples,
+      enableCardinalityInference,
+      this.config.useDateObjects,
+    );
+    this.querySubs.updateInPlace((prev) => {
+      prev[queryHash] = {
+        result: {
+          store,
+          attrsStore,
+          pageInfo: result.pageInfo,
+          processedTxId: undefined,
+          isExternal: true,
+        },
+        q,
+      };
+    });
+    this._cleanupPendingMutationsQueries();
+    this.notifyOne(queryHash);
+    this.notifyOneQueryOnce(queryHash);
+    this._cleanupPendingMutationsTimeout();
+  }
+
   _handleReceive(connId, msg) {
     // opt-out, enabled by default if schema
     const enableCardinalityInference =
@@ -1221,7 +1268,7 @@ export default class Reactor {
   }
 
   /** Runs instaql on a query and a store */
-  dataForQuery(hash) {
+  dataForQuery(hash, applyOptimistic = true) {
     const errorMessage = this._errorMessage;
     if (errorMessage) {
       return { error: errorMessage };
@@ -1245,15 +1292,26 @@ export default class Reactor {
       return cached;
     }
 
-    const { store, attrsStore, pageInfo, aggregate, processedTxId } = result;
+    let store = result.store;
+    let attrsStore = result.attrsStore;
+    const { pageInfo, aggregate, processedTxId } = result;
     const mutations = this._rewriteMutationsSorted(
       attrsStore,
       pendingMutations,
     );
-    const { store: newStore, attrsStore: newAttrsStore } =
-      this._applyOptimisticUpdates(store, attrsStore, mutations, processedTxId);
+    if (applyOptimistic) {
+      const optimisticResult = this._applyOptimisticUpdates(
+        store,
+        attrsStore,
+        mutations,
+        processedTxId,
+      );
+
+      store = optimisticResult.store;
+      attrsStore = optimisticResult.attrsStore;
+    }
     const resp = instaql(
-      { store: newStore, attrsStore: newAttrsStore, pageInfo, aggregate },
+      { store: store, attrsStore: attrsStore, pageInfo, aggregate },
       q,
     );
 
@@ -1989,7 +2047,27 @@ export default class Reactor {
     }
   }
 
+  async syncUserToEndpoint(user) {
+    if (this.config.cookieEndpoint) {
+      try {
+        fetch(this.config.cookieEndpoint + '/sync-auth', {
+          method: 'POST',
+          body: JSON.stringify({
+            user: user,
+          }),
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        });
+      } catch (error) {
+        console.error('Error syncing user with external endpoint', error);
+      }
+    }
+  }
+
   updateUser(newUser) {
+    this.syncUserToEndpoint(newUser);
+
     const newV = { error: undefined, user: newUser };
     this._currentUserCached = { isLoading: false, ...newV };
     this._dataForQueryCache = {};

package/src/SyncTable.ts

@@ -1,7 +1,7 @@
 import { PersistedObject } from './utils/PersistedObject.ts';
 import * as s from './store.ts';
 import weakHash from './utils/weakHash.ts';
-import uuid from './utils/uuid.ts';
+import uuid from './utils/id.ts';
 import { Logger } from './Reactor.js';
 import instaql, { compareOrder } from './instaql.ts';
 import { InstaQLResponse, ValidQuery } from './queryTypes.ts';

package/src/createRouteHandler.ts

@@ -0,0 +1,44 @@
+export const createInstantRouteHandler = (config: {
+  appId: string;
+  apiURI?: string;
+}) => {
+  async function handleUserSync(req: Request) {
+    const body = await req.json();
+    if (body.user && body.user.refresh_token) {
+      return new Response('sync', {
+        headers: {
+          // 7 day expiry
+          'Set-Cookie': `instant_user=${JSON.stringify(body.user)}; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=604800`,
+        },
+      });
+    } else {
+      return new Response('sync', {
+        headers: {
+          // remove the cookie (some browsers)
+          'Set-Cookie': `instant_user=; Path=/; HttpOnly; Secure; SameSite=Strict; Max-Age=-1`,
+        },
+      });
+    }
+  }
+
+  return {
+    GET: async (_req: Request) => {
+      return new Response('Method not allowed', {
+        status: 405,
+        statusText: 'Method Not Allowed',
+      });
+    },
+    POST: async (req: Request) => {
+      const url = new URL(req.url);
+      const pathname = url.pathname;
+      const route = pathname.split('/')[pathname.split('/').length - 1];
+      switch (route) {
+        case 'sync-auth':
+          return await handleUserSync(req);
+      }
+      return new Response('Route not found', {
+        status: 404,
+      });
+    },
+  };
+};

package/src/framework.ts

@@ -0,0 +1,294 @@
+import {
+  coerceQuery,
+  InstantCoreDatabase,
+  InstantDBAttr,
+  weakHash,
+} from './index.ts';
+import * as s from './store.js';
+import instaql from './instaql.js';
+import { RuleParams } from './schemaTypes.ts';
+import { createLinkIndex } from './utils/linkIndex.ts';
+
+export const isServer = typeof window === 'undefined' || 'Deno' in globalThis;
+
+export type FrameworkConfig = {
+  token?: string | null;
+  db: InstantCoreDatabase<any, any>;
+};
+
+type QueryPromise =
+  | {
+      type: 'http';
+      triples: any;
+      attrs: any;
+      queryHash: any;
+      query: any;
+      pageInfo?: any;
+    }
+  | {
+      type: 'session';
+      queryResult: any;
+    };
+
+export class FrameworkClient {
+  private params: FrameworkConfig;
+  private db: InstantCoreDatabase<any, any>;
+  public resultMap: Map<
+    string,
+    {
+      status: 'pending' | 'success' | 'error';
+      type: 'http' | 'session';
+      promise?: Promise<QueryPromise> | null;
+      data?: any;
+      error?: any;
+    }
+  > = new Map();
+
+  private queryResolvedCallbacks: ((result: {
+    triples: any;
+    attrs: any;
+    queryHash: any;
+    query: any;
+    pageInfo?: any;
+  }) => void)[] = [];
+
+  constructor(params: FrameworkConfig) {
+    this.params = params;
+    this.db = params.db;
+    this.resultMap = new Map<
+      string,
+      {
+        type: 'http' | 'session';
+        status: 'pending' | 'success' | 'error';
+        promise?: Promise<QueryPromise>;
+        data?: any;
+        error?: any;
+      }
+    >();
+  }
+
+  public subscribe = (
+    callback: (result: {
+      triples: any;
+      attrs: any;
+      queryHash: string;
+      pageInfo?: any;
+    }) => void,
+  ) => {
+    this.queryResolvedCallbacks.push(callback);
+  };
+
+  // Runs on the client when ssr gets html script tags
+  public addQueryResult = (queryKey: string, value: any) => {
+    this.resultMap.set(queryKey, {
+      type: value.type,
+      status: 'success',
+      data: value,
+      promise: null,
+      error: null,
+    });
+    // send the result to the client
+    if (!isServer) {
+      // make sure the attrs are there to create stores
+      if (!this.db._reactor.attrs) {
+        this.db._reactor._setAttrs(value.attrs);
+      }
+      this.db._reactor._addQueryData(
+        value.query,
+        value,
+        !!this.db._reactor.config.schema,
+      );
+    }
+  };
+
+  public query = (
+    _query: any,
+    opts?: {
+      ruleParams: RuleParams;
+    },
+  ): {
+    type: 'http' | 'session';
+    status: 'pending' | 'success' | 'error';
+    promise?: Promise<QueryPromise>;
+    data?: any;
+    error?: any;
+  } => {
+    const { hash, query } = this.hashQuery(_query, opts);
+
+    if (this.db._reactor.status === 'authenticated') {
+      const promise = this.db.queryOnce(_query, opts);
+      let entry = {
+        status: 'pending' as 'pending' | 'success' | 'error',
+        type: 'session' as 'http' | 'session',
+        data: undefined as any,
+        error: undefined as any,
+        promise: promise as any,
+      };
+      promise.then((result) => {
+        entry.status = 'success';
+        entry.data = result;
+        entry.promise = null;
+      });
+      promise.catch((error) => {
+        entry.status = 'error';
+        entry.error = error;
+        entry.promise = null;
+      });
+      return entry as any;
+    }
+
+    const promise = this.getTriplesAndAttrsForQuery(query);
+    let entry = {
+      status: 'pending' as 'pending' | 'success' | 'error',
+      type: 'http' as 'http' | 'session',
+      data: undefined as any,
+      error: undefined as any,
+      promise: promise as any,
+    };
+
+    promise.then((result) => {
+      entry.status = 'success';
+      entry.data = result;
+      entry.promise = null;
+    });
+    promise.catch((error) => {
+      entry.status = 'error';
+      entry.error = error;
+      entry.promise = null;
+    });
+
+    promise.then((result) => {
+      this.queryResolvedCallbacks.forEach((callback) => {
+        callback({
+          queryHash: hash,
+          query: query,
+          attrs: result.attrs,
+          triples: result.triples,
+          pageInfo: result.pageInfo,
+        });
+      });
+    });
+
+    this.resultMap.set(hash, entry);
+    return entry;
+  };
+
+  public getExistingResultForQuery = (
+    _query: any,
+    opts?: {
+      ruleParams: RuleParams;
+    },
+  ) => {
+    const { hash } = this.hashQuery(_query, opts);
+    return this.resultMap.get(hash);
+  };
+
+  public completeIsomorphic = (
+    query: any,
+    triples: any[],
+    attrs: InstantDBAttr[],
+    pageInfo?: any,
+  ) => {
+    const attrMap = {};
+    attrs.forEach((attr) => {
+      attrMap[attr.id] = attr;
+    });
+
+    const enableCardinalityInference =
+      Boolean(this.db?._reactor?.config?.schema) &&
+      ('cardinalityInference' in this.db?._reactor?.config
+        ? Boolean(this.db?._reactor.config?.cardinalityInference)
+        : true);
+
+    const attrsStore = new s.AttrsStoreClass(
+      attrs.reduce((acc, attr) => {
+        acc[attr.id] = attr;
+        return acc;
+      }, {}),
+      createLinkIndex(this.db?._reactor.config.schema),
+    );
+
+    const store = s.createStore(
+      attrsStore,
+      triples,
+      enableCardinalityInference,
+      this.params.db._reactor.config.useDateObjects || false,
+    );
+    const resp = instaql(
+      {
+        store: store,
+        attrsStore: attrsStore,
+        pageInfo: pageInfo,
+        aggregate: undefined,
+      },
+      query,
+    );
+    return resp;
+  };
+
+  public hashQuery = (
+    _query: any,
+    opts?: {
+      ruleParams: RuleParams;
+    },
+  ): { hash: string; query: any } => {
+    if (_query && opts && 'ruleParams' in opts) {
+      _query = { $$ruleParams: opts['ruleParams'], ..._query };
+    }
+    const query = _query ? coerceQuery(_query) : null;
+    return { hash: weakHash(query), query: query };
+  };
+
+  public getTriplesAndAttrsForQuery = async (
+    query: any,
+  ): Promise<{
+    triples: any[];
+    attrs: InstantDBAttr[];
+    query: any;
+    queryHash: string;
+    type: 'http';
+    pageInfo?: any;
+  }> => {
+    const response = await fetch(
+      `${this.db._reactor.config.apiURI}/runtime/framework/query`,
+      {
+        method: 'POST',
+        headers: {
+          'app-id': this.params.db._reactor.config.appId,
+          'Content-Type': 'application/json',
+          Authorization: this.params.token
+            ? `Bearer ${this.params.token}`
+            : undefined,
+        } as Record<string, string>,
+        body: JSON.stringify({
+          query: query,
+        }),
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error('Error getting triples from server');
+    }
+
+    const data = await response.json();
+
+    const attrs = data?.attrs;
+    if (!attrs) {
+      throw new Error('No attrs');
+    }
+
+    // TODO: make safer
+    const triples = data.result?.[0].data?.['datalog-result']?.['join-rows'][0];
+
+    const pageInfo = data.result?.[0]?.data?.['page-info'];
+
+    return {
+      attrs,
+      triples,
+      type: 'http',
+      queryHash: this.hashQuery(query).hash,
+      query,
+      pageInfo,
+    };
+  };
+}

package/src/index.ts

@@ -8,7 +8,7 @@ import {
   type TransactionChunk,
 } from './instatx.js';
 import weakHash from './utils/weakHash.js';
-import id from './utils/uuid.js';
+import id from './utils/id.ts';
 import IndexedDBStorage from './IndexedDBStorage.ts';
 import { coerceToDate } from './utils/dates.js';
 import WindowNetworkListener from './WindowNetworkListener.js';
@@ -20,10 +20,13 @@ import {
   validateTransactions,
   TransactionValidationError,
 } from './transactionValidation.ts';
+
 import {
   StorageInterface,
   type StorageInterfaceStoreName,
 } from './utils/PersistedObject.ts';
+import { createInstantRouteHandler } from './createRouteHandler.ts';
+import { parseSchemaFromJSON } from './parseSchemaFromJSON.ts';
 
 import type {
   PresenceOpts,
@@ -103,6 +106,7 @@ import type {
 } from './schemaTypes.ts';
 import type { InstantRules } from './rulesTypes.ts';
 import type { UploadFileResponse, DeleteFileResponse } from './StorageAPI.ts';
+import { FrameworkClient, type FrameworkConfig } from './framework.ts';
 
 import type {
   ExchangeCodeForTokenParams,
@@ -153,6 +157,7 @@ export type InstantConfig<
   appId: string;
   schema?: S;
   websocketURI?: string;
+  cookieEndpoint?: string;
   apiURI?: string;
   devtool?: boolean | DevtoolConfig;
   verbose?: boolean;
@@ -902,7 +907,9 @@ export {
   validateQuery,
   QueryValidationError,
   validateTransactions,
+  parseSchemaFromJSON,
   TransactionValidationError,
+  FrameworkClient,
 
   // error
   InstantAPIError,
@@ -1018,6 +1025,7 @@ export {
 
   // SSE
   type EventSourceType,
+  type FrameworkConfig,
 
   // sync table types
   type SyncTableCallback,
@@ -1034,4 +1042,5 @@ export {
   // storage (e.g. indexeddb) interface
   StorageInterface,
   type StorageInterfaceStoreName,
+  createInstantRouteHandler,
 };

package/src/instaml.ts

@@ -9,7 +9,7 @@ import {
 import { getOps, isLookup, parseLookup } from './instatx.ts';
 import { immutableRemoveUndefined } from './utils/object.js';
 import { coerceToDate } from './utils/dates.ts';
-import uuid from './utils/uuid.ts';
+import uuid from './utils/id.ts';
 import {
   EntitiesWithLinks,
   IContainEntitiesAndLinks,

package/src/instaql.ts

@@ -1,5 +1,5 @@
 import { query as datalogQuery } from './datalog.js';
-import { uuidCompare } from './utils/uuid.ts';
+import { uuidCompare } from './utils/id.ts';
 import { stringCompare } from './utils/strings.ts';
 import * as s from './store.ts';
 import { InstantDBAttr } from './attrTypes.ts';