@livestore/common 0.0.56-dev.2 → 0.0.56

package/src/adapter-types.ts

@@ -6,7 +6,7 @@ import type { LiveStoreSchema, MutationEvent } from './schema/index.js'
 import type { PreparedBindValues } from './util.js'
 
 export interface PreparedStatement {
-  execute(bindValues: PreparedBindValues | undefined): GetRowsChangedCount
+  execute(bindValues: PreparedBindValues | undefined, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
   select<T>(bindValues: PreparedBindValues | undefined): ReadonlyArray<T>
   finalize(): void
 }
@@ -21,7 +21,12 @@ export type StoreAdapter = {
 export type SynchronousDatabase = {
   _tag: 'SynchronousDatabase'
   prepare(queryStr: string): PreparedStatement
-  execute(queryStr: string, bindValues: PreparedBindValues | undefined): GetRowsChangedCount
+  execute(
+    queryStr: string,
+    bindValues?: PreparedBindValues | undefined,
+    options?: { onRowsChanged?: (rowsChanged: number) => void },
+  ): void
+  select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
   export(): Uint8Array
 }
 
@@ -62,18 +67,11 @@ export type Coordinator = {
   syncMutations: Stream.Stream<MutationEvent.AnyEncoded, UnexpectedError>
   execute(queryStr: string, bindValues: PreparedBindValues | undefined): Effect.Effect<void, UnexpectedError>
   mutate(mutationEventEncoded: MutationEvent.Any, options: { persisted: boolean }): Effect.Effect<void, UnexpectedError>
-  dangerouslyReset(mode: ResetMode): Effect.Effect<void, UnexpectedError>
   export: Effect.Effect<Uint8Array | undefined, UnexpectedError>
-  /**
-   * This is different from `export` since in `getInitialSnapshot` is usually the place for migrations etc to happen
-   */
-  getInitialSnapshot: Effect.Effect<Uint8Array, UnexpectedError>
   getMutationLogData: Effect.Effect<Uint8Array, UnexpectedError>
   networkStatus: SubscriptionRef.SubscriptionRef<NetworkStatus>
 }
 
-export type GetRowsChangedCount = () => number
-
 export type LockStatus = 'has-lock' | 'no-lock'
 
 export type BootDb = {
@@ -102,11 +100,22 @@ export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('Live
     )
 }
 
+export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
+  'LiveStore.IntentionalShutdownCause',
+  {
+    reason: Schema.Literal('devtools-reset', 'devtools-import'),
+  },
+) {}
+
 export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
-  sql: Schema.String,
-  bindValues: Schema.Record({ key: Schema.String, value: Schema.Any }),
+  query: Schema.optional(
+    Schema.Struct({
+      sql: Schema.String,
+      bindValues: Schema.Union(Schema.Record({ key: Schema.String, value: Schema.Any }), Schema.Array(Schema.Any)),
+    }),
+  ),
   /** The SQLite result code */
-  code: Schema.Number,
+  code: Schema.optional(Schema.Number),
   /** The original SQLite3 error */
   cause: Schema.Defect,
 }) {}

package/src/devtools/devtools-messages.ts

@@ -124,9 +124,14 @@ export class ResetAllDataRes extends LSDReqResMessage('LSD.ResetAllDataRes', {})
 
 export class DatabaseFileInfoReq extends LSDReqResMessage('LSD.DatabaseFileInfoReq', {}) {}
 
+export class DatabaseFileInfo extends Schema.Struct({
+  fileSize: Schema.Number,
+  persistenceInfo: Schema.Struct({ fileName: Schema.String }, { key: Schema.String, value: Schema.Any }),
+}) {}
+
 export class DatabaseFileInfoRes extends LSDReqResMessage('LSD.DatabaseFileInfoRes', {
-  dbFileSize: Schema.Number,
-  mutationLogFileSize: Schema.Number,
+  db: DatabaseFileInfo,
+  mutationLog: DatabaseFileInfo,
 }) {}
 
 export class MessagePortForStoreReq extends LSDReqResMessage('LSD.MessagePortForStoreReq', {}) {}

package/src/rehydrate-from-mutationlog.ts

@@ -1,12 +1,7 @@
 import { memoizeByRef, shouldNeverHappen } from '@livestore/utils'
 import { Chunk, Effect, Option, Schema, Stream } from '@livestore/utils/effect'
 
-import {
-  type MigrationOptionsFromMutationLog,
-  SqliteError,
-  type SynchronousDatabase,
-  UnexpectedError,
-} from './adapter-types.js'
+import { type MigrationOptionsFromMutationLog, type SynchronousDatabase, UnexpectedError } from './adapter-types.js'
 import { getExecArgsFromMutation } from './mutation.js'
 import type { LiveStoreSchema, MutationDef, MutationLogMetaRow } from './schema/index.js'
 import { MUTATION_LOG_META_TABLE } from './schema/index.js'
@@ -27,9 +22,9 @@ export const rehydrateFromMutationLog = ({
   onProgress: (_: { done: number; total: number }) => Effect.Effect<void>
 }) =>
   Effect.gen(function* () {
-    const mutationsCount = logDb
-      .prepare(`SELECT COUNT(*) AS count FROM ${MUTATION_LOG_META_TABLE}`)
-      .select<{ count: number }>(undefined)[0]!.count
+    const mutationsCount = logDb.select<{ count: number }>(
+      `SELECT COUNT(*) AS count FROM ${MUTATION_LOG_META_TABLE}`,
+    )[0]!.count
 
     const hashMutation = memoizeByRef((mutation: MutationDef.Any) => Schema.hash(mutation.schema))
 
@@ -63,36 +58,25 @@ This likely means the schema has changed in an incompatible way.
           mutation: row.mutation,
           args: argsDecoded,
         }
-        // const argsEncoded = JSON.parse(row.args_json)
-        // const mutationSqlRes =
-        //   typeof mutation.sql === 'string'
-        //     ? mutation.sql
-        //     : mutation.sql(Schema.decodeUnknownSync(mutation.schema)(argsEncoded))
-        // const mutationSql = typeof mutationSqlRes === 'string' ? mutationSqlRes : mutationSqlRes.sql
-        // const bindValues = typeof mutationSqlRes === 'string' ? argsEncoded : mutationSqlRes.bindValues
 
         const execArgsArr = getExecArgsFromMutation({ mutationDef, mutationEventDecoded })
 
-        for (const { statementSql, bindValues } of execArgsArr) {
-          try {
-            // TODO cache prepared statements for mutations
-            const getRowsChanged = db.execute(statementSql, bindValues)
-            if (
-              import.meta.env.DEV &&
-              getRowsChanged() === 0 &&
-              migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true
-            ) {
+        const makeExecuteOptions = (statementSql: string, bindValues: any) => ({
+          onRowsChanged: (rowsChanged: number) => {
+            if (rowsChanged === 0 && migrationOptions.logging?.excludeAffectedRows?.(statementSql) !== true) {
               console.warn(`Mutation "${mutationDef.name}" did not affect any rows:`, statementSql, bindValues)
             }
-            // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
-          } catch (e) {
-            yield* new SqliteError({
-              sql: statementSql,
-              bindValues,
-              code: (e as any).resultCode,
-              cause: e,
-            })
-          }
+          },
+        })
+
+        for (const { statementSql, bindValues } of execArgsArr) {
+          // TODO cache prepared statements for mutations
+          db.execute(
+            statementSql,
+            bindValues,
+            import.meta.env.DEV ? makeExecuteOptions(statementSql, bindValues) : undefined,
+          )
+          // console.log(`Re-executed mutation ${mutationSql}`, bindValues)
         }
       }).pipe(Effect.withSpan(`@livestore/common:rehydrateFromMutationLog:processMutation`))
 

package/src/schema/index.ts

@@ -39,6 +39,9 @@ export type LiveStoreSchema<
 
   migrationOptions: MigrationOptions
 
+  /**
+   * @default 'default'
+   */
   key: string
 }
 
@@ -47,9 +50,6 @@ export type InputSchema = {
   readonly mutations?: ReadonlyArray<MutationDef.Any> | Record<string, MutationDef.Any>
   /**
    * Can be used to isolate multiple LiveStore apps running in the same origin
-   *
-   * Make sure you also use this key in the `storage` options (e.g. directory, prefix etc) to make sure
-   * different instances of LiveStore aren't overlapping on the storage level.
    */
   readonly key?: string
 }
@@ -118,7 +118,7 @@ export const makeSchema = <TInputSchema extends InputSchema>(
     mutations,
     migrationOptions: inputSchema.migrations ?? { strategy: 'hard-reset' },
     hash,
-    key: inputSchema.key ?? '',
+    key: inputSchema.key ?? 'default',
   } satisfies LiveStoreSchema
 }
 

package/src/schema-management/common.ts

@@ -16,6 +16,8 @@ export const dbExecute = (db: SynchronousDatabase, queryStr: string, bindValues?
   const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
 
   stmt.execute(preparedBindValues)
+
+  stmt.finalize()
 }
 
 export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValues?: ParamsObject) => {
@@ -25,7 +27,9 @@ export const dbSelect = <T>(db: SynchronousDatabase, queryStr: string, bindValue
   // cachedStmts.set(queryStr, stmt)
   // }
 
-  return stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
+  const res = stmt.select<T>(bindValues ? prepareBindValues(bindValues, queryStr) : undefined)
+  stmt.finalize()
+  return res
 }
 
 export interface SchemaManager {

package/src/schema-management/migrations.ts

@@ -28,14 +28,9 @@ export const makeSchemaManager = (db: SynchronousDatabase): Effect.Effect<Schema
     })
 
     return {
-      getMutationDefInfos: () => {
-        const schemaMutationsMetaRows = dbSelect<SchemaMutationsMetaRow>(
-          db,
-          sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`,
-        )
+      getMutationDefInfos: () =>
+        dbSelect<SchemaMutationsMetaRow>(db, sql`SELECT * FROM ${SCHEMA_MUTATIONS_META_TABLE}`),
 
-        return schemaMutationsMetaRows
-      },
       setMutationDefInfo: (info) => {
         dbExecute(
           db,
@@ -128,7 +123,7 @@ export const migrateTable = ({
   skipMetaTable?: boolean
 }) =>
   Effect.gen(function* () {
-    console.log(`Migrating table '${tableAst.name}'...`)
+    // console.log(`Migrating table '${tableAst.name}'...`)
     const tableName = tableAst.name
     const columnSpec = makeColumnSpec(tableAst)