Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:122124
MIME-Version: 1.0
References: <CADU7aovcatZ++PSg0Pt0-kXJH9Oe09N0jy5uXEoBYoRv6GeUwQ@mail.gmail.com>
 <3828a559-5dae-44d1-96ce-dff1a8b07c18@gmail.com> <CAPzBOBOx25-muH8BuMFJAHJp=L8wT_M-W8G-kk6fsPb9Lv_T0A@mail.gmail.com>
 <DABECB67-A138-4184-8E24-8CC9ED4802C4@gmail.com> <CAPzBOBM0tYMfi5T9K4J3i-1yBg_n=ZyeziGoQBXTvGjXZEOsgg@mail.gmail.com>
 <99C434B3-3953-4E90-8DEA-94237332219D@gmail.com> <CAPzBOBPRGBOp36sgJf0BoTaZjbi3HT7TW-9eZpS7h9w+OORfyA@mail.gmail.com>
 <CABdc3Wp9fw_4bci6XSqFeWMNt4Z6aY0M+Vs8HhrgmWs5SMc=Mw@mail.gmail.com>
In-Reply-To: <CABdc3Wp9fw_4bci6XSqFeWMNt4Z6aY0M+Vs8HhrgmWs5SMc=Mw@mail.gmail.com>
Date: Fri, 5 Jan 2024 11:26:34 -0300
Message-ID: <CADK1yXKZf+FvJsCxZVerSc88UZj4Yt41GWeyku_8mncVshj76w@mail.gmail.com>
To: =?UTF-8?Q?Micha=C5=82_Marcin_Brzuchalski?= <michal.brzuchalski@gmail.com>
Cc: Robert Landers <landers.robert@gmail.com>, Rowan Tommins <rowan.collins@gmail.com>, 
	internals@lists.php.net
Content-Type: multipart/alternative; boundary="000000000000c6d085060e33a4af"
Subject: Re: [PHP-DEV] RFC proposal: worker mode primitives for SAPIs
From: deleugyn@gmail.com (Deleu)

--000000000000c6d085060e33a4af
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Fri, Jan 5, 2024 at 9:40=E2=80=AFAM Micha=C5=82 Marcin Brzuchalski <
michal.brzuchalski@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 al=
l.
>
> 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 =3D 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 =3D function (\Psr\Http\Message\RequestInterface
$request): \Psr\Http\Message\ResponseInterface {
    // Process Request
}

worker_http_psr7($httpMiddlewareHandler);
```

HTTP Raw
```
$httpHandler =3D function (\Psr\Http\Message\StreamInterface $raw):
\Psr\Http\Message\ResponseInterface {
    // Process Request
}

worker_http_raw($httpHandler);
```

STDIN
```
$stdinHandler =3D function (SomeStdinCompatibleType $stdin):
SomeStdoutCompatibleType {

}

worker_stdin($stdinHandler);
```

Websocket
```
$websocketHandler =3D 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.

--=20
Marco Deleu

--000000000000c6d085060e33a4af--