...

East Foundation

Créer des applications PHP en implémentant la philosophie #East programming.


Pour intégrer votre projet suivant le #East programming avec votre framework favori tout en gardant ce paradigme.

La bibliothèque implémente le pattern "Middleware" pour vous permettre de compléter son comportement, tel qu'ajouter des fonctionnalités, le support des sessions ou des traductions.

Cette bibliothèque est construite sur la bibliothèque "Recipe" et surchage uniquement certaines interfaces afin de correspondre au contexte HTTP.

  • Les Middlewares sont des actions, mais ils implémentent une interface spécifique.
  • Le workflow HTTP est définie via une "Recipe", capable d'être complétée.
  • Le Chef devient un "Manager" et exécute le workflow définie pour les requêtes HTTP.
  • Utilisable avec n'importe quel framework PSR-11 ou avec Symfony 4.4
...

To understand “east”, think of a map, like north, south, east, west; the idea, as far as I understand, is that west-oriented is stateful (you call methods and work on the return values), while east-oriented is stateless (you pass lambdas or interface implementations).

http://www.draconianoverlord.com/2013/04/12/east-oriented-programming.html

Fonctionnalités


East

Utiliser le #East programming avec votre framework préféré.

PSR-7

Interopérable avec tout code exploitant la recommandation PSR-7.

PSR-11

Interopérable avec tout framework utilisant la recommandation PSR-11.

Extendable

Grâce à Recipe, peut-être complété uniquement via la configuration de la DI.

GitHub


Fork le project sur GitHub

Il est sous licence open source! Il est hébergé, développé et maintenu sur GitHub par des contributeurs comme vous.


Voir le projet sur GitHub

Patreon


Supporter le projet sur Patreon

Ce projet est logiciel libre et le restera. Mais il est développé sur mon temps libre. Si vous l'appréciez et si vous souhaitez m'aider à le maintenir et à le faire évoluer. N'hésitez pas à me supporter sur Patreon. Merci :) Richard.


Supporter le projet

Exemple



<?php

declare(strict_types=1);

use 
Teknoo\East\Foundation\Router\ResultInterface;
use function 
DI\decorate;
use 
DI\ContainerBuilder;
use 
Laminas\Diactoros\ServerRequest;
use 
Laminas\Diactoros\Response\TextResponse;
use 
Psr\Http\Message\ResponseInterface;
use 
Psr\Http\Message\ServerRequestInterface;
use 
Teknoo\East\Foundation\Http\ClientInterface;
use 
Teknoo\East\Foundation\Manager\ManagerInterface;
use 
Teknoo\East\Foundation\Middleware\MiddlewareInterface;
use 
Teknoo\East\Foundation\Recipe\RecipeInterface;
use 
Teknoo\East\Foundation\Router\Result;
use 
Teknoo\East\Foundation\Router\RouterInterface;

require_once 
'vendor/autoload.php';

//Simulate client, accepts responses from controller and pass them to the "framework" or lower layer to send them to
//the browser.
$client = new class implements ClientInterface {
    private ?
ResponseInterface $response null;

    public function 
updateResponse(callable $modifier): ClientInterface
    
{
        
$modifier($this$this->response);

        return 
$this;
    }

    public function 
acceptResponse(ResponseInterface $response): ClientInterface
    
{
        
$this->response $response;

        return 
$this;
    }

    public function 
sendResponse(ResponseInterface $response null bool $silently false): ClientInterface
    
{
        if (
$response instanceof ResponseInterface) {
            
$this->acceptResponse($response);
        }

        print (string) 
$response->getBody().PHP_EOL;

        return 
$this;
    }

    public function 
errorInRequest(\Throwable $throwable): ClientInterface
    
{
        print 
$throwable->getMessage();

        return 
$this;
    }
};

//First controller / endpoint, dedicated for the request /foo
$endPoint1 = function (ServerRequestInterface $requestClientInterface $client) {
    
$client->sendResponse(new TextResponse('request /bar, endpoint 1, value : '.$request->getQueryParams()['value']));
};

//Second controller / endpoint, dedicated for the request /bar
$endPoint2 = function (ClientInterface $clientstring $value) {
    
$client->sendResponse(new TextResponse('request /bar, endpoint 2, value : '.$value));
};

/**
 * Simulate router
 */
$router = new class($endPoint1$endPoint2) implements RouterInterface {
    
/**
     * @var callable
     */
    
private $endPoint1;

    
/**
     * @var callable
     */
    
private $endPoint2;

    public function 
__construct(callable $endPoint1 , callable $endPoint2)
    {
        
$this->endPoint1 $endPoint1;
        
$this->endPoint2 $endPoint2;
    }

    public function 
execute(
        
ClientInterface $client ,
        
ServerRequestInterface $request ,
        
ManagerInterface $manager
    
): MiddlewareInterface
    
{
        
$result null;
        
$uri = (string) $request->getUri();
        switch (
$uri) {
            case 
'/foo':
                
$result = new Result($this->endPoint1);
                break;
            case 
'/bar':
                
$result = new Result($this->endPoint2);
                break;
        }

        
$manager->updateWorkPlan([ResultInterface::class => $result]);
        
$manager->continueExecution($client$request);

        return 
$this;
    }
};

$builder = new ContainerBuilder();
$builder->addDefinitions('src/universal/di.php');
$builder->addDefinitions([
    
RouterInterface::class => $router,

    
RecipeInterface::class => decorate(function ($previous) use ($router) {
        if (
$previous instanceof RecipeInterface) {
            
$previous $previous->registerMiddleware(
                
$router,
                
RouterInterface::MIDDLEWARE_PRIORITY
            
);
        }

        return 
$previous;
    })
]);

$container $builder->build();

//Simulate Server request reception
$request1 = new ServerRequest([], [], '/foo''GET');
$request1 $request1->withQueryParams(['value' => 'bar']);
$request2 = new ServerRequest([], [], '/bar''GET');
$request2 $request2->withQueryParams(['value' => 'foo']);

$manager $container->get(ManagerInterface::class);
$manager->receiveRequest($client$request1);
//Print: request /bar, endpoint 1, value : bar
$manager->receiveRequest($client$request2);
//Print: request /bar, endpoint 2, value : foo