Register PG extensions in the model by convention (#2161)

By scanning property types in the model.

Closes #2137

Author: roji

EFCore.PG.sln.DotSettings

@@ -307,6 +307,7 @@ The .NET Foundation licenses this file to you under the MIT license.
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=niladic/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=pluralizer/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Poolable/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=postgis/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=pushdown/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=regconfig/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=regdictionary/@EntryIndexedValue">True</s:Boolean>

src/EFCore.PG.NTS/EFCore.PG.NTS.csproj

@@ -24,7 +24,7 @@
 
   <ItemGroup>
     <Compile Include="..\Shared\*.cs" />
-    <None Include="README.md" Pack="true" PackagePath="\"/>
+    <None Include="README.md" Pack="true" PackagePath="\" />
     <None Include="build\**\*">
       <Pack>True</Pack>
       <PackagePath>build</PackagePath>

src/EFCore.PG.NTS/Extensions/NpgsqlNetTopologySuiteServiceCollectionExtensions.cs

@@ -26,6 +26,7 @@ public static IServiceCollection AddEntityFrameworkNpgsqlNetTopologySuite(
             .TryAdd<IRelationalTypeMappingSourcePlugin, NpgsqlNetTopologySuiteTypeMappingSourcePlugin>()
             .TryAdd<IMethodCallTranslatorPlugin, NpgsqlNetTopologySuiteMethodCallTranslatorPlugin>()
             .TryAdd<IMemberTranslatorPlugin, NpgsqlNetTopologySuiteMemberTranslatorPlugin>()
+            .TryAdd<IConventionSetPlugin, NpgsqlNetTopologySuiteConventionSetPlugin>()
             .TryAddProviderSpecificServices(
                 x => x.TryAddSingleton<INpgsqlNetTopologySuiteOptions, NpgsqlNetTopologySuiteOptions>());
 

src/EFCore.PG.NTS/Internal/NpgsqlNetTopologySuiteConventionSetPlugin.cs

@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// ReSharper disable once CheckNamespace
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Internal;
+
+public class NpgsqlNetTopologySuiteConventionSetPlugin : IConventionSetPlugin
+{
+    public virtual ConventionSet ModifyConventions(ConventionSet conventionSet)
+    {
+        conventionSet.ModelFinalizingConventions.Add(new NpgsqlNetTopologySuiteExtensionAddingConvention());
+
+        return conventionSet;
+    }
+}
+

src/EFCore.PG.NTS/Internal/NpgsqlNetTopologySuiteExtensionAddingConvention.cs

@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// ReSharper disable once CheckNamespace
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Internal;
+
+public class NpgsqlNetTopologySuiteExtensionAddingConvention : IModelFinalizingConvention
+{
+    /// <inheritdoc />
+    public virtual void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
+        => modelBuilder.HasPostgresExtension("postgis");
+}

src/EFCore.PG.NTS/README.md

@@ -30,9 +30,6 @@ public class BlogContext : DbContext
         => optionsBuilder.UseNpgsql(
             @"Host=myserver;Username=mylogin;Password=mypass;Database=mydatabase",
             o => o.UseNetTopologySuite());
-
-    protected override void OnModelCreating(ModelBuilder modelBuilder)
-        => modelBuilder.HasPostgresExtension("postgis");
 }
 
 public class City

src/EFCore.PG/Extensions/BuilderExtensions/NpgsqlModelBuilderExtensions.cs

@@ -247,9 +247,7 @@ public static bool CanSetValueGenerationStrategy(
     /// <param name="schema">The schema in which to create the extension.</param>
     /// <param name="name">The name of the extension to create.</param>
     /// <param name="version">The version of the extension.</param>
-    /// <returns>
-    /// The updated <see cref="ModelBuilder"/>.
-    /// </returns>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
     /// <remarks>
     /// See: https://www.postgresql.org/docs/current/external-extensions.html
     /// </remarks>
@@ -274,9 +272,7 @@ public static ModelBuilder HasPostgresExtension(
     /// </summary>
     /// <param name="modelBuilder">The model builder in which to define the extension.</param>
     /// <param name="name">The name of the extension to create.</param>
-    /// <returns>
-    /// The updated <see cref="ModelBuilder"/>.
-    /// </returns>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
     /// <remarks>
     /// See: https://www.postgresql.org/docs/current/external-extensions.html
     /// </remarks>
@@ -286,6 +282,78 @@ public static ModelBuilder HasPostgresExtension(
         string name)
         => modelBuilder.HasPostgresExtension(null, name);
 
+    /// <summary>
+    /// Registers a PostgreSQL extension in the model.
+    /// </summary>
+    /// <param name="modelBuilder">The model builder in which to define the extension.</param>
+    /// <param name="schema">The schema in which to create the extension.</param>
+    /// <param name="name">The name of the extension to create.</param>
+    /// <param name="version">The version of the extension.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    /// <remarks>
+    /// See: https://www.postgresql.org/docs/current/external-extensions.html
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="modelBuilder"/></exception>
+    public static IConventionModelBuilder? HasPostgresExtension(
+        this IConventionModelBuilder modelBuilder,
+        string? schema,
+        string name,
+        string? version = null,
+        bool fromDataAnnotation = false)
+    {
+        if (modelBuilder.CanSetPostgresExtension(schema, name, version, fromDataAnnotation))
+        {
+            modelBuilder.Metadata.GetOrAddPostgresExtension(schema, name, version);
+            return modelBuilder;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Registers a PostgreSQL extension in the model.
+    /// </summary>
+    /// <param name="modelBuilder">The model builder in which to define the extension.</param>
+    /// <param name="name">The name of the extension to create.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    /// <remarks>
+    /// See: https://www.postgresql.org/docs/current/external-extensions.html
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"><paramref name="modelBuilder"/></exception>
+    public static IConventionModelBuilder? HasPostgresExtension(
+        this IConventionModelBuilder modelBuilder,
+        string name,
+        bool fromDataAnnotation = false)
+        => modelBuilder.HasPostgresExtension(schema: null, name, version: null, fromDataAnnotation);
+
+    /// <summary>
+    ///     Returns a value indicating whether the given PostgreSQL extension can be registered in the model.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlserver">Accessing SQL Server and SQL Azure databases with EF Core</see>
+    ///     for more information and examples.
+    /// </remarks>
+    /// <param name="modelBuilder">The model builder.</param>
+    /// <param name="schema">The schema in which to create the extension.</param>
+    /// <param name="name">The name of the extension to create.</param>
+    /// <param name="version">The version of the extension.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns><see langword="true" /> if the given value can be set as the default increment for SQL Server IDENTITY.</returns>
+    public static bool CanSetPostgresExtension(
+        this IConventionModelBuilder modelBuilder,
+        string? schema,
+        string name,
+        string? version = null,
+        bool fromDataAnnotation = false)
+    {
+        var annotationName = PostgresExtension.BuildAnnotationName(schema, name);
+
+        return modelBuilder.CanSetAnnotation(annotationName, $"{schema},{name},{version}", fromDataAnnotation);
+    }
+
     #endregion
 
     #region Enums

src/EFCore.PG/Extensions/MetadataExtensions/NpgsqlModelExtensions.cs

@@ -161,6 +161,13 @@ public static PostgresExtension GetOrAddPostgresExtension(
     public static IReadOnlyList<PostgresExtension> GetPostgresExtensions(this IReadOnlyModel model)
         => PostgresExtension.GetPostgresExtensions(model).ToArray();
 
+    public static PostgresExtension GetOrAddPostgresExtension(
+        this IConventionModel model,
+        string? schema,
+        string name,
+        string? version)
+        => PostgresExtension.GetOrAddPostgresExtension(model, schema, name, version);
+
     #endregion
 
     #region Enum types

src/EFCore.PG/Metadata/Conventions/NpgsqlConventionSetBuilder.cs

@@ -5,15 +5,20 @@ namespace Npgsql.EntityFrameworkCore.PostgreSQL.Metadata.Conventions;
 [EntityFrameworkInternal]
 public class NpgsqlConventionSetBuilder : RelationalConventionSetBuilder
 {
+    private readonly IRelationalTypeMappingSource _typeMappingSource;
     private readonly Version _postgresVersion;
 
     [EntityFrameworkInternal]
     public NpgsqlConventionSetBuilder(
         ProviderConventionSetBuilderDependencies dependencies,
         RelationalConventionSetBuilderDependencies relationalDependencies,
+        IRelationalTypeMappingSource typeMappingSource,
         INpgsqlOptions npgsqlOptions)
         : base(dependencies, relationalDependencies)
-        => _postgresVersion = npgsqlOptions.PostgresVersion;
+    {
+        _typeMappingSource = typeMappingSource;
+        _postgresVersion = npgsqlOptions.PostgresVersion;
+    }
 
     [EntityFrameworkInternal]
     public override ConventionSet CreateConventionSet()
@@ -43,6 +48,7 @@ public override ConventionSet CreateConventionSet()
             conventionSet.PropertyAnnotationChangedConventions, (RelationalValueGenerationConvention)valueGenerationConvention);
 
         conventionSet.ModelFinalizingConventions.Add(valueGenerationStrategyConvention);
+        conventionSet.ModelFinalizingConventions.Add(new NpgsqlPostgresExtensionDiscoveryConvention(_typeMappingSource));
         ReplaceConvention(conventionSet.ModelFinalizingConventions, storeGenerationConvention);
         ReplaceConvention(
             conventionSet.ModelFinalizingConventions,

src/EFCore.PG/Metadata/Conventions/NpgsqlPostgresExtensionDiscoveryConvention.cs

@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Metadata.Conventions;
+
+public class NpgsqlPostgresExtensionDiscoveryConvention : IModelFinalizingConvention
+{
+    private readonly IRelationalTypeMappingSource _typeMappingSource;
+
+    public NpgsqlPostgresExtensionDiscoveryConvention(IRelationalTypeMappingSource typeMappingSource)
+    {
+        _typeMappingSource = typeMappingSource;
+    }
+
+    /// <inheritdoc />
+    public virtual void ProcessModelFinalizing(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
+    {
+        foreach (var entityType in modelBuilder.Metadata.GetEntityTypes())
+        {
+            foreach (var property in entityType.GetDeclaredProperties())
+            {
+                var typeMapping = (RelationalTypeMapping?)property.FindTypeMapping()
+                                  ?? _typeMappingSource.FindMapping((IProperty)property);
+
+                if (typeMapping is null)
+                {
+                    continue;
+                }
+
+                switch (typeMapping.StoreType)
+                {
+                    case "hstore":
+                        modelBuilder.HasPostgresExtension("hstore");
+                        continue;
+                    case "citext":
+                        modelBuilder.HasPostgresExtension("citext");
+                        continue;
+                    case "ltree":
+                    case "lquery":
+                    case "ltxtquery":
+                        modelBuilder.HasPostgresExtension("ltree");
+                        continue;
+                }
+            }
+        }
+    }
+}