@livestore/common 0.3.0-dev.3 → 0.3.0-dev.31

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

@@ -1,206 +1,575 @@
 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 type { QueryBuilder } from './api.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 comments = DbSchema.table('comments', {
-  id: DbSchema.text({ primaryKey: true }),
-  text: DbSchema.text({ default: '', nullable: false }),
-  todoId: DbSchema.text({}),
+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 db = { todos: todos.query, comments: comments.query }
+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({}),
+  },
+})
 
-describe('query builder', () => {
-  describe('result schema', () => {
-    it('should print the schema', () => {
-      expect(String(getResultSchema(db.todos))).toMatchInlineSnapshot(`"ReadonlyArray<todos>"`)
-    })
-  })
+const UiState = State.SQLite.clientDocument({
+  name: 'UiState',
+  schema: Schema.Struct({
+    filter: Schema.Literal('all', 'active', 'completed'),
+  }),
+  default: { value: { filter: 'all' } },
+})
+
+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 }
+
+const dump = (qb: QueryBuilder<any, any, any>) => ({
+  bindValues: qb.asSql().bindValues,
+  query: qb.asSql().query,
+  schema: getResultSchema(qb).toString(),
+})
+
+describe('query builder', () => {
   describe('basic queries', () => {
     it('should handle simple SELECT queries', () => {
-      expect(db.todos.asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos)).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT * FROM 'todos'",
+          "schema": "ReadonlyArray<todos>",
         }
       `)
 
-      expect(db.todos.select('id', 'text').asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id'))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [],
+          "query": "SELECT id FROM 'todos'",
+          "schema": "ReadonlyArray<({ readonly id: string } <-> string)>",
+        }
+      `)
+
+      expect(dump(db.todos.select('id', 'text'))).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT id, text FROM 'todos'",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
+        }
+      `)
+    })
+
+    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 }> <-> { readonly id: string; readonly text: string })",
+        }
+      `)
+
+      expect(dump(db.todos.select('id', 'text').first({ fallback: () => undefined }))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            1,
+          ],
+          "query": "SELECT id, text FROM 'todos' LIMIT ?",
+          "schema": "(ReadonlyArray<{ readonly id: string; readonly text: string }> | readonly [undefined] <-> { readonly id: string; readonly text: string } | undefined)",
         }
       `)
     })
 
     it('should handle WHERE clauses', () => {
-      expect(db.todos.select('id', 'text').where('completed', true).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id', 'text').where('completed', true))).toMatchInlineSnapshot(`
         {
           "bindValues": [
             1,
           ],
           "query": "SELECT id, text FROM 'todos' WHERE completed = ?",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(db.todos.select('id', 'text').where('completed', '!=', true).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id', 'text').where('completed', '!=', true))).toMatchInlineSnapshot(`
         {
           "bindValues": [
             1,
           ],
           "query": "SELECT id, text FROM 'todos' WHERE completed != ?",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(db.todos.select('id', 'text').where({ completed: true }).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id', 'text').where({ completed: true }))).toMatchInlineSnapshot(`
         {
           "bindValues": [
             1,
           ],
           "query": "SELECT id, text FROM 'todos' WHERE completed = ?",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(db.todos.select('id', 'text').where({ completed: undefined }).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id', 'text').where({ completed: undefined }))).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT id, text FROM 'todos'",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(
-        db.todos
-          .select('id', 'text')
-          .where({ deletedAt: { op: '<=', value: new Date('2024-01-01') } })
-          .asSql(),
-      ).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",
+            ],
+            "query": "SELECT id, text FROM 'todos' WHERE deletedAt <= ?",
+            "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
+          }
+        `)
+      expect(dump(db.todos.select('id', 'text').where({ status: { op: 'IN', value: ['active'] } })))
+        .toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              "active",
+            ],
+            "query": "SELECT id, text FROM 'todos' WHERE status IN (?)",
+            "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
+          }
+        `)
+      expect(dump(db.todos.select('id', 'text').where({ status: { op: 'NOT IN', value: ['active', 'completed'] } })))
+        .toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              "active",
+              "completed",
+            ],
+            "query": "SELECT id, text FROM 'todos' WHERE status NOT IN (?, ?)",
+            "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
+          }
+        `)
+    })
+
+    it('should handle OFFSET and LIMIT clauses', () => {
+      expect(dump(db.todos.select('id', 'text').where('completed', true).offset(10).limit(10))).toMatchInlineSnapshot(`
         {
           "bindValues": [
-            "2024-01-01T00:00:00.000Z",
+            1,
+            10,
+            10,
           ],
-          "query": "SELECT id, text FROM 'todos' WHERE deletedAt <= ?",
+          "query": "SELECT id, text FROM 'todos' WHERE completed = ? OFFSET ? LIMIT ?",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(
-        db.todos
-          .select('id', 'text')
-          .where({ status: { op: 'IN', value: ['active'] } })
-          .asSql(),
-      ).toMatchInlineSnapshot(`
+    })
+
+    it('should handle OFFSET and LIMIT clauses correctly', () => {
+      // Test with both offset and limit
+      expect(dump(db.todos.select('id', 'text').where('completed', true).offset(5).limit(10))).toMatchInlineSnapshot(`
         {
           "bindValues": [
-            "active",
+            1,
+            5,
+            10,
           ],
-          "query": "SELECT id, text FROM 'todos' WHERE status IN (?)",
+          "query": "SELECT id, text FROM 'todos' WHERE completed = ? OFFSET ? LIMIT ?",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(
-        db.todos
-          .select('id', 'text')
-          .where({ status: { op: 'NOT IN', value: ['active', 'completed'] } })
-          .asSql(),
-      ).toMatchInlineSnapshot(`
+
+      // Test with only offset
+      expect(dump(db.todos.select('id', 'text').where('completed', true).offset(5))).toMatchInlineSnapshot(`
         {
           "bindValues": [
-            "active",
-            "completed",
+            1,
+            5,
           ],
-          "query": "SELECT id, text FROM 'todos' WHERE status NOT IN (?, ?)",
+          "query": "SELECT id, text FROM 'todos' WHERE completed = ? OFFSET ?",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-    })
 
-    it('should handle OFFSET and LIMIT clauses', () => {
-      expect(db.todos.select('id', 'text').where('completed', true).offset(10).limit(10).asSql())
-        .toMatchInlineSnapshot(`
-          {
-            "bindValues": [
-              1,
-              10,
-              10,
-            ],
-            "query": "SELECT id, text FROM 'todos' WHERE completed = ? OFFSET ? LIMIT ?",
-          }
-        `)
+      // Test with only limit
+      expect(dump(db.todos.select('id', 'text').where('completed', true).limit(10))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            1,
+            10,
+          ],
+          "query": "SELECT id, text FROM 'todos' WHERE completed = ? LIMIT ?",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
+        }
+      `)
     })
 
     it('should handle COUNT queries', () => {
-      expect(db.todos.count().asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.count())).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT COUNT(*) as count FROM 'todos'",
+          "schema": "(ReadonlyArray<({ readonly count: number } <-> number)> <-> number)",
         }
       `)
-      expect(db.todos.count().where('completed', true).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.count().where('completed', true))).toMatchInlineSnapshot(`
         {
           "bindValues": [
             1,
           ],
           "query": "SELECT COUNT(*) as count FROM 'todos' WHERE completed = ?",
+          "schema": "(ReadonlyArray<({ readonly count: number } <-> number)> <-> number)",
         }
       `)
     })
 
     it('should handle NULL comparisons', () => {
-      expect(db.todos.select('id', 'text').where('deletedAt', '=', null).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id', 'text').where('deletedAt', '=', null))).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT id, text FROM 'todos' WHERE deletedAt IS NULL",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
-      expect(db.todos.select('id', 'text').where('deletedAt', '!=', null).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.select('id', 'text').where('deletedAt', '!=', null))).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT id, text FROM 'todos' WHERE deletedAt IS NOT NULL",
+          "schema": "ReadonlyArray<{ readonly id: string; readonly text: string }>",
         }
       `)
     })
 
     it('should handle orderBy', () => {
-      expect(db.todos.orderBy('completed', 'desc').asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.orderBy('completed', 'desc'))).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT * FROM 'todos' ORDER BY completed desc",
+          "schema": "ReadonlyArray<todos>",
         }
       `)
 
-      expect(db.todos.orderBy([{ col: 'completed', direction: 'desc' }]).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.orderBy([{ col: 'completed', direction: 'desc' }]))).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT * FROM 'todos' ORDER BY completed desc",
+          "schema": "ReadonlyArray<todos>",
         }
       `)
 
-      expect(db.todos.orderBy([]).asSql()).toMatchInlineSnapshot(`
+      expect(dump(db.todos.orderBy([]))).toMatchInlineSnapshot(`
         {
           "bindValues": [],
           "query": "SELECT * FROM 'todos'",
+          "schema": "ReadonlyArray<todos>",
         }
       `)
     })
   })
 
-  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(dump(db.UiState.getOrCreate('sessionid-1'))).toMatchInlineSnapshot(`
+  //         {
+  //           "bindValues": [
+  //             "sessionid-1",
+  //           ],
+  //           "query": "SELECT * FROM 'UiState' WHERE id = ?",
+  //           "schema": "...", // TODO determine schema
+  //         }
+  //       `)
+  //   })
+
+  //   it('should handle getOrCreate queries with default id', () => {
+  //     expect(dump(db.UiStateWithDefaultId.getOrCreate())).toMatchInlineSnapshot(`
+  //       {
+  //         "bindValues": [],
+  //         "query": "SELECT * FROM 'UiState' WHERE id = ?",
+  //         "schema": "...", // TODO determine schema
+  //       }
+  //     `)
+  //   })
+  //   // it('should handle row queries with numbers', () => {
+  //   //   expect(dump(db.todosWithIntId.getOrCreate(123, { insertValues: { status: 'active' } }))).toMatchInlineSnapshot(`
+  //   //     {
+  //   //       "bindValues": [
+  //   //         123,
+  //   //       ],
+  //   //       "query": "SELECT * FROM 'todos_with_int_id' WHERE id = ?",
+  //   //       "schema": "...", // TODO determine schema
+  //   //     }
+  //   //   `)
+  //   // })
+  // })
+
+  describe('write operations', () => {
+    it('should handle INSERT queries', () => {
+      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "123",
+            "Buy milk",
+            "active",
+          ],
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?)",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle INSERT queries with undefined values', () => {
+      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active', completed: undefined })))
+        .toMatchInlineSnapshot(`
         {
           "bindValues": [
             "123",
+            "Buy milk",
+            "active",
+          ],
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?)",
+          "schema": "number",
+        }
+      `)
+    })
+
+    // Test helped to catch a bindValues ordering bug
+    it('should handle INSERT queries (issue)', () => {
+      expect(
+        dump(
+          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',
+          }),
+        ),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            1,
+            "Revert the user profile page",
+            2,
+            1722532520507,
+            1735492520507,
+            "a2",
+            "John Doe",
+          ],
+          "query": "INSERT INTO 'issue' (id, title, priority, created, modified, kanbanorder, creator) VALUES (?, ?, ?, ?, ?, ?, ?)",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle UPDATE queries', () => {
+      expect(dump(db.todos.update({ status: 'completed' }).where({ id: '123' }))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "completed",
+            "123",
+          ],
+          "query": "UPDATE 'todos' SET status = ? WHERE id = ?",
+          "schema": "number",
+        }
+      `)
+
+      // empty update set
+      expect(dump(db.todos.update({}).where({ id: '123' }))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [],
+          "query": "SELECT 1",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle UPDATE queries with undefined values', () => {
+      expect(dump(db.todos.update({ status: undefined, text: 'some text' }).where({ id: '123' })))
+        .toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "some text",
+            "123",
+          ],
+          "query": "UPDATE 'todos' SET text = ? WHERE id = ?",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle UPDATE queries with undefined values (issue)', () => {
+      expect(dump(db.issue.update({ priority: 2, creator: 'John Doe' }).where({ id: 1 }))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            2,
+            "John Doe",
+            1,
+          ],
+          "query": "UPDATE 'issue' SET priority = ?, creator = ? WHERE id = ?",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle DELETE queries', () => {
+      expect(dump(db.todos.delete().where({ status: 'completed' }))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "completed",
+          ],
+          "query": "DELETE FROM 'todos' WHERE status = ?",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle INSERT with ON CONFLICT', () => {
+      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'ignore')))
+        .toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "123",
+            "Buy milk",
+            "active",
+          ],
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?) ON CONFLICT (id) DO NOTHING",
+          "schema": "number",
+        }
+      `)
+
+      expect(
+        dump(
+          db.todos
+            .insert({ id: '123', text: 'Buy milk', status: 'active' })
+            .onConflict('id', 'update', { text: 'Buy soy milk', status: 'active' }),
+        ),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "123",
+            "Buy milk",
+            "active",
+            "Buy soy milk",
+            "active",
+          ],
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?) ON CONFLICT (id) DO UPDATE SET text = ?, status = ?",
+          "schema": "number",
+        }
+      `)
+
+      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'replace')))
+        .toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "123",
+            "Buy milk",
+            "active",
+          ],
+          "query": "INSERT OR REPLACE INTO 'todos' (id, text, status) VALUES (?, ?, ?)",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle ON CONFLICT with multiple columns', () => {
+      expect(
+        dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict(['id', 'status'], 'ignore')),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "123",
+            "Buy milk",
+            "active",
+          ],
+          "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?) ON CONFLICT (id, status) DO NOTHING",
+          "schema": "number",
+        }
+      `)
+    })
+
+    it('should handle RETURNING clause', () => {
+      expect(dump(db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).returning('id')))
+        .toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              "123",
+              "Buy milk",
+              "active",
+            ],
+            "query": "INSERT INTO 'todos' (id, text, status) VALUES (?, ?, ?) RETURNING id",
+            "schema": "ReadonlyArray<{ readonly id: string }>",
+          }
+        `)
+
+      expect(dump(db.todos.update({ status: 'completed' }).where({ id: '123' }).returning('id')))
+        .toMatchInlineSnapshot(`
+          {
+            "bindValues": [
+              "completed",
+              "123",
+            ],
+            "query": "UPDATE 'todos' SET status = ? WHERE id = ? RETURNING id",
+            "schema": "ReadonlyArray<{ readonly id: string }>",
+          }
+        `)
+
+      expect(dump(db.todos.delete().where({ status: 'completed' }).returning('id'))).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "completed",
           ],
-          "query": "SELECT * FROM 'todos' WHERE id = ?",
+          "query": "DELETE FROM 'todos' WHERE status = ? RETURNING id",
+          "schema": "ReadonlyArray<{ readonly id: string }>",
         }
       `)
     })