@livestore/common 0.3.0-dev.11 → 0.3.0-dev.2

package/src/init-singleton-tables.ts

@@ -1,9 +1,9 @@
-import type { SqliteDb } from './adapter-types.js'
+import type { SynchronousDatabase } from './adapter-types.js'
 import type { LiveStoreSchema } from './schema/mod.js'
 import { getDefaultValuesEncoded } from './schema/schema-helpers.js'
 import { prepareBindValues, sql } from './util.js'
 
-export const initializeSingletonTables = (schema: LiveStoreSchema, db: SqliteDb) => {
+export const initializeSingletonTables = (schema: LiveStoreSchema, db: SynchronousDatabase) => {
   for (const [, tableDef] of schema.tables) {
     if (tableDef.options.isSingleton) {
       const defaultValues = getDefaultValuesEncoded(tableDef, undefined)

package/src/leader-thread/apply-mutation.ts

@@ -2,26 +2,21 @@ import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
 import type { Scope } from '@livestore/utils/effect'
 import { Effect, Option, Schema } from '@livestore/utils/effect'
 
-import type { SqliteDb, SqliteError, UnexpectedError } from '../index.js'
-import { getExecArgsFromMutation } from '../mutation.js'
+import type { SqliteError, SynchronousDatabase, UnexpectedError } from '../index.js'
 import {
-  type LiveStoreSchema,
+  getExecArgsFromMutation,
   MUTATION_LOG_META_TABLE,
-  type MutationEvent,
   mutationLogMetaTable,
   SESSION_CHANGESET_META_TABLE,
   sessionChangesetMetaTable,
-} from '../schema/mod.js'
+} from '../index.js'
+import type { LiveStoreSchema, MutationEvent } from '../schema/mod.js'
 import { insertRow } from '../sql-queries/index.js'
 import { execSql, execSqlPrepared } from './connection.js'
 import { LeaderThreadCtx } from './types.js'
 
 export type ApplyMutation = (
   mutationEventEncoded: MutationEvent.AnyEncoded,
-  options?: {
-    /** Needed for rehydrateFromMutationLog */
-    skipMutationLog?: boolean
-  },
 ) => Effect.Effect<void, SqliteError | UnexpectedError>
 
 export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope | LeaderThreadCtx> = Effect.gen(
@@ -36,27 +31,15 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
       [...leaderThreadCtx.schema.mutations.entries()].map(([k, v]) => [k, Schema.hash(v.schema)] as const),
     )
 
-    return (mutationEventEncoded, options) =>
+    return (mutationEventEncoded) =>
       Effect.gen(function* () {
-        const { schema, dbReadModel: db, dbMutationLog } = leaderThreadCtx
-        const skipMutationLog = options?.skipMutationLog ?? false
+        const { mutationEventSchema, schema, db, dbLog } = leaderThreadCtx
+        const mutationEventDecoded = Schema.decodeUnknownSync(mutationEventSchema)(mutationEventEncoded)
 
-        const mutationName = mutationEventEncoded.mutation
+        const mutationName = mutationEventDecoded.mutation
         const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
 
-        const execArgsArr = getExecArgsFromMutation({
-          mutationDef,
-          mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },
-        })
-
-        // NOTE we might want to bring this back if we want to debug no-op mutations
-        // const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
-        //   onRowsChanged: (rowsChanged: number) => {
-        //     if (rowsChanged === 0) {
-        //       console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
-        //     }
-        //   },
-        // })
+        const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
         // console.group('[@livestore/common:leader-thread:applyMutation]', { mutationName })
 
@@ -70,29 +53,31 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
 
         const changeset = session.changeset()
         session.finish()
-
-        // TODO use prepared statements
-        yield* execSql(
-          db,
-          ...insertRow({
-            tableName: SESSION_CHANGESET_META_TABLE,
-            columns: sessionChangesetMetaTable.sqliteDef.columns,
-            values: {
-              idGlobal: mutationEventEncoded.id.global,
-              idLocal: mutationEventEncoded.id.local,
-              // NOTE the changeset will be empty (i.e. null) for no-op mutations
-              changeset: changeset ?? null,
-              debug: execArgsArr,
-            },
-          }),
-        )
+        // NOTE for no-op mutations (e.g. if the state didn't change) the changeset will be empty
+        // TODO possibly write a null value instead of omitting the row
+        if (changeset !== undefined && changeset.length > 0) {
+          // TODO use prepared statements
+          yield* execSql(
+            db,
+            ...insertRow({
+              tableName: SESSION_CHANGESET_META_TABLE,
+              columns: sessionChangesetMetaTable.sqliteDef.columns,
+              values: {
+                idGlobal: mutationEventEncoded.id.global,
+                idLocal: mutationEventEncoded.id.local,
+                changeset,
+                debug: execArgsArr,
+              },
+            }),
+          )
+        }
 
         // console.groupEnd()
 
         // write to mutation_log
-        const excludeFromMutationLog = shouldExcludeMutationFromLog(mutationName, mutationEventEncoded)
-        if (skipMutationLog === false && excludeFromMutationLog === false) {
-          yield* insertIntoMutationLog(mutationEventEncoded, dbMutationLog, mutationDefSchemaHashMap)
+        const excludeFromMutationLog = shouldExcludeMutationFromLog(mutationName, mutationEventDecoded)
+        if (excludeFromMutationLog === false) {
+          yield* insertIntoMutationLog(mutationEventEncoded, dbLog, mutationDefSchemaHashMap)
         } else {
           //   console.debug('[@livestore/common:leader-thread] skipping mutation log write', mutation, statementSql, bindValues)
         }
@@ -101,7 +86,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
           attributes: {
             mutationName: mutationEventEncoded.mutation,
             mutationId: mutationEventEncoded.id,
-            'span.label': `(${mutationEventEncoded.id.global},${mutationEventEncoded.id.local}) ${mutationEventEncoded.mutation}`,
+            'span.label': mutationEventEncoded.mutation,
           },
         }),
         // Effect.logDuration('@livestore/common:leader-thread:applyMutation'),
@@ -111,7 +96,7 @@ export const makeApplyMutation: Effect.Effect<ApplyMutation, never, Scope.Scope
 
 const insertIntoMutationLog = (
   mutationEventEncoded: MutationEvent.AnyEncoded,
-  dbMutationLog: SqliteDb,
+  dbLog: SynchronousDatabase,
   mutationDefSchemaHashMap: Map<string, number>,
 ) =>
   Effect.gen(function* () {
@@ -121,7 +106,7 @@ const insertIntoMutationLog = (
 
     // TODO use prepared statements
     yield* execSql(
-      dbMutationLog,
+      dbLog,
       ...insertRow({
         tableName: MUTATION_LOG_META_TABLE,
         columns: mutationLogMetaTable.sqliteDef.columns,
@@ -147,14 +132,11 @@ const makeShouldExcludeMutationFromLog = memoizeByRef((schema: LiveStoreSchema)
       ? (migrationOptions.excludeMutations ?? new Set(['livestore.RawSql']))
       : new Set(['livestore.RawSql'])
 
-  return (mutationName: string, mutationEventEncoded: MutationEvent.AnyEncoded): boolean => {
+  return (mutationName: string, mutationEventDecoded: MutationEvent.Any): boolean => {
     if (mutationLogExclude.has(mutationName)) return true
 
     const mutationDef = schema.mutations.get(mutationName) ?? shouldNeverHappen(`Unknown mutation: ${mutationName}`)
-    const execArgsArr = getExecArgsFromMutation({
-      mutationDef,
-      mutationEvent: { decoded: undefined, encoded: mutationEventEncoded },
-    })
+    const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
     return execArgsArr.some((_) => _.statementSql.includes('__livestore'))
   }

package/src/leader-thread/connection.ts

@@ -1,7 +1,7 @@
 // import type { WaSqlite } from '@livestore/sqlite-wasm'
 import { Effect } from '@livestore/utils/effect'
 
-import type { SqliteDb } from '../adapter-types.js'
+import type { SynchronousDatabase } from '../adapter-types.js'
 import { SqliteError } from '../adapter-types.js'
 import type { BindValues } from '../sql-queries/index.js'
 import type { PreparedBindValues } from '../util.js'
@@ -12,9 +12,9 @@ namespace WaSqlite {
   export type SQLiteError = any
 }
 
-export const configureConnection = (sqliteDb: SqliteDb, { fkEnabled }: { fkEnabled: boolean }) =>
+export const configureConnection = (syncDb: SynchronousDatabase, { fkEnabled }: { fkEnabled: boolean }) =>
   execSql(
-    sqliteDb,
+    syncDb,
     sql`
     PRAGMA page_size=8192;
     PRAGMA journal_mode=MEMORY;
@@ -23,10 +23,10 @@ export const configureConnection = (sqliteDb: SqliteDb, { fkEnabled }: { fkEnabl
     {},
   )
 
-export const execSql = (sqliteDb: SqliteDb, sql: string, bind: BindValues) => {
+export const execSql = (syncDb: SynchronousDatabase, sql: string, bind: BindValues) => {
   const bindValues = prepareBindValues(bind, sql)
   return Effect.try({
-    try: () => sqliteDb.execute(sql, bindValues),
+    try: () => syncDb.execute(sql, bindValues),
     catch: (cause) =>
       new SqliteError({ cause, query: { bindValues, sql }, code: (cause as WaSqlite.SQLiteError).code }),
   }).pipe(
@@ -48,9 +48,9 @@ export const execSql = (sqliteDb: SqliteDb, sql: string, bind: BindValues) => {
 // }
 
 // TODO actually use prepared statements
-export const execSqlPrepared = (sqliteDb: SqliteDb, sql: string, bindValues: PreparedBindValues) => {
+export const execSqlPrepared = (syncDb: SynchronousDatabase, sql: string, bindValues: PreparedBindValues) => {
   return Effect.try({
-    try: () => sqliteDb.execute(sql, bindValues),
+    try: () => syncDb.execute(sql, bindValues),
     catch: (cause) =>
       new SqliteError({ cause, query: { bindValues, sql }, code: (cause as WaSqlite.SQLiteError).code }),
   }).pipe(