devflare 1.0.0-next.19 → 1.0.0-next.20

package/dist/index-p0zppqxm.js

@@ -0,0 +1,467 @@
+import {
+  bridgeEnv
+} from "./index-hpjh0qjx.js";
+import {
+  wrapEnvSendEmailBindings
+} from "./index-124e9t4t.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, options = {}) {
+  const mutable = options.mutable ?? true;
+  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, value) {
+      if (!mutable) {
+        throw new TypeError(`Cannot assign to '${String(prop)}' on '${name}' because it is read-only.
+` + `Use 'locals' for mutable request-scoped data.`);
+      }
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        throw new ContextAccessError(name, String(prop));
+      }
+      ctx[prop] = value;
+      return true;
+    },
+    deleteProperty(_target, prop) {
+      if (!mutable) {
+        throw new TypeError(`Cannot delete property '${String(prop)}' from '${name}' because it is read-only.`);
+      }
+      const ctx = getter();
+      if (ctx === undefined || ctx === null) {
+        return true;
+      }
+      return Reflect.deleteProperty(ctx, prop);
+    },
+    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;
+      }
+      if (!mutable) {
+        return { ...descriptor, writable: false };
+      }
+      return descriptor;
+    }
+  });
+}
+
+// src/runtime/context-events.ts
+function createLocals(locals) {
+  return locals ?? {};
+}
+function prepareEventShell(env, options = {}) {
+  return {
+    env: wrapEnvSendEmailBindings(env),
+    locals: createLocals(options.locals)
+  };
+}
+function createAugmentedTarget(target, extra) {
+  return new Proxy(target, {
+    get(target2, prop) {
+      if (prop in extra) {
+        return extra[prop];
+      }
+      const value = Reflect.get(target2, prop, target2);
+      return typeof value === "function" ? value.bind(target2) : value;
+    },
+    has(target2, prop) {
+      return prop in extra || prop in target2;
+    },
+    ownKeys(target2) {
+      return Array.from(new Set([
+        ...Reflect.ownKeys(target2),
+        ...Reflect.ownKeys(extra)
+      ]));
+    },
+    getOwnPropertyDescriptor(target2, prop) {
+      if (prop in extra) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: extra[prop]
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(target2, prop);
+    }
+  });
+}
+function createBaseEvent(type, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return {
+    type,
+    ctx,
+    ...shell,
+    request: options.request ?? null,
+    params: options.params
+  };
+}
+function createFetchEvent(request, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(request, {
+    type: "fetch",
+    ctx,
+    ...shell,
+    url: new URL(request.url),
+    request,
+    params: options.params ?? {}
+  });
+}
+function createQueueEvent(batch, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(batch, {
+    type: "queue",
+    ctx,
+    ...shell,
+    batch
+  });
+}
+function createScheduledEvent(controller, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(controller, {
+    type: "scheduled",
+    ctx,
+    ...shell,
+    controller
+  });
+}
+function createEmailEvent(message, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(message, {
+    type: "email",
+    ctx,
+    ...shell,
+    message
+  });
+}
+function createTailEvent(events, env, ctx, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(events, {
+    type: "tail",
+    ctx,
+    ...shell,
+    events
+  });
+}
+function createDurableObjectFetchEvent(request, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(request, {
+    type: "durable-object-fetch",
+    ctx: state,
+    state,
+    ...shell,
+    request
+  });
+}
+function createDurableObjectAlarmEvent(env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return {
+    type: "durable-object-alarm",
+    ctx: state,
+    state,
+    ...shell
+  };
+}
+function createDurableObjectWebSocketMessageEvent(ws, message, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-message",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    message
+  });
+}
+function createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-close",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    code,
+    reason,
+    wasClean
+  });
+}
+function createDurableObjectWebSocketErrorEvent(ws, error, env, state, options = {}) {
+  const shell = prepareEventShell(env, { locals: options.locals });
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-error",
+    ctx: state,
+    state,
+    ...shell,
+    ws,
+    error
+  });
+}
+function createDefaultEvent(env, ctx, request, type, locals) {
+  switch (type) {
+    case "fetch": {
+      if (request && ctx) {
+        return createFetchEvent(request, env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals, request });
+    }
+    case "durable-object-fetch": {
+      if (request && ctx) {
+        return createDurableObjectFetchEvent(request, env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals, request });
+    }
+    case "durable-object-alarm": {
+      if (ctx) {
+        return createDurableObjectAlarmEvent(env, ctx, { locals });
+      }
+      return createBaseEvent(type, env, ctx, { locals });
+    }
+    case "queue":
+    case "scheduled":
+    case "email":
+    case "tail":
+    case "durable-object-websocket-message":
+    case "durable-object-websocket-close":
+    case "durable-object-websocket-error":
+      return createBaseEvent(type, env, ctx, { locals, request });
+    default: {
+      const exhaustive = type;
+      throw new Error(`createDefaultEvent: unknown event type ${String(exhaustive)}`);
+    }
+  }
+}
+
+// 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 = createLocals2();
+  const event = createDefaultEvent(env, ctx, request, type, locals);
+  return runWithEventContext(event, fn);
+}
+function runWithEventContext(event, fn) {
+  const context = {
+    env: event.env,
+    ctx: event.ctx,
+    request: event.request ?? null,
+    locals: event.locals,
+    type: event.type,
+    event
+  };
+  return storage.run(context, fn);
+}
+function getContext() {
+  const context = storage.getStore();
+  if (!context) {
+    throw new ContextUnavailableError;
+  }
+  return context;
+}
+function getContextOrNull() {
+  const context = storage.getStore();
+  return context ?? null;
+}
+function getEventContext() {
+  return getContext().event;
+}
+function getEventContextOrNull() {
+  return getContextOrNull()?.event ?? null;
+}
+function hasContext() {
+  return storage.getStore() !== undefined;
+}
+function createEventAccessor(name, matcher) {
+  const accessor = () => {
+    const currentEvent = getEventContextOrNull();
+    if (!currentEvent) {
+      throw new ContextUnavailableError;
+    }
+    if (!matcher(currentEvent)) {
+      throw new ContextUnavailableError(`${name} is not available in the current '${currentEvent.type}' context.
+
+Devflare stores event objects in AsyncLocalStorage so helpers called within a handler can reach the active event.
+Use ${name}.safe() to return null instead of throwing, or call the getter that matches the active surface.`);
+    }
+    return currentEvent;
+  };
+  accessor.safe = () => {
+    const currentEvent = getEventContextOrNull();
+    return currentEvent && matcher(currentEvent) ? currentEvent : null;
+  };
+  return accessor;
+}
+function isFetchEvent(event) {
+  return event.type === "fetch" && event.request instanceof Request;
+}
+function isQueueEvent(event) {
+  return event.type === "queue" && "batch" in event;
+}
+function isScheduledEvent(event) {
+  return event.type === "scheduled" && "controller" in event;
+}
+function isEmailEvent(event) {
+  return event.type === "email" && "message" in event;
+}
+function isTailEvent(event) {
+  return event.type === "tail" && Array.isArray(event) && "events" in event;
+}
+function isDurableObjectEvent(event) {
+  return event.type.startsWith("durable-object-") && "state" in event;
+}
+function isDurableObjectFetchEvent(event) {
+  return event.type === "durable-object-fetch" && event.request instanceof Request;
+}
+function isDurableObjectAlarmEvent(event) {
+  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;
+}
+function isDurableObjectWebSocketCloseEvent(event) {
+  return event.type === "durable-object-websocket-close" && "ws" in event && "code" in event;
+}
+function isDurableObjectWebSocketErrorEvent(event) {
+  return event.type === "durable-object-websocket-error" && "ws" in event && "error" in event;
+}
+var getFetchEvent = createEventAccessor("getFetchEvent()", isFetchEvent);
+var getQueueEvent = createEventAccessor("getQueueEvent()", isQueueEvent);
+var getScheduledEvent = createEventAccessor("getScheduledEvent()", isScheduledEvent);
+var getEmailEvent = createEventAccessor("getEmailEvent()", isEmailEvent);
+var getTailEvent = createEventAccessor("getTailEvent()", isTailEvent);
+var getDurableObjectEvent = createEventAccessor("getDurableObjectEvent()", isDurableObjectEvent);
+var getDurableObjectFetchEvent = createEventAccessor("getDurableObjectFetchEvent()", isDurableObjectFetchEvent);
+var getDurableObjectAlarmEvent = createEventAccessor("getDurableObjectAlarmEvent()", isDurableObjectAlarmEvent);
+var getDurableObjectWebSocketMessageEvent = createEventAccessor("getDurableObjectWebSocketMessageEvent()", isDurableObjectWebSocketMessageEvent);
+var getDurableObjectWebSocketCloseEvent = createEventAccessor("getDurableObjectWebSocketCloseEvent()", isDurableObjectWebSocketCloseEvent);
+var getDurableObjectWebSocketErrorEvent = createEventAccessor("getDurableObjectWebSocketErrorEvent()", isDurableObjectWebSocketErrorEvent);
+
+class ContextUnavailableError extends ContextAccessError {
+  code = "CONTEXT_UNAVAILABLE";
+  constructor(message) {
+    super("context", "<unavailable>");
+    if (message !== undefined) {
+      this.message = message;
+    } else {
+      this.message = `Context not available. Devflare uses AsyncLocalStorage to carry the active event through fetch, queue, scheduled, email, tail, and Durable Object handler call chains.
+
+` + `This usually means one of:
+
+` + `1. Accessing context at module top-level (runs at cold start, not per-request)
+` + `2. Accessing context in setTimeout/setInterval callbacks
+` + `3. Missing 'nodejs_compat' compatibility flag in your worker config
+
+` + `Fix: Move the access inside your handler, middleware, or a helper called from that handler trail.
+` + `Learn more: https://devflare.dev/docs/context-errors`;
+    }
+    this.name = "ContextUnavailableError";
+  }
+}
+
+// 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 { ContextAccessError, createContextProxy, createFetchEvent, createQueueEvent, createScheduledEvent, createEmailEvent, createTailEvent, createDurableObjectFetchEvent, createDurableObjectAlarmEvent, createDurableObjectWebSocketMessageEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, runWithContext, runWithEventContext, getContext, getContextOrNull, getEventContext, getEventContextOrNull, hasContext, getFetchEvent, getQueueEvent, getScheduledEvent, getEmailEvent, getTailEvent, getDurableObjectEvent, getDurableObjectFetchEvent, getDurableObjectAlarmEvent, getDurableObjectWebSocketMessageEvent, getDurableObjectWebSocketCloseEvent, getDurableObjectWebSocketErrorEvent, ContextUnavailableError, __setTestContext, __clearTestContext, env };