@wooksjs/event-http 0.7.0 → 0.7.2

package/dist/index.cjs

@@ -80,12 +80,12 @@ const parseCookieValue = (0, __wooksjs_event_core.cachedBy)((name, ctx) => {
 * Provides access to parsed request cookies.
 * @example
 * ```ts
-* const { getCookie, rawCookies } = useCookies()
+* const { getCookie, raw } = useCookies()
 * const sessionId = getCookie('session_id')
 * ```
 */
 const useCookies = (0, __wooksjs_event_core.defineWook)((ctx) => ({
-	rawCookies: ctx.get(httpKind.keys.req).headers.cookie,
+	raw: ctx.get(httpKind.keys.req).headers.cookie,
 	getCookie: (name) => parseCookieValue(name, ctx)
 }));
 
@@ -107,7 +107,7 @@ const useAccept = (0, __wooksjs_event_core.defineWook)((ctx) => {
 	const accept = ctx.get(httpKind.keys.req).headers.accept;
 	return {
 		accept,
-		accepts: (type) => acceptsMime(type, ctx)
+		has: (type) => acceptsMime(type, ctx)
 	};
 });
 
@@ -152,17 +152,17 @@ const authIsSlot = (0, __wooksjs_event_core.cachedBy)((type, ctx) => {
 * Provides parsed access to the Authorization header (type, credentials, Basic decoding).
 * @example
 * ```ts
-* const { authIs, authRawCredentials, basicCredentials } = useAuthorization()
-* if (authIs('bearer')) { const token = authRawCredentials() }
+* const { is, credentials, basicCredentials } = useAuthorization()
+* if (is('bearer')) { const token = credentials() }
 * ```
 */
 const useAuthorization = (0, __wooksjs_event_core.defineWook)((ctx) => {
 	const authorization = ctx.get(httpKind.keys.req).headers.authorization;
 	return {
 		authorization,
-		authType: () => ctx.get(authTypeSlot),
-		authRawCredentials: () => ctx.get(authCredentialsSlot),
-		authIs: (type) => authIsSlot(type, ctx),
+		type: () => ctx.get(authTypeSlot),
+		credentials: () => ctx.get(authCredentialsSlot),
+		is: (type) => authIsSlot(type, ctx),
 		basicCredentials: () => ctx.get(basicCredentialsSlot)
 	};
 });
@@ -520,7 +520,7 @@ const ipListSlot = (0, __wooksjs_event_core.cached)((ctx) => {
 * Provides access to the incoming HTTP request (method, url, headers, body, IP).
 * @example
 * ```ts
-* const { method, url, rawBody, getIp } = useRequest()
+* const { method, url, raw, rawBody, getIp } = useRequest()
 * const body = await rawBody()
 * ```
 */
@@ -551,7 +551,7 @@ const useRequest = (0, __wooksjs_event_core.defineWook)((ctx) => {
 		return ctx.get(remoteIpSlot);
 	}
 	return {
-		rawRequest: req,
+		raw: req,
 		url: req.url,
 		method: req.method,
 		headers: req.headers,
@@ -647,14 +647,14 @@ const urlSearchParamsSlot = (0, __wooksjs_event_core.cached)((ctx) => new WooksU
 * Provides access to URL search (query) parameters from the request.
 * @example
 * ```ts
-* const { urlSearchParams, jsonSearchParams } = useSearchParams()
-* const page = urlSearchParams().get('page')
+* const { params, toJson } = useUrlParams()
+* const page = params().get('page')
 * ```
 */
-const useSearchParams = (0, __wooksjs_event_core.defineWook)((ctx) => ({
-	rawSearchParams: () => ctx.get(rawSearchParamsSlot),
-	urlSearchParams: () => ctx.get(urlSearchParamsSlot),
-	jsonSearchParams: () => ctx.get(urlSearchParamsSlot).toJson()
+const useUrlParams = (0, __wooksjs_event_core.defineWook)((ctx) => ({
+	raw: () => ctx.get(rawSearchParamsSlot),
+	params: () => ctx.get(urlSearchParamsSlot),
+	toJson: () => ctx.get(urlSearchParamsSlot).toJson()
 }));
 
 //#endregion
@@ -1028,13 +1028,12 @@ var HttpResponse = class {
 //#region packages/event-http/src/event-http.ts
 /** Creates an async event context for an incoming HTTP request/response pair. */
 function createHttpContext(data, options, ResponseClass = HttpResponse) {
-	const ctx = new __wooksjs_event_core.EventContext(options);
-	const response = new ResponseClass(data.res, data.req, ctx.logger);
-	return (fn) => (0, __wooksjs_event_core.run)(ctx, () => ctx.seed(httpKind, {
+	const response = new ResponseClass(data.res, data.req, options.logger);
+	return (fn) => (0, __wooksjs_event_core.createEventContext)(options, httpKind, {
 		req: data.req,
 		response,
 		requestLimits: data.requestLimits
-	}, fn));
+	}, fn);
 }
 /** Returns the current HTTP event context. */
 function useHttpContext(ctx) {
@@ -1394,10 +1393,10 @@ function error_tl_default(ctx) {
 //#endregion
 //#region packages/event-http/src/response/wooks-http-response.ts
 let framework = {
-	version: "0.6.6",
+	version: "0.7.1",
 	poweredBy: "wooksjs",
 	link: "https://wooks.moost.org/",
-	image: "https://wooks.moost.org/wooks-full-logo.png"
+	image: "https://wooks.moost.org/wooks-full-logo.svg"
 };
 const icons = {
 	401: typeof _403_tl_default === "function" ? _403_tl_default({}) : "",
@@ -1418,14 +1417,14 @@ var WooksHttpResponse = class extends HttpResponse {
 	}
 	renderError(data, ctx) {
 		this._status = data.statusCode || 500;
-		const { accepts } = useAccept(ctx);
-		if (accepts("json")) {
+		const { has } = useAccept(ctx);
+		if (has("json")) {
 			this._headers["content-type"] = "application/json";
 			this._body = JSON.stringify(data);
-		} else if (accepts("html")) {
+		} else if (has("html")) {
 			this._headers["content-type"] = "text/html";
 			this._body = renderErrorHtml(data);
-		} else if (accepts("text")) {
+		} else if (has("text")) {
 			this._headers["content-type"] = "text/plain";
 			this._body = renderErrorText(data);
 		} else {
@@ -1601,16 +1600,15 @@ var WooksHttp = class extends wooks.WooksAdapterBase {
 		const notFoundHandler = this.opts?.onNotFound;
 		const defaultHeaders = this.opts?.defaultHeaders;
 		return (req, res) => {
-			const ctx = new __wooksjs_event_core.EventContext(ctxOptions);
-			const response = new this.ResponseClass(res, req, ctx.logger, defaultHeaders);
+			const response = new this.ResponseClass(res, req, ctxOptions.logger, defaultHeaders);
 			const method = req.method || "";
 			const url$1 = req.url || "";
-			(0, __wooksjs_event_core.run)(ctx, () => {
-				ctx.seed(httpKind, {
-					req,
-					response,
-					requestLimits: RequestLimits
-				});
+			(0, __wooksjs_event_core.createEventContext)(ctxOptions, httpKind, {
+				req,
+				response,
+				requestLimits: RequestLimits
+			}, () => {
+				const ctx = (0, __wooksjs_event_core.current)();
 				const handlers = this.wooks.lookupHandlers(method, url$1, ctx);
 				if (handlers || notFoundHandler) {
 					const result = this.processHandlers(handlers || [notFoundHandler], ctx, response);
@@ -1639,14 +1637,13 @@ var WooksHttp = class extends wooks.WooksAdapterBase {
 				socket.destroy();
 				return;
 			}
-			const ctx = new __wooksjs_event_core.EventContext(ctxOptions);
 			const url$1 = req.url || "";
-			(0, __wooksjs_event_core.run)(ctx, () => {
-				ctx.seed(httpKind, {
-					req,
-					response: void 0,
-					requestLimits
-				});
+			(0, __wooksjs_event_core.createEventContext)(ctxOptions, httpKind, {
+				req,
+				response: void 0,
+				requestLimits
+			}, () => {
+				const ctx = (0, __wooksjs_event_core.current)();
 				ctx.set(wsHandler.reqKey, req);
 				ctx.set(wsHandler.socketKey, socket);
 				ctx.set(wsHandler.headKey, head);
@@ -1871,4 +1868,4 @@ Object.defineProperty(exports, 'useRouteParams', {
     return __wooksjs_event_core.useRouteParams;
   }
 });
-exports.useSearchParams = useSearchParams;
+exports.useUrlParams = useUrlParams;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _wooksjs_event_core from '@wooksjs/event-core';
-import { EventContext, Logger, EventContextOptions } from '@wooksjs/event-core';
+import { EventContext as EventContext$1, Logger, EventContextOptions } from '@wooksjs/event-core';
 export { EventContext, EventContextOptions, useLogger, useRouteParams } from '@wooksjs/event-core';
 import * as http from 'http';
 import { IncomingHttpHeaders, IncomingMessage, ServerResponse, Server } from 'http';
@@ -15,21 +15,21 @@ import { Duplex } from 'stream';
  * Provides access to parsed request cookies.
  * @example
  * ```ts
- * const { getCookie, rawCookies } = useCookies()
+ * const { getCookie, raw } = useCookies()
  * const sessionId = getCookie('session_id')
  * ```
  */
-declare const useCookies: (ctx?: EventContext) => {
-    rawCookies: string | undefined;
+declare const useCookies: (ctx?: EventContext$1) => {
+    raw: string | undefined;
     getCookie: (name: string) => string | null;
 };
 
 /** Short names for common Accept MIME types. */
 type KnownAcceptType = 'json' | 'html' | 'xml' | 'text';
 /** Provides helpers to check the request's Accept header for supported MIME types. */
-declare const useAccept: (ctx?: EventContext) => {
+declare const useAccept: (ctx?: EventContext$1) => {
     accept: string | undefined;
-    accepts: (type: KnownAcceptType | (string & {})) => boolean;
+    has: (type: KnownAcceptType | (string & {})) => boolean;
 };
 
 /** Short names for common Authorization schemes. */
@@ -38,15 +38,15 @@ type KnownAuthType = 'basic' | 'bearer';
  * Provides parsed access to the Authorization header (type, credentials, Basic decoding).
  * @example
  * ```ts
- * const { authIs, authRawCredentials, basicCredentials } = useAuthorization()
- * if (authIs('bearer')) { const token = authRawCredentials() }
+ * const { is, credentials, basicCredentials } = useAuthorization()
+ * if (is('bearer')) { const token = credentials() }
  * ```
  */
-declare const useAuthorization: (ctx?: EventContext) => {
+declare const useAuthorization: (ctx?: EventContext$1) => {
     authorization: string | undefined;
-    authType: () => string | null;
-    authRawCredentials: () => string | null;
-    authIs: (type: KnownAuthType | (string & {})) => boolean;
+    type: () => string | null;
+    credentials: () => string | null;
+    is: (type: KnownAuthType | (string & {})) => boolean;
     basicCredentials: () => {
         username: string;
         password: string;
@@ -60,7 +60,7 @@ declare const useAuthorization: (ctx?: EventContext) => {
  * const { host, authorization } = useHeaders()
  * ```
  */
-declare function useHeaders(ctx?: EventContext): IncomingHttpHeaders;
+declare function useHeaders(ctx?: EventContext$1): IncomingHttpHeaders;
 
 /** Default safety limits for request body reading (size, ratio, timeout). */
 declare const DEFAULT_LIMITS: {
@@ -75,12 +75,12 @@ declare const rawBodySlot: _wooksjs_event_core.Cached<Promise<Buffer$1<ArrayBuff
  * Provides access to the incoming HTTP request (method, url, headers, body, IP).
  * @example
  * ```ts
- * const { method, url, rawBody, getIp } = useRequest()
+ * const { method, url, raw, rawBody, getIp } = useRequest()
  * const body = await rawBody()
  * ```
  */
-declare const useRequest: (ctx?: EventContext) => {
-    rawRequest: http.IncomingMessage;
+declare const useRequest: (ctx?: EventContext$1) => {
+    raw: http.IncomingMessage;
     url: string | undefined;
     method: string | undefined;
     headers: http.IncomingHttpHeaders;
@@ -410,9 +410,9 @@ declare class HttpResponse {
     /** Whether the response has already been sent (or the underlying stream is no longer writable). */
     get responded(): boolean;
     protected renderBody(): string | Uint8Array;
-    protected renderError(data: TWooksErrorBodyExt, _ctx: EventContext): void;
+    protected renderError(data: TWooksErrorBodyExt, _ctx: EventContext$1): void;
     /** Renders and sends an HTTP error response. Called automatically by the framework when a handler throws an `HttpError`. */
-    sendError(error: HttpError, ctx: EventContext): void | Promise<void>;
+    sendError(error: HttpError, ctx: EventContext$1): void | Promise<void>;
     /**
      * Finalizes and sends the response.
      *
@@ -442,7 +442,7 @@ declare class HttpResponse {
  * response.setCookie('session', 'abc', { httpOnly: true })
  * ```
  */
-declare function useResponse(ctx?: EventContext): HttpResponse;
+declare function useResponse(ctx?: EventContext$1): HttpResponse;
 
 /**
  * Extended `URLSearchParams` with safe JSON conversion.
@@ -459,14 +459,14 @@ declare class WooksURLSearchParams extends URLSearchParams {
  * Provides access to URL search (query) parameters from the request.
  * @example
  * ```ts
- * const { urlSearchParams, jsonSearchParams } = useSearchParams()
- * const page = urlSearchParams().get('page')
+ * const { params, toJson } = useUrlParams()
+ * const page = params().get('page')
  * ```
  */
-declare const useSearchParams: (ctx?: EventContext) => {
-    rawSearchParams: () => string;
-    urlSearchParams: () => WooksURLSearchParams;
-    jsonSearchParams: () => unknown;
+declare const useUrlParams: (ctx?: EventContext$1) => {
+    raw: () => string;
+    params: () => WooksURLSearchParams;
+    toJson: () => unknown;
 };
 
 /** Creates an async event context for an incoming HTTP request/response pair. */
@@ -488,7 +488,7 @@ declare class WooksHttpResponse extends HttpResponse {
         link: string;
         image: string;
     }): void;
-    protected renderError(data: TWooksErrorBodyExt, ctx: EventContext): void;
+    protected renderError(data: TWooksErrorBodyExt, ctx: EventContext$1): void;
 }
 
 /** Configuration options for the WooksHttp adapter. */
@@ -566,7 +566,7 @@ declare class WooksHttp extends WooksAdapterBase {
      * @param server Server
      */
     attachServer(server?: Server): void;
-    protected respond(data: unknown, response: HttpResponse, ctx: EventContext): void | Promise<void>;
+    protected respond(data: unknown, response: HttpResponse, ctx: EventContext$1): void | Promise<void>;
     /**
      * Returns server callback function
      * that can be passed to any node server:
@@ -585,8 +585,8 @@ declare class WooksHttp extends WooksAdapterBase {
      * Creates an HTTP context, seeds it with upgrade data, and routes as method 'UPGRADE'.
      */
     getUpgradeCb(): (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
-    protected processUpgradeHandlers(handlers: TWooksHandler[], ctx: EventContext, socket: Duplex): void | Promise<unknown>;
-    protected processHandlers(handlers: TWooksHandler[], ctx: EventContext, response: HttpResponse): void | Promise<unknown>;
+    protected processUpgradeHandlers(handlers: TWooksHandler[], ctx: EventContext$1, socket: Duplex): void | Promise<unknown>;
+    protected processHandlers(handlers: TWooksHandler[], ctx: EventContext$1, response: HttpResponse): void | Promise<unknown>;
     private processAsyncResult;
 }
 /**
@@ -671,5 +671,5 @@ interface TTestHttpContext {
  */
 declare function prepareTestHttpContext(options: TTestHttpContext): <T>(cb: (...a: any[]) => T) => T;
 
-export { DEFAULT_LIMITS, EHttpStatusCode, HttpError, HttpResponse, WooksHttp, WooksHttpResponse, WooksURLSearchParams, createHttpApp, createHttpContext, httpKind, httpStatusCodes, prepareTestHttpContext, rawBodySlot, renderCacheControl, securityHeaders, useAccept, useAuthorization, useCookies, useHeaders, useHttpContext, useRequest, useResponse, useSearchParams };
+export { DEFAULT_LIMITS, EHttpStatusCode, HttpError, HttpResponse, WooksHttp, WooksHttpResponse, WooksURLSearchParams, createHttpApp, createHttpContext, httpKind, httpStatusCodes, prepareTestHttpContext, rawBodySlot, renderCacheControl, securityHeaders, useAccept, useAuthorization, useCookies, useHeaders, useHttpContext, useRequest, useResponse, useUrlParams };
 export type { KnownAcceptType, KnownAuthType, SecurityHeadersOptions, TCacheControl, TCookieAttributes, TCookieAttributesInput, THttpEventData, TRequestLimits, TSetCookieData, TTestHttpContext, TWooksErrorBody, TWooksErrorBodyExt, TWooksHttpOptions };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { EventContext, cached, cachedBy, current, defineEventKind, defineWook, routeParamsKey, run, slot, useEventId, useLogger, useRouteParams } from "@wooksjs/event-core";
+import { EventContext, cached, cachedBy, createEventContext, current, defineEventKind, defineWook, routeParamsKey, run, slot, useEventId, useLogger, useRouteParams } from "@wooksjs/event-core";
 import { Buffer as Buffer$1 } from "buffer";
 import { Readable, pipeline } from "node:stream";
 import { promisify } from "node:util";
@@ -57,12 +57,12 @@ const parseCookieValue = cachedBy((name, ctx) => {
 * Provides access to parsed request cookies.
 * @example
 * ```ts
-* const { getCookie, rawCookies } = useCookies()
+* const { getCookie, raw } = useCookies()
 * const sessionId = getCookie('session_id')
 * ```
 */
 const useCookies = defineWook((ctx) => ({
-	rawCookies: ctx.get(httpKind.keys.req).headers.cookie,
+	raw: ctx.get(httpKind.keys.req).headers.cookie,
 	getCookie: (name) => parseCookieValue(name, ctx)
 }));
 
@@ -84,7 +84,7 @@ const useAccept = defineWook((ctx) => {
 	const accept = ctx.get(httpKind.keys.req).headers.accept;
 	return {
 		accept,
-		accepts: (type) => acceptsMime(type, ctx)
+		has: (type) => acceptsMime(type, ctx)
 	};
 });
 
@@ -129,17 +129,17 @@ const authIsSlot = cachedBy((type, ctx) => {
 * Provides parsed access to the Authorization header (type, credentials, Basic decoding).
 * @example
 * ```ts
-* const { authIs, authRawCredentials, basicCredentials } = useAuthorization()
-* if (authIs('bearer')) { const token = authRawCredentials() }
+* const { is, credentials, basicCredentials } = useAuthorization()
+* if (is('bearer')) { const token = credentials() }
 * ```
 */
 const useAuthorization = defineWook((ctx) => {
 	const authorization = ctx.get(httpKind.keys.req).headers.authorization;
 	return {
 		authorization,
-		authType: () => ctx.get(authTypeSlot),
-		authRawCredentials: () => ctx.get(authCredentialsSlot),
-		authIs: (type) => authIsSlot(type, ctx),
+		type: () => ctx.get(authTypeSlot),
+		credentials: () => ctx.get(authCredentialsSlot),
+		is: (type) => authIsSlot(type, ctx),
 		basicCredentials: () => ctx.get(basicCredentialsSlot)
 	};
 });
@@ -497,7 +497,7 @@ const ipListSlot = cached((ctx) => {
 * Provides access to the incoming HTTP request (method, url, headers, body, IP).
 * @example
 * ```ts
-* const { method, url, rawBody, getIp } = useRequest()
+* const { method, url, raw, rawBody, getIp } = useRequest()
 * const body = await rawBody()
 * ```
 */
@@ -528,7 +528,7 @@ const useRequest = defineWook((ctx) => {
 		return ctx.get(remoteIpSlot);
 	}
 	return {
-		rawRequest: req,
+		raw: req,
 		url: req.url,
 		method: req.method,
 		headers: req.headers,
@@ -624,14 +624,14 @@ const urlSearchParamsSlot = cached((ctx) => new WooksURLSearchParams(ctx.get(raw
 * Provides access to URL search (query) parameters from the request.
 * @example
 * ```ts
-* const { urlSearchParams, jsonSearchParams } = useSearchParams()
-* const page = urlSearchParams().get('page')
+* const { params, toJson } = useUrlParams()
+* const page = params().get('page')
 * ```
 */
-const useSearchParams = defineWook((ctx) => ({
-	rawSearchParams: () => ctx.get(rawSearchParamsSlot),
-	urlSearchParams: () => ctx.get(urlSearchParamsSlot),
-	jsonSearchParams: () => ctx.get(urlSearchParamsSlot).toJson()
+const useUrlParams = defineWook((ctx) => ({
+	raw: () => ctx.get(rawSearchParamsSlot),
+	params: () => ctx.get(urlSearchParamsSlot),
+	toJson: () => ctx.get(urlSearchParamsSlot).toJson()
 }));
 
 //#endregion
@@ -1005,13 +1005,12 @@ var HttpResponse = class {
 //#region packages/event-http/src/event-http.ts
 /** Creates an async event context for an incoming HTTP request/response pair. */
 function createHttpContext(data, options, ResponseClass = HttpResponse) {
-	const ctx = new EventContext(options);
-	const response = new ResponseClass(data.res, data.req, ctx.logger);
-	return (fn) => run(ctx, () => ctx.seed(httpKind, {
+	const response = new ResponseClass(data.res, data.req, options.logger);
+	return (fn) => createEventContext(options, httpKind, {
 		req: data.req,
 		response,
 		requestLimits: data.requestLimits
-	}, fn));
+	}, fn);
 }
 /** Returns the current HTTP event context. */
 function useHttpContext(ctx) {
@@ -1371,10 +1370,10 @@ function error_tl_default(ctx) {
 //#endregion
 //#region packages/event-http/src/response/wooks-http-response.ts
 let framework = {
-	version: "0.6.6",
+	version: "0.7.1",
 	poweredBy: "wooksjs",
 	link: "https://wooks.moost.org/",
-	image: "https://wooks.moost.org/wooks-full-logo.png"
+	image: "https://wooks.moost.org/wooks-full-logo.svg"
 };
 const icons = {
 	401: typeof _403_tl_default === "function" ? _403_tl_default({}) : "",
@@ -1395,14 +1394,14 @@ var WooksHttpResponse = class extends HttpResponse {
 	}
 	renderError(data, ctx) {
 		this._status = data.statusCode || 500;
-		const { accepts } = useAccept(ctx);
-		if (accepts("json")) {
+		const { has } = useAccept(ctx);
+		if (has("json")) {
 			this._headers["content-type"] = "application/json";
 			this._body = JSON.stringify(data);
-		} else if (accepts("html")) {
+		} else if (has("html")) {
 			this._headers["content-type"] = "text/html";
 			this._body = renderErrorHtml(data);
-		} else if (accepts("text")) {
+		} else if (has("text")) {
 			this._headers["content-type"] = "text/plain";
 			this._body = renderErrorText(data);
 		} else {
@@ -1578,16 +1577,15 @@ var WooksHttp = class extends WooksAdapterBase {
 		const notFoundHandler = this.opts?.onNotFound;
 		const defaultHeaders = this.opts?.defaultHeaders;
 		return (req, res) => {
-			const ctx = new EventContext(ctxOptions);
-			const response = new this.ResponseClass(res, req, ctx.logger, defaultHeaders);
+			const response = new this.ResponseClass(res, req, ctxOptions.logger, defaultHeaders);
 			const method = req.method || "";
 			const url = req.url || "";
-			run(ctx, () => {
-				ctx.seed(httpKind, {
-					req,
-					response,
-					requestLimits: RequestLimits
-				});
+			createEventContext(ctxOptions, httpKind, {
+				req,
+				response,
+				requestLimits: RequestLimits
+			}, () => {
+				const ctx = current();
 				const handlers = this.wooks.lookupHandlers(method, url, ctx);
 				if (handlers || notFoundHandler) {
 					const result = this.processHandlers(handlers || [notFoundHandler], ctx, response);
@@ -1616,14 +1614,13 @@ var WooksHttp = class extends WooksAdapterBase {
 				socket.destroy();
 				return;
 			}
-			const ctx = new EventContext(ctxOptions);
 			const url = req.url || "";
-			run(ctx, () => {
-				ctx.seed(httpKind, {
-					req,
-					response: void 0,
-					requestLimits
-				});
+			createEventContext(ctxOptions, httpKind, {
+				req,
+				response: void 0,
+				requestLimits
+			}, () => {
+				const ctx = current();
 				ctx.set(wsHandler.reqKey, req);
 				ctx.set(wsHandler.socketKey, socket);
 				ctx.set(wsHandler.headKey, head);
@@ -1814,4 +1811,4 @@ function prepareTestHttpContext(options) {
 }
 
 //#endregion
-export { DEFAULT_LIMITS, EHttpStatusCode, HttpError, HttpResponse, WooksHttp, WooksHttpResponse, WooksURLSearchParams, createHttpApp, createHttpContext, httpKind, httpStatusCodes, prepareTestHttpContext, rawBodySlot, renderCacheControl, securityHeaders, useAccept, useAuthorization, useCookies, useHeaders, useHttpContext, useLogger, useRequest, useResponse, useRouteParams, useSearchParams };
+export { DEFAULT_LIMITS, EHttpStatusCode, HttpError, HttpResponse, WooksHttp, WooksHttpResponse, WooksURLSearchParams, createHttpApp, createHttpContext, httpKind, httpStatusCodes, prepareTestHttpContext, rawBodySlot, renderCacheControl, securityHeaders, useAccept, useAuthorization, useCookies, useHeaders, useHttpContext, useLogger, useRequest, useResponse, useRouteParams, useUrlParams };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooksjs/event-http",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "@wooksjs/event-http",
   "keywords": [
     "api",
@@ -47,14 +47,14 @@
   "devDependencies": {
     "typescript": "^5.9.3",
     "vitest": "^3.2.4",
-    "@wooksjs/event-core": "^0.7.0",
-    "wooks": "^0.7.0"
+    "@wooksjs/event-core": "^0.7.2",
+    "wooks": "^0.7.2"
   },
   "peerDependencies": {
     "@prostojs/logger": "^0.4.3",
     "@prostojs/router": "^0.3.2",
-    "@wooksjs/event-core": "^0.7.0",
-    "wooks": "^0.7.0"
+    "@wooksjs/event-core": "^0.7.2",
+    "wooks": "^0.7.2"
   },
   "scripts": {
     "build": "rolldown -c ../../rolldown.config.mjs",

package/skills/wooksjs-event-http/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: wooksjs-event-http
-description: Use this skill when working with @wooksjs/event-http — to create HTTP servers with createHttpApp(), register route handlers with app.get()/post()/put()/patch()/delete(), read request data with useRequest()/useHeaders()/useCookies()/useSearchParams()/useAuthorization()/useAccept(), control responses with useResponse() and HttpResponse (status, headers, cookies, cache control, streaming), throw HTTP errors with HttpError, test handlers with prepareTestHttpContext(), or integrate with existing Node.js servers via getServerCb().
+description: Use this skill when working with @wooksjs/event-http — to create HTTP servers with createHttpApp(), register route handlers with app.get()/post()/put()/patch()/delete(), read request data with useRequest()/useHeaders()/useCookies()/useUrlParams()/useAuthorization()/useAccept(), control responses with useResponse() and HttpResponse (status, headers, cookies, cache control, streaming), throw HTTP errors with HttpError, test handlers with prepareTestHttpContext(), or integrate with existing Node.js servers via getServerCb().
 ---
 
 # @wooksjs/event-http
@@ -29,7 +29,7 @@ import {
   useResponse,
   useHeaders,
   useCookies,
-  useSearchParams,
+  useUrlParams,
   useAuthorization,
   useAccept,
   useRouteParams,

package/skills/wooksjs-event-http/core.md

@@ -32,13 +32,13 @@ app.listen(3000)
 
 **Options (`TWooksHttpOptions`):**
 
-| Option          | Type                       | Description                                                   |
-| --------------- | -------------------------- | ------------------------------------------------------------- |
-| `logger`        | `TConsoleBase`             | Custom logger instance                                        |
-| `onNotFound`    | `TWooksHandler`            | Handler called when no route matches (default: 404 HttpError) |
-| `router`        | router options             | Custom router configuration                                   |
-| `requestLimits` | `Omit<TRequestLimits, 'perRequest'>` | Default body size/timeout limits for all requests             |
-| `responseClass` | `typeof WooksHttpResponse` | Custom response subclass (default: `WooksHttpResponse`)       |
+| Option           | Type                                 | Description                                                               |
+| ---------------- | ------------------------------------ | ------------------------------------------------------------------------- |
+| `logger`         | `TConsoleBase`                       | Custom logger instance                                                    |
+| `onNotFound`     | `TWooksHandler`                      | Handler called when no route matches (default: 404 HttpError)             |
+| `router`         | router options                       | Custom router configuration                                               |
+| `requestLimits`  | `Omit<TRequestLimits, 'perRequest'>` | Default body size/timeout limits for all requests                         |
+| `responseClass`  | `typeof WooksHttpResponse`           | Custom response subclass (default: `WooksHttpResponse`)                   |
 | `defaultHeaders` | `Record<string, string \| string[]>` | Default headers applied to every response (e.g. from `securityHeaders()`) |
 
 ### Route registration

package/skills/wooksjs-event-http/request.md

@@ -22,17 +22,17 @@ const { method, url, headers, rawBody, getIp, reqId } = useRequest()
 
 **Returned properties:**
 
-| Property         | Type                                         | Description                                        |
-| ---------------- | -------------------------------------------- | -------------------------------------------------- |
-| `rawRequest`     | `IncomingMessage`                            | Node.js raw request object                         |
-| `url`            | `string`                                     | Request URL                                        |
-| `method`         | `string`                                     | HTTP method                                        |
-| `headers`        | `IncomingHttpHeaders`                        | Request headers                                    |
-| `rawBody`        | `() => Promise<Buffer>`                      | Lazy — reads and decompresses request body on call |
-| `reqId`          | `() => string`                               | Lazy UUID per request                              |
-| `getIp(opts?)`   | `(opts?: { trustProxy: boolean }) => string` | Client IP (with optional proxy trust)              |
+| Property         | Type                                              | Description                                        |
+| ---------------- | ------------------------------------------------- | -------------------------------------------------- |
+| `raw`            | `IncomingMessage`                                 | Node.js raw request object                         |
+| `url`            | `string`                                          | Request URL                                        |
+| `method`         | `string`                                          | HTTP method                                        |
+| `headers`        | `IncomingHttpHeaders`                             | Request headers                                    |
+| `rawBody`        | `() => Promise<Buffer>`                           | Lazy — reads and decompresses request body on call |
+| `reqId`          | `() => string`                                    | Lazy UUID per request                              |
+| `getIp(opts?)`   | `(opts?: { trustProxy: boolean }) => string`      | Client IP (with optional proxy trust)              |
 | `getIpList()`    | `() => { remoteIp: string; forwarded: string[] }` | All IPs (remote + X-Forwarded-For)                 |
-| `isCompressed()` | `() => boolean`                              | Whether the request body is compressed             |
+| `isCompressed()` | `() => boolean`                                   | Whether the request body is compressed             |
 
 **Request limits (per-request override):**
 
@@ -61,30 +61,30 @@ Parses incoming request cookies lazily (per cookie name, via `cachedBy`).
 ```ts
 import { useCookies } from '@wooksjs/event-http'
 
-const { getCookie, rawCookies } = useCookies()
+const { getCookie, raw } = useCookies()
 const session = getCookie('session_id') // parsed + cached
 const theme = getCookie('theme') // parsed + cached (different key)
-const raw = rawCookies // raw Cookie header string
+// raw = raw Cookie header string
 ```
 
-### `useSearchParams(ctx?)`
+### `useUrlParams(ctx?)`
 
 Provides access to URL query parameters.
 
 ```ts
-import { useSearchParams } from '@wooksjs/event-http'
+import { useUrlParams } from '@wooksjs/event-http'
 
-const { urlSearchParams, jsonSearchParams, rawSearchParams } = useSearchParams()
+const { params, toJson, raw } = useUrlParams()
 
 // URLSearchParams API
-const page = urlSearchParams().get('page')
-const tags = urlSearchParams().getAll('tag')
+const page = params().get('page')
+const tags = params().getAll('tag')
 
 // As a plain object
-const query = jsonSearchParams() // { page: '1', tag: ['a', 'b'] }
+const query = toJson() // { page: '1', tag: ['a', 'b'] }
 
 // Raw query string
-const raw = rawSearchParams() // '?page=1&tag=a&tag=b'
+const rawQuery = raw() // '?page=1&tag=a&tag=b'
 ```
 
 ### `useAuthorization(ctx?)`
@@ -94,13 +94,13 @@ Parses the Authorization header (supports Basic and Bearer).
 ```ts
 import { useAuthorization } from '@wooksjs/event-http'
 
-const { authorization, authType, authRawCredentials, authIs, basicCredentials } = useAuthorization()
+const { authorization, type, credentials, is, basicCredentials } = useAuthorization()
 
-if (authIs('bearer')) {
-  const token = authRawCredentials() // the raw token string
+if (is('bearer')) {
+  const token = credentials() // the raw token string
 }
 
-if (authIs('basic')) {
+if (is('basic')) {
   const { username, password } = basicCredentials()!
 }
 ```
@@ -110,9 +110,9 @@ if (authIs('basic')) {
 | Property               | Type                             | Description                                                    |
 | ---------------------- | -------------------------------- | -------------------------------------------------------------- |
 | `authorization`        | `string \| undefined`            | Raw Authorization header value                                 |
-| `authType()`           | `string \| null`                 | Auth scheme: `'Basic'`, `'Bearer'`, etc.                       |
-| `authRawCredentials()` | `string \| null`                 | Everything after the scheme                                    |
-| `authIs(type)`         | `boolean`                        | Check auth scheme: `'basic'`, `'bearer'`, or any custom scheme |
+| `type()`               | `string \| null`                 | Auth scheme: `'Basic'`, `'Bearer'`, etc.                       |
+| `credentials()`        | `string \| null`                 | Everything after the scheme                                    |
+| `is(type)`             | `boolean`                        | Check auth scheme: `'basic'`, `'bearer'`, or any custom scheme |
 | `basicCredentials()`   | `{ username, password } \| null` | Decoded Basic credentials                                      |
 
 ### `useAccept(ctx?)`
@@ -122,12 +122,12 @@ Checks the request's `Accept` header for MIME type support. Uses short names (`'
 ```ts
 import { useAccept } from '@wooksjs/event-http'
 
-const { accept, accepts } = useAccept()
+const { accept, has } = useAccept()
 
-if (accepts('json')) {
+if (has('json')) {
   /* ... */
 }
-if (accepts('image/png')) {
+if (has('image/png')) {
   /* ... */
 }
 ```
@@ -162,10 +162,10 @@ log.info('handling request')
 
 ```ts
 app.post('/admin/action', async () => {
-  const { authIs, authRawCredentials } = useAuthorization()
-  if (!authIs('bearer')) throw new HttpError(401)
+  const { is, credentials } = useAuthorization()
+  if (!is('bearer')) throw new HttpError(401)
 
-  const token = authRawCredentials()!
+  const token = credentials()!
   const user = await verifyToken(token)
   if (!user.isAdmin) throw new HttpError(403)
 
@@ -184,7 +184,7 @@ app.get('/hot-path', () => {
   const ctx = current()
   const { method } = useRequest(ctx)
   const { getCookie } = useCookies(ctx)
-  const { urlSearchParams } = useSearchParams(ctx)
+  const { params } = useUrlParams(ctx)
   // 1 ALS lookup instead of 3
 })
 ```

package/skills/wooksjs-event-http/testing.md

@@ -40,10 +40,10 @@ run(() => {
   // All composables work here
   const { method } = useRequest()
   const { params } = useRouteParams()
-  const { authIs } = useAuthorization()
+  const { is } = useAuthorization()
   expect(method).toBe('GET')
   expect(params.id).toBe('42')
-  expect(authIs('bearer')).toBe(true)
+  expect(is('bearer')).toBe(true)
 })
 ```