@livestore/common 0.4.0-dev.17 → 0.4.0-dev.19

package/src/schema/state/sqlite/column-def.test.ts

@@ -278,12 +278,29 @@ describe('getColumnDefForSchema', () => {
       expect(State.SQLite.getColumnDefForSchema(StatusEnum).columnType).toBe('text')
       expect(State.SQLite.getColumnDefForSchema(StatusUnion).columnType).toBe('text')
     })
+
+    it('should handle unions of numeric literals as integer column', () => {
+      const IntervalSchema = Schema.Literal(1, 5, 15, 30)
+
+      const columnDef = State.SQLite.getColumnDefForSchema(IntervalSchema)
+
+      expect(columnDef.columnType).toBe('integer')
+    })
+
+    it('should handle unions of non-integer numeric literals as real column', () => {
+      const PercentSchema = Schema.Literal(0.1, 0.2, 0.25)
+
+      const columnDef = State.SQLite.getColumnDefForSchema(PercentSchema)
+
+      expect(columnDef.columnType).toBe('real')
+    })
   })
 
   describe('binary data', () => {
     it('should handle Uint8Array as blob column', () => {
       const columnDef = State.SQLite.getColumnDefForSchema(Schema.Uint8Array)
-      expect(columnDef.columnType).toBe('text') // Stored as JSON
+      expect(columnDef.columnType).toBe('blob')
+      expect(columnDef.schema.toString()).toBe('Uint8ArrayFromSelf')
     })
   })
 

package/src/schema/state/sqlite/column-def.ts

@@ -179,33 +179,16 @@ const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false
     return SqliteDsl.real({ schema: coreSchema, nullable })
   }
 
-  // Literals based on their type
-  if (SchemaAST.isLiteral(coreAst)) {
-    const value = coreAst.literal
-    if (typeof value === 'boolean') return SqliteDsl.boolean({ nullable })
+  if (isUint8ArraySchema(coreAst) || isUint8ArraySchema(encodedAst)) {
+    return SqliteDsl.blob({ schema: Schema.Uint8ArrayFromSelf as Schema.Schema<Uint8Array<ArrayBuffer>>, nullable })
   }
 
-  if (isLiteralUnionOf(coreAst, (value): value is string => typeof value === 'string')) {
-    return SqliteDsl.text({ schema: coreSchema, nullable })
-  }
-
-  // Literals based on their encoded type
-  if (SchemaAST.isLiteral(encodedAst)) {
-    const value = encodedAst.literal
-    if (typeof value === 'string') return SqliteDsl.text({ schema: coreSchema, nullable })
-    if (typeof value === 'number') {
-      // Check if the original schema is Int
-      const id = SchemaAST.getIdentifierAnnotation(coreAst).pipe(Option.getOrElse(() => ''))
-      if (id === 'Int') {
-        return SqliteDsl.integer({ schema: coreSchema, nullable })
-      }
-      return SqliteDsl.real({ schema: coreSchema, nullable })
-    }
-  }
+  const literalColumn = getLiteralColumnDefinition(encodedAst, coreSchema, nullable, coreAst)
+  if (literalColumn) return literalColumn
 
-  if (isLiteralUnionOf(encodedAst, (value): value is string => typeof value === 'string')) {
-    return SqliteDsl.text({ schema: coreSchema, nullable })
-  }
+  // Fallback to checking the original AST in case the encoded schema differs
+  const coreLiteralColumn = getLiteralColumnDefinition(coreAst, coreSchema, nullable, coreAst)
+  if (coreLiteralColumn) return coreLiteralColumn
 
   // Everything else needs JSON encoding
   return SqliteDsl.json({ schema: coreSchema, nullable })
@@ -230,10 +213,70 @@ const stripNullable = (ast: SchemaAST.AST): SchemaAST.AST => {
   return SchemaAST.Union.make(coreTypes, ast.annotations)
 }
 
-const isLiteralUnionOf = <T extends SchemaAST.LiteralValue>(
+const getLiteralColumnDefinition = (
   ast: SchemaAST.AST,
-  predicate: (value: SchemaAST.LiteralValue) => value is T,
-): ast is SchemaAST.Union & { types: ReadonlyArray<SchemaAST.Literal & { literal: T }> } =>
-  SchemaAST.isUnion(ast) &&
-  ast.types.length > 0 &&
-  ast.types.every((type) => SchemaAST.isLiteral(type) && predicate(type.literal))
+  schema: Schema.Schema.AnyNoContext,
+  nullable: boolean,
+  sourceAst: SchemaAST.AST,
+): SqliteDsl.ColumnDefinition.Any | null => {
+  const literalValues = extractLiteralValues(ast)
+  if (!literalValues) return null
+
+  const literalType = getLiteralValueType(literalValues)
+  switch (literalType) {
+    case 'string':
+      return SqliteDsl.text({ schema, nullable })
+    case 'number': {
+      const id = SchemaAST.getIdentifierAnnotation(sourceAst).pipe(Option.getOrElse(() => ''))
+      if (id === 'Int' || id === 'DateFromNumber') {
+        return SqliteDsl.integer({ schema, nullable })
+      }
+
+      const useIntegerColumn =
+        literalValues.length > 1 && literalValues.every((value) => typeof value === 'number' && Number.isInteger(value))
+
+      return useIntegerColumn ? SqliteDsl.integer({ schema, nullable }) : SqliteDsl.real({ schema, nullable })
+    }
+    case 'boolean':
+      return SqliteDsl.boolean({ nullable })
+    case 'bigint':
+      return SqliteDsl.integer({ schema, nullable })
+    default:
+      return null
+  }
+}
+
+const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.LiteralValue> | null => {
+  if (SchemaAST.isLiteral(ast)) return [ast.literal]
+
+  if (SchemaAST.isUnion(ast) && ast.types.length > 0 && ast.types.every((type) => SchemaAST.isLiteral(type))) {
+    return ast.types.map((type) => (type as SchemaAST.Literal).literal)
+  }
+
+  return null
+}
+
+const getLiteralValueType = (
+  literals: ReadonlyArray<SchemaAST.LiteralValue>,
+): 'string' | 'number' | 'boolean' | 'bigint' | null => {
+  const literalTypes = new Set(literals.map((value) => (value === null ? 'null' : typeof value)))
+  if (literalTypes.size !== 1) return null
+
+  const [literalType] = literalTypes
+  return literalType === 'string' || literalType === 'number' || literalType === 'boolean' || literalType === 'bigint'
+    ? literalType
+    : null
+}
+
+const isUint8ArraySchema = (ast: SchemaAST.AST): boolean => {
+  const identifier = SchemaAST.getIdentifierAnnotation(ast)
+  if (Option.isSome(identifier) && identifier.value.includes('Uint8Array')) {
+    return true
+  }
+
+  if (SchemaAST.isTupleType(ast)) {
+    return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumberKeyword(ast.rest[0]!.type)
+  }
+
+  return false
+}

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

@@ -1,14 +1,14 @@
 import { shouldNeverHappen } from '@livestore/utils'
 
 import type { MigrationOptions } from '../../../adapter-types.ts'
-import type { Materializer } from '../../EventDef.ts'
+import type { Materializer } from '../../EventDef/mod.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/state-tables.ts'
 import type { TableDef, TableDefBase } from './table-def.ts'
 
-export * from '../../EventDef.ts'
+export * from '../../EventDef/mod.ts'
 export {
   type ClientDocumentTableDef,
   ClientDocumentTableDefSymbol,

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

@@ -347,22 +347,26 @@ export namespace QueryBuilder {
     >
 
     /**
-     * Example: If the row already exists, it will be ignored.
+     * Upsert: insert a row, or handle conflicts on existing rows.
+     * Equivalent to SQLite's `INSERT ... ON CONFLICT` clause.
+     *
+     * Actions:
+     * - `'ignore'`: Skip the insert if a row with the same key exists
+     * - `'replace'`: Delete the existing row and insert the new one
+     * - `'update'`: Update specific columns on the existing row
+     *
      * ```ts
+     * // Ignore: skip if row exists
      * db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'ignore')
-     * ```
      *
-     * Example: If the row already exists, it will be replaced.
-     * ```ts
+     * // Replace: delete existing row and insert new one
      * db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'replace')
-     * ```
      *
-     * Example: If the row already exists, it will be updated.
-     * ```ts
+     * // Update: merge specific columns into existing row
      * db.todos.insert({ id: '123', text: 'Buy milk', status: 'active' }).onConflict('id', 'update', { text: 'Buy soy milk' })
      * ```
      *
-     * NOTE This API doesn't yet support composite primary keys.
+     * NOTE: Composite primary keys are not yet supported.
      */
     readonly onConflict: {
       <TTarget extends SingleOrReadonlyArray<keyof TTableDef['sqliteDef']['columns']>>(

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

@@ -7,6 +7,8 @@ import type { State } from '../../../mod.ts'
 import type { QueryBuilderAst } from './api.ts'
 
 // 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 +18,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
@@ -48,11 +52,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 ')
@@ -62,7 +66,7 @@ const formatWhereClause = (
 
 const formatReturningClause = (returning?: string[]): string => {
   if (!returning || returning.length === 0) return ''
-  return ` RETURNING ${returning.join(', ')}`
+  return ` RETURNING ${returning.map(quoteIdentifier).join(', ')}`
 }
 
 export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: SqlValue[]; usedTables: Set<string> } => {
@@ -72,6 +76,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)
 
@@ -91,7 +96,8 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
         // 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 +111,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 +136,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
@@ -157,7 +164,9 @@ export const astToSql = (ast: QueryBuilderAst): { query: string; bindValues: Sql
       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}`
@@ -201,21 +210,21 @@ 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 ?` : ''