using IdentityServer4 with custom Configration DBContext

You don't need to create a custom ConfigurationDbContext or event IDbContextFactory in order to switch to use different databases. With IdentityServer4.EntityFramework version 2.3.2, you can do:

namespace DL.STS.Host
{
    public class Startup
    {
        ...

        public void ConfigureServices(IServiceCollection services)
        {
            string connectionString = _configuration.GetConnectionString("appDbConnection");

            string migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly
                .GetName().Name;

            services
               .AddIdentityServer()
               .AddConfigurationStore(options =>
               {
                   options.ConfigureDbContext = builder =>
                       // I made up this extension method "UseOracle",
                       // but this is where you plug your database in
                       builder.UseOracle(connectionString,
                           sql => sql.MigrationsAssembly(migrationsAssembly));
               })
               ...;

            ...
        }

        ...
    }
}

Separate Configuration/Operational Store into its own project/assembly?

What if you want to lay out your solution nicely and would like to separate the configuration store and operational store (as well as the identity user store) into their own class library/assembly?

Per the documentation, you can use -o to specify the output migration folder destination:

dotnet ef migrations add InitialIdentityServerPersistedGrantDbMigration -c PersistedGrantDbContext -o Data/Migrations/IdentityServer/PersistedGrantDb
dotnet ef migrations add InitialIdentityServerConfigurationDbMigration -c ConfigurationDbContext -o Data/Migrations/IdentityServer/ConfigurationDb

But who likes to memorize/type such long path when doing migrations? Then you might think: how about a custom ConfigurationDbContext inherited from IdentityServer's, and a separate project:

using IdentityServer4.EntityFramework.DbContexts;
using IdentityServer4.EntityFramework.Options;
using Microsoft.EntityFrameworkCore;

namespace DL.STS.Data.ConfigurationStore.EFCore
{
    public class AppConfigurationDbContext : ConfigurationDbContext
    {
        public AppConfigurationDbContext(DbContextOptions<ConfigurationDbContext> options, 
            ConfigurationStoreOptions storeOptions) : base(options, storeOptions)
        {
        }
    }
}

Common errors

I think this is where people get into troubles. When you do Add-Migration, you would either encounter:

Unable to create an object of type AppConfigurationDbContext. For different patterns supported at design time, see https://go.microsoft.com/fwlink/?linkid=851728.

or

Unable to resolve service for type Microsoft.EntityFrameworkCore.DbContextOptions<IdentityServer4.EntityFramework.DbContexts.ConfigurationDbContext> while attempting to activate DL.STS.Data.ConfigurationStore.EFCore.AppConfigurationDbContext.

I don't think, for now, there is a way to fix it.

Is there any other ways?

It turns out it's actually quite easy. It seems like you can't have your own DbContext inherited from IdentityServer's. So get rid of that, and create an extension method in that separate library/assembly:

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System.Reflection;

namespace DL.STS.Data.ConfigurationStore.EFCore.Extensions
{
    public static class IdentityServerBuilderExtensions
    {
        public static IIdentityServerBuilder AddEFConfigurationStore(
            this IIdentityServerBuilder builder, string connectionString)
        {
            string assemblyNamespace = typeof(IdentityServerBuilderExtensions)
                .GetTypeInfo()
                .Assembly
                .GetName()
                .Name;

            builder.AddConfigurationStore(options =>
                options.ConfigureDbContext = b =>
                    b.UseSqlServer(connectionString, optionsBuilder =>
                        optionsBuilder.MigrationsAssembly(assemblyNamespace)
                    )
            );

            return builder;
        }
    }
}

Then on Startup.cs on your web project:

public void ConfigureServices(IServiceCollection services)
{
    ...

    string connectionString = _configuration.GetConnectionString("appDbConnection");

    services
        .AddIdentityServer()
        .AddDeveloperSigningCredential()
        .AddEFConfigurationStore(connectionString)
        ...;

    ...
}

And when you do PM> Add-Migration AddConfigurationTables -Context ConfigurationDbContext with the default project being that separate library/assembly:

with the recent release, the Identityserver framework does support custom implementation of configuration store, operation store. This will also work with migration

see below for instance

            public class CustomPersistsDbContext : DbContext, IPersistedGrantDbContext
                {
                }

In the OnModelCreating(ModelBuilder modelBuilder) I had to add the relations manually:

                protected override void OnModelCreating(ModelBuilder modelBuilder)
                {
                    //Optional: The version of .NET Core, used by Ef Core Migration history table
                    modelBuilder.HasAnnotation("ProductVersion", "2.2.0-rtm-35687");

          //.. Your custom code

    //PersistentDbContext
modelBuilder.Entity("IdentityServer4.EntityFramework.Entities.DeviceFlowCodes", b =>
                    {
                        b.Property<string>("UserCode")
                            .ValueGeneratedOnAdd()
                            .HasMaxLength(200);

                        b.Property<string>("ClientId")
                            .IsRequired()
                            .HasMaxLength(200);

                        b.Property<DateTime>("CreationTime");

                        b.Property<string>("Data")
                            .IsRequired()
                            .HasMaxLength(50000);

                        b.Property<string>("DeviceCode")
                            .IsRequired()
                            .HasMaxLength(200);

                        b.Property<DateTime?>("Expiration")
                            .IsRequired();

                        b.Property<string>("SubjectId")
                            .HasMaxLength(200);

                        b.HasKey("UserCode");

                        b.HasIndex("DeviceCode")
                            .IsUnique();

                        b.HasIndex("UserCode")
                            .IsUnique();

                        b.ToTable("DeviceCodes");
                    });

                    modelBuilder.Entity("IdentityServer4.EntityFramework.Entities.PersistedGrant", b =>
                    {
                        b.Property<string>("Key")
                            .HasMaxLength(200);

                        b.Property<string>("ClientId")
                            .IsRequired()
                            .HasMaxLength(200);

                        b.Property<DateTime>("CreationTime");

                        b.Property<string>("Data")
                            .IsRequired()
                            .HasMaxLength(50000);

                        b.Property<DateTime?>("Expiration");

                        b.Property<string>("SubjectId")
                            .HasMaxLength(200);

                        b.Property<string>("Type")
                            .IsRequired()
                            .HasMaxLength(50);

                        b.HasKey("Key");

                        b.HasIndex("SubjectId", "ClientId", "Type");

                        b.ToTable("PersistedGrants");
                    });
                }

On the services startup

 .AddOperationalStore<CustomPersistsDbContext>(options =>

Adding an IDbContextFactory fixed the issue.

public class IdentityConfigurationDbContextFactory : IDbContextFactory<IdentityConfigurationDbContext> {

        public IdentityConfigurationDbContext Create(DbContextFactoryOptions options) {
            var optionsBuilder = new DbContextOptionsBuilder<ConfigurationDbContext>();
            var config = new ConfigurationBuilder()
                             .SetBasePath(options.ContentRootPath)
                             .AddJsonFile("appsettings.json")
                              .AddJsonFile($"appsettings.{options.EnvironmentName}.json", true)

                             .Build();

            optionsBuilder.UseOracle(config.GetConnectionString("DefaultConnection"));

            return new IdentityConfigurationDbContext(optionsBuilder.Options, new ConfigurationStoreOptions());
        }
    }

I may not be too late to this party but what you might be able to simply do is thus:

.AddConfigurationStore<CustomIdentityContext>(options =>
            {
                options.ConfigureDbContext = builder => builder.UseSqlServer(connectionString, b => b.MigrationsAssembly("tuitionpayer.IdentityEF"));
            })
            // this adds the operational data from DB (codes, tokens, consents)
            .AddOperationalStore<CustomIdentityContext>(options =>
            {
                options.ConfigureDbContext = builder => builder.UseSqlServer(connectionString, b => b.MigrationsAssembly("tuitionpayer.IdentityEF"));

                // this enables automatic token cleanup. this is optional.
                options.EnableTokenCleanup = true;
            });

And the DbContext will look something like:

public class CustomIdentityContext : IdentityDbContext<CustomUser, CustomRole, string>, IPersistedGrantDbContext, IConfigurationDbContext
{
    public CustomIdentityContext(DbContextOptions<CustomIdentityContext> options) : base(options)
    {
    }

    public DbSet<PersistedGrant> PersistedGrants { get; set; }
    public DbSet<DeviceFlowCodes> DeviceFlowCodes { get; set; }
    public DbSet<Client> Clients { get; set; }
    public DbSet<ClientCorsOrigin> ClientCorsOrigins { get; set; }
    public DbSet<IdentityResource> IdentityResources { get; set; }
    public DbSet<ApiResource> ApiResources { get; set; }
    public DbSet<ApiScope> ApiScopes { get; set; }

    public Task<int> SaveChangesAsync() => base.SaveChangesAsync();
}

Also, note that the CustomUser and CustomRole are to Inherit from IdentityUser and IdentityRole respectively.

I hope this helps someone else.

I think that the easiest way to do it is to use the parameter T of ConfigurationDbContext as below. It works for me on net core 3.0

public class ConfigurationDataContext : ConfigurationDbContext<ConfigurationDataContext>
{
    public ConfigurationDataContext(DbContextOptions<ConfigurationDataContext> options, ConfigurationStoreOptions storeOptions)
    : base(options, storeOptions)
    {
    }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        builder.ApplyConfigurationsFromAssembly(typeof(MyConfigurationsAssemby).Assembly);
    }
}

I used your solution with a little change. I am attaching below the code. in your test method OnModelCreating you declare two methods

...
modelBuilder.ConfigureClientContext(configurationStoreOptions);
modelBuilder.ConfigureResourcesContext(configurationStoreOptions);

modelBuilder.ConfigurePersistedGrantContext(operationalStoreOptions); // need to add

that refer to PersistedGrants and DeviceFlowCodes, this is good, but you need to add

ConfigurePersistedGrantContext also.

here too there is info👍

public class MYCustomDbContext : DbContext, IPersistedGrantDbContext, IConfigurationDbContext


public DbSet<PersistedGrant> PersistedGrants { get; set; }

public DbSet<DeviceFlowCodes> DeviceFlowCodes { get; set; }

........

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder);

    if (modelBuilder is null)
       throw new ArgumentNullException(nameof(modelBuilder));

    ConfigurationStoreOptions storeConfigurationOptions = new ConfigurationStoreOptions();
    OperationalStoreOptions storeOperationalOptions = new OperationalStoreOptions();

    modelBuilder.ConfigureClientContext(configurationStoreOptions);
    modelBuilder.ConfigureResourcesContext(configurationStoreOptions);
    modelBuilder.ConfigurePersistedGrantContext(operationalStoreOptions);
}

Task<int> IPersistedGrantDbContext.SaveChangesAsync() => base.SaveChangesAsync();

public Task<int> SaveChangesAsync() => base.SaveChangesAsync();

public void ConfigureServices(IServiceCollection services)
{
......
 services.AddOperationalStore<MYCustomDbContext>(options => {
                    // this enables automatic token cleanup.
                    options.EnableTokenCleanup = true;
                    options.TokenCleanupInterval = 3600; }
.....
}

I made this with the last version of IdentityServer4.EntityFramework (4.1.2):

I created a class called ApplicationConfigurationDbContext inherit from ConfigurationDbContext<TContext>, where TContext is my class

public class ApplicationConfigurationDbContext : ConfigurationDbContext<ApplicationConfigurationDbContext>
{
    public ApplicationConfigurationDbContext(DbContextOptions<ApplicationConfigurationDbContext> options, ConfigurationStoreOptions storeOptions) : base(options, storeOptions)
    {

    }

    // My own entities...

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        // My own configurations...
    }
}

Then in Startup class I registered my DbContext and finally after calling AddIdentityServer() extension method I chained AddConfigurationStore() extension method too, that's it!.

public class Startup
{
    // Hide for brevity

    public void ConfigureServices(IServiceCollection services)
    {
        var builder = services.AddIdentityServer(options =>
        {
            // My options...
        })
        .AddConfigurationStore<ApplicationConfigurationDbContext>(options =>
        {
            options.ConfigureDbContext = b => b.UseSqlServer(connectionString,
                sql => sql.MigrationsAssembly(migrationsAssembly));
        })
        .AddAspNetIdentity<ApplicationUser>();
    }
}

When I wish to add a migration I do this:

dotnet ef migrations add "Add_New_Table" --context "ApplicationConfigurationDbContext" --startup-project "My.Start.Project" --project "Target.Project" --output-dir "Migrations/ConfigurationDb"

More information about Entity Framework Core tools via .NET CLI here.