On Fri, Jan 5, 2024 at 9:40 AM Michał Marcin Brzuchalski < michal.brzuchal...@gmail.com> wrote:
> There are indeed dozens of libraries already working with PSR nicely but > IMHO > the API should provide all the necessary information in a way that allows > the construction of such objects, > but suggesting PSR with request/response objects will limit the > capabilities of worker mode API > to handle pure HTTP protocol only. > > What I'd like to say is that I believe for the initial proposal of any > eventual worker mode API > with the PSR with request/response objects should not be considered at all. > > Cheers > I think it's been mentioned quite a few times that it doesn't matter what gets passed to the callable function that hands over control to userland, as long as it's more functional-style and not superglobals. I also think that there's merit in both sides of the conversation between PSR-7 vs associative arrays, but I find it more important to get one of them, any of them and not halt for one or the other. PSR would make it HTTP-only, yes, but that largely benefits the PHP ecosystem to an extent order of magnitude larger than any non-HTTP format. On the other hand, being a dynamically typed language, nothing holds us from having a more simple/generic `function handler(mixed $event)` format which can also be used to process HTTP and non-HTTP events. I do prefer the more generic one as I would be interested in seeing what PHP would become with the capability of processing non-HTTP protocols made easier. That being said, I find it important to consider the quality of such an API for its users. It would end up forcing users to do the following: ``` function handler(mixed $event) { if (isset($event['_REQUEST'])) { // We are on HTTP Protocol } if (isset($event['...'])) { // This is a Websocket } } ``` If the original proposal is correct and/or my little understanding of this thread is somewhat in the right direction, it means that the introduction of a PHP function that asks its engine for the next event to process isn't a huge amount of work on PHP Internals. If that's true, I would ask that we consider making something more flexible / forgiving of errors / adjustable and evolution-friendly. Instead of striving so much for coming up with one perfect API that shall be the one true API for PHP for the next decade, we can instead consider the possibility of having multiple small APIs that can harmonically coexist. Example: Classic: ``` $classicHttpHandler = function (array $get, array $post, array $request, array $server, array $cookies): string|Stringable { // process incoming request in a somewhat backward-compatible friendly way return 'http response'; // Return the response similarly to how we used to `echo` it to the server. } worker_http_classic($classicHttpHandler); ``` PSR-7: ``` $httpMiddlewareHandler = function (\Psr\Http\Message\RequestInterface $request): \Psr\Http\Message\ResponseInterface { // Process Request } worker_http_psr7($httpMiddlewareHandler); ``` HTTP Raw ``` $httpHandler = function (\Psr\Http\Message\StreamInterface $raw): \Psr\Http\Message\ResponseInterface { // Process Request } worker_http_raw($httpHandler); ``` STDIN ``` $stdinHandler = function (SomeStdinCompatibleType $stdin): SomeStdoutCompatibleType { } worker_stdin($stdinHandler); ``` Websocket ``` $websocketHandler = function (string $event, mixed $data): ??? { // Process websocket incoming event } worker_websocket_event($httpHandler); ``` These APIs don't need to be ready on day one. They don't even need to be ready at all, actually. Each would end up being its own RFC. What makes the system a bit more. flexible is the api naming which follows the pattern PHP Engine Namespace (worker), Purpose Namespace (_http, _websocket, etc) and Variation Namespace (_classic, _psr7, _raw). For me personally one awesome last step would make this a PHP Class instead of procedural functions. That would be even better because we could use the Class namespace itself to version it and provide future changes without breaking what's been introduced already. -- Marco Deleu