ModularSystem.Core 1.35.1

ModularSystem Core (Under Development)

Build a Solid Basic CRUD Within Minutes

This library streamlines the foundational tasks of setting up web servers. ModularSystem aims to automate repetitive aspects of web application development in a modular and simple manner.

Overview

ModularSystem provides a collection of useful classes for daily development tasks. The core philosophy is to maintain a stable API model to facilitate communication between different servers without requiring specific adaptation layers. This enables parsing and understanding the interface exposed by a server without data mapping, typing, or adaptation. The term 'Modular' reflects the system's extensibility, allowing developers to add modules to enhance functionality and promote code reuse.

CRUD Operations

The library offers complete CRUD (Create, Read, Update, Delete) operations, featuring a well-defined query mechanism based on Expression trees.

Generics

The entity interface employs a generic type T, which inherits from a base class. This design allows the library to apply dynamic CRUD operations to any class. Developers will need to implement or override specific methods, where application-specific logic like validation and presentation can be added.

Entity Interface

The Entity Interface serves as the foundation for CRUD operations. It consolidates validation logic, data access layers, and much more to expose methods through the entity.

Getting Started

• To begin, create the data structure for the entity model. This model should implement the IQueryableModel interface. Extend from QueryableBase to automatically implement all required methods.

  using ModularSystem.Core;
  
  class User : QueryableModel
  {
      public string Email { get; set; }
      public string Password { get; set; }
  }
  
  
  

• Implement the IEntity<T> interface in the entity class. One approach is to extend from Entity<T> and implement the abstract methods.

  using ModularSystem.Core;
  
  class UserEntity : Entity<User>
  {
      // ...
  }
  
  

The raw entity class requires implementation of certain methods and properties:

• Example:

  using ModularSystem.Core;
  
  class UserEntity : Entity<User>
  {
      protected IDataAccessObject<User> DataAccessObject { get; }
  
      public UserEntity()
      {
          //...
      }
  
      protected override MemberExpression CreateIdSelectorExpression  (ParameterExpression parameter)
      {
          //...
      }
  
      protected override object? TryParseId(string id)
      {
          //...
      }
  }
  
  

• The library also provides an Entity Framework implementation, with additional modules offering other implementations.

  using ModularSystem.Core;
  
  class UserEntity : EFEntity<User>
  {
      protected IDataAccessObject<User> DataAccessObject { get; }
  
      public UserEntity()
      {
          //...
      }
  }
  

Data Access Object Interface (IDAO)

The IDataAccessObject interface houses the code for database access, serving as the entity's I/O interface for a given resource. The core library includes embedded implementations like EFCoreDataAccessObject.

using ModularSystem.Core;

class UserEntity : EFEntity<User>
{
    protected IDataAccessObject<User> DataAccessObject { get; }

    public UserEntity()
    {
        DataAccessObject = new EFCoreDataAccessObject<User>(new MyDbContext());
    }
}

IValidator<T> Interface

Here you define data validation rules for specific data structures. Implement a validation method to return or throw exceptions if the data is in an invalid state.

public class UserValidator : IValidator<User>
{
    public Task<Exception?> ValidateAsync(User instance)
    {
        //...
    }
}

class UserEntity : EFEntity<User>
{
    protected IDataAccessObject<User> DataAccessObject { get; }

    public UserEntity()
    {
        DataAccessObject = new EFCoreDataAccessObject<User>(new MyDbContext());
        Validator = new UserValidator();
    }
}

Wiring it All Together

Entities can be utilized by other layers to create use cases, thus enabling clean and desired code behavior.

public class MyUseCase
{
    public async Task DoSomeStuff()
    {
        var entity = new UserEntity();
        var user = new User();
        var id = await entity.CreateAsync(user);
    }

    public async Task DoSomeMoreStuff()
    {
        var entity = new UserEntity();
        var query = new Query<User>().SetFilter(x => x.Email == "foo@bar.baz");
        var queryResult = await entity.SearchAsync(query);
    }
}

API Controller

Create a basic CRUD API with the ApiController base class, which generates GET, POST, PUT, and DELETE endpoints.

[Route("api/user")]
public class UserController : CrudController<User>
{
    protected override IEntity<User> Entity { get; }

    public UserController() : base()
    {
        Entity = new UserEntity();
    }
}

WORK IN PROGRESS...