@livestore/common 0.3.2-dev.10 → 0.3.2-dev.11

package/src/schema/state/sqlite/client-document-def.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, test } from 'vitest'
 
 import { tables } from '../../../__tests__/fixture.ts'
 import type * as LiveStoreEvent from '../../LiveStoreEvent.ts'
-import { ClientDocumentTableDefSymbol, clientDocument } from './client-document-def.ts'
+import { ClientDocumentTableDefSymbol, clientDocument, mergeDefaultValues } from './client-document-def.ts'
 
 describe('client document table', () => {
   test('set event', () => {
@@ -238,3 +238,91 @@ const patchId = (muationEvent: LiveStoreEvent.PartialAnyDecoded) => {
   const id = `00000000-0000-0000-0000-000000000000`
   return { ...muationEvent, id }
 }
+
+describe('mergeDefaultValues', () => {
+  test('merges values from both objects', () => {
+    const defaults = { a: 1, b: 2 }
+    const explicit = { a: 10, b: 20 }
+    const result = mergeDefaultValues(defaults, explicit)
+
+    expect(result).toEqual({ a: 10, b: 20 })
+  })
+
+  test('uses default values when explicit values are undefined', () => {
+    const defaults = { a: 1, b: 2 }
+    const explicit = { a: undefined, b: 20 } as any
+    const result = mergeDefaultValues(defaults, explicit)
+
+    expect(result).toEqual({ a: 1, b: 20 })
+  })
+
+  test('should preserve properties that are not in default values', () => {
+    const defaults = { a: 1, b: 2 }
+    const explicit = { a: 10, b: 20, c: 30 }
+    const result = mergeDefaultValues(defaults, explicit)
+
+    // Should include ALL properties from explicit, not just those in defaults
+    expect(result).toEqual({ a: 10, b: 20, c: 30 })
+    expect('c' in result).toBe(true)
+  })
+
+  test('issue #487 - should preserve optional fields not in defaults', () => {
+    const defaults = {
+      newTodoText: '',
+      filter: 'all' as const,
+    }
+    const userSet = {
+      newTodoText: '',
+      description: 'First attempt', // Optional field not in defaults
+      filter: 'all' as const,
+    }
+    const result = mergeDefaultValues(defaults, userSet)
+
+    // Should include the description field even though it's not in defaults
+    expect(result).toEqual({
+      newTodoText: '',
+      description: 'First attempt',
+      filter: 'all',
+    })
+    expect('description' in result).toBe(true)
+  })
+
+  test('handles non-object values', () => {
+    expect(mergeDefaultValues('default', 'explicit')).toBe('explicit')
+    expect(mergeDefaultValues(42, 100)).toBe(100)
+    expect(mergeDefaultValues(null, { a: 1 })).toEqual({ a: 1 })
+    expect(mergeDefaultValues({ a: 1 }, null)).toBe(null)
+  })
+
+  test('handles nested objects (current implementation does not deep merge)', () => {
+    const defaults = { a: { x: 1, y: 2 }, b: 3 }
+    const explicit = { a: { x: 10 }, b: 30 } as any
+    const result = mergeDefaultValues(defaults, explicit)
+
+    // Current implementation replaces entire nested object
+    expect(result).toEqual({ a: { x: 10 }, b: 30 })
+    // Note: 'y' is lost because the entire 'a' object is replaced
+  })
+
+  test('should handle mix of default and new properties', () => {
+    const defaults = {
+      required1: 'default1',
+      required2: 'default2',
+    }
+    const userSet = {
+      required1: 'user1', // Override default
+      required2: 'default2', // Keep default
+      optional1: 'new1', // New field
+      optional2: 'new2', // New field
+    }
+    const result = mergeDefaultValues(defaults, userSet)
+
+    expect(result).toEqual({
+      required1: 'user1',
+      required2: 'default2',
+      optional1: 'new1',
+      optional2: 'new2',
+    })
+    expect(Object.keys(result).sort()).toEqual(['optional1', 'optional2', 'required1', 'required2'])
+  })
+})

package/src/schema/state/sqlite/client-document-def.ts

@@ -121,7 +121,7 @@ export const clientDocument = <
   return clientDocumentTableDef
 }
 
-const mergeDefaultValues = <T>(defaultValues: T, explicitDefaultValues: T): T => {
+export const mergeDefaultValues = <T>(defaultValues: T, explicitDefaultValues: T): T => {
   if (
     typeof defaultValues !== 'object' ||
     typeof explicitDefaultValues !== 'object' ||
@@ -131,7 +131,10 @@ const mergeDefaultValues = <T>(defaultValues: T, explicitDefaultValues: T): T =>
     return explicitDefaultValues
   }
 
-  return Object.keys(defaultValues as any).reduce((acc, key) => {
+  // Get all unique keys from both objects
+  const allKeys = new Set([...Object.keys(defaultValues as any), ...Object.keys(explicitDefaultValues as any)])
+
+  return Array.from(allKeys).reduce((acc, key) => {
     acc[key] = (explicitDefaultValues as any)[key] ?? (defaultValues as any)[key]
     return acc
   }, {} as any)

package/src/schema/state/sqlite/query-builder/api.ts

@@ -122,7 +122,7 @@ export type QueryBuilder<
   readonly [QueryBuilderTypeId]: QueryBuilderTypeId
   readonly [QueryBuilderAstSymbol]: QueryBuilderAst
   readonly ResultType: TResult
-  readonly asSql: () => { query: string; bindValues: SqlValue[] }
+  readonly asSql: () => { query: string; bindValues: SqlValue[]; usedTables: Set<string> }
   readonly toString: () => string
 } & Omit<QueryBuilder.ApiFull<TResult, TTableDef, TWithout>, TWithout>
 
@@ -264,14 +264,15 @@ export namespace QueryBuilder {
      * Example:
      * ```ts
      * db.todos.orderBy('createdAt', 'desc')
+     * db.todos.orderBy([{ col: 'createdAt', direction: 'desc' }])
      * ```
      */
     readonly orderBy: {
-      <TColName extends keyof TTableDef['sqliteDef']['columns'] & string>(
+      <const TColName extends keyof TTableDef['sqliteDef']['columns'] & string>(
         col: TColName,
         direction: 'asc' | 'desc',
       ): QueryBuilder<TResult, TTableDef, TWithout | 'returning' | 'onConflict'>
-      <TParams extends QueryBuilder.OrderByParams<TTableDef>>(
+      <const TParams extends QueryBuilder.OrderByParams<TTableDef>>(
         params: TParams,
       ): QueryBuilder<TResult, TTableDef, TWithout | 'returning' | 'onConflict'>
     }

package/src/schema/state/sqlite/query-builder/astToSql.ts

@@ -65,8 +65,9 @@ const formatReturningClause = (returning?: string[]): string => {
   return ` RETURNING ${returning.join(', ')}`
 }
 
-export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: SqlValue[] } => {
+export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: SqlValue[]; usedTables: Set<string> } => {
   const bindValues: SqlValue[] = []
+  const usedTables = new Set<string>([ast.tableDef.sqliteDef.name])
 
   // INSERT query
   if (ast._tag === 'InsertQuery') {
@@ -134,7 +135,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     query += conflictClause
 
     query += formatReturningClause(ast.returning)
-    return { query, bindValues }
+    return { query, bindValues, usedTables }
   }
 
   // UPDATE query
@@ -145,7 +146,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
       console.warn(
         `UPDATE query requires at least one column to set (for table ${ast.tableDef.sqliteDef.name}). Running no-op query instead to skip this update query.`,
       )
-      return { query: 'SELECT 1', bindValues: [] }
+      return { query: 'SELECT 1', bindValues: [], usedTables }
       // return shouldNeverHappen('UPDATE query requires at least one column to set.')
     }
 
@@ -162,7 +163,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     if (whereClause) query += ` ${whereClause}`
 
     query += formatReturningClause(ast.returning)
-    return { query, bindValues }
+    return { query, bindValues, usedTables }
   }
 
   // DELETE query
@@ -173,7 +174,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     if (whereClause) query += ` ${whereClause}`
 
     query += formatReturningClause(ast.returning)
-    return { query, bindValues }
+    return { query, bindValues, usedTables }
   }
 
   // COUNT query
@@ -185,7 +186,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
       .filter((clause) => clause.length > 0)
       .join(' ')
 
-    return { query, bindValues }
+    return { query, bindValues, usedTables }
   }
 
   // ROW query
@@ -202,6 +203,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     return {
       query: `SELECT * FROM '${ast.tableDef.sqliteDef.name}' WHERE id = ?`,
       bindValues: [encodedId as SqlValue],
+      usedTables,
     }
   }
 
@@ -228,5 +230,5 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     .filter((clause) => clause.length > 0)
     .join(' ')
 
-  return { query, bindValues }
+  return { query, bindValues, usedTables }
 }

package/src/schema-management/common.ts

@@ -1,4 +1,4 @@
-import type { SqliteDb } from '../adapter-types.ts'
+import { type SqliteDb, SqliteError } from '../adapter-types.ts'
 import type { ParamsObject } from '../util.ts'
 import { prepareBindValues } from '../util.ts'
 
@@ -15,9 +15,16 @@ export const dbExecute = (db: SqliteDb, queryStr: string, bindValues?: ParamsObj
 
   const preparedBindValues = bindValues ? prepareBindValues(bindValues, queryStr) : undefined
 
-  stmt.execute(preparedBindValues)
+  try {
+    stmt.execute(preparedBindValues)
 
-  stmt.finalize()
+    stmt.finalize()
+  } catch (cause) {
+    throw new SqliteError({
+      cause,
+      query: { sql: queryStr, bindValues: preparedBindValues ?? {} },
+    })
+  }
 }
 
 export const dbSelect = <T>(db: SqliteDb, queryStr: string, bindValues?: ParamsObject) => {

package/src/schema-management/migrations.test.ts

@@ -0,0 +1,65 @@
+import { Option, Schema } from '@livestore/utils/effect'
+import { describe, expect, it } from 'vitest'
+import type { SqliteAst } from '../schema/state/sqlite/db-schema/mod.ts'
+import { makeColumnSpec } from './migrations.js'
+
+const createColumn = (
+  name: string,
+  type: 'text' | 'integer',
+  options: { nullable?: boolean; primaryKey?: boolean } = {},
+) => ({
+  _tag: 'column' as const,
+  name,
+  type: { _tag: type },
+  nullable: options.nullable ?? true,
+  primaryKey: options.primaryKey ?? false,
+  default: Option.none(),
+  schema: type === 'text' ? Schema.String : Schema.Number,
+})
+
+describe('makeColumnSpec', () => {
+  it('should quote column names properly for reserved keywords', () => {
+    const table: SqliteAst.Table = {
+      _tag: 'table',
+      name: 'blocks',
+      columns: [createColumn('order', 'integer', { nullable: false }), createColumn('group', 'text')],
+      indexes: [],
+    }
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(`"'order' integer not null , 'group' text  "`)
+    expect(result).toContain("'order'")
+    expect(result).toContain("'group'")
+  })
+
+  it('should handle basic columns with primary keys', () => {
+    const table: SqliteAst.Table = {
+      _tag: 'table',
+      name: 'users',
+      columns: [createColumn('id', 'text', { nullable: false, primaryKey: true }), createColumn('name', 'text')],
+      indexes: [],
+    }
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(`"'id' text not null , 'name' text  , PRIMARY KEY ('id')"`)
+    expect(result).toContain("PRIMARY KEY ('id')")
+  })
+
+  it('should handle multi-column primary keys', () => {
+    const table: SqliteAst.Table = {
+      _tag: 'table',
+      name: 'composite',
+      columns: [
+        createColumn('tenant_id', 'text', { nullable: false, primaryKey: true }),
+        createColumn('user_id', 'text', { nullable: false, primaryKey: true }),
+      ],
+      indexes: [],
+    }
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(
+      `"'tenant_id' text not null , 'user_id' text not null , PRIMARY KEY ('tenant_id', 'user_id')"`,
+    )
+    expect(result).toContain("PRIMARY KEY ('tenant_id', 'user_id')")
+  })
+})

package/src/schema-management/migrations.ts

@@ -169,7 +169,7 @@ export const migrateTable = ({
 
 const createIndexFromDefinition = (tableName: string, index: SqliteAst.Index) => {
   const uniqueStr = index.unique ? 'UNIQUE' : ''
-  return sql`create ${uniqueStr} index if not exists '${index.name}' on '${tableName}' (${index.columns.join(', ')})`
+  return sql`create ${uniqueStr} index if not exists '${index.name}' on '${tableName}' (${index.columns.map((col) => `'${col}'`).join(', ')})`
 }
 
 export const makeColumnSpec = (tableAst: SqliteAst.Table) => {

package/src/sync/ClientSessionSyncProcessor.ts

@@ -3,6 +3,7 @@ import { LS_DEV, shouldNeverHappen, TRACE_VERBOSE } from '@livestore/utils'
 import {
   BucketQueue,
   Effect,
+  Exit,
   FiberHandle,
   Option,
   Queue,
@@ -316,7 +317,7 @@ export const makeClientSessionSyncProcessor = ({
           refreshTables(writeTables)
         }).pipe(
           Effect.tapCauseLogPretty,
-          Effect.catchAllCause((cause) => clientSession.shutdown(cause)),
+          Effect.catchAllCause((cause) => clientSession.shutdown(Exit.failCause(cause))),
         ),
       ),
       Stream.runDrain,
@@ -381,13 +382,14 @@ export interface ClientSessionSyncProcessor {
 // TODO turn this into a build-time "macro" so all simulation snippets are removed for production builds
 const SIMULATION_ENABLED = true
 
+// Warning: High values for the simulation params can lead to very long test runs since those get multiplied with the number of events
 export const ClientSessionSyncProcessorSimulationParams = Schema.Struct({
   pull: Schema.Struct({
-    '1_before_leader_push_fiber_interrupt': Schema.Int.pipe(Schema.between(0, 1000)),
-    '2_before_leader_push_queue_clear': Schema.Int.pipe(Schema.between(0, 1000)),
-    '3_before_rebase_rollback': Schema.Int.pipe(Schema.between(0, 1000)),
-    '4_before_leader_push_queue_offer': Schema.Int.pipe(Schema.between(0, 1000)),
-    '5_before_leader_push_fiber_run': Schema.Int.pipe(Schema.between(0, 1000)),
+    '1_before_leader_push_fiber_interrupt': Schema.Int.pipe(Schema.between(0, 25)),
+    '2_before_leader_push_queue_clear': Schema.Int.pipe(Schema.between(0, 25)),
+    '3_before_rebase_rollback': Schema.Int.pipe(Schema.between(0, 25)),
+    '4_before_leader_push_queue_offer': Schema.Int.pipe(Schema.between(0, 25)),
+    '5_before_leader_push_fiber_run': Schema.Int.pipe(Schema.between(0, 25)),
   }),
 })
 type ClientSessionSyncProcessorSimulationParams = typeof ClientSessionSyncProcessorSimulationParams.Type

package/src/sync/sync.ts

@@ -31,6 +31,7 @@ export type SyncOptions = {
   onSyncError?: 'shutdown' | 'ignore'
 }
 
+// TODO rename to `SyncProviderClientConstructor`
 export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue> = (
   args: MakeBackendArgs,
 ) => Effect.Effect<SyncBackend<TSyncMetadata>, UnexpectedError, Scope.Scope | HttpClient.HttpClient>
@@ -41,6 +42,7 @@ export type SyncBackendConstructor<TSyncMetadata = Schema.JsonValue> = (
 // - dynamic sync backend data;
 //   - data center location (e.g. colo on CF workers)
 
+// TODO rename to `SyncProviderClient`
 export type SyncBackend<TSyncMetadata = Schema.JsonValue> = {
   /**
    * Can be implemented to prepare a connection to the sync backend to speed up the first pull/push.

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.3.2-dev.10' as const
+export const liveStoreVersion = '0.3.2-dev.11' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.