@instantdb/core 0.22.87 → 0.22.88-experimental.drewh-ssr.20248709142.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instantdb/core",
-  "version": "0.22.87",
+  "version": "0.22.88-experimental.drewh-ssr.20248709142.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.87"
+    "@instantdb/version": "0.22.88-experimental.drewh-ssr.20248709142.1"
   },
   "scripts": {
     "test": "vitest",

package/src/Reactor.js

@@ -319,7 +319,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;
@@ -513,6 +523,42 @@ 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 store = s.createStore(
+      this.attrs,
+      result.triples,
+      enableCardinalityInference,
+      this._linkIndex,
+      this.config.useDateObjects,
+    );
+    this.querySubs.updateInPlace((prev) => {
+      prev[queryHash] = {
+        result: {
+          store,
+          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 =
@@ -1146,7 +1192,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 };
@@ -1170,17 +1216,16 @@ export default class Reactor {
       return cached;
     }
 
-    const { store, pageInfo, aggregate, processedTxId } = result;
+    let store = result.store;
+    const { pageInfo, aggregate, processedTxId } = result;
     const mutations = this._rewriteMutationsSorted(
       store.attrs,
       pendingMutations,
     );
-    const newStore = this._applyOptimisticUpdates(
-      store,
-      mutations,
-      processedTxId,
-    );
-    const resp = instaql({ store: newStore, pageInfo, aggregate }, q);
+    if (applyOptimistic) {
+      store = this._applyOptimisticUpdates(store, mutations, processedTxId);
+    }
+    const resp = instaql({ store: store, pageInfo, aggregate }, q);
 
     return { data: resp, querySubVersion, pendingMutationsVersion };
   }
@@ -1912,7 +1957,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/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,281 @@
+import {
+  coerceQuery,
+  InstantCoreDatabase,
+  InstantDBAttr,
+  weakHash,
+} from './index.ts';
+import * as s from './store.js';
+import instaql from './instaql.js';
+import { RuleParams } from './schemaTypes.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 store = s.createStore(
+      attrMap,
+      triples,
+      enableCardinalityInference,
+      null,
+      this.params.db._reactor.config.useDateObjects || false,
+    );
+    const resp = instaql(
+      { store: store, 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/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

@@ -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/parseSchemaFromJSON.ts

@@ -0,0 +1,176 @@
+import { i } from './schema.ts';
+import { DataAttrDef, InstantSchemaDef } from './schemaTypes.ts';
+
+export const parseSchemaFromJSON = (
+  s: any,
+): InstantSchemaDef<any, any, any> => {
+  // Parse entities
+  const entities: Record<string, any> = {};
+
+  for (const [entityName, entityInfo] of Object.entries(s.entities)) {
+    const entityDef = entityInfo as any;
+    const attrs: Record<string, any> = {};
+
+    // Parse attributes
+    for (const [attrName, attrInfo] of Object.entries(entityDef.attrs)) {
+      const attrDef = attrInfo as any;
+      let attr: DataAttrDef<any, any, any>;
+
+      // Create the appropriate attribute type
+      switch (attrDef.valueType) {
+        case 'string':
+          attr = i.string();
+          break;
+        case 'number':
+          attr = i.number();
+          break;
+        case 'boolean':
+          attr = i.boolean();
+          break;
+        case 'date':
+          attr = i.date();
+          break;
+        case 'json':
+          attr = i.json();
+          break;
+        default:
+          attr = i.json();
+      }
+
+      // Apply modifiers
+      if (!attrDef.required) {
+        attr = attr.optional();
+      }
+
+      if (attrDef.config?.indexed) {
+        attr = attr.indexed();
+      }
+
+      if (attrDef.config?.unique) {
+        attr = attr.unique();
+      }
+
+      attrs[attrName] = attr;
+    }
+
+    entities[entityName] = i.entity(attrs);
+  }
+
+  // Parse links
+  const links: Record<string, any> = s.links || {};
+
+  // Parse rooms
+  const rooms: Record<string, any> = {};
+
+  if (s.rooms) {
+    for (const [roomName, roomInfo] of Object.entries(s.rooms)) {
+      const roomDef = roomInfo as any;
+
+      // Parse presence
+      const presenceAttrs: Record<string, any> = {};
+      for (const [attrName, attrInfo] of Object.entries(
+        roomDef.presence.attrs,
+      )) {
+        const attrDef = attrInfo as any;
+        let attr: DataAttrDef<any, any, any>;
+
+        switch (attrDef.valueType) {
+          case 'string':
+            attr = i.string();
+            break;
+          case 'number':
+            attr = i.number();
+            break;
+          case 'boolean':
+            attr = i.boolean();
+            break;
+          case 'date':
+            attr = i.date();
+            break;
+          case 'json':
+            attr = i.json();
+            break;
+          default:
+            attr = i.json();
+        }
+
+        if (!attrDef.required) {
+          attr = attr.optional();
+        }
+
+        if (attrDef.config?.indexed) {
+          attr = attr.indexed();
+        }
+
+        if (attrDef.config?.unique) {
+          attr = attr.unique();
+        }
+
+        presenceAttrs[attrName] = attr;
+      }
+
+      // Parse topics
+      const topics: Record<string, any> = {};
+      if (roomDef.topics) {
+        for (const [topicName, topicInfo] of Object.entries(roomDef.topics)) {
+          const topicDef = topicInfo as any;
+          const topicAttrs: Record<string, any> = {};
+
+          for (const [attrName, attrInfo] of Object.entries(topicDef.attrs)) {
+            const attrDef = attrInfo as any;
+            let attr: DataAttrDef<any, any, any>;
+
+            switch (attrDef.valueType) {
+              case 'string':
+                attr = i.string();
+                break;
+              case 'number':
+                attr = i.number();
+                break;
+              case 'boolean':
+                attr = i.boolean();
+                break;
+              case 'date':
+                attr = i.date();
+                break;
+              case 'json':
+                attr = i.json();
+                break;
+              default:
+                attr = i.json();
+            }
+
+            if (!attrDef.required) {
+              attr = attr.optional();
+            }
+
+            if (attrDef.config?.indexed) {
+              attr = attr.indexed();
+            }
+
+            if (attrDef.config?.unique) {
+              attr = attr.unique();
+            }
+
+            topicAttrs[attrName] = attr;
+          }
+
+          topics[topicName] = i.entity(topicAttrs);
+        }
+      }
+
+      rooms[roomName] = {
+        presence: i.entity(presenceAttrs),
+        topics,
+      };
+    }
+  }
+
+  const resultingSchema = i.schema({
+    entities,
+    links,
+    rooms,
+  });
+
+  return resultingSchema;
+};