git clone https://github.com/exilon/QuickCore
git clone https://github.com/exilon/QuickLib
git clone https://github.com/exilon/QuickLogger

program HelloWorld;
{$APPTYPE CONSOLE}
uses Quick.Core.Mvc, Startup in 'Startup.pas';
var Server : TMvcServer;
begin
  Server := TMvcServer.Create('127.0.0.1', 8080, False);
  Server.UseStartup<TStartup>;
  Server.Start;
  Readln;
  Server.Free;
end.

unit Startup;
interface
uses Quick.Core.Mvc, Quick.Core.DependencyInjection, Controller.Home;
type
  TStartup = class(TStartupMvc)
  public
    class procedure ConfigureServices(services : TServiceCollection); override;
    class procedure Configure(app : TMVCServer); override;
  end;
implementation
class procedure TStartup.ConfigureServices(services : TServiceCollection);
begin
  services.AddLogging(TLoggerBuilder.GetBuilder.AddConsole.Build);
end;
class procedure TStartup.Configure(app : TMVCServer);
begin
  app.AddControllers.AddController(THomeController).UseRouting.UseMVC;
end;
end.

unit Controller.Home;
interface
uses Quick.Core.Mvc.Controller, Quick.Core.Mvc.ActionResult;
type
  [Route('api')]
  [ApiController]
  THomeController = class(THttpController)
  published
    [HttpGet('hello')]
    function Hello : IActionResult;
  end;
implementation
function THomeController.Hello: IActionResult;
begin
  Result := Json('{"message":"Hello, World!"}');
end;
initialization
  RegisterController(THomeController);
end.

GET http://localhost:8080/api/hello
??? {"message":"Hello, World!"}

// Singleton — same instance for the whole app lifetime
services.AddSingleton<IMyService, TMyService>;

// Transient — new instance on every resolution
services.AddTransient<IMyService, TMyService>;

// Scoped — one instance per request scope
services.AddScoped<IMyService, TMyService>;

services.AddSingleton<IMyService, TMyService>('',
  function : TMyService
  begin
    Result := TMyService.Create('some-param');
  end);

services.AddSingleton<ICache, TRedisCache>('redis');
services.AddSingleton<ICache, TMemoryCache>('memory');

// Resolve by name
var cache := provider.GetService<ICache>('redis');

// Inject by name in a controller action parameter
function MyAction([FromKeyedServices('redis')] cache : ICache) : IActionResult;

// Register with defaults
services.Configure<TSmtpOptions>(procedure(o : TSmtpOptions)
begin
  o.Host := 'localhost';
  o.Port := 25;
end);

// Inject
constructor TMailService.Create(opts : IOptions<TSmtpOptions>);
begin
  fHost := opts.Value.Host;
end;

services
  .AddOptions(TOptionsFileFormat.ofYAML, True)
  .Configure<TAppSettings>(procedure(o : TAppSettings)
    begin
      o.Smtp   := 'mail.domain.com';
      o.ApiUrl := 'https://api.example.com';
    end);

[Table('products')]
TProduct = class(TEntity)
private
  FId    : TAutoID;
  FName  : string;
  FPrice : Double;
public
  [Key]
  property Id    : TAutoID read FId    write FId;
  property Name  : string  read FName  write FName;
  property Price : Double  read FPrice write FPrice;
end;

TShopContext = class(TDBContext)
private
  FProducts : TDBSet<TProduct>;
public
  property Products : TDBSet<TProduct> read FProducts write FProducts;
  constructor Create(aConn : TDBConnectionModel); override;
end;

services.Extension<TEntityServiceExtension>
  .AddDBContext<TShopContext>(procedure(o : TDBContextOptionsBuilder)
    begin
      o.UseSQLite.UseDatabase('shop.db');
    end);

// Inject context
constructor TProductsController.Create(ctx : TShopContext);

// Add
ctx.Products.Add(product);

// Query
var list := ctx.Products.Where('Price < ?', [100.0]).OrderBy('Name').Select;

// Update / Delete
ctx.Products.Update(product);
ctx.Products.Delete(product);

type
  TAddCategoryMigration = class(TMigration)
  public
    procedure Up; override;
    procedure Down; override;
  end;

procedure TAddCategoryMigration.Up;
begin
  ExecuteSQL('ALTER TABLE products ADD COLUMN Category VARCHAR(100)');
end;

// IRepository<T> is included — register via factory
services.AddScoped<IRepository<TProduct>, TEntityRepository<TProduct>>('',
  function : TEntityRepository<TProduct>
  begin
    Result := TEntityRepository<TProduct>.Create(
      services.Resolve<TShopContext>.Products, 'Id');
  end);

ctx.Database.BeginTransaction;
try
  ctx.Orders.Add(order);
  ctx.OrderItems.Add(item);
  ctx.Database.CommitTransaction;
except
  ctx.Database.RollbackTransaction;
  raise;
end;

// Soft delete — inherit from TEntitySD; deleted rows are filtered automatically
[SoftDelete]
TPost = class(TEntitySD) ...

// Optimistic concurrency — inherit from TEntityRV; conflict raises EOptimisticConcurrencyException
TProduct = class(TEntityRV) ...

[Route('api/products')]
[ApiController]
TProductsController = class(THttpController)
published
  [HttpGet]
  function List : IActionResult;

  [HttpGet('{id}')]
  function GetById(id : Integer) : IActionResult;

  [HttpPost]
  function Create([FromBody] product : TProduct) : IActionResult;

  [HttpPut('{id}')]
  function Update(id : Integer; [FromBody] product : TProduct) : IActionResult;

  [HttpDelete('{id}')]
  function Delete(id : Integer) : IActionResult;
end;

TCreateProductDto = class
  [Required]
  [StringLength(100)]
  property Name  : string read ... write ...;

  [Range(0.01, 1000000)]
  property Price : Double read ... write ...;
end;
// Validation is automatic — returns HTTP 400 + JSON errors on failure

Result := Ok;                          // 200
Result := Json(obj);                   // 200 + serialized JSON
Result := StatusCode(201, '...');      // custom status
Result := BadRequest('invalid input'); // 400
Result := NotFound;                    // 404
Result := Unauthorized;               // 401
Result := Redirect('https://...');    // 302
Result := View('home');               // render Mustache view

app
  .UseExceptionHandler              // global 500 handler
  .UseCors(procedure(o : TCorsPolicyOptions) begin
      o.AllowAnyOrigin.AllowAnyMethod.AllowAnyHeader;
    end)
  .UseRateLimiting(100, 60)         // 100 req / 60 s
  .UseResponseCompression
  .UseAuthentication
  .UseAuthorization
  .UseSession
  .UseSwagger                       // /swagger + /swagger/v1/swagger.json
  .UseStaticFiles
  .UseRouting
  .UseMVC;

app.UseSwagger;
// Browse: http://localhost:8080/swagger

[SwaggerOperation('List all products')]
[ProducesResponseType(200)]
[ProducesResponseType(401)]
function List : IActionResult;

server.MapGet('/ping', function(ctx : THttpContext) : string
  begin
    Result := '{"pong":true}';
  end);

services.Extension<TAuthenticationServiceExtension>
  .AddAuthentication
  .AddJwtBearer(procedure(o : TJwtOptions)
    begin
      o.Secret         := 'my-256-bit-secret';
      o.Issuer         := 'my-app';
      o.ExpiryMinutes  := 60;
    end);

app.UseAuthentication.UseAuthorization;

// Inject IJwtTokenService
var token := fJwt.GenerateToken(userId, username, ['Admin']);

services.Extension<TApiKeyAuthenticationServiceExtension>
  .AddApiKey
  .UseMemoryStore(procedure(o : TApiKeyMemoryStoreOptions)
    begin
      o.AddApiKey('Alice', 'Admin', 'secret-key-abc');
      o.AddApiKey('Bob',   'User',  'secret-key-xyz');
    end);

services.Extension<TAuthorizationServiceExtension>
  .AddAuthorization(procedure(o : TAuthorizationOptions)
    begin
      o.AddPolicy('AdminOnly',
        TAuthorizationPolicyBuilder.GetBuilder
          .RequireAuthenticatedUser
          .RequireClaim(TClaimTypes.Role, 'Admin')
          .Build);
    end);

// In controller
[Authorize]                         // any authenticated user
[Authorize(Policy='AdminOnly')]     // admin only
[AllowAnonymous]                    // bypass auth

services.Extension<TAuthenticationServiceExtension>
  .AddIdentity<TAppUser, TAppRole>(procedure(o : TIdentityOptions)
    begin
      o.Password.RequiredLength  := 8;
      o.User.RequireUniqueEmail  := True;
    end)
  .AddEntityStore<TIdentityContext>;

// Inject IUserManager<TUser, TRole>
fUserManager.CreateUser(user, password);
fUserManager.ValidateCredentials(username, password);
fUserManager.AddToRole(userId, 'Admin');

// Define a profile
constructor TMyProfile.Create;
begin
  CreateMap<TDBProduct, TProductDto>
    .ForMember('Name', 'FullName')   // rename property
    .ReverseMap;                     // also maps TProductDto → TDBProduct
end;

initialization
  TAutoMapper.RegisterProfile<TMyProfile>;

CreateMap<TDBProduct, TProductDto>
  .Condition('Price', function(src : TObject) : Boolean  // skip when condition false
    begin Result := (src as TDBProduct).Price > 0; end)
  .ConvertUsing('Category', function(v : TValue) : TValue  // transform value
    begin Result := TValue.From(v.AsString.ToUpper); end)
  .BeforeMap(procedure(src, dst : TObject) begin ... end)
  .AfterMap(procedure(src, dst : TObject)  begin ... end)
  .NullSubstitute('(none)')
  .IgnoreOtherMembers;

// Validate all maps at startup
TAutoMapper.AssertConfigurationIsValid;

constructor TController.Create(mapper : IMapper);
...
var dto := fMapper.Map<TProductDto>(dbProduct);

services.Extension<TMemoryCacheServiceExtension>.AddMemoryCache;

// Inject IMemoryCache
if not fCache.TryGetValue<TList<TProduct>>('products', list) then
begin
  list := GetFromDB;
  fCache.SetValue<TList<TProduct>>('products', list, 60); // TTL 60 s
end;

services.Extension<TRedisCacheServiceExtension>
  .AddRedisCache(procedure(o : TRedisCacheOptions)
    begin
      o.Host     := 'localhost';
      o.Port     := 6379;
      o.DataBase := 0;
    end);

services.Extension<TLocalizationServiceExtension>
  .AddLocalization(procedure(o : TLocalizationOptions)
    begin
      o.AddCulture('en');
      o.AddCulture('es');
      o.AddCulture('fr');
      o.AddIfNotfound := True;
    end);

// Inject IStringLocalization — culture selected from Accept-Language header
var msg := fL10n.GetItemFmt('greeting', [userName]);

locales/en.lng   ???  greeting=Hello, %s!
locales/es.lng   ???  greeting=??Hola, %s!
locales/fr.lng   ???  greeting=Bonjour, %s!

type
  TMyWorker = class(TBackgroundService)
  protected
    procedure Execute; override;
  end;

// Register
services.Extension<THostedServiceExtension>.AddHostedService<TMyWorker>;

services.Extension<TTaskControlServiceExtension>.AddTaskControl;

// After build — queue an ad-hoc task
fTaskControl.BackgroundTasks.QueueTask(procedure begin
  DoSomeWork;
end);

// Schedule a recurring task
fTaskControl.ScheduledTasks.AddTask('CleanUp')
  .RunEvery(3600000)  // every hour
  .OnExecute(procedure begin CleanOldRecords; end);

services
  .Extension<THealthChecksServiceExtension>
    .AddHealthChecks
    .AddUrlCheck('google', 'https://www.google.com', TTimeSpan.FromSeconds(5))
    .AddDBContextCheck<TShopContext>('db', TTimeSpan.FromSeconds(5))
    .AddMemoryCheck('memory', 512, TTimeSpan.FromSeconds(30))
    .AddInMemoryStorage;

app.Extension<THealthChecksUIMVCServerExtension>
  .UseHealthChecksUI;
// GET /health      → Xabaril-style summary JSON
// GET /health/live → liveness
// GET /healthui    → HTML dashboard

services.Extension<TMessageQueueServiceExtension>
  .AddRedisMessageQueue<TOrderProcessor>(procedure(o : TRedisMessageQueueOptions)
    begin
      o.Host                := 'localhost';
      o.Port                := 6379;
      o.Key                 := 'orders';
      o.MaxConsumersPool    := 3;
      o.ReliableMessageQueue.Enabled := True;
    end);

// Produce (inject IMessageQueue<TOrderMessage>)
fQueue.Enqueue(msg);

// Consume (TOrderProcessor extends TMessageQueueTask<TOrderMessage>)
procedure TOrderProcessor.ProcessMessage(aMessage : TOrderMessage);
begin
  // called automatically for each dequeued message
end;

tests/bin/Win64/Debug/QuickCore.Tests.exe