@pikku/core 0.6.21 → 0.6.23

package/dist/http/http-route-runner.js

@@ -1,19 +1,24 @@
 import { verifyPermissions } from '../permissions.js';
 import { match } from 'path-to-regexp';
-import { PikkuHTTPAbstractRequest } from './pikku-http-abstract-request.js';
-import { PikkuHTTPAbstractResponse } from './pikku-http-abstract-response.js';
 import { ForbiddenError, MissingSessionError, NotFoundError, } from '../errors/errors.js';
 import { closeSessionServices } from '../utils.js';
 import { coerceQueryStringToArray, validateSchema } from '../schema.js';
-import { LocalUserSessionService } from '../services/user-session-service.js';
+import { PikkuUserSessionService } from '../services/user-session-service.js';
 import { runMiddleware } from '../middleware-runner.js';
 import { handleError } from '../handle-error.js';
 import { pikkuState } from '../pikku-state.js';
+import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
+import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
 /**
- * Add middleware to a specific route or globally
+ * Registers middleware either globally or for a specific route.
  *
- * @param {APIMiddleware[] | string} routeOrMiddleware - Route pattern to match or middleware array
- * @param {APIMiddleware} [middleware] - Middleware to add (required if first param is a string)
+ * When a string route pattern is provided along with middleware, the middleware
+ * is applied only to that route. Otherwise, if an array is provided, it is treated
+ * as global middleware (applied to all routes).
+ *
+ * @template APIMiddleware The middleware type.
+ * @param {APIMiddleware[] | string} routeOrMiddleware - Either a global middleware array or a route pattern string.
+ * @param {APIMiddleware[]} [middleware] - The middleware array to apply when a route pattern is specified.
  */
 export const addMiddleware = (routeOrMiddleware, middleware) => {
     if (typeof routeOrMiddleware === 'string' && middleware) {
@@ -30,42 +35,56 @@ export const addMiddleware = (routeOrMiddleware, middleware) => {
     }
 };
 /**
- * Add a route to the global routes registry
+ * Adds a new route to the global HTTP route registry.
+ *
+ * The route configuration includes the HTTP method, route path, permissions,
+ * middleware, and the handler function that implements the route's logic.
  *
- * @param {CoreHTTPFunctionRoute} route - Route configuration to add
+ * @template In Expected input type.
+ * @template Out Expected output type.
+ * @template Route Route pattern as a string.
+ * @template APIFunction Type for the route handler function.
+ * @template APIFunctionSessionless Type for a sessionless handler.
+ * @template APIPermission Type representing required permissions.
+ * @template APIMiddleware Middleware type to be used with the route.
+ * @param {CoreHTTPFunctionRoute<In, Out, Route, APIFunction, APIFunctionSessionless, APIPermission, APIMiddleware>} route - The route configuration object.
  */
 export const addRoute = (route) => {
     pikkuState('http', 'routes').push(route);
 };
 /**
- * Find a route that matches the given request type and path
+ * Finds a matching route based on the HTTP method and URL path.
  *
- * @param {string} requestType - HTTP method (GET, POST, etc.)
- * @param {string} requestPath - URL path to match
- * @returns {Object | undefined} Matching route information or undefined if no match
+ * Iterates over all registered routes, skipping those with a mismatched method.
+ * When a route pattern matches the incoming request path, this function aggregates
+ * any global middleware along with route-specific middleware and identifies any input schema.
+ *
+ * @param {string} requestType - The HTTP method (e.g., GET, POST).
+ * @param {string} requestPath - The URL path of the incoming request.
+ * @returns {Object | undefined} An object with matched route details or undefined if no match.
  */
 const getMatchingRoute = (requestType, requestPath) => {
     const routes = pikkuState('http', 'routes');
     const middleware = pikkuState('http', 'middleware');
     const routesMeta = pikkuState('http', 'meta');
     for (const route of routes) {
-        // Skip routes that don't match the request method
+        // Skip routes that don't match the HTTP method
         if (route.method !== requestType.toLowerCase()) {
             continue;
         }
-        // Create path matcher function
+        // Generate a matching function from the route pattern
         const matchFunc = match(`/${route.route}`.replace(/^\/\//, '/'), {
             decode: decodeURIComponent,
         });
-        // Try to match the path
+        // Attempt to match the request path
         const matchedPath = matchFunc(requestPath.replace(/^\/\//, '/'));
         if (matchedPath) {
-            // Get all middleware for this route
+            // Aggregate global and route-specific middleware
             const globalMiddleware = middleware
                 .filter((m) => m.route === '*' || new RegExp(m.route).test(route.route))
                 .map((m) => m.middleware)
                 .flat();
-            // Find schema for this route
+            // Extract associated schema information if available
             const schemaName = routesMeta.find((routeMeta) => routeMeta.method === route.method && routeMeta.route === route.route)?.input;
             return {
                 matchedPath,
@@ -79,47 +98,61 @@ const getMatchingRoute = (requestType, requestPath) => {
     return undefined;
 };
 /**
- * Create an HTTP interaction object from request and response
+ * Combines the request and response objects into a single HTTP interaction object.
+ *
+ * This utility function creates an object that holds both the HTTP request and response,
+ * which simplifies passing these around through middleware and route execution.
  *
- * @param {PikkuRequest | undefined} request - The HTTP request object
- * @param {PikkuResponse | undefined} response - The HTTP response object
- * @returns {PikkuHTTP | undefined} HTTP interaction object or undefined
+ * @param {PikkuHTTPRequest | undefined} request - The HTTP request object.
+ * @param {PikkuHTTPResponse | undefined} response - The HTTP response object.
+ * @returns {PikkuHTTP | undefined} The combined HTTP interaction object or undefined if none provided.
  */
 export const createHTTPInteraction = (request, response) => {
     let http = undefined;
-    if (request instanceof PikkuHTTPAbstractRequest ||
-        response instanceof PikkuHTTPAbstractResponse) {
+    if (request || response) {
         http = {};
-        if (request instanceof PikkuHTTPAbstractRequest) {
+        if (request) {
             http.request = request;
         }
-        if (response instanceof PikkuHTTPAbstractResponse) {
+        if (response) {
             http.response = response;
         }
     }
     return http;
 };
 /**
- * Validate input data and execute route handler with appropriate middleware
+ * Validates the input data and executes the route handler with associated middleware.
  *
- * @param {Object} services - Available services
- * @param {Object} matchedRoute - Information about the matched route
- * @param {PikkuHTTP | undefined} http - HTTP interaction object
- * @param {Object} options - Additional options
- * @returns {Promise<any>} Result of the route handler
+ * This function is the central execution point for a route. It performs these steps:
+ *  1. Sets URL parameters on the request.
+ *  2. Validates the user session if required.
+ *  3. Creates session-specific services.
+ *  4. Validates the incoming data against a schema.
+ *  5. Optionally coerces query string values to arrays.
+ *  6. Checks route-specific permissions.
+ *  7. Executes the route handler.
+ *  8. Sends the appropriate response.
+ *
+ * @param {Object} services - A collection of shared services and utilities.
+ * @param {Object} matchedRoute - Contains route details, URL parameters, middleware, and optional schema.
+ * @param {PikkuHTTP | undefined} http - The HTTP interaction object.
+ * @param {Object} options - Options for route execution (e.g., whether to coerce query strings to arrays).
+ * @returns {Promise<any>} An object containing the route handler result and session services (if any).
+ * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRouteWithMiddleware = async (services, matchedRoute, http, options) => {
     const { matchedPath, params, route, middleware, schemaName } = matchedRoute;
-    const { singletonServices, userSessionService, context, createSessionServices, skipUserSession, } = services;
+    const { singletonServices, userSessionService, createSessionServices, skipUserSession, } = services;
     const requiresSession = route.auth !== false;
     let sessionServices;
     let result;
+    // Attach URL parameters to the request object
     http?.request?.setParams(params);
     singletonServices.logger.info(`Matched route: ${route.route} | method: ${route.method.toUpperCase()} | auth: ${requiresSession.toString()}`);
-    // Main route execution function
+    // Main route execution logic wrapped for middleware handling
     const runMain = async () => {
         const session = userSessionService.get();
-        // Validate session was set if needed
+        // Ensure session is available when required
         if (skipUserSession && requiresSession) {
             throw new Error("Can't skip trying to get user session if auth is required");
         }
@@ -130,59 +163,110 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             });
             throw new MissingSessionError();
         }
-        // Create session services
-        sessionServices = await createSessionServices({ ...singletonServices, context }, { http }, session);
+        // Create session-specific services for handling the request
+        sessionServices = await createSessionServices({ ...singletonServices, userSessionService }, { http }, session);
         const allServices = {
             ...singletonServices,
             ...sessionServices,
             http,
-            context,
         };
-        const data = await http?.request?.getData();
-        // Validate schema
-        validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, data);
+        const data = await http?.request?.data();
+        // Validate request data against the defined schema, if any
+        await validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, data);
+        // Coerce query string parameters to arrays if specified by the schema
         if (options.coerceToArray && schemaName) {
             coerceQueryStringToArray(schemaName, data);
         }
-        // Run permission checks
+        // Execute permission checks
         const permissioned = await verifyPermissions(route.permissions, allServices, data, session);
         if (permissioned === false) {
             throw new ForbiddenError('Permission denied');
         }
-        // Execute the route handler
+        // Invoke the actual route handler function
         result = await route.func(allServices, data, session);
-        // Set the response
+        // Respond with either a binary or JSON response based on configuration
         if (route.returnsJSON === false) {
-            http?.response?.setResponse(result);
+            http?.response?.arrayBuffer(result);
         }
         else {
-            http?.response?.setJson(result);
+            http?.response?.json(result);
         }
-        http?.response?.setStatus(200);
-        http?.response?.end();
+        http?.response?.status(200);
+        // TODO: Evaluate if the response stream should be explicitly ended.
+        // http?.response?.end()
         return result;
     };
-    await runMiddleware({ ...singletonServices, context, userSessionService }, { http }, middleware, runMain);
+    // Execute middleware, then run the main logic
+    await runMiddleware({ ...singletonServices, userSessionService }, { http }, middleware, runMain);
     return sessionServices ? { result, sessionServices } : { result };
 };
 /**
- * Run an HTTP route with the given parameters
+ * Executes an HTTP route for a given Fetch API request.
+ *
+ * This function wraps the entire lifecycle of handling an HTTP request:
+ *  - Matching the request to a registered route.
+ *  - Validating input and session state.
+ *  - Running middleware and the route handler.
+ *  - Handling errors and forming the response.
+ *
+ * @template In Expected input data type.
+ * @template Out Expected output data type.
+ * @param {Request} request - The native Fetch API Request object.
+ * @param {RunRouteOptions & RunRouteParams} params - Additional options including services and session management.
+ * @returns {Promise<Response>} A promise that resolves to a Fetch API Response object.
+ */
+export const fetch = async (request, params) => {
+    const pikkuResponse = new PikkuFetchHTTPResponse();
+    await fetchData(request, pikkuResponse, params);
+    return pikkuResponse.toResponse();
+};
+/**
+ * Executes an HTTP route using a Pikku-specific request wrapper.
+ *
+ * This variant accepts either a native Request or a PikkuHTTPRequest object and returns
+ * a PikkuFetchHTTPResponse for further manipulation if needed.
+ *
+ * @template In Expected input data type.
+ * @template Out Expected output data type.
+ * @param {Request | PikkuHTTPRequest} request - The request object.
+ * @param {RunRouteOptions & RunRouteParams} params - Execution options including services and session configuration.
+ * @returns {Promise<PikkuFetchHTTPResponse>} A promise that resolves to a PikkuFetchHTTPResponse object.
+ */
+export const pikkuFetch = async (request, params) => {
+    const pikkuResponse = new PikkuFetchHTTPResponse();
+    await fetchData(request, pikkuResponse, params);
+    return pikkuResponse;
+};
+/**
+ * Core function to process an HTTP request through route matching, validation,
+ * middleware execution, error handling, and session service cleanup.
+ *
+ * This function does the following:
+ *  - Wraps the incoming request and response into an HTTP interaction object.
+ *  - Determines the correct route based on HTTP method and path.
+ *  - Executes middleware and the route handler.
+ *  - Catches and handles errors, optionally bubbling them if configured.
+ *  - Cleans up any session services created during processing.
  *
- * @param {Object} options - Options for running the route
- * @returns {Promise<Out | void>} Result of the route handler
- * @ignore
+ * @template In Expected input data type.
+ * @template Out Expected output data type.
+ * @param {Request | PikkuHTTPRequest} request - The incoming HTTP request.
+ * @param {PikkuHTTPResponse} response - The response object to be populated.
+ * @param {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
+ * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const runHTTPRoute = async ({ singletonServices, request, response, createSessionServices, route: apiRoute, method: apiType, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceToArray = false, bubbleErrors = false, }) => {
-    const context = new Map();
-    const userSessionService = new LocalUserSessionService();
+export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceToArray = false, bubbleErrors = false, }) => {
+    const userSessionService = new PikkuUserSessionService();
     let sessionServices;
     let result;
-    // Create HTTP interaction object
-    const http = createHTTPInteraction(request, response);
-    // Find matching route
+    // Combine the request and response into one interaction object
+    const http = createHTTPInteraction(request instanceof Request ? new PikkuFetchHTTPRequest(request) : request, response);
+    const apiType = http.request.method();
+    const apiRoute = http.request.path();
+    // Locate the matching route based on the HTTP method and path
     const matchedRoute = getMatchingRoute(apiType, apiRoute);
     try {
-        // Handle route not found
+        // If no route matches, log the occurrence and throw a NotFoundError
         if (!matchedRoute) {
             singletonServices.logger.info({
                 message: 'Route not found',
@@ -191,23 +275,23 @@ export const runHTTPRoute = async ({ singletonServices, request, response, creat
             });
             throw new NotFoundError(`Route not found: ${apiRoute}`);
         }
-        // Execute route with middleware
+        // Execute the matched route along with its middleware and session management
         ;
         ({ result, sessionServices } = await executeRouteWithMiddleware({
             singletonServices,
             userSessionService,
-            context,
             createSessionServices,
             skipUserSession,
         }, matchedRoute, http, { coerceToArray }));
         return result;
     }
     catch (e) {
-        // Handle and possibly bubble the error
-        handleError(e, http, context.get('trackingId'), singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        // Handle errors and, depending on configuration, bubble them up or respond with an error
+        handleError(e, http, '111', // TODO: context.get('trackingId'),
+        singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {
-        // Clean up session services
+        // Clean up any session-specific services created during processing
         if (sessionServices) {
             await closeSessionServices(singletonServices.logger, sessionServices);
         }

package/dist/http/http-routes.types.d.ts

@@ -1,10 +1,7 @@
+import { SerializeOptions } from 'cookie';
 import { PikkuError } from '../errors/error-handler.js';
 import { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
 import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../types/functions.types.js';
-import { PikkuRequest } from '../pikku-request.js';
-import { PikkuResponse } from '../pikku-response.js';
-import { PikkuHTTPAbstractRequest } from './pikku-http-abstract-request.js';
-import { PikkuHTTPAbstractResponse } from './pikku-http-abstract-response.js';
 type ExtractRouteParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
 export type AssertRouteParams<In, Route extends string> = ExtractRouteParams<Route> extends keyof In ? unknown : ['Error: Route parameters', ExtractRouteParams<Route>, 'not in', keyof In];
 export type RunRouteOptions = Partial<{
@@ -14,10 +11,8 @@ export type RunRouteOptions = Partial<{
     coerceToArray: boolean;
     bubbleErrors: boolean;
 }>;
-export type RunRouteParams<In> = {
+export type RunRouteParams = {
     singletonServices: CoreSingletonServices;
-    request: PikkuRequest<In> | PikkuHTTPAbstractRequest<In>;
-    response?: PikkuResponse | PikkuHTTPAbstractResponse | undefined;
     createSessionServices: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 /**
@@ -44,8 +39,8 @@ export type CoreHTTPFunction = {
  * Represents a http interaction within Pikku, including a request and response.
  */
 export interface PikkuHTTP {
-    request?: PikkuHTTPAbstractRequest;
-    response?: PikkuHTTPAbstractResponse;
+    request?: PikkuHTTPRequest;
+    response?: PikkuHTTPResponse;
 }
 /**
  * Represents request headers as either a record or a function to get headers by name.
@@ -130,4 +125,24 @@ export type HTTPRouteMiddleware = {
     route: string;
     middleware: PikkuMiddleware[];
 };
+export interface PikkuHTTPRequest<In = unknown> {
+    method(): HTTPMethod;
+    path(): string;
+    data(): Promise<In>;
+    json(): Promise<unknown>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    header(headerName: string): string | null;
+    cookie(name?: string): string | null;
+    params(): Partial<Record<string, string | string[]>>;
+    setParams(params: Record<string, string | string[] | undefined>): void;
+    query(): PikkuQuery;
+}
+export interface PikkuHTTPResponse {
+    status(code: number): this;
+    cookie(name: string, value: string | null, options: SerializeOptions): this;
+    header(name: string, value: string | string[]): this;
+    arrayBuffer(data: XMLHttpRequestBodyInit): this;
+    json(data: unknown): this;
+    redirect(location: string, status?: number): this;
+}
 export {};

package/dist/http/incomingmessage-to-request-convertor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/http/incomingmessage-to-request-convertor.js

@@ -0,0 +1 @@
+export {};

package/dist/http/index.d.ts

@@ -1,5 +1,6 @@
-export * from './pikku-http-abstract-request.js';
-export * from './pikku-http-abstract-response.js';
+export * from './pikku-fetch-http-request.js';
+export * from './pikku-fetch-http-response.js';
+export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
-export { runHTTPRoute, addRoute } from './http-route-runner.js';
+export { fetch, fetchData, addRoute } from './http-route-runner.js';
 export type * from './http-routes.types.js';

package/dist/http/index.js

@@ -1,4 +1,5 @@
-export * from './pikku-http-abstract-request.js';
-export * from './pikku-http-abstract-response.js';
+export * from './pikku-fetch-http-request.js';
+export * from './pikku-fetch-http-response.js';
+export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
-export { runHTTPRoute, addRoute } from './http-route-runner.js';
+export { fetch, fetchData, addRoute } from './http-route-runner.js';

package/dist/http/{pikku-http-abstract-request.d.ts → pikku-fetch-http-request.d.ts}

@@ -1,41 +1,41 @@
-import { PikkuRequest } from '../pikku-request.js';
-import { HTTPMethod, PikkuQuery } from './http-routes.types.js';
+import { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http-routes.types.js';
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.
  * @group RequestResponse
  */
-export declare abstract class PikkuHTTPAbstractRequest<In = unknown> extends PikkuRequest<In> {
-    path: string;
-    method: HTTPMethod;
-    private params;
-    constructor(path: string, method: HTTPMethod);
+export declare class PikkuFetchHTTPRequest<In = unknown> implements PikkuHTTPRequest<In> {
+    #private;
+    private request;
+    constructor(request: Request);
+    method(): HTTPMethod;
+    path(): string;
     /**
      * Retrieves the request body.
      * @returns A promise that resolves to the request body.
      */
-    abstract getBody(): Promise<In>;
+    json(): Promise<In>;
     /**
      * Retrieves the raw request body as a Buffer.
      * @returns A promise that resolves to the raw request body.
      */
-    getRawBody(): Promise<Buffer>;
+    arrayBuffer(): Promise<ArrayBuffer>;
     /**
      * Retrieves the value of a specific header.
      * @param headerName - The name of the header to retrieve.
      * @returns The value of the header, or undefined if the header is not found.
      */
-    abstract getHeader(headerName: string): string | undefined;
+    header(headerName: string): string | null;
     /**
      * Retrieves the cookies from the request.
      * @returns An object containing the cookies.
      */
-    getCookies(): Partial<Record<string, string>>;
+    cookie(cookieName: string): string | null;
     /**
      * Retrieves the request parameters.
      * @returns An object containing the request parameters.
      */
-    getParams(): Partial<Record<string, string | string[]>>;
+    params(): Partial<Record<string, string | string[]>>;
     /**
      * Sets the request parameters.
      * @param params - An object containing the request parameters to set.
@@ -45,16 +45,10 @@ export declare abstract class PikkuHTTPAbstractRequest<In = unknown> extends Pik
      * Retrieves the query parameters from the request.
      * @returns An object containing the query parameters.
      */
-    getQuery(): PikkuQuery;
-    /**
-     * Retrieves the IP address of the client making the request.
-     * @returns The IP address of the client.
-     * @throws {Error} This method is not implemented and should be overridden by subclasses.
-     */
-    getIP(): string;
+    query(): PikkuQuery;
     /**
      * Retrieves the combined data from the request, including parameters, query, and body.
      * @returns A promise that resolves to an object containing the combined data.
      */
-    getData(): Promise<In>;
+    data(): Promise<In>;
 }

package/dist/http/pikku-fetch-http-request.js

@@ -0,0 +1,92 @@
+import { parse as parseQuery } from 'picoquery';
+import { parse as parseCookie } from 'cookie';
+/**
+ * Abstract class representing a pikku request.
+ * @template In - The type of the request body.
+ * @group RequestResponse
+ */
+export class PikkuFetchHTTPRequest {
+    request;
+    #cookies;
+    #params = {};
+    #url;
+    constructor(request) {
+        this.request = request;
+        this.#url = new URL(request.url);
+    }
+    method() {
+        return this.request.method.toLowerCase();
+    }
+    path() {
+        return this.#url.pathname;
+    }
+    /**
+     * Retrieves the request body.
+     * @returns A promise that resolves to the request body.
+     */
+    json() {
+        return this.request.json();
+    }
+    /**
+     * Retrieves the raw request body as a Buffer.
+     * @returns A promise that resolves to the raw request body.
+     */
+    arrayBuffer() {
+        return this.request.arrayBuffer();
+    }
+    /**
+     * Retrieves the value of a specific header.
+     * @param headerName - The name of the header to retrieve.
+     * @returns The value of the header, or undefined if the header is not found.
+     */
+    header(headerName) {
+        return this.request.headers.get(headerName.toLowerCase());
+    }
+    /**
+     * Retrieves the cookies from the request.
+     * @returns An object containing the cookies.
+     */
+    cookie(cookieName) {
+        const cookieHeader = this.header('cookie');
+        this.#cookies = cookieHeader ? parseCookie(cookieHeader) : {};
+        return this.#cookies[cookieName] || null;
+    }
+    /**
+     * Retrieves the request parameters.
+     * @returns An object containing the request parameters.
+     */
+    params() {
+        return this.#params;
+    }
+    /**
+     * Sets the request parameters.
+     * @param params - An object containing the request parameters to set.
+     */
+    setParams(params) {
+        this.#params = params;
+    }
+    /**
+     * Retrieves the query parameters from the request.
+     * @returns An object containing the query parameters.
+     */
+    query() {
+        return parseQuery(this.#url.searchParams.toString());
+    }
+    /**
+     * Retrieves the combined data from the request, including parameters, query, and body.
+     * @returns A promise that resolves to an object containing the combined data.
+     */
+    async data() {
+        let body = {};
+        try {
+            body = await this.json();
+        }
+        catch (e) { }
+        return {
+            ...this.params(),
+            ...this.query(),
+            // TODO: If body isn't an object, we should insert it as the word...
+            ...body,
+        };
+    }
+}

package/dist/http/pikku-fetch-http-response.d.ts

@@ -0,0 +1,14 @@
+import { PikkuHTTPResponse } from './http-routes.types.js';
+export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
+    #private;
+    status(code: number): this;
+    cookie(name: string, value: string, flags: any): this;
+    header(name: string, value: string | string[]): this;
+    arrayBuffer(data: XMLHttpRequestBodyInit): this;
+    json(data: unknown): this;
+    text(content: string): this;
+    html(content: string): this;
+    body(body: BodyInit): this;
+    redirect(location: string, status?: number): this;
+    toResponse(args?: Record<string, any>): Response;
+}