ModularSystem.Core 1.29.4

ModularSystem Core (under development)

Build a solid basic CRUD within minutes

A library that takes care of the basic and boring stuff about creating web servers. The Modular System seeks to create a simple and modular way to automate the repetitive aspects of creating a regular web application.

Overview

This library is a group of usefull classes for daily delevopment, the goal is to always use the same code abstraction of a concept or idea, that way two diferent servers can communicate without using much, or any, specific adaptation layer. The interface exposed by one server can be parsed and understood without the need to map, type and adapt the data from the output, and that is only possible to do having a stable API model to use, that is what ModularSystem does. The 'Modular' comes from the idea to create specific modules to add functionalities to the application based on this stable interface model; the core library has some modules to add aditional features and code resusability.

CRUD

• Create and insert into database a new instance of a class
• Get one document by ID or or many by search with filters
• Update one document or many with one or multiple updates
• Delete one document by ID

Generic Typing

The entity interface works with a generic type T where T inherts from a base class, that way the library can apply the dynamic CRUD to any class. Some methods are required to be implemented or overriten, that is where the application specific logic can be wired, such as validation and presentation.

Entity Interface

The entity interface is the CRUD foundation, it contains references to the validation logic and data access layer interface. It wires everything together to create the methods exposed by the entity.

• To start you need to create the data structure that will be the entity model. It is important that this model implements the IQueryableBase interface. You can extend the model from QueryableBase to auto implement everything.

Example:

using ModularSystem.Core;

class User : QueryableBase
{
    public string Email { get; set; }
    public string Password { get; set; }
}

The IQueryableBase interface adds properties and methods that are used by the rest of the library, so don't forget to do that. Keep in mind that you can override almost everything and set the behaviour yourself.

• A presented type for this model is also required, this presented type is what the library will use as I/O models to define the adapter layer.

Example:

//...
class PresentedUser 
{
    public string Email { get; set; }
}

Now you are all set to create the entity for this model.

• The entity class must implement the IEntity<T> interface. The easy way is to extend from Entity<T> and implement the abstract interface.

Example:

using ModularSystem.Core;

class UserEntity : Entity<User>
{
    // ...
}

The entity requires, at least, the implementation of two interfaces and returning them from methods in the child class.

using ModularSystem.Core;

class UserEntity : Entity<User>
{
    protected IDAO<T> dao;
    protected IValidator<T> validator;
    
    public UserEntity()
    {
        dao = new UserDao();
        validator = new UserValidator();
    }
    
    public override IDAO<T> GetDAO() => dao;
    public override IValidator<T> GetValidator() => validator;
}

Data Access Object Interface (IDAO)

The IDAO interface is the part of the app where the code to access the database lives. It is all defined in a very abstract way, this is how entity interfaces with the I/O for a given resource.

Example:

using ModularSystem.Core;

public class UserDao : IDAO<User>
{
    // ...
}

The interface itself is really simple, implementing it is the real effort but, it will be done only once. The library ships with a MongoDB implementation of DAO, but you can write your own implementations like a PostgreDao class or a MySqlDao and so on.

public class UserDao : MongoDAO<User> 
{
    public UserDao(IMongoCollection<T> collection) : base(collection) 
    {
        // ...
    }
}

The IValidator<T> interface

The part of the app where you define the data validation for a given data structure. The validator defines a validation method that should throw exceptions in case the data is in an invalid state.

Example:

public class UserValdiator : IValidator<User> 
{
    // ...
}

Wiring it all together

Now that the entity has the implementations from those interfaces, it can be used by the another layer to create use cases. The entity enables writing clean code to define the desired behaviour.

public class MyUseCase 
{
    public void DoSomeStuff()
    {
        var entity = new UserEntity();
        var user = new User();
        var task = entity.CreateAsync(user);
    }
    
    public void DoSomeMoreStuff()
    {
        var entity = new UserEntity();
        var context = RequestContext.System();
        var request = new SearchRequest(context);
        var filter = new SomeFilter();
        request.AddFilter(filter);
        var task<IQueryList<User>> = entity.SearchAsync(request);
    }
}

You can create a basic crud ot of an entity implementation using the ApiController base class

the full namespace is ModularSystem.Web.ApiController, and it must implemente an bastract interface. The presented type here is the defined API for the app, generating GET, POST, PUT and DELETE methods for the resource.

ApiController<InnerType, OutterType> IAdapter<InnerType, OutterType>

The adapter work the same way, but you can adapt anything and have as many adapters as you like in the pipeline.

[Route("api/user")]
[ApiController]
public class UserController : ApiController<User, PresentedUser> 
{
    protected IEntity<User> entity;
    protected IAdapter<User, PresentedUser> adapter;
    
    public UserController(IAppContext appContext) : base(appContext.EnvToString())
    {
        entity = new UserEntity();
        adapter = new UserAdapter();
    }
    
    protected abstract IEntity<T> GetEntity() => entity;
    protected abstract IAdapter<T, PresentedT> GetAdapter() => adapter;
}

Define the adapter layer using the Adapter<TIn, TOut> class.

public class UserAdapter : Adapter<User, PresentedUser> 
{
    // TODO...
}

WORK IN PROGRESS ...