Skip to content
CAI
Software that uses CAICheck a score

JetBrains/Exposed

62.4

Adequate · 13 November 2026

119k

lines of production code

JavaScript

with Kotlin

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Exposed Migration sample project demonstrating Flyway integration

A new sample project has been added to showcase database migration workflows using Exposed v1 and Flyway. The sample includes a \Users\ table definition and two entry points: one that simulates an existing database and generates a migration script to add a primary key, and another that applies the generated migration via Flyway and verifies the schema change.

samples/exposed-migration · high confidence

Add Exposed-Ktor sample application

A new sample project demonstrating how to integrate the Exposed ORM with the Ktor web framework has been added. This sample provides a complete, runnable example including database configuration using H2, JSON serialization setup, and a REST API for user management (create, read, update, delete) to help users understand the integration patterns.

samples/exposed-ktor · high confidence

Add JDBC and R2DBC DAO sample applications

New sample applications have been added for both JDBC and R2DBC access patterns, providing reference implementations for the Exposed DAO layer. The JDBC sample (\samples/exposed-jdbc-dao-sample\) demonstrates synchronous data access using Ktor, H2, and the \exposed.v1.jdbc\ API, while the R2DBC sample (\samples/exposed-r2dbc-dao-sample\) showcases asynchronous access using \exposed.v1.dao.r2dbc\. Both samples implement a complete broker domain model—including brokers, clients, portfolios, instruments, and trades—featuring entity definitions, table schemas, DTOs, and REST routes for CRUD operations and data seeding.

samples/exposed-jdbc-dao-sample, samples/exposed-r2dbc-dao-sample · high confidence

Add Ktor and R2DBC sample project

A new sample project demonstrating how to use Exposed with Ktor and R2DBC has been added. It includes domain models and table definitions for users, projects, issues, and comments, showcasing features such as JSON column storage, generated columns, and foreign key constraints.

exposed-ktor-r2dbc · high confidence

Add Ktor sample project demonstrating Exposed v1 usage

A new sample project for Ktor has been added, providing a complete example of how to integrate Exposed v1 with the Ktor framework. The sample includes a \UsersSchema\ plugin that defines a \Users\ table and a \UserService\ class, illustrating how to perform CRUD operations using Exposed's DSL within a Ktor application context, including setup of suspend transactions and database schema creation.

exposed-ktor · high confidence

Add Spring Boot 3 sample using Exposed R2DBC

A new sample application has been added to demonstrate integrating the Exposed ORM with Spring Boot 3's reactive R2DBC stack. The sample provides a complete reference implementation including a MySQL database configuration, reactive user CRUD endpoints, and necessary native-image hints for GraalVM compatibility.

samples/springboot3-exposed-r2dbc, springboot3-exposed-r2dbc · high confidence

Add Spring Boot 4 starter with auto-configuration and GraalVM native image support

This change introduces a new \exposed-spring-boot4-starter\ module that provides Spring Boot 4 compatibility for the Exposed library. It includes an \ExposedAutoConfiguration\ class that automatically registers a \SpringTransactionManager\, a \DatabaseInitializer\ for optional schema generation (controlled by \spring.exposed.generate-ddl\), and an \ExposedSpringTransactionAttributeSource\ for transaction management. To support GraalVM native images, the starter registers an \ExposedAotContribution\ that provides ahead-of-time reflection and resource hints for Exposed core classes and column types. The module also includes configuration metadata for properties like \spring.exposed.show-sql\ and \spring.exposed.excluded-packages\, along with tests verifying schema generation, transaction integration, and exclusion logic.

exposed-spring-boot4-starter · high confidence

Add Spring Boot integration documentation and sample project

Added a new documentation snippet and working sample project for Exposed's Spring Boot support. The sample demonstrates a complete CRUD application using Spring Boot 4, Exposed v1, and an H2 in-memory database, including configuration via \ExposedAutoConfiguration\, transaction management, and schema initialization.

documentation-website/Writerside/snippets/exposed-spring · high confidence

Add Spring Boot sample project using Exposed v1

A new Spring Boot sample project has been added to demonstrate CRUD operations with Exposed v1. The sample includes a User entity, a REST controller for user management, and a service layer that utilizes the Exposed v1 JDBC DSL (imported from \org.jetbrains.exposed.v1.jdbc\) for database interactions. It is configured to run with Spring Boot 4 and uses an H2 in-memory database with automatic schema initialization.

samples/exposed-spring · high confidence

Add new Exposed sample applications

The repository now includes a \samples\ directory containing several reference applications to help users get started with Exposed. These include \exposed-ktor\ and \exposed-ktor-r2dbc\ for building backend applications with Ktor (using JDBC and PostgreSQL R2DBC respectively), \exposed-jdbc-dao-sample\ and \exposed-r2dbc-dao-sample\ demonstrating the DAO API with JDBC and R2DBC drivers, \exposed-spring\ for Spring Boot 3 integration, \exposed-migration\ for generating migration scripts, and \exposed-gradle-plugin-sample\ illustrating the use of the Exposed Gradle plugin.

samples · high confidence

Add sample project demonstrating Ktor and R2DBC integration

Introduces a new sample application in \samples/exposed-ktor-r2dbc\ that demonstrates how to use Exposed v1 with Ktor and R2DBC. The sample includes a full-stack implementation with Ktor routing, dependency injection, and database configuration, covering CRUD operations for Projects, Users, Issues, and Comments using the new \R2dbcDatabase.connect()\ API and \suspendTransaction\.

samples/exposed-ktor-r2dbc · high confidence

Add sample project for the Exposed DAO getting-started tutorial

A new sample Gradle/Kotlin project has been added to the documentation website to accompany the 'Get started with Exposed' tutorial. This project demonstrates core Exposed DAO operations—including schema creation, inserting, selecting, updating, and deleting records—using the \org.jetbrains.exposed.v1\ package namespace and an in-memory H2 database, providing users with a concrete, runnable example of the tutorial's concepts.

documentation-website/Writerside/snippets/get-started-with-exposed · high confidence

Add suspend-capable caching map to avoid blocking

Exposed now provides CachableMapWithSuspendableDefault, a new internal utility that supports suspend functions for default value generation, allowing caching operations to be performed asynchronously without blocking threads. This complements the existing CachableMapWithDefault and enables non-blocking behavior in suspend contexts.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/utils · high confidence

Added Exposed SQL Functions example project

A new Gradle application has been added to the documentation website to demonstrate how to use built-in and custom SQL functions with the Exposed API. This example project, referenced by the SQL Functions documentation topic, includes runnable code for string, aggregate, window, and custom functions, as well as a custom trim implementation, allowing users to see practical usage of the v1 API.

documentation-website/Writerside/snippets/exposed-sql-functions · high confidence

Documentation examples for Exposed DAO R2DBC relationships and CRUD operations

Added new Gradle-based example projects to the documentation website to demonstrate the Exposed DAO R2DBC API. The \exposed-dao-r2dbc\ snippets provide runnable code for CRUD operations, including creating entities with composite IDs, reading with joins and computed fields, updating, and deleting. The \exposed-dao-r2dbc-relationships\ snippets demonstrate defining and querying entity relationships, covering one-to-many, many-to-many, parent-child hierarchies, and eager loading patterns.

documentation-website/Writerside/snippets/exposed-dao-r2dbc · high confidence

Documentation now includes runnable example projects for dependency setup

The documentation website now provides dedicated example projects for Groovy Gradle, Kotlin Gradle, and Maven build systems. These new snippets serve as concrete, buildable references for the 'Adding dependencies' topic, allowing users to see exactly how to configure the core Exposed dependencies in their respective build tools.

documentation-website/Writerside/snippets/exposed-modules-groovy-gradle, documentation-website/Writerside/snippets/exposed-modules-kotlin-gradle, documentation-website/Writerside/snippets/exposed-modules-maven · high confidence

Documentation snippet for Exposed SQL migrations with Flyway

Added a new documentation snippet demonstrating how to generate migration scripts using Exposed and apply them via Flyway. The example shows how to use MigrationUtils to generate SQL statements for schema changes and integrate them with Flyway for database migration.

documentation-website/Writerside/snippets/exposed-migrations · high confidence

Documentation snippet for Exposed v1 transaction and exec examples

Added a new documentation snippet project (\exposed-transactions\) demonstrating how to use the Exposed v1 API for database transactions and raw SQL execution. The examples cover basic and parameterized \exec()\ calls, result mapping, multi-statement execution for MySQL, and transaction savepoints/rollbacks, serving as reference code for the 'Working with SQL Strings' and 'Transactions' documentation topics.

documentation-website/Writerside/snippets/exposed-transactions · high confidence

Exposed Kotlin DateTime API surface published

The public API for the exposed-kotlin-datetime module is now explicitly defined, exposing column types for dates, times, timestamps, durations, and instant-based temporal data (including \kotlinx.datetime\ and \kotlin.time\ types), along with helper functions for creating literals, parameters, and custom date/time functions.

exposed-kotlin-datetime/api · high confidence

Exposed v1 JDBC API surface and core execution engine

This change introduces the v1 JDBC implementation layer, providing the foundational API for database interaction. It includes the \Database\ class for managing connections and dialects (with support for Amazon Redshift), the \Query\ class for building and executing SELECT statements (including batched fetching and locking), and the \JdbcTransaction\ class for handling transaction lifecycle and statement execution. The diff also adds utility functions for schema management (\SchemaUtils\), metadata checks (\MetadataQueries\), and SQL execution plans (\ExplainBlockingExecutable\), along with core iterable abstractions (\SizedIterable\) for result handling.

exposed-jdbc/src · high confidence

Exposed v1 core library initial release

The \exposed-core\ module is introduced as a new v1 API, providing the foundational classes for database interaction including \AbstractQuery\ for SQL construction, \Column\ and \ColumnType\ for schema definitions, \DatabaseApi\ and \DatabaseConfig\ for connection management, and \Constraints\ for DDL operations. This release establishes the core architecture for the v1 Exposed library, replacing or preceding the previous internal implementations.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core · high confidence

Initial API surface definition added

A new file defining the public API surface (exposed.api) has been added to the project. This establishes the baseline for the public interface of the library, likely to support API compatibility checks or documentation generation.

api · medium confidence

Initial Writerside documentation build configuration and analytics setup

The documentation website build system is now configured using JetBrains Writerside. This includes a build script that disables the universal zip artifact, a build profile defining the site's header logo, Algolia search credentials, and a feedback widget, and the integration of Google Analytics (GA4) via a verification meta tag and tracking script.

documentation-website/Writerside/cfg · high confidence

Initial documentation website launch with comprehensive Exposed guides

The documentation website has been created, introducing a new structure for Exposed's reference materials. This includes an 'About' page detailing the DSL and DAO APIs and supported databases (H2, MariaDB, MySQL, Oracle, PostgreSQL, Redshift, SQL Server, SQLite), an 'Adding dependencies' guide covering Gradle/Maven setup and the new version catalog, and detailed topic pages for data types such as Arrays, Binary, and Custom types. The site also features a 'Breaking Changes' reference for version 1.0.0 and a 'Contributing' guide outlining code style, commit message conventions, and pull request procedures.

documentation-website/Writerside/topics · high confidence

Initial project scaffolding and documentation setup

The repository is initialized with core project files, including the Apache 2.0 license, a comprehensive README detailing supported databases (H2, MariaDB, MySQL, Oracle, PostgreSQL, Amazon Redshift, SQL Server, SQLite) and modules (core, DAO, JDBC, R2DBC), and a CHANGELOG documenting versions up to 1.5.0. Development tooling is configured via .editorconfig for code style and .gitignore for build artifacts, while CLAUDE.md and context7.json provide AI assistant guidance. The legacy 'README' placeholder file is removed.

(repo-wide) · high confidence

Initial public API for JSON column operations and types

This change introduces the public API surface for the \exposed-json\ module, making JSON-specific database operations and column types available to users. It exposes the \JsonColumnType\ and \JsonBColumnType\ classes for defining JSON and JSONB columns, along with utility functions \json()\ and \jsonb()\ for column creation. Additionally, it provides the \JsonConditionsKt\ functions \contains\ and \exists\ for querying JSON data, as well as the \Extract\ function for extracting JSON values, enabling structured interaction with JSON fields in supported databases.

exposed-json/api · high confidence

Initial public API surface for Exposed R2DBC

The \exposed-r2dbc\ module now exposes its complete public API, defining the contract for the new reactive database driver. This includes the \QueriesKt\ functions for executing standard operations (select, insert, update, delete, upsert, batch operations) as suspend functions, the \Query\ class implementing \SizedIterable\ and \SuspendExecutable\ for reactive result handling, and support for set operations (Except, Intersect). The API also introduces \SuspendExecutable\ for explain queries and \ReturningSuspendExecutable\ for returning clauses, establishing the foundation for non-blocking database interactions.

exposed-r2dbc/api · high confidence

Initial public API surface for the DAO module

The DAO module now exposes its public API through the \exposed-dao.api\ file, defining the stable contract for the Data Access Object layer. This includes the core \Entity\ and \EntityClass\ abstractions for managing records, \CompositeEntity\ support for tables with composite primary keys, and \EntityBatchUpdate\ for efficient bulk operations. The API also introduces \EntityCache\ for managing in-memory caching and state, along with \EntityChange\ and \EntityChangeType\ to track and react to entity lifecycle events.

exposed-dao/api · high confidence

Introduce Exposed Gradle Plugin for schema migrations

The Exposed Gradle Plugin is now available to automate database migration script generation. By applying the plugin and configuring the \exposed { migrations { ... } }\ block in your \build.gradle.kts\, you can define table packages, database connection details (or TestContainers images), and output formatting options. Running the \generateMigrations\ task scans your Exposed table definitions and produces SQL migration scripts, supporting features like multiple table packages, custom file naming formats, and command-line overrides for single-file output.

exposed-gradle-plugin · high confidence

Introduce Exposed v1 R2DBC support

Adds the Exposed v1 R2DBC module, enabling non-blocking, reactive database access via the R2DBC protocol. This new capability provides a full suite of asynchronous query execution (SELECT, INSERT, UPDATE, DELETE), transaction management, and metadata operations, allowing users to integrate Exposed with reactive stacks and drivers such as PostgreSQL, MySQL, H2, Oracle, and SQL Server.

exposed-r2dbc/src · high confidence

Introduce R2DBC DAO API for reactive entity management

Adds the \exposed-dao-r2dbc\ module, providing a reactive DAO layer built on R2DBC. This includes core classes like \Entity\ and \EntityClass\ for mapping rows to objects, an \EntityCache\ for transactional state management, and support for relationships via \Accessor\ (many-to-one), \BackReference\ (one-to-one), and eager loading utilities (\load\, \with\). It also introduces \CompositeEntity\ for composite primary keys and \EntityBatchUpdate\ for bulk operations, all marked with \@ExperimentalR2dbcDaoApi\. Also in this area: Fix: Prevent insertion of deleted unflushed entities in R2DBC DAO.

exposed-dao-r2dbc · high confidence

Introduce R2DBC-based database migration utilities

Exposed now provides a new \exposed-migration-r2dbc\ module that brings schema migration capabilities to R2DBC applications. The \MigrationUtils\ object exposes functions such as \statementsRequiredForDatabaseMigration\, \dropUnmappedColumnsStatements\, \dropUnmappedIndices\, and \generateMigrationScript\, allowing users to generate and review SQL statements for schema changes asynchronously. This includes support for handling column comments, auto-increment sequences, and check constraints within the R2DBC transactional context.

exposed-migration-r2dbc · high confidence

Introduce Spring Boot auto-configuration and GraalVM AOT support

The Spring Boot starter now includes an auto-configuration class that automatically registers the database initializer, transaction manager, and database configuration beans, simplifying setup for users. Additionally, an Ahead-Of-Time (AOT) processor is provided to support GraalVM native image compilation, ensuring the framework works correctly in native environments.

exposed-spring-boot-starter/api · high confidence

Introduce coroutine-aware transaction context management

Added TransactionContextElement and TransactionContextHolder to properly manage transaction state across coroutine suspensions and thread switches. TransactionContextElement ensures that when a coroutine is suspended and resumed on a different thread, the transaction is correctly pushed onto and popped from the thread-local stack, preventing stack corruption and duplicate entries. TransactionContextHolder provides an interface for associating transactions with specific coroutine contexts, enabling better integration between Exposed's transaction management and Kotlin coroutines.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/transactions/suspend · high confidence

Introduce v1 DAO identity table hierarchy with UUID and composite key support

The v1 DAO layer now provides a dedicated identity table structure under \org.jetbrains.exposed.v1.core.dao.id\, introducing \IdTable\ as the base for identity columns and specific implementations including \IntIdTable\, \UIntIdTable\, \LongIdTable\, \ULongIdTable\, and \UUIDTable\. This update adds support for \kotlin.uuid.Uuid\ as a primary key type via \UuidTable\, which auto-generates UUIDs (defaulting to version 4, with version 7 support) using the new \autoGenerate()\ mechanism, alongside a legacy \UUIDTable\ for \java.util.UUID\. Additionally, \CompositeIdTable\ and \CompositeID\ are introduced to handle primary keys composed of multiple columns, while \EntityID\ serves as the wrapper for identity values.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/dao · high confidence

Introduce v1 JSON and JSONB column types with query operators

The exposed-json module now provides \json()\ and \jsonb()\ column definitions for storing JSON data in text or binary formats, including specific handling for SQLite's JSONB type and PostgreSQL CLOB deserialization. It also adds query-time capabilities via \contains()\ and \exists()\ operators to search within JSON structures, and \extract()\ along with \castToJson()\ functions to retrieve and cast JSON sub-components, all integrated with the v1 core API.

exposed-json/src/main · high confidence

Java 8 Date/Time API support in Exposed v1

The exposed-java-time module now provides column types and SQL functions for Java 8 date and time classes (java.time), including LocalDate, LocalDateTime, LocalTime, Instant, OffsetDateTime, and Duration. This allows users to map database columns directly to these standard Java types and use corresponding SQL functions (such as date, time, year, month, day, hour, minute, second, and current timestamp variants) within their queries.

exposed-java-time/src/main · high confidence

New Crypt module adds encryption and password hashing column types

The exposed-crypt module now provides built-in support for encrypting and hashing data in database columns. Users can store encrypted strings or binary data using the new \encryptedVarchar\ and \encryptedBinary\ column types, which support AES-256 (GCM and CBC modes), Blowfish, and Triple DES algorithms via the \Algorithms\ object. For password storage, the module introduces a \hashed\ column extension that stores one-way hashes, supporting OWASP-recommended algorithms including Argon2id, BCrypt, PBKDF2, and scrypt through dedicated hasher classes (\Argon2Hasher\, \BCryptHasher\, \Pbkdf2Hasher\, \SCryptHasher\). This allows developers to securely store sensitive data without managing encryption logic manually.

exposed-crypt/src/main · high confidence

New Exposed DSL documentation snippets for v1

The documentation website now includes a dedicated snippets project (\exposed-dsl\) containing comprehensive Kotlin examples for the Exposed v1 API. These new files demonstrate core DSL capabilities including table definitions (with custom names and IntIdTable), querying (where conditions, joins, unions, distinct, sorting, and custom index hints), CRUD operations (insert, update, delete, replace, upsert, and batch operations), and statement building (prepareSQL). This provides users with concrete, copy-pasteable reference code for the new v1 syntax.

documentation-website/Writerside/snippets/exposed-dsl/src/main/kotlin/org/example/examples · high confidence

New Exposed Maven plugin for generating SQL migration scripts

A new Maven plugin has been introduced to automatically generate SQL migration scripts from Exposed table definitions. The plugin provides the \exposed:generate-migrations\ goal, which scans the project's classpath for Exposed table definitions in specified packages and outputs SQL files to a configurable directory. Users can configure the output via parameters such as file prefix, separator, version format, and extension, and can connect to a live database via JDBC URL or use Testcontainers for schema comparison. The plugin also includes integration tests to verify generation against H2 and PostgreSQL templates.

exposed-maven-plugin · high confidence

New Exposed v1 DAO relationships example project

A new Gradle-based example project has been added to the documentation website to demonstrate how to create and manage relationships between entities using the Exposed DAO API. The project includes Kotlin code for defining tables (such as Actors, Films, and Users), entity classes, and example scenarios covering one-to-many, many-to-many, parent-child, and eager loading patterns. This serves as a reference implementation for the DAO Relationships documentation topic.

documentation-website/Writerside/snippets/exposed-dao-relationships · high confidence

New JDBC migration utility API for schema synchronization

The \exposed-migration-jdbc\ module now exposes a new \MigrationUtils\ API that allows users to generate SQL migration scripts and identify required schema changes without automatically applying them. This utility provides functions to generate migration scripts to files, retrieve statements for database migration (including creating tables, altering columns, and dropping unmapped indices or sequences), and explicitly drop unmapped columns or indices. It also includes support for migrating column comments, ensuring that schema definitions in code can be accurately reflected in the database through generated SQL statements.

exposed-migration-jdbc · high confidence

New Java Time API surface for Exposed

The \exposed-java-time\ module now exposes a comprehensive public API for working with Java 8+ date and time types. This includes column types for \LocalDate\, \LocalDateTime\, \LocalTime\, \Instant\, \Duration\, and \OffsetDateTime\, along with helper functions to create columns of these types. The API also provides functions for extracting date/time components (year, month, day, hour, minute, second) and creating literals/parameters for these types, as well as singleton functions for current date, time, and timestamp values.

exposed-java-time/api · high confidence

New Spring 7 transaction integration with thread-safe rollback rules

The \spring7-transaction\ module introduces \SpringTransactionManager\ and \ExposedSpringTransactionAttributeSource\ to integrate Exposed with Spring 7's transaction management. \SpringTransactionManager\ bridges Exposed's transaction stack with Spring's \AbstractPlatformTransactionManager\, supporting nested transactions and \REQUIRES\_NEW\ propagation. \ExposedSpringTransactionAttributeSource\ automatically adds \ExposedSQLException\ to rollback rules and, crucially, returns a defensive copy of transaction attributes to prevent data races on the delegate's cached instances, ensuring thread safety under concurrent access.

spring7-transaction · high confidence

New Spring JDBC transaction integration and attribute source

Added \SpringTransactionManager\ to enable standard Spring JDBC transaction management within Exposed, allowing users to leverage Spring's transaction infrastructure for database operations. Introduced \ExposedSpringTransactionAttributeSource\ to automatically include \SQLException\ in rollback rules for transaction attributes, ensuring consistent error handling. These components work together to provide a seamless integration between Exposed's transaction scope and Spring's transaction abstraction.

spring-transaction/src/main · high confidence

New documentation snippet project for Exposed DSL examples

A new snippets project has been added to the documentation website to host standalone, runnable code examples for the Exposed DSL. The main application file demonstrates how to connect to H2, SQLite, and MySQL databases, create schema tables, and execute various CRUD operations including custom selects, alias usage, and SQL statement preparation. This change extracts DSL code snippets into a dedicated module to support non-H2 compatible queries and provide clearer, isolated examples for users learning the library.

documentation-website/Writerside/snippets/exposed-dsl/src/main/kotlin/org/example · high confidence

New internal migration utility API for schema diffing and script generation

The exposed-migration-core module now includes a new internal API class, MigrationUtilityApi, which provides helper methods for database schema migrations. This class extends SchemaUtilityApi and introduces protected methods to filter missing or unmapped database sequences relative to table definitions, generate DROP statements for columns present in the database but not in the current schema mapping, and write a list of SQL statements to a migration script file. These utilities support the underlying mechanics of generating migration scripts by handling sequence alignment and column removal logic.

exposed-migration-core · high confidence

New sample project for Exposed data types

Added a new Gradle application under \documentation-website/Writerside/snippets/exposed-data-types\ that demonstrates how to use Exposed's data types. The project includes example code for basic types (numeric, boolean, string), arrays (including multi-dimensional), binary data, enumerations (ordinal, named, and custom PostgreSQL enums), and date/time handling via Kotlin DateTime, Java Time, and Joda Time libraries. This sample serves as a runnable reference for the documentation's data types topics.

documentation-website/Writerside/snippets/exposed-data-types · high confidence

New v1 DAO API with entity caching and lifecycle hooks

The \exposed-dao\ module now provides a new v1 Data Access Object API that introduces an \EntityCache\ for per-transaction entity caching, typed entity base classes (\IntEntity\, \LongEntity\, \CompositeEntity\), and an \EntityHook\ system for subscribing to entity lifecycle events (created, updated, removed). This change adds the core infrastructure for the DAO pattern, including batch updates and relationship management via \InnerTableLink\, while the previous DAO implementation is no longer present in this location.

exposed-dao/src · high confidence

New v1 Spring Boot starter with auto-schema generation and GraalVM native image support

The exposed-spring-boot-starter now includes a new v1 package (org.jetbrains.exposed.v1.spring.boot) that provides automatic database schema creation via the DatabaseInitializer class, which scans application packages for Exposed Table definitions and generates DDL when the spring.exposed.generate-ddl property is enabled. Additionally, the ExposedAotContribution class registers comprehensive reflection and resource hints required for running Exposed applications as GraalVM native images, resolving previous native runtime failures related to missing reflection hints for column types and entity classes.

exposed-spring-boot-starter/src/main/kotlin · high confidence

New v1 core statement classes for batch and multi-row operations

The \exposed-core\ module now includes a comprehensive set of new statement classes in the \statements\ package to support advanced data manipulation. This introduces \BatchInsertStatement\, \BatchUpdateStatement\, \BatchUpsertStatement\, and \BatchReplaceStatement\ for performing bulk operations, along with \MultiRowValuesInsertStatement\ and \SQLServerBatchInsertStatement\ to enable single-statement multi-row inserts with database-specific limits. Additionally, \MergeStatement\ (with \MergeTableStatement\ and \MergeSelectStatement\) provides SQL MERGE support, while \ReturningStatement\ allows retrieving data from modified rows. Supporting infrastructure includes \DeleteStatement\, \InsertSelectStatement\, \ReplaceStatement\, and a refactored \StatementBuilder\ interface that exposes the corresponding DSL methods (e.g., \batchInsert\, \deleteReturning\).

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements · high confidence

Support for storing monetary values using Java Money API

Users can now store money amounts and currencies in the database using the Java Money API (javax.money). This change introduces a new \CompositeMoneyColumn\ that maps a \MonetaryAmount\ to two underlying database columns (a decimal for the amount and a varchar for the currency code), along with a dedicated \CurrencyColumnType\ for handling currency units. Extension functions on \Table\ allow easy definition of these composite columns, and the DAO layer supports reading and writing \MonetaryAmount\ objects directly, including handling defaults and nullable values.

exposed-money/src · high confidence

API

Exposed Crypt API stability for encryption and hashing

The public API for the Exposed Crypt module is now stabilized, exposing the core classes and functions for encryption and hashing. This includes the \Algorithms\ utility for selecting encryption modes (AES-256 PBE CBC/GCM, Blowfish, Triple DES), the \Encryptor\ interface, and column transformers (\StringEncryptionTransformer\, \ByteArrayEncryptionTransformer\) for \EncryptedVarChar\ and \EncryptedBinary\ columns. It also stabilizes the hashing infrastructure, including the \Hasher\ interface, specific hashers (\Argon2Hasher\, \BCryptHasher\, \Pbkdf2Hasher\, \SCryptHasher\), and the \Hashed\ value class, along with extension functions on \Table\ to define encrypted and hashed columns.

exposed-crypt/api · high confidence

Exposed JDBC API v1 public surface published

The \exposed-jdbc\ module now exposes a stable v1 API surface (defined in \exposed-jdbc.api\) that makes core JDBC integration classes and functions public. This includes the \Database\ class and its companion for connection management, \JdbcTransaction\ for transaction handling, and top-level query functions such as \batchInsert\, \batchReplace\, and \batchUpsert\. Users can now rely on these specific JDBC transaction and batch operation APIs as part of the public contract.

exposed-jdbc/api · high confidence

Exposed Joda-Time API surface published for v1

The public API for the exposed-jodatime module has been established, exposing the full set of date and time column types (Date, DateTime, Time, and TimestampWithTimeZone) along with their corresponding column factories and helper functions. This includes support for extracting date/time components (Year, Month, Day, Hour, Minute, Second) and functions for current date/time, literals, and parameters, enabling users to define and query Joda-Time based columns in their database schemas.

exposed-jodatime/api · high confidence

New Spring Transaction API surface for transaction management

The public API for Spring integration now exposes the \ExposedSpringTransactionAttributeSource\ and \SpringTransactionManager\ classes. Users can utilize \ExposedSpringTransactionManager\ to manage database transactions within Spring applications, and \ExposedSpringTransactionAttributeSource\ to define transaction attributes for methods, enabling declarative transaction management support.

spring-transaction/api · high confidence

Architecture

Exposed v1 core vendor dialects and providers restructured

The core vendor-specific logic for database dialects (H2, MySQL, MariaDB, Oracle, PostgreSQL, SQLite, SQL Server, etc.) has been reorganized into the \exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/vendors\ package. This change introduces new foundational classes like \ColumnMetadata\, \DataTypeProvider\, \FunctionProvider\, and \DatabaseDialect\, alongside a dedicated \ForUpdateOption\ class that standardizes row-level locking clauses (e.g., \FOR UPDATE\, \SKIP LOCKED\) across different databases. Users benefit from a more consistent and extensible internal architecture that better supports vendor-specific SQL generation, data type mapping, and advanced locking behaviors without requiring changes to their existing query code.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/vendors · high confidence

Refactored core statement and metadata API classes into separate files

The internal API classes in the \exposed-core\ statements module have been separated from a single monolithic file into distinct files (ExposedBlob, ExposedDatabaseMetadata, ExposedMetadataUtils, ExposedSavepoint, IdentifierManagerApi, PreparedStatementApi, and ResultApi). This structural change improves code organization and maintainability without altering the public API surface or user-facing behavior.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements/api · high confidence

Behavioural changes

2 commits (0 fixes) modifying documentation-website/Writerside/snippets/exposed-dao-r2dbc-relationships

A change to existing behaviour in documentation-website/Writerside/snippets/exposed-dao-r2dbc-relationships — 2 commits, 16 files: “docs: EXPOSED-1086 Add docs for R2DBC DAO and a what's new topic (\#2949)”; “docs: fix: snippets build issues (\#2987)” (refs \#2949, \#2987).

documentation-website/Writerside/snippets/exposed-dao-r2dbc-relationships · medium confidence · unverified

2 commits (0 fixes) modifying documentation-website/Writerside/snippets/get-started-with-exposed-dao

A change to existing behaviour in documentation-website/Writerside/snippets/get-started-with-exposed-dao — 2 commits, 3 files: “docs: fix: snippets build issues (\#2987)”; “docs: EXPOSED-747 Add a get started tutorial for Exposed DAO (\#2556)” (refs \#2987, \#2556).

documentation-website/Writerside/snippets/get-started-with-exposed-dao · medium confidence · unverified

Add R2DBC database connection examples to documentation

The documentation website now includes a new snippet project for R2DBC databases, providing copy-paste examples for connecting to PostgreSQL, MySQL, Oracle, MariaDB, SQL Server, and H2 via R2DBC. These examples demonstrate the updated \R2dbcDatabase.connect()\ API and the new \suspendTransaction()\ function, aligning with the recent API changes to Exposed's transaction handling.

documentation-website/Writerside/snippets/exposed-databases-r2dbc · high confidence

Added logging configuration and platform mapping for Windows Server 2019

The test resources now include a log4j2.xml configuration file to define console and async logging appenders for the Exposed framework, replacing previous logging setups. Additionally, a new platform-map.properties file has been added to map various operating system identifiers to standardized platform names, explicitly adding support for Windows Server 2019 (amd64) alongside existing mappings for Linux, macOS, Solaris, FreeBSD, and older Windows versions.

exposed-tests/src/main/resources · high confidence

Documentation snippets updated for Exposed v1 DAO entity definitions

The documentation website snippets for the Exposed DAO module have been updated to reflect the v1 API, introducing new entity examples that demonstrate key features such as base entity inheritance with automatic timestamp handling, immutable entities, composite and custom ID types, column transformations (including Base64 and unsigned integer handling), and custom entity overrides. These changes align the reference code with the Exposed v1 core and DAO libraries, ensuring users have accurate, up-to-date examples for implementing entities in the new version.

documentation-website/Writerside/snippets/exposed-dao/src/main/kotlin/org/example/entities · high confidence

Documentation snippets updated to Exposed v1 API

The code samples in the documentation website have been migrated from the previous API to the Exposed v1 interface (importing from \org.jetbrains.exposed.v1.\*\). This includes new table definitions such as \BaseTable\ with auto-fill timestamp columns, \DirectorsTable\ using composite IDs, and \StarWarsFilmsWithRankTable\ demonstrating the new \Rank\ API, ensuring the reference code aligns with the 1.0.0 release.

documentation-website/Writerside/snippets/exposed-dao/src/main/kotlin/org/example/tables · high confidence

Exposed Money API stability and nullability fixes

The exposed-money module introduces stricter type safety for composite money columns and corrects nullability definitions in the compositeMoney() function, ensuring that currency and amount columns are handled consistently with their database representations. Additionally, the API now exposes a dedicated CurrencyColumnType for better integration with javax.money.CurrencyUnit, improving type safety when working with currency data.

exposed-money/api · high confidence

Initial Writerside documentation website structure and runnable code snippets

The documentation site has been restructured using JetBrains Writerside, introducing a new navigation hierarchy (hi.tree) that organizes content into sections such as Getting Started, Schemas, Transactions, Deep Dive into DSL/DAO, and Tools. To support accurate and runnable examples, a new snippets directory has been added containing Gradle and Maven projects for the Gradle and Maven plugins, a DAO tutorial, and data hashing. The site configuration (writerside.cfg) now references these snippets and defines version variables (v.list) for supported databases and libraries, while redirection rules (redirection-rules.xml) preserve access to previously removed documentation pages.

documentation-website/Writerside · high confidence

Migrate datetime columns and functions from kotlinx.datetime.Instant to kotlin.time.Instant

The exposed-kotlin-datetime module now uses kotlin.time.Instant as the primary type for timestamp columns and functions, replacing the deprecated kotlinx.datetime.Instant. New column types (KotlinInstantColumnType) and extension functions (Table.timestamp, Date, Time, Year, CurrentTimestamp) are provided for the standard library type, while the previous implementations are marked deprecated with clear migration paths. This change aligns the library with the deprecation of Instant in kotlinx-datetime, ensuring future compatibility and consistent behavior across supported databases.

exposed-kotlin-datetime/src/main · high confidence

Migration generator supports multiple table packages and prevents timestamp collisions

The migration generator now accepts a list of package names (via the new \tablesPackages\ configuration option) in addition to the single \tablesPackage\, allowing table definitions to be scanned across multiple packages. Additionally, to prevent migration version collisions when generating multiple files in a single run, timestamp-based version formats now append an index suffix (e.g., \.1\, \.2\) to subsequent migrations, ensuring unique and ordered file names.

exposed-plugin-core · high confidence

New Gradle build infrastructure for testing, publishing, and code quality

The build system now includes dedicated Gradle plugins in buildSrc to streamline development workflows. A new TestDb DSL automatically manages Docker containers for database integration tests, allowing tests to run against specific database dialects while excluding incompatible modules (such as Spring or plugin tests) from non-matching environments. Publishing is standardized via a new helper that configures Maven Central metadata (licenses, developers, SCM) for artifacts. Additionally, Detekt is configured to run in parallel on documentation snippets and sample code, with results displayed directly in the terminal rather than generating XML reports.

buildSrc · high confidence

Refactored Joda-Time module to use new v1 core abstractions

The Joda-Time date and time handling has been refactored to align with the new \exposed-v1\ core architecture. The \DateColumnType.kt\ and \DateFunctions.kt\ files now implement column types (such as \JodaLocalDateColumnType\ and \JodaLocalDateTimeColumnType\) that extend the new \v1.core.datetime\ base classes, replacing previous implementations. This change updates how Joda-Time \DateTime\ and \LocalTime\ values are mapped to and from the database, ensuring compatibility with the updated core framework while preserving existing SQL function support for date, time, and timestamp operations.

exposed-jodatime/src/main · high confidence

Refactored datetime column types for improved database dialect support

The datetime column type implementations in the core module have been refactored to provide more robust and dialect-specific handling of date, time, and duration values. This change introduces specialized formatting and parsing logic for MySQL, Oracle, SQLite, and PostgreSQL, ensuring correct round-tripping of data across different database engines. Key improvements include fixing timestamp misreads for dates before the Unix epoch, adding support for storing duration intervals as nanoseconds, and standardizing how default values and string representations are generated for each dialect.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/datetime · high confidence

Refactored transaction management into a pluggable core interface

The transaction management logic in the core module has been restructured to support customization and multiple database drivers. A new \TransactionsHolder\ interface and \TransactionsHolderProvider\ allow the transaction stack implementation to be swapped via ServiceLoader (e.g., for Spring integration), with \ThreadLocalTransactionsStack\ as the default. Additionally, a new \DatabasesManager\ interface and \TransactionManagersContainer\ centralize the tracking of database instances and their associated transaction managers, replacing the previous monolithic structure.

exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/transactions · high confidence

Spring Boot 3 compatibility and configuration metadata support

The Exposed Spring Boot starter now supports Spring Boot 3 and GraalVM native images. This is achieved by migrating auto-configuration registration from the deprecated spring.factories to the new AutoConfiguration.imports file, adding an AOT (Ahead-of-Time) factory for native image support, and introducing a spring-configuration-metadata.json file. The metadata file exposes three new configuration properties for users: spring.exposed.generate-ddl to auto-generate the database schema, spring.exposed.show-sql to log SQL queries, and spring.exposed.excluded-packages to exclude specific packages from schema generation.

exposed-spring-boot-starter/src/main/resources · high confidence

Updated DAO documentation snippet to use Exposed v1 API

The code snippet in the documentation website has been updated to demonstrate the Exposed v1 API. The example now uses the \org.jetbrains.exposed.v1\ package namespace for database configuration, schema management, and transaction handling, replacing previous versions that likely used the older API structure.

documentation-website/Writerside/snippets/exposed-dao/src/main/kotlin/org/example · high confidence

Updated Exposed DAO documentation snippets for version 1.0.0

The documentation website now includes new code snippets for the Exposed DAO module, demonstrating CRUD operations (Create, Read, Update, Delete) using the Exposed 1.0.0 API. These examples illustrate entity creation with auto-generated and composite IDs, querying with sorting and joins, and updating records, ensuring the documentation aligns with the recent major version bump to Exposed 1.0.0.

documentation-website/Writerside/snippets/exposed-dao/src/main/kotlin/org/example/examples · high confidence

Test coverage

Added H2 and PostgreSQL test suites for connection pooling, concurrency, and multi-database scenarios; Added comprehensive test coverage for DAO entity management and caching; Added comprehensive test coverage for JSON and JSONB columns; Added comprehensive test coverage for datetime column types and literals; Added comprehensive test suite for Spring transaction management; Added shared test utilities and schema definitions; Added test coverage for DDL operations including column comments, index creation, and sequence management; Added test coverage for Exposed v1 shared functionality; Added test coverage for Java Time types and DAO defaults; Added test coverage for JodaTime date and datetime operations; Added test coverage for R2DBC DAO module; Added test coverage for SQL functions and window functions; Added test coverage for encrypted and hashed columns in the Crypt module; Added test coverage for shared database column types; Added tests for Amazon Redshift dialect support; Added tests for Oracle FOR UPDATE SKIP LOCKED support; Added tests for ResultRow caching and Version parsing; Added tests for SQL Server temporal table default expressions; Added tests for Spring Boot starter auto-configuration and JDBC template integration; Added tests for mixed JDBC and R2DBC database connections; Expanded test coverage for DML operations and query features; Initial R2DBC test suite scaffolding; New centralized test infrastructure for Exposed v1.

Dependencies

Updated sample projects to use Exposed 1.5.0 and Kotlin 2.2.20

The documentation sample projects (including Gradle and Maven configurations for DAO, DSL, data types, and migration snippets) have been updated to reference Exposed version 1.5.0 and Kotlin version 2.2.20. This ensures that the code examples in the documentation align with the latest library releases and compiler versions.

(dependencies) · high confidence

Housekeeping

Documentation examples for JSON and JSONB data types; Exposed Core API Snapshot for Version 1.

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

How this codebase got here

Score

  • CAI 53 → 62 (+9.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 66 → 66 (-0.2)
  • Architecture 97 → 97 (-0.7)
  • Maturity 66 → 62 (-3.2)
  • Readiness 43 → 55 (+11.9)
  • Security 52 → 72 (+19.5)
  • Performance 81 → 100 (+19.4)

Resolved (143)

  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (10 lines × 2) (documentation-website/Writerside/snippets/exposed-dao-r2dbc/src/main/kotlin/org/example/entities/BaseEntityClass.kt)
  • Duplicated block (10 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (10 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (10 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (10 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/IterableEx.kt)
  • Duplicated block (10 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/IterableEx.kt)
  • Duplicated block (10 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/transactions/JdbcTransactionManager.kt)
  • Duplicated block (10 lines × 2) (samples/exposed-jdbc-dao-sample/src/main/kotlin/org/jetbrains/exposed/samples/broker/jdbc/routes/ClientRoutes.kt)
  • Duplicated block (11 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (11 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (11 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityFieldWithTransform.kt)
  • Duplicated block (11 lines × 2) (exposed-dao/src/main/kotlin/org/jetbrains/exposed/v1/dao/Entity.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/JdbcTransaction.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/SchemaUtils.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/transactions/Transactions.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/vendors/MysqlDialectMetadata.kt)
  • Duplicated block (11 lines × 2) (exposed-migration-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/migration/jdbc/MigrationUtils.kt)
  • Duplicated block (11 lines × 2) (samples/exposed-jdbc-dao-sample/src/main/kotlin/org/jetbrains/exposed/samples/broker/jdbc/routes/SeedRoutes.kt)
  • Duplicated block (12 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityHook.kt)
  • …and 123 more

New (494)

  • Banned license: com.mysql:mysql-connector-j
  • Banned license: mysql:mysql-connector-java
  • Duplicated block (10 lines × 2) (documentation-website/Writerside/snippets/exposed-dao-r2dbc/src/main/kotlin/org/example/entities/BaseEntityClass.kt)
  • Duplicated block (10 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements/BatchUpsertStatement.kt)
  • Duplicated block (10 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (10 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (10 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/IterableEx.kt)
  • Duplicated block (10 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/IterableEx.kt)
  • Duplicated block (10 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/transactions/JdbcTransactionManager.kt)
  • Duplicated block (10–12 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (10–12 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (11 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityClass.kt)
  • Duplicated block (11 lines × 2) (exposed-dao-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/dao/r2dbc/EntityFieldWithTransform.kt)
  • Duplicated block (11 lines × 2) (exposed-dao/src/main/kotlin/org/jetbrains/exposed/v1/dao/Entity.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/JdbcTransaction.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/SchemaUtils.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/transactions/Transactions.kt)
  • Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/vendors/MysqlDialectMetadata.kt)
  • Duplicated block (11 lines × 2) (exposed-migration-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/migration/jdbc/MigrationUtils.kt)
  • Duplicated block (11 lines × 2) (samples/exposed-jdbc-dao-sample/src/main/kotlin/org/jetbrains/exposed/samples/broker/jdbc/routes/SeedRoutes.kt)
  • …and 474 more

Changes since last survey

  • 27 commits — 20 feature/other, 7 fixes

By area

  • gradle/libs.versions.toml — 11 commits
  • documentation-website/Writerside — 7 commits
  • exposed-core/src — 4 commits
  • .github/workflows — 1 commit
  • docs/api — 1 commit
  • exposed-dao-r2dbc/src — 1 commit
  • exposed-jdbc/src — 1 commit
  • exposed-r2dbc/src — 1 commit

Notable commits

  • fix: fix: EXPOSED-1075 Keep JSONB column identity out of the SELECT list rewrite (#2913)
  • fix: fix: EXPOSED-1094 Add failing test for deleting an unflushed entity that is still referenced (#2970)
  • fix: fix: EXPOSED-1097 Make JDBC & R2DBC transaction context registry thread-safe (#2950)
  • fix: fix: EXPOSED-1117 Render jsonb extract path as a literal on PostgreSQL (#2977)
  • fix: fix: Keep H2's foreign key indices out of migration statements (#2976)
  • fix: fix: LocalDateTimeColumnType misreads datetime values before Unix epoch (#2969)
  • fix: fix: Resolve R2dbcDatabase.identifierManager without a connection (#2972)
  • change: build(deps): Bump com.amazon.redshift:redshift-jdbc42 (#2986)
  • change: build(deps): Bump com.oracle.database.jdbc:ojdbc11 (#2997)
  • change: build(deps): Bump flyway from 13.6.0 to 13.9.0 (#2954)
  • change: build(deps): Bump flyway from 13.9.0 to 13.12.0 (#2996)
  • change: build(deps): Bump io.github.hakky54:logcaptor from 2.12.6 to 2.13.0 (#2985)
  • change: build(deps): Bump joda-time:joda-time from 2.14.4 to 2.15.1 (#2994)
  • change: build(deps): Bump maven-api from 3.9.16 to 3.10.0 (#2945)
  • change: build(deps): Bump org.apache.maven.plugin-tools:maven-plugin-annotations (#2923)
  • change: build(deps): Bump org.jetbrains.kotlinx.kover from 0.9.9 to 0.9.11 (#2955)
  • change: build(deps): Bump org.postgresql:postgresql from 42.7.13 to 42.7.14 (#2993)
  • change: build(deps): Bump org.xerial:sqlite-jdbc from 3.53.4.0 to 3.54.1.0 (#2995)
  • change: build: Run GitHub workflows on pull requests targeting develop/* and release/* branches (#3012)
  • change: chore: Bump Exposed version from 1.6.0 to 1.6.1 (#3000)
  • …and 7 more

Architecture

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

Added bounded contexts (4)

  • documentation-website/Writerside/snippets/exposed-spring
  • exposed-dao
  • exposed-dao-r2dbc
  • samples/exposed-spring

Removed bounded contexts (4)

  • documentation-website/Writerside/snippets/exposed-spring
  • exposed-dao
  • exposed-dao-r2dbc
  • samples/exposed-spring

Added dependency edges (6)

  • documentation-website/Writerside/snippets/exposed-spring → exposed-core
  • exposed-dao → exposed-core (coupling)
  • exposed-dao → exposed-jdbc
  • exposed-dao-r2dbc → exposed-core (coupling)
  • exposed-dao-r2dbc → exposed-r2dbc
  • samples/exposed-spring → exposed-core

Removed dependency edges (was a dependency, now gone) (6)

  • documentation-website/Writerside/snippets/exposed-spring → exposed-core
  • exposed-dao → exposed-core (coupling)
  • exposed-dao → exposed-jdbc
  • exposed-dao-r2dbc → exposed-core (coupling)
  • exposed-dao-r2dbc → exposed-r2dbc
  • samples/exposed-spring → exposed-core

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

Survey your own repository

JetBrains/Exposed 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.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 51b78c1fa4c8967aa56779fbcd8d6ae8dfa40c24 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.63+preprod-4a8cc97a9484.