Make search an edge route

apps/web/next.config.js

@@ -1,5 +1,19 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
+  webpack: (
+    config,
+    {buildId, dev, isServer, defaultLoaders, nextRuntime, webpack}
+  ) => {
+    if (config.name === 'edge-server') {
+      config.resolve.conditionNames = ['worker', 'import', 'require']
+      config.module.rules.unshift({
+        test: /\.wasm$/,
+        loader: 'next-middleware-wasm-loader',
+        type: 'javascript/auto'
+      })
+    }
+    return config
+  },
   reactStrictMode: false,
   swcMinify: true,
   typescript: {

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

@@ -7,7 +7,7 @@ export async function GET(request: Request) {
   if (!searchTerm) return Response.json([])
   const matches = await cms
     .in(cms.workspaces.main.pages)
-    .syncInterval(0)
+    .disableSync()
     .find(
       Entry()
         .select({

src/backend/Handler.ts

@@ -113,7 +113,7 @@ export class Handler implements Resolver {
   }
 
   async periodicSync(syncInterval = 5) {
-    if (syncInterval === 0) return
+    if (syncInterval === Infinity) return
     const now = Date.now()
     if (now - this.lastSync < syncInterval * 1000) return
     this.lastSync = now

src/cli/Generate.ts

@@ -1,7 +1,9 @@
 import {Database} from 'alinea/backend'
 import {Store} from 'alinea/backend/Store'
+import {exportStore} from 'alinea/cli/util/ExportStore.server'
 import {CMS} from 'alinea/core/CMS'
 import {Config} from 'alinea/core/Config'
+import {join} from 'alinea/core/util/Paths'
 import {BuildResult} from 'esbuild'
 import fs from 'node:fs'
 import {createRequire} from 'node:module'
@@ -103,14 +105,17 @@ export async function* generate(options: GenerateOptions): AsyncGenerator<
   let nextBuild: Promise<{value: BuildResult; done?: boolean}> = builds.next()
   let afterGenerateCalled = false
 
-  const [store, exportStore] = await createDb()
+  function writeStore(data: Uint8Array) {
+    return exportStore(data, join(context.outDir, 'store.js'))
+  }
+  const [store, storeData] = await createDb()
   await copyStaticFiles(context)
   while (true) {
     const {done} = await nextBuild
     nextBuild = builds.next()
     try {
       const cms = await loadCMS(context.outDir)
-      cms.exportStore(context.outDir, new Uint8Array())
+      await writeStore(new Uint8Array())
       const fileData = new LocalData({
         config: cms.config,
         fs: fs.promises,
@@ -125,12 +130,6 @@ export async function* generate(options: GenerateOptions): AsyncGenerator<
         nextBuild
       )) {
         yield {cms, db, localData: fileData}
-        // For debug reasons write out db
-        if (process.env.NODE_ENV === 'development')
-          fs.writeFileSync(
-            path.join(context.outDir, 'content.sqlite'),
-            exportStore()
-          )
         if (onAfterGenerate && !afterGenerateCalled) {
           afterGenerateCalled = true
           onAfterGenerate()
@@ -139,7 +138,7 @@ export async function* generate(options: GenerateOptions): AsyncGenerator<
       if (done) {
         await Promise.all([
           generatePackage(context, cms.config),
-          cms.exportStore(context.outDir, exportStore())
+          writeStore(storeData())
         ])
         break
       }

src/core/CMS.ts

@@ -32,7 +32,6 @@ export abstract class CMS extends GraphRealm implements CMSApi {
   }
 
   abstract resolver(): Promise<Resolver>
-  abstract exportStore(cwd: string, store: Uint8Array): Promise<void>
   abstract readStore(): Promise<Store>
 
   #attach(config: Config) {

src/core/Graph.ts

@@ -29,6 +29,8 @@ export interface GraphRealmApi {
   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
+  /** Disable polling for updates to content */
+  disableSync(): GraphRealmApi
   /** The amount of results found */
   count(cursor: Cursor.Find<any>): Promise<number>
 }
@@ -49,6 +51,19 @@ export class GraphRealm implements GraphRealmApi {
     this.targets = Schema.targets(config.schema)
   }
 
+  disableSync() {
+    return new GraphRealm(
+      this.config,
+      params => {
+        return this.resolve({
+          ...params,
+          syncInterval: Infinity
+        })
+      },
+      this.origin
+    )
+  }
+
   syncInterval(interval: number) {
     return new GraphRealm(
       this.config,

src/core/driver/DefaultDriver.server.tsx

@@ -1,23 +1,17 @@
 import {Database} from 'alinea/backend'
 import {Store, createStore} from 'alinea/backend/Store'
 import {EntryResolver} from 'alinea/backend/resolver/EntryResolver'
-import {exportStore} from 'alinea/cli/util/ExportStore'
 import {base64} from 'alinea/core/util/Encoding'
 import PLazy from 'p-lazy'
 import {CMS, CMSApi} from '../CMS.js'
 import {Client} from '../Client.js'
 import {Config} from '../Config.js'
 import {Resolver} from '../Resolver.js'
 import {Realm} from '../pages/Realm.js'
-import {join} from '../util/Paths.js'
 
 export class DefaultDriver extends CMS {
   db = PLazy.from(this.createDb.bind(this))
 
-  exportStore(outDir: string, data: Uint8Array): Promise<void> {
-    return exportStore(data, join(outDir, 'store.js'))
-  }
-
   async readStore(): Promise<Store> {
     // @ts-ignore
     const {storeData} = await import('@alinea/generated/store.js')

src/core/driver/DefaultDriver.tsx

@@ -4,10 +4,6 @@ import {Config} from '../Config.js'
 import {Resolver} from '../Resolver.js'
 
 export class DefaultDriver extends CMS {
-  exportStore(outDir: string, data: Uint8Array): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
   async readStore(): Promise<Store> {
     throw new Error('Not implemented')
   }