JetBrains/Exposed

This release introduces the Exposed v1 API, a comprehensive refactor of the core library that establishes a new, stable public interface for query construction, column handling, and transaction management. The update brings robust support for asynchronous operations via R2DBC, alongside significant enhancements to the DAO layer with entity caching and lifecycle hooks. Additionally, the release expands the ecosystem with encrypted column types, JSON handling, and Spring Boot 3/4 auto-configuration, all supported by extensive new test coverage and documentation samples.

New Kotlin example files (CreateExamples, DeleteExamples, ReadExamples, UpdateExamples) were added to the documentation website, demonstrating how to perform Create, Read, Update, and Delete operations using the Exposed DAO API, including support for composite IDs and joins.

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

Added App.kt code snippet for the Exposed DAO documentation, demonstrating database connection setup and CRUD (Create, Read, Update, Delete) example implementations for tables such as StarWarsFilms, Directors, Users, and others.

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

Added a new \exposed-dsl\ snippets project containing Kotlin example files for documentation. The new files demonstrate usage of the Exposed DSL, including table definitions (e.g., \StarWarsFilmsTable\, \ActorsTable\), query building, joins, updates, and other data operations. These snippets are referenced by line numbers in the documentation topics (e.g., \DSL-Querying-Data.topic\), providing concrete code examples for users.

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

A new sample project for the Exposed Gradle plugin has been added to demonstrate the \generateMigrations\ task. The sample uses JDBC with an H2 in-memory database to generate SQL migration scripts from Kotlin table definitions, providing a hands-on example of the plugin's workflow. The project includes all necessary Gradle wrapper files, a \.gitignore\ for build artifacts, and example table definitions for 'Users' and 'Cities' to illustrate schema generation.

documentation-website/Writerside/snippets/exposed-data-types/src/main/kotlin/org/example, samples/exposed-gradle-plugin-sample · high confidence

A new sample project has been added at samples/exposed-ktor-r2dbc, demonstrating a Ktor application using Exposed with R2DBC and PostgreSQL. The sample implements a basic project-issue tracker with Domain-Driven Design, featuring RESTful endpoints for managing projects, users, issues, and comments. It includes a Dockerfile and docker-compose.yml for easy local development, along with an endpoints.http file for testing the API.

samples/exposed-ktor, samples/exposed-ktor-r2dbc, samples/exposed-migration · high confidence

The Exposed plugin core now includes the foundational classes for generating migration scripts, including \MigrationConfig\ for build-tool-agnostic configuration, \MigrationGenerator\ to scan classpaths and produce SQL scripts, and \VersionFormat\ to control filename versioning. This enables the Maven plugin to generate database migration files based on Exposed table definitions.

exposed-plugin-core · high confidence

Users can now generate SQL migration scripts from Exposed table definitions using the new \exposed:generate-migrations\ Maven goal. The plugin scans the project's classpath for Exposed table definitions and produces versioned SQL files, with configurable options for file naming, separators, and database connection (including Testcontainers support). The change includes the \GenerateMigrationsMojo\ implementation, its API descriptor, and integration tests verifying the generation behavior.

exposed-maven-plugin · high confidence

A new Gradle-based example project has been added to the documentation site, demonstrating how to use Exposed's built-in and custom SQL functions. The project includes examples for string, aggregate, and window functions, as well as custom date and trim functions, providing a runnable reference for users.

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

The documentation site now includes a new \exposed-transactions\ snippet project that demonstrates how to perform units of work with database transactions using the Exposed v1 API. It provides Kotlin examples for executing raw SQL strings with \exec()\ and \execAndMap()\ across H2 and MySQL, as well as handling nested transactions and savepoints. These code snippets are referenced in the 'Working with SQL Strings' and 'Transactions' documentation topics to show practical usage of the updated Exposed v1 transaction management.

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

A new sample application has been added at samples/springboot3-exposed-r2dbc, demonstrating a Spring Boot 3.5.0 application using Kotlin 2.1.20, WebFlux, and the Exposed R2DBC library for reactive database access. The sample includes a complete implementation with controllers, services, and DAOs, along with Gradle wrapper files, configuration, and integration tests.

samples/springboot3-exposed-r2dbc · high confidence

A new Spring Boot 4 starter module has been added, providing automatic configuration for Exposed via \ExposedAutoConfiguration\, which registers a \DatabaseInitializer\ for schema generation and a \SpringTransactionManager\ for transaction management. The module includes an \ExposedAotContribution\ to register reflection and resource hints required for GraalVM native images, and exposes configuration properties (\spring.exposed.generate-ddl\, \spring.exposed.show-sql\, \spring.exposed.excluded-packages\) to control schema generation and SQL logging.

exposed-spring-boot4-starter · high confidence

A new Spring Boot 4-based sample project has been added to the documentation website, demonstrating how to use Exposed for Create, Read, Update, and Delete (CRUD) operations. The example includes a REST controller, service layer, and entity mapping, allowing users to run the application and test endpoints via a provided HTTP request file.

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

A new Spring Boot 4 sample project has been added to demonstrate CRUD operations using Exposed. The sample includes a REST controller, service layer, and entity definitions that leverage the Exposed v1 API (e.g., \org.jetbrains.exposed.v1.\*\), providing a complete working example of integrating Exposed with Spring Boot.

samples/exposed-spring · high confidence

The Exposed library introduces new types for handling monetary values in the database layer. A new CompositeMoneyColumn class and its associated factory functions (compositeMoney, nullable) allow mapping composite columns for amount and currency. Additionally, a CurrencyColumnType is added to map javax.money.CurrencyUnit to database strings, enabling type-safe storage and retrieval of currency information.

exposed-money/api · high confidence

The Exposed v1 API now supports storing monetary values as a composite of a numeric amount and a currency code. Users can create composite columns using the new \compositeMoney\ extension functions on \Table\, which map to two underlying columns (one for the \BigDecimal\ amount and one for the \CurrencyUnit\). This allows querying and inserting money values as a single logical unit while persisting them as separate database columns. A new \CurrencyColumnType\ handles the storage and retrieval of currency codes, and tests verify default value handling and nullability for these composite columns.

exposed-money/src · high confidence

The documentation website now includes detailed topics for all supported data types, including arrays, binary, custom, and column transformations. It also provides a new 'About' page explaining the framework's architecture and supported databases, alongside a complete 'Adding dependencies' guide covering Gradle and Maven setup with version catalogs.

documentation-website/Writerside/topics · high confidence

Added new example code and README files for the \exposed-databases-r2dbc\ module, demonstrating how to configure and connect to various R2DBC databases (H2, MySQL, Oracle, PostgreSQL, MariaDB, SQL Server) using the \R2dbcDatabase.connect\ API. The snippets include a \UsersTable\ definition and usage of \suspendTransaction\ for asynchronous database operations.

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

The exposed-crypt module now provides new encrypted column types (EncryptedVarCharColumnType, EncryptedBinaryColumnType) and a suite of encryption algorithms (AES-256 in GCM and CBC modes, Blowfish, and Triple DES) to securely store sensitive data in the database. This includes the core Encryptor class, table extension functions for creating encrypted columns, and corresponding DAO and unit tests to verify encryption, decryption, and logging behavior.

exposed-crypt/src · high confidence

Added new example projects for Groovy Gradle, Kotlin Gradle, and Maven build configurations. Each directory contains a minimal project structure with a README and a basic Kotlin entry point, serving as reference implementations for the 'Adding dependencies' documentation topic.

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

Added new Kotlin example files for arrays, basic types, binary, enumeration, JSON/JSONB, Java time, Joda time, and Kotlin time to the documentation snippets, providing users with ready-to-use code examples for each data type.

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

A new sample Gradle/Kotlin project has been added to the documentation website, providing a concrete example for the 'Get started with Exposed' tutorial. The project includes a \Tasks\ table definition and an \App.kt\ entry point that demonstrates core Exposed operations such as connecting to an H2 in-memory database, creating tables, inserting and updating records, and performing queries. This allows users to follow the tutorial steps and run the code locally.

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

Added a collection of sample projects and build configuration files to support documentation and development workflows. This includes Gradle and Maven build scripts for various Exposed modules (such as DAO, DSL, migrations, and Spring integration) located in the documentation-website snippets directory, as well as the root build.gradle.kts and buildSrc configuration files that define plugin dependencies, test database configurations, and publishing settings.

(dependencies) · high confidence

A new \App.kt\ file has been added to the \exposed-dsl\ snippets project, providing executable Kotlin code examples for the documentation website. This includes setup for H2, SQLite, and MySQL database connections, along with runner functions for create, read, update, delete, querying, aliasing, custom select, and build statement examples.

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

Added a new documentation snippet and sample project for Exposed Migrations, demonstrating how to generate migration scripts and apply them using Flyway. The new files include a README with build and run instructions, a Kotlin application showing the migration workflow, and a sample SQL migration script, all referenced by the main Migrations documentation topic.

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

The exposed-java-time module now provides column types and SQL functions for Java 8 date/time types (LocalDate, LocalDateTime, LocalTime, Instant, OffsetDateTime, Duration). This enables storing and querying these specific Java types in the database, with corresponding helper functions (e.g., date(), time(), year(), month()) for extracting date/time components.

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

The \exposed-jodatime\ module now provides new column types (\JodaLocalDateColumnType\, \JodaLocalDateTimeColumnType\, \JodaLocalTimeColumnType\, \DateTimeWithTimeZoneColumnType\) and corresponding SQL functions (such as \date()\, \time()\, \year()\, \month()\, \day()\, \hour()\, \minute()\, \second()\) that map to and from the Joda-Time library. This enables users to store and query date and time values using Joda-Time types in their database schemas.

exposed-jodatime/src/main · high confidence

The exposed-migration-core module now exposes an internal API for database schema migrations. This includes a MigrationUtilityApi class that provides methods to write migration scripts to files, generate DROP statements for unmapped columns, and filter missing or unmapped database sequences. These utilities support the underlying migration logic but are marked as internal and not intended for direct public use.

exposed-migration-core · medium confidence

The exposed-migration-r2dbc module now provides a complete, asynchronous implementation of the database migration utilities, enabling non-blocking schema updates via R2DBC. The new \MigrationUtils\ object exposes functions such as \generateMigrationScript\, \statementsRequiredForDatabaseMigration\, \dropUnmappedColumnsStatements\, \dropUnmappedIndices\, and \dropUnmappedSequences\ to handle schema synchronization. This allows users to generate and apply migration scripts without blocking the event loop, with comprehensive test coverage for table, index, and constraint migrations.

exposed-migration-r2dbc · high confidence

The repository is initialized with foundational project files, including the Apache 2.0 license, a comprehensive CHANGELOG, and a detailed README outlining the Exposed ORM framework's features, supported databases, and usage examples. The setup also includes a CLAUDE.md file providing AI assistant guidance, a context7.json configuration, and Gradle wrapper scripts (gradlew, gradlew.bat) to standardize the build environment.

(repo-wide) · high confidence

The documentation website has been initialized with the core Writerside configuration files, including the table of contents (hi.tree), variable definitions (v.list) specifying Exposed version 1.4.0 and various database driver versions, and category definitions (c.list). The setup also includes a 'snippets' directory containing runnable Gradle and Maven project examples for the Gradle plugin, Maven plugin, and the DAO tutorial, providing users with ready-to-run code samples for the documentation.

documentation-website/Writerside · high confidence

The \exposed-r2dbc\ module introduces a complete implementation for asynchronous, non-blocking database interactions using the R2DBC protocol. This includes the \R2dbcDatabase\ and \R2dbcTransaction\ classes for managing connections and transactional contexts, along with a full suite of query execution methods (such as \select\, \insert\, \delete\, and \update\) that operate on \SuspendExecutable\ and \SizedIterable\ interfaces. The diff also adds core infrastructure files like \ConnectionFactoryOptionsUtils\ for parsing connection details, \ExplainSuspendExecutable\ for query plan analysis, and \MetadataQueries\ for schema/table existence checks, effectively enabling the library to interact with databases asynchronously.

exposed-r2dbc/src · high confidence

The Exposed Gradle plugin now provides a \generateMigrations\ task that automatically generates SQL migration scripts from Exposed table definitions. Users can configure the output directory, file naming conventions, and database connection details (or use TestContainers) within the \exposed { migrations { ... } }\ build block. The plugin also registers a root \exposed\ extension to manage these settings and includes a warning if the Kotlin Gradle plugin is not applied.

exposed-gradle-plugin · high confidence

The \exposed-jdbc\ module now publishes a formal API contract (\exposed-jdbc.api\) that exposes the public surface of the JDBC integration, including the \Database\ class, \JdbcTransaction\ management, and batch operation helpers. This change establishes the stable interface for users interacting with JDBC-backed databases, ensuring consistent access to connection, dialect metadata, and transaction control.

exposed-jdbc/api · high confidence

Adds a new R2DBC module to the Exposed library, exposing a comprehensive set of suspend functions for database operations including select, insert, update, delete, and batch operations. The API defines new classes such as Query, R2dbcTransaction, and various statement builders, enabling asynchronous, non-blocking database interactions via R2DBC instead of traditional JDBC.

exposed-r2dbc/api · high confidence

The spring-transaction module now exposes the public API for the Spring integration, specifically the ExposedSpringTransactionAttributeSource and SpringTransactionManager classes. This provides the necessary interfaces for managing Spring transactions with Exposed, allowing developers to configure transaction management through Spring's standard mechanisms.

spring-transaction/api · high confidence

The \exposed-core\ module now includes a comprehensive set of new classes in the \org.jetbrains.exposed.v1.core.statements\ package, introducing the foundational SQL statement types for the v1 API. This includes \InsertStatement\, \BatchInsertStatement\, \BatchReplaceStatement\, \BatchUpdateStatement\, \BatchUpsertStatement\, \DeleteStatement\, \InsertSelectStatement\, \MergeStatement\ (with \MergeTableStatement\ and \MergeSelectStatement\), \ReplaceStatement\, \ReturningStatement\, and \SQLServerBatchInsertStatement\. These classes provide the core infrastructure for representing and executing SQL INSERT, UPDATE, DELETE, MERGE, and BATCH operations, along with support for RETURNING clauses and database-specific optimizations like SQL Server's row limits.

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

The exposed-crypt module now exposes a public API for working with encrypted data. This includes the \Algorithms\ class providing factory methods for AES-256 (PBE, GCM), Blowfish, and Triple DES encryption. The \Encryptor\ class and its associated transformers (\ByteArrayEncryptionTransformer\, \StringEncryptionTransformer\) are now part of the public interface, allowing developers to create encrypted binary and varchar columns (\EncryptedBinaryColumnType\, \EncryptedVarCharColumnType\) using these algorithms.

exposed-crypt/api · high confidence

Added a new v1 DAO implementation in the \exposed-dao\ module, introducing a complete entity management system. This includes the \Entity\ base class and its \IntEntity\/\LongEntity\ specializations, alongside \EntityClass\ and \EntityCache\ for managing entity state and caching. The update also adds \EntityHook\ for tracking lifecycle events (created, updated, removed) and an \EntityLifecycleInterceptor\ to automatically flush and clear caches during transactions and rollbacks. Additionally, support for composite entity IDs and many-to-many relationships via \InnerTableLink\ is provided.

exposed-dao/src · high confidence

The exposed-jdbc module now includes new core classes such as Database, JdbcTransaction, Query, and ExposedConnectionImpl, which handle JDBC-specific operations like connection management, transaction control, and SQL execution. This change establishes the foundational JDBC implementation layer, enabling the library to interact with relational databases via JDBC while maintaining a consistent API for database operations.

exposed-jdbc/src · high confidence

The \exposed-core\ module adds several new classes to the \org.jetbrains.exposed.v1.core.statements.api\ package, including \ExposedBlob\, \ExposedDatabaseMetadata\, \ExposedMetadataUtils\, \ExposedSavepoint\, \IdentifierManagerApi\, \PreparedStatementApi\, and \ResultApi\. These classes provide the foundational interfaces and implementations for managing database metadata, handling binary data, managing SQL identifiers, and processing query results, effectively establishing the core API surface for these capabilities.

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

The \exposed-migration-jdbc\ module now exposes the \MigrationUtils\ object, which provides methods to generate SQL statements required for database migration, including creating/dropping tables, columns, indices, sequences, and check constraints. It also offers a \generateMigrationScript\ function to write these statements to a file. This enables programmatic database schema management and migration script generation for JDBC-based databases.

exposed-migration-jdbc · high confidence

The exposed-dao module now exposes a comprehensive public API for the DAO layer, including the \Entity\, \EntityClass\, and \EntityCache\ classes and their associated methods. This update introduces support for managing entity states, handling composite primary keys, and utilizing the entity cache for improved performance. Users can now interact with these core DAO components through the public API, enabling more robust entity management and caching strategies.

exposed-dao/api · high confidence

The buildSrc module introduces new Gradle configuration scripts: a Detekt integration that scans documentation and sample code, a Maven Central publishing setup that configures POM metadata and licenses, and a TestDb DSL that orchestrates Docker Compose containers and splits test tasks by database dialect. These changes streamline static analysis, artifact publishing, and multi-dialect test execution for the Exposed framework.

buildSrc · high confidence

The \exposed-json\ module now provides \JsonColumnType\ and \JsonBColumnType\ classes, along with \json()\ and \jsonb()\ extension functions, enabling storage of JSON data in both text and binary formats. Additionally, new query operators \contains()\, \exists()\, and \extract()\ are introduced to support JSON-specific SQL functions and path-based data extraction.

exposed-json/src/main · high confidence

The \exposed-java-time\ module now exposes a comprehensive public API for working with Java 8+ temporal types. This includes column type classes for \Instant\, \LocalDate\, \LocalDateTime\, \LocalTime\, and \OffsetDateTime\, enabling seamless storage and retrieval of these types. Additionally, the API provides functions to extract date/time components (year, month, day, hour, minute, second) and utility functions for creating literals and parameters for all supported temporal types, including a new \timestampWithTimeZone\ column and function.

exposed-java-time/api · high confidence

A new Spring 7 transaction module is introduced, providing \SpringTransactionManager\ and \ExposedSpringTransactionAttributeSource\ to integrate Exposed with Spring's transaction management. The \SpringTransactionManager\ coordinates Exposed and Spring JDBC connections, supporting propagation levels like \NESTED\ and \REquireS-NEW\. The \ExposedSpringTransactionAttributeSource\ adds \ExposedSQLException\ to rollback rules and, critically, returns a defensive copy of the transaction attribute to prevent data races on the delegate's cached instance. This fix resolves a concurrency issue (EXPOSED-1028) where concurrent calls could mutate shared state, leading to \NullPointerException\. The change includes a public API definition and comprehensive tests for transaction propagation, mixed Exposed/JDBC usage, and multi-container scenarios.

spring7-transaction · high confidence

A new Spring-compatible transaction manager, ExposedSpringTransactionManager, has been added to the spring-transaction module. This class extends Spring's AbstractPlatformTransactionManager to integrate Exposed's transactional behavior with Spring's standard transaction management infrastructure. The implementation includes a custom ExposedSpringTransactionAttributeSource that ensures ExposedSQLException is included in rollback rules and returns defensive copies of transaction attributes to prevent concurrent modification issues. The manager handles binding/unbinding Spring JDBC connection holders and manages the lifecycle of Exposed transactions within Spring's transactional context.

spring-transaction/src/main · high confidence

A new example project has been added to the documentation website under \documentation-website/Writerside/snippets/exposed-dao-relationships\. It provides a Gradle-based application that demonstrates how to create and manage relationships between entities using the Exposed DAO API, including one-to-many, many-to-many, parent-child, and eager loading patterns.

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

The Exposed core library introduces new identity table classes to support modern identifier types. A new \UuidTable\ is added, allowing primary keys to be auto-generated \kotlin.uuid.Uuid\ values (supporting both V4 and V7 generation strategies). Additionally, a \UUIDTable\ is provided for \java.util.UUID\ types. The framework also introduces \CompositeIdTable\ to support composite primary keys, backed by a new \CompositeID\ class and an \EntityID\ wrapper for identity values. These changes enable more flexible and type-safe database table definitions for various identifier strategies.

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

The exposed-json module now exposes a public API for working with JSON columns. This includes new column types (JsonColumnType, JsonBColumnType) and helper functions (json, jsonb) for defining JSON columns in tables. Additionally, new condition builders (contains, exists) are exposed to construct JSON-specific query filters, enabling users to filter records based on JSON content and structure.

exposed-json/api · high confidence

A new public API file introduces Spring Boot auto-configuration for Exposed, including a DatabaseInitializer component for managing database initialization order, an ExposedAotContribution class to support GraalVM native image ahead-of-time processing, and an ExposedAutoConfiguration class that wires up the database configuration, transaction manager, and attribute source for Spring integration.

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

The Exposed Spring Boot starter now includes new components to support automatic database schema generation and GraalVM native image compatibility. A new \DatabaseInitializer\ class, registered via \ExposedAutoConfiguration\, automatically creates database tables at startup based on discovered Exposed \Table\ classes, controlled by the \spring.exposed.generate-ddl\ property. Additionally, \ExposedAotContribution\ registers reflection and resource hints for Exposed core classes, enabling native image builds by ensuring all necessary classes are available at runtime. This change introduces new configuration properties (\spring.exposed.generate-ddl\, \spring.exposed.excluded-packages\, \spring.exposed.show-sql\) to control this behavior.

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

The public API for the Joda-Time module is now explicitly defined, exposing classes and functions for handling date, time, and timestamp-with-timezone columns, as well as helper functions for literals, parameters, and date/time extraction (year, month, day, hour, minute, second). This change establishes the stable interface for these Joda-Time types within the Exposed library.

exposed-jodatime/api · high confidence

The public API for the exposed-core module has been updated, introducing new types and methods for query construction and column handling. This includes the addition of AbstractQuery with support for comments, distinct on, and for update options, alongside new classes for array and vector column types. The diff also shows the introduction of an AbstractQuery$CommentPosition enum and updates to the Alias and AutoIncColumnType classes, reflecting changes to how queries and column definitions are structured in the core library.

exposed-core/api · high confidence

The \exposed-kotlin-datetime\ module now explicitly exposes its public API surface, including column types for \Instant\, \LocalDate\, \LocalDateTime\, \LocalTime\, and \Duration\, as well as extension functions and column builders for these types. This change makes the Kotlin datetime integration a first-class, stable part of the library's public contract, allowing users to rely on these specific classes and functions in their own code.

exposed-kotlin-datetime/api · high confidence

The v1 core module now includes a new vendor abstraction layer, introducing base classes and interfaces for database dialects, data type providers, and function providers. This refactors how database-specific SQL generation and metadata are handled, providing a structured way to define dialects for H2, MariaDB, MySQL, Oracle, and others. This change reorganizes the internal implementation of the library, ensuring that each database vendor's specific SQL syntax and type mappings are encapsulated within their respective dialect classes.

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

The core query and column handling logic has been reorganized into the new v1 package, introducing new files such as AbstractQuery, Alias, Column, ColumnDiff, ColumnType, CompositeColumn, Constraints, and DatabaseApi. This refactoring separates internal classes and provides a cleaner API for query construction, column definitions, and database configuration, while maintaining compatibility with existing Exposed functionality.

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

The documentation website now includes Kotlin code snippets for various Exposed DAO table definitions, including base tables, city and user tables, director and guild tables, and Star Wars film and rating tables. These samples demonstrate how to define tables using IntIdTable, CompositeIdTable, and UuidTable, along with column types like varchar, integer, and reference columns. The snippets serve as reference material for users learning how to structure their own database tables with Exposed.

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

A new CachableMapWithSuspendableDefault class is introduced alongside a CacheWithSuspendableDefault interface, enabling caching maps with suspendable default value providers. This allows the caching mechanism to support asynchronous default value computation, addressing the previous limitation where runBlocking was used inside the synchronous CachableMapWithDefault.

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

An empty file named 'api/exposed.api' was added to the project. This appears to be a placeholder or configuration file for API tracking, though it currently contains no content.

api · low confidence

Added new Kotlin entity classes to the documentation snippets, including base classes for auto-filling timestamps, handling composite IDs, custom entity types, and various standard entity examples such as CityEntity, DirectorEntity, and UserEntity.

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

A new log4j2 configuration file was added to standardize test logging output, and a platform-map properties file was introduced to map various Windows versions, including Windows Server 2019, to a unified 'Win-x86' platform identifier.

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

The documentation website's Writerside configuration has been established with new XML files that define the build process and site variables. The build script disables the universal zip artifact for web builds. Site settings are configured with a custom header logo, a primary color theme, and specific Algolia search parameters (ID, index, and API key) to enable search functionality. Additionally, Google Analytics tracking is enabled via a head script, and a feedback widget is activated for user input.

documentation-website/Writerside/cfg · high confidence

Added TransactionContextElement and TransactionContextHolder to manage thread-local transaction state for coroutines. This ensures that when a coroutine is suspended and resumed on a different thread, the transaction is properly restored to the thread-local stack, preventing ClassCast exceptions and duplicate entries in the transaction stack.

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

The exposed-kotlin-datetime module introduces new column types and SQL functions that use the modern kotlin.time.Instant and kotlin.time.Duration types, while deprecating the legacy kotlinx.datetime.Instant-based equivalents. Users should update their schema definitions to use the new timestamp, date, time, and duration column types and functions, as the old ones are marked deprecated and will be removed in a future release.

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

The datetime column types (Instant, LocalDate, LocalDateTime, LocalTime, OffsetDateTime, and Duration) have been refactored to improve cross-database compatibility and fix specific bugs. InstantColumnType now correctly handles timestamps before the Unix epoch, and DurationColumnType stores durations as nanosecond values for maximum precision. Each type now includes dialect-specific formatting and parsing logic for MySQL, Oracle, PostgreSQL, SQLite, and H2, ensuring accurate storage and retrieval of date and time values across different database systems.

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

The transaction management layer has been refactored to separate concerns into distinct components: a new \DatabasesManager\ interface and implementation for tracking default and primary databases, a \TransactionManagersContainer\ to manage the mapping between databases and their transaction managers, and a \ThreadLocalTransactionsStack\ to handle per-thread transaction context. Additionally, a \TransactionScope\ property delegate was added to allow storing data within the current transaction's scope. These changes restructure how transactions are tracked and accessed, providing a more modular internal API for transaction management.

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

The starter now registers its auto-configuration class via the Spring Boot 3 / Spring Framework 6 standard \AutoConfiguration.imports\ file, replacing the legacy \spring.factories\ approach. Additionally, \spring-configuration-metadata.json\ is added to expose properties (\spring.exposed.generate-ddl\, \spring.exposed.show-sql\, \spring.exposed.excluded-packages\) for IDE support and documentation, and an AOT factory is registered for native image support.

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

Add R2DBC test suite with base classes and shared utilities; Add comprehensive test coverage for shared column types; Added H2 and PostgreSQL test suites for connection pools, concurrency, and multi-database scenarios; Added Java Time test suite for date, time, and timestamp columns; Added Joda-Time test suite for date and time handling; Added SQL Server temporal table defaults test; Added SQL Server temporal table tests; Added Spring Boot integration tests for the Exposed starter; Added comprehensive test coverage for JSON and JSONB column operations; Added comprehensive test coverage for core Exposed functionality; Added comprehensive test suite for Spring transaction management; Added datetime literal and default value tests for Kotlin time types; Added shared DML test suite for the v1 API; Added shared test utilities and schema definitions for the v1 test suite; Added tests for DDL generation across multiple database schemas; Added tests for Oracle FOR UPDATE SKIP LOCKED support; Added tests for ResultRow caching and Version parsing; Added tests for entity caching, hooks, and composite IDs; Added tests for mixed JDBC and R2DBC database connections; New test infrastructure for database dialects and connection management.

The Gradle wrapper has been updated to version 8.14.4. This change ensures that the project uses a specific, stable version of the Gradle build tool, which may include bug fixes, performance improvements, and new features available in that release.

gradle · high confidence

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

• CAI 69 → 40 (-29.1)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.15) — scores are not directly comparable.

• Code Health 82 → 46 (-36.6)
• Architecture 99 → 96 (-3.8)
• Maturity 66 → 50 (-15.9)
• Readiness 62 → 17 (-45.4)
• Security 74 → 89 (+15.1)
• Domain Modelling 100 → 100 (+0.0)

• ArrayTypeMapper.mapPgArray (cyclomatic 24) (exposed-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/mappers/ArrayTypeMapper.kt)
• Change coupling: BatchUpsertStatement.kt ↔ FunctionProvider.kt (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements/BatchUpsertStatement.kt)
• Column.descriptionDdl (cognitive 28) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/Column.kt)
• Column.descriptionDdl (cyclomatic 25) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/Column.kt)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (exposed-dao/src/main/kotlin/org/jetbrains/exposed/v1/dao/Entity.kt)
• Duplicated block (10 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/Query.kt)
• Duplicated block (10 lines × 3) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/AbstractQuery.kt)
• Duplicated block (11 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/Exceptions.kt)
• Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/SetOperations.kt)
• Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/statements/InsertBlockingExecutable.kt)
• Duplicated block (11 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/statements/jdbc/JdbcDatabaseMetadataImpl.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-migration-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/migration/jdbc/MigrationUtils.kt)
• Duplicated block (12 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements/Statement.kt)
• Duplicated block (12 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/statements/api/ExposedDatabaseMetadata.kt)
• Duplicated block (12 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/Query.kt)
• Duplicated block (12 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/SchemaUtils.kt)
• Duplicated block (12 lines × 2) (exposed-migration-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/migration/jdbc/MigrationUtils.kt)
• …and 84 more

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (11 lines × 2) (exposed-dao/src/main/kotlin/org/jetbrains/exposed/v1/dao/Entity.kt)
• Duplicated block (15 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/OpBuilder.kt)
• Duplicated block (15 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/SQLExpressionBuilder.kt)
• Duplicated block (17 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/transactions/Transactions.kt)
• Duplicated block (18 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/ColumnType.kt)
• Duplicated block (19 lines × 2) (exposed-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/vendors/metadata/PostgreSQLMetadata.kt)
• Duplicated block (20 lines × 2) (exposed-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/vendors/metadata/H2Metadata.kt)
• Duplicated block (20 lines × 2) (exposed-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/vendors/metadata/OracleMetadata.kt)
• Duplicated block (20 lines × 2) (exposed-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/vendors/metadata/PostgreSQLMetadata.kt)
• Duplicated block (20 lines × 2) (exposed-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/vendors/metadata/SQLServerMetadata.kt)
• Duplicated block (26 lines × 2) (exposed-r2dbc/src/main/kotlin/org/jetbrains/exposed/v1/r2dbc/vendors/metadata/MySQLMetadata.kt)
• Duplicated block (49 lines × 2) (exposed-jdbc/src/main/kotlin/org/jetbrains/exposed/v1/jdbc/transactions/Transactions.kt)
• Duplicated block (7 lines × 2) (exposed-core/src/main/kotlin/org/jetbrains/exposed/v1/core/OpBuilder.kt)
• Duplicated block (9 lines × 2) (exposed-dao/src/main/kotlin/org/jetbrains/exposed/v1/dao/EntityLifecycleInterceptor.kt)
• High IaC: DS-0002 (samples/exposed-ktor-r2dbc/Dockerfile)
• Low IaC: DS-0026 (samples/exposed-ktor-r2dbc/Dockerfile)
• No tests found
• The BOM section lists only the core module (exposed-core) and does not show how to add R2DBC or Kotlin datetime modules, which are critical for a full dependency reference. (exposed-bom/README.md)

• 3 commits — 2 feature/other, 1 fixes

• docs/api — 1 commit
• documentation-website/Writerside — 1 commit
• samples/exposed-gradle-plugin-sample — 1 commit

• fix: fix: Fix version catalog docs and versions (#2874)
• change: chore: Bump Exposed version from 1.3.1 to 1.4.0 (#2875)
• change: docs: EXPOSED-1037 Update the date and time types topic (#2863)

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

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.