@livestore/livestore 0.2.0 → 0.3.0-dev.11

package/src/{SynchronousDatabaseWrapper.ts → SqliteDbWrapper.ts}

@@ -5,9 +5,12 @@ import type {
   MutableDebugInfo,
   PreparedBindValues,
   PreparedStatement,
-  SynchronousDatabase,
+  SqliteDb,
+  SqliteDbChangeset,
+  SqliteDbSession,
 } from '@livestore/common'
 import { BoundArray, BoundMap, sql } from '@livestore/common'
+import { isDevEnv } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 
 import QueryCache from './QueryCache.js'
@@ -20,12 +23,17 @@ export const emptyDebugInfo = (): DebugInfo => ({
   events: new BoundArray(1000),
 })
 
-export class SynchronousDatabaseWrapper {
+/**
+ * This class is mostly adding result caching around a SqliteDb which is used to speed up
+ * SQLite queries when used through the reactivity graph.
+ */
+export class SqliteDbWrapper implements SqliteDb {
+  _tag = 'SqliteDb' as const
   // TODO: how many unique active statements are expected?
   private cachedStmts = new BoundMap<string, PreparedStatement>(200)
   private tablesUsedCache = new BoundMap<string, Set<string>>(200)
   private resultCache = new QueryCache()
-  private db: SynchronousDatabase
+  private db: SqliteDb
   private otelTracer: otel.Tracer
   private otelRootSpanContext: otel.Context
   private tablesUsedStmt
@@ -35,7 +43,7 @@ export class SynchronousDatabaseWrapper {
     db,
     otel,
   }: {
-    db: SynchronousDatabase
+    db: SqliteDb
     otel: {
       tracer: otel.Tracer
       rootSpanContext: otel.Context
@@ -53,6 +61,25 @@ export class SynchronousDatabaseWrapper {
 
     configureSQLite(this)
   }
+  metadata: any
+  prepare(queryStr: string): PreparedStatement {
+    return this.db.prepare(queryStr)
+  }
+  import(data: Uint8Array<ArrayBufferLike> | SqliteDb<any, any>) {
+    return this.db.import(data)
+  }
+  close(): void {
+    return this.db.close()
+  }
+  destroy(): void {
+    return this.db.destroy()
+  }
+  session(): SqliteDbSession {
+    return this.db.session()
+  }
+  makeChangeset(data: Uint8Array): SqliteDbChangeset {
+    return this.db.makeChangeset(data)
+  }
 
   txn<TRes>(callback: () => TRes): TRes {
     this.execute(sql`begin transaction;`)
@@ -75,6 +102,21 @@ export class SynchronousDatabaseWrapper {
     return result
   }
 
+  withChangeset<TRes>(callback: () => TRes): { result: TRes; changeset: Uint8Array | undefined } {
+    const session = this.db.session()
+    const result = callback()
+    const changeset = session.changeset()
+
+    session.finish()
+
+    return { result, changeset }
+  }
+
+  rollback(changeset: Uint8Array) {
+    const invertedChangeset = this.db.makeChangeset(changeset).invert()
+    invertedChangeset.apply()
+  }
+
   getTablesUsed(query: string) {
     // It seems that SQLite doesn't properly handle `DELETE FROM SOME_TABLE` queries without a WHERE clause
     // So we need to handle these queries separately
@@ -105,9 +147,13 @@ export class SynchronousDatabaseWrapper {
 
   execute(
     queryStr: string,
-    bindValues?: PreparedBindValues,
-    writeTables?: ReadonlySet<string>,
-    options?: { hasNoEffects?: boolean; otelContext?: otel.Context },
+    bindValues?: PreparedBindValues | undefined,
+    options?: {
+      hasNoEffects?: boolean
+      otelContext?: otel.Context
+      writeTables?: ReadonlySet<string>
+      onRowsChanged?: (rowsChanged: number) => void
+    },
   ): { durationMs: number } {
     // console.debug('in-memory-db:execute', query, bindValues)
 
@@ -128,7 +174,7 @@ export class SynchronousDatabaseWrapper {
         if (options?.hasNoEffects !== true && !this.resultCache.ignoreQuery(queryStr)) {
           // TODO use write tables instead
           // check what queries actually end up here.
-          this.resultCache.invalidate(writeTables ?? this.getTablesUsed(queryStr))
+          this.resultCache.invalidate(options?.writeTables ?? this.getTablesUsed(queryStr))
         }
 
         span.end()
@@ -138,7 +184,7 @@ export class SynchronousDatabaseWrapper {
         this.debugInfo.queryFrameDuration += durationMs
         this.debugInfo.queryFrameCount++
 
-        if (durationMs > 5 && import.meta.env.DEV) {
+        if (durationMs > 5 && isDevEnv()) {
           this.debugInfo.slowQueries.push({
             queryStr,
             bindValues,
@@ -156,14 +202,14 @@ export class SynchronousDatabaseWrapper {
 
   select<T = any>(
     queryStr: string,
+    bindValues?: PreparedBindValues | undefined,
     options?: {
       queriedTables?: ReadonlySet<string>
-      bindValues?: PreparedBindValues
       skipCache?: boolean
       otelContext?: otel.Context
     },
   ): ReadonlyArray<T> {
-    const { queriedTables, bindValues, skipCache = false, otelContext } = options ?? {}
+    const { queriedTables, skipCache = false, otelContext } = options ?? {}
 
     // console.debug('in-memory-db:select', query, bindValues)
 
@@ -206,7 +252,7 @@ export class SynchronousDatabaseWrapper {
           this.debugInfo.queryFrameCount++
 
           // TODO also enable in non-dev mode
-          if (durationMs > 5 && import.meta.env.DEV) {
+          if (durationMs > 5 && isDevEnv()) {
             this.debugInfo.slowQueries.push({
               queryStr,
               bindValues,
@@ -236,7 +282,7 @@ export class SynchronousDatabaseWrapper {
 }
 
 /** Set up SQLite performance; hasn't been super carefully optimized yet. */
-const configureSQLite = (db: SynchronousDatabaseWrapper) => {
+const configureSQLite = (db: SqliteDbWrapper) => {
   db.execute(
     // TODO: revisit these tuning parameters for max performance
     sql`

package/src/ambient.d.ts

@@ -5,7 +5,7 @@ interface Window {
 }
 
 var __debugLiveStore: any
-var __debugDownloadBlob: any
+var __debugLiveStoreUtils: any
 
 interface ImportMeta {
   readonly env: ImportMetaEnv

package/src/effect/LiveStore.ts

@@ -1,24 +1,30 @@
 import type { Adapter, BootStatus, UnexpectedError } from '@livestore/common'
 import type { LiveStoreSchema } from '@livestore/common/schema'
-import type { Cause, Scope } from '@livestore/utils/effect'
-import { Context, Deferred, Duration, Effect, FiberSet, Layer, OtelTracer, pipe } from '@livestore/utils/effect'
-import * as otel from '@opentelemetry/api'
+import type { Cause, OtelTracer, Scope } from '@livestore/utils/effect'
+import { Context, Deferred, Duration, Effect, Layer, pipe } from '@livestore/utils/effect'
+import type * as otel from '@opentelemetry/api'
 import type { GraphQLSchema } from 'graphql'
 
+import type { SqliteDbWrapper } from '../SqliteDbWrapper.js'
 import { createStore } from '../store/create-store.js'
 import type { Store } from '../store/store.js'
 import type { BaseGraphQLContext, LiveStoreContextRunning as LiveStoreContextRunning_ } from '../store/store-types.js'
-import type { SynchronousDatabaseWrapper } from '../SynchronousDatabaseWrapper.js'
 
-export type LiveStoreContextRunning = LiveStoreContextRunning_
-export const LiveStoreContextRunning = Context.GenericTag<LiveStoreContextRunning>(
-  '@livestore/livestore/effect/LiveStoreContextRunning',
-)
+export class LiveStoreContextRunning extends Context.Tag('@livestore/livestore/effect/LiveStoreContextRunning')<
+  LiveStoreContextRunning,
+  LiveStoreContextRunning_
+>() {
+  static fromDeferred = Effect.gen(function* () {
+    const deferred = yield* DeferredStoreContext
+    const ctx = yield* deferred
+    return Layer.succeed(LiveStoreContextRunning, ctx)
+  }).pipe(Layer.unwrapScoped)
+}
 
-export type DeferredStoreContext = Deferred.Deferred<LiveStoreContextRunning, UnexpectedError>
-export const DeferredStoreContext = Context.GenericTag<DeferredStoreContext>(
-  '@livestore/livestore/effect/DeferredStoreContext',
-)
+export class DeferredStoreContext extends Context.Tag('@livestore/livestore/effect/DeferredStoreContext')<
+  DeferredStoreContext,
+  Deferred.Deferred<LiveStoreContextRunning['Type'], UnexpectedError>
+>() {}
 
 export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
   schema: LiveStoreSchema
@@ -32,10 +38,12 @@ export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
    */
   storeId?: string
   graphQLOptions?: {
-    schema: Effect.Effect<GraphQLSchema, never, otel.Tracer>
-    makeContext: (db: SynchronousDatabaseWrapper, tracer: otel.Tracer, sessionId: string) => GraphQLContext
+    schema: Effect.Effect<GraphQLSchema, never, OtelTracer.OtelTracer>
+    makeContext: (db: SqliteDbWrapper, tracer: otel.Tracer, sessionId: string) => GraphQLContext
   }
-  boot?: (store: Store<GraphQLContext, LiveStoreSchema>) => Effect.Effect<void, unknown, otel.Tracer>
+  boot?: (
+    store: Store<GraphQLContext, LiveStoreSchema>,
+  ) => Effect.Effect<void, unknown, OtelTracer.OtelTracer | LiveStoreContextRunning>
   adapter: Adapter
   disableDevtools?: boolean
   onBootStatus?: (status: BootStatus) => void
@@ -44,7 +52,7 @@ export type LiveStoreContextProps<GraphQLContext extends BaseGraphQLContext> = {
 
 export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>(
   props: LiveStoreContextProps<GraphQLContext>,
-): Layer.Layer<LiveStoreContextRunning, UnexpectedError | Cause.TimeoutException, otel.Tracer> =>
+): Layer.Layer<LiveStoreContextRunning, UnexpectedError | Cause.TimeoutException, OtelTracer.OtelTracer> =>
   Layer.scoped(LiveStoreContextRunning, makeLiveStoreContext(props)).pipe(
     Layer.withSpan('LiveStore'),
     Layer.provide(LiveStoreContextDeferred),
@@ -52,7 +60,7 @@ export const LiveStoreContextLayer = <GraphQLContext extends BaseGraphQLContext>
 
 export const LiveStoreContextDeferred = Layer.effect(
   DeferredStoreContext,
-  Deferred.make<LiveStoreContextRunning, UnexpectedError>(),
+  Deferred.make<LiveStoreContextRunning['Type'], UnexpectedError>(),
 )
 
 export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>({
@@ -65,43 +73,34 @@ export const makeLiveStoreContext = <GraphQLContext extends BaseGraphQLContext>(
   onBootStatus,
   batchUpdates,
 }: LiveStoreContextProps<GraphQLContext>): Effect.Effect<
-  LiveStoreContextRunning,
+  LiveStoreContextRunning['Type'],
   UnexpectedError | Cause.TimeoutException,
-  DeferredStoreContext | Scope.Scope | otel.Tracer
+  DeferredStoreContext | Scope.Scope | OtelTracer.OtelTracer
 > =>
   pipe(
     Effect.gen(function* () {
-      const otelRootSpanContext = otel.context.active()
-
-      const otelTracer = yield* OtelTracer.Tracer
-
       const graphQLOptions = yield* graphQLOptions_
         ? Effect.all({ schema: graphQLOptions_.schema, makeContext: Effect.succeed(graphQLOptions_.makeContext) })
         : Effect.succeed(undefined)
 
-      // TODO join fiber set and close tear down parent scope in case of error (Needs refactor with Mike A)
-      const fiberSet = yield* FiberSet.make()
-
       const store = yield* createStore({
         schema,
         storeId,
         graphQLOptions,
-        otelOptions: {
-          tracer: otelTracer,
-          rootSpanContext: otelRootSpanContext,
-        },
         boot,
         adapter,
         disableDevtools,
-        fiberSet,
         onBootStatus,
         batchUpdates,
       })
 
       globalThis.__debugLiveStore ??= {}
-      // window.__debugLiveStore[schema.key] = store
+      if (Object.keys(globalThis.__debugLiveStore).length === 0) {
+        globalThis.__debugLiveStore['_'] = store
+      }
+      globalThis.__debugLiveStore[storeId] = store
 
-      return { stage: 'running', store } satisfies LiveStoreContextRunning
+      return { stage: 'running', store } satisfies LiveStoreContextRunning['Type']
     }),
     Effect.tapErrorCause((cause) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.failCause(def, cause))),
     Effect.tap((storeCtx) => Effect.flatMap(DeferredStoreContext, (def) => Deferred.succeed(def, storeCtx))),

package/src/index.ts

@@ -8,10 +8,15 @@ export type {
   OtelOptions,
 } from './store/store-types.js'
 
-export type { LiveStoreContextRunning } from './effect/LiveStore.js'
-export { StoreAbort, StoreInterrupted, type LiveStoreContext } from './store/store-types.js'
+export {
+  StoreAbort,
+  StoreInterrupted,
+  type LiveStoreContext,
+  type ShutdownDeferred,
+  type LiveStoreContextRunning,
+} from './store/store-types.js'
 
-export { SynchronousDatabaseWrapper, emptyDebugInfo } from './SynchronousDatabaseWrapper.js'
+export { SqliteDbWrapper, emptyDebugInfo } from './SqliteDbWrapper.js'
 
 export type {
   GetAtom,
@@ -26,8 +31,9 @@ export type {
   Effect,
 } from './reactive.js'
 export { LiveStoreComputedQuery, computed } from './live-queries/computed.js'
-export { LiveStoreDbQuery, queryDb } from './live-queries/db.js'
+export { LiveStoreDbQuery, queryDb } from './live-queries/db-query.js'
 export { LiveStoreGraphQLQuery, queryGraphQL } from './live-queries/graphql.js'
+export { makeRef, type LiveQueryRef } from './live-queries/make-ref.js'
 export {
   type GetAtomResult,
   type ReactivityGraph,
@@ -35,10 +41,11 @@ export {
   type LiveQuery,
   type GetResult,
   type LiveQueryAny,
+  type LiveQueryDef,
+  type LiveQueryDefAny,
+  type RcRef,
 } from './live-queries/base-class.js'
 
-export { globalReactivityGraph } from './global-state.js'
-
 export { deriveColQuery } from './row-query-utils.js'
 
 export * from '@livestore/common/schema'
@@ -46,7 +53,7 @@ export {
   sql,
   SessionIdSymbol,
   type BootStatus,
-  type SynchronousDatabase,
+  type SqliteDb,
   type DebugInfo,
   type MutableDebugInfo,
   prepareBindValues,