agrosner/DBFlow

DBFlow 5.0 is a Kotlin Multiplatform SQLite library that provides database persistence for Android, JVM, iOS, and macOS. It utilizes a Kotlin compiler plugin to generate type-safe adapters and a fluent query DSL, replacing legacy reflection-based approaches with a structured, compile-time code generation architecture. The system supports reactive data observation via Kotlin Flows, LiveData, and RxJava, while offering platform-specific implementations for connection management, encryption, and change notifications.

10 changes.

The project underwent a comprehensive rewrite to establish DBFlow 5.0 as a Kotlin Multiplatform library, replacing the legacy Java runtime with a new modular architecture targeting Android, JVM, iOS, and macOS. This period focused on modernizing the build system, integrating reactive streams and LiveData support, and adding features like SQLCipher encryption and paging capabilities.

28 changes.

The project underwent a comprehensive restructuring to support Kotlin Multiplatform, introducing shared core abstractions, platform-specific implementations for Android, JVM, and Native targets, and a new Gradle plugin for automated adapter generation. This period also saw the replacement of the previous code generation approach with a Kotlin compiler plugin, alongside significant refactoring of the query builder, transaction management, and observation systems to leverage modern Kotlin features like Flows and DSLs.

Introduces the initial Java platform implementation for the database library, providing concrete classes for writing database files, executing SQL migrations from files, managing thread-local transactions, and handling closeable resources.

lib/src/javaPlatformMain · high confidence

The livedata module now provides a new \toLiveData\ extension function that wraps database queries in an \androidx.lifecycle.LiveData\ stream. This allows consumers to observe query results and automatically receive updates when the underlying tables change, with the implementation handling transaction management and observer registration via \OnTableChangedObserver\.

livedata · high confidence

Introduces a new \QueryDataSource\ class and a \toDataSourceFactory\ extension function in the \com.dbflow5.paging\ package, enabling users to paginate the results of an \ExecutableQuery\ using AndroidX's \PositionalDataSource\. This implementation integrates with the database's transaction system via \beginTransactionAsync\ and automatically invalidates the data source when observed tables change, providing a type-safe way to handle large result sets in UI components.

paging/src/main/kotlin · high confidence

The reactive-streams module now supports RxJava 3 for executing database transactions. New extension functions allow converting a Transaction.Builder into an RxJava Single or Maybe, enabling reactive observers to handle transaction results and errors. Additionally, a new Flowable-based API is provided to observe table changes via ExecutableQuery, and a TransactionDisposable class manages transaction lifecycle and cancellation within reactive streams.

reactive-streams/src/main/kotlin/com/dbflow5/reactivestreams/transaction · high confidence

This change introduces a new SQLCipher module within the dbflow5 package, providing encrypted database capabilities for Android applications. It adds specific implementations for the database connection, open helper, and statement execution layers (SQLCipherDatabaseConnection, SQLCipherOpenHelper, SQLCipherStatement) that wrap the net.sqlcipher library. This allows users to configure their databases with a secret key for encryption while maintaining the existing dbflow API surface.

sqlcipher · high confidence

The query builder now supports a suite of standard SQLite functions, allowing users to construct queries using aggregate methods (AVG, COUNT, GROUP\_CONCAT, MAX, MIN, SUM, TOTAL), conditional logic (IFNULL, NULLIF), type casting (CAST), and date/time operations (DATE, DATETIME, STRFTIME). Additional helpers for string replacement (REPLACE), snippet generation, randomization (RANDOM), and offset retrieval are also available.

lib/src/commonMain/kotlin/com/dbflow5/query/methods · high confidence

The core library now includes a new \TypeConverters.kt\ file for the Java platform that defines how specific Java types are stored and retrieved in the database. This adds support for \java.sql.Date\ (stored as Long), \UUID\ (stored as String), \BigDecimal\ and \BigInteger\ (stored as String), \java.util.Calendar\ (stored as Long), and \java.util.Date\ (stored as Long).

core/src/javaPlatformMain · high confidence

Android applications can now receive database change notifications via the system ContentResolver. This change introduces a new notification pipeline in the Android module that converts internal model notifications into ContentResolver-compatible URIs. It includes a ContentResolverNotifier implementation that dispatches these changes using the 'dbflow' scheme, along with encoders and decoders to serialize table names, change actions, and specific field updates into URI query parameters and fragments.

lib/src/androidMain/kotlin/com/dbflow5/content · high confidence

The new DBFlow Gradle plugin automatically configures Kotlin projects (JVM, Android, and Multiplatform) to generate database adapters. It handles the necessary dependencies, adds the generated source directories to the compilation classpath, and configures linker options for Kotlin/Native, removing the need for manual setup of the compiler plugin and build tasks.

compiler-gradle · high confidence

This change introduces the foundational Kotlin Multiplatform (MPP) structure for the database core, moving key components into the commonMain source set. It adds a comprehensive suite of annotations for defining database schemas, including \@Table\, \@Column\, \@Database\, \@ForeignKey\, \@OneToMany\, \@ManyToMany\, and \@Query\, alongside support for constraints like \@Unique\, \@NotNull\, and \@Index\. The update also includes core utility classes such as \StringUtils\ for SQL identifier handling, \TypeConverter\ interfaces with built-in converters for booleans, characters, and blobs, and data types like \Blob\ and \Collate\. These additions establish the shared API surface required for code generation across platforms.

core/src/commonMain · high confidence

This change introduces the first implementation of the database layer for native platforms (iOS and macOS) within the \lib/src/nativeMain\ directory. It provides concrete implementations for core database operations, including connection management via \NativeDatabaseConnection\, statement execution through \NativeDatabaseStatement\, and result set handling with \NativeFlowCursor\. The update also adds platform-specific helpers for database opening (\NativeOpenHelper\), backup/restore logic (\DatabaseBackup\), and migration file handling (\NativeMigrationFileHelper\), along with necessary configuration and logging stubs to enable the library to function on native targets.

lib/src/nativeMain · high confidence

This change establishes the foundational structure for the DBFlow 5.0 release, introducing a Kotlin Multiplatform SQLite library that targets Android, JVM, iOS, and macOS. It adds the core documentation (README, SUMMARY, usage guides), a Gradle wrapper, and an \.editorconfig\ to enforce coding standards. The project is organized into modules including \lib\ (runtime and query DSL), \core\ (annotations), and a compiler plugin (\com.dbflow5\) that generates adapters and database definitions. It also includes a Git submodule for documentation (\usage2\) and an issue template to standardize contributions.

(repo-wide) · high confidence

Added TableChangeOnSubscribe to enable reactive streams to emit results whenever the underlying database tables change. This new component registers an OnTableChangedObserver to detect modifications and re-executes the associated query within an async transaction, ensuring that subscribers receive updated data automatically as the database state evolves.

reactive-streams/src/main/kotlin/com/dbflow5/reactivestreams/query · high confidence

The \kotlin-codegen\ module now includes a new \module.kt\ that registers a comprehensive set of writer classes (such as \DatabaseWriter\, \ClassAdapterWriter\, and \CreationSQLWriter\) via Koin dependency injection. These writers are responsible for generating the Kotlin code for database models, adapters, and SQL operations, effectively replacing previous reflection-based or manual approaches with a structured, code-gen-driven architecture.

kotlin-codegen/src/main/kotlin/com/grosner/dbflow5/codegen/kotlin/writer · high confidence

The library now includes a new \FlowLog\ object for centralized logging, allowing users to set minimum logging levels (Verbose through Error) and providing helper methods for logging errors and warnings. Additionally, a \JournalMode\ enum is introduced to configure SQLite journaling behavior, automatically adjusting between Write-Ahead Logging, Truncate, or Automatic modes based on device RAM constraints via \DBPlatformSettings\.

lib/src/commonMain/kotlin/com/dbflow5/config · high confidence

The shared-model module now includes a comprehensive set of data classes (such as ClassModel, DatabaseModel, FieldModel, and SQLiteModel) that represent the internal structure of database schemas, tables, and fields. These classes serve as the foundational model for the code generation process, enabling the processor to analyze annotations and generate the corresponding adapter and database initialization code.

shared-model · high confidence

The library now includes a new JVM-specific database implementation in the \lib/src/jvmMain/kotlin/com/dbflow5/database\ directory, enabling database operations on JVM platforms (including non-Android environments) using JDBC. This change introduces a suite of new classes including \JDBCConnection\, \JDBCConnectionWrapper\, \JDBCDatabaseConnection\, \JDBCDatabaseStatement\, and \JDBCFlowCursor\ to handle connection management, transaction control, and query execution. It also provides \JDBCOpenHelper\ as the entry point for opening databases, \DatabaseBackup\ for handling prepackaged databases, and \JDBCMigrationFileHelper\ for migration file resolution. The \CreateDB\ function is also provided, though it currently throws an exception indicating it is not yet fully rewritten for this platform.

lib/src/jvmMain/kotlin/com/dbflow5/database · high confidence

A new JVM-specific logging implementation has been added to the DBFlow configuration module. This change introduces a \call\ function that routes DBFlow log messages to the SLF4J SimpleLogger, mapping internal log levels (Verbose, Debug, Info, Warn, Error, WTF) to corresponding SLF4J severity levels. This enables DBFlow to output logs via the standard SLF4J interface on JVM platforms.

lib/src/jvmMain/kotlin/com/dbflow5/config · high confidence

A new JVM-specific implementation of DBPlatformSettings is introduced, defining default behaviors for low-RAM detection and coroutine dispatchers (using a single-thread executor for transactions and the main dispatcher for callbacks). Additionally, a convenience extension function is added to the DBCreator interface, allowing users to initialize a DBFlowDatabase instance by providing only custom DBSettings, with the platform-specific defaults applied automatically.

lib/src/jvmMain/kotlin/com/dbflow5/database/config · high confidence

A new \AlterTable.kt\ file introduces a Kotlin DSL for defining table schema changes within migrations. Users can now use the \alterTable\ extension on \MigrationScope\ to chain operations such as \addColumn\, \dropColumn\, \renameTo\, and \renameColumn\. These operations are implemented as sealed interfaces (\AlterTableType\) that generate the corresponding SQL statements and execute them via the \DatabaseConnection\.

lib/src/commonMain/kotlin/com/dbflow5/query/migration · high confidence

The legacy database runtime implementation has been removed from the application. This change deletes the core configuration and initialization classes (DatabaseHelperListener, ModelCache, DBConfiguration, FlowConfig, FlowSQLiteOpenHelper), the runtime transaction management system (DBBatchSaveQueue, DBManagerRuntime, DBTransactionQueue, DatabaseManager, TableManager, and associated transaction types like FetchTransaction and SaveTransaction), and the SQL query building infrastructure (From, Select, Join, QueryBuilder, and related structures). Users relying on these specific classes for database operations will need to migrate to the updated API.

src/main/java · high confidence

The library introduces a new MPP abstraction layer in the common module, adding an \expect interface Closeable\ and a corresponding \use\ extension function to standardize resource cleanup across platforms. Additionally, an \EnsureNeverFrozen\ marker is added to support Kotlin/Native memory management requirements.

lib/src/commonMain/kotlin/com/dbflow5/mpp · high confidence

The Android module now provides concrete implementations for database connectivity and management. This includes an Android-specific database connection interface, a cursor wrapper for data retrieval, and a migration file helper that reads from Android assets. Additionally, a new database backup component handles prepackaged database deployment, backup creation, and corruption recovery using Android's Context and file system APIs.

lib/src/androidMain/kotlin/com/dbflow5/database · high confidence

This change introduces the Android-specific implementation for the database library, providing concrete classes for database connections (AndroidDatabase), statement execution (AndroidDatabaseStatement), and helper management (AndroidSQLiteOpenHelper). It also adds support for observing database changes via Android's ContentResolver through FlowContentObserver and ContentNotification, allowing applications to react to model updates. Additionally, it includes platform-specific logging configuration and database settings tailored for the Android environment.

lib/src/androidMain · high confidence

The library now ensures that async transaction callbacks (success, error, and completion) are dispatched to the main thread by default. This is achieved through the new \CallbackDispatcher\ abstraction in the \com.dbflow5.transaction\ package, which wraps a \CoroutineDispatcher\ and defaults to \Dispatchers.Main\. Existing code relying on the previous implicit threading behavior may see callbacks executing on the main thread instead of the background thread where the transaction ran, potentially affecting UI update timing or requiring explicit dispatcher configuration if background processing is still desired.

lib/src/commonMain/kotlin/com/dbflow5/transaction · high confidence

The DBFlow compiler has been refactored to use a Kotlin compiler plugin (supporting K2) that generates adapter companions at compile time. This replaces the previous approach of generating \\*\_Table\ objects and a database holder factory. The plugin now generates model companions that act as runtime adapters, extending \ModelAdapterImpl\, \ViewAdapterImpl\, or \QueryAdapterImpl\ as appropriate. Additionally, the API for opening databases has changed: users must now use the \createDB\ function instead of relying on generated types, which the compiler rewrites to call the generated database class's \create\ method.

compiler · high confidence

The library has replaced the previous generated database holder factory with a new \createDB\ entry point that the compiler plugin rewrites to generated database instances. Database operations are now performed within explicit \writableTransaction\ and \readableTransaction\ scopes, providing structured access for writes and reads respectively. This change introduces new core abstractions like \DatabaseConnection\, \DatabaseHelper\, and \DatabaseHelperDelegate\ to manage the database lifecycle, migrations, and callbacks, while also renaming \DatabaseWrapper\ to \DatabaseConnection\ and \execSQL\ to \execute\ for clarity.

lib/src/commonMain/kotlin/com/dbflow5/database · high confidence

The code generator now includes new helper classes to streamline the creation of Kotlin code. MemberNames provides a centralized registry of MemberName references for common operations (such as select, list, and bind) and internal adapter utilities, ensuring consistent naming across generated code. ParameterPropertySpec simplifies the construction of properties and their corresponding parameters, handling naming conventions like underscore prefixes. These changes support the broader refactoring of the Kotlin code generation package structure.

kotlin-codegen/src/main/kotlin/com/grosner/dbflow5/codegen/kotlin/kotlinpoet · high confidence

Adds new common configuration classes for the database library to support Multiplatform (MPP) projects. The \DBSettings\ data class now encapsulates database initialization parameters, including platform-specific settings via the \DBPlatformSettings\ expect class (handling coroutine dispatchers and low-RAM flags), helper creators, transaction and callback dispatchers, and validation for database names. The new \DBCreator\ interface provides a standardized contract for generated code to instantiate \DBFlowDatabase\ instances using these settings.

lib/src/commonMain/kotlin/com/dbflow5/database/config · high confidence

The library introduces a new mechanism for tracking database changes, replacing previous implementations with a structured observer pattern. This includes the \TableObserver\ class, which manages SQLite triggers to detect table-level invalidations, and the \ObservingTableTracker\ to efficiently monitor observer counts and sync states. Additionally, a new notification subsystem has been added under \observing.notifications\, featuring the \ModelNotifier\ interface and \DirectModelNotifier\ implementation to emit \ModelNotification\ events (such as \TableChange\ and \ModelChange\) via Kotlin Flows, allowing applications to react to specific model updates asynchronously.

lib/src/commonMain/kotlin/com/dbflow5/observing · high confidence

The query API in the \com.dbflow5.query\ package has been rewritten to provide a more structured, type-safe, and fluent experience. This change introduces a comprehensive set of new interfaces and extension functions for building SQL statements, including dedicated builders for \SELECT\ (with support for joins, aliases, and qualifiers), \INSERT\ (with conflict actions and value mapping), \DELETE\, and \CASE\ expressions. The new design leverages Kotlin's type system to guide users through the query construction process, ensuring that operations like \groupBy\, \having\, \orderBy\, and \limit\ are only available at the correct stages of the query lifecycle. Additionally, the package now includes robust support for \JOIN\ operations (inner, left outer, cross, natural) with flexible \ON\ and \USING\ clause handling, as well as new listener interfaces (\DatabaseStatementListener\, \LoadFromCursorListener\) for hooking into the database execution lifecycle.

lib/src/commonMain/kotlin/com/dbflow5/query · high confidence

The library has refactored its core database interaction layer by renaming the internal database wrapper to DatabaseConnection and standardizing SQL execution through a new execute(query) method, which is now utilized by the relocated SqlUtils module for operations like dropping indexes and running queries. Additionally, a new ClassToken utility has been introduced to assist code generation in inferring property class types, supporting the broader move towards a multi-platform (MPP) architecture.

lib/src/commonMain/kotlin/com/dbflow5 · medium confidence

The library's adapter system has been restructured so that model, view, and query companions now serve as the runtime adapters themselves. This change introduces the \AdapterCompanion\ interface and new implementation classes (\ModelAdapterImpl\, \ViewAdapterImpl\, \QueryAdapterImpl\) that replace the previous \\*\_Table\ objects and database holder factories. For users, this simplifies the API by allowing direct use of companion objects (e.g., \User.name\) for column properties and queries without needing separate delegate types, while also introducing Kotlin Flow support for reactive table change observation and transaction execution.

lib/src/commonMain/kotlin/com/dbflow5/adapter · high confidence

Added test infrastructure configuration files; Expanded Android and Multiplatform Test Suite.

The build system has been updated to use Kotlin version 2.4.10 and targets Java 17 for both compilation and runtime compatibility. Minimum SDK levels for Android and related libraries have been standardized to 21, and the AtomicFu library has been added at version 0.33.0. These changes are implemented through new centralized configuration scripts in the buildSrc module, ensuring consistent JDK and Kotlin compiler settings across the project.

buildSrc · high confidence

The project has been restructured to support Kotlin Multiplatform (JVM, Android, iOS, macOS) and upgraded to Kotlin 2.4.10 and Android Gradle Plugin 9.3.0. The build system now uses a version catalog (gradle/libs.versions.toml) to manage dependencies, including Kotlinx Coroutines 1.11.0, Koin 4.2.1, and KotlinPoet 2.2.0. The legacy Groovy build scripts and old Android support libraries have been removed in favor of a new modular architecture with separate artifacts for core, library, paging, LiveData, reactive streams, and SQLCipher.

(dependencies) · high confidence

The Gradle wrapper configuration has been updated to use Gradle distribution version 9.7.1. This change ensures that builds are executed using the specified newer version of the Gradle build tool, replacing any previous wrapper configuration.

gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 48 → 53 (+4.9)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 97 → 98 (+0.4)
• Architecture 94 → 95 (+1.2)
• Maturity 55 → 59 (+3.7)
• Readiness 17 → 25 (+7.8)
• Security 100 → 100 (+0.0)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (lib/src/main/kotlin/com/dbflow5/query/IConditional.kt)
• No exposed public API
• No tests found
• Test reliability not included

• CreationSQLWriter.create (cognitive 38) (kotlin-codegen/src/main/kotlin/com/grosner/dbflow5/codegen/kotlin/writer/CreationSQLWriter.kt)
• CreationSQLWriter.create (cyclomatic 16) (kotlin-codegen/src/main/kotlin/com/grosner/dbflow5/codegen/kotlin/writer/CreationSQLWriter.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (lib/src/androidMain/kotlin/com/dbflow5/database/AndroidDatabase.kt)
• Duplicated block (13–15 lines × 2) (kotlin-codegen/src/main/kotlin/com/grosner/dbflow5/codegen/kotlin/writer/ObjectWriter.kt)
• Duplicated block (26 lines × 2) (compiler/src/main/kotlin/com/dbflow5/compiler/ir/CompanionAdapterIrTransformer.kt)
• Duplicated block (29–37 lines × 2) (kotlin-codegen/src/main/kotlin/com/grosner/dbflow5/codegen/kotlin/writer/ManyToManyClassWriter.kt)
• Duplicated block (6 lines × 2) (compiler/src/main/kotlin/com/dbflow5/compiler/ir/AnnotationParsers.kt)
• Edited copy of a member (27 corresponding lines) (compiler/src/main/kotlin/com/dbflow5/compiler/ir/CompanionAdapterIrTransformer.kt)
• JDBCConnection.getDatabaseLocked (cognitive 17) (lib/src/jvmMain/kotlin/com/dbflow5/database/JDBCConnection.kt)
• TodoComment (lib/src/androidMain/kotlin/com/dbflow5/content/ContentNotification.kt)
• TodoComment (lib/src/commonMain/kotlin/com/dbflow5/query/Join.kt)
• TodoComment (lib/src/commonMain/kotlin/com/dbflow5/query/operations/Method.kt)
• TodoComment (lib/src/nativeMain/kotlin/com/dbflow5/database/NativeMigrationFileHelper.kt)
• TodoComment (tests/src/commonMain/kotlin/com/dbflow5/test/ProspectQuiz.kt)
• TodoComment (tests/src/commonMain/kotlin/com/dbflow5/test/TestForeignKeyDatabase.kt)
• TodoComment (tests/src/commonTest/kotlin/com/dbflow5/test/usecases/OneToManyModelTest.kt)

• 10 commits — 10 feature/other, 0 fixes

• lib/src — 2 commits
• tests/src — 2 commits
• (repo) — 1 commit
• (root) — 1 commit
• compiler/src — 1 commit
• core/src — 1 commit
• processor/src — 1 commit
• usage2/usage — 1 commit

• change: Make model companions the runtime adapters
• change: Merge pull request #1747 from agrosner/compiler-plugin
• change: Remove legacy KSP and KAPT processor modules
• change: [API] generate AdapterCompanion model companions in the compiler plugin, replacing *_Table objects and the database holder factory.
• change: [API] open databases with createDB instead of generated types.
• change: [Build] upgrade to Gradle 9.7, AGP 9.3, and Kotlin 2.4
• change: [Compiler] generate adapters with a Kotlin compiler plugin.
• change: [Docs] rewrite usage for the compiler plugin and KMP.
• change: [Gradle] plugin wires lib, compiler classpath, generated sources, linker opts, and a dbflowGenerate task.
• change: [Tests] make JVM and native KMP host tests pass.

• Containers 0 added · 0 removed · contexts 6 added · 0 removed · edges 4 added · 0 removed

• compiler
• kotlin-codegen
• lib
• reactive-streams
• shared-model
• sqlcipher

• compiler → shared-model
• kotlin-codegen → shared-model
• reactive-streams → lib (coupling)
• sqlcipher → lib

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

agrosner/DBFlow was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.