@livestore/common 0.4.0-dev.21 → 0.4.0-dev.23

package/src/schema/state/sqlite/client-document-def.ts

@@ -95,10 +95,12 @@ export const clientDocument = <
   Object.defineProperty(setEventDef, 'schema', {
     value: Schema.Struct({
       id: Schema.String,
-      value: options.partialSet ? Schema.partial(valueSchema) : valueSchema,
+      value: options.partialSet === true ? Schema.partial(valueSchema) : valueSchema,
     }).annotations({ title: `${name}Set:Args` }),
   })
-  Object.defineProperty(setEventDef, 'options', { value: { derived: true, clientOnly: true, facts: undefined } })
+  Object.defineProperty(setEventDef, 'options', {
+    value: { derived: true, clientOnly: true, facts: undefined, deprecated: undefined },
+  })
 
   const clientDocumentTableDefTrait: ClientDocumentTableDef.Trait<
     TName,
@@ -106,20 +108,26 @@ export const clientDocument = <
     TEncoded,
     ClientDocumentTableOptions<TType>
   > = {
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- dynamic table def composition; type safety ensured by ClientDocumentTableDef.Trait
     get: makeGetQueryBuilder(() => clientDocumentTableDef) as any,
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- dynamic table def composition; type safety ensured by SetEventDefLike signature
     set: setEventDef as any,
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- phantom type field for generic inference only
     Value: 'only-for-type-inference' as any,
     default: options.default,
     valueSchema,
     [ClientDocumentTableDefSymbol]: {
       derived: {
+        // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- dynamic event def composition; type checked at usage sites
         setEventDef: derivedSetEventDef as any,
+        // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- dynamic materializer composition; type checked at usage sites
         setMaterializer: derivedSetMaterializer as any,
       },
       options,
     },
   }
 
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- composing tableDef + clientDocumentTableDefTrait into final type; validated by satisfies above
   const clientDocumentTableDef = {
     ...tableDef,
     ...clientDocumentTableDefTrait,
@@ -139,11 +147,14 @@ export const mergeDefaultValues = <T>(defaultValues: T, explicitDefaultValues: T
   }
 
   // Get all unique keys from both objects
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Object.keys requires indexable type; T is constrained to object by preceding typeof checks
   const allKeys = new Set([...Object.keys(defaultValues as any), ...Object.keys(explicitDefaultValues as any)])
 
   return Array.from(allKeys).reduce((acc, key) => {
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- dynamic key access on generic object; keys validated from Object.keys above
     acc[key] = (explicitDefaultValues as any)[key] ?? (defaultValues as any)[key]
     return acc
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- reduce accumulator type; result type is T
   }, {} as any)
 }
 
@@ -175,7 +186,10 @@ export const createOptimisticEventSchema = ({
   defaultValue: any
   partialSet: boolean
 }) => {
-  const targetSchema = partialSet ? Schema.partial(valueSchema) : valueSchema
+  const targetSchema = partialSet === true ? Schema.partial(valueSchema) : valueSchema
+  // The transform decode must yield values in the target schema's ENCODED shape.
+  // This keeps JSON columns consistent when Encoded != Type (e.g. Option).
+  const encodeTarget = Schema.encodeSync(targetSchema)
 
   return Schema.transform(
     Schema.Unknown, // Accept any historical event structure
@@ -184,17 +198,21 @@ export const createOptimisticEventSchema = ({
       decode: (eventValue) => {
         // Try direct decode first (for current schema events)
         try {
-          return Schema.decodeUnknownSync(targetSchema)(eventValue)
+          const decoded = Schema.decodeUnknownSync(targetSchema)(eventValue)
+          // Re-encode so downstream parseJson/column decoding sees encoded values.
+          return encodeTarget(decoded)
         } catch {
           // Optimistic decoding for historical events
 
           // Handle null/undefined/non-object cases
           if (typeof eventValue !== 'object' || eventValue === null) {
-            console.warn(`Client document: Non-object event value, using ${partialSet ? 'empty partial' : 'defaults'}`)
-            return partialSet ? {} : defaultValue
+            console.warn(
+              `Client document: Non-object event value, using ${partialSet === true ? 'empty partial' : 'defaults'}`,
+            )
+            return encodeTarget(partialSet === true ? {} : defaultValue)
           }
 
-          if (partialSet) {
+          if (partialSet === true) {
             // For partial sets: only preserve fields that exist in new schema
             const partialResult: Record<string, unknown> = {}
             let hasValidFields = false
@@ -207,16 +225,17 @@ export const createOptimisticEventSchema = ({
               // Drop fields that don't exist in new schema
             }
 
-            if (hasValidFields) {
+            if (hasValidFields === true) {
               try {
-                return Schema.decodeUnknownSync(targetSchema)(partialResult)
+                const decoded = Schema.decodeUnknownSync(targetSchema)(partialResult)
+                return encodeTarget(decoded)
               } catch {
                 // Even filtered fields don't match schema
                 console.warn('Client document: Partial fields incompatible, returning empty partial')
-                return {}
+                return encodeTarget({})
               }
             }
-            return {}
+            return encodeTarget({})
           } else {
             // Full set: merge old data with new defaults
             const merged: Record<string, unknown> = { ...defaultValue }
@@ -231,12 +250,13 @@ export const createOptimisticEventSchema = ({
 
             // Try to decode the merged value
             try {
-              return Schema.decodeUnknownSync(valueSchema)(merged)
+              const decoded = Schema.decodeUnknownSync(valueSchema)(merged)
+              return encodeTarget(decoded)
             } catch {
               // Merged value still doesn't match (e.g., type changes)
               // Fall back to pure defaults
               console.warn('Client document: Could not preserve event data, using defaults')
-              return defaultValue
+              return encodeTarget(defaultValue)
             }
           }
         }
@@ -357,11 +377,14 @@ const makeGetQueryBuilder = <TTableDef extends ClientDocumentTableDef<any, any,
     return {
       [QueryBuilderTypeId]: QueryBuilderTypeId,
       [QueryBuilderAstSymbol]: ast,
+      // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- phantom type field for generic inference only
       ResultType: 'only-for-type-inference' as any,
       asSql: () => ({ query, bindValues: [id] }),
       toString: () => query.toString(),
+      // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- spreading empty object to satisfy QueryBuilder interface requirements
       ...({} as any), // Needed for type cast
     }
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- makeGetQueryBuilder return type uses complex conditional generics
   }) as any
 }
 
@@ -544,7 +567,7 @@ export namespace ClientDocumentTableDef {
       readonly name: `${TName}Set`
       readonly args: { id: string; value: TType }
     }
-    readonly options: { derived: true; clientOnly: true; facts: undefined }
+    readonly options: { derived: true; clientOnly: true; facts: undefined; deprecated: undefined }
   }
 
   export type SetEventDef<TName extends string, TType, TOptions extends ClientDocumentTableOptions<TType>> = EventDef<

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

@@ -1,6 +1,7 @@
-import { Schema, SchemaAST } from '@livestore/utils/effect'
 import { describe, expect, test } from 'vitest'
 
+import { Schema, SchemaAST } from '@livestore/utils/effect'
+
 import { withColumnType, withPrimaryKey } from './column-annotations.ts'
 
 describe.concurrent('annotations', () => {

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

@@ -1,5 +1,6 @@
 import type { Schema } from '@livestore/utils/effect'
 import { dual, Option, SchemaAST } from '@livestore/utils/effect'
+
 import type { SqliteDsl } from './db-schema/mod.ts'
 
 export const PrimaryKeyId = Symbol.for('livestore/state/sqlite/annotations/primary-key')
@@ -79,7 +80,7 @@ const validateSchemaColumnTypeCompatibility = (
 const applyAnnotations = <T extends Schema.Schema.All>(schema: T, overrides: Record<PropertyKey, unknown>): T => {
   const identifier = SchemaAST.getIdentifierAnnotation(schema.ast)
   const shouldPreserveIdentifier = Option.isSome(identifier) && !(SchemaAST.IdentifierAnnotationId in overrides)
-  const annotations: Record<PropertyKey, unknown> = shouldPreserveIdentifier
+  const annotations: Record<PropertyKey, unknown> = shouldPreserveIdentifier === true
     ? { ...overrides, [SchemaAST.IdentifierAnnotationId]: identifier.value }
     : overrides
 

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

@@ -1,6 +1,8 @@
-import { Schema } from '@livestore/utils/effect'
 import { assert, describe, expect, it } from 'vitest'
 
+import { Schema } from '@livestore/utils/effect'
+import { objectToString } from '@livestore/utils'
+
 import * as State from '../mod.ts'
 import { withAutoIncrement, withColumnType, withDefault, withPrimaryKey, withUnique } from './column-annotations.ts'
 
@@ -299,7 +301,7 @@ describe('getColumnDefForSchema', () => {
     it('should handle Uint8Array as blob column', () => {
       const columnDef = State.SQLite.getColumnDefForSchema(Schema.Uint8Array)
       expect(columnDef.columnType).toBe('blob')
-      expect(columnDef.schema.toString()).toBe('Uint8ArrayFromSelf')
+      expect(objectToString(columnDef.schema)).toBe('Uint8ArrayFromSelf')
     })
   })
 
@@ -356,8 +358,8 @@ describe('getColumnDefForSchema', () => {
 
       expect(table.sqliteDef.columns.active.nullable).toBe(true)
       expect(table.sqliteDef.columns.active.columnType).toBe('integer')
-      expect(table.sqliteDef.columns.active.schema.toString()).toBe('(number <-> boolean) | null')
-      expect((table.rowSchema as any).fields.active.toString()).toBe('(number <-> boolean) | null')
+      expect(objectToString(table.sqliteDef.columns.active.schema)).toBe('(number <-> boolean) | null')
+      expect(String((table.rowSchema as any).fields.active)).toBe('(number <-> boolean) | null')
     })
 
     it('should handle optional complex types with JSON encoding', () => {
@@ -406,8 +408,8 @@ describe('getColumnDefForSchema', () => {
       const table = State.SQLite.table({ name: 'timers', schema })
 
       expect(table.sqliteDef.columns.status.columnType).toBe('text')
-      expect(table.sqliteDef.columns.status.schema.toString()).toBe('"idle" | "running" | "stopped"')
-      expect((table.rowSchema as any).fields.status.toString()).toBe('"idle" | "running" | "stopped"')
+      expect(objectToString(table.sqliteDef.columns.status.schema)).toBe('"idle" | "running" | "stopped"')
+      expect(String((table.rowSchema as any).fields.status)).toBe('"idle" | "running" | "stopped"')
     })
 
     it('should handle Schema.NullOr with complex types', () => {

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

@@ -20,19 +20,20 @@ export const getColumnDefForSchema = (
 
   // Extract annotations
   const getAnnotation = <T>(annotationId: symbol): Option.Option<T> =>
-    propertySignature
+    propertySignature !== undefined
       ? hasPropertyAnnotation<T>(propertySignature, annotationId)
       : SchemaAST.getAnnotation<T>(annotationId)(ast)
 
   const columnType = SchemaAST.getAnnotation<SqliteDsl.FieldColumnType>(ColumnType)(ast)
 
   // Check if schema has null (e.g., Schema.NullOr) or undefined or if it's forced nullable (optional field)
-  const isNullable = forceNullable || hasNull(ast) || hasUndefined(ast)
+  const isNullable = forceNullable === true || hasNull(ast) === true || hasUndefined(ast) === true
 
   // Get base column definition with nullable flag
-  const baseColumn = Option.isSome(columnType)
-    ? getColumnForType(columnType.value, isNullable)
-    : getColumnForSchema(schema, isNullable)
+  const baseColumn =
+    Option.isSome(columnType) === true
+      ? getColumnForType(columnType.value, isNullable)
+      : getColumnForSchema(schema, isNullable)
 
   // Apply annotations
   const primaryKey = getAnnotation<boolean>(PrimaryKeyId).pipe(Option.getOrElse(() => false))
@@ -41,9 +42,9 @@ export const getColumnDefForSchema = (
 
   return {
     ...baseColumn,
-    ...(primaryKey && { primaryKey: true }),
-    ...(autoIncrement && { autoIncrement: true }),
-    ...(Option.isSome(defaultValue) && { default: Option.some(defaultValue.value) }),
+    ...(primaryKey === true ? { primaryKey: true } : {}),
+    ...(autoIncrement === true ? { autoIncrement: true } : {}),
+    ...(Option.isSome(defaultValue) === true ? { default: Option.some(defaultValue.value) } : {}),
   }
 }
 
@@ -51,9 +52,9 @@ const hasPropertyAnnotation = <T>(
   propertySignature: SchemaAST.PropertySignature,
   annotationId: symbol,
 ): Option.Option<T> => {
-  if ('annotations' in propertySignature && propertySignature.annotations) {
+  if ('annotations' in propertySignature && propertySignature.annotations !== undefined) {
     const annotation = SchemaAST.getAnnotation<T>(annotationId)(propertySignature as any)
-    if (Option.isSome(annotation)) return annotation
+    if (Option.isSome(annotation) === true) return annotation
   }
   return SchemaAST.getAnnotation<T>(annotationId)(propertySignature.type)
 }
@@ -74,15 +75,15 @@ export const schemaFieldsToColumns = (
     const fieldSchema = Schema.make(prop.type)
 
     // Warn about lossy conversion for fields with both null and undefined
-    if (prop.isOptional) {
+    if (prop.isOptional === true) {
       const { hasNull, hasUndefined } = checkNullUndefined(fieldSchema.ast)
-      if (hasNull && hasUndefined) {
+      if (hasNull === true && hasUndefined === true) {
         console.warn(`Field '${prop.name}' has both null and undefined - treating | undefined as | null`)
       }
     }
 
     // Get column definition - pass nullable flag for optional fields
-    const columnDef = getColumnDefForSchema(fieldSchema, prop, prop.isOptional)
+    const columnDef = getColumnDefForSchema(fieldSchema, prop, prop.isOptional === true)
 
     // Check for primary key and unique annotations
     const hasPrimaryKey = hasPropertyAnnotation<boolean>(prop, PrimaryKeyId).pipe(Option.getOrElse(() => false))
@@ -91,16 +92,16 @@ export const schemaFieldsToColumns = (
     // Build final column
     columns[prop.name] = {
       ...columnDef,
-      ...(hasPrimaryKey && { primaryKey: true }),
+      ...(hasPrimaryKey === true ? { primaryKey: true } : {}),
     }
 
     // Validate primary key + nullable
     const column = columns[prop.name]
-    if (column?.primaryKey && column.nullable) {
+    if (column?.primaryKey === true && column.nullable === true) {
       throw new Error('Primary key columns cannot be nullable')
     }
 
-    if (hasUnique) uniqueColumns.push(prop.name)
+    if (hasUnique === true) uniqueColumns.push(prop.name)
   }
 
   return { columns, uniqueColumns }
@@ -111,9 +112,9 @@ const checkNullUndefined = (ast: SchemaAST.AST): { hasNull: boolean; hasUndefine
   let hasUndefined = false
 
   const visit = (type: SchemaAST.AST): void => {
-    if (SchemaAST.isUndefinedKeyword(type)) hasUndefined = true
-    else if (SchemaAST.isLiteral(type) && type.literal === null) hasNull = true
-    else if (SchemaAST.isUnion(type)) type.types.forEach(visit)
+    if (SchemaAST.isUndefinedKeyword(type) === true) hasUndefined = true
+    else if (SchemaAST.isLiteral(type) === true && type.literal === null) hasNull = true
+    else if (SchemaAST.isUnion(type) === true) type.types.forEach(visit)
   }
 
   visit(ast)
@@ -121,16 +122,16 @@ const checkNullUndefined = (ast: SchemaAST.AST): { hasNull: boolean; hasUndefine
 }
 
 const hasNull = (ast: SchemaAST.AST): boolean => {
-  if (SchemaAST.isLiteral(ast) && ast.literal === null) return true
-  if (SchemaAST.isUnion(ast)) {
+  if (SchemaAST.isLiteral(ast) === true && ast.literal === null) return true
+  if (SchemaAST.isUnion(ast) === true) {
     return ast.types.some((type) => hasNull(type))
   }
   return false
 }
 
 const hasUndefined = (ast: SchemaAST.AST): boolean => {
-  if (SchemaAST.isUndefinedKeyword(ast)) return true
-  if (SchemaAST.isUnion(ast)) {
+  if (SchemaAST.isUndefinedKeyword(ast) === true) return true
+  if (SchemaAST.isUnion(ast) === true) {
     return ast.types.some((type) => hasUndefined(type))
   }
   return false
@@ -158,7 +159,7 @@ const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false
   const coreSchema = stripNullable(ast) === ast ? schema : Schema.make(coreAst)
 
   // Special case: Boolean is transformed to integer in SQLite
-  if (SchemaAST.isBooleanKeyword(coreAst)) {
+  if (SchemaAST.isBooleanKeyword(coreAst) === true) {
     return SqliteDsl.boolean({ nullable })
   }
 
@@ -166,11 +167,11 @@ const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false
   const encodedAst = Schema.encodedSchema(coreSchema).ast
 
   // Check if the encoded type matches SQLite native types
-  if (SchemaAST.isStringKeyword(encodedAst)) {
+  if (SchemaAST.isStringKeyword(encodedAst) === true) {
     return SqliteDsl.text({ schema: coreSchema, nullable })
   }
 
-  if (SchemaAST.isNumberKeyword(encodedAst)) {
+  if (SchemaAST.isNumberKeyword(encodedAst) === true) {
     // Special cases for integer columns
     const id = SchemaAST.getIdentifierAnnotation(coreAst).pipe(Option.getOrElse(() => ''))
     if (id === 'Int' || id === 'DateFromNumber') {
@@ -179,23 +180,23 @@ const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false
     return SqliteDsl.real({ schema: coreSchema, nullable })
   }
 
-  if (isUint8ArraySchema(coreAst) || isUint8ArraySchema(encodedAst)) {
+  if (isUint8ArraySchema(coreAst) === true || isUint8ArraySchema(encodedAst) === true) {
     return SqliteDsl.blob({ schema: Schema.Uint8ArrayFromSelf as Schema.Schema<Uint8Array<ArrayBuffer>>, nullable })
   }
 
   const literalColumn = getLiteralColumnDefinition(encodedAst, coreSchema, nullable, coreAst)
-  if (literalColumn) return literalColumn
+  if (literalColumn !== null) return literalColumn
 
   // Fallback to checking the original AST in case the encoded schema differs
   const coreLiteralColumn = getLiteralColumnDefinition(coreAst, coreSchema, nullable, coreAst)
-  if (coreLiteralColumn) return coreLiteralColumn
+  if (coreLiteralColumn !== null) return coreLiteralColumn
 
   // Everything else needs JSON encoding
   return SqliteDsl.json({ schema: coreSchema, nullable })
 }
 
 const stripNullable = (ast: SchemaAST.AST): SchemaAST.AST => {
-  if (!SchemaAST.isUnion(ast)) return ast
+  if (SchemaAST.isUnion(ast) === false) return ast
 
   // Filter out null/undefined members while preserving any annotations on the union
   const coreTypes = ast.types.filter(
@@ -220,7 +221,7 @@ const getLiteralColumnDefinition = (
   sourceAst: SchemaAST.AST,
 ): SqliteDsl.ColumnDefinition.Any | null => {
   const literalValues = extractLiteralValues(ast)
-  if (!literalValues) return null
+  if (literalValues == null) return null
 
   const literalType = getLiteralValueType(literalValues)
   switch (literalType) {
@@ -235,7 +236,7 @@ const getLiteralColumnDefinition = (
       const useIntegerColumn =
         literalValues.length > 1 && literalValues.every((value) => typeof value === 'number' && Number.isInteger(value))
 
-      return useIntegerColumn ? SqliteDsl.integer({ schema, nullable }) : SqliteDsl.real({ schema, nullable })
+      return useIntegerColumn === true ? SqliteDsl.integer({ schema, nullable }) : SqliteDsl.real({ schema, nullable })
     }
     case 'boolean':
       return SqliteDsl.boolean({ nullable })
@@ -247,9 +248,13 @@ const getLiteralColumnDefinition = (
 }
 
 const extractLiteralValues = (ast: SchemaAST.AST): ReadonlyArray<SchemaAST.LiteralValue> | null => {
-  if (SchemaAST.isLiteral(ast)) return [ast.literal]
+  if (SchemaAST.isLiteral(ast) === true) return [ast.literal]
 
-  if (SchemaAST.isUnion(ast) && ast.types.length > 0 && ast.types.every((type) => SchemaAST.isLiteral(type))) {
+  if (
+    SchemaAST.isUnion(ast) === true &&
+    ast.types.length > 0 &&
+    ast.types.every((type) => SchemaAST.isLiteral(type)) === true
+  ) {
     return ast.types.map((type) => (type as SchemaAST.Literal).literal)
   }
 
@@ -270,11 +275,11 @@ const getLiteralValueType = (
 
 const isUint8ArraySchema = (ast: SchemaAST.AST): boolean => {
   const identifier = SchemaAST.getIdentifierAnnotation(ast)
-  if (Option.isSome(identifier) && identifier.value.includes('Uint8Array')) {
+  if (Option.isSome(identifier) === true && identifier.value.includes('Uint8Array') === true) {
     return true
   }
 
-  if (SchemaAST.isTupleType(ast)) {
+  if (SchemaAST.isTupleType(ast) === true) {
     return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumberKeyword(ast.rest[0]!.type)
   }
 

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

@@ -1,5 +1,7 @@
-import { Option, Schema } from '@livestore/utils/effect'
 import { describe, expect, it } from 'vitest'
+
+import { Option, Schema } from '@livestore/utils/effect'
+
 import { makeColumnSpec } from './column-spec.ts'
 import { SqliteAst } from './db-schema/mod.ts'
 

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

@@ -1,4 +1,5 @@
 import { Schema } from '@livestore/utils/effect'
+
 import { type SqliteAst, SqliteDsl } from './db-schema/mod.ts'
 
 /**
@@ -12,13 +13,13 @@ import { type SqliteAst, SqliteDsl } from './db-schema/mod.ts'
 export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
   const pkColumns = tableAst.columns.filter((_) => _.primaryKey)
   const hasSinglePk = pkColumns.length === 1
-  const pkColumn = hasSinglePk ? pkColumns[0] : undefined
+  const pkColumn = hasSinglePk === true ? pkColumns[0] : undefined
 
   // Build column definitions, handling the special SQLite rule that AUTOINCREMENT
   // is only valid on a single column declared as INTEGER PRIMARY KEY (column-level).
   const columnDefStrs = tableAst.columns.map((column) =>
     toSqliteColumnSpec(column, {
-      inlinePrimaryKey: hasSinglePk && column === pkColumn && column.primaryKey === true,
+      inlinePrimaryKey: hasSinglePk && column === pkColumn &&  column.primaryKey,
     }),
   )
 
@@ -36,24 +37,24 @@ const toSqliteColumnSpec = (column: SqliteAst.Column, opts: { inlinePrimaryKey:
   const columnTypeStr = column.type._tag
   // When PRIMARY KEY is declared inline, NOT NULL is implied and should not be emitted,
   // and AUTOINCREMENT must immediately follow PRIMARY KEY within the same constraint.
-  const nullableStr = opts.inlinePrimaryKey ? '' : column.nullable === false ? 'not null' : ''
+  const nullableStr = opts.inlinePrimaryKey === true ? '' : column.nullable === false ? 'not null' : ''
 
   // Only include AUTOINCREMENT when it's valid: single-column INTEGER PRIMARY KEY
-  const includeAutoIncrement = opts.inlinePrimaryKey && column.type._tag === 'integer' && column.autoIncrement === true
+  const includeAutoIncrement = opts.inlinePrimaryKey === true && column.type._tag === 'integer' && column.autoIncrement === true
 
-  const pkStr = opts.inlinePrimaryKey ? 'primary key' : ''
-  const autoIncrementStr = includeAutoIncrement ? 'autoincrement' : ''
+  const pkStr = opts.inlinePrimaryKey === true ? 'primary key' : ''
+  const autoIncrementStr = includeAutoIncrement === true ? 'autoincrement' : ''
 
   const defaultValueStr = (() => {
     if (column.default._tag === 'None') return ''
 
     const defaultValue = column.default.value
-    if (SqliteDsl.isDefaultThunk(defaultValue)) return ''
+    if (SqliteDsl.isDefaultThunk(defaultValue) === true) return ''
 
     const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
 
     if (resolvedDefault === null) return 'default null'
-    if (SqliteDsl.isSqlDefaultValue(resolvedDefault)) return `default ${resolvedDefault.sql}`
+    if (SqliteDsl.isSqlDefaultValue(resolvedDefault) === true) return `default ${resolvedDefault.sql}`
 
     const encodeValue = Schema.encodeSync(column.schema)
     const encodedDefaultValue = encodeValue(resolvedDefault)

package/src/schema/state/sqlite/db-schema/ast/sqlite.ts

@@ -124,7 +124,7 @@ const trimInfoForHasing = (obj: Table | Column | Index | ForeignKey | DbSchema):
 
       // NEW: Include schema hash for JSON columns
       // This ensures that changes to the JSON schema are detected
-      if (isJsonColumn(obj) && obj.schema) {
+      if (isJsonColumn(obj) === true && obj.schema !== undefined) {
         // Use Effect's Schema.hash for consistent hashing
         baseInfo.jsonSchemaHash = Schema.hash(obj.schema)
       }
@@ -155,7 +155,7 @@ const trimInfoForHasing = (obj: Table | Column | Index | ForeignKey | DbSchema):
       }
     }
     default: {
-      throw new Error(`Unreachable: ${obj}`)
+      throw new Error(`Unreachable: ${String(obj)}`)
     }
   }
 }

package/src/schema/state/sqlite/db-schema/dsl/field-defs.test.ts

@@ -1,6 +1,7 @@
-import { Schema } from '@livestore/utils/effect'
 import { describe, expect, test } from 'vitest'
 
+import { Schema } from '@livestore/utils/effect'
+
 import * as F from './field-defs.ts'
 
 describe.concurrent('FieldDefs', () => {

package/src/schema/state/sqlite/db-schema/dsl/field-defs.ts

@@ -6,6 +6,7 @@ export type SqlDefaultValue = {
 }
 
 export const isSqlDefaultValue = (value: unknown): value is SqlDefaultValue => {
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- type guard property access after structural check
   return typeof value === 'object' && value !== null && 'sql' in value && typeof (value as any).sql === 'string'
 }
 
@@ -16,14 +17,14 @@ export const isDefaultThunk = (value: unknown): value is ColumnDefaultThunk<unkn
 export type ColumnDefaultValue<T> = T | null | ColumnDefaultThunk<T | null> | SqlDefaultValue
 
 export const resolveColumnDefault = <T>(value: ColumnDefaultValue<T>): T | null | SqlDefaultValue =>
-  isDefaultThunk(value) ? (value as ColumnDefaultThunk<T | null>)() : value
+  isDefaultThunk(value) === true ? value() : value
 
-export type ColumnDefinition<TEncoded, TDecoded> = {
+export type ColumnDefinition<TEncoded, TDecoded, TNullable extends boolean = boolean> = {
   readonly columnType: FieldColumnType
   readonly schema: Schema.Schema<TDecoded, TEncoded>
   readonly default: Option.Option<ColumnDefaultValue<TDecoded>>
   /** @default false */
-  readonly nullable: boolean
+  readonly nullable: TNullable
   /** @default false */
   readonly primaryKey: boolean
   /** @default false */
@@ -40,6 +41,7 @@ export const isColumnDefinition = (value: unknown): value is ColumnDefinition.An
     typeof value === 'object' &&
     value !== null &&
     'columnType' in value &&
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- type guard narrowing; columnType checked to be in valid set
     validColumnTypes.includes(value.columnType as any)
   )
 }
@@ -105,6 +107,7 @@ const makeColDef =
     const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
     const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
 
+    // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- column factory return type uses complex conditional generics; consumer type safety enforced by ColDefFn signature
     return {
       columnType,
       schema,
@@ -200,10 +203,12 @@ type MakeSpecializedColDefFn = {
 
 const makeSpecializedColDef: MakeSpecializedColDefFn = (columnType, opts) => (def?: ColumnDefinitionInput) => {
   const nullable = def?.nullable ?? false
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- schema type variance; custom schema compatibility checked at call site
   const schemaWithoutNull = opts._tag === 'baseSchemaFn' ? opts.baseSchemaFn(def?.schema as any) : opts.baseSchema
   const schema = nullable === true ? Schema.NullOr(schemaWithoutNull) : schemaWithoutNull
   const default_ = def?.default === undefined || def.default === NoDefault ? Option.none() : Option.some(def.default)
 
+  // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- specialized column factory return type uses complex conditional generics; consumer type safety enforced by SpecializedColDefFn signature
   return {
     columnType,
     schema,
@@ -236,7 +241,7 @@ export const boolean: SpecializedColDefFn<'integer', false, boolean> = makeSpeci
   _tag: 'baseSchema',
   baseSchema: Schema.transform(Schema.Number, Schema.Boolean, {
     decode: (_) => _ === 1,
-    encode: (_) => (_ ? 1 : 0),
+    encode: (_) => (_ === true ? 1 : 0),
   }),
 })
 
@@ -259,15 +264,19 @@ export const defaultSchemaForColumnType = <TColumnType extends FieldColumnType>(
 
   switch (columnType) {
     case 'text': {
+      // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
       return Schema.String as any as Schema.Schema<T>
     }
     case 'integer': {
+      // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
       return Schema.Number as any as Schema.Schema<T>
     }
     case 'real': {
+      // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
       return Schema.Number as any as Schema.Schema<T>
     }
     case 'blob': {
+      // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- switch-based type narrowing for column type to schema mapping; each case is correct for its branch
       return Schema.Uint8ArrayFromSelf as any as Schema.Schema<T>
     }
     default: {

package/src/schema/state/sqlite/db-schema/dsl/mod.ts

@@ -31,7 +31,7 @@ export type DbSchemaFromInputSchema<TSchemaInput extends DbSchemaInput> =
 export const makeDbSchema = <TDbSchemaInput extends DbSchemaInput>(
   schema: TDbSchemaInput,
 ): DbSchemaFromInputSchema<TDbSchemaInput> => {
-  return Array.isArray(schema) ? Object.fromEntries(schema.map((_) => [_.name, _])) : (schema as any)
+  return Array.isArray(schema) === true ? Object.fromEntries(schema.map((_) => [_.name, _])) : (schema as any)
 }
 
 export const table = <TTableName extends string, TColumns extends Columns, TIndexes extends Index[]>(
@@ -76,6 +76,7 @@ export const insertStructSchemaForTable = <TTableDefinition extends TableDefinit
     Object.fromEntries(
       tableDef.ast.columns.map((column) => [
         column.name,
+
         column.nullable === true || column.default._tag === 'Some' ? Schema.optional(column.schema) : column.schema,
       ]),
     ),
@@ -195,8 +196,7 @@ export namespace FromColumns {
   }
 
   export type NullableColumnNames<TColumns extends Columns> = keyof {
-    // TODO double check why there is a `true` in the type
-    [K in keyof TColumns as TColumns[K] extends ColumnDefinition<any, true> ? K : never]: {}
+    [K in keyof TColumns as TColumns[K]['nullable'] extends true ? K : never]: {}
   }
 
   export type RequiredInsertColumns<TColumns extends Columns> = {