@livestore/common 0.0.0-snapshot-2b8a9de3ec1a701aca891ebc2c98eb328274ae9e → 0.0.0-snapshot-2c861249e50661661613204300b1fc0d902c2e46

package/src/query-builder/impl.test.ts

@@ -1,40 +1,78 @@
 import { Schema } from '@livestore/utils/effect'
 import { describe, expect, it } from 'vitest'
 
-import { DbSchema } from '../schema/mod.js'
+import { State } from '../schema/mod.js'
 import { getResultSchema } from './impl.js'
 
-const todos = DbSchema.table(
-  'todos',
-  {
-    id: DbSchema.text({ primaryKey: true }),
-    text: DbSchema.text({ default: '', nullable: false }),
-    completed: DbSchema.boolean({ default: false, nullable: false }),
-    status: DbSchema.text({ schema: Schema.Literal('active', 'completed') }),
-    deletedAt: DbSchema.datetime({ nullable: true }),
+const todos = State.SQLite.table({
+  name: 'todos',
+  columns: {
+    id: State.SQLite.text({ primaryKey: true }),
+    text: State.SQLite.text({ default: '', nullable: false }),
+    completed: State.SQLite.boolean({ default: false, nullable: false }),
+    status: State.SQLite.text({ schema: Schema.Literal('active', 'completed') }),
+    deletedAt: State.SQLite.datetime({ nullable: true }),
     // TODO consider leaning more into Effect schema
-    // other: Schema.Number.pipe(DbSchema.asInteger),
+    // other: Schema.Number.pipe(State.SQLite.asInteger),
   },
-  { deriveMutations: true },
-)
-
-const todosWithIntId = DbSchema.table(
-  'todos_with_int_id',
-  {
-    id: DbSchema.integer({ primaryKey: true }),
-    text: DbSchema.text({ default: '', nullable: false }),
-    status: DbSchema.text({ schema: Schema.Literal('active', 'completed') }),
+})
+
+const todosWithIntId = State.SQLite.table({
+  name: 'todos_with_int_id',
+  columns: {
+    id: State.SQLite.integer({ primaryKey: true }),
+    text: State.SQLite.text({ default: '', nullable: false }),
+    status: State.SQLite.text({ schema: Schema.Literal('active', 'completed') }),
+  },
+})
+
+const comments = State.SQLite.table({
+  name: 'comments',
+  columns: {
+    id: State.SQLite.text({ primaryKey: true }),
+    text: State.SQLite.text({ default: '', nullable: false }),
+    todoId: State.SQLite.text({}),
   },
-  { deriveMutations: true },
-)
+})
 
-const comments = DbSchema.table('comments', {
-  id: DbSchema.text({ primaryKey: true }),
-  text: DbSchema.text({ default: '', nullable: false }),
-  todoId: DbSchema.text({}),
+const UiState = State.SQLite.clientDocument({
+  name: 'UiState',
+  schema: Schema.Struct({
+    filter: Schema.Literal('all', 'active', 'completed'),
+  }),
+  default: { value: { filter: 'all' } },
 })
 
-const db = { todos: todos.query, todosWithIntId: todosWithIntId.query, comments: comments.query }
+const UiStateWithDefaultId = State.SQLite.clientDocument({
+  name: 'UiState',
+  schema: Schema.Struct({
+    filter: Schema.Literal('all', 'active', 'completed'),
+  }),
+  default: {
+    id: 'static',
+    value: { filter: 'all' },
+  },
+})
+
+export const issue = State.SQLite.table({
+  name: 'issue',
+  columns: {
+    id: State.SQLite.integer({ primaryKey: true }),
+    title: State.SQLite.text({ default: '' }),
+    creator: State.SQLite.text({ default: '' }),
+    priority: State.SQLite.integer({ schema: Schema.Literal(0, 1, 2, 3, 4), default: 0 }),
+    created: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    deleted: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
+    modified: State.SQLite.integer({ schema: Schema.DateFromNumber }),
+    kanbanorder: State.SQLite.text({ nullable: false, default: '' }),
+  },
+  indexes: [
+    { name: 'issue_kanbanorder', columns: ['kanbanorder'] },
+    { name: 'issue_created', columns: ['created'] },
+  ],
+})
+
+const db = { todos, todosWithIntId, comments, issue, UiState, UiStateWithDefaultId }
 
 describe('query builder', () => {
   describe('result schema', () => {
@@ -52,6 +90,13 @@ describe('query builder', () => {
         }
       `)
 
+      expect(db.todos.select('id').asSql()).toMatchInlineSnapshot(`
+        {
+          "bindValues": [],
+          "query": "SELECT id FROM 'todos'",
+        }
+      `)
+
       expect(db.todos.select('id', 'text').asSql()).toMatchInlineSnapshot(`
         {
           "bindValues": [],
@@ -147,6 +192,42 @@ describe('query builder', () => {
         `)
     })
 
+    it('should handle OFFSET and LIMIT clauses correctly', () => {
+      // Test with both offset and limit
+      expect(db.todos.select('id', 'text').where('completed', true).offset(5).limit(10).asSql()).toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              1,
+              5,
+              10,
+            ],
+            "query": "SELECT id, text FROM 'todos' WHERE completed = ? OFFSET ? LIMIT ?",
+          }
+        `)
+
+      // Test with only offset
+      expect(db.todos.select('id', 'text').where('completed', true).offset(5).asSql()).toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              1,
+              5,
+            ],
+            "query": "SELECT id, text FROM 'todos' WHERE completed = ? OFFSET ?",
+          }
+        `)
+
+      // Test with only limit
+      expect(db.todos.select('id', 'text').where('completed', true).limit(10).asSql()).toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              1,
+              10,
+            ],
+            "query": "SELECT id, text FROM 'todos' WHERE completed = ? LIMIT ?",
+          }
+        `)
+    })
+
     it('should handle COUNT queries', () => {
       expect(db.todos.count().asSql()).toMatchInlineSnapshot(`
         {
@@ -203,40 +284,92 @@ describe('query builder', () => {
     })
   })
 
-  describe('row queries', () => {
-    it('should handle row queries', () => {
-      expect(db.todos.row('123', { insertValues: { status: 'completed' } }).asSql()).toMatchInlineSnapshot(`
+  // describe('getOrCreate queries', () => {
+  //   it('should handle getOrCreate queries', () => {
+  //     expect(db.UiState.getOrCreate('sessionid-1').asSql()).toMatchInlineSnapshot(`
+  //         {
+  //           "bindValues": [
+  //             "sessionid-1",
+  //           ],
+  //           "query": "SELECT * FROM 'UiState' WHERE id = ?",
+  //         }
+  //       `)
+  //   })
+
+  //   it('should handle getOrCreate queries with default id', () => {
+  //     expect(db.UiStateWithDefaultId.getOrCreate().asSql()).toMatchInlineSnapshot(`
+  //       {
+  //         "bindValues": [],
+  //         "query": "SELECT * FROM 'UiState' WHERE id = ?",
+  //       }
+  //     `)
+  //   })
+  //   // it('should handle row queries with numbers', () => {
+  //   //   expect(db.todosWithIntId.getOrCreate(123, { insertValues: { status: 'active' } }).asSql()).toMatchInlineSnapshot(`
+  //   //     {
+  //   //       "bindValues": [
+  //   //         123,
+  //   //       ],
+  //   //       "query": "SELECT * FROM 'todos_with_int_id' WHERE id = ?",
+  //   //     }
+  //   //   `)
+  //   // })
+  // })
+
+  describe('write operations', () => {
+    it('should handle INSERT queries', () => {
+      expect(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).asSql()).toMatchInlineSnapshot(`
         {
           "bindValues": [
             "123",
+            "Buy milk",
+            "active",
           ],
-          "query": "SELECT * FROM 'todos' WHERE id = ?",
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?)",
         }
       `)
     })
 
-    it('should handle row queries with numbers', () => {
-      expect(db.todosWithIntId.row(123, { insertValues: { status: 'active' } }).asSql()).toMatchInlineSnapshot(`
+    it('should handle INSERT queries with undefined values', () => {
+      expect(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active', completed: undefined }).asSql())
+        .toMatchInlineSnapshot(`
         {
           "bindValues": [
-            123,
+            "123",
+            "Buy milk",
+            "active",
           ],
-          "query": "SELECT * FROM 'todos_with_int_id' WHERE id = ?",
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?)",
         }
       `)
     })
-  })
 
-  describe('write operations', () => {
-    it('should handle INSERT queries', () => {
-      expect(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).asSql()).toMatchInlineSnapshot(`
+    // Test helped to catch a bindValues ordering bug
+    it('should handle INSERT queries (issue)', () => {
+      expect(
+        db.issue
+          .insert({
+            id: 1,
+            title: 'Revert the user profile page',
+            priority: 2,
+            created: new Date('2024-08-01T17:15:20.507Z'),
+            modified: new Date('2024-12-29T17:15:20.507Z'),
+            kanbanorder: 'a2',
+            creator: 'John Doe',
+          })
+          .asSql(),
+      ).toMatchInlineSnapshot(`
         {
           "bindValues": [
-            "123",
-            "Buy milk",
-            "active",
+            1,
+            "Revert the user profile page",
+            2,
+            1722532520507,
+            1735492520507,
+            "a2",
+            "John Doe",
           ],
-          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?)",
+          "query": "INSERT INTO 'issue' (id, title, priority, created, modified, kanbanorder, creator) VALUES (?, ?, ?, ?, ?, ?, ?)",
         }
       `)
     })
@@ -251,6 +384,40 @@ describe('query builder', () => {
           "query": "UPDATE 'todos' SET status = ? WHERE id = ?",
         }
       `)
+
+      // empty update set
+      expect(db.todos.update({}).where({ id: '123' }).asSql()).toMatchInlineSnapshot(`
+        {
+          "bindValues": [],
+          "query": "SELECT 1",
+        }
+      `)
+    })
+
+    it('should handle UPDATE queries with undefined values', () => {
+      expect(db.todos.update({ status: undefined, text: 'some text' }).where({ id: '123' }).asSql())
+        .toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "some text",
+            "123",
+          ],
+          "query": "UPDATE 'todos' SET text = ? WHERE id = ?",
+        }
+      `)
+    })
+
+    it('should handle UPDATE queries with undefined values (issue)', () => {
+      expect(db.issue.update({ priority: 2, creator: 'John Doe' }).where({ id: 1 }).asSql()).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            2,
+            "John Doe",
+            1,
+          ],
+          "query": "UPDATE 'issue' SET priority = ?, creator = ? WHERE id = ?",
+        }
+      `)
     })
 
     it('should handle DELETE queries', () => {
@@ -294,6 +461,36 @@ describe('query builder', () => {
           "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?) ON CONFLICT (id) DO UPDATE SET text = ?, status = ?",
         }
       `)
+
+      expect(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'replace').asSql())
+        .toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "123",
+            "Buy milk",
+            "active",
+          ],
+          "query": "INSERT OR REPLACE INTO 'todos' (id, text, status) VALUES (?, ?, ?)",
+        }
+      `)
+    })
+
+    it('should handle ON CONFLICT with multiple columns', () => {
+      expect(
+        db.todos
+          .insert({ id: '123', text: 'Buy milk', status: 'active' })
+          .onConflict(['id', 'status'], 'ignore')
+          .asSql(),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "123",
+            "Buy milk",
+            "active",
+          ],
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?) ON CONFLICT (id, status) DO NOTHING",
+        }
+      `)
     })
 
     it('should handle RETURNING clause', () => {

package/src/query-builder/impl.ts

@@ -1,16 +1,15 @@
-import { casesHandled } from '@livestore/utils'
+import { casesHandled, shouldNeverHappen } from '@livestore/utils'
 import { Match, Option, Predicate, Schema } from '@livestore/utils/effect'
 
-import type { QueryInfo } from '../query-info.js'
-import type { DbSchema } from '../schema/mod.js'
+import type { State } from '../schema/mod.js'
 import type { QueryBuilder, QueryBuilderAst } from './api.js'
-import { QueryBuilderAstSymbol, TypeId } from './api.js'
+import { QueryBuilderAstSymbol, QueryBuilderTypeId } from './api.js'
 import { astToSql } from './astToSql.js'
 
-export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBase>(
+export const makeQueryBuilder = <TResult, TTableDef extends State.SQLite.TableDefBase>(
   tableDef: TTableDef,
   ast: QueryBuilderAst = emptyAst(tableDef),
-): QueryBuilder<TResult, TTableDef, never, QueryInfo.None> => {
+): QueryBuilder<TResult, TTableDef, never> => {
   const api = {
     // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
     select() {
@@ -19,11 +18,12 @@ export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBas
       // eslint-disable-next-line prefer-rest-params
       const params = [...arguments]
 
-      if (params.length === 2 && typeof params[0] === 'string' && typeof params[1] === 'object') {
-        const [col, options] = params as any as [string, { pluck: boolean }]
+      // Pluck if there's only one column selected
+      if (params.length === 1) {
+        const [col] = params as any as [string]
         return makeQueryBuilder(tableDef, {
           ...ast,
-          resultSchemaSingle: options.pluck ? ast.resultSchemaSingle.pipe(Schema.pluck(col)) : ast.resultSchemaSingle,
+          resultSchemaSingle: ast.resultSchemaSingle.pipe(Schema.pluck(col)),
           select: { columns: [col] },
         })
       }
@@ -148,51 +148,60 @@ export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBas
         pickFirst: options?.fallback ? { fallback: options.fallback } : { fallback: () => undefined },
       })
     },
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-    row() {
-      // eslint-disable-next-line prefer-rest-params
-      const params = [...arguments]
-
-      let id: string | number
-
-      if (tableDef.options.isSingleton) {
-        id = tableDef.sqliteDef.columns.id!.default.pipe(Option.getOrThrow)
-      } else {
-        id = params[0] as string | number
-        if (id === undefined) {
-          invalidQueryBuilder(`Id missing for row query on non-singleton table ${tableDef.sqliteDef.name}`)
-        }
-      }
-
-      // TODO validate all required columns are present and values are matching the schema
-      const insertValues: Record<string, unknown> = params[1]?.insertValues ?? {}
-
-      return makeQueryBuilder(tableDef, {
-        _tag: 'RowQuery',
-        id,
-        tableDef,
-        insertValues,
-      }) as any
-    },
+    // // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    // getOrCreate() {
+    //   if (tableDef.options.isClientDocumentTable === false) {
+    //     return invalidQueryBuilder(`getOrCreate() is not allowed when table is not a client document table`)
+    //   }
+
+    //   // eslint-disable-next-line prefer-rest-params
+    //   const params = [...arguments]
+
+    //   let id: string | number
+
+    //   // TODO refactor to handle default id
+    //   id = params[0] as string | number
+    //   if (id === undefined) {
+    //     invalidQueryBuilder(`Id missing for row query on non-singleton table ${tableDef.sqliteDef.name}`)
+    //   }
+
+    //   // TODO validate all required columns are present and values are matching the schema
+    //   const insertValues: Record<string, unknown> = params[1]?.insertValues ?? {}
+
+    //   return makeQueryBuilder(tableDef, {
+    //     _tag: 'RowQuery',
+    //     id,
+    //     tableDef,
+    //     insertValues,
+    //   }) as any
+    // },
     insert: (values) => {
+      const filteredValues = Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined))
+
       return makeQueryBuilder(tableDef, {
         _tag: 'InsertQuery',
         tableDef,
-        values: values as any,
+        values: filteredValues,
         onConflict: undefined,
         returning: undefined,
         resultSchema: Schema.Void,
       }) as any
     },
-    onConflict: (target: string, action: 'ignore' | 'replace' | 'update', updateValues?: Record<string, unknown>) => {
+    onConflict: (
+      targetOrTargets: string | string[],
+      action: 'ignore' | 'replace' | 'update',
+      updateValues?: Record<string, unknown>,
+    ) => {
+      const targets = Array.isArray(targetOrTargets) ? targetOrTargets : [targetOrTargets]
+
       assertInsertQueryBuilderAst(ast)
 
       const onConflict = Match.value(action).pipe(
-        Match.when('ignore', () => ({ target, action: { _tag: 'ignore' } }) satisfies QueryBuilderAst.OnConflict),
-        Match.when('replace', () => ({ target, action: { _tag: 'replace' } }) satisfies QueryBuilderAst.OnConflict),
+        Match.when('ignore', () => ({ targets, action: { _tag: 'ignore' } }) satisfies QueryBuilderAst.OnConflict),
+        Match.when('replace', () => ({ targets, action: { _tag: 'replace' } }) satisfies QueryBuilderAst.OnConflict),
         Match.when(
           'update',
-          () => ({ target, action: { _tag: 'update', update: updateValues! } }) satisfies QueryBuilderAst.OnConflict,
+          () => ({ targets, action: { _tag: 'update', update: updateValues! } }) satisfies QueryBuilderAst.OnConflict,
         ),
         Match.exhaustive,
       )
@@ -209,15 +218,17 @@ export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBas
       return makeQueryBuilder(tableDef, {
         ...ast,
         returning: columns,
-        resultSchema: tableDef.schema.pipe(Schema.pick(...columns), Schema.Array),
+        resultSchema: tableDef.rowSchema.pipe(Schema.pick(...columns), Schema.Array),
       }) as any
     },
 
     update: (values) => {
+      const filteredValues = Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined))
+
       return makeQueryBuilder(tableDef, {
         _tag: 'UpdateQuery',
         tableDef,
-        values: values as any,
+        values: filteredValues,
         where: [],
         returning: undefined,
         resultSchema: Schema.Void,
@@ -233,11 +244,12 @@ export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBas
         resultSchema: Schema.Void,
       }) as any
     },
-  } satisfies QueryBuilder.ApiFull<TResult, TTableDef, never, QueryInfo.None>
+  } satisfies QueryBuilder.ApiFull<TResult, TTableDef, never>
 
   return {
-    [TypeId]: TypeId,
+    [QueryBuilderTypeId]: QueryBuilderTypeId,
     [QueryBuilderAstSymbol]: ast,
+    ['ResultType']: 'only-for-type-inference' as TResult,
     asSql: () => astToSql(ast),
     toString: () => {
       try {
@@ -251,7 +263,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends DbSchema.TableDefBas
   } satisfies QueryBuilder<TResult, TTableDef>
 }
 
-const emptyAst = (tableDef: DbSchema.TableDefBase): QueryBuilderAst.SelectQuery => ({
+const emptyAst = (tableDef: State.SQLite.TableDefBase): QueryBuilderAst.SelectQuery => ({
   _tag: 'SelectQuery',
   columns: [],
   pickFirst: false,
@@ -261,35 +273,35 @@ const emptyAst = (tableDef: DbSchema.TableDefBase): QueryBuilderAst.SelectQuery
   limit: Option.none(),
   tableDef,
   where: [],
-  resultSchemaSingle: tableDef.schema,
+  resultSchemaSingle: tableDef.rowSchema,
 })
 
 // Helper functions
 // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertSelectQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.SelectQuery {
   if (ast._tag !== 'SelectQuery') {
-    throw new Error('Expected SelectQuery but got ' + ast._tag)
+    return shouldNeverHappen('Expected SelectQuery but got ' + ast._tag)
   }
 }
 
 // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertInsertQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.InsertQuery {
   if (ast._tag !== 'InsertQuery') {
-    throw new Error('Expected InsertQuery but got ' + ast._tag)
+    return shouldNeverHappen('Expected InsertQuery but got ' + ast._tag)
   }
 }
 
 // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertWriteQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.WriteQuery {
   if (ast._tag !== 'InsertQuery' && ast._tag !== 'UpdateQuery' && ast._tag !== 'DeleteQuery') {
-    throw new Error('Expected WriteQuery but got ' + ast._tag)
+    return shouldNeverHappen('Expected WriteQuery but got ' + ast._tag)
   }
 }
 
 const isRowQuery = (ast: QueryBuilderAst): ast is QueryBuilderAst.RowQuery => ast._tag === 'RowQuery'
 
 export const invalidQueryBuilder = (msg?: string) => {
-  throw new Error('Invalid query builder' + (msg ? `: ${msg}` : ''))
+  return shouldNeverHappen('Invalid query builder' + (msg ? `: ${msg}` : ''))
 }
 
 export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<any> => {
@@ -312,17 +324,17 @@ export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<
       // For write operations with RETURNING clause, we need to return the appropriate schema
       if (queryAst.returning && queryAst.returning.length > 0) {
         // Create a schema for the returned columns
-        return queryAst.tableDef.schema.pipe(Schema.pick(...queryAst.returning), Schema.Array)
+        return queryAst.tableDef.rowSchema.pipe(Schema.pick(...queryAst.returning), Schema.Array)
       }
 
       // For write operations without RETURNING, the result is the number of affected rows
       return Schema.Number
     }
     default: {
-      if (queryAst.tableDef.options.isSingleColumn) {
-        return queryAst.tableDef.schema.pipe(Schema.pluck('value'), Schema.Array, Schema.headOrElse())
+      if (queryAst.tableDef.options.isClientDocumentTable) {
+        return queryAst.tableDef.rowSchema.pipe(Schema.pluck('value'), Schema.Array, Schema.headOrElse())
       } else {
-        return queryAst.tableDef.schema.pipe(Schema.Array, Schema.headOrElse())
+        return queryAst.tableDef.rowSchema.pipe(Schema.Array, Schema.headOrElse())
       }
     }
   }