Register PG extensions in the model by convention

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;
+                }
+            }
+        }
+    }
+}

src/EFCore.PG/Metadata/PostgresExtension.cs

@@ -56,6 +56,39 @@ public static PostgresExtension GetOrAddPostgresExtension(
         return new PostgresExtension(annotatable, annotationName) { Version = version };
     }
 
+    /// <summary>
+    /// Gets or adds a <see cref="PostgresExtension"/> from or to the <see cref="IMutableAnnotatable"/>.
+    /// </summary>
+    /// <param name="annotatable">The annotatable from which to get or add the extension.</param>
+    /// <param name="schema">The extension schema or null to use the model's default schema.</param>
+    /// <param name="name">The extension name.</param>
+    /// <param name="version">The extension version.</param>
+    /// <returns>
+    /// The <see cref="PostgresExtension"/> from the <see cref="IMutableAnnotatable"/>.
+    /// </returns>
+    /// <exception cref="ArgumentException"><paramref name="schema"/></exception>
+    /// <exception cref="ArgumentNullException"><paramref name="annotatable"/></exception>
+    /// <exception cref="ArgumentNullException"><paramref name="name"/></exception>
+    public static PostgresExtension GetOrAddPostgresExtension(
+        IConventionAnnotatable annotatable,
+        string? schema,
+        string name,
+        string? version)
+    {
+        Check.NotNull(annotatable, nameof(annotatable));
+        Check.NullButNotEmpty(schema, nameof(schema));
+        Check.NotNull(name, nameof(name));
+
+        if (FindPostgresExtension(annotatable, schema, name) is { } postgresExtension)
+        {
+            return postgresExtension;
+        }
+
+        var annotationName = BuildAnnotationName(schema, name);
+
+        return new PostgresExtension(annotatable, annotationName) { Version = version };
+    }
+
     /// <summary>
     /// Gets or adds a <see cref="PostgresExtension"/> from or to the <see cref="IMutableAnnotatable"/>.
     /// </summary>
@@ -99,7 +132,7 @@ public static PostgresExtension GetOrAddPostgresExtension(
         return annotatable[annotationName] is null ? null : new PostgresExtension(annotatable, annotationName);
     }
 
-    private static string BuildAnnotationName(string? schema, string name)
+    internal static string BuildAnnotationName(string? schema, string name)
         => schema is not null
             ? $"{NpgsqlAnnotationNames.PostgresExtensionPrefix}{schema}.{name}"
             : $"{NpgsqlAnnotationNames.PostgresExtensionPrefix}{name}";

test/EFCore.PG.FunctionalTests/BuiltInDataTypesNpgsqlTest.cs

@@ -965,7 +965,6 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con
             NpgsqlConnection.GlobalTypeMapper.MapEnum<Mood>();
             ((NpgsqlTypeMappingSource)context.GetService<ITypeMappingSource>()).LoadUserDefinedTypeMappings(context.GetService<ISqlGenerationHelper>());
 
-            modelBuilder.HasPostgresExtension("hstore");
             modelBuilder.HasPostgresEnum("mood", new[] { "happy", "sad" });
 
             MakeRequired<MappedDataTypes>(modelBuilder);
@@ -1431,4 +1430,4 @@ protected class MappedNullableDataTypes
 }
 
 // ReSharper disable once UnusedMember.Global
-public enum Mood { Happy, Sad }
+public enum Mood { Happy, Sad }

test/EFCore.PG.FunctionalTests/Query/CitextQueryTest.cs

@@ -269,9 +269,6 @@ public class CitextQueryContext : PoolableDbContext
 
         public CitextQueryContext(DbContextOptions options) : base(options) {}
 
-        protected override void OnModelCreating(ModelBuilder modelBuilder)
-            => modelBuilder.HasPostgresExtension("citext");
-
         public static void Seed(CitextQueryContext context)
         {
             context.SomeEntities.AddRange(
@@ -295,4 +292,4 @@ public class CitextQueryFixture : SharedStoreFixtureBase<CitextQueryContext>
         public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory;
         protected override void Seed(CitextQueryContext context) => CitextQueryContext.Seed(context);
     }
-}
+}

test/EFCore.PG.FunctionalTests/Query/LTreeQueryTest.cs

@@ -427,9 +427,6 @@ public class LTreeQueryContext : PoolableDbContext
 
         public LTreeQueryContext(DbContextOptions options) : base(options) {}
 
-        protected override void OnModelCreating(ModelBuilder modelBuilder)
-            => modelBuilder.HasPostgresExtension("ltree");
-
         public static void Seed(LTreeQueryContext context)
         {
             var ltreeEntities = new LTreeEntity[]
@@ -471,9 +468,7 @@ public class LTreeQueryFixture : SharedStoreFixtureBase<LTreeQueryContext>
         protected override ITestStoreFactory TestStoreFactory => NpgsqlTestStoreFactory.Instance;
         public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory;
         protected override void Seed(LTreeQueryContext context) => LTreeQueryContext.Seed(context);
-        protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext context)
-            => modelBuilder.HasPostgresExtension("ltree");
     }
 
     #endregion
-}
+}

test/EFCore.PG.FunctionalTests/SpatialNpgsqlFixture.cs

@@ -24,7 +24,6 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con
     {
         base.OnModelCreating(modelBuilder, context);
 
-        modelBuilder.HasPostgresExtension("postgis")
-            .HasPostgresExtension("uuid-ossp");
+        modelBuilder.HasPostgresExtension("uuid-ossp");
     }
-}
+}