Add syncInterval to be explicit about when to (not) sync

apps/web/src/app/api/search/route.ts

@@ -5,21 +5,26 @@ import {Entry} from 'alinea/core'
 export async function GET(request: Request) {
   const searchTerm = new URL(request.url).searchParams.get('query')
   if (!searchTerm) return Response.json([])
-  const matches = await cms.in(cms.workspaces.main.pages).find(
-    Entry()
-      .select({
-        title: Entry.title,
-        url: Entry.url,
-        snippet: alinea.snippet(),
-        parents({parents}) {
-          return parents().select({
-            id: Entry.entryId,
-            title: Entry.title
-          })
-        }
-      })
-      .search(searchTerm)
-      .take(25)
-  )
+  const matches = await cms
+    .in(cms.workspaces.main.pages)
+    .syncInterval(0)
+    .find(
+      Entry()
+        .select({
+          title: Entry.title,
+          url: Entry.url,
+          snippet: alinea.snippet(),
+          parents({parents}) {
+            return parents().select({
+              id: Entry.entryId,
+              title: Entry.title
+            })
+          }
+        })
+        .search(...searchTerm.split(' '))
+        .take(25)
+    )
   return Response.json(matches)
 }
+
+export const runtime = 'edge'

src/backend/Handler.ts

@@ -73,8 +73,10 @@ export class Handler implements Resolver {
 
   resolve = async (params: Connection.ResolveParams) => {
     const {resolveDefaults} = this.options
-    await this.periodicSync()
-    return this.resolver.resolve({...resolveDefaults, ...params})
+    const resolveParams = {...resolveDefaults, ...params}
+    const {syncInterval} = resolveParams
+    await this.periodicSync(syncInterval)
+    return this.resolver.resolve(resolveParams)
   }
 
   protected previewAuth(): Connection.Context {
@@ -110,9 +112,10 @@ export class Handler implements Resolver {
     return {...entry, ...entryData, path: entry.path}
   }
 
-  async periodicSync() {
+  async periodicSync(syncInterval = 5) {
+    if (syncInterval === 0) return
     const now = Date.now()
-    if (now - this.lastSync < 5_000) return
+    if (now - this.lastSync < syncInterval * 1000) return
     this.lastSync = now
     try {
       await this.syncPending()

src/core/Config.ts

@@ -25,9 +25,11 @@ export interface Config {
   preview?: string | ComponentType<{entry: Entry; previewToken: string}>
   /** Every edit will pass through a draft phase before being published */
   enableDrafts?: boolean
+  /** The interval in seconds at which the frontend will poll for updates */
+  syncInterval?: number
 
   /**
-  publicDir?: string
+    publicDir?: string
   dashboardFile?: string
   handlerUrl?: 
   */

src/core/Connection.ts

@@ -56,6 +56,7 @@ export namespace Connection {
     selection: Selection
     location?: Array<string>
     locale?: string
+    syncInterval?: number
   }
   export type MediaUploadParams = {
     buffer: ArrayBuffer

src/core/Graph.ts

@@ -15,13 +15,21 @@ import {seralizeLocation, serializeSelection} from './pages/Serialize.js'
 export type Location = Root | Workspace | PageSeed
 
 export interface GraphRealmApi {
+  /** Filter results by location */
   in(location: Location): GraphRealmApi
+  /** Filter results by locale */
   locale(locale: string): GraphRealmApi
+  /** Find a single entry or null */
   maybeGet<S extends Projection | Type>(
     select: S
   ): Promise<Projection.InferOne<S> | null>
+  /** Find a single entry */
   get<S extends Projection | Type>(select: S): Promise<Projection.InferOne<S>>
+  /** Find a set of entries */
   find<S extends Projection | Type>(select: S): Promise<Selection.Infer<S>>
+  /** The time in seconds to poll for updates to content */
+  syncInterval(interval: number): GraphRealmApi
+  /** The amount of results found */
   count(cursor: Cursor.Find<any>): Promise<number>
 }
 
@@ -41,6 +49,19 @@ export class GraphRealm implements GraphRealmApi {
     this.targets = Schema.targets(config.schema)
   }
 
+  syncInterval(interval: number) {
+    return new GraphRealm(
+      this.config,
+      params => {
+        return this.resolve({
+          ...params,
+          syncInterval: interval
+        })
+      },
+      this.origin
+    )
+  }
+
   in(location: Location): GraphRealmApi {
     // Should this reset locale?
     return new GraphRealm(this.config, this.resolve, {...this.origin, location})

src/core/Resolver.ts

@@ -11,6 +11,7 @@ export interface PreviewUpdate {
 export interface ResolveDefaults {
   realm?: Realm
   preview?: PreviewUpdate
+  syncInterval?: number
 }
 
 export interface Resolver {

src/core/driver/DefaultDriver.server.tsx

@@ -31,6 +31,7 @@ export class DefaultDriver extends CMS {
         config: this.config,
         url: devUrl,
         resolveDefaults: {
+          syncInterval: this.config.syncInterval ?? 60,
           realm: Realm.Published
         }
       })

src/core/driver/NextDriver.server.tsx

@@ -35,6 +35,7 @@ class NextDriver extends DefaultDriver implements NextApi {
     const [draftStatus] = outcome(() => draftMode())
     const isDraft = draftStatus?.isEnabled
     const resolveDefaults: ResolveDefaults = {
+      syncInterval: this.config.syncInterval ?? 60,
       realm: Realm.Published
     }
     if (isDraft) {

src/ui/UIStory.tsx

@@ -16,7 +16,7 @@ export interface UIStoryProps extends PropsWithChildren<{}> {
 
 export function UIStory({fullWidth, fullHeight, children}: UIStoryProps) {
   return (
-    <DashboardProvider dev config={example} client={client}>
+    <DashboardProvider dev config={example.config} client={client}>
       <Viewport attachToBody>
         <FieldToolbar.Provider>
           <div