@instantdb/core 0.22.88-experimental.version-bump-0-22-88.20244772799.1 → 0.22.89-experimental.drewh-ssr.20277611943.1

package/src/SyncTable.ts

@@ -16,12 +16,12 @@ type SubState = {
 
 type SubEntity = {
   entity: any;
-  store: any;
+  store: s.Store;
   serverCreatedAt: number;
 };
 
 type SubValues = {
-  attrs: Record<string, any>;
+  attrsStore: s.AttrsStore;
   entities: Array<SubEntity>;
 };
 
@@ -38,8 +38,21 @@ type Sub = {
   updatedAt: number;
 };
 
+type SubEntityInStorage = {
+  entity: any;
+  store: s.StoreJson;
+  serverCreatedAt: number;
+};
+
+type SubValuesInStorage = {
+  attrsStore: s.AttrsStoreJson;
+  entities: Array<SubEntityInStorage>;
+};
+
 // We could make a better type for this if we had a return type for s.toJSON
-type SubInStorage = Sub;
+type SubInStorage = Omit<Sub, 'values'> & {
+  values: SubValuesInStorage;
+};
 
 type StartMsg = {
   op: 'start-sync';
@@ -96,36 +109,38 @@ type Config = { useDateObjects: boolean };
 function syncSubFromStorage(sub: SubInStorage, useDateObjects: boolean): Sub {
   const values = sub.values;
   if (values) {
-    for (const e of values.entities || []) {
-      e.store.useDateObjects = useDateObjects;
-      e.store.attrs = values.attrs;
-      e.store = s.fromJSON(e.store);
+    const attrsStore = s.attrsStoreFromJSON(values.attrsStore, null);
+    if (attrsStore) {
+      for (const e of values.entities || []) {
+        e.store.useDateObjects = useDateObjects;
+        (e as unknown as SubEntity).store = s.fromJSON(attrsStore, e.store);
+      }
+      (values as unknown as SubValues).attrsStore = attrsStore;
     }
   }
 
-  return sub;
+  return sub as unknown as Sub;
 }
 
 function syncSubToStorage(_k: string, sub: Sub): SubInStorage {
-  if (sub.values?.entities) {
-    const entities: SubEntity[] = [];
+  if (sub.values) {
+    const entities: SubEntityInStorage[] = [];
     for (const e of sub.values?.entities) {
       const store = s.toJSON(e.store);
-      // We'll store the attrs once on values, and put the
-      // attrs back into the store on hydration
-      // @ts-ignore: ts doesn't want us to delete a non-optional
-      delete store['attrs'];
       entities.push({ ...e, store });
     }
-    return { ...sub, values: { ...sub.values, entities } };
+    return {
+      ...sub,
+      values: { attrsStore: sub.values.attrsStore.toJSON(), entities },
+    };
   } else {
-    return sub;
+    return sub as unknown as SubInStorage;
   }
 }
 
 function onMergeSub(
   _key: string,
-  storageSub: SubInStorage,
+  storageSub: Sub,
   inMemorySub: Sub | null,
 ): Sub {
   const storageTxId = storageSub?.state?.txId;
@@ -142,13 +157,21 @@ function onMergeSub(
   return storageSub || inMemorySub;
 }
 
-function queryEntity(sub: Sub, store: any) {
-  const res = instaql({ store, pageInfo: null, aggregate: null }, sub.query);
+function queryEntity(sub: Sub, store: s.Store, attrsStore: s.AttrsStore) {
+  const res = instaql(
+    { store, attrsStore, pageInfo: null, aggregate: null },
+    sub.query,
+  );
   return res.data[sub.table][0];
 }
 
-function getServerCreatedAt(sub: Sub, store: any, entityId: string): number {
-  const aid = s.getAttrByFwdIdentName(store, sub.table, 'id')?.id;
+function getServerCreatedAt(
+  sub: Sub,
+  store: s.Store,
+  attrsStore: s.AttrsStore,
+  entityId: string,
+): number {
+  const aid = s.getAttrByFwdIdentName(attrsStore, sub.table, 'id')?.id;
   if (!aid) {
     return -1;
   }
@@ -160,23 +183,25 @@ function getServerCreatedAt(sub: Sub, store: any, entityId: string): number {
 }
 
 function applyChangesToStore(
-  store: any,
+  store: s.Store,
+  attrsStore: s.AttrsStore,
   changes: SyncUpdateTriplesMsg['txes'][number]['changes'],
 ): void {
   for (const { action, triple } of changes) {
     switch (action) {
       case 'added':
-        s.addTriple(store, triple);
+        s.addTriple(store, attrsStore, triple);
         break;
       case 'removed':
-        s.retractTriple(store, triple);
+        s.retractTriple(store, attrsStore, triple);
         break;
     }
   }
 }
 
 function changedFieldsOfChanges(
-  store: any,
+  store: s.Store,
+  attrsStore: s.AttrsStore,
   changes: SyncUpdateTriplesMsg['txes'][number]['changes'],
 ): {
   [eid: string]: SyncTransaction<
@@ -190,7 +215,7 @@ function changedFieldsOfChanges(
   const changedFields = {};
   for (const { action, triple } of changes) {
     const [e, a, v] = triple;
-    const field = store.attrs[a]?.['forward-identity']?.[2];
+    const field = attrsStore.getAttr(a)?.['forward-identity']?.[2];
     if (!field) continue;
 
     const fields = changedFields[e] ?? {};
@@ -225,17 +250,19 @@ function subData(sub: Sub, entities: NonNullable<Sub['values']>['entities']) {
   return { [sub.table]: entities.map((e) => e.entity) };
 }
 
+type CreateStore = (triples: Triple[]) => s.Store;
+
 // Updates the sub order field type if it hasn't been set
 // and returns the type. We have to wait until the attrs
 // are loaded before we can determine the type.
-function orderFieldTypeMutative(sub: Sub, createStore) {
+function orderFieldTypeMutative(sub: Sub, getAttrs: () => s.AttrsStore) {
   if (sub.orderFieldType) {
     return sub.orderFieldType;
   }
   const orderFieldType =
     sub.orderField === 'serverCreatedAt'
       ? 'number'
-      : s.getAttrByFwdIdentName(createStore([]), sub.table, sub.orderField)?.[
+      : s.getAttrByFwdIdentName(getAttrs(), sub.table, sub.orderField)?.[
           'checked-data-type'
         ];
 
@@ -414,19 +441,22 @@ export class SyncTable {
   private config: Config;
   private idToHash: { [subscriptionId: string]: string } = {};
   private log: Logger;
-  private createStore: (triples: Triple[]) => any;
+  private createStore: CreateStore;
+  private getAttrs: () => s.AttrsStore;
 
   constructor(
     trySend: TrySend,
     storage: StorageInterface,
     config: Config,
     log: Logger,
-    createStore: (triples: Triple[]) => any,
+    createStore: CreateStore,
+    getAttrs: () => s.AttrsStore,
   ) {
     this.trySend = trySend;
     this.config = config;
     this.log = log;
     this.createStore = createStore;
+    this.getAttrs = getAttrs;
 
     this.subs = new PersistedObject<string, Sub, SubInStorage>({
       persister: storage,
@@ -624,19 +654,23 @@ export class SyncTable {
 
     const values: SubValues = sub.values ?? {
       entities: [],
-      attrs: this.createStore([]).attrs,
+      attrsStore: this.getAttrs(),
     };
     sub.values = values;
     const entities = values.entities;
 
     for (const entRows of joinRows) {
       const store = this.createStore(entRows);
-      values.attrs = store.attrs;
-      const entity = queryEntity(sub, store);
+      const entity = queryEntity(sub, store, values.attrsStore);
       entities.push({
         store,
         entity,
-        serverCreatedAt: getServerCreatedAt(sub, store, entity.id),
+        serverCreatedAt: getServerCreatedAt(
+          sub,
+          store,
+          values.attrsStore,
+          entity.id,
+        ),
       });
       batch.push(entity);
     }
@@ -727,7 +761,7 @@ export class SyncTable {
 
       const values: SubValues = sub.values ?? {
         entities: [],
-        attrs: this.createStore([]).attrs,
+        attrsStore: this.getAttrs(),
       };
       const entities = values.entities;
       sub.values = values;
@@ -738,11 +772,13 @@ export class SyncTable {
         for (let i = 0; i < entities.length; i++) {
           const ent = entities[i];
           if (s.hasEntity(ent.store, eid)) {
-            applyChangesToStore(ent.store, changes);
-            const entity = queryEntity(sub, ent.store);
-            const changedFields = changedFieldsOfChanges(ent.store, changes)[
-              eid
-            ];
+            applyChangesToStore(ent.store, values.attrsStore, changes);
+            const entity = queryEntity(sub, ent.store, values.attrsStore);
+            const changedFields = changedFieldsOfChanges(
+              ent.store,
+              values.attrsStore,
+              changes,
+            )[eid];
             if (entity) {
               updated.push({
                 oldEntity: ent.entity,
@@ -763,9 +799,8 @@ export class SyncTable {
       // 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([]);
-        values.attrs = store.attrs;
-        applyChangesToStore(store, changes);
-        const entity = queryEntity(sub, store);
+        applyChangesToStore(store, values.attrsStore, changes);
+        const entity = queryEntity(sub, store, values.attrsStore);
         if (!entity) {
           this.log.error('No entity found after applying change', {
             sub,
@@ -777,7 +812,12 @@ export class SyncTable {
         entities.push({
           store,
           entity,
-          serverCreatedAt: getServerCreatedAt(sub, store, entity.id),
+          serverCreatedAt: getServerCreatedAt(
+            sub,
+            store,
+            values.attrsStore,
+            entity.id,
+          ),
         });
         added.push(entity);
       }
@@ -789,7 +829,7 @@ export class SyncTable {
         entities.splice(idx, 1);
       }
 
-      const orderFieldType = orderFieldTypeMutative(sub, this.createStore);
+      const orderFieldType = orderFieldTypeMutative(sub, this.getAttrs);
 
       sortEntitiesInPlace(sub, orderFieldType!, entities);
       this.notifyCbs(hash, {

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

@@ -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,
 };