A package connecting Entity Framework Core data to EfVueCrust
What this project aims to do, ideally, is allow data models from .net applications to be understood and interacted with by Vue3 applications.
If you're finding this already somehow, please know this is a very incomplete restart of a thing I've rebuilt a couple of times, this will hopefully be a clean, clear, trimmed down version of that system. If this message is here, consider it an Alpha version
Define your models as you do today, using EfVueMantle.ModelBase as your base class. (see caveats)
Mantle provides bases for model, controller, and service for each data type. This scaffolds the basic functionality allowing Crust to explore data via convention. It also crafts Javascript class files for Crust, allowing your Vue3 application to understand your entire data structure.
Get it on GitHub or npm install ef-vue-crust
Provides interfaces for Vue3 to interact with your defined data models via convention.
Creates a virtual "Database" that holds onto records, remembers query results and sort orders, and generally lets you worry about presentation instead of how to transfer data back and forth.
Traverse properties in your Vue3 components with dot notation object accessors, and let ef-vue-crust worry about asyncronous data loading.
(Core, Mantle, Crust, get it? Great. Naming things is hard.)
These generic methods are understood and automatically sought by ef-vue-crust.
Implemented
Implemented (case-insensitive exact match, case-insensitive string-include match)
Implemented (descending and ascending)
Implemented
Implemented
Implemented
Implemented
Not implemented
Not implemented
You'll need to call the ExportDataObjects method, with a path to wherever you want the exported JS to live. I suggest a directory in your VueProject/src folder named something snazzy and original like "data". It will create sub-directories for models and enums as necessary.
This will automatically pick up any models using EfVueMantle.ModelBase as a base class, and any enums used in their properties.
I just drop this in my Program.cs:
if (_hostingEnvironment.IsDevelopment())
{
ModelExport.ExportDataObjects("../../your-vue-project/src/data");
}
If you need to add any custom data types, create the hypen-cased.js file for the class in a directory named "data-types". Then decorate your property like so:
[EfVuePropertyType("SomeType")]
This will add an include for your custom data-type definition SomeType, looking for /path/to/your/data/data-type/some-type.js
The ModelBase class contains only three properties - Id, Created, and Updated. It's mostly necessary so that the other base classes can rely on the Id property, and so the exporter knows which models to roll out.
public class AccountModel : ModelBase{
//Properties to your heart's desire.
}
You will need to manually define FKs at the moment... hopefully that won't remain a thing.
public int UserId { get; set; }
[ForeignKey("UserId")]
public UserModel User { get; set; }
If you have a many-to- relationship, you'll need a property for the list of the keys in your model. Be sure to mark it as [NotMapped].
[NotMapped]
public List<int> CommentsIds { get; set; }
public List<CommentModel> Comments { get; set; } = new();
And you'll need to define the relationship using WithProjection in your dbcontext:
builder.Entity<DiscussionModel>()
.HasMany(x => x.Comments);
builder.Entity<DiscussionModel>()
.WithProjection(
x => x.CommentsIds,
x => x.Comments.Where(y => y.ParentCommentId == null).Select(y => y.Id).ToList()
);
There are many custom decorators, and some native ones will be recognized as well. TODO many of which are vestigial, and need to be cleaned up
TODO also need to document them all
If the [JsonIgnore] decorator is used, the model export will ignore that property.
-
The .net-> js translator currently requires that you manually define the ForeignKeys for 1-1 relationships in your models. Not a huge thing but a bit annoying. This can hopefully be overcome later
-
Although Crust supports guid PKs/ids (untested) this package defaults ids to ints. It's not a priority for me at this time, but the intent is for GUID ids to be supported
Do your controllers as usual, just use the EfVueMantle.ControllerBase class as your base.
public class CommentController : ControllerBase<CommentModel, CommentService>
{
public CommentController(CommentService commentService) : base(commentService)
{
}
}
This adds the default endpoints needed for Crust to get the data it wants, and you don't have to do anything else unless you need custom functionality.
All base controller methods are virtual, so override if you need more complex functionality.
Just like Models and Controllers, use ServiceBase to add a service with all the basic functionality needed already set up.
public class CommentService : ServiceBase<CommentModel>
{
public CommentService(YourDbContext context) : base(context.Comments, context)
{
}
}
Once again, that's all you need. Override the base methods as needed and expand the service as you like.
At some point we'll have open socket data alerts sent to your local Crust databases, allowing live updates on a per-entity basis.