Design Robust Android Room Database Entities

This skill designs robust Android Room Database entity schemas using Room's annotation-based ORM - entity modeling, relationships, data types, migrations, and performance optimization. A basic entity uses @Entity(tableName = ...), @PrimaryKey(autoGenerate = true), and @ColumnInfo(name = ...) to map Kotlin properties to explicit column names, with defaults like defaultValue = "1". Primary-key strategies cover auto-generated keys, composite primary keys via @Entity(primaryKeys = [...]) (shown on a UserPlaylistCrossRef join entity), and string UUID primary keys (UUID.randomUUID().toString()).

Complex data types are handled via a Converters class with @TypeConverter methods converting List<String> to/from JSON with Gson, Date to/from a Long timestamp, and an enum to/from its name string, applied to an entity with @TypeConverters(Converters::class). Relationships cover one-to-many (a Book entity with a ForeignKey referencing Author, onDelete = ForeignKey.CASCADE, and an AuthorWithBooks data class combining @Embedded and @Relation) and many-to-many (a StudentCourseCrossRef join entity with a composite primary key and two foreign keys, related via @Relation(... associateBy = Junction(StudentCourseCrossRef::class))):

data class StudentWithCourses(
    @Embedded val student: Student,
    @Relation(
        parentColumn = "studentId",
        entityColumn = "courseId",
        associateBy = Junction(StudentCourseCrossRef::class)
    )
    val courses: List<Course>
)

Advanced features cover indices (Index(value = [...], unique = true) for uniqueness, composite indices like ["category_id", "price"]) and embedded objects (an Address data class embedded twice on User with billing_/shipping_ prefixes to avoid column collisions). Best practices cover performance (preferring primitive types, indexing frequently-queried columns, avoiding large embedded objects, @Ignore for computed properties), schema design (always specifying tableName explicitly, meaningful @ColumnInfo names, proper foreign-key constraints), nullable fields with defaults (bio: String? = null, defaultValue = "CURRENT_TIMESTAMP"), and migration considerations (designing with future migrations in mind, using nullable fields for new columns, documenting schema changes).

A nullable-fields example on a UserProfile entity shows optional bio and avatarUrl columns defaulting to null alongside a createdAt column defaulted via defaultValue = "CURRENT_TIMESTAMP" and an isVerified boolean defaulted to "0" - illustrating how nullable columns and sensible defaults ease adding new fields without breaking existing rows. The guidance closes by stressing validating entity relationships, optimizing for the app's actual query patterns rather than a generic normalization ideal, and testing schemas with realistic data volumes before shipping.

Use it when designing or reviewing Android Room entities - primary-key strategy, type converters, one-to-many or many-to-many relationships, indices, embedded objects, or migration-friendly schema design. It is not a general SQLite or non-Android ORM guide - it is scoped to Room's Kotlin annotation-based entity modeling.

Given a data model and its relationships, it produces Room @Entity class definitions, @TypeConverter implementations for complex types, foreign-key and junction-entity relationship mappings, and indexing and migration-friendly schema recommendations.

Android developers designing or maintaining Room Database entity schemas in Kotlin.