nitro 2.2.28 → 3.0.0

package/dist/runtime/index.d.mts

@@ -0,0 +1,11 @@
+export { defineNitroPlugin } from "./internal/plugin.mjs";
+export { defineRouteMeta } from "./internal/meta.mjs";
+export { defineNitroErrorHandler } from "./internal/error/utils.mjs";
+export { useRuntimeConfig } from "./internal/runtime-config.mjs";
+export { useRequest } from "./internal/context.mjs";
+export { defineRenderHandler } from "./internal/renderer.mjs";
+export { defineCachedFunction, defineCachedEventHandler, defineCachedHandler, cachedFunction, cachedEventHandler, } from "./internal/cache.mjs";
+export { useNitroApp } from "./internal/app.mjs";
+export { useStorage } from "./internal/storage.mjs";
+export { useDatabase } from "./internal/database.mjs";
+export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/index.mjs

@@ -0,0 +1,17 @@
+export { defineNitroPlugin } from "./internal/plugin.mjs";
+export { defineRouteMeta } from "./internal/meta.mjs";
+export { defineNitroErrorHandler } from "./internal/error/utils.mjs";
+export { useRuntimeConfig } from "./internal/runtime-config.mjs";
+export { useRequest } from "./internal/context.mjs";
+export { defineRenderHandler } from "./internal/renderer.mjs";
+export {
+  defineCachedFunction,
+  defineCachedEventHandler,
+  defineCachedHandler,
+  cachedFunction,
+  cachedEventHandler
+} from "./internal/cache.mjs";
+export { useNitroApp } from "./internal/app.mjs";
+export { useStorage } from "./internal/storage.mjs";
+export { useDatabase } from "./internal/database.mjs";
+export { defineTask, runTask } from "./internal/task.mjs";

package/dist/runtime/internal/app.d.mts

@@ -0,0 +1,2 @@
+import type { NitroApp } from "nitro/types";
+export declare function useNitroApp(): NitroApp;

package/dist/runtime/internal/app.mjs

@@ -0,0 +1,153 @@
+import { H3Core, toRequest } from "h3";
+import { createHooks } from "hookable";
+import { nitroAsyncContext } from "./context.mjs";
+import errorHandler from "#nitro-internal-virtual/error-handler";
+import { plugins } from "#nitro-internal-virtual/plugins";
+import {
+  findRoute,
+  findRouteRules,
+  globalMiddleware,
+  findRoutedMiddleware
+} from "#nitro-internal-virtual/routing";
+export function useNitroApp() {
+  return useNitroApp.__instance__ ??= initNitroApp();
+}
+function initNitroApp() {
+  const nitroApp = createNitroApp();
+  for (const plugin of plugins) {
+    try {
+      plugin(nitroApp);
+    } catch (error) {
+      nitroApp.captureError(error, { tags: ["plugin"] });
+      throw error;
+    }
+  }
+  return nitroApp;
+}
+function createNitroApp() {
+  const hooks = createHooks();
+  const captureError = (error, errorCtx) => {
+    const promise = hooks.callHookParallel("error", error, errorCtx).catch((hookError) => {
+      console.error("Error while capturing another error", hookError);
+    });
+    if (errorCtx?.event) {
+      const errors = errorCtx.event.req.context?.nitro?.errors;
+      if (errors) {
+        errors.push({ error, context: errorCtx });
+      }
+      if (typeof errorCtx.event.req.waitUntil === "function") {
+        errorCtx.event.req.waitUntil(promise);
+      }
+    }
+  };
+  const h3App = createH3App(captureError);
+  let fetchHandler = async (req) => {
+    req.context ??= {};
+    req.context.nitro = req.context.nitro || { errors: [] };
+    const event = { req };
+    const nitroApp = useNitroApp();
+    await nitroApp.hooks.callHook("request", event).catch((error) => {
+      captureError(error, { event, tags: ["request"] });
+    });
+    const response = await h3App.request(req, void 0, req.context);
+    await nitroApp.hooks.callHook("response", response, event).catch((error) => {
+      captureError(error, { event, tags: ["request", "response"] });
+    });
+    return response;
+  };
+  if (import.meta._asyncContext) {
+    const originalFetchHandler = fetchHandler;
+    fetchHandler = (req) => {
+      const asyncCtx = { request: req };
+      return nitroAsyncContext.callAsync(
+        asyncCtx,
+        () => originalFetchHandler(req)
+      );
+    };
+  }
+  const requestHandler = (input, init, context) => {
+    const req = toRequest(input, init);
+    req.context = { ...req.context, ...context };
+    return Promise.resolve(fetchHandler(req));
+  };
+  const originalFetch = globalThis.fetch;
+  const nitroFetch = (input, init) => {
+    if (typeof input === "string" && input.startsWith("/")) {
+      return requestHandler(input, init);
+    }
+    if (input instanceof Request && "_request" in input) {
+      input = input._request;
+    }
+    return originalFetch(input, init);
+  };
+  globalThis.fetch = nitroFetch;
+  const app = {
+    _h3: h3App,
+    hooks,
+    fetch: requestHandler,
+    captureError
+  };
+  return app;
+}
+function createH3App(captureError) {
+  const DEBUG_MODE = ["1", "true", "TRUE"].includes(process.env.DEBUG + "");
+  const h3App = new H3Core({
+    debug: DEBUG_MODE,
+    onError: (error, event) => {
+      captureError(error, { event, tags: ["request"] });
+      return errorHandler(error, event);
+    }
+  });
+  h3App._findRoute = (event) => findRoute(event.req.method, event.url.pathname);
+  h3App._getMiddleware = (event, route) => {
+    const pathname = event.url.pathname;
+    const method = event.req.method;
+    const { routeRules, routeRuleMiddleware } = getRouteRules(method, pathname);
+    event.context.routeRules = routeRules;
+    return [
+      ...routeRuleMiddleware,
+      ...globalMiddleware,
+      ...findRoutedMiddleware(method, pathname).map((r) => r.data),
+      ...route?.data?.middleware || []
+    ].filter(Boolean);
+  };
+  return h3App;
+}
+function getRouteRules(method, pathname) {
+  const m = findRouteRules(method, pathname);
+  if (!m?.length) {
+    return { routeRuleMiddleware: [] };
+  }
+  const routeRules = {};
+  for (const layer of m) {
+    for (const rule of layer.data) {
+      const currentRule = routeRules[rule.name];
+      if (currentRule) {
+        if (rule.options === false) {
+          delete routeRules[rule.name];
+          continue;
+        }
+        if (typeof currentRule.options === "object" && typeof rule.options === "object") {
+          currentRule.options = { ...currentRule.options, ...rule.options };
+        } else {
+          currentRule.options = rule.options;
+        }
+        currentRule.route = rule.route;
+        currentRule.params = { ...currentRule.params, ...layer.params };
+      } else if (rule.options !== false) {
+        routeRules[rule.name] = { ...rule, params: layer.params };
+      }
+    }
+  }
+  const middleware = [];
+  for (const rule of Object.values(routeRules)) {
+    if (rule.options === false || !rule.handler) {
+      continue;
+    }
+    middleware.push(rule.handler(rule));
+  }
+  return {
+    routeRules,
+    routeRuleMiddleware: middleware
+  };
+}

package/dist/runtime/internal/cache.d.mts

@@ -0,0 +1,7 @@
+import type { EventHandler } from "h3";
+import type { CacheOptions, CachedEventHandlerOptions } from "nitro/types";
+export declare function defineCachedFunction<T, ArgsT extends unknown[] = any[]>(fn: (...args: ArgsT) => T | Promise<T>, opts?: CacheOptions<T, ArgsT>): (...args: ArgsT) => Promise<T>;
+export declare function cachedFunction<T, ArgsT extends unknown[] = any[]>(fn: (...args: ArgsT) => T | Promise<T>, opts?: CacheOptions<T>): (...args: ArgsT) => Promise<T | undefined>;
+export declare function defineCachedEventHandler(handler: EventHandler, opts?: CachedEventHandlerOptions): EventHandler;
+export declare const cachedEventHandler: typeof defineCachedEventHandler;
+export declare const defineCachedHandler: typeof defineCachedEventHandler;

package/dist/runtime/internal/cache.mjs

@@ -0,0 +1,236 @@
+import { defineHandler, handleCacheHeaders, isHTTPEvent, toResponse } from "h3";
+import { FastResponse } from "srvx";
+import { parseURL } from "ufo";
+import { hash } from "ohash";
+import { useNitroApp } from "./app.mjs";
+import { useStorage } from "./storage.mjs";
+function defaultCacheOptions() {
+  return {
+    name: "_",
+    base: "/cache",
+    swr: true,
+    maxAge: 1
+  };
+}
+export function defineCachedFunction(fn, opts = {}) {
+  opts = { ...defaultCacheOptions(), ...opts };
+  const pending = {};
+  const group = opts.group || "nitro/functions";
+  const name = opts.name || fn.name || "_";
+  const integrity = opts.integrity || hash([fn, opts]);
+  const validate = opts.validate || ((entry) => entry.value !== void 0);
+  async function get(key, resolver, shouldInvalidateCache, event) {
+    const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
+    let entry = await useStorage().getItem(cacheKey).catch((error) => {
+      console.error(`[cache] Cache read error.`, error);
+      useNitroApp().captureError(error, { event, tags: ["cache"] });
+    }) || {};
+    if (typeof entry !== "object") {
+      entry = {};
+      const error = new Error("Malformed data read from cache.");
+      console.error("[cache]", error);
+      useNitroApp().captureError(error, { event, tags: ["cache"] });
+    }
+    const ttl = (opts.maxAge ?? 0) * 1e3;
+    if (ttl) {
+      entry.expires = Date.now() + ttl;
+    }
+    const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false;
+    const _resolve = async () => {
+      const isPending = pending[key];
+      if (!isPending) {
+        if (entry.value !== void 0 && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
+          entry.value = void 0;
+          entry.integrity = void 0;
+          entry.mtime = void 0;
+          entry.expires = void 0;
+        }
+        pending[key] = Promise.resolve(resolver());
+      }
+      try {
+        entry.value = await pending[key];
+      } catch (error) {
+        if (!isPending) {
+          delete pending[key];
+        }
+        throw error;
+      }
+      if (!isPending) {
+        entry.mtime = Date.now();
+        entry.integrity = integrity;
+        delete pending[key];
+        if (validate(entry) !== false) {
+          let setOpts;
+          if (opts.maxAge && !opts.swr) {
+            setOpts = { ttl: opts.maxAge };
+          }
+          const promise = useStorage().setItem(cacheKey, entry, setOpts).catch((error) => {
+            console.error(`[cache] Cache write error.`, error);
+            useNitroApp().captureError(error, { event, tags: ["cache"] });
+          });
+          if (typeof event?.req?.waitUntil === "function") {
+            event.req.waitUntil(promise);
+          }
+        }
+      }
+    };
+    const _resolvePromise = expired ? _resolve() : Promise.resolve();
+    if (entry.value === void 0) {
+      await _resolvePromise;
+    } else if (expired && event && event.req.waitUntil) {
+      event.req.waitUntil(_resolvePromise);
+    }
+    if (opts.swr && validate(entry) !== false) {
+      _resolvePromise.catch((error) => {
+        console.error(`[cache] SWR handler error.`, error);
+        useNitroApp().captureError(error, { event, tags: ["cache"] });
+      });
+      return entry;
+    }
+    return _resolvePromise.then(() => entry);
+  }
+  return async (...args) => {
+    const shouldBypassCache = await opts.shouldBypassCache?.(...args);
+    if (shouldBypassCache) {
+      return fn(...args);
+    }
+    const key = await (opts.getKey || getKey)(...args);
+    const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args);
+    const entry = await get(
+      key,
+      () => fn(...args),
+      shouldInvalidateCache,
+      args[0] && isHTTPEvent(args[0]) ? args[0] : void 0
+    );
+    let value = entry.value;
+    if (opts.transform) {
+      value = await opts.transform(entry, ...args) || value;
+    }
+    return value;
+  };
+}
+export function cachedFunction(fn, opts = {}) {
+  return defineCachedFunction(fn, opts);
+}
+function getKey(...args) {
+  return args.length > 0 ? hash(args) : "";
+}
+function escapeKey(key) {
+  return String(key).replace(/\W/g, "");
+}
+export function defineCachedEventHandler(handler, opts = defaultCacheOptions()) {
+  const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort();
+  const _opts = {
+    ...opts,
+    shouldBypassCache: (event) => {
+      return event.req.method !== "GET" && event.req.method !== "HEAD";
+    },
+    getKey: async (event) => {
+      const customKey = await opts.getKey?.(event);
+      if (customKey) {
+        return escapeKey(customKey);
+      }
+      const _path = event.url.pathname + event.url.search;
+      let _pathname;
+      try {
+        _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
+      } catch {
+        _pathname = "-";
+      }
+      const _hashedPath = `${_pathname}.${hash(_path)}`;
+      const _headers = variableHeaderNames.map((header) => [header, event.req.headers.get(header)]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
+      return [_hashedPath, ..._headers].join(":");
+    },
+    validate: (entry) => {
+      if (!entry.value) {
+        return false;
+      }
+      if (entry.value.status >= 400) {
+        return false;
+      }
+      if (entry.value.body === void 0) {
+        return false;
+      }
+      if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
+        return false;
+      }
+      return true;
+    },
+    group: opts.group || "nitro/handlers",
+    integrity: opts.integrity || hash([handler, opts])
+  };
+  const _cachedHandler = cachedFunction(
+    async (event) => {
+      const filteredHeaders = [...event.req.headers.entries()].filter(
+        ([key]) => !variableHeaderNames.includes(key.toLowerCase())
+      );
+      try {
+        const originalReq = event.req;
+        event.req = new Request(event.req.url, {
+          method: event.req.method,
+          headers: filteredHeaders
+        });
+        event.req.runtime = originalReq.runtime;
+        event.req.waitUntil = originalReq.waitUntil;
+      } catch (error) {
+        console.error("[cache] Failed to filter headers:", error);
+      }
+      const rawValue = await handler(event);
+      const res = await toResponse(rawValue, event);
+      const body = await res.text();
+      if (!res.headers.has("etag")) {
+        res.headers.set("etag", `W/"${hash(body)}"`);
+      }
+      if (!res.headers.has("last-modified")) {
+        res.headers.set("last-modified", (/* @__PURE__ */ new Date()).toUTCString());
+      }
+      const cacheControl = [];
+      if (opts.swr) {
+        if (opts.maxAge) {
+          cacheControl.push(`s-maxage=${opts.maxAge}`);
+        }
+        if (opts.staleMaxAge) {
+          cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`);
+        } else {
+          cacheControl.push("stale-while-revalidate");
+        }
+      } else if (opts.maxAge) {
+        cacheControl.push(`max-age=${opts.maxAge}`);
+      }
+      if (cacheControl.length > 0) {
+        res.headers.set("cache-control", cacheControl.join(", "));
+      }
+      const cacheEntry = {
+        status: res.status,
+        statusText: res.statusText,
+        headers: Object.fromEntries(res.headers.entries()),
+        body
+      };
+      return cacheEntry;
+    },
+    _opts
+  );
+  return defineHandler(async (event) => {
+    if (opts.headersOnly) {
+      if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
+        return;
+      }
+      return handler(event);
+    }
+    const response = await _cachedHandler(event);
+    if (handleCacheHeaders(event, {
+      modifiedTime: new Date(response.headers["last-modified"]),
+      etag: response.headers.etag,
+      maxAge: opts.maxAge
+    })) {
+      return;
+    }
+    return new FastResponse(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  });
+}
+export const cachedEventHandler = defineCachedEventHandler;
+export const defineCachedHandler = defineCachedEventHandler;

package/dist/runtime/internal/context.d.mts

@@ -0,0 +1,12 @@
+import type { ServerRequest } from "srvx";
+export declare const nitroAsyncContext: import("unctx/index").UseContext<NitroAsyncContext>;
+/**
+ *
+ * Access to the current Nitro request.
+ *
+ * @experimental
+ *  - Requires `experimental.asyncContext: true` config to work.
+ *  - Works in Node.js and limited runtimes only
+ *
+ */
+export declare function useRequest(): ServerRequest;

package/dist/runtime/internal/context.mjs

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { HTTPError } from "h3";
+import { getContext } from "unctx";
+export const nitroAsyncContext = /* @__PURE__ */ (() => getContext("nitro-app", {
+  asyncContext: import.meta._asyncContext,
+  AsyncLocalStorage: import.meta._asyncContext ? AsyncLocalStorage : void 0
+}))();
+export function useRequest() {
+  try {
+    return nitroAsyncContext.use().request;
+  } catch {
+    const hint = import.meta._asyncContext ? "Note: This is an experimental feature and might be broken on non-Node.js environments." : "Enable the experimental flag using `experimental.asyncContext: true`.";
+    throw new HTTPError({
+      message: `Nitro request context is not available. ${hint}`
+    });
+  }
+}

package/dist/runtime/internal/database.d.mts

@@ -0,0 +1,2 @@
+import type { Database } from "db0";
+export declare function useDatabase(name?: string): Database;

package/dist/runtime/internal/database.mjs

@@ -0,0 +1,14 @@
+import { createDatabase } from "db0";
+import { connectionConfigs } from "#nitro-internal-virtual/database";
+const instances = /* @__PURE__ */ Object.create(null);
+export function useDatabase(name = "default") {
+  if (instances[name]) {
+    return instances[name];
+  }
+  if (!connectionConfigs[name]) {
+    throw new Error(`Database connection "${name}" not configured.`);
+  }
+  return instances[name] = createDatabase(
+    connectionConfigs[name].connector(connectionConfigs[name].options || {})
+  );
+}

package/dist/runtime/internal/debug.d.mts

@@ -0,0 +1,2 @@
+declare const _default: NitroAppPlugin;
+export default _default;

package/dist/runtime/internal/debug.mjs

@@ -0,0 +1,5 @@
+import { createDebugger } from "hookable";
+import { defineNitroPlugin } from "./plugin.mjs";
+export default defineNitroPlugin((nitro) => {
+  createDebugger(nitro.hooks, { tag: "nitro-runtime" });
+});

package/dist/runtime/internal/error/dev.d.mts

@@ -0,0 +1,9 @@
+import type { HTTPError, HTTPEvent } from "h3";
+import type { InternalHandlerResponse } from "./utils.mjs";
+declare const _default: NitroErrorHandler;
+export default _default;
+export declare function defaultHandler(error: HTTPError, event: HTTPEvent, opts?: {
+    silent?: boolean;
+    json?: boolean;
+}): Promise<InternalHandlerResponse>;
+export declare function loadStackTrace(error: any): Promise<void>;

package/dist/runtime/internal/error/dev.mjs

@@ -0,0 +1,122 @@
+import { getRequestURL } from "h3";
+import { readFile } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+import consola from "consola";
+import { ErrorParser } from "youch-core";
+import { Youch } from "youch";
+import { SourceMapConsumer } from "source-map";
+import { defineNitroErrorHandler } from "./utils.mjs";
+import { FastResponse } from "srvx";
+export default defineNitroErrorHandler(
+  async function defaultNitroErrorHandler(error, event) {
+    const res = await defaultHandler(error, event);
+    return new FastResponse(
+      typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
+      res
+    );
+  }
+);
+export async function defaultHandler(error, event, opts) {
+  const isSensitive = error.unhandled;
+  const status = error.status || 500;
+  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
+  if (status === 404) {
+    const baseURL = import.meta.baseURL || "/";
+    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
+      return {
+        status: 302,
+        statusText: "Found",
+        headers: { location: redirectTo },
+        body: `Redirecting...`
+      };
+    }
+  }
+  await loadStackTrace(error).catch(consola.error);
+  const youch = new Youch();
+  if (isSensitive && !opts?.silent) {
+    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
+    const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+    consola.error(
+      `[request error] ${tags} [${event.req.method}] ${url}
+
+`,
+      ansiError
+    );
+  }
+  const useJSON = opts?.json || !event.req.headers.get("accept")?.includes("text/html");
+  const headers = {
+    "content-type": useJSON ? "application/json" : "text/html",
+    // Prevent browser from guessing the MIME types of resources.
+    "x-content-type-options": "nosniff",
+    // Prevent error page from being embedded in an iframe
+    "x-frame-options": "DENY",
+    // Prevent browsers from sending the Referer header
+    "referrer-policy": "no-referrer",
+    // Disable the execution of any js
+    "content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
+  };
+  if (status === 404 || !event.res.headers.has("cache-control")) {
+    headers["cache-control"] = "no-cache";
+  }
+  const body = useJSON ? {
+    error: true,
+    url,
+    status,
+    statusText: error.statusText,
+    message: error.message,
+    data: error.data,
+    stack: error.stack?.split("\n").map((line) => line.trim())
+  } : await youch.toHTML(error, {
+    request: {
+      url: url.href,
+      method: event.req.method,
+      headers: Object.fromEntries(event.req.headers.entries())
+    }
+  });
+  return {
+    status,
+    statusText: error.statusText,
+    headers,
+    body
+  };
+}
+export async function loadStackTrace(error) {
+  if (!(error instanceof Error)) {
+    return;
+  }
+  const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
+  const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
+  Object.defineProperty(error, "stack", { value: stack });
+  if (error.cause) {
+    await loadStackTrace(error.cause).catch(consola.error);
+  }
+}
+async function sourceLoader(frame) {
+  if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+    return;
+  }
+  if (frame.type === "app") {
+    const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
+    });
+    if (rawSourceMap) {
+      const consumer = await new SourceMapConsumer(rawSourceMap);
+      const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
+      if (originalPosition.source && originalPosition.line) {
+        frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
+        frame.lineNumber = originalPosition.line;
+        frame.columnNumber = originalPosition.column || 0;
+      }
+    }
+  }
+  const contents = await readFile(frame.fileName, "utf8").catch(() => {
+  });
+  return contents ? { contents } : void 0;
+}
+function fmtFrame(frame) {
+  if (frame.type === "native") {
+    return frame.raw;
+  }
+  const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
+  return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
+}

package/dist/runtime/internal/error/prod.d.mts

@@ -0,0 +1,8 @@
+import type { HTTPError, HTTPEvent } from "h3";
+import type { InternalHandlerResponse } from "./utils.mjs";
+declare const _default: NitroErrorHandler;
+export default _default;
+export declare function defaultHandler(error: HTTPError, event: HTTPEvent, opts?: {
+    silent?: boolean;
+    json?: boolean;
+}): InternalHandlerResponse;