1
// Copyright (c) 2026 Cloudflare, Inc.
2
// Licensed under the Apache 2.0 license found in the LICENSE file or at:
3
//     https://opensource.org/licenses/Apache-2.0
4
 
5
#pragma once
6
 
7
#include <workerd/rust/worker/ffi.rs.h>
8
 
9
#include <kj-rs/kj-rs.h>
10
 
11
namespace workerd::rust::worker {
12
 
13
inline workerd::EventOutcome fromImpl(kj_rs::Rust*, workerd::rust::worker::EventOutcome outcome) {
14
  switch (outcome) {
15
    case workerd::rust::worker::EventOutcome::Unknown:
16
      return workerd::EventOutcome::UNKNOWN;
17
    case workerd::rust::worker::EventOutcome::Ok:
18
      return workerd::EventOutcome::OK;
19
    case workerd::rust::worker::EventOutcome::Exception:
20
      return workerd::EventOutcome::EXCEPTION;
21
    case workerd::rust::worker::EventOutcome::ExceededCpu:
22
      return workerd::EventOutcome::EXCEEDED_CPU;
23
    case workerd::rust::worker::EventOutcome::KillSwitch:
24
      return workerd::EventOutcome::KILL_SWITCH;
25
    case workerd::rust::worker::EventOutcome::DaemonDown:
26
      return workerd::EventOutcome::DAEMON_DOWN;
27
    case workerd::rust::worker::EventOutcome::ScriptNotFound:
28
      return workerd::EventOutcome::SCRIPT_NOT_FOUND;
29
    case workerd::rust::worker::EventOutcome::Canceled:
30
      return workerd::EventOutcome::CANCELED;
31
    case workerd::rust::worker::EventOutcome::ExceededMemory:
32
      return workerd::EventOutcome::EXCEEDED_MEMORY;
33
    case workerd::rust::worker::EventOutcome::LoadShed:
34
      return workerd::EventOutcome::LOAD_SHED;
35
    case workerd::rust::worker::EventOutcome::ResponseStreamDisconnected:
36
      return workerd::EventOutcome::RESPONSE_STREAM_DISCONNECTED;
37
    case workerd::rust::worker::EventOutcome::InternalError:
38
      return workerd::EventOutcome::INTERNAL_ERROR;
39
  }
40
}
41
 
42
inline workerd::WorkerInterface::ScheduledResult fromImpl(
43
    kj_rs::Rust*, workerd::rust::worker::ScheduledResult result) {
44
  return workerd::WorkerInterface::ScheduledResult{
45
    .retry = result.retry,
46
    .outcome = kj::from<kj_rs::Rust>(result.outcome),
47
  };
48
}
49
 
50
inline workerd::WorkerInterface::AlarmResult fromImpl(
51
    kj_rs::Rust*, workerd::rust::worker::AlarmResult result) {
52
  return workerd::WorkerInterface::AlarmResult{
53
    .retry = result.retry,
54
    .retryCountsAgainstLimit = result.retry_counts_against_limit,
55
    .outcome = kj::from<kj_rs::Rust>(result.outcome),
56
    .errorDescription = result.error_description.empty()
57
        ? kj::none
58
        : kj::Maybe<kj::String>(kj::str(result.error_description)),
59
  };
60
}
61
 
62
inline workerd::WorkerInterface::CustomEvent::Result fromImpl(
63
    kj_rs::Rust*, workerd::rust::worker::CustomEventResult result) {
64
  return workerd::WorkerInterface::CustomEvent::Result{
65
    .outcome = kj::from<kj_rs::Rust>(result.outcome),
66
  };
67
}
68
 
69
class RustWorkerInterface final: public workerd::WorkerInterface {
70
 public:
71
  using Impl = workerd::rust::worker::Wrapper;
72
  RustWorkerInterface(::rust::Box<Impl> impl): impl(kj::mv(impl)) {}
73
 
74
  kj::Promise<void> request(kj::HttpMethod method,
75
      kj::StringPtr url,
76
      const kj::HttpHeaders& headers,
77
      kj::AsyncInputStream& requestBody,
78
      Response& response) override {
79
    return impl->request(method, url.asBytes().as<kj_rs::Rust>(), headers, requestBody, response);
80
  }
81
 
82
  kj::Promise<void> connect(kj::StringPtr host,
83
      const kj::HttpHeaders& headers,
84
      kj::AsyncIoStream& connection,
85
      ConnectResponse& tunnel,
86
      kj::HttpConnectSettings settings) override {
87
    return impl->connect(host.asBytes().as<kj_rs::Rust>(), headers, connection, tunnel,
88
        kj::rust::HttpConnectSettings{
89
          .use_tls = settings.useTls,
90
          .tls_starter = settings.tlsStarter,
91
        });
92
  }
93
 
94
  kj::Promise<void> prewarm(kj::StringPtr url) override {
95
    return impl->prewarm(url.asBytes().as<kj_rs::Rust>());
96
  }
97
 
98
  kj::Promise<ScheduledResult> runScheduled(kj::Date scheduledTime, kj::StringPtr cron) override {
99
    co_return kj::from<kj_rs::Rust>(
100
        co_await impl->run_scheduled(scheduledTime, cron.asBytes().as<kj_rs::Rust>()));
101
  }
102
 
103
  kj::Promise<AlarmResult> runAlarm(kj::Date scheduledTime, uint32_t retryCount) override {
104
    co_return kj::from<kj_rs::Rust>(co_await impl->run_alarm(scheduledTime, retryCount));
105
  }
106
 
107
  kj::Promise<CustomEvent::Result> customEvent(kj::Own<CustomEvent> event) override {
108
    co_return kj::from<kj_rs::Rust>(co_await impl->custom_event(*event));
109
  }
110
 
111
  kj::Promise<bool> test() override {
112
    return impl->test();
113
  }
114
 
115
 private:
116
  ::rust::Box<Impl> impl;
117
};
118
 
119
inline kj::Own<workerd::WorkerInterface> fromImpl(
120
    kj_rs::Rust*, ::rust::Box<RustWorkerInterface::Impl> impl) {
121
  return kj::heap<RustWorkerInterface>(kj::mv(impl));
122
}
123
 
124
}  // namespace workerd::rust::worker