Cloudflare

The resource you `fetch()`'d will be cached according to normal Cloudflare cache behaviour

If it's a Cloudflare customer, it'll be cached according to their rules

If they're not, it'll be cached under your zone and that behaviour can be controlled w/ some properties in the `cf` part of RequestInit

Does doing a `.tee()` on a response cause extra memory to be used if one reader is slower than the other?

I want to basically return the response, and cache it too

Hi, is there any way I can use remote mysql database with prisma in the worker?

The faster stream is back pressured to the speed of the slower

If you only read one branch then the other branch is buffered into memory - but you'd be warned about that in the logs.

hmm so I should probably do two fetch's then?

I've never had issues personally - the only thing of note is that if you're using waitUntil then the stream must be consumed within 30 seconds.

Now that's probably a confusing sentence, so I'll elaborate

if I do `const resp = await fetch(url);` and then `const [foo, bar] = resp.body.tee()` and then `ctx.waitUntil(env.R2.put(key, foo))` and `return new Response(bar)` - the response being streamed to the client must be completed in under 30 seconds, since `waitUntil` currently has a bug where it starts the 30 second timer when the response headers are sent to the client rather than after the response body has finished streaming.

If it isn't completed within 30 seconds, the `waitUntil` operation will be cancelled.

Emphasis on *currently has a bug* - that's not intended behaviour

what about if I do this instead?

```javascript
const resp1 = await fetch(url)
const resp2 = await fetch(url)
ctx.waitUntil(env.R2.put(key, resp2.body))
return resp1
```

I wouldn't recommend it, there's latency from awaiting two requests, but it probably works

better?

```javascript
const resp1 = await fetch(url)
const resp2 = fetch(url).then(async (response) => { return response.body })
ctx.waitUntil(env.R2.put(key, resp2))
return resp1
```

I have no idea how the Worker will manage those promises (does waitUntil know to wait for resp2)

```javascript
const resp1 = await fetch(url)
const my_promise = fetch(url).then(async (response) => { env.R2.put(key, response.body) })
ctx.waitUntil(my_promise)
return resp1
```

https://tenor.com/view/wait-what-confused-um-squint-gif-13025511

are you streaming files that won't be downloaded by the user within 30 seconds

there's a workaround to the issue that kenton posted which is probably less cursed than this

I'm accepting temporary arbitrary files from untrusted random users

https://stackoverflow.com/a/75248062/19639237