@livestore/common 0.4.0-dev.9 → 0.5.0-dev.0

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

@@ -1,12 +1,82 @@
 import { shouldNeverHappen } from '@livestore/utils'
-import { Schema } from '@livestore/utils/effect'
+import { Schema, SchemaAST, Struct } from '@livestore/utils/effect'
 
-import { SessionIdSymbol } from '../../../../adapter-types.ts'
+import { SessionIdSymbol } from '../../../../session-id-symbol.ts'
 import type { SqlValue } from '../../../../util.ts'
 import type { State } from '../../../mod.ts'
 import type { QueryBuilderAst } from './api.ts'
 
+/**
+ * Extracts array element schema from a JSON array AST with a JSON string encoding.
+ * Returns the element schema, or undefined if the AST is not a JSON array.
+ */
+const extractJsonArrayElementSchema = (ast: SchemaAST.AST): Schema.Top | undefined => {
+  if (hasJsonStringEncoding(ast) === false) return undefined
+
+  const typeAst = SchemaAST.toType(ast)
+  // Check if the type side is Arrays (Effect's internal representation of Array)
+  if (SchemaAST.isArrays(typeAst) === false) return undefined
+
+  // For Schema.Array, rest contains the element AST - get the first one.
+  const restElement = typeAst.rest[0]
+  if (restElement === undefined) return undefined
+
+  return Schema.make(restElement)
+}
+
+/**
+ * For JSON array columns, extracts the element schema from Schema.fromJsonString(Schema.Array(ElementSchema)).
+ * Also handles nullable JSON arrays (Schema.NullOr(Schema.fromJsonString(Schema.Array(...)))).
+ * Returns the element schema, or undefined if the column is not a JSON array.
+ */
+const getJsonArrayElementSchema = (colSchema: Schema.Top): Schema.Top | undefined => {
+  const ast = colSchema.ast
+
+  // Case 1: Direct JSON string encoding (non-nullable JSON array)
+  const direct = extractJsonArrayElementSchema(ast)
+  if (direct !== undefined) return direct
+
+  // Case 2: Nullable JSON array - Schema.NullOr wraps the JSON array in a Union.
+  if (SchemaAST.isUnion(ast) === true) {
+    for (const member of ast.types) {
+      const result = extractJsonArrayElementSchema(member)
+      if (result !== undefined) return result
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * `SchemaTransformation.fromJsonString` is a factory since Effect rc.109, so encoding links can no
+ * longer be matched by identity. `Schema.fromJsonString` annotates its encoded side as
+ * `application/json`, which identifies the link regardless of the reviver/replacer/space options.
+ */
+const hasJsonStringEncoding = (ast: SchemaAST.AST): boolean =>
+  ast.encoding?.some((link) => link.to.annotations?.contentMediaType === 'application/json') === true
+
+/**
+ * Encodes a JSON array element to the representation returned by SQLite's json_each().
+ * Objects/arrays are stringified so they match json_each's TEXT representation.
+ */
+const encodeJsonArrayElementValue = (elementSchema: Schema.Top, value: unknown): SqlValue => {
+  const encoded = Schema.encodeSync(elementSchema as Schema.Codec<unknown, SqlValue>)(value)
+
+  if (encoded === null) return null
+  if (typeof encoded === 'object') {
+    // Objects and arrays need to be JSON-stringified to match json_each() output
+    return JSON.stringify(encoded)
+  }
+  if (typeof encoded === 'boolean') {
+    return encoded === true ? 1 : 0
+  }
+
+  return encoded
+}
+
 // Helper functions for SQL generation
+const quoteIdentifier = (identifier: string): string => `"${identifier.replace(/"/g, '""')}"`
+
 const formatWhereClause = (
   whereConditions: ReadonlyArray<QueryBuilderAst.Where>,
   tableDef: State.SQLite.TableDefBase,
@@ -16,13 +86,15 @@ const formatWhereClause = (
 
   const whereClause = whereConditions
     .map(({ col, op, value }) => {
+      const quotedCol = quoteIdentifier(col)
+
       // Handle NULL values
       if (value === null) {
         if (op !== '=' && op !== '!=') {
           throw new Error(`Unsupported operator for NULL value: ${op}`)
         }
         const opStmt = op === '=' ? 'IS' : 'IS NOT'
-        return `${col} ${opStmt} NULL`
+        return `${quotedCol} ${opStmt} NULL`
       }
 
       // Get column definition and encode value
@@ -31,12 +103,29 @@ const formatWhereClause = (
         throw new Error(`Column ${col} not found`)
       }
 
+      // Handle JSON array containment operators
+      if (op === 'JSON_CONTAINS' || op === 'JSON_NOT_CONTAINS') {
+        const elementSchema = getJsonArrayElementSchema(colDef.schema)
+        if (elementSchema === undefined) {
+          throw new Error(
+            `${op} operator can only be used on JSON array columns, but column "${col}" is not a JSON array`,
+          )
+        }
+
+        const existsOp = op === 'JSON_CONTAINS' ? 'EXISTS' : 'NOT EXISTS'
+        // Encode the element value using the element schema
+        // Objects are JSON-stringified to match json_each() output
+        const encodedValue = encodeJsonArrayElementValue(elementSchema, value)
+        bindValues.push(encodedValue)
+        return `${existsOp} (SELECT 1 FROM json_each(${quotedCol}) WHERE value = ?)`
+      }
+
       // Handle array values for IN/NOT IN operators
       const isArray = op === 'IN' || op === 'NOT IN'
 
-      if (isArray) {
+      if (isArray === true) {
         // Verify value is an array
-        if (!Array.isArray(value)) {
+        if (Array.isArray(value) === false) {
           return shouldNeverHappen(`Expected array value for ${op} operator but got`, value)
         }
 
@@ -48,11 +137,11 @@ const formatWhereClause = (
         const encodedValues = value.map((v) => Schema.encodeSync(colDef.schema)(v)) as SqlValue[]
         bindValues.push(...encodedValues)
         const placeholders = encodedValues.map(() => '?').join(', ')
-        return `${col} ${op} (${placeholders})`
+        return `${quotedCol} ${op} (${placeholders})`
       } else {
         const encodedValue = Schema.encodeSync(colDef.schema)(value)
         bindValues.push(encodedValue as SqlValue)
-        return `${col} ${op} ?`
+        return `${quotedCol} ${op} ?`
       }
     })
     .join(' AND ')
@@ -61,8 +150,8 @@ const formatWhereClause = (
 }
 
 const formatReturningClause = (returning?: string[]): string => {
-  if (!returning || returning.length === 0) return ''
-  return ` RETURNING ${returning.join(', ')}`
+  if (returning == null || returning.length === 0) return ''
+  return ` RETURNING ${returning.map(quoteIdentifier).join(', ')}`
 }
 
 export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: SqlValue[]; usedTables: Set<string> } => {
@@ -72,6 +161,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
   // INSERT query
   if (ast._tag === 'InsertQuery') {
     const columns = Object.keys(ast.values)
+    const quotedColumns = columns.map(quoteIdentifier)
     const placeholders = columns.map(() => '?').join(', ')
     const encodedValues = Schema.encodeSync(ast.tableDef.insertSchema)(ast.values)
 
@@ -84,14 +174,15 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     let conflictClause = '' // Store the ON CONFLICT clause separately
 
     // Handle ON CONFLICT clause
-    if (ast.onConflict) {
+    if (ast.onConflict !== undefined) {
       // 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 {
         // Build the ON CONFLICT clause for IGNORE or UPDATE
-        conflictClause = ` ON CONFLICT (${ast.onConflict.targets.join(', ')}) `
+        const conflictTargets = ast.onConflict.targets.map(quoteIdentifier).join(', ')
+        conflictClause = ` ON CONFLICT (${conflictTargets}) `
         if (ast.onConflict.action._tag === 'ignore') {
           conflictClause += 'DO NOTHING'
         } else {
@@ -105,8 +196,9 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
           const updates = updateCols
             .map((col) => {
               const value = updateValues[col]
+              const quotedCol = quoteIdentifier(col)
               // If the value is undefined, use excluded.col
-              return value === undefined ? `${col} = excluded.${col}` : `${col} = ?`
+              return value === undefined ? `${quotedCol} = excluded.${quotedCol}` : `${quotedCol} = ?`
             })
             .join(', ')
 
@@ -129,7 +221,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     }
 
     // Construct the main query part
-    let query = `${insertVerb} INTO '${ast.tableDef.sqliteDef.name}' (${columns.join(', ')}) VALUES (${placeholders})`
+    let query = `${insertVerb} INTO '${ast.tableDef.sqliteDef.name}' (${quotedColumns.join(', ')}) VALUES (${placeholders})`
 
     // Append the conflict clause if it was generated (i.e., not for REPLACE)
     query += conflictClause
@@ -150,17 +242,19 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
       // return shouldNeverHappen('UPDATE query requires at least one column to set.')
     }
 
-    const encodedValues = Schema.encodeSync(Schema.partial(ast.tableDef.rowSchema))(ast.values)
+    const encodedValues = Schema.encodeSync(ast.tableDef.rowSchema.mapFields(Struct.map(Schema.optional)))(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(', ')}`
+    let query = `UPDATE '${ast.tableDef.sqliteDef.name}' SET ${setColumns
+      .map((col) => `${quoteIdentifier(col)} = ?`)
+      .join(', ')}`
 
     const whereClause = formatWhereClause(ast.where, ast.tableDef, bindValues)
-    if (whereClause) query += ` ${whereClause}`
+    if (whereClause !== undefined) query += ` ${whereClause}`
 
     query += formatReturningClause(ast.returning)
     return { query, bindValues, usedTables }
@@ -171,7 +265,7 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     let query = `DELETE FROM '${ast.tableDef.sqliteDef.name}'`
 
     const whereClause = formatWhereClause(ast.where, ast.tableDef, bindValues)
-    if (whereClause) query += ` ${whereClause}`
+    if (whereClause !== undefined) query += ` ${whereClause}`
 
     query += formatReturningClause(ast.returning)
     return { query, bindValues, usedTables }
@@ -201,31 +295,31 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
     const encodedId = ast.id === SessionIdSymbol ? ast.id : Schema.encodeSync(idColDef.schema)(ast.id)
 
     return {
-      query: `SELECT * FROM '${ast.tableDef.sqliteDef.name}' WHERE id = ?`,
+      query: `SELECT * FROM '${ast.tableDef.sqliteDef.name}' WHERE ${quoteIdentifier('id')} = ?`,
       bindValues: [encodedId as SqlValue],
       usedTables,
     }
   }
 
   // SELECT query
-  const columnsStmt = ast.select.columns.length === 0 ? '*' : ast.select.columns.join(', ')
+  const columnsStmt = ast.select.columns.length === 0 ? '*' : ast.select.columns.map(quoteIdentifier).join(', ')
   const selectStmt = `SELECT ${columnsStmt}`
   const fromStmt = `FROM '${ast.tableDef.sqliteDef.name}'`
   const whereStmt = formatWhereClause(ast.where, ast.tableDef, bindValues)
 
   const orderByStmt =
     ast.orderBy.length > 0
-      ? `ORDER BY ${ast.orderBy.map(({ col, direction }) => `${col} ${direction}`).join(', ')}`
+      ? `ORDER BY ${ast.orderBy.map(({ col, direction }) => `${quoteIdentifier(col)} ${direction}`).join(', ')}`
       : ''
 
   const limitStmt = ast.limit._tag === 'Some' ? `LIMIT ?` : ''
   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)
+  // Push limit and offset values in the correct order matching the query string
   if (ast.limit._tag === 'Some') bindValues.push(ast.limit.value)
+  if (ast.offset._tag === 'Some') bindValues.push(ast.offset.value)
 
-  const query = [selectStmt, fromStmt, whereStmt, orderByStmt, offsetStmt, limitStmt]
+  const query = [selectStmt, fromStmt, whereStmt, orderByStmt, limitStmt, offsetStmt]
     .map((clause) => clause.trim())
     .filter((clause) => clause.length > 0)
     .join(' ')