@livestore/common 0.3.1 → 0.3.2-dev.0

package/src/schema/EventSequenceNumber.test.ts

@@ -4,9 +4,126 @@ import { expect } from 'vitest'
 import { EventSequenceNumber } from './mod.js'
 
 Vitest.describe('EventSequenceNumber', () => {
-  Vitest.test('nextPair', () => {
+  Vitest.test('nextPair (no rebase)', () => {
     const e_0_0 = EventSequenceNumber.make({ global: 0, client: 0 })
-    expect(EventSequenceNumber.nextPair(e_0_0, false).seqNum).toStrictEqual({ global: 1, client: 0 })
-    expect(EventSequenceNumber.nextPair(e_0_0, true).seqNum).toStrictEqual({ global: 0, client: 1 })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: false }).seqNum).toStrictEqual({
+      global: 1,
+      client: 0,
+      rebaseGeneration: 0,
+    })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: true }).seqNum).toStrictEqual({
+      global: 0,
+      client: 1,
+      rebaseGeneration: 0,
+    })
+  })
+
+  Vitest.test('nextPair (rebase)', () => {
+    const e_0_0 = EventSequenceNumber.make({ global: 0, client: 0 })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: false, rebaseGeneration: 1 }).seqNum).toStrictEqual({
+      global: 1,
+      client: 0,
+      rebaseGeneration: 1,
+    })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0, isClient: true, rebaseGeneration: 1 }).seqNum).toStrictEqual({
+      global: 0,
+      client: 1,
+      rebaseGeneration: 1,
+    })
+
+    const e_0_0_g1 = EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 2 })
+    expect(EventSequenceNumber.nextPair({ seqNum: e_0_0_g1, isClient: false }).seqNum).toStrictEqual({
+      global: 1,
+      client: 0,
+      rebaseGeneration: 2,
+    })
+  })
+
+  Vitest.test('toString', () => {
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 0 }))).toBe('e0')
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 1 }))).toBe(
+      'e0r1',
+    )
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 1 }))).toBe('e0+1')
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 1 }))).toBe(
+      'e0+1r1',
+    )
+    expect(EventSequenceNumber.toString(EventSequenceNumber.make({ global: 5, client: 3, rebaseGeneration: 2 }))).toBe(
+      'e5+3r2',
+    )
+  })
+
+  Vitest.test('fromString', () => {
+    // Basic cases
+    expect(EventSequenceNumber.fromString('e0')).toStrictEqual(EventSequenceNumber.make({ global: 0, client: 0 }))
+    expect(EventSequenceNumber.fromString('e0r1')).toStrictEqual(
+      EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 1 }),
+    )
+    expect(EventSequenceNumber.fromString('e0+1')).toStrictEqual(EventSequenceNumber.make({ global: 0, client: 1 }))
+    expect(EventSequenceNumber.fromString('e0+1r1')).toStrictEqual(
+      EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 1 }),
+    )
+    expect(EventSequenceNumber.fromString('e5+3r2')).toStrictEqual(
+      EventSequenceNumber.make({ global: 5, client: 3, rebaseGeneration: 2 }),
+    )
+
+    // Error cases
+    expect(() => EventSequenceNumber.fromString('0')).toThrow(
+      'Invalid event sequence number string: must start with "e"',
+    )
+    expect(() => EventSequenceNumber.fromString('eabc')).toThrow(
+      'Invalid event sequence number string: invalid number format',
+    )
+    expect(() => EventSequenceNumber.fromString('e0+abc')).toThrow(
+      'Invalid event sequence number string: invalid number format',
+    )
+    expect(() => EventSequenceNumber.fromString('e0rabc')).toThrow(
+      'Invalid event sequence number string: invalid number format',
+    )
+  })
+
+  Vitest.test('toString/fromString roundtrip', () => {
+    const testCases = [
+      { global: 0, client: 0, rebaseGeneration: 0 },
+      { global: 0, client: 0, rebaseGeneration: 1 },
+      { global: 0, client: 1, rebaseGeneration: 0 },
+      { global: 0, client: 1, rebaseGeneration: 1 },
+      { global: 5, client: 3, rebaseGeneration: 2 },
+      { global: 100, client: 50, rebaseGeneration: 10 },
+    ]
+
+    for (const testCase of testCases) {
+      const original = EventSequenceNumber.make(testCase)
+      const str = EventSequenceNumber.toString(original)
+      const parsed = EventSequenceNumber.fromString(str)
+      expect(parsed).toStrictEqual(original)
+    }
+  })
+
+  Vitest.test('compare', () => {
+    const e_0_0_r0 = EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 0 })
+    const e_0_0_r1 = EventSequenceNumber.make({ global: 0, client: 0, rebaseGeneration: 1 })
+    const e_0_1_r0 = EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 0 })
+    const e_0_1_r1 = EventSequenceNumber.make({ global: 0, client: 1, rebaseGeneration: 1 })
+    const e_1_0_r0 = EventSequenceNumber.make({ global: 1, client: 0, rebaseGeneration: 0 })
+    const e_1_1_r0 = EventSequenceNumber.make({ global: 1, client: 1, rebaseGeneration: 0 })
+
+    // Global comparison (strongest level)
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_1_0_r0)).toBeLessThan(0)
+    expect(EventSequenceNumber.compare(e_1_0_r0, e_0_0_r0)).toBeGreaterThan(0)
+    expect(EventSequenceNumber.compare(e_0_1_r1, e_1_0_r0)).toBeLessThan(0) // global overrides client and rebase
+
+    // Client comparison (second level)
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_0_1_r0)).toBeLessThan(0)
+    expect(EventSequenceNumber.compare(e_0_1_r0, e_0_0_r0)).toBeGreaterThan(0)
+    expect(EventSequenceNumber.compare(e_0_0_r1, e_0_1_r0)).toBeLessThan(0) // client overrides rebase
+
+    // Rebase generation comparison (weakest level)
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_0_0_r1)).toBeLessThan(0)
+    expect(EventSequenceNumber.compare(e_0_0_r1, e_0_0_r0)).toBeGreaterThan(0)
+
+    // Equal comparison
+    expect(EventSequenceNumber.compare(e_0_0_r0, e_0_0_r0)).toBe(0)
+    expect(EventSequenceNumber.compare(e_1_1_r0, e_1_1_r0)).toBe(0)
   })
 })

package/src/schema/EventSequenceNumber.ts

@@ -10,6 +10,8 @@ export const GlobalEventSequenceNumber = Schema.fromBrand(globalEventSequenceNum
 
 export const clientDefault = 0 as any as ClientEventSequenceNumber
 
+export const rebaseGenerationDefault = 0
+
 /**
  * LiveStore event sequence number value consisting of a globally unique event sequence number
  * and a client sequence number.
@@ -20,16 +22,17 @@ export type EventSequenceNumber = {
   global: GlobalEventSequenceNumber
   client: ClientEventSequenceNumber
   /**
-   * TODO add generation number in favour of LEADER_MERGE_COUNTER_TABLE
+   * Generation integer that is incremented whenever the client rebased.
+   * Starts from and resets to 0 for each global sequence number.
    */
-  // generation: number
+  rebaseGeneration: number
 }
 
-// export const EventSequenceNumber = Schema.Struct({})
-// export const EventSequenceNumber = Schema.Struct({})
-// export const ClientEventSequenceNumber = Schema.Struct({})
-// export const GlobalEventSequenceNumber = Schema.Struct({})
+export type EventSequenceNumberInput =
+  | EventSequenceNumber
+  | (Omit<typeof EventSequenceNumber.Encoded, 'rebaseGeneration'> & { rebaseGeneration?: number })
 
+// TODO adjust name to `ClientEventSequenceNumber`
 /**
  * NOTE: Client mutation events with a non-0 client id, won't be synced to the sync backend.
  */
@@ -40,36 +43,83 @@ export const EventSequenceNumber = Schema.Struct({
 
   // TODO also provide a way to see "confirmation level" of event (e.g. confirmed by leader/sync backend)
 
-  // TODO: actually add this field
   // Client only
-  // generation: Schema.Number.pipe(Schema.optional),
-}).annotations({ title: 'LiveStore.EventSequenceNumber' })
+  rebaseGeneration: Schema.Int,
+}).annotations({
+  title: 'LiveStore.EventSequenceNumber',
+  pretty: () => (seqNum) => toString(seqNum),
+})
 
 /**
  * Compare two event sequence numbers i.e. checks if the first event sequence number is less than the second.
+ * Comparison hierarchy: global > client > rebaseGeneration
  */
 export const compare = (a: EventSequenceNumber, b: EventSequenceNumber) => {
   if (a.global !== b.global) {
     return a.global - b.global
   }
-  return a.client - b.client
+  if (a.client !== b.client) {
+    return a.client - b.client
+  }
+  return a.rebaseGeneration - b.rebaseGeneration
 }
 
 /**
  * Convert an event sequence number to a string representation.
  */
-export const toString = (seqNum: EventSequenceNumber) =>
-  seqNum.client === 0 ? `e${seqNum.global}` : `e${seqNum.global}+${seqNum.client}`
+export const toString = (seqNum: EventSequenceNumber) => {
+  const rebaseGenerationStr = seqNum.rebaseGeneration > 0 ? `r${seqNum.rebaseGeneration}` : ''
+  return seqNum.client === 0
+    ? `e${seqNum.global}${rebaseGenerationStr}`
+    : `e${seqNum.global}+${seqNum.client}${rebaseGenerationStr}`
+}
 
 /**
  * Convert a string representation of an event sequence number to an event sequence number.
+ * Parses strings in the format: e{global}[+{client}][r{rebaseGeneration}]
+ * Examples: "e0", "e0r1", "e0+1", "e0+1r1"
  */
 export const fromString = (str: string): EventSequenceNumber => {
-  const [global, client] = str.slice(1, -1).split(',').map(Number)
-  if (global === undefined || client === undefined) {
-    throw new Error('Invalid event sequence number string')
+  if (!str.startsWith('e')) {
+    throw new Error('Invalid event sequence number string: must start with "e"')
+  }
+
+  // Remove the 'e' prefix
+  const remaining = str.slice(1)
+
+  // Parse rebase generation if present
+  let rebaseGeneration = rebaseGenerationDefault
+  let withoutRebase = remaining
+  const rebaseMatch = remaining.match(/r(\d+)$/)
+  if (rebaseMatch !== null) {
+    rebaseGeneration = Number.parseInt(rebaseMatch[1]!, 10)
+    withoutRebase = remaining.slice(0, -rebaseMatch[0].length)
+  }
+
+  // Parse global and client parts
+  const parts = withoutRebase.split('+')
+
+  // Validate that parts contain only digits (and possibly empty for client)
+  if (parts[0] === '' || !/^\d+$/.test(parts[0]!)) {
+    throw new Error('Invalid event sequence number string: invalid number format')
+  }
+
+  if (parts.length > 1 && parts[1] !== undefined && (parts[1] === '' || !/^\d+$/.test(parts[1]))) {
+    throw new Error('Invalid event sequence number string: invalid number format')
+  }
+
+  const global = Number.parseInt(parts[0]!, 10)
+  const client = parts.length > 1 && parts[1] !== undefined ? Number.parseInt(parts[1], 10) : 0
+
+  if (Number.isNaN(global) || Number.isNaN(client) || Number.isNaN(rebaseGeneration)) {
+    throw new TypeError('Invalid event sequence number string: invalid number format')
+  }
+
+  return {
+    global: global as any as GlobalEventSequenceNumber,
+    client: client as any as ClientEventSequenceNumber,
+    rebaseGeneration,
   }
-  return { global, client } as EventSequenceNumber
 }
 
 export const isEqual = (a: EventSequenceNumber, b: EventSequenceNumber) =>
@@ -80,6 +130,7 @@ export type EventSequenceNumberPair = { seqNum: EventSequenceNumber; parentSeqNu
 export const ROOT = {
   global: 0 as any as GlobalEventSequenceNumber,
   client: clientDefault,
+  rebaseGeneration: rebaseGenerationDefault,
 } satisfies EventSequenceNumber
 
 export const isGreaterThan = (a: EventSequenceNumber, b: EventSequenceNumber) => {
@@ -101,21 +152,42 @@ export const diff = (a: EventSequenceNumber, b: EventSequenceNumber) => {
   }
 }
 
-export const make = (seqNum: EventSequenceNumber | typeof EventSequenceNumber.Encoded): EventSequenceNumber => {
-  return Schema.is(EventSequenceNumber)(seqNum) ? seqNum : Schema.decodeSync(EventSequenceNumber)(seqNum)
+export const make = (seqNum: EventSequenceNumberInput): EventSequenceNumber => {
+  return Schema.is(EventSequenceNumber)(seqNum)
+    ? seqNum
+    : Schema.decodeSync(EventSequenceNumber)({
+        ...seqNum,
+        rebaseGeneration: seqNum.rebaseGeneration ?? rebaseGenerationDefault,
+      })
 }
 
-export const nextPair = (seqNum: EventSequenceNumber, isLocal: boolean): EventSequenceNumberPair => {
-  if (isLocal) {
+export const nextPair = ({
+  seqNum,
+  isClient,
+  rebaseGeneration,
+}: {
+  seqNum: EventSequenceNumber
+  isClient: boolean
+  rebaseGeneration?: number
+}): EventSequenceNumberPair => {
+  if (isClient) {
     return {
-      seqNum: { global: seqNum.global, client: (seqNum.client + 1) as any as ClientEventSequenceNumber },
+      seqNum: {
+        global: seqNum.global,
+        client: (seqNum.client + 1) as any as ClientEventSequenceNumber,
+        rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
+      },
       parentSeqNum: seqNum,
     }
   }
 
   return {
-    seqNum: { global: (seqNum.global + 1) as any as GlobalEventSequenceNumber, client: clientDefault },
+    seqNum: {
+      global: (seqNum.global + 1) as any as GlobalEventSequenceNumber,
+      client: clientDefault,
+      rebaseGeneration: rebaseGeneration ?? seqNum.rebaseGeneration,
+    },
     // NOTE we always point to `client: 0` for non-clientOnly events
-    parentSeqNum: { global: seqNum.global, client: clientDefault },
+    parentSeqNum: { global: seqNum.global, client: clientDefault, rebaseGeneration: seqNum.rebaseGeneration },
   }
 }

package/src/schema/LiveStoreEvent.ts

@@ -221,10 +221,18 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEve
    *          +---- global number
    * Client num is ommitted for global events
    */
-  rebase = (parentSeqNum: EventSequenceNumber.EventSequenceNumber, isClient: boolean) =>
+  rebase = ({
+    parentSeqNum,
+    isClient,
+    rebaseGeneration,
+  }: {
+    parentSeqNum: EventSequenceNumber.EventSequenceNumber
+    isClient: boolean
+    rebaseGeneration: number
+  }) =>
     new EncodedWithMeta({
       ...this,
-      ...EventSequenceNumber.nextPair(parentSeqNum, isClient),
+      ...EventSequenceNumber.nextPair({ seqNum: parentSeqNum, isClient, rebaseGeneration }),
     })
 
   static fromGlobal = (
@@ -237,8 +245,16 @@ export class EncodedWithMeta extends Schema.Class<EncodedWithMeta>('LiveStoreEve
   ) =>
     new EncodedWithMeta({
       ...event,
-      seqNum: { global: event.seqNum, client: EventSequenceNumber.clientDefault },
-      parentSeqNum: { global: event.parentSeqNum, client: EventSequenceNumber.clientDefault },
+      seqNum: {
+        global: event.seqNum,
+        client: EventSequenceNumber.clientDefault,
+        rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
+      },
+      parentSeqNum: {
+        global: event.parentSeqNum,
+        client: EventSequenceNumber.clientDefault,
+        rebaseGeneration: EventSequenceNumber.rebaseGenerationDefault,
+      },
       meta: {
         sessionChangeset: { _tag: 'unset' as const },
         syncMetadata: meta.syncMetadata,

package/src/schema/state/sqlite/db-schema/dsl/field-defs.ts

@@ -17,7 +17,7 @@ export const isColumnDefinition = (value: unknown): value is ColumnDefinition<an
     typeof value === 'object' &&
     value !== null &&
     'columnType' in value &&
-    validColumnTypes.includes(value['columnType'] as any)
+    validColumnTypes.includes(value.columnType as any)
   )
 }
 
@@ -36,7 +36,7 @@ export type SqlDefaultValue = {
 }
 
 export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
-  return typeof value === 'object' && value !== null && 'sql' in value && typeof value['sql'] === 'string'
+  return typeof value === 'object' && value !== null && 'sql' in value && typeof value.sql === 'string'
 }
 
 export type ColDefFn<TColumnType extends FieldColumnType> = {

package/src/schema/state/sqlite/db-schema/hash.ts

@@ -1,8 +1,8 @@
 // Based on https://stackoverflow.com/a/7616484
 export const hashCode = (str: string) => {
-  let hash = 0,
-    i,
-    chr
+  let hash = 0
+  let i: number
+  let chr: number
   if (str.length === 0) return hash
   for (i = 0; i < str.length; i++) {
     // eslint-disable-next-line unicorn/prefer-code-point

package/src/schema/state/sqlite/mod.ts

@@ -6,7 +6,7 @@ import type { InternalState } from '../../schema.js'
 import { ClientDocumentTableDefSymbol, tableIsClientDocumentTable } from './client-document-def.js'
 import { SqliteAst } from './db-schema/mod.js'
 import { stateSystemTables } from './system-tables.js'
-import { type TableDef, type TableDefBase } from './table-def.js'
+import type { TableDef, TableDefBase } from './table-def.js'
 
 export * from './table-def.js'
 export {

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

@@ -19,7 +19,11 @@ export namespace QueryBuilderAst {
   export interface SelectQuery {
     readonly _tag: 'SelectQuery'
     readonly columns: string[]
-    readonly pickFirst: false | { fallback: () => any } | 'throws'
+    readonly pickFirst:
+      | { _tag: 'disabled' }
+      | { _tag: 'enabled'; behaviour: 'undefined' }
+      | { _tag: 'enabled'; behaviour: 'error' }
+      | { _tag: 'enabled'; behaviour: 'fallback'; fallback: () => any }
     readonly select: {
       columns: ReadonlyArray<string>
     }
@@ -167,6 +171,21 @@ export namespace QueryBuilder {
     direction: 'asc' | 'desc'
   }>
 
+  export type FirstQueryBehaviour<TResult, TFallback> =
+    | {
+        /** Will error if no matching row was found */
+        behaviour: 'error'
+      }
+    | {
+        /** Will return `undefined` if no matching row was found */
+        behaviour: 'undefined'
+      }
+    | {
+        /** Will return a fallback value if no matching row was found */
+        behaviour: 'fallback'
+        fallback: () => TResult | TFallback
+      }
+
   export type ApiFull<TResult, TTableDef extends TableDefBase, TWithout extends ApiFeature> = {
     /**
      * `SELECT *` is the default
@@ -285,16 +304,27 @@ export namespace QueryBuilder {
      * Example:
      * ```ts
      * db.todos.first()
-     * db.todos.where('id', '123').first()
+     * db.todos.where('id', '123').first() // will return `undefined` if no rows are returned
+     * db.todos.where('id', '123').first({ behaviour: 'error' }) // will throw if no rows are returned
+     * db.todos.first({ behaviour: 'fallback', fallback: () => ({ id: '123', text: 'Buy milk', status: 'active' }) })
      * ```
      *
-     * Query will throw if no rows are returned and no fallback is provided.
+     * Behaviour:
+     * - `undefined`: Will return `undefined` if no rows are returned (default behaviour)
+     * - `error`: Will throw if no rows are returned
+     * - `fallback`: Will return a fallback value if no rows are returned
      */
-    readonly first: <TFallback = never>(options?: {
-      /** @default 'throws' */
-      fallback?: (() => TFallback | GetSingle<TResult>) | 'throws'
-    }) => QueryBuilder<
-      TFallback | GetSingle<TResult>,
+    readonly first: <
+      TBehaviour extends QueryBuilder.FirstQueryBehaviour<GetSingle<TResult>, TFallback>,
+      TFallback = never,
+    >(
+      behaviour?: QueryBuilder.FirstQueryBehaviour<GetSingle<TResult>, TFallback> & TBehaviour,
+    ) => QueryBuilder<
+      TBehaviour extends { behaviour: 'fallback' }
+        ? ReturnType<TBehaviour['fallback']> | GetSingle<TResult>
+        : TBehaviour extends { behaviour: 'undefined' }
+          ? undefined | GetSingle<TResult>
+          : GetSingle<TResult>,
       TTableDef,
       TWithout | 'row' | 'first' | 'orderBy' | 'select' | 'limit' | 'offset' | 'where' | 'returning' | 'onConflict'
     >

package/src/schema/state/sqlite/query-builder/impl.test.ts

@@ -55,7 +55,7 @@ const UiStateWithDefaultId = State.SQLite.clientDocument({
   },
 })
 
-export const issue = State.SQLite.table({
+const issue = State.SQLite.table({
   name: 'issue',
   columns: {
     id: State.SQLite.integer({ primaryKey: true }),
@@ -120,7 +120,19 @@ describe('query builder', () => {
         }
       `)
 
-      expect(dump(db.todos.select('id', 'text').first({ fallback: () => undefined }))).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id', 'text').first({ behaviour: 'error' }))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            1,
+          ],
+          "query": "SELECT id, text FROM 'todos' LIMIT ?",
+          "schema": "(ReadonlyArray<{ readonly id: string; readonly text: string }> <-> { readonly id: string; readonly text: string })",
+        }
+      `)
+
+      expect(
+        dump(db.todos.select('id', 'text').first({ behaviour: 'fallback', fallback: () => undefined })),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
             1,
@@ -166,8 +178,9 @@ describe('query builder', () => {
           "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(dump(db.todos.select('id', 'text').where({ deletedAt: { op: '<=', value: new Date('2024-01-01') } })))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.select('id', 'text').where({ deletedAt: { op: '<=', value: new Date('2024-01-01') } })),
+      ).toMatchInlineSnapshot(`
           {
             "bindValues": [
               "2024-01-01T00:00:00.000Z",
@@ -176,8 +189,9 @@ describe('query builder', () => {
             "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
           }
         `)
-      expect(dump(db.todos.select('id', 'text').where({ status: { op: 'IN', value: ['active'] } })))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.select('id', 'text').where({ status: { op: 'IN', value: ['active'] } })),
+      ).toMatchInlineSnapshot(`
           {
             "bindValues": [
               "active",
@@ -186,8 +200,9 @@ describe('query builder', () => {
             "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
           }
         `)
-      expect(dump(db.todos.select('id', 'text').where({ status: { op: 'NOT IN', value: ['active', 'completed'] } })))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.select('id', 'text').where({ status: { op: 'NOT IN', value: ['active', 'completed'] } })),
+      ).toMatchInlineSnapshot(`
           {
             "bindValues": [
               "active",
@@ -197,6 +212,25 @@ describe('query builder', () => {
             "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
           }
         `)
+
+      expect(
+        dump(
+          db.todos
+            .select('id', 'text')
+            .where({ completed: false })
+            .where({ status: { op: 'IN', value: ['active'] } })
+            .where({ deletedAt: undefined }),
+        ),
+      ).toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              0,
+              "active",
+            ],
+            "query": "SELECT id, text FROM 'todos' WHERE completed = ? AND status IN (?)",
+            "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
+          }
+        `)
     })
 
     it('should handle OFFSET and LIMIT clauses', () => {
@@ -375,8 +409,9 @@ describe('query builder', () => {
     })
 
     it('should handle INSERT queries with undefined values', () => {
-      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active', completed: undefined })))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active', completed: undefined })),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
             "123",
@@ -443,8 +478,9 @@ describe('query builder', () => {
     })
 
     it('should handle UPDATE queries with undefined values', () => {
-      expect(dump(db.todos.update({ status: undefined, text: 'some text' }).where({ id: '123' })))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.update({ status: undefined, text: 'some text' }).where({ id: '123' })),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
             "some text",
@@ -483,8 +519,9 @@ describe('query builder', () => {
     })
 
     it('should handle INSERT with ON CONFLICT', () => {
-      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'ignore')))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'ignore')),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
             "123",
@@ -516,8 +553,9 @@ describe('query builder', () => {
         }
       `)
 
-      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'replace')))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'replace')),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
             "123",
@@ -547,8 +585,9 @@ describe('query builder', () => {
     })
 
     it('should handle RETURNING clause', () => {
-      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).returning('id')))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).returning('id')),
+      ).toMatchInlineSnapshot(`
           {
             "bindValues": [
               "123",
@@ -560,8 +599,9 @@ describe('query builder', () => {
           }
         `)
 
-      expect(dump(db.todos.update({ status: 'completed' }).where({ id: '123' }).returning('id')))
-        .toMatchInlineSnapshot(`
+      expect(
+        dump(db.todos.update({ status: 'completed' }).where({ id: '123' }).returning('id')),
+      ).toMatchInlineSnapshot(`
           {
             "bindValues": [
               "completed",