devflare 1.0.0-next.20 → 1.0.0-next.21

package/dist/index-f1yshy4s.js

@@ -0,0 +1,412 @@
+import {
+  createContextProxy,
+  createFetchEvent,
+  getContextOrNull,
+  runWithEventContext
+} from "./index-tknbyxzn.js";
+
+// src/runtime/exports.ts
+function createReadonlyProxy(getter, name) {
+  return createContextProxy(getter, name, { mutable: false });
+}
+var env = createReadonlyProxy(() => getContextOrNull()?.env, "env");
+var ctx = createReadonlyProxy(() => getContextOrNull()?.ctx, "ctx");
+var event = createReadonlyProxy(() => getContextOrNull()?.event, "event");
+var locals = createContextProxy(() => getContextOrNull()?.locals, "locals");
+// src/runtime/middleware.ts
+var FETCH_SEQUENCE_SYMBOL = Symbol.for("devflare.fetch-sequence");
+var FETCH_RESOLVE_STYLE_SYMBOL = Symbol.for("devflare.fetch-resolve-style");
+var FETCH_WORKER_STYLE_SYMBOL = Symbol.for("devflare.fetch-worker-style");
+var QUEUE_WORKER_STYLE_SYMBOL = Symbol.for("devflare.queue-worker-style");
+var SCHEDULED_WORKER_STYLE_SYMBOL = Symbol.for("devflare.scheduled-worker-style");
+function createNotFoundResponse() {
+  return new Response("Not Found", { status: 404 });
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function markResolveStyle(handler) {
+  Object.defineProperty(handler, FETCH_RESOLVE_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function markWorkerStyle(handler) {
+  Object.defineProperty(handler, FETCH_WORKER_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function defineFetchHandler(handler, options) {
+  if (options?.style === "resolve") {
+    return markResolveStyle(handler);
+  }
+  if (options?.style === "worker") {
+    return markWorkerStyle(handler);
+  }
+  return handler;
+}
+function hasResolveStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[FETCH_RESOLVE_STYLE_SYMBOL] || record[FETCH_SEQUENCE_SYMBOL]);
+}
+function hasWorkerStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[FETCH_WORKER_STYLE_SYMBOL]);
+}
+function isResolveStyleFunction(handler) {
+  return hasResolveStyleMarker(handler);
+}
+function assertExplicit2ArgStyle(handler) {
+  if (handler.length !== 2) {
+    return;
+  }
+  if (hasResolveStyleMarker(handler) || hasWorkerStyleMarker(handler)) {
+    return;
+  }
+  throw new Error("[devflare] Ambiguous 2-argument fetch handler. The calling convention must be declared explicitly via " + "`defineFetchHandler(fn, { style: 'resolve' })` (for `(event, resolve) => Response`) or " + "`defineFetchHandler(fn, { style: 'worker' })` (for `(request, env) => Response`). " + "Single-arg `(event) => Response` and 3-arg worker-style `(request, env, ctx) => Response` " + "handlers do not require wrapping.");
+}
+function defineQueueHandler(handler) {
+  Object.defineProperty(handler, QUEUE_WORKER_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function defineScheduledHandler(handler) {
+  Object.defineProperty(handler, SCHEDULED_WORKER_STYLE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function hasQueueWorkerStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[QUEUE_WORKER_STYLE_SYMBOL]);
+}
+function hasScheduledWorkerStyleMarker(handler) {
+  const record = handler;
+  return Boolean(record[SCHEDULED_WORKER_STYLE_SYMBOL]);
+}
+function assertExplicitQueueHandlerStyle(handler) {
+  if (handler.length !== 2) {
+    return;
+  }
+  if (hasQueueWorkerStyleMarker(handler)) {
+    return;
+  }
+  throw new Error("[devflare] Ambiguous 2-argument queue handler. The calling convention must be declared explicitly via " + "`defineQueueHandler(fn)` for `(batch, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(batch, env, ctx) => void` handlers do not require wrapping.");
+}
+function assertExplicitScheduledHandlerStyle(handler) {
+  if (handler.length !== 2) {
+    return;
+  }
+  if (hasScheduledWorkerStyleMarker(handler)) {
+    return;
+  }
+  throw new Error("[devflare] Ambiguous 2-argument scheduled handler. The calling convention must be declared explicitly via " + "`defineScheduledHandler(fn)` for `(controller, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(controller, env, ctx) => void` handlers do not require wrapping.");
+}
+function isWorkerStyleFetchFunction(handler) {
+  if (isResolveStyleFunction(handler)) {
+    return false;
+  }
+  if (handler.length >= 3) {
+    return true;
+  }
+  return hasWorkerStyleMarker(handler);
+}
+function invokeWorkerStyleFetchFunction(handler, event2) {
+  return handler(event2.request, event2.env, event2.ctx);
+}
+function bindMethod(target, key) {
+  if (!target || typeof target !== "object") {
+    return null;
+  }
+  const value = target[key];
+  if (!isFunction(value)) {
+    return null;
+  }
+  const boundHandler = value.bind(target);
+  if (isResolveStyleFunction(value)) {
+    markResolveStyle(boundHandler);
+  }
+  if (hasWorkerStyleMarker(value)) {
+    markWorkerStyle(boundHandler);
+  }
+  return boundHandler;
+}
+function createFetchSequence(middlewares) {
+  return async (event2, resolve = async () => createNotFoundResponse()) => {
+    const executeMiddleware = async (index, activeEvent) => {
+      if (index >= middlewares.length) {
+        return resolve(activeEvent);
+      }
+      const middleware = middlewares[index];
+      return middleware(activeEvent, async (nextEvent = activeEvent) => {
+        return executeMiddleware(index + 1, nextEvent);
+      });
+    };
+    return executeMiddleware(0, event2);
+  };
+}
+function sequence(...middlewares) {
+  const composed = createFetchSequence(middlewares);
+  Object.defineProperty(composed, FETCH_SEQUENCE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return markResolveStyle(composed);
+}
+function getDefaultHandleHandler(module) {
+  return bindMethod(module.default, "handle");
+}
+function getDefaultFetchHandler(module) {
+  const defaultExport = module.default;
+  if (isFunction(defaultExport)) {
+    return defaultExport;
+  }
+  return bindMethod(defaultExport, "fetch");
+}
+function getPrimaryFetchEntryCandidates(module) {
+  const candidates = [];
+  const namedHandle = isFunction(module.handle) ? module.handle : null;
+  if (namedHandle) {
+    candidates.push({
+      name: "handle",
+      handler: namedHandle
+    });
+  }
+  const namedFetch = isFunction(module.fetch) ? module.fetch : null;
+  if (namedFetch) {
+    candidates.push({
+      name: "fetch",
+      handler: namedFetch
+    });
+  }
+  const defaultHandle = getDefaultHandleHandler(module);
+  if (defaultHandle) {
+    candidates.push({
+      name: "default.handle",
+      handler: defaultHandle
+    });
+  }
+  const defaultFetch = getDefaultFetchHandler(module);
+  if (defaultFetch) {
+    candidates.push({
+      name: isFunction(module.default) ? "default" : "default.fetch",
+      handler: defaultFetch
+    });
+  }
+  return candidates;
+}
+function assertSinglePrimaryFetchEntry(candidates) {
+  if (candidates.length <= 1) {
+    return;
+  }
+  const foundEntries = candidates.map(({ name }) => `"${name}"`).join(", ");
+  throw new Error(`Ambiguous fetch entry module. Export exactly one primary fetch entry per module. ` + `Use either "fetch" or "handle" (or one default equivalent), not both. ` + `Found: ${foundEntries}`);
+}
+function resolveMethodHandler(module, method) {
+  const normalizedMethod = method.toUpperCase();
+  const directHandler = isFunction(module[normalizedMethod]) ? module[normalizedMethod] : bindMethod(module.default, normalizedMethod);
+  if (directHandler) {
+    return {
+      handler: directHandler,
+      stripBody: false
+    };
+  }
+  if (normalizedMethod === "HEAD") {
+    const getHandler = isFunction(module.GET) ? module.GET : bindMethod(module.default, "GET");
+    if (getHandler) {
+      return {
+        handler: getHandler,
+        stripBody: true
+      };
+    }
+  }
+  const allHandler = isFunction(module.ALL) ? module.ALL : bindMethod(module.default, "ALL");
+  if (allHandler) {
+    return {
+      handler: allHandler,
+      stripBody: false
+    };
+  }
+  return null;
+}
+async function invokeResolvedFetchHandler(handler, event2) {
+  if (isResolveStyleFunction(handler)) {
+    return handler(event2, async () => createNotFoundResponse());
+  }
+  if (isWorkerStyleFetchFunction(handler)) {
+    return invokeWorkerStyleFetchFunction(handler, event2);
+  }
+  assertExplicit2ArgStyle(handler);
+  return handler(event2);
+}
+function resolveFetchHandler(module) {
+  const candidates = getPrimaryFetchEntryCandidates(module);
+  assertSinglePrimaryFetchEntry(candidates);
+  return candidates[0]?.handler ?? null;
+}
+async function invokeFetchHandler(handler, event2, resolve = async () => createNotFoundResponse()) {
+  if (!isFunction(handler)) {
+    return resolve(event2);
+  }
+  if (isResolveStyleFunction(handler)) {
+    const response2 = await handler(event2, resolve);
+    return response2 ?? createNotFoundResponse();
+  }
+  if (isWorkerStyleFetchFunction(handler)) {
+    const response2 = await invokeWorkerStyleFetchFunction(handler, event2);
+    return response2 ?? createNotFoundResponse();
+  }
+  assertExplicit2ArgStyle(handler);
+  const response = await handler(event2);
+  return response ?? createNotFoundResponse();
+}
+function createResolveFetch(module, _currentEntry, initialEvent, options = {}) {
+  return async (nextEvent = initialEvent) => {
+    return runWithEventContext(nextEvent, async () => {
+      const methodResolution = resolveMethodHandler(module, nextEvent.request.method);
+      if (methodResolution) {
+        const response = await invokeResolvedFetchHandler(methodResolution.handler, nextEvent);
+        const finalResponse = response ?? createNotFoundResponse();
+        if (methodResolution.stripBody) {
+          return new Response(null, finalResponse);
+        }
+        return finalResponse;
+      }
+      if (options.fallbackResolve) {
+        return options.fallbackResolve(nextEvent);
+      }
+      return createNotFoundResponse();
+    });
+  };
+}
+async function invokeFetchModule(module, event2, fallbackResolve) {
+  const handler = resolveFetchHandler(module);
+  if (!handler) {
+    return createResolveFetch(module, null, event2, { fallbackResolve })(event2);
+  }
+  return invokeFetchHandler(handler, event2, createResolveFetch(module, handler, event2, { fallbackResolve }));
+}
+// src/runtime/router/index.ts
+function normalizePathname(pathname) {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  const trimmed = normalized.replace(/\/+$|\/+$/g, "");
+  return trimmed === "" ? "/" : trimmed;
+}
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function getPathSegments(pathname) {
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname === "/") {
+    return [];
+  }
+  return normalizedPathname.slice(1).split("/").filter(Boolean).map(decodePathSegment);
+}
+function getMatchPathname(input) {
+  if (input instanceof Request) {
+    return new URL(input.url).pathname;
+  }
+  if (input instanceof URL) {
+    return input.pathname;
+  }
+  if (input.includes("://")) {
+    return new URL(input).pathname;
+  }
+  return input;
+}
+function matchRouteSegments(routeSegments, pathnameSegments) {
+  if (routeSegments.length === 0) {
+    return pathnameSegments.length === 0 ? {} : null;
+  }
+  const params = {};
+  let routeIndex = 0;
+  let pathIndex = 0;
+  while (routeIndex < routeSegments.length) {
+    const routeSegment = routeSegments[routeIndex];
+    if (routeSegment.type === "optional-rest") {
+      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
+      pathIndex = pathnameSegments.length;
+      routeIndex += 1;
+      continue;
+    }
+    if (routeSegment.type === "rest") {
+      if (pathIndex >= pathnameSegments.length) {
+        return null;
+      }
+      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
+      pathIndex = pathnameSegments.length;
+      routeIndex += 1;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === undefined) {
+      return null;
+    }
+    if (routeSegment.type === "static") {
+      if (pathnameSegment !== routeSegment.value) {
+        return null;
+      }
+    } else {
+      params[routeSegment.name] = pathnameSegment;
+    }
+    pathIndex += 1;
+    routeIndex += 1;
+  }
+  if (pathIndex !== pathnameSegments.length) {
+    return null;
+  }
+  return params;
+}
+function matchFetchRoute(routes, input) {
+  const pathnameSegments = getPathSegments(getMatchPathname(input));
+  for (const route of routes) {
+    const params = matchRouteSegments(route.segments, pathnameSegments);
+    if (params) {
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return null;
+}
+async function invokeRouteModules(routes, event2) {
+  const match = matchFetchRoute(routes, event2.request);
+  if (!match) {
+    return new Response("Not Found", { status: 404 });
+  }
+  const routeEvent = createFetchEvent(event2.request, event2.env, event2.ctx, {
+    params: match.params,
+    locals: event2.locals
+  });
+  return runWithEventContext(routeEvent, () => invokeFetchModule(match.route.module, routeEvent));
+}
+function createRouteResolve(routes, initialEvent) {
+  return async (nextEvent = initialEvent) => {
+    return invokeRouteModules(routes, nextEvent);
+  };
+}
+export { env, ctx, event, locals, markResolveStyle, markWorkerStyle, defineFetchHandler, defineQueueHandler, defineScheduledHandler, assertExplicitQueueHandlerStyle, assertExplicitScheduledHandlerStyle, sequence, resolveFetchHandler, invokeFetchHandler, createResolveFetch, invokeFetchModule, matchFetchRoute, invokeRouteModules, createRouteResolve };

package/dist/index-hpwa6vsw.js

@@ -0,0 +1,239 @@
+// 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) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  try {
+    return typeof value.send === "function" && typeof value.sendBatch !== "function";
+  } catch {
+    return false;
+  }
+}
+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) {
+    const copy = new Uint8Array(raw.byteLength);
+    copy.set(raw);
+    return new Blob([copy]).stream();
+  }
+  if (raw instanceof ArrayBuffer) {
+    return new Blob([new Uint8Array(raw.slice(0))]).stream();
+  }
+  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) {
+      if (typeof prop === "string" && localSendEmailBindings.has(prop)) {
+        return localSendEmailBindings.get(prop);
+      }
+      const value = Reflect.get(target, prop, receiver);
+      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) {
+      if (typeof prop === "string" && localSendEmailBindings.has(prop)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: localSendEmailBindings.get(prop)
+        };
+      }
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (descriptor) {
+        return descriptor;
+      }
+      return;
+    }
+  });
+  wrappedEnvBindings.set(env, wrapped);
+  return wrapped;
+}
+
+export { createEmailMessageRaw, normalizeSendEmailMessage, wrapSendEmailBinding, createLocalSendEmailBinding, setLocalSendEmailBindings, clearLocalSendEmailBindings, wrapEnvSendEmailBindings };