devflare 1.0.0-next.23 → 1.0.0-next.27

package/dist/index-nhbkm2ba.js

@@ -1,467 +0,0 @@
-import {
-  bridgeEnv
-} from "./index-5enq8ntr.js";
-import {
-  wrapEnvSendEmailBindings
-} from "./index-kgstnk6g.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 };