@livestore/common 0.3.0-dev.28 → 0.3.0-dev.29

package/src/query-builder/api.ts

@@ -1,10 +1,10 @@
-import type { GetValForKey } from '@livestore/utils'
+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 { QueryInfo } from '../query-info.js'
+import type { ClientDocumentTableDef } from '../schema/client-document-def.js'
 import type { SqliteDsl } from '../schema/db-schema/mod.js'
-import type { DbSchema } from '../schema/mod.js'
+import type { State } from '../schema/mod.js'
 import type { SqlValue } from '../util.js'
 
 export type QueryBuilderAst =
@@ -26,28 +26,28 @@ export namespace QueryBuilderAst {
     readonly orderBy: ReadonlyArray<OrderBy>
     readonly offset: Option.Option<number>
     readonly limit: Option.Option<number>
-    readonly tableDef: DbSchema.TableDefBase
+    readonly tableDef: State.SQLite.TableDefBase
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
     readonly resultSchemaSingle: Schema.Schema<any>
   }
 
   export interface CountQuery {
     readonly _tag: 'CountQuery'
-    readonly tableDef: DbSchema.TableDefBase
+    readonly tableDef: State.SQLite.TableDefBase
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
     readonly resultSchema: Schema.Schema<number, ReadonlyArray<{ count: number }>>
   }
 
   export interface RowQuery {
     readonly _tag: 'RowQuery'
-    readonly tableDef: DbSchema.TableDefBase
-    readonly id: string | SessionIdSymbol | number
-    readonly insertValues: Record<string, unknown>
+    readonly tableDef: State.SQLite.ClientDocumentTableDef.Any
+    readonly id: string | SessionIdSymbol
+    readonly explicitDefaultValues: Record<string, unknown>
   }
 
   export interface InsertQuery {
     readonly _tag: 'InsertQuery'
-    readonly tableDef: DbSchema.TableDefBase
+    readonly tableDef: State.SQLite.TableDefBase
     readonly values: Record<string, unknown>
     readonly onConflict: OnConflict | undefined
     readonly returning: string[] | undefined
@@ -56,7 +56,7 @@ export namespace QueryBuilderAst {
 
   export interface OnConflict {
     /** Conflicting column name */
-    readonly target: string
+    readonly targets: string[]
     readonly action:
       | { readonly _tag: 'ignore' }
       | { readonly _tag: 'replace' }
@@ -68,7 +68,7 @@ export namespace QueryBuilderAst {
 
   export interface UpdateQuery {
     readonly _tag: 'UpdateQuery'
-    readonly tableDef: DbSchema.TableDefBase
+    readonly tableDef: State.SQLite.TableDefBase
     readonly values: Record<string, unknown>
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
     readonly returning: string[] | undefined
@@ -77,7 +77,7 @@ export namespace QueryBuilderAst {
 
   export interface DeleteQuery {
     readonly _tag: 'DeleteQuery'
-    readonly tableDef: DbSchema.TableDefBase
+    readonly tableDef: State.SQLite.TableDefBase
     readonly where: ReadonlyArray<QueryBuilderAst.Where>
     readonly returning: string[] | undefined
     readonly resultSchema: Schema.Schema<any>
@@ -99,27 +99,31 @@ export namespace QueryBuilderAst {
 
 export const QueryBuilderAstSymbol = Symbol.for('QueryBuilderAst')
 export type QueryBuilderAstSymbol = typeof QueryBuilderAstSymbol
-export const TypeId = Symbol.for('QueryBuilder')
-export type TypeId = typeof TypeId
+
+export const QueryBuilderResultSymbol = Symbol.for('QueryBuilderResult')
+export type QueryBuilderResultSymbol = typeof QueryBuilderResultSymbol
+
+export const QueryBuilderTypeId = Symbol.for('QueryBuilder')
+export type QueryBuilderTypeId = typeof QueryBuilderTypeId
 
 export const isQueryBuilder = (value: unknown): value is QueryBuilder<any, any, any> =>
-  Predicate.hasProperty(value, TypeId)
+  Predicate.hasProperty(value, QueryBuilderTypeId)
 
 export type QueryBuilder<
   TResult,
-  TTableDef extends DbSchema.TableDefBase,
+  TTableDef extends State.SQLite.TableDefBase,
   /** Used to gradually remove features from the API based on the query context */
   TWithout extends QueryBuilder.ApiFeature = never,
-  TQueryInfo extends QueryInfo = QueryInfo.None,
 > = {
-  readonly [TypeId]: TypeId
+  readonly [QueryBuilderTypeId]: QueryBuilderTypeId
   readonly [QueryBuilderAstSymbol]: QueryBuilderAst
+  readonly ['ResultType']: TResult
   readonly asSql: () => { query: string; bindValues: SqlValue[] }
   readonly toString: () => string
-} & Omit<QueryBuilder.ApiFull<TResult, TTableDef, TWithout, TQueryInfo>, TWithout>
+} & Omit<QueryBuilder.ApiFull<TResult, TTableDef, TWithout>, TWithout>
 
 export namespace QueryBuilder {
-  export type Any = QueryBuilder<any, any, any, any>
+  export type Any = QueryBuilder<any, any, any>
   export type WhereOps = WhereOps.Equality | WhereOps.Order | WhereOps.Like | WhereOps.In
 
   export namespace WhereOps {
@@ -147,7 +151,7 @@ export namespace QueryBuilder {
     | 'returning'
     | 'onConflict'
 
-  export type WhereParams<TTableDef extends DbSchema.TableDefBase> = Partial<{
+  export type WhereParams<TTableDef extends State.SQLite.TableDefBase> = Partial<{
     [K in keyof TTableDef['sqliteDef']['columns']]:
       | TTableDef['sqliteDef']['columns'][K]['schema']['Type']
       | { op: QueryBuilder.WhereOps.SingleValue; value: TTableDef['sqliteDef']['columns'][K]['schema']['Type'] }
@@ -158,40 +162,31 @@ export namespace QueryBuilder {
       | undefined
   }>
 
-  export type OrderByParams<TTableDef extends DbSchema.TableDefBase> = ReadonlyArray<{
+  export type OrderByParams<TTableDef extends State.SQLite.TableDefBase> = ReadonlyArray<{
     col: keyof TTableDef['sqliteDef']['columns'] & string
     direction: 'asc' | 'desc'
   }>
 
-  export type ApiFull<
-    TResult,
-    TTableDef extends DbSchema.TableDefBase,
-    TWithout extends ApiFeature,
-    TQueryInfo extends QueryInfo,
-  > = {
+  export type ApiFull<TResult, TTableDef extends State.SQLite.TableDefBase, TWithout extends ApiFeature> = {
     /**
      * `SELECT *` is the default
      *
      * Example:
      * ```ts
      * db.todos.select('id', 'text', 'completed')
-     * db.todos.select('id', { pluck: true })
+     * db.todos.select('id')
      * ```
      */
     readonly select: {
-      <TColumn extends keyof TTableDef['sqliteDef']['columns'] & string, TPluck extends boolean = false>(
-        column: TColumn,
-        options?: { pluck: TPluck },
+      /** Selects and plucks a single column */
+      <TColumn extends keyof TTableDef['sqliteDef']['columns'] & string>(
+        pluckColumn: TColumn,
       ): QueryBuilder<
-        TPluck extends true
-          ? ReadonlyArray<TTableDef['sqliteDef']['columns'][TColumn]['schema']['Type']>
-          : ReadonlyArray<{
-              readonly [K in TColumn]: TTableDef['sqliteDef']['columns'][K]['schema']['Type']
-            }>,
+        ReadonlyArray<TTableDef['sqliteDef']['columns'][TColumn]['schema']['Type']>,
         TTableDef,
-        TWithout | 'row' | 'select' | 'returning' | 'onConflict',
-        TQueryInfo
+        TWithout | 'row' | 'select' | 'returning' | 'onConflict'
       >
+      /** Select multiple columns */
       <TColumns extends keyof TTableDef['sqliteDef']['columns'] & string>(
         ...columns: TColumns[]
         // TODO also support arbitrary SQL selects
@@ -201,8 +196,7 @@ export namespace QueryBuilder {
           readonly [K in TColumns]: TTableDef['sqliteDef']['columns'][K]['schema']['Type']
         }>,
         TTableDef,
-        TWithout | 'row' | 'select' | 'count' | 'returning' | 'onConflict',
-        TQueryInfo
+        TWithout | 'row' | 'select' | 'count' | 'returning' | 'onConflict'
       >
     }
 
@@ -222,18 +216,16 @@ export namespace QueryBuilder {
      * TODO: Also support `OR`
      */
     readonly where: {
-      <TParams extends QueryBuilder.WhereParams<TTableDef>>(
-        params: TParams,
-      ): QueryBuilder<TResult, TTableDef, TWithout | 'row' | 'select', TQueryInfo>
+      (params: QueryBuilder.WhereParams<TTableDef>): QueryBuilder<TResult, TTableDef, TWithout | 'row' | 'select'>
       <TColName extends keyof TTableDef['sqliteDef']['columns']>(
         col: TColName,
         value: TTableDef['sqliteDef']['columns'][TColName]['schema']['Type'],
-      ): QueryBuilder<TResult, TTableDef, TWithout | 'row' | 'select', TQueryInfo>
+      ): QueryBuilder<TResult, TTableDef, TWithout | 'row' | 'select'>
       <TColName extends keyof TTableDef['sqliteDef']['columns']>(
         col: TColName,
         op: QueryBuilder.WhereOps,
         value: TTableDef['sqliteDef']['columns'][TColName]['schema']['Type'],
-      ): QueryBuilder<TResult, TTableDef, TWithout | 'row' | 'select', TQueryInfo>
+      ): QueryBuilder<TResult, TTableDef, TWithout | 'row' | 'select'>
     }
 
     /**
@@ -246,8 +238,7 @@ export namespace QueryBuilder {
     readonly count: () => QueryBuilder<
       number,
       TTableDef,
-      TWithout | 'row' | 'count' | 'select' | 'orderBy' | 'first' | 'offset' | 'limit' | 'returning' | 'onConflict',
-      TQueryInfo
+      TWithout | 'row' | 'count' | 'select' | 'orderBy' | 'first' | 'offset' | 'limit' | 'returning' | 'onConflict'
     >
 
     /**
@@ -260,10 +251,10 @@ export namespace QueryBuilder {
       <TColName extends keyof TTableDef['sqliteDef']['columns'] & string>(
         col: TColName,
         direction: 'asc' | 'desc',
-      ): QueryBuilder<TResult, TTableDef, TWithout | 'returning' | 'onConflict', TQueryInfo>
+      ): QueryBuilder<TResult, TTableDef, TWithout | 'returning' | 'onConflict'>
       <TParams extends QueryBuilder.OrderByParams<TTableDef>>(
         params: TParams,
-      ): QueryBuilder<TResult, TTableDef, TWithout | 'returning' | 'onConflict', TQueryInfo>
+      ): QueryBuilder<TResult, TTableDef, TWithout | 'returning' | 'onConflict'>
     }
 
     /**
@@ -274,12 +265,7 @@ export namespace QueryBuilder {
      */
     readonly offset: (
       offset: number,
-    ) => QueryBuilder<
-      TResult,
-      TTableDef,
-      TWithout | 'row' | 'offset' | 'orderBy' | 'returning' | 'onConflict',
-      TQueryInfo
-    >
+    ) => QueryBuilder<TResult, TTableDef, TWithout | 'row' | 'offset' | 'orderBy' | 'returning' | 'onConflict'>
 
     /**
      * Example:
@@ -292,42 +278,26 @@ export namespace QueryBuilder {
     ) => QueryBuilder<
       TResult,
       TTableDef,
-      TWithout | 'row' | 'limit' | 'offset' | 'first' | 'orderBy' | 'returning' | 'onConflict',
-      TQueryInfo
+      TWithout | 'row' | 'limit' | 'offset' | 'first' | 'orderBy' | 'returning' | 'onConflict'
     >
 
     /**
      * Example:
      * ```ts
      * db.todos.first()
+     * db.todos.where('id', '123').first()
      * ```
+     *
+     * Query will fail if no rows are returned and no fallback is provided.
      */
-    readonly first: <TFallback extends GetSingle<TResult> = never>(options?: {
-      fallback?: () => TFallback
+    readonly first: <TFallback = never>(options?: {
+      fallback?: () => TFallback | GetSingle<TResult>
     }) => QueryBuilder<
       TFallback | GetSingle<TResult>,
       TTableDef,
-      TWithout | 'row' | 'first' | 'orderBy' | 'select' | 'limit' | 'offset' | 'where' | 'returning' | 'onConflict',
-      TQueryInfo
+      TWithout | 'row' | 'first' | 'orderBy' | 'select' | 'limit' | 'offset' | 'where' | 'returning' | 'onConflict'
     >
 
-    /**
-     * Gets a single row from the table and will create it if it doesn't exist yet.
-     */
-    // TODO maybe call `getsert`?
-    readonly row: TTableDef['options']['isSingleton'] extends true
-      ? () => QueryBuilder<RowQuery.Result<TTableDef>, TTableDef, QueryBuilder.ApiFeature, QueryInfo.Row>
-      : TTableDef['options']['deriveMutations']['enabled'] extends false
-        ? (_: 'Error: Need to enable deriveMutations to use row()') => any
-        : TTableDef['options']['requiredInsertColumnNames'] extends never
-          ? (
-              id: string | SessionIdSymbol | number,
-            ) => QueryBuilder<RowQuery.Result<TTableDef>, TTableDef, QueryBuilder.ApiFeature, QueryInfo.Row>
-          : <TOptions extends RowQuery.RequiredColumnsOptions<TTableDef>>(
-              id: string | SessionIdSymbol | number,
-              opts: TOptions,
-            ) => QueryBuilder<RowQuery.Result<TTableDef>, TTableDef, QueryBuilder.ApiFeature, QueryInfo.Row>
-
     /**
      * Insert a new row into the table
      *
@@ -341,8 +311,7 @@ export namespace QueryBuilder {
     ) => QueryBuilder<
       TResult,
       TTableDef,
-      TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'where',
-      QueryInfo.Write
+      TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'where'
     >
 
     /**
@@ -364,24 +333,22 @@ export namespace QueryBuilder {
      * NOTE This API doesn't yet support composite primary keys.
      */
     readonly onConflict: {
-      (
-        target: string,
+      <TTarget extends SingleOrReadonlyArray<keyof TTableDef['sqliteDef']['columns']>>(
+        target: TTarget,
         action: 'ignore' | 'replace',
       ): QueryBuilder<
         TResult,
         TTableDef,
-        TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'where',
-        TQueryInfo
+        TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'where'
       >
-      <TTarget extends keyof TTableDef['sqliteDef']['columns'] & string>(
+      <TTarget extends SingleOrReadonlyArray<keyof TTableDef['sqliteDef']['columns']>>(
         target: TTarget,
         action: 'update',
-        updateValues: Partial<TTableDef['schema']['Type']>,
+        updateValues: Partial<TTableDef['rowSchema']['Type']>,
       ): QueryBuilder<
         TResult,
         TTableDef,
-        TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'where',
-        TQueryInfo
+        TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'where'
       >
     }
 
@@ -411,12 +378,11 @@ export namespace QueryBuilder {
      * ```
      */
     readonly update: (
-      values: Partial<TTableDef['schema']['Type']>,
+      values: Partial<TTableDef['rowSchema']['Type']>,
     ) => QueryBuilder<
       TResult,
       TTableDef,
-      TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'onConflict',
-      QueryInfo.Write
+      TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'onConflict'
     >
 
     /**
@@ -432,35 +398,43 @@ export namespace QueryBuilder {
     readonly delete: () => QueryBuilder<
       TResult,
       TTableDef,
-      TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'onConflict',
-      QueryInfo.Write
+      TWithout | 'row' | 'select' | 'count' | 'orderBy' | 'first' | 'offset' | 'limit' | 'onConflict'
     >
   }
 }
 
 export namespace RowQuery {
-  export type RequiredColumnsOptions<TTableDef extends DbSchema.TableDefBase> = {
+  export type GetOrCreateOptions<TTableDef extends ClientDocumentTableDef.TraitAny> = {
+    default: Partial<TTableDef['Value']>
+  }
+
+  // TODO get rid of this
+  export type RequiredColumnsOptions<TTableDef extends State.SQLite.TableDefBase> = {
     /**
      * Values to be inserted into the row if it doesn't exist yet
      */
-    insertValues: Pick<
+    explicitDefaultValues: Pick<
       SqliteDsl.FromColumns.RowDecodedAll<TTableDef['sqliteDef']['columns']>,
       SqliteDsl.FromColumns.RequiredInsertColumnNames<Omit<TTableDef['sqliteDef']['columns'], 'id'>>
     >
   }
 
-  export type Result<TTableDef extends DbSchema.TableDefBase> = TTableDef['options']['isSingleColumn'] extends true
-    ? GetValForKey<SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>, 'value'>
-    : SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>
+  export type Result<TTableDef extends State.SQLite.TableDefBase> = SqliteDsl.FromColumns.RowDecoded<
+    TTableDef['sqliteDef']['columns']
+  >
+
+  export type DocumentResult<TTableDef extends ClientDocumentTableDef.Any> = GetValForKey<
+    SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>,
+    'value'
+  >
 
-  export type ResultEncoded<TTableDef extends DbSchema.TableDefBase> =
-    TTableDef['options']['isSingleColumn'] extends true
+  export type ResultEncoded<TTableDef extends State.SQLite.TableDefBase> =
+    TTableDef['options']['isClientDocumentTable'] extends true
       ? GetValForKey<SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>, 'value'>
       : SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>
+
+  export type GetIdColumnType<TTableDef extends State.SQLite.TableDefBase> =
+    TTableDef['sqliteDef']['columns']['id']['schema']['Type']
 }
 
 type GetSingle<T> = T extends ReadonlyArray<infer U> ? U : never
-
-// export type QueryBuilderParamRef = { _tag: 'QueryBuilderParamRef' }
-// export type QueryBuilderSelectParams = { [key: string]: QueryBuilderSelectParam }
-// export type QueryBuilderSelectParam = boolean | ((ref: QueryBuilderParamRef) => QueryBuilder<any, any>)

package/src/query-builder/astToSql.ts

@@ -2,14 +2,14 @@ import { shouldNeverHappen } from '@livestore/utils'
 import { Schema } from '@livestore/utils/effect'
 
 import { SessionIdSymbol } from '../adapter-types.js'
-import type { DbSchema } from '../schema/mod.js'
+import type { State } from '../schema/mod.js'
 import type { SqlValue } from '../util.js'
 import type { QueryBuilderAst } from './api.js'
 
 // Helper functions for SQL generation
 const formatWhereClause = (
   whereConditions: ReadonlyArray<QueryBuilderAst.Where>,
-  tableDef: DbSchema.TableDefBase,
+  tableDef: State.SQLite.TableDefBase,
   bindValues: SqlValue[],
 ): string => {
   if (whereConditions.length === 0) return ''
@@ -72,52 +72,67 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
   if (ast._tag === 'InsertQuery') {
     const columns = Object.keys(ast.values)
     const placeholders = columns.map(() => '?').join(', ')
-    const values = Object.values(Schema.encodeSync(ast.tableDef.insertSchema)(ast.values)) as SqlValue[]
+    const encodedValues = Schema.encodeSync(ast.tableDef.insertSchema)(ast.values)
 
-    bindValues.push(...values)
+    // Ensure bind values are added in the same order as columns
+    columns.forEach((col) => {
+      bindValues.push(encodedValues[col] as SqlValue)
+    })
 
-    let query = `INSERT INTO '${ast.tableDef.sqliteDef.name}' (${columns.join(', ')}) VALUES (${placeholders})`
+    let insertVerb = 'INSERT'
+    let conflictClause = '' // Store the ON CONFLICT clause separately
 
     // Handle ON CONFLICT clause
     if (ast.onConflict) {
-      query += ` ON CONFLICT (${ast.onConflict.target}) `
-      if (ast.onConflict.action._tag === 'ignore') {
-        query += 'DO NOTHING'
-      } else if (ast.onConflict.action._tag === 'replace') {
-        query += 'DO REPLACE'
+      // Handle REPLACE specifically as it changes the INSERT verb
+      if (ast.onConflict.action._tag === 'replace') {
+        insertVerb = 'INSERT OR REPLACE'
+        // For REPLACE, the conflict target is implied and no further clause is needed
       } else {
-        // Handle the update record case
-        const updateValues = ast.onConflict.action.update
-        const updateCols = Object.keys(updateValues)
-        if (updateCols.length === 0) {
-          throw new Error('No update columns provided for ON CONFLICT DO UPDATE')
-        }
+        // Build the ON CONFLICT clause for IGNORE or UPDATE
+        conflictClause = ` ON CONFLICT (${ast.onConflict.targets.join(', ')}) `
+        if (ast.onConflict.action._tag === 'ignore') {
+          conflictClause += 'DO NOTHING'
+        } else {
+          // Handle the update record case
+          const updateValues = ast.onConflict.action.update
+          const updateCols = Object.keys(updateValues)
+          if (updateCols.length === 0) {
+            throw new Error('No update columns provided for ON CONFLICT DO UPDATE')
+          }
 
-        const updates = updateCols
-          .map((col) => {
+          const updates = updateCols
+            .map((col) => {
+              const value = updateValues[col]
+              // If the value is undefined, use excluded.col
+              return value === undefined ? `${col} = excluded.${col}` : `${col} = ?`
+            })
+            .join(', ')
+
+          // Add values for the parameters
+          updateCols.forEach((col) => {
             const value = updateValues[col]
-            // If the value is undefined, use excluded.col
-            return value === undefined ? `${col} = excluded.${col}` : `${col} = ?`
-          })
-          .join(', ')
-
-        // Add values for the parameters
-        updateCols.forEach((col) => {
-          const value = updateValues[col]
-          if (value !== undefined) {
-            const colDef = ast.tableDef.sqliteDef.columns[col]
-            if (colDef === undefined) {
-              throw new Error(`Column ${col} not found`)
+            if (value !== undefined) {
+              const colDef = ast.tableDef.sqliteDef.columns[col]
+              if (colDef === undefined) {
+                throw new Error(`Column ${col} not found`)
+              }
+              const encodedValue = Schema.encodeSync(colDef.schema)(value)
+              bindValues.push(encodedValue as SqlValue)
             }
-            const encodedValue = Schema.encodeSync(colDef.schema)(value)
-            bindValues.push(encodedValue as SqlValue)
-          }
-        })
+          })
 
-        query += `DO UPDATE SET ${updates}`
+          conflictClause += `DO UPDATE SET ${updates}`
+        }
       }
     }
 
+    // Construct the main query part
+    let query = `${insertVerb} INTO '${ast.tableDef.sqliteDef.name}' (${columns.join(', ')}) VALUES (${placeholders})`
+
+    // Append the conflict clause if it was generated (i.e., not for REPLACE)
+    query += conflictClause
+
     query += formatReturningClause(ast.returning)
     return { query, bindValues }
   }
@@ -125,8 +140,21 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
   // UPDATE query
   if (ast._tag === 'UpdateQuery') {
     const setColumns = Object.keys(ast.values)
-    const setValues = Object.values(Schema.encodeSync(Schema.partial(ast.tableDef.schema))(ast.values))
-    bindValues.push(...setValues)
+
+    if (setColumns.length === 0) {
+      console.warn(
+        `UPDATE query requires at least one column to set (for table ${ast.tableDef.sqliteDef.name}). Running no-op query instead to skip this update query.`,
+      )
+      return { query: 'SELECT 1', bindValues: [] }
+      // return shouldNeverHappen('UPDATE query requires at least one column to set.')
+    }
+
+    const encodedValues = Schema.encodeSync(Schema.partial(ast.tableDef.rowSchema))(ast.values)
+
+    // Ensure bind values are added in the same order as columns
+    setColumns.forEach((col) => {
+      bindValues.push(encodedValues[col] as SqlValue)
+    })
 
     let query = `UPDATE '${ast.tableDef.sqliteDef.name}' SET ${setColumns.map((col) => `${col} = ?`).join(', ')}`
 
@@ -189,10 +217,11 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
       : ''
 
   const limitStmt = ast.limit._tag === 'Some' ? `LIMIT ?` : ''
-  if (ast.limit._tag === 'Some') bindValues.push(ast.limit.value)
-
   const offsetStmt = ast.offset._tag === 'Some' ? `OFFSET ?` : ''
+
+  // Push offset and limit values in the correct order matching the query string
   if (ast.offset._tag === 'Some') bindValues.push(ast.offset.value)
+  if (ast.limit._tag === 'Some') bindValues.push(ast.limit.value)
 
   const query = [selectStmt, fromStmt, whereStmt, orderByStmt, offsetStmt, limitStmt]
     .map((clause) => clause.trim())