@livestore/common 0.3.1 → 0.3.2-dev.1

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

@@ -1,9 +1,9 @@
 import { Schema } from '@livestore/utils/effect'
 import { describe, expect, test } from 'vitest'
 
-import { tables } from '../../../__tests__/fixture.js'
-import type * as LiveStoreEvent from '../../LiveStoreEvent.js'
-import { clientDocument, ClientDocumentTableDefSymbol } from './client-document-def.js'
+import { tables } from '../../../__tests__/fixture.ts'
+import type * as LiveStoreEvent from '../../LiveStoreEvent.ts'
+import { ClientDocumentTableDefSymbol, clientDocument } from './client-document-def.ts'
 
 describe('client document table', () => {
   test('set event', () => {
@@ -70,8 +70,9 @@ describe('client document table', () => {
     })
 
     test('struct value (partial set=true)', () => {
-      expect(forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: true }))
-        .toMatchInlineSnapshot(`
+      expect(
+        forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: true }),
+      ).toMatchInlineSnapshot(`
           {
             "bindValues": [
               "id1",
@@ -92,8 +93,9 @@ describe('client document table', () => {
     })
 
     test('struct value (partial set=false)', () => {
-      expect(forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: false }))
-        .toMatchInlineSnapshot(`
+      expect(
+        forSchema(Schema.Struct({ a: Schema.String }), { a: 'hello' }, 'id1', { partialSet: false }),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
             "id1",

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

@@ -2,15 +2,15 @@ import { shouldNeverHappen } from '@livestore/utils'
 import type { Option, Types } from '@livestore/utils/effect'
 import { Schema, SchemaAST } from '@livestore/utils/effect'
 
-import { SessionIdSymbol } from '../../../adapter-types.js'
-import { sql } from '../../../util.js'
-import type { EventDef, Materializer } from '../../EventDef.js'
-import { defineEvent, defineMaterializer } from '../../EventDef.js'
-import { SqliteDsl } from './db-schema/mod.js'
-import type { QueryBuilder, QueryBuilderAst } from './query-builder/mod.js'
-import { QueryBuilderAstSymbol, QueryBuilderTypeId } from './query-builder/mod.js'
-import type { TableDef, TableDefBase } from './table-def.js'
-import { table } from './table-def.js'
+import { SessionIdSymbol } from '../../../adapter-types.ts'
+import { sql } from '../../../util.ts'
+import type { EventDef, Materializer } from '../../EventDef.ts'
+import { defineEvent, defineMaterializer } from '../../EventDef.ts'
+import { SqliteDsl } from './db-schema/mod.ts'
+import type { QueryBuilder, QueryBuilderAst } from './query-builder/mod.ts'
+import { QueryBuilderAstSymbol, QueryBuilderTypeId } from './query-builder/mod.ts'
+import type { TableDef, TableDefBase } from './table-def.ts'
+import { table } from './table-def.ts'
 
 /**
  * Special:
@@ -386,37 +386,49 @@ export namespace ClientDocumentTableDef {
     }
   }
 
-  export type GetOptions<TTableDef extends TraitAny> =
-    TTableDef extends ClientDocumentTableDef.Trait<any, any, any, infer TOptions> ? TOptions : never
+  export type GetOptions<TTableDef extends TraitAny> = TTableDef extends ClientDocumentTableDef.Trait<
+    any,
+    any,
+    any,
+    infer TOptions
+  >
+    ? TOptions
+    : never
 
   export type TraitAny = Trait<any, any, any, any>
 
-  export type DefaultIdType<TTableDef extends TraitAny> =
-    TTableDef extends ClientDocumentTableDef.Trait<any, any, any, infer TOptions>
-      ? TOptions['default']['id'] extends SessionIdSymbol | string
-        ? TOptions['default']['id']
-        : never
+  export type DefaultIdType<TTableDef extends TraitAny> = TTableDef extends ClientDocumentTableDef.Trait<
+    any,
+    any,
+    any,
+    infer TOptions
+  >
+    ? TOptions['default']['id'] extends SessionIdSymbol | string
+      ? TOptions['default']['id']
       : never
+    : never
 
-  export type SetEventDefLike<TName extends string, TType, TOptions extends ClientDocumentTableOptions<TType>> =
-    // Helper to create partial event
-    (TOptions['default']['id'] extends undefined
-      ? (
-          args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
-          id: string | SessionIdSymbol,
-        ) => { name: `${TName}Set`; args: { id: string; value: TType } }
-      : (
-          args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
-          id?: string | SessionIdSymbol,
-        ) => { name: `${TName}Set`; args: { id: string; value: TType } }) & {
+  export type SetEventDefLike<
+    TName extends string,
+    TType,
+    TOptions extends ClientDocumentTableOptions<TType>,
+  > = (TOptions['default']['id'] extends undefined // Helper to create partial event
+    ? (
+        args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
+        id: string | SessionIdSymbol,
+      ) => { name: `${TName}Set`; args: { id: string; value: TType } }
+    : (
+        args: TOptions['partialSet'] extends false ? TType : Partial<TType>,
+        id?: string | SessionIdSymbol,
+      ) => { name: `${TName}Set`; args: { id: string; value: TType } }) & {
+    readonly name: `${TName}Set`
+    readonly schema: Schema.Schema<any>
+    readonly Event: {
       readonly name: `${TName}Set`
-      readonly schema: Schema.Schema<any>
-      readonly Event: {
-        readonly name: `${TName}Set`
-        readonly args: { id: string; value: TType }
-      }
-      readonly options: { derived: true; clientOnly: true; facts: undefined }
+      readonly args: { id: string; value: TType }
     }
+    readonly options: { derived: true; clientOnly: true; facts: undefined }
+  }
 
   export type SetEventDef<TName extends string, TType, TOptions extends ClientDocumentTableOptions<TType>> = EventDef<
     TName,

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

@@ -1,6 +1,6 @@
 import { type Option, Schema } from '@livestore/utils/effect'
 
-import { hashCode } from '../hash.js'
+import { hashCode } from '../hash.ts'
 
 export namespace ColumnType {
   export type ColumnType = Text | Null | Real | Integer | Blob

package/src/schema/state/sqlite/db-schema/ast/validate.ts

@@ -1,4 +1,4 @@
-import type { DbSchema } from './sqlite.js'
+import type { DbSchema } from './sqlite.ts'
 
 // TODO
 export const validate = (_dbSchema: DbSchema) => {

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

@@ -1,7 +1,7 @@
 import { Schema } from '@livestore/utils/effect'
 import { describe, expect, test } from 'vitest'
 
-import * as F from './field-defs.js'
+import * as F from './field-defs.ts'
 
 describe.concurrent('FieldDefs', () => {
   test('text', () => {

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/dsl/mod.ts

@@ -2,10 +2,10 @@ import type { Nullable } from '@livestore/utils'
 import type { Option, Types } from '@livestore/utils/effect'
 import { Schema } from '@livestore/utils/effect'
 
-import type * as SqliteAst from '../ast/sqlite.js'
-import type { ColumnDefinition } from './field-defs.js'
+import type * as SqliteAst from '../ast/sqlite.ts'
+import type { ColumnDefinition } from './field-defs.ts'
 
-export * from './field-defs.js'
+export * from './field-defs.ts'
 
 export type DbSchema = {
   [key: string]: TableDefinition<string, Columns>
@@ -19,12 +19,13 @@ export type DbSchemaInput = Record<string, TableDefinition<any, any>> | Readonly
  * - array: we use the table name of each array item (= table definition) as the object key
  * - object: we discard the keys of the input object and use the table name of each object value (= table definition) as the new object key
  */
-export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> =
-  TSchemaInput extends ReadonlyArray<TableDefinition<any, any>>
-    ? { [K in TSchemaInput[number] as K['name']]: K }
-    : TSchemaInput extends Record<string, TableDefinition<any, any>>
-      ? { [K in keyof TSchemaInput as TSchemaInput[K]['name']]: TSchemaInput[K] }
-      : never
+export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> = TSchemaInput extends ReadonlyArray<
+  TableDefinition<any, any>
+>
+  ? { [K in TSchemaInput[number] as K['name']]: K }
+  : TSchemaInput extends Record<string, TableDefinition<any, any>>
+    ? { [K in keyof TSchemaInput as TSchemaInput[K]['name']]: TSchemaInput[K] }
+    : never
 
 // TODO ensure via runtime check (possibly even via type-level check) that all index names are unique
 export const makeDbSchema = <TDbSchemaInput extends DbSchemaInput>(
@@ -113,8 +114,12 @@ export type TableDefinition<TName extends string, TColumns extends Columns> = {
 
 export type Columns = Record<string, ColumnDefinition<any, any>>
 
-export type IsSingleColumn<TColumns extends Columns | ColumnDefinition<any, any>> =
-  TColumns extends ColumnDefinition<any, any> ? true : false
+export type IsSingleColumn<TColumns extends Columns | ColumnDefinition<any, any>> = TColumns extends ColumnDefinition<
+  any,
+  any
+>
+  ? true
+  : false
 
 /**
  * NOTE this is only needed to avoid a TS limitation where `StructSchemaForColumns` in the default case
@@ -207,8 +212,9 @@ export namespace FromColumns {
 
   export type RequiredInsertColumnNames<TColumns extends Columns> = keyof RequiredInsertColumns<TColumns>
 
-  export type RequiresInsertValues<TColumns extends Columns> =
-    RequiredInsertColumnNames<TColumns> extends never ? false : true
+  export type RequiresInsertValues<TColumns extends Columns> = RequiredInsertColumnNames<TColumns> extends never
+    ? false
+    : true
 
   export type InsertRowDecoded<TColumns extends Columns> = Types.Simplify<
     Pick<RowDecodedAll<TColumns>, RequiredInsertColumnNames<TColumns>> &

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

@@ -1,11 +1,10 @@
 // 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
     chr = str.charCodeAt(i)
     hash = (hash << 5) - hash + chr
     hash = Math.trunc(hash) // Convert to 32bit integer

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

@@ -1,2 +1,2 @@
-export * as SqliteDsl from './dsl/mod.js'
-export * as SqliteAst from './ast/sqlite.js'
+export * as SqliteAst from './ast/sqlite.ts'
+export * as SqliteDsl from './dsl/mod.ts'

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

@@ -1,22 +1,22 @@
 import { shouldNeverHappen } from '@livestore/utils'
 
-import type { MigrationOptions } from '../../../adapter-types.js'
-import { type Materializer, rawSqlEvent, rawSqlMaterializer } from '../../EventDef.js'
-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 { MigrationOptions } from '../../../adapter-types.ts'
+import { type Materializer, rawSqlEvent, rawSqlMaterializer } from '../../EventDef.ts'
+import type { InternalState } from '../../schema.ts'
+import { ClientDocumentTableDefSymbol, tableIsClientDocumentTable } from './client-document-def.ts'
+import { SqliteAst } from './db-schema/mod.ts'
+import { stateSystemTables } from './system-tables.ts'
+import type { TableDef, TableDefBase } from './table-def.ts'
 
-export * from './table-def.js'
+export * from '../../EventDef.ts'
 export {
-  ClientDocumentTableDefSymbol,
-  tableIsClientDocumentTable,
-  clientDocument,
   type ClientDocumentTableDef,
+  ClientDocumentTableDefSymbol,
   type ClientDocumentTableOptions,
-} from './client-document-def.js'
-export * from '../../EventDef.js'
+  clientDocument,
+  tableIsClientDocumentTable,
+} from './client-document-def.ts'
+export * from './table-def.ts'
 
 export const makeState = <TStateInput extends InputState>(inputSchema: TStateInput): InternalState => {
   const inputTables: ReadonlyArray<TableDef> = Array.isArray(inputSchema.tables)

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

@@ -1,11 +1,11 @@
 import type { GetValForKey, SingleOrReadonlyArray } from '@livestore/utils'
 import { type Option, Predicate, type Schema } from '@livestore/utils/effect'
 
-import type { SessionIdSymbol } from '../../../../adapter-types.js'
-import type { SqlValue } from '../../../../util.js'
-import type { ClientDocumentTableDef } from '../client-document-def.js'
-import type { SqliteDsl } from '../db-schema/mod.js'
-import type { TableDefBase } from '../table-def.js'
+import type { SessionIdSymbol } from '../../../../adapter-types.ts'
+import type { SqlValue } from '../../../../util.ts'
+import type { ClientDocumentTableDef } from '../client-document-def.ts'
+import type { SqliteDsl } from '../db-schema/mod.ts'
+import type { TableDefBase } from '../table-def.ts'
 
 export type QueryBuilderAst =
   | QueryBuilderAst.SelectQuery
@@ -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/astToSql.ts

@@ -1,10 +1,10 @@
 import { shouldNeverHappen } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
-import { SessionIdSymbol } from '../../../../adapter-types.js'
-import type { SqlValue } from '../../../../util.js'
-import type { State } from '../../../mod.js'
-import type { QueryBuilderAst } from './api.js'
+import { SessionIdSymbol } from '../../../../adapter-types.ts'
+import type { SqlValue } from '../../../../util.ts'
+import type { State } from '../../../mod.ts'
+import type { QueryBuilderAst } from './api.ts'
 
 // Helper functions for SQL generation
 const formatWhereClause = (

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

@@ -1,9 +1,9 @@
 import { Schema } from '@livestore/utils/effect'
 import { describe, expect, it } from 'vitest'
 
-import { State } from '../../../mod.js'
-import type { QueryBuilder } from './api.js'
-import { getResultSchema } from './impl.js'
+import { State } from '../../../mod.ts'
+import type { QueryBuilder } from './api.ts'
+import { getResultSchema } from './impl.ts'
 
 const todos = State.SQLite.table({
   name: 'todos',
@@ -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 }),
@@ -111,6 +111,16 @@ describe('query builder', () => {
 
     it('should handle .first()', () => {
       expect(dump(db.todos.select('id', 'text').first())).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            1,
+          ],
+          "query": "SELECT id, text FROM 'todos' LIMIT ?",
+          "schema": "(ReadonlyArray<{ readonly id: string; readonly text: string } | undefined> <-> { readonly id: string; readonly text: string } | undefined)",
+        }
+      `)
+
+      expect(dump(db.todos.select('id', 'text').first({ behaviour: 'error' }))).toMatchInlineSnapshot(`
         {
           "bindValues": [
             1,
@@ -120,7 +130,9 @@ describe('query builder', () => {
         }
       `)
 
-      expect(dump(db.todos.select('id', 'text').first({ fallback: () => undefined }))).toMatchInlineSnapshot(`
+      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",