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

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

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()
 		)
 	}
 `;