implement ConnectionProvider

build.gradle.kts

@@ -17,38 +17,38 @@
 import net.ltgt.gradle.errorprone.errorprone
 
 plugins {
-    // Apply the java-library plugin for API and implementation separation.
     `java-library`
     alias(libs.plugins.spotless)
     alias(libs.plugins.errorprone)
 }
 
 repositories {
-    // Use Maven Central for resolving dependencies.
     mavenCentral()
 }
 
 dependencies {
-    // Use JUnit Jupiter for testing.
     testImplementation(libs.junit.jupiter)
+    testImplementation(libs.logback.classic)
 
-    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    testRuntimeOnly(libs.junit.platform.launcher)
 
     errorprone(libs.nullaway)
     api(libs.jspecify)
 
     errorprone(libs.google.errorprone.core)
+
+    implementation(libs.hibernate.core)
+    implementation(libs.mongo.java.driver.sync)
+    implementation(libs.sl4j.api)
 }
 
-// Apply a specific Java toolchain to ease working on different environments.
 java {
     toolchain {
         languageVersion = JavaLanguageVersion.of(17)
     }
 }
 
 tasks.named<Test>("test") {
-    // Use JUnit Platform for unit tests.
     useJUnitPlatform()
 }
 
@@ -57,8 +57,7 @@ tasks.named<Test>("test") {
 
 spotless {
     java {
-        // note: you can use an empty string for all the imports you didn't specify explicitly, '|' to join group without blank line, and '\\#` prefix for static imports
-        importOrder("java|javax", "", "\\#")
+        importOrder()
 
         removeUnusedImports()
 

gradle/libs.versions.toml

@@ -2,19 +2,28 @@
 # https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format
 
 [versions]
-junit-jupiter = "5.10.3"
+junit-jupiter = "5.11.3"
 spotless = "6.25.0"
 palantir = "2.50.0"
-errorprone = "4.0.1"
-google-errorprone-core = "2.9.0"
-nullaway = "0.10.26"
-jspecify = "0.3.0"
+errorprone = "4.1.0"
+google-errorprone-core = "2.35.1"
+nullaway = "0.12.1"
+jspecify = "1.0.0"
+hibernate-core = "6.6.1.Final"
+mongo-java-driver-sync = "5.2.0"
+slf4j-api = "2.0.16"
+logback-classic = "1.5.12"
 
 [libraries]
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
+junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" }
 nullaway = { module = "com.uber.nullaway:nullaway", version.ref = "nullaway" }
 jspecify = { module = "org.jspecify:jspecify", version.ref = "jspecify" }
 google-errorprone-core = { module = "com.google.errorprone:error_prone_core", version.ref = "google-errorprone-core" }
+hibernate-core = { module = "org.hibernate.orm:hibernate-core", version.ref = "hibernate-core" }
+mongo-java-driver-sync = { module = "org.mongodb:mongodb-driver-sync", version.ref = "mongo-java-driver-sync" }
+sl4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j-api" }
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback-classic" }
 
 [plugins]
 spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }

src/main/java/com/mongodb/hibernate/dialect/MongoDialect.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate.dialect;
+
+import org.hibernate.dialect.DatabaseVersion;
+import org.hibernate.dialect.Dialect;
+import org.hibernate.engine.jdbc.dialect.spi.DialectResolutionInfo;
+
+/**
+ * A MongoDB {@link Dialect} for {@linkplain #getMinimumSupportedVersion() version 6.0 and above}.
+ *
+ * <p>Usually Hibernate dialect represents some SQL RDBMS and speaks SQL with vendor-specific difference. MongoDB is a
+ * document DB and speaks <i>MQL</i> (MongoDB Query Language), but it is still possible to integrate with Hibernate by
+ * creating a JDBC adaptor on top of <a href="https://www.mongodb.com/docs/drivers/java/sync/current/">MongoDB Java
+ * Driver</a>.
+ */
+public final class MongoDialect extends Dialect {
+    private static final DatabaseVersion MINIMUM_VERSION = DatabaseVersion.make(6);
+
+    /** Default constructor used when no version info is available. */
+    public MongoDialect() {
+        super((DatabaseVersion) null);
+    }
+
+    /**
+     * Constructor used when MongoDB meta data is available.
+     *
+     * @param info MongoDB meta data
+     */
+    public MongoDialect(DialectResolutionInfo info) {
+        super(info);
+    }
+
+    @Override
+    protected DatabaseVersion getMinimumSupportedVersion() {
+        return MINIMUM_VERSION;
+    }
+}

src/main/java/com/mongodb/hibernate/dialect/package-info.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@NullMarked
+package com.mongodb.hibernate.dialect;
+
+import org.jspecify.annotations.NullMarked;

src/main/java/com/mongodb/hibernate/internal/NotYetImplementedException.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate.internal;
+
+import java.io.Serial;
+
+/**
+ * A temporary marker exception to denote that the feature in question is in the scope of MongoDB dialect but has not
+ * been implemented yet.
+ *
+ * <p>Ultimately all of its references should be eliminated sooner or later, and then this class is supposed to be
+ * deleted prior to product release.
+ *
+ * <p>It is recommended to provide some message to explain when it will be implemented (e.g. JIRA ticket id is a good
+ * idea), but that is optional.
+ *
+ * <p>This class is not part of the public API and may be removed or changed at any time.
+ */
+public final class NotYetImplementedException extends RuntimeException {
+
+    @Serial
+    private static final long serialVersionUID = -1642331376287373147L;
+
+    /**
+     * Default constructor.
+     *
+     * <p>It is recommended to use the other constructor with some explanation.
+     */
+    public NotYetImplementedException() {}
+
+    /**
+     * Constructor with message parameter.
+     *
+     * @param message explanation on when the feature is to be implemented
+     */
+    public NotYetImplementedException(String message) {
+        super(message);
+    }
+}

src/main/java/com/mongodb/hibernate/internal/package-info.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@NullMarked
+package com.mongodb.hibernate.internal;
+
+import org.jspecify.annotations.NullMarked;

src/main/java/com/mongodb/hibernate/jdbc/MongoConnectionProvider.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2024-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate.jdbc;
+
+import static org.hibernate.cfg.JdbcSettings.*;
+
+import com.mongodb.ConnectionString;
+import com.mongodb.MongoClientSettings;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.hibernate.internal.NotYetImplementedException;
+import java.io.Serial;
+import java.sql.Connection;
+import java.util.Map;
+import org.hibernate.HibernateException;
+import org.hibernate.cfg.JdbcSettings;
+import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
+import org.hibernate.service.UnknownUnwrapTypeException;
+import org.hibernate.service.spi.Configurable;
+import org.hibernate.service.spi.Stoppable;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * {@linkplain com.mongodb.hibernate.dialect.MongoDialect MongoDB dialect}'s customized JDBC {@link ConnectionProvider}
+ * SPI implementation.
+ *
+ * <p>{@link MongoConnectionProvider} uses the following Hibernate properties:
+ *
+ * <ul>
+ *   <li>{@linkplain JdbcSettings#JAKARTA_JDBC_URL jakarta.persistence.jdbc.url}
+ *   <li>{@linkplain JdbcSettings#JAKARTA_JDBC_USER jakarta.persistence.jdbc.user}
+ *   <li>{@linkplain JdbcSettings#JAKARTA_JDBC_PASSWORD jakarta.persistence.jdbc.password}
+ * </ul>
+ *
+ * <p>as follows:
+ *
+ * <p>
+ *
+ * <table>
+ *     <tr><th>Property</th><th>Description</th></tr>
+ *     <tr>
+ *         <td>{@linkplain JdbcSettings#JAKARTA_JDBC_URL jakarta.persistence.jdbc.url}</td>
+ *         <td>MongoDB
+ *         <a href="https://www.mongodb.com/docs/manual/reference/connection-string/">connection string</a></td>
+ *     </tr>
+ *     <tr>
+ *         <td>{@linkplain JdbcSettings#JAKARTA_JDBC_USER jakarta.persistence.jdbc.user}</td>
+ *         <td>{@code userName} for {@link com.mongodb.MongoCredential#createCredential(String, String, char[])}</td>
+ *     </tr>
+ *     <tr>
+ *         <td>{@linkplain JdbcSettings#JAKARTA_JDBC_PASSWORD jakarta.persistence.jdbc.password}</td>
+ *         <td>{@code password} for {@link com.mongodb.MongoCredential#createCredential(String, String, char[])}</td>
+ *     </tr>
+ * </table>
+ *
+ * <p>{@value JdbcSettings#JAKARTA_JDBC_URL} property is mandatory and it maps to MongoDB's <a
+ * href="https://www.mongodb.com/docs/manual/reference/connection-string/">connection string</a>, in which database name
+ * must be provided to align with JDBC URL's convention. The other two JDBC properties are optional.
+ *
+ * @see ConnectionProvider
+ * @see JdbcSettings#JAKARTA_JDBC_URL
+ * @see JdbcSettings#JAKARTA_JDBC_USER
+ * @see JdbcSettings#JAKARTA_JDBC_PASSWORD
+ * @see <a href="https://www.mongodb.com/docs/manual/reference/connection-string/">connection string</a>
+ */
+public final class MongoConnectionProvider implements ConnectionProvider, Configurable, Stoppable {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    private @Nullable MongoClient mongoClient;
+
+    @Override
+    public Connection getConnection() {
+        throw new NotYetImplementedException(
+                "To be implemented in scope of https://jira.mongodb.org/browse/HIBERNATE-29");
+    }
+
+    @Override
+    public void closeConnection(Connection connection) {
+        throw new NotYetImplementedException(
+                "To be implemented in scope of https://jira.mongodb.org/browse/HIBERNATE-29");
+    }
+
+    @Override
+    public boolean supportsAggressiveRelease() {
+        return false;
+    }
+
+    @Override
+    public boolean isUnwrappableAs(Class<?> unwrapType) {
+        return false;
+    }
+
+    @Override
+    public <T> T unwrap(Class<T> unwrapType) {
+        throw new UnknownUnwrapTypeException(unwrapType);
+    }
+
+    @Override
+    public void configure(Map<String, Object> configValues) {
+        var jdbcUrl = configValues.get(JAKARTA_JDBC_URL);
+        if (jdbcUrl == null) {
+            throw new HibernateException("Configuration is required: " + JAKARTA_JDBC_URL);
+        }
+        if (!(jdbcUrl instanceof String)) {
+            throw new HibernateException(
+                    String.format("Configuration [%s] value [%s] not of string type", JAKARTA_JDBC_URL, jdbcUrl));
+        }
+        ConnectionString connectionString;
+        try {
+            connectionString = new ConnectionString((String) jdbcUrl);
+        } catch (RuntimeException e) {
+            throw new HibernateException(
+                    String.format(
+                            "Failed to create ConnectionString from configuration [%s] with value [%s]",
+                            JAKARTA_JDBC_URL, jdbcUrl),
+                    e);
+        }
+        var database = connectionString.getDatabase();
+        if (database == null) {
+            throw new HibernateException(String.format(
+                    "Database must be provided in ConnectionString from configuration [%s] with value [%s]",
+                    JAKARTA_JDBC_URL, jdbcUrl));
+        }
+
+        var clientSettingsBuilder = MongoClientSettings.builder().applyConnectionString(connectionString);
+
+        if (configValues.get(JAKARTA_JDBC_USER) != null || configValues.get(JAKARTA_JDBC_PASSWORD) != null) {
+            throw new NotYetImplementedException("To be implemented after auth could be tested in CI");
+        }
+
+        var clientSettings = clientSettingsBuilder.build();
+        this.mongoClient = MongoClients.create(clientSettings);
+    }
+
+    @Override
+    public void stop() {
+        if (this.mongoClient != null) {
+            this.mongoClient.close();
+        }
+    }
+}