devflare 1.0.0-next.1 → 1.0.0-next.10

package/dist/{index-gz1gndna.js → index-9wt9x09k.js}

@@ -104,30 +104,26 @@ function generateWrapper(className, options = {}) {
   const includeWebsockets = options.websockets ?? false;
   let wrapper = `
 // ============ Devflare DO Wrapper for ${className} ============
-import { runWithContext } from 'devflare/runtime'
+import { createDurableObjectAlarmEvent, createDurableObjectFetchEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, createDurableObjectWebSocketMessageEvent, runWithEventContext } from 'devflare/runtime'
 
 const __Original${className} = ${className}
 
 class ${className}Wrapper extends __Original${className} {
 	async fetch(request: Request): Promise<Response> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			request,
-			() => super.fetch(request),
-			'fetch'
+		const __devflareEvent = createDurableObjectFetchEvent(request, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.fetch(__devflareEvent)
 		)
 	}
 `;
   if (includeAlarms) {
     wrapper += `
 	async alarm(): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.alarm?.() ?? Promise.resolve(),
-			'scheduled'
+		const __devflareEvent = createDurableObjectAlarmEvent(this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.alarm?.(__devflareEvent) ?? Promise.resolve()
 		)
 	}
 `;
@@ -135,32 +131,26 @@ class ${className}Wrapper extends __Original${className} {
   if (includeWebsockets) {
     wrapper += `
 	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.webSocketMessage?.(ws, message) ?? Promise.resolve(),
-			'fetch'
+		const __devflareEvent = createDurableObjectWebSocketMessageEvent(ws, message, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketMessage?.(__devflareEvent, message) ?? Promise.resolve()
 		)
 	}
 
 	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.webSocketClose?.(ws, code, reason, wasClean) ?? Promise.resolve(),
-			'fetch'
+		const __devflareEvent = createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketClose?.(__devflareEvent, code, reason, wasClean) ?? Promise.resolve()
 		)
 	}
 
 	async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.webSocketError?.(ws, error) ?? Promise.resolve(),
-			'fetch'
+		const __devflareEvent = createDurableObjectWebSocketErrorEvent(ws, error, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketError?.(__devflareEvent, error) ?? Promise.resolve()
 		)
 	}
 `;
@@ -212,7 +202,7 @@ async function transformDurableObject(code, id) {
     }
   }
   const imports = `
-import { runWithContext } from 'devflare/runtime'
+import { createDurableObjectAlarmEvent, createDurableObjectFetchEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, createDurableObjectWebSocketMessageEvent, runWithEventContext } from 'devflare/runtime'
 `;
   s.prepend(imports);
   for (const classInfo of doClasses) {
@@ -241,24 +231,20 @@ function generateWrapperCodeInternal(className, options) {
 // ============ Devflare DO Wrapper for ${className} ============
 class ${className}Wrapper extends __Original${className} {
 	async fetch(request: Request): Promise<Response> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			request,
-			() => super.fetch(request),
-			'fetch'
+		const __devflareEvent = createDurableObjectFetchEvent(request, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.fetch(__devflareEvent)
 		)
 	}
 `;
   if (options.alarms) {
     wrapper += `
 	async alarm(): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.alarm?.() ?? Promise.resolve(),
-			'scheduled'
+		const __devflareEvent = createDurableObjectAlarmEvent(this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.alarm?.(__devflareEvent) ?? Promise.resolve()
 		)
 	}
 `;
@@ -266,32 +252,26 @@ class ${className}Wrapper extends __Original${className} {
   if (options.websockets) {
     wrapper += `
 	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.webSocketMessage?.(ws, message) ?? Promise.resolve(),
-			'fetch'
+		const __devflareEvent = createDurableObjectWebSocketMessageEvent(ws, message, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketMessage?.(__devflareEvent, message) ?? Promise.resolve()
 		)
 	}
 
 	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.webSocketClose?.(ws, code, reason, wasClean) ?? Promise.resolve(),
-			'fetch'
+		const __devflareEvent = createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketClose?.(__devflareEvent, code, reason, wasClean) ?? Promise.resolve()
 		)
 	}
 
 	async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
-		return runWithContext(
-			this.env,
-			this.ctx,
-			null,
-			() => super.webSocketError?.(ws, error) ?? Promise.resolve(),
-			'fetch'
+		const __devflareEvent = createDurableObjectWebSocketErrorEvent(ws, error, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketError?.(__devflareEvent, error) ?? Promise.resolve()
 		)
 	}
 `;

package/dist/index-fef08w43.js

@@ -0,0 +1,231 @@
+// src/utils/send-email.ts
+var RAW_EMAIL = "EmailMessage::raw";
+var wrappedSendEmailBindings = new WeakMap;
+var wrappedEnvBindings = new WeakMap;
+var localSendEmailBindings = new Map;
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSendEmailBinding(value) {
+  return isRecord(value) && typeof value.send === "function" && typeof value.sendBatch !== "function";
+}
+function isComposableSendEmailMessage(message) {
+  return isRecord(message) && typeof message.from === "string" && (typeof message.to === "string" || Array.isArray(message.to));
+}
+function formatEmailAddress(value) {
+  if (!value) {
+    return;
+  }
+  return typeof value === "string" ? value : String(value);
+}
+function formatEmailList(value) {
+  if (!value) {
+    return;
+  }
+  return Array.isArray(value) ? value.join(", ") : value;
+}
+function normalizeBodyText(value) {
+  return value.replace(/\r?\n/g, `\r
+`);
+}
+function buildMultipartAlternativeBody(message, boundary) {
+  const parts = [];
+  if (message.text) {
+    parts.push(`--${boundary}`, "Content-Type: text/plain; charset=UTF-8", "", normalizeBodyText(message.text));
+  }
+  if (message.html) {
+    parts.push(`--${boundary}`, "Content-Type: text/html; charset=UTF-8", "", normalizeBodyText(message.html));
+  }
+  parts.push(`--${boundary}--`);
+  return parts.join(`\r
+`);
+}
+function buildRawEmail(message) {
+  const lines = [];
+  const messageId = `<${Date.now()}-${Math.random().toString(36).slice(2)}@devflare.dev>`;
+  lines.push(`From: ${message.from}`);
+  lines.push(`To: ${formatEmailList(message.to)}`);
+  lines.push(`Date: ${new Date().toUTCString()}`);
+  lines.push(`Message-ID: ${messageId}`);
+  if (message.subject) {
+    lines.push(`Subject: ${message.subject}`);
+  }
+  const replyTo = formatEmailAddress(message.replyTo);
+  if (replyTo) {
+    lines.push(`Reply-To: ${replyTo}`);
+  }
+  const cc = formatEmailList(message.cc);
+  if (cc) {
+    lines.push(`Cc: ${cc}`);
+  }
+  const bcc = formatEmailList(message.bcc);
+  if (bcc) {
+    lines.push(`Bcc: ${bcc}`);
+  }
+  if (message.headers) {
+    for (const [key, value] of Object.entries(message.headers)) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("MIME-Version: 1.0");
+  if (message.text && message.html) {
+    const boundary = `devflare-alt-${crypto.randomUUID()}`;
+    lines.push(`Content-Type: multipart/alternative; boundary="${boundary}"`);
+    lines.push("");
+    lines.push(buildMultipartAlternativeBody(message, boundary));
+    return lines.join(`\r
+`);
+  }
+  lines.push(`Content-Type: ${message.html ? "text/html" : "text/plain"}; charset=UTF-8`);
+  lines.push("");
+  lines.push(normalizeBodyText(message.html ?? message.text ?? ""));
+  return lines.join(`\r
+`);
+}
+function createEmailMessageRaw(raw) {
+  if (typeof raw === "string" || raw instanceof ReadableStream) {
+    return raw;
+  }
+  if (raw instanceof Uint8Array || raw instanceof ArrayBuffer) {
+    const body = new Response(raw).body;
+    if (!body) {
+      throw new Error("Could not create email body stream");
+    }
+    return body;
+  }
+  throw new Error("Unsupported EmailMessage raw payload");
+}
+function normalizeSendEmailMessage(message) {
+  if (!isComposableSendEmailMessage(message)) {
+    return message;
+  }
+  if (hasOwn(message, RAW_EMAIL)) {
+    return message;
+  }
+  if (hasOwn(message, "raw") && message.raw !== undefined) {
+    return {
+      from: message.from,
+      to: message.to,
+      [RAW_EMAIL]: createEmailMessageRaw(message.raw)
+    };
+  }
+  return {
+    from: message.from,
+    to: message.to,
+    [RAW_EMAIL]: createEmailMessageRaw(buildRawEmail(message))
+  };
+}
+function wrapSendEmailBinding(binding) {
+  const cached = wrappedSendEmailBindings.get(binding);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(binding, {
+    get(target, prop, receiver) {
+      if (prop === "send") {
+        return async (message) => target.send(normalizeSendEmailMessage(message));
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  wrappedSendEmailBindings.set(binding, wrapped);
+  return wrapped;
+}
+function createLocalSendEmailBinding(config = {}, options = {}) {
+  return {
+    async send(message) {
+      const normalized = normalizeSendEmailMessage(message);
+      if (isRecord(normalized)) {
+        const from = typeof normalized.from === "string" ? normalized.from : undefined;
+        const recipients = Array.isArray(normalized.to) ? normalized.to.filter((value) => typeof value === "string") : typeof normalized.to === "string" ? [normalized.to] : [];
+        if (from && config.allowedSenderAddresses && !config.allowedSenderAddresses.includes(from)) {
+          throw new Error(`email from ${from} not allowed`);
+        }
+        for (const recipient of recipients) {
+          if (config.destinationAddress !== undefined && recipient !== config.destinationAddress) {
+            throw new Error(`email to ${recipient} not allowed`);
+          }
+          if (config.allowedDestinationAddresses !== undefined && !config.allowedDestinationAddresses.includes(recipient)) {
+            throw new Error(`email to ${recipient} not allowed`);
+          }
+        }
+      }
+      await options.onSend?.(normalized);
+      return;
+    }
+  };
+}
+function setLocalSendEmailBindings(bindings) {
+  localSendEmailBindings.clear();
+  for (const [name, config] of Object.entries(bindings)) {
+    localSendEmailBindings.set(name, createLocalSendEmailBinding(config));
+  }
+}
+function clearLocalSendEmailBindings() {
+  localSendEmailBindings.clear();
+}
+function needsEnvSendEmailWrapping(env) {
+  if (localSendEmailBindings.size > 0) {
+    return true;
+  }
+  for (const key of Reflect.ownKeys(env)) {
+    const value = Reflect.get(env, key);
+    if (isSendEmailBinding(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function wrapEnvSendEmailBindings(env) {
+  if (!isRecord(env)) {
+    return env;
+  }
+  if (!needsEnvSendEmailWrapping(env)) {
+    return env;
+  }
+  const cached = wrappedEnvBindings.get(env);
+  if (cached) {
+    return cached;
+  }
+  const wrapped = new Proxy(env, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (value === undefined && typeof prop === "string") {
+        return localSendEmailBindings.get(prop);
+      }
+      return isSendEmailBinding(value) ? wrapSendEmailBinding(value) : value;
+    },
+    has(target, prop) {
+      return Reflect.has(target, prop) || typeof prop === "string" && localSendEmailBindings.has(prop);
+    },
+    ownKeys(target) {
+      return Array.from(new Set([
+        ...Reflect.ownKeys(target),
+        ...localSendEmailBindings.keys()
+      ]));
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (descriptor) {
+        return descriptor;
+      }
+      if (typeof prop === "string" && localSendEmailBindings.has(prop)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: localSendEmailBindings.get(prop)
+        };
+      }
+      return;
+    }
+  });
+  wrappedEnvBindings.set(env, wrapped);
+  return wrapped;
+}
+
+export { normalizeSendEmailMessage, createLocalSendEmailBinding, setLocalSendEmailBindings, clearLocalSendEmailBindings, wrapEnvSendEmailBindings };