Schemata.Authorization.Foundation 1.0.0-preview.24259.22

Schemata

Application Framework aims on modular business applications.

Quick Start

dotnet new web
dotnet add package --prerelease Schemata.Application.Complex.Targets

var builder = WebApplication.CreateBuilder(args)
                            .UseSchemata(schema => {
                                 schema.UseLogging();
                                 schema.UseDeveloperExceptionPage();

                                 schema.ConfigureServices(services => {
                                     services.AddTransient(typeof(IRepositoryAddAsyncAdvice<>), typeof(MyAdviceAddAsync<>));

                                     services.AddRepository(typeof(MyRepository<>))
                                             .UseEntityFrameworkCore<MyDbContext>((sp, options) => options.UseSqlServer(schema.Configuration.GetConnectionString("Default")));

                                     services.AddDistributedMemoryCache();
                                 });

                                 schema.UseForwardedHeaders();
                                 schema.UseHttps();
                                 schema.UseCookiePolicy();

                                 schema.UseSession();

                                 schema.UseCors();
                                 schema.UseRouting();
                                 schema.UseControllers();
                                 schema.UseJsonSerializer();

                                 schema.UseTenancy();
                                 schema.UseModular();

                                 schema.UseIdentity();
                                 schema.UseAuthorization(options => {
                                            options.AddEphemeralEncryptionKey()
                                                   .AddEphemeralSigningKey();
                                        })
                                       .UseCodeFlow()
                                       .UseRefreshTokenFlow()
                                       .UseDeviceFlow()
                                       .UseIntrospection()
                                       .UseCaching();
                                 schema.UseWorkflow();

                                 // You can also utilize UseAutoMapper() once you've incorporated the Schemata.Mapping.AutoMapper package into your project.
                                 schema.UseMapster()
                                       .Map<Source, Destination>(map => {
                                            map.For(d => d.DisplayName).From(s => s.Name);
                                            map.For(d => d.Age).From(s => s.Age).Ignore((s, d) => s.Age < 18);
                                            map.For(d => d.Grade).Ignore()
                                               .For(d => d.Sex).From(s => s.Sex.ToString());
                                        });

                                 schema.UseResource()
                                       .MapHttp()
                             });

var app = builder.Build();

app.Run();

Fields

• DSL
• Modular
• Audit
• Authorization
• Datasource
• Event
• Identity
• Mapping
• Task
• Tenant
• Validation
• Workflow

Features

Features are modular components that can be integrated during the application startup process.

Each feature must implement the ISimpleFeature interface.

Features are characterized by Order and Priority, both of which are Int32 values. The Order determines the sequence in which the ConfigureServices methods are invoked. The Priority establishes the sequence for invoking the Configure<Application|Endpoints> methods.

The range [100_000_000, 1_000_000_000) and (2_147_000_000, 2_147_400_000] for Order and Priority is reserved for built-in features and Schemata extensions.

Built-in Features

A built-in feature can be activated by calling the UseXXX method on the SchemataBuilder instance. These features may also have additional configuration methods.

Extension Features

An extension feature can be activated in the same way as a built-in feature.

Compliance

Schemata is designed to comply with .NET Standard 2.0, .NET Standard 2.1, and the two most recent .NET Long-Term Support (LTS) versions, which are .NET 6.0 and .NET 8.0 at the time of writing.

Some packages may have additional compliance requirements, which are documented below.

Package	Compliance
Schemata.DSL
Schemata.Core
Schemata.Modular
Schemata.Authorization.Foundation
Schemata.Identity.Foundation
Schemata.Mapping.Foundation
Schemata.Resource.Foundation
Schemata.Tenancy.Foundation
Schemata.Workflow.Foundation

Schemata.Authorization.Foundation

Schemata Authorization Foundation is designed to comply with the OpenID Connect Core 1.0 specification.

Schemata.Identity.Foundation

Schemata Identity Foundation is designed to comply with Asp.Net Core Identity.

Additionally, we bring the Bearer Token Authentication Scheme and Core Identity API to platforms that do not support it.

Schemata.Mapping.Foundation

The Schemata Mapping Foundation is designed to be compatible with various mapping libraries, including AutoMapper and Mapster, among others.

It provides a unified interface for these libraries, enabling developers to switch between them without modifying their code.

Schemata.Resource.Foundation

The Schemata Resource Foundation is designed to comply with the API Improvement Proposals - General AIPs proposals.

Schemata.Workflow.Foundation

Unfortunately, the Schemata Workflow Foundation is not yet compliant with enterprise standards such as BPMN 2.0.