devflare 1.0.0-next.14 → 1.0.0-next.16

package/dist/index-9n6djthj.js

@@ -0,0 +1,490 @@
+import {
+  createFetchEvent,
+  getContextOrNull,
+  runWithEventContext
+} from "./index-cgbvmse6.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_RESOLVE_STYLE_SYMBOL = Symbol.for("devflare.fetch-resolve-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 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) {
+  if (handler[FETCH_RESOLVE_STYLE_SYMBOL]) {
+    return true;
+  }
+  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 normalizeParameterName(parameterName) {
+  return parameterName?.trim().toLowerCase() ?? "";
+}
+function isParamsStyleFunction(handler) {
+  if (handler.length !== 2) {
+    return false;
+  }
+  const parameterNames = getFunctionParameterNames(handler);
+  const secondParameter = normalizeParameterName(parameterNames[1]);
+  return secondParameter === "params" || secondParameter.endsWith("params");
+}
+function isRequestStyleParameterName(parameterName) {
+  if (!parameterName || parameterName.startsWith("{") || parameterName.startsWith("[")) {
+    return false;
+  }
+  return parameterName === "request" || parameterName === "req" || parameterName.endsWith("request") || parameterName.endsWith("req");
+}
+function isWorkerStyleFetchFunction(handler) {
+  if (isResolveStyleFunction(handler)) {
+    return false;
+  }
+  if (handler.length >= 3) {
+    return true;
+  }
+  if (handler.length === 2) {
+    return !isParamsStyleFunction(handler);
+  }
+  if (handler.length === 1) {
+    const parameterNames = getFunctionParameterNames(handler);
+    return isRequestStyleParameterName(normalizeParameterName(parameterNames[0]));
+  }
+  return false;
+}
+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);
+  return isResolveStyleFunction(value) ? markResolveStyle(boundHandler) : 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 (isParamsStyleFunction(handler)) {
+    return handler(event2, event2.params);
+  }
+  if (isWorkerStyleFetchFunction(handler)) {
+    return invokeWorkerStyleFetchFunction(handler, event2);
+  }
+  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();
+  }
+  const response = await (isWorkerStyleFetchFunction(handler) ? invokeWorkerStyleFetchFunction(handler, event2) : 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, resolveFetchHandler, invokeFetchHandler, createResolveFetch, invokeFetchModule, matchFetchRoute, invokeRouteModules, createRouteResolve };

package/dist/index-aabgympv.js

@@ -0,0 +1,39 @@
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/cli/generated-artifacts.ts
+import { resolve } from "pathe";
+var DEVFLARE_DIR = [".devflare"];
+var DEVFLARE_BUILD_DIR = [".devflare", "build"];
+var WRANGLER_DEPLOY_DIR = [".wrangler", "deploy"];
+function getGeneratedArtifactPaths(cwd) {
+  const devflareDir = resolve(cwd, ...DEVFLARE_DIR);
+  const buildDir = resolve(cwd, ...DEVFLARE_BUILD_DIR);
+  const deployDir = resolve(cwd, ...WRANGLER_DEPLOY_DIR);
+  return {
+    devflareDir,
+    devWranglerConfigPath: resolve(devflareDir, "wrangler.jsonc"),
+    buildDir,
+    buildWorkerPath: resolve(buildDir, "worker.js"),
+    buildWranglerConfigPath: resolve(buildDir, "wrangler.jsonc"),
+    deployDir,
+    deployRedirectPath: resolve(deployDir, "config.json")
+  };
+}
+async function ensureGeneratedDirectory(dirPath, writeGitignore = false) {
+  const fs = await import("node:fs/promises");
+  await fs.mkdir(dirPath, { recursive: true });
+  if (!writeGitignore) {
+    return;
+  }
+  const gitignorePath = resolve(dirPath, ".gitignore");
+  try {
+    await fs.access(gitignorePath);
+  } catch {
+    await fs.writeFile(gitignorePath, `*
+`, "utf-8");
+  }
+}
+
+export { getGeneratedArtifactPaths, ensureGeneratedDirectory };

package/dist/index-b8m6883k.js

@@ -0,0 +1,74 @@
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./index-yzddwp02.js";
+import {
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  getWorkspaceAccountId
+} from "./index-jb75kwa4.js";
+
+// src/cli/command-utils.ts
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function resolveNamedSelection(options) {
+  if (options.explicitValue) {
+    return {
+      value: options.explicitValue,
+      source: "option"
+    };
+  }
+  if (options.fallbackValue) {
+    return {
+      value: options.fallbackValue,
+      source: "arg"
+    };
+  }
+  if (options.configuredValue) {
+    return {
+      value: options.configuredValue,
+      source: "config"
+    };
+  }
+  return {
+    value: undefined,
+    source: "none"
+  };
+}
+async function getConfiguredAccountId(cwd) {
+  const workspaceAccountId = getWorkspaceAccountId();
+  if (workspaceAccountId) {
+    return workspaceAccountId;
+  }
+  const envAccountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+  if (envAccountId) {
+    return envAccountId;
+  }
+  const configPath = await resolveConfigPath(cwd);
+  if (!configPath) {
+    return;
+  }
+  try {
+    const config = await loadConfig({ cwd });
+    return config.accountId;
+  } catch {
+    return;
+  }
+}
+async function resolveCloudflareAccountId(options) {
+  if (options.explicitAccountId) {
+    return options.explicitAccountId;
+  }
+  if (options.configuredAccountId) {
+    return options.configuredAccountId;
+  }
+  const primaryAccount = await getPrimaryAccount(options.apiOptions);
+  if (!primaryAccount) {
+    return;
+  }
+  const effective = await getEffectiveAccountId(primaryAccount.id);
+  return effective.accountId;
+}
+
+export { asOptionalString, resolveNamedSelection, getConfiguredAccountId, resolveCloudflareAccountId };

package/dist/{index-5yxg30va.js → index-cgbvmse6.js}

@@ -1,10 +1,8 @@
 import {
   wrapEnvSendEmailBindings
-} from "./index-fef08w43.js";
+} from "./index-h18pxvzs.js";
 
-// src/runtime/context.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage;
+// src/runtime/context-events.ts
 function createLocals(locals) {
   return locals ?? {};
 }
@@ -59,6 +57,7 @@ function createFetchEvent(request, env, ctx, options = {}) {
     env: runtimeEnv,
     ctx,
     locals,
+    url: new URL(request.url),
     request,
     params: options.params ?? {}
   });
@@ -178,13 +177,23 @@ function createDefaultEvent(env, ctx, request, type, locals) {
   if (type === "durable-object-fetch" && request && ctx) {
     return createDurableObjectFetchEvent(request, env, ctx, { locals });
   }
+  if (type === "durable-object-alarm" && ctx) {
+    return createDurableObjectAlarmEvent(env, ctx, { locals });
+  }
   return createBaseEvent(type, env, ctx, {
     locals,
     request
   });
 }
+
+// src/runtime/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage;
+function createLocals2() {
+  return {};
+}
 function runWithContext(env, ctx, request, fn, type = "fetch") {
-  const locals = createLocals();
+  const locals = createLocals2();
   const event = createDefaultEvent(env, ctx, request, type, locals);
   return runWithEventContext(event, fn);
 }
@@ -261,7 +270,7 @@ function isDurableObjectFetchEvent(event) {
   return event.type === "durable-object-fetch" && event.request instanceof Request;
 }
 function isDurableObjectAlarmEvent(event) {
-  return event.type === "durable-object-alarm";
+  return event.type === "durable-object-alarm" && "state" in event;
 }
 function isDurableObjectWebSocketMessageEvent(event) {
   return event.type === "durable-object-websocket-message" && "ws" in event && "message" in event;