lopata 0.0.1

package/runtime/bindings/email.ts

@@ -0,0 +1,180 @@
+import type { Database } from "bun:sqlite";
+import { randomUUIDv7 } from "bun";
+import { startSpan, setSpanAttribute } from "../tracing/span";
+
+/**
+ * EmailMessage — exported from `cloudflare:email`.
+ * Used to construct an email for sending via a send_email binding.
+ */
+export class EmailMessage {
+	readonly from: string;
+	readonly to: string;
+	readonly raw: ReadableStream<Uint8Array> | Uint8Array | ArrayBuffer | string;
+
+	constructor(from: string, to: string, raw: ReadableStream<Uint8Array> | Uint8Array | ArrayBuffer | string) {
+		this.from = from;
+		this.to = to;
+		this.raw = raw;
+	}
+}
+
+/**
+ * SendEmailBinding — the `send_email` binding.
+ * Persists sent emails to SQLite.
+ */
+export class SendEmailBinding {
+	private db: Database;
+	private bindingName: string;
+	private destinationAddress: string | undefined;
+	private allowedDestinationAddresses: string[] | undefined;
+
+	constructor(db: Database, bindingName: string, destinationAddress?: string, allowedDestinationAddresses?: string[]) {
+		this.db = db;
+		this.bindingName = bindingName;
+		this.destinationAddress = destinationAddress;
+		this.allowedDestinationAddresses = allowedDestinationAddresses;
+	}
+
+	async send(message: EmailMessage): Promise<void> {
+		// Validate destination
+		if (this.destinationAddress && message.to !== this.destinationAddress) {
+			throw new Error(`Destination address "${message.to}" not allowed. Binding "${this.bindingName}" only allows sending to "${this.destinationAddress}".`);
+		}
+		if (this.allowedDestinationAddresses && this.allowedDestinationAddresses.length > 0) {
+			if (!this.allowedDestinationAddresses.includes(message.to)) {
+				throw new Error(`Destination address "${message.to}" not in allowed list for binding "${this.bindingName}".`);
+			}
+		}
+
+		const rawBytes = await resolveRaw(message.raw);
+		const id = randomUUIDv7();
+		this.db.run(
+			"INSERT INTO email_messages (id, binding, from_addr, to_addr, raw, raw_size, status, created_at) VALUES (?, ?, ?, ?, ?, ?, 'sent', ?)",
+			[id, this.bindingName, message.from, message.to, rawBytes, rawBytes.byteLength, Date.now()],
+		);
+	}
+}
+
+/**
+ * ForwardableEmailMessage — the object passed to the worker's `email()` handler.
+ * Provides from, to, headers, raw, rawSize, setReject(), forward(), reply().
+ */
+export class ForwardableEmailMessage {
+	readonly from: string;
+	readonly to: string;
+	readonly headers: Headers;
+	readonly raw: ReadableStream<Uint8Array>;
+	readonly rawSize: number;
+
+	private db: Database;
+	private rawBytes: Uint8Array;
+	private messageId: string;
+	private rejected = false;
+
+	constructor(db: Database, messageId: string, from: string, to: string, rawBytes: Uint8Array) {
+		this.db = db;
+		this.messageId = messageId;
+		this.from = from;
+		this.to = to;
+		this.rawBytes = rawBytes;
+		this.rawSize = rawBytes.byteLength;
+		this.headers = parseEmailHeaders(rawBytes);
+		this.raw = new ReadableStream({
+			start(controller) {
+				controller.enqueue(rawBytes);
+				controller.close();
+			},
+		});
+	}
+
+	setReject(reason: string): void {
+		startSpan({ name: "email.setReject", kind: "client", attributes: { "email.reject_reason": reason } }, () => {
+			this.rejected = true;
+			this.db.run(
+				"UPDATE email_messages SET status = 'rejected', reject_reason = ? WHERE id = ?",
+				[reason, this.messageId],
+			);
+		});
+	}
+
+	async forward(rcptTo: string, headers?: Headers): Promise<void> {
+		return startSpan({ name: "email.forward", kind: "client", attributes: { "email.forward_to": rcptTo } }, async () => {
+			const id = randomUUIDv7();
+			this.db.run(
+				"INSERT INTO email_messages (id, binding, from_addr, to_addr, raw, raw_size, status, created_at) VALUES (?, ?, ?, ?, ?, ?, 'forwarded', ?)",
+				[id, "_forward", this.from, rcptTo, this.rawBytes, this.rawBytes.byteLength, Date.now()],
+			);
+		});
+	}
+
+	async reply(message: EmailMessage): Promise<void> {
+		return startSpan({ name: "email.reply", kind: "client", attributes: { "email.reply_to": message.to } }, async () => {
+			const rawBytes = await resolveRaw(message.raw);
+			const id = randomUUIDv7();
+			this.db.run(
+				"INSERT INTO email_messages (id, binding, from_addr, to_addr, raw, raw_size, status, created_at) VALUES (?, ?, ?, ?, ?, ?, 'sent', ?)",
+				[id, "_reply", message.from, message.to, rawBytes, rawBytes.byteLength, Date.now()],
+			);
+		});
+	}
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+async function resolveRaw(raw: ReadableStream<Uint8Array> | Uint8Array | ArrayBuffer | string): Promise<Uint8Array> {
+	if (typeof raw === "string") return new TextEncoder().encode(raw);
+	if (raw instanceof Uint8Array) return raw;
+	if (raw instanceof ArrayBuffer) return new Uint8Array(raw);
+	// ReadableStream
+	const reader = raw.getReader();
+	const chunks: Uint8Array[] = [];
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		chunks.push(value);
+	}
+	const totalLen = chunks.reduce((s, c) => s + c.byteLength, 0);
+	const result = new Uint8Array(totalLen);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return result;
+}
+
+function parseEmailHeaders(rawBytes: Uint8Array): Headers {
+	const headers = new Headers();
+	const text = new TextDecoder().decode(rawBytes);
+	// Headers end at the first blank line
+	const headerEnd = text.indexOf("\r\n\r\n");
+	const headerSection = headerEnd !== -1 ? text.slice(0, headerEnd) : text.indexOf("\n\n") !== -1 ? text.slice(0, text.indexOf("\n\n")) : text;
+
+	const lines = headerSection.split(/\r?\n/);
+	let currentKey = "";
+	let currentValue = "";
+
+	for (const line of lines) {
+		if (/^\s/.test(line) && currentKey) {
+			// Continuation line
+			currentValue += " " + line.trim();
+		} else {
+			if (currentKey) {
+				headers.append(currentKey, currentValue);
+			}
+			const colonIdx = line.indexOf(":");
+			if (colonIdx !== -1) {
+				currentKey = line.slice(0, colonIdx).trim();
+				currentValue = line.slice(colonIdx + 1).trim();
+			} else {
+				currentKey = "";
+				currentValue = "";
+			}
+		}
+	}
+	if (currentKey) {
+		headers.append(currentKey, currentValue);
+	}
+
+	return headers;
+}

package/runtime/bindings/html-rewriter.ts

@@ -0,0 +1,84 @@
+import {
+  HTMLRewriter as RawHTMLRewriter,
+  type ElementHandlers,
+  type DocumentHandlers,
+} from "html-rewriter-wasm";
+
+/**
+ * Cloudflare-compatible HTMLRewriter that wraps html-rewriter-wasm.
+ * Usage: new HTMLRewriter().on(selector, handler).onDocument(handler).transform(response)
+ */
+export class HTMLRewriter {
+  private elementHandlers: Array<[string, ElementHandlers]> = [];
+  private documentHandlers: DocumentHandlers[] = [];
+
+  on(selector: string, handler: ElementHandlers): this {
+    this.elementHandlers.push([selector, handler]);
+    return this;
+  }
+
+  onDocument(handler: DocumentHandlers): this {
+    this.documentHandlers.push(handler);
+    return this;
+  }
+
+  transform(response: Response): Response {
+    // If body is null, return as-is (e.g. 204 No Content)
+    if (response.body === null) {
+      return new Response(null, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Headers(response.headers),
+      });
+    }
+
+    const elementHandlers = this.elementHandlers;
+    const documentHandlers = this.documentHandlers;
+
+    const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>();
+    const writer = writable.getWriter();
+
+    const rewriter = new RawHTMLRewriter((chunk: Uint8Array) => {
+      writer.write(chunk);
+    });
+
+    for (const [selector, handler] of elementHandlers) {
+      rewriter.on(selector, handler);
+    }
+    for (const handler of documentHandlers) {
+      rewriter.onDocument(handler);
+    }
+
+    const encoder = new TextEncoder();
+    const reader = response.body.getReader();
+
+    (async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          // value can be Uint8Array or string
+          const chunk = typeof value === "string" ? encoder.encode(value) : value;
+          await rewriter.write(chunk);
+        }
+        await rewriter.end();
+      } catch (err) {
+        await writer.abort(err instanceof Error ? err : new Error(String(err)));
+        return;
+      } finally {
+        rewriter.free();
+      }
+      await writer.close();
+    })();
+
+    // Copy headers but remove content-length since streaming transform changes size
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+
+    return new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  }
+}

package/runtime/bindings/hyperdrive.ts

@@ -0,0 +1,130 @@
+/**
+ * Local implementation of the Cloudflare Hyperdrive binding.
+ * Parses a PostgreSQL connection string and exposes readonly properties.
+ * connect() creates a raw TCP socket via Bun.connect().
+ */
+
+interface HyperdriveSocket {
+	readable: ReadableStream<Uint8Array>;
+	writable: WritableStream<Uint8Array>;
+	closed: Promise<void>;
+	opened: Promise<{ remoteAddress: string }>;
+	close(): void;
+}
+
+export class HyperdriveBinding {
+	private readonly _url: URL | null;
+	private readonly _connectionString: string;
+
+	constructor(connectionString: string) {
+		this._connectionString = connectionString;
+		if (connectionString) {
+			this._url = new URL(connectionString);
+		} else {
+			this._url = null;
+		}
+	}
+
+	get connectionString(): string {
+		return this._connectionString;
+	}
+
+	get host(): string {
+		return this._url?.hostname ?? "";
+	}
+
+	get port(): number {
+		if (!this._url) return 5432;
+		return this._url.port ? parseInt(this._url.port, 10) : 5432;
+	}
+
+	get user(): string {
+		return this._url ? decodeURIComponent(this._url.username) : "";
+	}
+
+	get password(): string {
+		return this._url ? decodeURIComponent(this._url.password) : "";
+	}
+
+	get database(): string {
+		if (!this._url) return "";
+		// pathname is "/<database>", strip leading slash
+		return decodeURIComponent(this._url.pathname.slice(1));
+	}
+
+	connect(): HyperdriveSocket {
+		if (!this._url) {
+			throw new Error("Hyperdrive: no connection string configured");
+		}
+
+		const host = this.host;
+		const port = this.port;
+
+		let readableController: ReadableStreamDefaultController<Uint8Array>;
+		let resolveOpened: (info: { remoteAddress: string }) => void;
+		let resolveClosed: () => void;
+		let rejectOpened: (err: Error) => void;
+		let rejectClosed: (err: Error) => void;
+		let bunSocket: ReturnType<typeof Bun.connect> extends Promise<infer T> ? T : never;
+
+		const readable = new ReadableStream<Uint8Array>({
+			start(controller) {
+				readableController = controller;
+			},
+		});
+
+		const opened = new Promise<{ remoteAddress: string }>((resolve, reject) => {
+			resolveOpened = resolve;
+			rejectOpened = reject;
+		});
+
+		const closed = new Promise<void>((resolve, reject) => {
+			resolveClosed = resolve;
+			rejectClosed = reject;
+		});
+
+		const writable = new WritableStream<Uint8Array>({
+			async write(chunk) {
+				const sock = await socketPromise;
+				sock.write(chunk);
+			},
+		});
+
+		const socketPromise = Bun.connect({
+			hostname: host,
+			port,
+			socket: {
+				data(_socket, data) {
+					readableController.enqueue(new Uint8Array(data));
+				},
+				open(socket) {
+					bunSocket = socket as any;
+					resolveOpened!({ remoteAddress: `${host}:${port}` });
+				},
+				close() {
+					try { readableController.close(); } catch {}
+					resolveClosed!();
+				},
+				error(_socket, err) {
+					rejectOpened!(err);
+					rejectClosed!(err);
+					try { readableController.error(err); } catch {}
+				},
+			},
+		});
+
+		return {
+			readable,
+			writable,
+			opened,
+			closed,
+			close() {
+				socketPromise.then(s => s.end());
+			},
+		};
+	}
+
+	startTls(): never {
+		throw new Error("startTls() is not supported in local dev mode");
+	}
+}