Sealed

Author: injectives

driver/pom.xml

@@ -238,6 +238,15 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-failsafe-plugin</artifactId>
       </plugin>
+        <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-compiler-plugin</artifactId>
+            <configuration>
+                <source>17</source>
+                <target>17</target>
+                <compilerArgs>--enable-preview</compilerArgs>
+            </configuration>
+        </plugin>
     </plugins>
   </build>
 

driver/src/main/java/org/neo4j/driver/Config.java

@@ -30,8 +30,6 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import org.neo4j.driver.internal.SecuritySettings;
@@ -146,13 +144,9 @@ public final class Config implements Serializable {
      */
     private final String userAgent;
     /**
-     * The minimum notification severity level.
+     * The notification config.
      */
-    private NotificationSeveritySetting minNotificationSeverity;
-    /**
-     * The disabled notification categories.
-     */
-    private Set<NotificationCategorySetting> disabledNotificationCategories;
+    private final NotificationConfig notificationConfig;
     /**
      * The {@link MetricsAdapter}.
      */
@@ -176,8 +170,7 @@ private Config(ConfigBuilder builder) {
         this.maxTransactionRetryTimeMillis = builder.maxTransactionRetryTimeMillis;
         this.resolver = builder.resolver;
         this.fetchSize = builder.fetchSize;
-        this.minNotificationSeverity = builder.minNotificationSeverity;
-        this.disabledNotificationCategories = builder.disabledNotificationCategories;
+        this.notificationConfig = builder.notificationConfig;
 
         this.eventLoopThreads = builder.eventLoopThreads;
         this.metricsAdapter = builder.metricsAdapter;
@@ -324,23 +317,12 @@ public long fetchSize() {
     }
 
     /**
-     * Returns minimum notification severity level.
-     *
-     * @return the minimum notification severity level
-     * @since 5.7
-     */
-    public NotificationSeveritySetting notificationsMinimumSeverityLevelSeverity() {
-        return minNotificationSeverity;
-    }
-
-    /**
-     * Returns disabled notification categories.
-     *
-     * @return the disabled notification categories
+     * Returns notification config.
+     * @return the notification config
      * @since 5.7
      */
-    public Optional<DisabledNotificationCategories> notificationsDisabledCategories() {
-        return Optional.ofNullable(disabledNotificationCategories).map(DisabledNotificationCategories::new);
+    public NotificationConfig notificationConfig() {
+        return notificationConfig;
     }
 
     /**
@@ -394,9 +376,8 @@ public static final class ConfigBuilder {
         private ServerAddressResolver resolver;
         private MetricsAdapter metricsAdapter = MetricsAdapter.DEV_NULL;
         private long fetchSize = FetchSizeUtil.DEFAULT_FETCH_SIZE;
-        private NotificationSeveritySetting minNotificationSeverity = NotificationSeveritySetting.INHERIT;
-        private Set<NotificationCategorySetting> disabledNotificationCategories = null;
         private int eventLoopThreads = 0;
+        private NotificationConfig notificationConfig = NotificationConfig.defaultConfig();
 
         private ConfigBuilder() {}
 
@@ -792,45 +773,13 @@ public ConfigBuilder withUserAgent(String userAgent) {
         }
 
         /**
-         * Sets minimum notification severity level that is used by the server when supplying the notifications.
-         * <p>
-         * By default, it is set to {@link NotificationSeveritySetting#INHERIT}.
-         *
-         * @param severity the minimum severity level
-         * @return this builder
-         * @see org.neo4j.driver.summary.Notification
-         * @since 5.7
-         */
-        public ConfigBuilder withMinimumNotificationSeverity(NotificationSeveritySetting severity) {
-            this.minNotificationSeverity = Objects.requireNonNull(severity, "severity must not be null");
-            return this;
-        }
-
-        /**
-         * Sets notification categories that will be disabled by the server when supplying the notifications.
-         * <p>
-         * By default, this has no explicit value. The server determines the behaviour.
-         *
-         * @param categories the set of disabled notification categories
-         * @return this builder
-         * @see org.neo4j.driver.summary.Notification
-         * @since 5.7
-         */
-        public ConfigBuilder withDisabledNotificationCategories(Set<NotificationCategorySetting> categories) {
-            this.disabledNotificationCategories =
-                    Set.copyOf(Objects.requireNonNull(categories, "categories must not be null"));
-            return this;
-        }
-
-        /**
-         * Unsets disabled notification categories.
-         *
+         * Sets notification config.
+         * @param notificationConfig the notification config
          * @return this builder
-         * @see org.neo4j.driver.summary.Notification
          * @since 5.7
          */
-        public ConfigBuilder withInheritedDisabledNotificationCategories() {
-            this.disabledNotificationCategories = null;
+        public ConfigBuilder withNotificationConfig(NotificationConfig notificationConfig) {
+            this.notificationConfig = Objects.requireNonNull(notificationConfig, "notificationConfig must not be null");
             return this;
         }
 

driver/src/main/java/org/neo4j/driver/DisabledNotificationCategories.java

@@ -18,49 +18,56 @@
  */
 package org.neo4j.driver;
 
-import org.neo4j.driver.summary.Notification;
+import java.io.Serializable;
+import org.neo4j.driver.internal.InternalNotificationCategory;
+import org.neo4j.driver.internal.InternalNotificationCategory.Type;
 
 /**
- * {@link Notification} categories that are used in {@link Config} and {@link SessionConfig}.
+ * A notification category.
  *
  * @since 5.7
  */
-public enum NotificationCategorySetting {
+public sealed interface NotificationCategory extends Serializable permits InternalNotificationCategory {
     /**
      * A hint category.
      * <p>
      * For instance, the given hint cannot be satisfied.
      */
-    HINT,
+    NotificationCategory HINT = new InternalNotificationCategory(Type.HINT);
+
     /**
      * An unrecognized category.
      * <p>
      * For instance, the query or command mentions entities that are unknown to the system.
      */
-    UNRECOGNIZED,
+    NotificationCategory UNRECOGNIZED = new InternalNotificationCategory(Type.UNRECOGNIZED);
+
     /**
      * An unsupported category.
      * <p>
      * For instance, the query/command is trying to use features that are not supported by the current system or using
      * features that are experimental and should not be used in production.
      */
-    UNSUPPORTED,
+    NotificationCategory UNSUPPORTED = new InternalNotificationCategory(Type.UNSUPPORTED);
+
     /**
      * A performance category.
      * <p>
      * For instance, the query uses costly operations and might be slow.
      */
-    PERFORMANCE,
+    NotificationCategory PERFORMANCE = new InternalNotificationCategory(Type.PERFORMANCE);
+
     /**
      * A deprecation category.
      * <p>
      * For instance, the query/command use deprecated features that should be replaced.
      */
-    DEPRECATION,
+    NotificationCategory DEPRECATION = new InternalNotificationCategory(Type.DEPRECATION);
+
     /**
      * A generic category.
      * <p>
      * For instance, notifications that are not part of a more specific class.
      */
-    GENERIC
+    NotificationCategory GENERIC = new InternalNotificationCategory(Type.GENERIC);
 }

driver/src/main/java/org/neo4j/driver/NotificationCategorySetting.java renamed to driver/src/main/java/org/neo4j/driver/NotificationCategory.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * 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 org.neo4j.driver;
+
+import java.io.Serializable;
+import java.util.Objects;
+import java.util.Set;
+import org.neo4j.driver.internal.InternalNotificationConfig;
+import org.neo4j.driver.internal.InternalNotificationSeverity;
+
+/**
+ * Notification configuration that defines what notifications the server may supply to the driver.
+ * <p>
+ * Please note that such configurations are only recognised by the server version 5.7 and above.
+ * @since 5.7
+ */
+public sealed interface NotificationConfig extends Serializable permits InternalNotificationConfig {
+    /**
+     * Returns a default notification config.
+     * <p>
+     * It has no options activated, meaning they the resulting behaviour depends on upstream entity. For instance,
+     * when this config is set on session level, the resulting behaviour depends on config set on driver level.
+     * Likewise, when this config is set on driver level, the resulting behaviour depends on the server.
+     * @return the default config
+     */
+    static NotificationConfig defaultConfig() {
+        return new InternalNotificationConfig(null, null);
+    }
+
+    /**
+     * A config that disables all notifications.
+     * @return the config that disables all notifications
+     */
+    static NotificationConfig disableAll() {
+        return new InternalNotificationConfig(InternalNotificationSeverity.OFF, null);
+    }
+
+    /**
+     * Returns a config that sets a minimum severity level for notifications.
+     *
+     * @param minimumSeverity the minimum severity level
+     * @return the config
+     */
+    static NotificationConfig enableMinimumSeverity(NotificationSeverity minimumSeverity) {
+        Objects.requireNonNull(minimumSeverity, "minimumSeverity must not be null");
+        return new InternalNotificationConfig(minimumSeverity, null);
+    }
+
+    /**
+     * Returns a config that disables a set of notification categories.
+     *
+     * @param disabledCategories the categories to disable, an empty set means no categories are disabled
+     * @return the config
+     */
+    static NotificationConfig disableCategories(Set<NotificationCategory> disabledCategories) {
+        Objects.requireNonNull(disabledCategories, "disabledCategories must not be null");
+        return new InternalNotificationConfig(null, Set.copyOf(disabledCategories));
+    }
+
+    /**
+     * Returns a config that sets a minimum severity level for notifications and also disables a set of notification categories.
+     *
+     * @param minimumSeverity the minimum severity level
+     * @param disabledCategories the categories to disable, an empty set means no categories are disabled
+     * @return the config
+     */
+    static NotificationConfig enableMinimumSeverityAndDisableCategories(
+            NotificationSeverity minimumSeverity, Set<NotificationCategory> disabledCategories) {
+        Objects.requireNonNull(minimumSeverity, "minimumSeverity must not be null");
+        Objects.requireNonNull(disabledCategories, "disabledCategories must not be null");
+        return new InternalNotificationConfig(minimumSeverity, Set.copyOf(disabledCategories));
+    }
+}

driver/src/main/java/org/neo4j/driver/NotificationConfig.java

@@ -16,25 +16,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.neo4j.driver.summary;
+package org.neo4j.driver;
+
+import static org.neo4j.driver.internal.InternalNotificationSeverity.Type;
+
+import java.io.Serializable;
+import org.neo4j.driver.internal.InternalNotificationSeverity;
 
 /**
- * {@link Notification} severity levels.
- *
+ * A notification severity level.
  * @since 5.7
  */
-public enum NotificationSeverity {
-    /**
-     * A warning severity level.
-     */
-    WARNING,
+public sealed interface NotificationSeverity extends Serializable, Comparable<NotificationSeverity>
+        permits InternalNotificationSeverity {
     /**
      * An information severity level.
      */
-    INFORMATION,
+    NotificationSeverity INFORMATION = new InternalNotificationSeverity(Type.INFORMATION, 800);
     /**
-     * An unknown severity level. The driver will map unknown severity levels to this value. This may happen when driver
-     * there is a version mismatch between the driver and the server.
+     * A warning severity level.
      */
-    UNKNOWN
+    NotificationSeverity WARNING = new InternalNotificationSeverity(Type.WARNING, 900);
 }