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

package/dist/{index-67qcae0f.js → index-6v3wjg1r.js}

@@ -1,6 +1,6 @@
 import {
   normalizeDOBinding
-} from "./index-hcex3rgh.js";
+} from "./index-1phx14av.js";
 import {
   __require
 } from "./index-37x76zdn.js";
@@ -133,6 +133,7 @@ function compileBindings(bindings, result) {
     result.services = Object.entries(bindings.services).map(([binding, config]) => ({
       binding,
       service: config.service,
+      ...config.entrypoint && { entrypoint: config.entrypoint },
       ...config.environment && { environment: config.environment }
     }));
   }
@@ -160,6 +161,20 @@ function compileBindings(bindings, result) {
       dataset: config.dataset
     }));
   }
+  if (bindings.sendEmail) {
+    result.send_email = Object.entries(bindings.sendEmail).map(([name, config]) => ({
+      name,
+      ...config.destinationAddress && {
+        destination_address: config.destinationAddress
+      },
+      ...config.allowedDestinationAddresses && {
+        allowed_destination_addresses: config.allowedDestinationAddresses
+      },
+      ...config.allowedSenderAddresses && {
+        allowed_sender_addresses: config.allowedSenderAddresses
+      }
+    }));
+  }
 }
 function stringifyConfig(config) {
   const header = `// Generated by devflare — Do not edit directly

package/dist/index-8gtqgb3q.js

@@ -0,0 +1,529 @@
+import {
+  createFetchEvent,
+  getContextOrNull,
+  runWithEventContext
+} from "./index-5yxg30va.js";
+
+// src/runtime/validation.ts
+class ContextAccessError extends Error {
+  contextName;
+  propertyName;
+  constructor(contextName, propertyName) {
+    super(`Cannot access ${contextName}.${propertyName} outside of an active Devflare handler trail.
+
+` + `This typically happens when:
+` + `  1. Accessing ${contextName} at module top-level (during import)
+` + `  2. Accessing ${contextName} in a callback that runs after the handler ends
+` + `  3. Accessing ${contextName} in a setTimeout/setInterval callback
+
+` + `Move the access inside your handler function or middleware.`);
+    this.name = "ContextAccessError";
+    this.contextName = contextName;
+    this.propertyName = propertyName;
+  }
+}
+function createContextProxy(getter, name) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        throw new ContextAccessError(name, String(prop));
+      }
+      return ctx[prop];
+    },
+    set(_target, prop, value) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        throw new ContextAccessError(name, String(prop));
+      }
+      ctx[prop] = value;
+      return true;
+    },
+    has(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        return false;
+      }
+      return prop in ctx;
+    },
+    ownKeys(_target) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        return [];
+      }
+      return Reflect.ownKeys(ctx);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined) {
+        return;
+      }
+      return Reflect.getOwnPropertyDescriptor(ctx, prop);
+    }
+  });
+}
+
+// src/runtime/exports.ts
+function createReadonlyProxy(getter, name) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        throw new ContextAccessError(name, String(prop));
+      }
+      return ctx[prop];
+    },
+    set(_target, prop) {
+      throw new TypeError(`Cannot assign to '${String(prop)}' on '${name}' because it is read-only.
+` + `Use 'locals' for mutable request-scoped data.`);
+    },
+    deleteProperty(_target, prop) {
+      throw new TypeError(`Cannot delete property '${String(prop)}' from '${name}' because it is read-only.`);
+    },
+    has(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        return false;
+      }
+      return prop in ctx;
+    },
+    ownKeys(_target) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        return [];
+      }
+      return Reflect.ownKeys(ctx);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        return;
+      }
+      const descriptor = Reflect.getOwnPropertyDescriptor(ctx, prop);
+      if (descriptor) {
+        return { ...descriptor, writable: false };
+      }
+      return;
+    }
+  });
+}
+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_INVOCATION_MODE_SYMBOL = Symbol.for("devflare.fetch-invocation-mode");
+function createNotFoundResponse() {
+  return new Response("Not Found", { status: 404 });
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function markFetchInvocationMode(handler, mode) {
+  Object.defineProperty(handler, FETCH_INVOCATION_MODE_SYMBOL, {
+    value: mode,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+  return handler;
+}
+function getFetchInvocationMode(handler) {
+  return handler[FETCH_INVOCATION_MODE_SYMBOL] ?? null;
+}
+function splitParameterList(source) {
+  const parameters = [];
+  let current = "";
+  let depth = 0;
+  for (const char of source) {
+    if (char === "," && depth === 0) {
+      if (current.trim()) {
+        parameters.push(current.trim());
+      }
+      current = "";
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{" || char === "<") {
+      depth += 1;
+    } else if (char === ")" || char === "]" || char === "}" || char === ">") {
+      depth = Math.max(0, depth - 1);
+    }
+    current += char;
+  }
+  if (current.trim()) {
+    parameters.push(current.trim());
+  }
+  return parameters;
+}
+function getFunctionParameterNames(handler) {
+  const source = handler.toString().trim();
+  const parenthesizedMatch = source.match(/^[^(]*\(([^)]*)\)/);
+  if (parenthesizedMatch) {
+    return splitParameterList(parenthesizedMatch[1]);
+  }
+  const singleParameterArrowMatch = source.match(/^(?:async\s+)?([^=()\s]+)\s*=>/);
+  if (singleParameterArrowMatch) {
+    return [singleParameterArrowMatch[1].trim()];
+  }
+  return [];
+}
+function isResolveStyleFunction(handler) {
+  const mode = getFetchInvocationMode(handler);
+  if (mode) {
+    return mode === "resolve";
+  }
+  if (handler[FETCH_SEQUENCE_SYMBOL]) {
+    return true;
+  }
+  if (handler.length !== 2) {
+    return false;
+  }
+  const parameterNames = getFunctionParameterNames(handler);
+  const secondParameter = parameterNames[1]?.trim().toLowerCase() ?? "";
+  return secondParameter === "resolve" || secondParameter.endsWith("resolve");
+}
+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)) {
+    return markFetchInvocationMode(boundHandler, "resolve");
+  }
+  return boundHandler;
+}
+function createLegacySequence(middlewares) {
+  return (handler) => {
+    if (middlewares.length === 0) {
+      return async () => {
+        const response = await handler();
+        return response ?? createNotFoundResponse();
+      };
+    }
+    return async () => {
+      let index = 0;
+      const executeMiddleware = async () => {
+        if (index < middlewares.length) {
+          const middleware = middlewares[index++];
+          return middleware(executeMiddleware);
+        }
+        const response = await handler();
+        return response ?? createNotFoundResponse();
+      };
+      return executeMiddleware();
+    };
+  };
+}
+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 legacySequence = createLegacySequence(middlewares);
+  const fetchSequence = createFetchSequence(middlewares);
+  const composed = (...args) => {
+    if (args.length === 1 && isFunction(args[0])) {
+      return legacySequence(args[0]);
+    }
+    return fetchSequence(args[0], args[1] ?? (async () => createNotFoundResponse()));
+  };
+  Object.defineProperty(composed, FETCH_SEQUENCE_SYMBOL, {
+    value: true,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return composed;
+}
+function handle(...handlers) {
+  return async () => {
+    for (const handler of handlers) {
+      const response = await handler();
+      if (response !== null) {
+        return response;
+      }
+    }
+    return null;
+  };
+}
+function resolve(...handlers) {
+  return handle(...handlers);
+}
+function pipe(middlewares, handlers) {
+  return createLegacySequence(middlewares)(handle(...handlers));
+}
+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 (handler.length >= 4) {
+    return handler(event2, event2.env, event2.ctx, event2.params);
+  }
+  if (handler.length === 3) {
+    return handler(event2, event2.env, event2.ctx);
+  }
+  if (handler.length === 2) {
+    return handler(event2, event2.params);
+  }
+  if (handler.length === 0) {
+    return handler();
+  }
+  return handler(event2);
+}
+function resolveFetchHandler(module) {
+  const candidates = getPrimaryFetchEntryCandidates(module);
+  assertSinglePrimaryFetchEntry(candidates);
+  return candidates[0]?.handler ?? null;
+}
+async function invokeFetchHandler(handler, event2, resolve2 = async () => createNotFoundResponse()) {
+  if (!isFunction(handler)) {
+    return resolve2(event2);
+  }
+  if (isResolveStyleFunction(handler)) {
+    const response2 = await handler(event2, resolve2);
+    return response2 ?? createNotFoundResponse();
+  }
+  if (handler.length >= 4) {
+    const response2 = await handler(event2, event2.env, event2.ctx, event2.params);
+    return response2 ?? createNotFoundResponse();
+  }
+  if (handler.length === 3) {
+    const response2 = await handler(event2, event2.env, event2.ctx);
+    return response2 ?? createNotFoundResponse();
+  }
+  if (handler.length === 2) {
+    const response2 = await handler(event2, event2.env);
+    return response2 ?? createNotFoundResponse();
+  }
+  if (handler.length === 0) {
+    const response2 = await handler();
+    return response2 ?? createNotFoundResponse();
+  }
+  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.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 { ContextAccessError, createContextProxy, env, ctx, event, locals, sequence, handle, resolve, pipe, resolveFetchHandler, invokeFetchHandler, createResolveFetch, invokeFetchModule, matchFetchRoute, invokeRouteModules, createRouteResolve };