@livestore/livestore 0.0.41-dev.2 → 0.0.42-dev.0

package/src/query-info.ts

@@ -1,16 +1,14 @@
+import { type DbSchema, rawSqlMutation, type RawSqlMutationEvent } from '@livestore/common/schema'
 import { notYetImplemented, shouldNeverHappen } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
-import { rawSqlMutation, type RawSqlMutationEvent } from './schema/mutations.js'
-import type { FromTable, TableDef } from './schema/table-def.js'
-
 /**
  * Semantic information about a query with supported cases being:
  * - a whole row
  * - a single column value
  * - a sub value in a JSON column
  */
-export type QueryInfo<TTableDef extends TableDef = TableDef> =
+export type QueryInfo<TTableDef extends DbSchema.TableDef = DbSchema.TableDef> =
   | QueryInfoNone
   | QueryInfoRow<TTableDef>
   | QueryInfoColJsonValue<TTableDef, GetJsonColumn<TTableDef>>
@@ -20,20 +18,23 @@ export type QueryInfoNone = {
   _tag: 'None'
 }
 
-export type QueryInfoRow<TTableDef extends TableDef> = {
+export type QueryInfoRow<TTableDef extends DbSchema.TableDef> = {
   _tag: 'Row'
   table: TTableDef
   id: string
 }
 
-export type QueryInfoCol<TTableDef extends TableDef, TColName extends keyof TTableDef['sqliteDef']['columns']> = {
+export type QueryInfoCol<
+  TTableDef extends DbSchema.TableDef,
+  TColName extends keyof TTableDef['sqliteDef']['columns'],
+> = {
   _tag: 'Col'
   table: TTableDef
   id: string
   column: TColName
 }
 
-export type QueryInfoColJsonValue<TTableDef extends TableDef, TColName extends GetJsonColumn<TTableDef>> = {
+export type QueryInfoColJsonValue<TTableDef extends DbSchema.TableDef, TColName extends GetJsonColumn<TTableDef>> = {
   _tag: 'ColJsonValue'
   table: TTableDef
   id: string
@@ -44,14 +45,14 @@ export type QueryInfoColJsonValue<TTableDef extends TableDef, TColName extends G
   jsonPath: string
 }
 
-type GetJsonColumn<TTableDef extends TableDef> = keyof {
+type GetJsonColumn<TTableDef extends DbSchema.TableDef> = keyof {
   [ColName in keyof TTableDef['sqliteDef']['columns'] as TTableDef['sqliteDef']['columns'][ColName]['columnType'] extends 'text'
     ? ColName
     : never]: {}
 }
 
 export type UpdateValueForPath<TPath extends QueryInfo> = TPath extends { _tag: 'Row' }
-  ? Partial<FromTable.RowDecodedAll<TPath['table']>>
+  ? Partial<DbSchema.FromTable.RowDecodedAll<TPath['table']>>
   : TPath extends { _tag: 'Col' }
     ? Schema.Schema.To<TPath['table']['sqliteDef']['columns'][TPath['column']]['schema']>
     : TPath extends { _tag: 'ColJsonValue' }

package/src/react/LiveStoreProvider.tsx

@@ -1,70 +1,65 @@
+import type { DatabaseFactory } from '@livestore/common'
+import type { LiveStoreSchema } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import type * as otel from '@opentelemetry/api'
 import type { ReactElement, ReactNode } from 'react'
 import React from 'react'
-import initSqlite3Wasm from 'sqlite-esm'
 
 // TODO refactor so the `react` module doesn't depend on `effect` module
 import type { LiveStoreContext as StoreContext_, LiveStoreCreateStoreOptions } from '../effect/LiveStore.js'
-import type { InMemoryDatabase } from '../inMemoryDatabase.js'
-import type { LiveStoreSchema } from '../schema/index.js'
-import type { StorageInit } from '../storage/index.js'
-import type { BaseGraphQLContext, GraphQLOptions, Store } from '../store.js'
+import type { BaseGraphQLContext, BootDb, GraphQLOptions, Store } from '../store.js'
 import { createStore } from '../store.js'
 import { LiveStoreContext } from './LiveStoreContext.js'
 
-// NOTE we're starting to initialize the sqlite wasm binary here (already before calling `createStore`),
-// so that it's ready when we need it
-const sqlite3Promise = initSqlite3Wasm({
-  print: (message) => console.log(`[livestore sqlite] ${message}`),
-  printErr: (message) => console.error(`[livestore sqlite] ${message}`),
-})
-
 interface LiveStoreProviderProps<GraphQLContext> {
   schema: LiveStoreSchema
-  loadStorage: () => StorageInit | Promise<StorageInit>
-  boot?: (db: InMemoryDatabase, parentSpan: otel.Span) => unknown | Promise<unknown>
+  boot?: (db: BootDb, parentSpan: otel.Span) => unknown | Promise<unknown>
   graphQLOptions?: GraphQLOptions<GraphQLContext>
   otelTracer?: otel.Tracer
   otelRootSpanContext?: otel.Context
   fallback: ReactElement
+  makeDb: DatabaseFactory
+  batchUpdates?: (run: () => void) => void
 }
 
 export const LiveStoreProvider = <GraphQLContext extends BaseGraphQLContext>({
   fallback,
-  loadStorage,
   graphQLOptions,
   otelTracer,
   otelRootSpanContext,
   children,
   schema,
   boot,
+  makeDb,
+  batchUpdates,
 }: LiveStoreProviderProps<GraphQLContext> & { children?: ReactNode }): JSX.Element => {
-  const store = useCreateStore({
+  const storeCtx = useCreateStore({
     schema,
-    loadStorage,
     graphQLOptions,
     otelTracer,
     otelRootSpanContext,
     boot,
+    makeDb,
+    batchUpdates,
   })
 
-  if (store === undefined) {
+  if (storeCtx === undefined) {
     return fallback
   }
 
-  window.__debugLiveStore = store.store
+  window.__debugLiveStore = storeCtx.store
 
-  return <LiveStoreContext.Provider value={store}>{children}</LiveStoreContext.Provider>
+  return <LiveStoreContext.Provider value={storeCtx}>{children}</LiveStoreContext.Provider>
 }
 
 const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
   schema,
-  loadStorage,
   graphQLOptions,
   otelTracer,
   otelRootSpanContext,
   boot,
+  makeDb,
+  batchUpdates,
 }: LiveStoreCreateStoreOptions<GraphQLContext>) => {
   const [ctxValue, setCtxValue] = React.useState<StoreContext_ | undefined>()
 
@@ -76,15 +71,14 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
 
     void (async () => {
       try {
-        const sqlite3 = await sqlite3Promise
         store = await createStore({
           schema,
-          loadStorage,
           graphQLOptions,
           otelTracer,
           otelRootSpanContext,
           boot,
-          sqlite3,
+          makeDb,
+          batchUpdates,
         })
         setCtxValue({ store })
       } catch (e) {
@@ -95,9 +89,7 @@ const useCreateStore = <GraphQLContext extends BaseGraphQLContext>({
     return () => {
       store?.destroy()
     }
-
-    // TODO: do we need to return any cleanup function here?
-  }, [schema, loadStorage, graphQLOptions, otelTracer, otelRootSpanContext, boot])
+  }, [schema, graphQLOptions, otelTracer, otelRootSpanContext, boot, makeDb, batchUpdates])
 
   return ctxValue
 }

package/src/react/useRow.ts

@@ -1,3 +1,4 @@
+import { DbSchema } from '@livestore/common/schema'
 import * as otel from '@opentelemetry/api'
 import type { SqliteDsl } from 'effect-db-schema'
 import { mapValues } from 'lodash-es'
@@ -8,18 +9,17 @@ import type { QueryInfo } from '../query-info.js'
 import { mutationForQueryInfo } from '../query-info.js'
 import type { RowResult } from '../row-query.js'
 import { rowQuery } from '../row-query.js'
-import { type DefaultSqliteTableDef, type TableDef, tableIsSingleton, type TableOptions } from '../schema/table-def.js'
 import { useStore } from './LiveStoreContext.js'
 import { useQueryRef } from './useQuery.js'
 import { useCleanup } from './utils/useCleanup.js'
 
-export type UseRowResult<TTableDef extends TableDef> = [
+export type UseRowResult<TTableDef extends DbSchema.TableDef> = [
   row: RowResult<TTableDef>,
   setRow: StateSetters<TTableDef>,
   query$: LiveQuery<RowResult<TTableDef>, QueryInfo>,
 ]
 
-export type UseRowOptionsDefaulValues<TTableDef extends TableDef> = {
+export type UseRowOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
   defaultValues?: Partial<RowResult<TTableDef>>
 }
 
@@ -37,17 +37,29 @@ export type UseRowOptionsBase = {
  * If the table is a singleton table, `useRow` can be called without an `id` argument. Otherwise, the `id` argument is required.
  */
 export const useRow: {
-  <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: true }>>(
+  <
+    TTableDef extends DbSchema.TableDef<
+      DbSchema.DefaultSqliteTableDef,
+      boolean,
+      DbSchema.TableOptions & { isSingleton: true }
+    >,
+  >(
     table: TTableDef,
     options?: UseRowOptionsBase,
   ): UseRowResult<TTableDef>
-  <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: false }>>(
+  <
+    TTableDef extends DbSchema.TableDef<
+      DbSchema.DefaultSqliteTableDef,
+      boolean,
+      DbSchema.TableOptions & { isSingleton: false }
+    >,
+  >(
     table: TTableDef,
     // TODO adjust so it works with arbitrary primary keys or unique constraints
     id: string,
     options?: UseRowOptionsBase & UseRowOptionsDefaulValues<TTableDef>,
   ): UseRowResult<TTableDef>
-} = <TTableDef extends TableDef>(
+} = <TTableDef extends DbSchema.TableDef>(
   table: TTableDef,
   idOrOptions?: string | UseRowOptionsBase,
   options_?: UseRowOptionsBase & UseRowOptionsDefaulValues<TTableDef>,
@@ -83,7 +95,7 @@ export const useRow: {
 
     const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
-    const query$ = tableIsSingleton(table)
+    const query$ = DbSchema.tableIsSingleton(table)
       ? (rowQuery(table, { otelContext, dbGraph }) as LiveQuery<RowResult<TTableDef>, QueryInfo>)
       : (rowQuery(table as TTableDef & { options: { isSingleton: false } }, id!, {
           otelContext,
@@ -160,7 +172,7 @@ export const useRow: {
 export type Dispatch<A> = (action: A) => void
 export type SetStateAction<S> = S | ((previousValue: S) => S)
 
-export type StateSetters<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
+export type StateSetters<TTableDef extends DbSchema.TableDef> = TTableDef['isSingleColumn'] extends true
   ? Dispatch<SetStateAction<RowResult<TTableDef>>>
   : {
       [K in keyof RowResult<TTableDef>]: Dispatch<SetStateAction<RowResult<TTableDef>[K]>>
@@ -171,7 +183,7 @@ export type StateSetters<TTableDef extends TableDef> = TTableDef['isSingleColumn
 /** Reference counted cache for `query$` and otel context */
 class RCCache {
   private readonly cache = new Map<
-    TableDef,
+    DbSchema.TableDef,
     Map<
       string,
       {
@@ -182,16 +194,16 @@ class RCCache {
       }
     >
   >()
-  private reverseCache = new Map<LiveQuery<any, any>, [TableDef, string]>()
+  private reverseCache = new Map<LiveQuery<any, any>, [DbSchema.TableDef, string]>()
 
-  get = (table: TableDef, id: string) => {
+  get = (table: DbSchema.TableDef, id: string) => {
     const queries = this.cache.get(table)
     if (queries === undefined) return undefined
     return queries.get(id)
   }
 
   set = (
-    table: TableDef,
+    table: DbSchema.TableDef,
     id: string,
     query$: LiveQuery<any, any>,
     reactId: string,

package/src/reactiveQueries/sql.test.ts

@@ -31,11 +31,19 @@ describe('otel', () => {
 
     const { store } = await makeTodoMvc({ otelTracer: tracer, otelContext })
 
-    return { store, tracer, exporter, span, provider }
+    return {
+      [Symbol.dispose]: () => store.destroy(),
+      store,
+      tracer,
+      exporter,
+      span,
+      provider,
+    }
   }
 
   it('otel', async () => {
-    const { store, exporter, span } = await makeQuery()
+    using inputs = await makeQuery()
+    const { store, exporter, span } = inputs
 
     const query = querySQL(`select * from todos`, { queriedTables: new Set(['todos']) })
     expect(query.run()).toMatchInlineSnapshot('[]')
@@ -73,20 +81,6 @@ describe('otel', () => {
           ",
             },
           },
-          {
-            "_name": "sql-in-memory-select",
-            "attributes": {
-              "sql.cached": false,
-              "sql.query": "SELECT * FROM __livestore_schema",
-              "sql.rowsCount": 0,
-            },
-          },
-          {
-            "_name": "livestore.in-memory-db:execute",
-            "attributes": {
-              "sql.query": "INSERT OR IGNORE INTO app (id, newTodoText, filter) VALUES ('static', '', 'all');",
-            },
-          },
           {
             "_name": "LiveStore:mutations",
             "children": [
@@ -170,7 +164,8 @@ describe('otel', () => {
   })
 
   it('with thunks', async () => {
-    const { store, exporter, span } = await makeQuery()
+    using inputs = await makeQuery()
+    const { store, exporter, span } = inputs
 
     const defaultTodo = { id: '', text: '', completed: false }
 
@@ -219,20 +214,6 @@ describe('otel', () => {
           ",
             },
           },
-          {
-            "_name": "sql-in-memory-select",
-            "attributes": {
-              "sql.cached": false,
-              "sql.query": "SELECT * FROM __livestore_schema",
-              "sql.rowsCount": 0,
-            },
-          },
-          {
-            "_name": "livestore.in-memory-db:execute",
-            "attributes": {
-              "sql.query": "INSERT OR IGNORE INTO app (id, newTodoText, filter) VALUES ('static', '', 'all');",
-            },
-          },
           {
             "_name": "LiveStore:mutations",
             "children": [

package/src/reactiveQueries/sql.ts

@@ -147,7 +147,7 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
             const sqlString = get(queryString$, otelContext)
 
             if (queriedTablesRef.current === undefined) {
-              queriedTablesRef.current = store.inMemoryDB.getTablesUsed(sqlString)
+              queriedTablesRef.current = store.mainDbWrapper.getTablesUsed(sqlString)
             }
 
             // Establish a reactive dependency on the tables used in the query
@@ -159,7 +159,7 @@ export class LiveStoreSQLQuery<TResult, TQueryInfo extends QueryInfo = QueryInfo
             span.setAttribute('sql.query', sqlString)
             span.updateName(`sql:${sqlString.slice(0, 50)}`)
 
-            const rawResults = store.inMemoryDB.select<any>(sqlString, {
+            const rawResults = store.mainDbWrapper.select<any>(sqlString, {
               queriedTables,
               bindValues: bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
               otelContext,

package/src/row-query.ts

@@ -1,26 +1,19 @@
+import { sql } from '@livestore/common'
+import { DbSchema, SCHEMA_META_TABLE } from '@livestore/common/schema'
 import { shouldNeverHappen } from '@livestore/utils'
 import { Schema, TreeFormatter } from '@livestore/utils/effect'
 import type * as otel from '@opentelemetry/api'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
-import { computed } from './index.js'
-import type { InMemoryDatabase } from './inMemoryDatabase.js'
 import { migrateTable } from './migrations.js'
 import type { QueryInfoCol, QueryInfoNone, QueryInfoRow } from './query-info.js'
 import type { Ref } from './reactive.js'
 import type { DbContext, DbGraph, LiveQuery, LiveQueryAny } from './reactiveQueries/base-class.js'
+import { computed } from './reactiveQueries/js.js'
 // import type { LiveStoreJSQuery } from './reactiveQueries/js.js'
 import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
-import { SCHEMA_META_TABLE } from './schema/index.js'
-import {
-  type DefaultSqliteTableDef,
-  getDefaultValuesEncoded,
-  type TableDef,
-  type TableOptions,
-} from './schema/table-def.js'
-import type { RefreshReason } from './store.js'
+import type { RefreshReason, Store } from './store.js'
 import type { GetValForKey } from './utils/util.js'
-import { prepareBindValues, sql } from './utils/util.js'
 
 export type RowQueryOptions = {
   otelContext?: otel.Context
@@ -28,16 +21,28 @@ export type RowQueryOptions = {
   dbGraph?: DbGraph
 }
 
-export type RowQueryOptionsDefaulValues<TTableDef extends TableDef> = {
+export type RowQueryOptionsDefaulValues<TTableDef extends DbSchema.TableDef> = {
   defaultValues: Partial<RowResult<TTableDef>>
 }
 
 export type MakeRowQuery = {
-  <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: true }>>(
+  <
+    TTableDef extends DbSchema.TableDef<
+      DbSchema.DefaultSqliteTableDef,
+      boolean,
+      DbSchema.TableOptions & { isSingleton: true }
+    >,
+  >(
     table: TTableDef,
     options?: RowQueryOptions,
   ): LiveQuery<RowResult<TTableDef>, QueryInfoRow<TTableDef>>
-  <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: false }>>(
+  <
+    TTableDef extends DbSchema.TableDef<
+      DbSchema.DefaultSqliteTableDef,
+      boolean,
+      DbSchema.TableOptions & { isSingleton: false }
+    >,
+  >(
     table: TTableDef,
     // TODO adjust so it works with arbitrary primary keys or unique constraints
     id: string,
@@ -46,7 +51,7 @@ export type MakeRowQuery = {
 }
 
 // TODO also allow other where clauses and multiple rows
-export const rowQuery: MakeRowQuery = <TTableDef extends TableDef>(
+export const rowQuery: MakeRowQuery = <TTableDef extends DbSchema.TableDef>(
   table: TTableDef,
   idOrOptions?: string | RowQueryOptions,
   options_?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
@@ -98,11 +103,11 @@ export const rowQuery: MakeRowQuery = <TTableDef extends TableDef>(
   })
 }
 
-export type RowResult<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
+export type RowResult<TTableDef extends DbSchema.TableDef> = TTableDef['isSingleColumn'] extends true
   ? GetValForKey<SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>, 'value'>
   : SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>
 
-export type RowResultEncoded<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
+export type RowResultEncoded<TTableDef extends DbSchema.TableDef> = TTableDef['isSingleColumn'] extends true
   ? GetValForKey<SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>, 'value'>
   : SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>
 
@@ -126,19 +131,19 @@ export const deriveColQuery: {
 }
 
 const insertRowWithDefaultValuesOrIgnore = ({
-  db,
+  store,
   id,
   table,
   otelContext,
   defaultValues: explicitDefaultValues,
 }: {
-  db: InMemoryDatabase
+  store: Store
   id: string
-  table: TableDef
+  table: DbSchema.TableDef
   otelContext: otel.Context
-  defaultValues: Partial<RowResult<TableDef>> | undefined
+  defaultValues: Partial<RowResult<DbSchema.TableDef>> | undefined
 }) => {
-  const defaultValues = getDefaultValuesEncoded(table, explicitDefaultValues)
+  const defaultValues = DbSchema.getDefaultValuesEncoded(table, explicitDefaultValues)
 
   const defaultColumnNames = [...Object.keys(defaultValues), 'id']
   const columnValues = defaultColumnNames.map((name) => `$${name}`).join(', ')
@@ -148,9 +153,7 @@ const insertRowWithDefaultValuesOrIgnore = ({
     ', ',
   )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = '${id}')`
 
-  db.execute(insertQuery, prepareBindValues({ ...defaultValues, id }, insertQuery), new Set([tableName]), {
-    otelContext,
-  })
+  store.execute(insertQuery, { ...defaultValues, id }, new Set([tableName]), otelContext)
 }
 
 const makeExecBeforeFirstRun =
@@ -167,7 +170,7 @@ const makeExecBeforeFirstRun =
     skipInsertDefaultRow?: boolean
     otelContext?: otel.Context
     componentTableName: string
-    table: TableDef
+    table: DbSchema.TableDef
   }) =>
   ({ store }: DbContext) => {
     const otelContext = otelContext_ ?? store.otel.queriesSpanContext
@@ -175,12 +178,12 @@ const makeExecBeforeFirstRun =
     // TODO find a better solution for this
     if (store.tableRefs[componentTableName] === undefined) {
       const schemaHash = SqliteAst.hash(table.sqliteDef.ast)
-      const res = store.inMemoryDB.select<{ schemaHash: number }>(
+      const res = store.mainDbWrapper.select<{ schemaHash: number }>(
         sql`SELECT schemaHash FROM ${SCHEMA_META_TABLE} WHERE tableName = '${componentTableName}'`,
       )
       if (res.length === 0 || res[0]!.schemaHash !== schemaHash) {
         migrateTable({
-          db: store._proxyDb,
+          db: store.db,
           tableAst: table.sqliteDef.ast,
           otelContext,
           schemaHash,
@@ -200,7 +203,7 @@ const makeExecBeforeFirstRun =
     if (skipInsertDefaultRow !== true) {
       // TODO find a way to only do this if necessary
       insertRowWithDefaultValuesOrIgnore({
-        db: store._proxyDb,
+        store,
         id: id ?? 'singleton',
         table,
         otelContext,