and the

{ cf: { lol: true }}

part isn't spoofable?

ts
export default <ExportedHandler> {
  fetch(req) {
    return Response.json(req.cf);
  }
}

ts
interface Environment {
  FOO: Fetcher
}

export default <ExportedHandler<Environment>> {
  fetch(req, env) {
    return env.FOO.fetch(req.url, { cf: { lol: true }})
  }
}

Output:

json
{"lol":true}

req.cf

is populated on the inbound request by Cloudflare - and since Service Bindings don't 'go through' Cloudflare's normal request flow, it'll only exist on the Worker you're invoking if you pass it yourself

Even then, custom properties would also only ever be yourself

thanks!

Hello everyone, is there any difference in

wrangler.toml

for this two routes?

routes = [
  { pattern = "*/something/*", zone_id = "xxx" },
  { pattern = "domain.com/*/something/*", zone_name = "domain.com" }
]

Because I cannot use

zone_id

for the second and

zone_name

for the first while publishing my worker 😦

pages-action worked a treat by the way. Thank you 🙂

No prob! happy to help

Hi, I'm wondering how feasible it would be to use a Worker to stream a file to R2, while also compressing it on the fly (preferably with zstd or deflate). I could chunk the input into same-size parts, but the compressed chunks would be different sizes, meaning I couldn't use multi-part uploads. Same issue with using a

TransformStream

, I wouldn't know the file size ahead of time. Anyone have any ideas/suggestions?

Eeeh - it’s not ideal to do in Workers since as you’ve mentioned, size must be known upfront or have consistent parts

How big are the files in question?

Range of file sizes, largest would be somewhere between 5-10 GBs

Anything above 5GB would have to be multipart anyhow - and those sizes rule out buffering

I’d be impressed if a Worker could compress those within CPU limits - but I’ve never tested the efficiency of CompressionStream

Is there any problem you see that would cause a race condition? I sometimes get an error on the fetch at the end saying that

This ReadableStream is disturbed (has already been read from), and cannot be used as a body.

.

typescript
        let request_body = request.body;

        if(request_body && !cleaned_headers.has("X-Amz-Content-Sha256")) {
            let hash_body;
            [request_body, hash_body] = request_body.tee();
            const digestStream = new crypto.DigestStream("SHA-256");
            hash_body.pipeTo(digestStream);
            const digest = await digestStream.digest; // This could be a problem for bundled usage
            const hexString = [...new Uint8Array(digest)].map(b => b.toString(16).padStart(2, '0')).join('')
            cleaned_headers.set("X-Amz-Content-Sha256", hexString)
        }


        const lambdaResponse = await aws.fetch(target_url, {
            method: request.method,
            headers: cleaned_headers,
            body: request_body,
            redirect: "manual"
        })

oh hmm

this race condition is so weird

Am I not setting

request_body

correctly?

I am so confused.

well, I have up to 128MB of memory...

I guess I can just buffer it all in

weird scoping issue with request_body being outside the if block and reassigned inside?

totally random guess, not at a PC to test anything

that error sounds like the underlying ReadableStream source is being used rather than one of the two streams from tee

yeah, beginning to think it might be aws4fetch related

my max body size is 6MB anyway iirc

so I can buffer it in

Do I need to add DNS records if I am creating custom worker routes?

custom domains? no