@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 07:15 UTC

main
ts 339 lines 11.9 KB
Raw
1 import { EmailMessage } from "cloudflare:email";
2 /// <reference types="vite/client" />
3 // Mirrors the runtime-feature playgrounds of `@cloudflare/vite-plugin`:
4 // `bindings`, `durable-objects`, `block-concurrency-while`, `workflows`,
5 // `websockets`, `ctx-exports`, `same-worker-service-bindings`,
6 // `importable-env`, `explicit-resource-management`, `cron-triggers`,
7 // `email-worker`, `stream-binding`, `external-durable-objects` and
8 // `external-workflows`.
9 // Each route is the playground's handler for the spec it backs.
10 import {
11 DurableObject,
12 WorkerEntrypoint,
13 WorkflowEntrypoint,
14 env as importedEnv,
15 } from "cloudflare:workers";
16 import type { WorkflowEvent, WorkflowStep } from "cloudflare:workers";
17 import type { Counter as ExternalCounter } from "../worker-b/index.ts";
18 import image from "./image.png?inline";
19
20 interface Env {
21 KV: KVNamespace;
22 IMAGES: ImagesBinding;
23 WAE: AnalyticsEngineDataset;
24 RATE_LIMITER: RateLimit;
25 COUNTERS: DurableObjectNamespace<Counter>;
26 LEGACY: DurableObjectNamespace;
27 KV_BACKED?: DurableObjectNamespace<KvBacked>;
28 INITIALIZED: DurableObjectNamespace<BlockConcurrency>;
29 WEBSOCKET_SERVER: DurableObjectNamespace<WebSocketServer>;
30 MY_WORKFLOW: Workflow;
31 EXTERNAL_COUNTERS: DurableObjectNamespace<ExternalCounter>;
32 EXTERNAL_WORKFLOW: Workflow;
33 NAMED_ENTRYPOINT: Service<NamedEntrypoint>;
34 LEGACY_ENTRYPOINT: Fetcher;
35 EMAIL: SendEmail;
36 STREAM: StreamBinding;
37 "importable-env_VAR": string;
38 "importable-env_SECRET": string;
39 }
40
41 // `importable-env`: the env import resolves at module scope.
42 const importedVar = (importedEnv as unknown as Env)["importable-env_VAR"];
43
44 // `durable-objects`
45 export class Counter extends DurableObject {
46 #log: Array<string> = [];
47
48 async getCounterValue() {
49 return ((await this.ctx.storage.get("value")) as number) || 0;
50 }
51
52 record(value: string) {
53 this.#log.push(value);
54 }
55
56 getLog() {
57 return this.#log;
58 }
59
60 async increment(amount = 1) {
61 const value = (((await this.ctx.storage.get("value")) as number) || 0) + amount;
62 await this.ctx.storage.put("value", value);
63 return value;
64 }
65
66 async decrement(amount = 1) {
67 const value = (((await this.ctx.storage.get("value")) as number) || 0) - amount;
68 await this.ctx.storage.put("value", value);
69 return value;
70 }
71 }
72
73 // `durable-objects`: a class that doesn't extend `DurableObject`.
74 export class Legacy {
75 fetch() {
76 return new Response("Legacy Durable Object");
77 }
78 }
79
80 // `block-concurrency-while`
81 // `durable-objects`: a class declared `storage: "legacy-kv"`, which has no
82 // SQL storage.
83 export class KvBacked extends DurableObject {
84 hasSql() {
85 try {
86 this.ctx.storage.sql.exec("SELECT 1");
87 return true;
88 } catch {
89 return false;
90 }
91 }
92 }
93
94 export class BlockConcurrency extends DurableObject {
95 #isInitialized = false;
96
97 constructor(ctx: DurableObjectState, env: Env) {
98 super(ctx, env);
99 void this.ctx.blockConcurrencyWhile(async () => {
100 this.#isInitialized = true;
101 });
102 }
103
104 get isInitialized() {
105 return this.#isInitialized;
106 }
107 }
108
109 // `websockets`
110 export class WebSocketServer extends DurableObject {
111 override fetch() {
112 const { 0: client, 1: server } = new WebSocketPair();
113 this.ctx.acceptWebSocket(server);
114 return new Response(null, { status: 101, webSocket: client });
115 }
116
117 override async webSocketMessage(ws: WebSocket, data: string | ArrayBuffer) {
118 ws.send(`Durable Object received client message: '${data}' of type '${typeof data}'.`);
119 }
120 }
121
122 // `workflows`
123 export class MyWorkflow extends WorkflowEntrypoint {
124 override async run(_: WorkflowEvent<unknown>, step: WorkflowStep) {
125 await step.do("first step", async () => ({ output: "First step result" }));
126 await step.sleep("sleep", "1 second");
127 await step.do("second step", async () => ({ output: "Second step result" }));
128 return "Workflow output";
129 }
130 }
131
132 // `ctx-exports` and `same-worker-service-bindings`
133 export class NamedEntrypoint extends WorkerEntrypoint {
134 multiply(a: number, b: number) {
135 return a * b;
136 }
137
138 greet() {
139 return "Hello World from a Worker Entrypoint";
140 }
141 }
142
143 // `same-worker-service-bindings`: a plain object entrypoint.
144 export const legacy = {
145 fetch() {
146 return new Response("Legacy Worker entrypoint");
147 },
148 };
149
150 const workflowRoutes = async (workflow: Workflow, url: URL) => {
151 const id = url.searchParams.get("id") ?? undefined;
152 if (url.pathname.endsWith("/create")) {
153 let instance: WorkflowInstance;
154 try {
155 instance = await workflow.create(id === undefined ? undefined : { id });
156 } catch (error) {
157 if (!(error instanceof Error && error.message.includes("instance.already_exists"))) {
158 throw error;
159 }
160 instance = await workflow.get(id!);
161 }
162 return Response.json({ id: instance.id, status: await instance.status() });
163 }
164 return Response.json(await (await workflow.get(id!)).status());
165 };
166
167 const entries = (value: object) =>
168 Object.entries(value)
169 .filter(([key]) => key.startsWith("importable-env_"))
170 .map(([key, value]) => ({ key, value }));
171
172 export default {
173 async fetch(request: Request, env: Env, ctx: ExecutionContext) {
174 const url = new URL(request.url);
175 const name = url.searchParams.get("name") ?? "default";
176 switch (url.pathname) {
177 // `bindings`
178 case "/kv": {
179 const value = Math.floor(Date.now() * Math.random()).toString(36);
180 await env.KV.put("value", value);
181 return value === (await env.KV.get("value"))
182 ? new Response("KV binding works")
183 : new Response("KV binding failed to set value", { status: 500 });
184 }
185 case "/images": {
186 const response = await fetch(image);
187 const info = await env.IMAGES.info(response.body!);
188 return info.format === "image/png"
189 ? new Response("Images binding works")
190 : new Response("Images binding returns an incorrect format", { status: 500 });
191 }
192 case "/ae":
193 env.WAE.writeDataPoint({ doubles: [2, 3] });
194 return new Response("AE binding works");
195 case "/rate-limit": {
196 const key = url.searchParams.get("key") ?? "shared-key";
197 const { success: first } = await env.RATE_LIMITER.limit({ key });
198 const { success: second } = await env.RATE_LIMITER.limit({ key });
199 return new Response(`Rate limit binding works: first: ${first}, second: ${second}`);
200 }
201 // `durable-objects`
202 case "/do":
203 case "/do/increment":
204 case "/do/decrement": {
205 const stub = env.COUNTERS.get(env.COUNTERS.idFromName(name));
206 const count = url.pathname.endsWith("/increment")
207 ? await stub.increment()
208 : url.pathname.endsWith("/decrement")
209 ? await stub.decrement()
210 : await stub.getCounterValue();
211 return new Response(`Durable Object '${name}' count: ${count}`);
212 }
213 case "/do/kv-backed":
214 return Response.json({
215 hasSql: await env.KV_BACKED!.get(env.KV_BACKED!.idFromName("kv")).hasSql(),
216 });
217 case "/do/legacy":
218 return env.LEGACY.get(env.LEGACY.idFromName("test")).fetch(request);
219 case "/do/rpc-ordering": {
220 const stub = env.COUNTERS.get(env.COUNTERS.idFromName(name));
221 await Promise.all(Array.from({ length: 100 }, (_, i) => stub.record(`call-${i}`)));
222 const actual = await stub.getLog();
223 const expected = Array.from({ length: 100 }, (_, i) => `call-${i}`);
224 return Response.json({ inOrder: JSON.stringify(actual) === JSON.stringify(expected) });
225 }
226 // `block-concurrency-while`
227 case "/do/block-concurrency": {
228 const stub = env.INITIALIZED.get(env.INITIALIZED.idFromName("test-id"));
229 return Response.json({ isInitialized: await stub.isInitialized });
230 }
231 // `websockets`
232 case "/websocket":
233 if (request.headers.get("Upgrade") !== "websocket") {
234 return new Response("Durable Object expected Upgrade: websocket", { status: 426 });
235 }
236 return env.WEBSOCKET_SERVER.get(env.WEBSOCKET_SERVER.idFromName("id")).fetch(request);
237 // `workflows` and `external-workflows`
238 case "/workflow/create":
239 case "/workflow/get":
240 return workflowRoutes(env.MY_WORKFLOW, url);
241 case "/external-workflow/create":
242 case "/external-workflow/get":
243 return workflowRoutes(env.EXTERNAL_WORKFLOW, url);
244 // `external-durable-objects`
245 case "/external-do":
246 case "/external-do/increment": {
247 const stub = env.EXTERNAL_COUNTERS.get(env.EXTERNAL_COUNTERS.idFromName(name));
248 const count = url.pathname.endsWith("/increment")
249 ? await stub.increment()
250 : await stub.getCounterValue();
251 return new Response(`From worker-a: ${JSON.stringify({ name, count })}`);
252 }
253 // `ctx-exports`
254 case "/ctx-exports/worker-entrypoint": {
255 const exports = ctx.exports as unknown as { NamedEntrypoint: Service<NamedEntrypoint> };
256 return new Response(await exports.NamedEntrypoint.greet());
257 }
258 // `same-worker-service-bindings`
259 case "/service/named":
260 return Response.json({ result: await env.NAMED_ENTRYPOINT.multiply(4, 5) });
261 case "/service/legacy":
262 return env.LEGACY_ENTRYPOINT.fetch(request);
263 // `importable-env`
264 case "/importable-env":
265 return Response.json({
266 importedAtModuleScope: importedVar,
267 handlerEnv: entries(env),
268 importedEnv: entries(importedEnv),
269 });
270 // `explicit-resource-management`
271 case "/explicit-resource-management": {
272 const disposed: Array<string> = [];
273 {
274 await using _session = {
275 async [Symbol.asyncDispose]() {
276 disposed.push("session");
277 },
278 };
279 using _socket = {
280 [Symbol.dispose]() {
281 disposed.push("socket");
282 },
283 };
284 }
285 return Response.json(disposed);
286 }
287 // `cron-triggers` (cf-worker-header): an outbound fetch to the test's
288 // echo server, which reports the `CF-Worker` header it received.
289 case "/cf-worker-header":
290 return fetch(url.searchParams.get("echoUrl")!);
291 // Miniflare's outbound `cf.image` mock: the origin image is resized
292 // locally.
293 case "/cf-image":
294 return fetch(url.searchParams.get("imageUrl")!, {
295 cf: { image: { width: 4, format: "png" } },
296 });
297 // `stream-binding`: the binding fetches the bytes from `/video-asset`.
298 case "/video-asset":
299 return new Response(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]), {
300 headers: { "Content-Type": "application/octet-stream" },
301 });
302 case "/stream/upload": {
303 const video = await env.STREAM.upload(`${url.origin}/video-asset`);
304 return Response.json({ preview: video.preview, id: video.id });
305 }
306 // `cron-triggers` and `email-worker`: the handlers below record what
307 // they received.
308 case "/handled":
309 return Response.json({
310 scheduled: await env.KV.get("scheduled"),
311 email: await env.KV.get("email"),
312 });
313 case "/send": {
314 const raw = [
315 'From: "Sending email test" <sender@example.com>',
316 "To: recipient@example.com",
317 "Subject: An email generated in a Worker",
318 `Message-ID: <${crypto.randomUUID()}@example.com>`,
319 `Date: ${new Date().toUTCString()}`,
320 "Content-Type: text/plain",
321 "",
322 "Congratulations, you just sent an email from a Worker.",
323 ].join("\r\n");
324 await env.EMAIL.send(new EmailMessage("sender@example.com", "recipient@example.com", raw));
325 return new Response("Email message sent successfully!");
326 }
327 }
328 return new Response("vite-runtime-worker");
329 },
330
331 async scheduled(controller: ScheduledController, env: Env) {
332 await env.KV.put("scheduled", controller.cron || "manual");
333 },
334
335 async email(message: ForwardableEmailMessage, env: Env) {
336 const raw = await new Response(message.raw).text();
337 await env.KV.put("email", `${message.from} ${raw.includes("Hi there") ? "Hi there" : ""}`);
338 },
339 };