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

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

@@ -12,27 +12,28 @@ import { SqliteDsl } from './db-schema/mod.ts'
  * Fields with both null and undefined will emit a warning as this is a lossy conversion.
  */
 export const getColumnDefForSchema = (
-  schema: Schema.Schema.AnyNoContext,
+  schema: Schema.Top,
   propertySignature?: SchemaAST.PropertySignature,
   forceNullable = false,
 ): SqliteDsl.ColumnDefinition.Any => {
   const ast = schema.ast
 
   // Extract annotations
-  const getAnnotation = <T>(annotationId: symbol): Option.Option<T> =>
-    propertySignature
+  const getAnnotation = <T>(annotationId: string): Option.Option<T> =>
+    propertySignature !== undefined
       ? hasPropertyAnnotation<T>(propertySignature, annotationId)
-      : SchemaAST.getAnnotation<T>(annotationId)(ast)
+      : Option.fromUndefinedOr(SchemaAST.resolveAt<T>(annotationId)(ast))
 
-  const columnType = SchemaAST.getAnnotation<SqliteDsl.FieldColumnType>(ColumnType)(ast)
+  const columnType = Option.fromUndefinedOr(SchemaAST.resolveAt<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,21 +42,21 @@ 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) } : {}),
   }
 }
 
 const hasPropertyAnnotation = <T>(
   propertySignature: SchemaAST.PropertySignature,
-  annotationId: symbol,
+  annotationId: string,
 ): Option.Option<T> => {
-  if ('annotations' in propertySignature && propertySignature.annotations) {
-    const annotation = SchemaAST.getAnnotation<T>(annotationId)(propertySignature as any)
-    if (Option.isSome(annotation)) return annotation
+  const keyAnnotation = propertySignature.type.context?.annotations?.[annotationId] as T | undefined
+  if (keyAnnotation !== undefined) {
+    return Option.some(keyAnnotation)
   }
-  return SchemaAST.getAnnotation<T>(annotationId)(propertySignature.type)
+  return Option.fromUndefinedOr(SchemaAST.resolveAt<T>(annotationId)(propertySignature.type))
 }
 
 /**
@@ -71,18 +72,19 @@ export const schemaFieldsToColumns = (
   for (const prop of propertySignatures) {
     if (typeof prop.name !== 'string') continue
 
-    const fieldSchema = Schema.make(prop.type)
+    const isOptional = SchemaAST.isOptional(prop.type)
+    const fieldSchema = Schema.make<Schema.Top>(prop.type)
 
     // Warn about lossy conversion for fields with both null and undefined
-    if (prop.isOptional) {
+    if (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, isOptional === true)
 
     // Check for primary key and unique annotations
     const hasPrimaryKey = hasPropertyAnnotation<boolean>(prop, PrimaryKeyId).pipe(Option.getOrElse(() => false))
@@ -91,16 +93,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 +113,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.isUndefined(type) === true) hasUndefined = true
+    else if (SchemaAST.isNull(type) === true) hasNull = true
+    else if (SchemaAST.isUnion(type) === true) type.types.forEach(visit)
   }
 
   visit(ast)
@@ -121,16 +123,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.isNull(ast) === true) 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.isUndefined(ast) === true) return true
+  if (SchemaAST.isUnion(ast) === true) {
     return ast.types.some((type) => hasUndefined(type))
   }
   return false
@@ -151,65 +153,170 @@ const getColumnForType = (columnType: string, nullable = false): SqliteDsl.Colum
   }
 }
 
-const getColumnForSchema = (schema: Schema.Schema.AnyNoContext, nullable = false): SqliteDsl.ColumnDefinition.Any => {
+const getColumnForSchema = (schema: Schema.Top, nullable = false): SqliteDsl.ColumnDefinition.Any => {
   const ast = schema.ast
   // Strip nullable wrapper to get core type
   const coreAst = stripNullable(ast)
-  const coreSchema = stripNullable(ast) === ast ? schema : Schema.make(coreAst)
+  const coreSchema = (stripNullable(ast) === ast ? schema : Schema.make(coreAst)) as Schema.Codec<any, any>
 
   // Special case: Boolean is transformed to integer in SQLite
-  if (SchemaAST.isBooleanKeyword(coreAst)) {
+  if (SchemaAST.isBoolean(coreAst) === true) {
     return SqliteDsl.boolean({ nullable })
   }
 
   // Get the encoded AST - what actually gets stored in SQLite
-  const encodedAst = Schema.encodedSchema(coreSchema).ast
+  const encodedAst = Schema.toEncoded(coreSchema).ast
 
   // Check if the encoded type matches SQLite native types
-  if (SchemaAST.isStringKeyword(encodedAst)) {
+  if (SchemaAST.isString(encodedAst) === true) {
     return SqliteDsl.text({ schema: coreSchema, nullable })
   }
 
-  if (SchemaAST.isNumberKeyword(encodedAst)) {
-    // Special cases for integer columns
-    const id = SchemaAST.getIdentifierAnnotation(coreAst).pipe(Option.getOrElse(() => ''))
-    if (id === 'Int' || id === 'DateFromNumber') {
+  if (SchemaAST.isNumber(encodedAst) === true) {
+    if (hasCheck(coreAst.checks, 'effect/schema/isInt') === true || hasDateRepresentation(coreAst) === true) {
       return SqliteDsl.integer({ schema: coreSchema, nullable })
     }
     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: 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 !== 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(
-    (type) => !(SchemaAST.isLiteral(type) && type.literal === null) && !SchemaAST.isUndefinedKeyword(type),
+  // Filter out null/undefined members while preserving any annotations on the union
+  const coreTypes = ast.types.filter(
+    (type) => SchemaAST.isNull(type) === false && SchemaAST.isUndefined(type) === false,
   )
 
-  return core || ast
+  if (coreTypes.length === 0 || coreTypes.length === ast.types.length) {
+    return ast
+  }
+
+  if (coreTypes.length === 1) {
+    return coreTypes[0]!
+  }
+
+  return new SchemaAST.Union(coreTypes, ast.mode, ast.annotations)
+}
+
+const getLiteralColumnDefinition = (
+  ast: SchemaAST.AST,
+  schema: Schema.Codec<any, any>,
+  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': {
+      if (hasCheck(sourceAst.checks, 'effect/schema/isInt') === true || hasDateRepresentation(sourceAst) === true) {
+        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
+  }
+}
+
+/** Effect's built-in date codecs expose their semantic type through the Date representation annotation. */
+const hasDateRepresentation = (ast: SchemaAST.AST): boolean => hasRepresentation(ast, 'effect/schema/Date')
+
+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.literal)
+  }
+
+  return null
+}
+
+const getLiteralValueType = (
+  literals: ReadonlyArray<SchemaAST.LiteralValue>,
+): 'string' | 'number' | 'boolean' | 'bigint' | null => {
+  const literalTypes = new Set(literals.map((value) => typeof value))
+  if (literalTypes.size !== 1) return null
+
+  const [literalType] = literalTypes
+  return literalType === 'string' || literalType === 'number' || literalType === 'boolean' || literalType === 'bigint'
+    ? literalType
+    : null
+}
+
+/**
+ * Recursively checks for Effect built-in check metadata.
+ *
+ * Checks can be attached directly as `Filter`s or nested in `FilterGroup`s when
+ * schemas compose multiple refinements, e.g. `Schema.Int.check(...)`.
+ *
+ * Effect rc.109 replaced the closed `meta` annotation with the open `representation`
+ * identity, so built-in checks are matched by their representation id.
+ */
+const hasCheck = (checks: ReadonlyArray<SchemaAST.Check<unknown>> | undefined, representationId: string): boolean => {
+  return (
+    checks?.some((check) => {
+      switch (check._tag) {
+        case 'Filter':
+          return check.annotations?.representation?.id === representationId
+        case 'FilterGroup':
+          return hasCheck(check.checks, representationId)
+      }
+    }) === true
+  )
+}
+
+const isUint8ArraySchema = (ast: SchemaAST.AST): boolean => {
+  // `resolveAt` reads the last check's annotations, which can mask the declaration's representation.
+  if (hasRepresentation(ast, 'effect/schema/Uint8Array') === true) {
+    return true
+  }
+
+  const identifier = SchemaAST.resolveIdentifier(ast)
+  if (identifier !== undefined && identifier.includes('Uint8Array') === true) {
+    return true
+  }
+
+  if (SchemaAST.isArrays(ast) === true) {
+    return ast.elements.length === 0 && ast.rest.length === 1 && SchemaAST.isNumber(ast.rest[0]!)
+  }
+
+  return false
+}
+
+const hasRepresentation = (ast: SchemaAST.AST, id: string): boolean => {
+  const representation = ast.annotations?.representation
+  return (
+    typeof representation === 'object' && representation !== null && 'id' in representation && representation.id === id
+  )
 }

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'
 
@@ -26,9 +28,9 @@ const createColumn = (
       case 'text':
         return Schema.String
       case 'integer':
-        return options.defaultValue === true || options.defaultValue === false ? Schema.Boolean : Schema.Number
+        return options.defaultValue === true || options.defaultValue === false ? Schema.Boolean : Schema.Finite
       case 'real':
-        return Schema.Number
+        return Schema.Finite
       case 'blob':
         return Schema.Uint8ArrayFromBase64
       default:
@@ -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,59 @@ 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

@@ -25,7 +25,7 @@ export type Column = {
   nullable: boolean
   autoIncrement: boolean
   default: Option.Option<any>
-  schema: Schema.Schema<any>
+  schema: Schema.Codec<any, any>
 }
 
 export const column = (props: Omit<Column, '_tag'>): Column => ({ _tag: 'column', ...props })
@@ -84,14 +84,24 @@ export type DbSchema = {
 export const dbSchema = (tables: Table[]): DbSchema => ({ _tag: 'dbSchema', tables })
 
 /**
- * Helper to detect if a column is a JSON column (has parseJson transformation)
+ * Helper to detect if a column is a JSON column (encoded as a JSON string)
  */
 const isJsonColumn = (column: Column): boolean => {
   if (column.type._tag !== 'text') return false
 
-  // Check if the schema AST is a parseJson transformation
-  const ast = column.schema.ast
-  return ast._tag === 'Transformation' && ast.annotations.schemaId === SchemaAST.ParseJsonSchemaId
+  return hasJsonStringEncoding(column.schema.ast)
+}
+
+/**
+ * `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 => {
+  if (ast.encoding?.some((link) => link.to.annotations?.contentMediaType === 'application/json') === true) {
+    return true
+  }
+  return SchemaAST.isUnion(ast) === true && ast.types.some(hasJsonStringEncoding)
 }
 
 /**
@@ -124,7 +134,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 +165,7 @@ const trimInfoForHasing = (obj: Table | Column | Index | ForeignKey | DbSchema):
       }
     }
     default: {
-      throw new Error(`Unreachable: ${obj}`)
+      throw new Error(`Unreachable: ${String(obj)}`)
     }
   }
 }