Couchbase’s new EF Core provider opens the door to some powerful .NET integrations: even ones traditionally tied to relational databases. This post walks through how Identity, GraphQL, and OData all work with Couchbase.
In this post, I’ll walk through three advanced EF Core integrations that I have successfully tested with Couchbase:
- ASP.NET Core Identity
- GraphQL (via Hot Chocolate)
- OData
Nota: These integrations are based on limited testing and are not officially supported (yet). Your mileage may vary, but so far, they show a lot of promise.
ASP.NET Core Identity
Microsoft.AspNetCore.Identity.EntityFrameworkCore provides a plug-and-play authentication and user management system for ASP.NET apps.
Couchbase’s EF Core provider works well with it. The only caveat is that you’ll need to make sure the proper collections exist first (like AspNetUsers, AspNetRoles, etc).
Nota: You must create the following collections in advance: AspNetUsers, AspNetRoles, AspNetUserRoles, AspNetUserClaims, AspNetUserLogins, AspNetUserTokens, AspNetRoleClaims.
Example EF setup
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
público class AppDbContext : IdentityDbContext<ApplicationUser> { público AppDbContext(DbContextOptions<AppDbContext> Opções) : base(Opções) { } protected override vazio OnModelCreating(ModelBuilder builder) { base.OnModelCreating(builder); builder.Entity<ApplicationUser>().ToCouchbaseCollection(this, “AspNetUsers”); builder.Entity<IdentityRole>().ToCouchbaseCollection(this, “AspNetRoles”); builder.Entity<IdentityUserRole<string>>().ToCouchbaseCollection(this, “AspNetUserRoles”); builder.Entity<IdentityUserClaim<string>>().ToCouchbaseCollection(this, “AspNetUserClaims”); builder.Entity<IdentityUserLogin<string>>().ToCouchbaseCollection(this, “AspNetUserLogins”); builder.Entity<IdentityUserToken<string>>().ToCouchbaseCollection(this, “AspNetUserTokens”); builder.Entity<IdentityRoleClaim<string>>().ToCouchbaseCollection(this, “AspNetRoleClaims”); } } público class ApplicationUser : IdentityUser { } |
MVC auth example
Here’s an ASP.NET Core MVC controller with registration, login, and logout, as well as a custom role:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
público class AuthController : Controller { private readonly UserManager<ApplicationUser> _userManager; private readonly SignInManager<ApplicationUser> _signInManager; private readonly RoleManager<IdentityRole> _roleManager; público AuthController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager, RoleManager<IdentityRole> roleManager) { _userManager = userManager; _signInManager = signInManager; _roleManager = roleManager; } público IActionResult Register() => View(); [HttpPost] público assíncrono Task<IActionResult> Register(RegisterModel modelo) { if (!ModelState.IsValid) retornar View(modelo); var user = novo ApplicationUser { UserName = modelo.Email, Email = modelo.Email }; var result = await _userManager.CreateAsync(user, modelo.Password); if (result.Succeeded) { var roleName = “CustomRole”; if (!await _roleManager.RoleExistsAsync(roleName)) await _roleManager.CreateAsync(novo IdentityRole(roleName)); await _userManager.AddToRoleAsync(user, roleName); await _signInManager.SignInAsync(user, isPersistent: false); retornar RedirectToAction(“Index”, “Home”); } foreach (var error in result.Errors) ModelState.AddModelError(“”, error.Description); retornar View(modelo); } público IActionResult Login() => View(); [HttpPost] público assíncrono Task<IActionResult> Login(LoginModel modelo) { if (!ModelState.IsValid) retornar View(modelo); var result = await _signInManager.PasswordSignInAsync(modelo.Email, modelo.Password, false, false); if (result.Succeeded) retornar RedirectToAction(“Index”, “Home”); ModelState.AddModelError(“”, “Invalid login attempt.”); retornar View(modelo); } público assíncrono Task<IActionResult> Logout() { await _signInManager.SignOutAsync(); retornar RedirectToAction(“Index”, “Home”); } } |
The data follows the standard Identity structure, stored in a Couchbase document. For example, a document in AspNetUser collection:
GraphQL with Hot Chocolate
Hot Chocolate is a popular GraphQL server for .NET. It can integrate with EF Core, leaning on the LINQ capabilities of the provider (which Couchbase has). This means that GraphQL queries are translated to LINQ, which is then translated to Couchbase SQL++.
Setup
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
público class WidgetQuery { [UseFiltering] [UseSorting] público IQueryable<Widget> GetWidgets([Service] WidgetDbContext dbContext) => dbContext.Widgets; } // Program.cs: builder.Serviços .AddGraphQLServer() .AddQueryType<WidgetQuery>() .AddFiltering() .AddSorting() .AddProjections(); app.MapGraphQL(); |
Example usage
- Go to /graphql in browser (this brings up a web interface)
- Try a query like this:
|
1 2 3 4 5 6 7 8 9 |
consulta { widgets(where: { nome: { contains: “foo” } }, order: { createdDt: DESC }) { identidade nome preço numInStock createdDt } } |
This will return results like:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
{ “data”: { “widgets”: [ { “id”: “b5c494fe-135f-4f01-bf12-6e4ad1eee829”, “nome”: “foobar”, “price”: 1.99, “numInStock”: 50, “createdDt”: “2025-06-18T18:11:19.149Z” } ] } } |
Tips
- GraphQL queries need to match your GSI indexes (it’s just SQL++ queries under the hood).
- You can use cover indexes and other SQL++ indexes to improve performance.
OData
Microsoft.AspNetCore.OData exposes your EF Core data as OData endpoints, making it easy to connect tools like Excel, Power BI, and Tableau to Couchbase.
Sample program.cs
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
builder.Serviços.AddControllersWithViews() .AddOData(opt => { var odataBuilder = novo ODataConventionModelBuilder(); odataBuilder.EntitySet<Widget>(“Widgets”); opt.AddRouteComponents(“odata”, odataBuilder.GetEdmModel()) .Filter() .OrderBy() .Select() .Expand() .Count() .SetMaxTop(100); }); |
Controller
|
1 2 3 |
[HttpGet(“/odata/Widgets”)] [EnableQuery] público IQueryable<Widget> GetOData() => _context.Widgets; |
Example OData queries
- https://localhost:7037/odata/Widgets?$filter=price gt 1&$orderby=name
- https://localhost:7037/odata/Widgets?$select=name,price&$top=10
Nota: Make sure your EF Core LINQ queries can be translated to SQL++ and that any filtered/sorted fields are indexed in Couchbase.
Wrapping up
All of these integrations are backed by EF Core—and now, with Couchbase support, you can take full advantage of them in your code. Whether you’re building secure web applications, GraphQL APIs or integrating with BI tools, The EF Core and Couchbase combo makes it possible.
Curious to see more? Let us know what integrations you’d like to explore next!
Deixe um comentário
Você precisa fazer o login para publicar um comentário.