devflare 1.0.0-next.1 → 1.0.0-next.11

package/dist/index-dr6sbp8d.js

@@ -0,0 +1,39 @@
+import {
+  resolveConfigPath
+} from "./index-wyf3s77s.js";
+
+// src/cli/config-path.ts
+import { stat } from "node:fs/promises";
+var CONFIG_FILE_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+var SUPPORTED_CONFIG_FILENAMES = CONFIG_FILE_EXTENSIONS.map((extension) => `devflare.config${extension}`);
+function hasKnownConfigExtension(filePath) {
+  return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+async function getExistingFilePath(filePath) {
+  try {
+    const fileStat = await stat(filePath);
+    return fileStat.isFile() ? filePath : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveConfigCandidatePath(candidatePath) {
+  const candidates = [candidatePath];
+  if (!hasKnownConfigExtension(candidatePath)) {
+    for (const extension of CONFIG_FILE_EXTENSIONS) {
+      candidates.push(`${candidatePath}${extension}`);
+    }
+  }
+  for (const candidate of candidates) {
+    const existingFilePath = await getExistingFilePath(candidate);
+    if (existingFilePath) {
+      return existingFilePath;
+    }
+  }
+  return await resolveConfigPath(candidatePath) ?? null;
+}
+function formatSupportedConfigFilenames() {
+  return SUPPORTED_CONFIG_FILENAMES.join(", ");
+}
+
+export { resolveConfigCandidatePath, formatSupportedConfigFilenames };

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 };

package/dist/{index-m2q41jwa.js → index-n932ytmq.js}

@@ -9,7 +9,10 @@ import {
   parseJsonMsg,
   serializeValue,
   stringifyJsonMsg
-} from "./index-pf5s73n9.js";
+} from "./index-59df49vn.js";
+import {
+  normalizeSendEmailMessage
+} from "./index-fef08w43.js";
 
 // src/bridge/server.ts
 var server_default = {
@@ -176,6 +179,8 @@ async function executeRpcMethod(method, params, env, ctx) {
       return executeDoFetch(env, params[0], params[1], params[2]);
     case "stub.rpc":
       return executeDoRpc(env, params[0], params[1], params[2], params[3]);
+    case "email.send":
+      return executeSendEmail(binding, params[0]);
     case "send":
       return binding.send(params[0], params[1]);
     case "sendBatch":
@@ -189,6 +194,9 @@ async function executeRpcMethod(method, params, env, ctx) {
       throw new Error(`Unknown operation: ${method}`);
   }
 }
+async function executeSendEmail(binding, message) {
+  return binding.send(normalizeSendEmailMessage(message));
+}
 function serializeR2Object(obj) {
   if (!obj)
     return null;

package/dist/{index-07q6yxyc.js → index-v8vvsn9x.js}

@@ -165,4 +165,5 @@ function serviceBinding(refOrLegacy, options) {
     __ref: refOrLegacy
   };
 }
+
 export { defineConfig, ref, resolveRef, serviceBinding };

package/dist/index-vky23txa.js

@@ -0,0 +1,70 @@
+import {
+  getContextOrNull
+} from "./index-5yxg30va.js";
+import {
+  bridgeEnv
+} from "./index-59df49vn.js";
+
+// src/env.ts
+var testContextEnv = null;
+var testContextDispose = null;
+function __setTestContext(envBindings, dispose) {
+  testContextEnv = envBindings;
+  testContextDispose = dispose;
+}
+function __clearTestContext() {
+  testContextEnv = null;
+  testContextDispose = null;
+}
+var env = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "dispose") {
+      return async () => {
+        if (testContextDispose) {
+          await testContextDispose();
+          __clearTestContext();
+        }
+      };
+    }
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return ctx.env[prop];
+    }
+    if (testContextEnv) {
+      return testContextEnv[prop];
+    }
+    return bridgeEnv[prop];
+  },
+  has(_target, prop) {
+    if (prop === "dispose")
+      return true;
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return prop in ctx.env;
+    }
+    if (testContextEnv) {
+      return prop in testContextEnv;
+    }
+    return prop in bridgeEnv;
+  },
+  ownKeys(_target) {
+    const ctx = getContextOrNull();
+    if (ctx?.env) {
+      return Reflect.ownKeys(ctx.env);
+    }
+    if (testContextEnv) {
+      return Reflect.ownKeys(testContextEnv);
+    }
+    return Reflect.ownKeys(bridgeEnv);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    if (prop === "dispose") {
+      return { configurable: true, enumerable: false, writable: false };
+    }
+    const ctx = getContextOrNull();
+    const source = ctx?.env ?? testContextEnv ?? bridgeEnv;
+    return Reflect.getOwnPropertyDescriptor(source, prop);
+  }
+});
+
+export { __setTestContext, __clearTestContext, env };

package/dist/{index-z14anrqp.js → index-wfbfz02q.js}

@@ -95,11 +95,16 @@ function transformWorkerEntrypoint(code, id, options = {}) {
   }
   const fetchFn = functions.find((f) => f.name === "fetch");
   const rpcMethods = functions.filter((f) => f.name !== "fetch");
+  const needsFetchHelpers = Boolean(fetchFn);
   const s = new MagicString(code);
   const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
 `;
-  if (injectContext) {
-    s.prepend(`import { runWithContext } from 'devflare/runtime'
+  if (needsFetchHelpers) {
+    const runtimeImports = ["createFetchEvent", "invokeFetchHandler"];
+    if (injectContext) {
+      runtimeImports.push("runWithEventContext");
+    }
+    s.prepend(`import { ${runtimeImports.join(", ")} } from 'devflare/runtime'
 `);
   }
   s.prepend(importStatement);
@@ -123,29 +128,23 @@ function transformWorkerEntrypoint(code, id, options = {}) {
 class ${className} extends WorkerEntrypoint {
 `;
   if (fetchFn) {
-    if (injectContext) {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return runWithContext(
+    classBody += `	async fetch(request: Request): Promise<Response> {
 `;
-      classBody += `			this.env,
+    classBody += `		const __devflareEvent = createFetchEvent(request, this.env, this.ctx)
 `;
-      classBody += `			this.ctx,
-`;
-      classBody += `			request,
+    if (injectContext) {
+      classBody += `		return runWithEventContext(
 `;
-      classBody += `			() => __originalFetch(request, this.env, this.ctx),
+      classBody += `			__devflareEvent,
 `;
-      classBody += `			'fetch'
+      classBody += `			() => invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `		)
 `;
       classBody += `	}
 `;
     } else {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return __originalFetch(request, this.env, this.ctx)
+      classBody += `		return invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `	}
 `;