@livestore/common 0.4.0-dev.8 → 0.4.0

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

@@ -1,5 +1,7 @@
+import { assert, describe, expect, it } from 'vitest'
+
 import { Schema } from '@livestore/utils/effect'
-import { describe, expect, it } from 'vitest'
+import { objectToString } from '@livestore/utils'
 
 import * as State from '../mod.ts'
 import { withAutoIncrement, withColumnType, withDefault, withPrimaryKey, withUnique } from './column-annotations.ts'
@@ -144,11 +146,10 @@ describe('getColumnDefForSchema', () => {
 
     it('should map tagged unions to json column', () => {
       const ResultSchema = Schema.Union(
-        Schema.Struct({
-          _tag: Schema.Literal('success'),
+        Schema.TaggedStruct('success', {
           value: Schema.String,
         }),
-        Schema.Struct({ _tag: Schema.Literal('error'), error: Schema.String }),
+        Schema.TaggedStruct('error', { error: Schema.String }),
       )
 
       const columnDef = State.SQLite.getColumnDefForSchema(ResultSchema)
@@ -273,17 +274,34 @@ describe('getColumnDefForSchema', () => {
         INACTIVE: 'inactive',
       })
 
-      const StatusUnion = Schema.Union(Schema.Literal('pending'), Schema.Literal('active'), Schema.Literal('inactive'))
+      const StatusUnion = Schema.Literal('pending', 'active', 'inactive')
 
       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(objectToString(columnDef.schema)).toBe('Uint8ArrayFromSelf')
     })
   })
 
@@ -340,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', () => {
@@ -381,6 +399,19 @@ describe('getColumnDefForSchema', () => {
       expect((table.rowSchema as any).fields.count.toString()).toBe('Int | null')
     })
 
+    it('should treat unions of string literals as text columns without JSON parsing', () => {
+      const schema = Schema.Struct({
+        id: Schema.String,
+        status: Schema.Literal('idle', 'running', 'stopped'),
+      })
+
+      const table = State.SQLite.table({ name: 'timers', schema })
+
+      expect(table.sqliteDef.columns.status.columnType).toBe('text')
+      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', () => {
       const schema = Schema.Struct({
         data: Schema.NullOr(Schema.Struct({ value: Schema.Number })),
@@ -539,7 +570,7 @@ describe('getColumnDefForSchema', () => {
 
       it('should work with column type annotation', () => {
         const UserSchema = Schema.Struct({
-          id: Schema.Number.pipe(withColumnType('integer')).pipe(withPrimaryKey),
+          id: Schema.Number.pipe(withColumnType('integer'), withPrimaryKey),
           name: Schema.String,
         })
 
@@ -571,7 +602,7 @@ describe('getColumnDefForSchema', () => {
     describe('withAutoIncrement', () => {
       it('should add autoIncrement annotation to schema', () => {
         const UserSchema = Schema.Struct({
-          id: Schema.Int.pipe(withPrimaryKey).pipe(withAutoIncrement),
+          id: Schema.Int.pipe(withPrimaryKey, withAutoIncrement),
           name: Schema.String,
         })
         const userTable = State.SQLite.table({
@@ -623,6 +654,29 @@ describe('getColumnDefForSchema', () => {
           table2.sqliteDef.columns.count.default._tag === 'Some' && table2.sqliteDef.columns.count.default.value,
         ).toBe(0)
       })
+
+      it('should support thunk defaults without eager evaluation', () => {
+        let counter = 0
+        const UserSchema = Schema.Struct({
+          id: Schema.String.pipe(
+            withDefault(() => {
+              counter += 1
+              return `user-${counter}`
+            }),
+          ),
+        })
+
+        const table = State.SQLite.table({ name: 'users_with_thunk', schema: UserSchema })
+
+        expect(counter).toBe(0)
+        expect(table.sqliteDef.columns.id.default._tag).toBe('Some')
+        if (table.sqliteDef.columns.id.default._tag === 'Some') {
+          const defaultThunk = table.sqliteDef.columns.id.default.value
+          assert(typeof defaultThunk === 'function')
+          expect(defaultThunk()).toBe('user-1')
+          expect(defaultThunk()).toBe('user-2')
+        }
+      })
     })
 
     describe('withUnique', () => {
@@ -668,7 +722,7 @@ describe('getColumnDefForSchema', () => {
 
     describe('combined annotations', () => {
       it('should work with multiple annotations', () => {
-        const schema = Schema.Uint8ArrayFromBase64.pipe(withColumnType('blob')).pipe(withPrimaryKey)
+        const schema = Schema.Uint8ArrayFromBase64.pipe(withColumnType('blob'), withPrimaryKey)
 
         const UserSchema = Schema.Struct({
           id: schema,
@@ -686,7 +740,7 @@ describe('getColumnDefForSchema', () => {
 
       it('should combine all annotations', () => {
         const UserSchema = Schema.Struct({
-          id: Schema.Int.pipe(withPrimaryKey).pipe(withAutoIncrement),
+          id: Schema.Int.pipe(withPrimaryKey, withAutoIncrement),
           email: Schema.String.pipe(withUnique),
           status: Schema.String.pipe(withDefault('active')),
           metadata: Schema.Unknown.pipe(withColumnType('text')),

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,37 +180,108 @@ 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) === true || isUint8ArraySchema(encodedAst) === true) {
+    return SqliteDsl.blob({ schema: Schema.Uint8ArrayFromSelf as Schema.Schema<Uint8Array<ArrayBuffer>>, 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 !== null) return literalColumn
+
+  // Fallback to checking the original AST in case the encoded schema differs
+  const coreLiteralColumn = getLiteralColumnDefinition(coreAst, coreSchema, nullable, coreAst)
+  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
 
-  // Find non-null/undefined type
-  const core = ast.types.find(
+  // Filter out null/undefined members while preserving any annotations on the union
+  const coreTypes = ast.types.filter(
     (type) => !(SchemaAST.isLiteral(type) && type.literal === null) && !SchemaAST.isUndefinedKeyword(type),
   )
 
-  return core || ast
+  if (coreTypes.length === 0 || coreTypes.length === ast.types.length) {
+    return ast
+  }
+
+  if (coreTypes.length === 1) {
+    return coreTypes[0]!
+  }
+
+  return SchemaAST.Union.make(coreTypes, ast.annotations)
+}
+
+const getLiteralColumnDefinition = (
+  ast: SchemaAST.AST,
+  schema: Schema.Schema.AnyNoContext,
+  nullable: boolean,
+  sourceAst: SchemaAST.AST,
+): SqliteDsl.ColumnDefinition.Any | null => {
+  const literalValues = extractLiteralValues(ast)
+  if (literalValues == null) 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 === true ? 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) === true) return [ast.literal]
+
+  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)
+  }
+
+  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) === true && identifier.value.includes('Uint8Array') === true) {
+    return true
+  }
+
+  if (SchemaAST.isTupleType(ast) === true) {
+    return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumberKeyword(ast.rest[0]!.type)
+  }
+
+  return false
 }

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'
 
@@ -56,9 +58,9 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(`"'order' integer not null  , 'group' text   "`)
-    expect(result).toContain("'order'")
-    expect(result).toContain("'group'")
+    expect(result).toMatchInlineSnapshot(`""order" integer   not null , "group" text    "`)
+    expect(result).toContain('"order"')
+    expect(result).toContain('"group"')
   })
 
   it('should handle basic columns with primary keys', () => {
@@ -69,8 +71,7 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(`"'id' text not null  , 'name' text   , PRIMARY KEY ('id')"`)
-    expect(result).toContain("PRIMARY KEY ('id')")
+    expect(result).toMatchInlineSnapshot(`""id" text primary key   , "name" text    "`)
   })
 
   it('should handle multi-column primary keys', () => {
@@ -85,9 +86,9 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'tenant_id' text not null  , 'user_id' text not null  , PRIMARY KEY ('tenant_id', 'user_id')"`,
+      `""tenant_id" text   not null , "user_id" text   not null , PRIMARY KEY ("tenant_id", "user_id")"`,
     )
-    expect(result).toContain("PRIMARY KEY ('tenant_id', 'user_id')")
+    expect(result).toContain('PRIMARY KEY ("tenant_id", "user_id")')
   })
 
   it('should handle auto-increment columns', () => {
@@ -101,9 +102,9 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(`"'id' integer not null autoincrement , 'title' text   , PRIMARY KEY ('id')"`)
+    expect(result).toMatchInlineSnapshot(`""id" integer primary key autoincrement  , "title" text    "`)
     expect(result).toContain('autoincrement')
-    expect(result).toContain("PRIMARY KEY ('id')")
+    expect(result).not.toContain("PRIMARY KEY ('id')")
   })
 
   it('should handle columns with default values', () => {
@@ -121,7 +122,7 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null  , 'name' text not null  , 'price' real   default 0, 'active' integer   default true, 'description' text   default 'No description', PRIMARY KEY ('id')"`,
+      `""id" integer primary key   , "name" text   not null , "price" real    default 0, "active" integer    default true, "description" text    default 'No description'"`,
     )
     expect(result).toContain('default 0')
     expect(result).toContain('default true')
@@ -141,12 +142,28 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null  , 'created_at' text   default CURRENT_TIMESTAMP, 'random_value' real   default RANDOM(), PRIMARY KEY ('id')"`,
+      `""id" integer primary key   , "created_at" text    default CURRENT_TIMESTAMP, "random_value" real    default RANDOM()"`,
     )
     expect(result).toContain('default CURRENT_TIMESTAMP')
     expect(result).toContain('default RANDOM()')
   })
 
+  it('should omit default clause for thunk defaults', () => {
+    const table = SqliteAst.table(
+      'thunks',
+      [
+        createColumn('id', 'integer', { nullable: false, primaryKey: true }),
+        createColumn('token', 'text', { defaultValue: () => 'dynamic-token' }),
+      ],
+      [],
+    )
+
+    const result = makeColumnSpec(table)
+    expect(result).toMatchInlineSnapshot(`""id" integer primary key   , "token" text    "`)
+    expect(result).not.toContain('dynamic-token')
+    expect(result).not.toMatch(/token" text\s+default/i)
+  })
+
   it('should handle null default values', () => {
     const table = SqliteAst.table(
       'nullable_defaults',
@@ -158,9 +175,7 @@ describe('makeColumnSpec', () => {
     )
 
     const result = makeColumnSpec(table)
-    expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null  , 'optional_text' text   default null, PRIMARY KEY ('id')"`,
-    )
+    expect(result).toMatchInlineSnapshot(`""id" integer primary key   , "optional_text" text    default null"`)
     expect(result).toContain('default null')
   })
 
@@ -190,7 +205,7 @@ describe('makeColumnSpec', () => {
 
     const result = makeColumnSpec(table)
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null autoincrement , 'name' text not null  default 'Unnamed', 'created_at' text not null  default CURRENT_TIMESTAMP, 'status' text   default 'pending', PRIMARY KEY ('id')"`,
+      `""id" integer primary key autoincrement  , "name" text   not null default 'Unnamed', "created_at" text   not null default CURRENT_TIMESTAMP, "status" text    default 'pending'"`,
     )
   })
 
@@ -213,7 +228,7 @@ describe('makeColumnSpec', () => {
     const result = makeColumnSpec(table)
     // The makeColumnSpec function only generates column specifications, not indexes
     expect(result).toMatchInlineSnapshot(
-      `"'id' integer not null autoincrement , 'email' text not null  , 'username' text not null  , 'created_at' text   default CURRENT_TIMESTAMP, PRIMARY KEY ('id')"`,
+      `""id" integer primary key autoincrement  , "email" text   not null , "username" text   not null , "created_at" text    default CURRENT_TIMESTAMP"`,
     )
     // Verify the table has the indexes (even though they're not in the column spec)
     expect(table.indexes).toHaveLength(3)

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'
 
 /**
@@ -10,33 +11,58 @@ import { type SqliteAst, SqliteDsl } from './db-schema/mod.ts'
  * ```
  */
 export const makeColumnSpec = (tableAst: SqliteAst.Table) => {
-  const primaryKeys = tableAst.columns.filter((_) => _.primaryKey).map((_) => `'${_.name}'`)
-  const columnDefStrs = tableAst.columns.map(toSqliteColumnSpec)
+  const pkColumns = tableAst.columns.filter((_) => _.primaryKey)
+  const hasSinglePk = pkColumns.length === 1
+  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,
+    }),
+  )
 
-  if (primaryKeys.length > 0) {
-    columnDefStrs.push(`PRIMARY KEY (${primaryKeys.join(', ')})`)
+  // For composite primary keys, add a table-level PRIMARY KEY clause.
+  if (pkColumns.length > 1) {
+    const quotedPkCols = pkColumns.map((_) => `"${_.name}"`)
+    columnDefStrs.push(`PRIMARY KEY (${quotedPkCols.join(', ')})`)
   }
 
   return columnDefStrs.join(', ')
 }
 
 /** NOTE primary keys are applied on a table level not on a column level to account for multi-column primary keys */
-const toSqliteColumnSpec = (column: SqliteAst.Column) => {
+const toSqliteColumnSpec = (column: SqliteAst.Column, opts: { inlinePrimaryKey: boolean }) => {
   const columnTypeStr = column.type._tag
-  const nullableStr = column.nullable === false ? 'not null' : ''
-  const autoIncrementStr = column.autoIncrement ? 'autoincrement' : ''
+  // 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 === true ? '' : column.nullable === false ? 'not null' : ''
+
+  // Only include AUTOINCREMENT when it's valid: single-column INTEGER PRIMARY KEY
+  const includeAutoIncrement = opts.inlinePrimaryKey === true && column.type._tag === 'integer' && column.autoIncrement === true
+
+  const pkStr = opts.inlinePrimaryKey === true ? 'primary key' : ''
+  const autoIncrementStr = includeAutoIncrement === true ? 'autoincrement' : ''
+
   const defaultValueStr = (() => {
     if (column.default._tag === 'None') return ''
 
-    if (column.default.value === null) return 'default null'
-    if (SqliteDsl.isSqlDefaultValue(column.default.value)) return `default ${column.default.value.sql}`
+    const defaultValue = column.default.value
+    if (SqliteDsl.isDefaultThunk(defaultValue) === true) return ''
+
+    const resolvedDefault = SqliteDsl.resolveColumnDefault(defaultValue)
+
+    if (resolvedDefault === null) return 'default null'
+    if (SqliteDsl.isSqlDefaultValue(resolvedDefault) === true) return `default ${resolvedDefault.sql}`
 
     const encodeValue = Schema.encodeSync(column.schema)
-    const encodedDefaultValue = encodeValue(column.default.value)
+    const encodedDefaultValue = encodeValue(resolvedDefault)
 
     if (columnTypeStr === 'text') return `default '${encodedDefaultValue}'`
     return `default ${encodedDefaultValue}`
   })()
 
-  return `'${column.name}' ${columnTypeStr} ${nullableStr} ${autoIncrementStr} ${defaultValueStr}`
+  // Ensure order: PRIMARY KEY [AUTOINCREMENT] [NOT NULL] ...
+  return `"${column.name}" ${columnTypeStr} ${pkStr} ${autoIncrementStr} ${nullableStr} ${defaultValueStr}`
 }

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', () => {