Migrates MongoDb to file scoped namespaces

format.sh

@@ -5,6 +5,7 @@ rootDir=$(dirname "$0")
 $rootDir/src/HotChocolate/AspNetCore/format.sh
 $rootDir/src/HotChocolate/ApolloFederation/format.sh
 $rootDir/src/HotChocolate/Data/format.sh
+$rootDir/src/HotChocolate/MongoDb/format.sh
 $rootDir/src/HotChocolate/Language/format.sh
 $rootDir/src/HotChocolate/Stitching/format.sh
 $rootDir/src/HotChocolate/Spatial/format.sh

src/HotChocolate/MongoDb/format.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+BASEDIR=$(dirname "$0")
+src=$BASEDIR/src
+test=$BASEDIR/test
+
+dotnet format $src/Data
+dotnet format $src/Types
+dotnet format $test/Data.MongoDb.Filters.Tests
+dotnet format $test/Data.MongoDb.Projections.Tests
+dotnet format $test/Data.MongoDb.Paging.Tests
+dotnet format $test/Data.MongoDb.Sorting.Tests
+dotnet format $test/Types.MongoDb

src/HotChocolate/MongoDb/src/Data/Driver/AndFilterDefinition.cs

@@ -4,114 +4,113 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Linq;
 
-namespace HotChocolate.Data.MongoDb
+namespace HotChocolate.Data.MongoDb;
+
+/// <summary>
+/// This class was ported over from the official mongo db driver
+/// </summary>
+public sealed class AndFilterDefinition : MongoDbFilterDefinition
 {
-    /// <summary>
-    /// This class was ported over from the official mongo db driver
-    /// </summary>
-    public sealed class AndFilterDefinition : MongoDbFilterDefinition
+    private static readonly string[] __operatorsThatCannotBeCombined = new[]
     {
-        private static readonly string[] __operatorsThatCannotBeCombined = new[]
-        {
             "$geoWithin",
             "$near",
             "$geoIntersects",
             "$nearSphere"
         };
 
-        private readonly MongoDbFilterDefinition[] _filters;
+    private readonly MongoDbFilterDefinition[] _filters;
 
-        public AndFilterDefinition(params MongoDbFilterDefinition[] filters)
-        {
-            _filters = filters;
-        }
+    public AndFilterDefinition(params MongoDbFilterDefinition[] filters)
+    {
+        _filters = filters;
+    }
+
+    public AndFilterDefinition(IEnumerable<MongoDbFilterDefinition> filters)
+    {
+        _filters = filters.ToArray();
+    }
 
-        public AndFilterDefinition(IEnumerable<MongoDbFilterDefinition> filters)
+    public override BsonDocument Render(
+        IBsonSerializer documentSerializer,
+        IBsonSerializerRegistry serializerRegistry)
+    {
+        if (_filters.Length == 0)
         {
-            _filters = filters.ToArray();
+            return new BsonDocument("$and", new BsonArray(0));
         }
 
-        public override BsonDocument Render(
-            IBsonSerializer documentSerializer,
-            IBsonSerializerRegistry serializerRegistry)
+        var document = new BsonDocument();
+
+        foreach (var filter in _filters)
         {
-            if (_filters.Length == 0)
+            BsonDocument renderedFilter = filter.Render(documentSerializer, serializerRegistry);
+            foreach (BsonElement clause in renderedFilter)
             {
-                return new BsonDocument("$and", new BsonArray(0));
+                AddClause(document, clause);
             }
+        }
 
-            var document = new BsonDocument();
+        return document;
+    }
 
-            foreach (var filter in _filters)
+    private static void AddClause(BsonDocument document, BsonElement clause)
+    {
+        if (clause.Name == "$and")
+        {
+            // flatten out nested $and
+            foreach (var item in (BsonArray)clause.Value)
             {
-                BsonDocument renderedFilter = filter.Render(documentSerializer, serializerRegistry);
-                foreach (BsonElement clause in renderedFilter)
+                foreach (BsonElement element in (BsonDocument)item)
                 {
-                    AddClause(document, clause);
+                    AddClause(document, element);
                 }
             }
-
-            return document;
         }
-
-        private static void AddClause(BsonDocument document, BsonElement clause)
+        else if (document.ElementCount == 1 && document.GetElement(0).Name == "$and")
         {
-            if (clause.Name == "$and")
-            {
-                // flatten out nested $and
-                foreach (var item in (BsonArray)clause.Value)
-                {
-                    foreach (BsonElement element in (BsonDocument)item)
-                    {
-                        AddClause(document, element);
-                    }
-                }
-            }
-            else if (document.ElementCount == 1 && document.GetElement(0).Name == "$and")
-            {
-                ((BsonArray)document[0]).Add(new BsonDocument(clause));
-            }
-            else if (document.Contains(clause.Name))
+            ((BsonArray)document[0]).Add(new BsonDocument(clause));
+        }
+        else if (document.Contains(clause.Name))
+        {
+            BsonElement existingClause = document.GetElement(clause.Name);
+            if (existingClause.Value is BsonDocument existingClauseValue &&
+                clause.Value is BsonDocument clauseValue)
             {
-                BsonElement existingClause = document.GetElement(clause.Name);
-                if (existingClause.Value is BsonDocument existingClauseValue &&
-                    clause.Value is BsonDocument clauseValue)
+                var clauseOperator = clauseValue.ElementCount > 0
+                    ? clauseValue.GetElement(0).Name
+                    : null;
+                if (clauseValue.Names.Any(op => existingClauseValue.Contains(op)) ||
+                    __operatorsThatCannotBeCombined.Contains(clauseOperator))
                 {
-                    var clauseOperator = clauseValue.ElementCount > 0
-                        ? clauseValue.GetElement(0).Name
-                        : null;
-                    if (clauseValue.Names.Any(op => existingClauseValue.Contains(op)) ||
-                        __operatorsThatCannotBeCombined.Contains(clauseOperator))
-                    {
-                        PromoteFilterToDollarForm(document, clause);
-                    }
-                    else
-                    {
-                        existingClauseValue.AddRange(clauseValue);
-                    }
+                    PromoteFilterToDollarForm(document, clause);
                 }
                 else
                 {
-                    PromoteFilterToDollarForm(document, clause);
+                    existingClauseValue.AddRange(clauseValue);
                 }
             }
             else
             {
-                document.Add(clause);
+                PromoteFilterToDollarForm(document, clause);
             }
         }
-
-        private static void PromoteFilterToDollarForm(BsonDocument document, BsonElement clause)
+        else
         {
-            var clauses = new BsonArray();
-            foreach (BsonElement queryElement in document)
-            {
-                clauses.Add(new BsonDocument(queryElement));
-            }
+            document.Add(clause);
+        }
+    }
 
-            clauses.Add(new BsonDocument(clause));
-            document.Clear();
-            document.Add("$and", clauses);
+    private static void PromoteFilterToDollarForm(BsonDocument document, BsonElement clause)
+    {
+        var clauses = new BsonArray();
+        foreach (BsonElement queryElement in document)
+        {
+            clauses.Add(new BsonDocument(queryElement));
         }
+
+        clauses.Add(new BsonDocument(clause));
+        document.Clear();
+        document.Add("$and", clauses);
     }
 }

src/HotChocolate/MongoDb/src/Data/Driver/FilterDefinitionExtensions.cs

@@ -2,36 +2,35 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
 
-namespace HotChocolate.Data.MongoDb
+namespace HotChocolate.Data.MongoDb;
+
+public static class FilterDefinitionExtensions
 {
-    public static class FilterDefinitionExtensions
+    public static MongoDbFilterDefinition Wrap<T>(
+        this FilterDefinition<T> filterDefinition) =>
+        new FilterDefinitionWrapper<T>(filterDefinition);
+
+    private sealed class FilterDefinitionWrapper<TDocument> : MongoDbFilterDefinition
     {
-        public static MongoDbFilterDefinition Wrap<T>(
-            this FilterDefinition<T> filterDefinition) =>
-            new FilterDefinitionWrapper<T>(filterDefinition);
+        private readonly FilterDefinition<TDocument> _filter;
 
-        private sealed class FilterDefinitionWrapper<TDocument> : MongoDbFilterDefinition
+        public FilterDefinitionWrapper(FilterDefinition<TDocument> filter)
         {
-            private readonly FilterDefinition<TDocument> _filter;
+            _filter = filter;
+        }
 
-            public FilterDefinitionWrapper(FilterDefinition<TDocument> filter)
+        public override BsonDocument Render(
+            IBsonSerializer documentSerializer,
+            IBsonSerializerRegistry serializerRegistry)
+        {
+            if (documentSerializer is IBsonSerializer<TDocument> typedSerializer)
             {
-                _filter = filter;
+                return _filter.Render(typedSerializer, serializerRegistry);
             }
 
-            public override BsonDocument Render(
-                IBsonSerializer documentSerializer,
-                IBsonSerializerRegistry serializerRegistry)
-            {
-                if (documentSerializer is IBsonSerializer<TDocument> typedSerializer)
-                {
-                    return _filter.Render(typedSerializer, serializerRegistry);
-                }
-
-                return _filter.Render(
-                    serializerRegistry.GetSerializer<TDocument>(),
-                    serializerRegistry);
-            }
+            return _filter.Render(
+                serializerRegistry.GetSerializer<TDocument>(),
+                serializerRegistry);
         }
     }
 }

src/HotChocolate/MongoDb/src/Data/Driver/MongoDbCombinedProjectionDefinition.cs

@@ -4,47 +4,46 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
 
-namespace HotChocolate.Data.MongoDb
+namespace HotChocolate.Data.MongoDb;
+
+/// <summary>
+/// This class was ported over from the official mongo db driver
+/// </summary>
+public sealed class MongoDbCombinedProjectionDefinition : MongoDbProjectionDefinition
 {
-    /// <summary>
-    /// This class was ported over from the official mongo db driver
-    /// </summary>
-    public sealed class MongoDbCombinedProjectionDefinition : MongoDbProjectionDefinition
+    private readonly MongoDbProjectionDefinition[] _projections;
+
+    public MongoDbCombinedProjectionDefinition(
+        params MongoDbProjectionDefinition[] projections)
     {
-        private readonly MongoDbProjectionDefinition[] _projections;
+        _projections = projections;
+    }
 
-        public MongoDbCombinedProjectionDefinition(
-            params MongoDbProjectionDefinition[] projections)
-        {
-            _projections = projections;
-        }
+    public MongoDbCombinedProjectionDefinition(
+        IEnumerable<MongoDbProjectionDefinition> projections)
+    {
+        _projections = Ensure.IsNotNull(projections, nameof(projections)).ToArray();
+    }
 
-        public MongoDbCombinedProjectionDefinition(
-            IEnumerable<MongoDbProjectionDefinition> projections)
-        {
-            _projections = Ensure.IsNotNull(projections, nameof(projections)).ToArray();
-        }
+    public override BsonDocument Render(
+        IBsonSerializer documentSerializer,
+        IBsonSerializerRegistry serializerRegistry)
+    {
+        var document = new BsonDocument();
 
-        public override BsonDocument Render(
-            IBsonSerializer documentSerializer,
-            IBsonSerializerRegistry serializerRegistry)
+        foreach (var sort in _projections)
         {
-            var document = new BsonDocument();
+            BsonDocument renderedProjection = sort.Render(
+                documentSerializer,
+                serializerRegistry);
 
-            foreach (var sort in _projections)
+            foreach (BsonElement element in renderedProjection.Elements)
             {
-                BsonDocument renderedProjection = sort.Render(
-                    documentSerializer,
-                    serializerRegistry);
-
-                foreach (BsonElement element in renderedProjection.Elements)
-                {
-                    document.Remove(element.Name);
-                    document.Add(element);
-                }
+                document.Remove(element.Name);
+                document.Add(element);
             }
-
-            return document;
         }
+
+        return document;
     }
 }