@pikku/core 0.12.0 → 0.12.2

package/dist/wirings/gateway/gateway-runner.js

@@ -0,0 +1,325 @@
+import { pikkuState } from '../../pikku-state.js';
+import { addFunction } from '../../function/function-runner.js';
+import { runMiddleware } from '../../middleware-runner.js';
+import { httpRouter } from '../http/routers/http-router.js';
+/**
+ * Register a messaging gateway.
+ *
+ * `wireGateway` is a meta-wiring that composes existing primitives
+ * (`wireHTTP`, `wireChannel`) under the hood.  It does not replace them;
+ * it layers on top.
+ *
+ * @param config - Gateway configuration (name, type, adapter, func, middleware, etc.)
+ */
+export const wireGateway = (config) => {
+    // Store gateway config
+    pikkuState(null, 'gateway', 'gateways').set(config.name, config);
+    switch (config.type) {
+        case 'webhook':
+            wireWebhookGateway(config);
+            break;
+        case 'websocket':
+            wireWebsocketGateway(config);
+            break;
+        case 'listener':
+            wireListenerGateway(config);
+            break;
+        default:
+            throw new Error(`Unknown gateway type '${config.type}' for gateway '${config.name}'`);
+    }
+};
+// ---------------------------------------------------------------------------
+// Webhook gateway — platform POSTs to us
+// ---------------------------------------------------------------------------
+const wireWebhookGateway = (config) => {
+    const { name, route, adapter } = config;
+    if (!route) {
+        throw new Error(`Webhook gateway '${name}' requires a route`);
+    }
+    const postFuncId = `gateway__${name}__post`;
+    const httpMeta = pikkuState(null, 'http', 'meta');
+    const funcMeta = pikkuState(null, 'function', 'meta');
+    const routes = pikkuState(null, 'http', 'routes');
+    // --- POST handler (main message receiver) --------------------------------
+    funcMeta[postFuncId] = {
+        pikkuFuncId: postFuncId,
+        inputSchemaName: null,
+        outputSchemaName: null,
+        sessionless: true,
+    };
+    httpMeta['post'][route] = {
+        pikkuFuncId: postFuncId,
+        route,
+        method: 'post',
+    };
+    const postHandler = {
+        auth: false,
+        func: createWebhookPostHandler(config),
+    };
+    addFunction(postFuncId, postHandler);
+    if (!routes.has('post')) {
+        routes.set('post', new Map());
+    }
+    routes.get('post').set(route, {
+        method: 'post',
+        route,
+        func: postHandler,
+        auth: false,
+    });
+    // --- GET handler (webhook verification, e.g. WhatsApp challenge) ---------
+    if (adapter.verifyWebhook) {
+        const verifyFuncId = `gateway__${name}__verify`;
+        funcMeta[verifyFuncId] = {
+            pikkuFuncId: verifyFuncId,
+            inputSchemaName: null,
+            outputSchemaName: null,
+            sessionless: true,
+        };
+        httpMeta['get'][route] = {
+            pikkuFuncId: verifyFuncId,
+            route,
+            method: 'get',
+        };
+        const verifyHandler = {
+            auth: false,
+            func: createWebhookVerifyHandler(adapter),
+        };
+        addFunction(verifyFuncId, verifyHandler);
+        if (!routes.has('get')) {
+            routes.set('get', new Map());
+        }
+        routes.get('get').set(route, {
+            method: 'get',
+            route,
+            func: verifyHandler,
+            auth: false,
+        });
+    }
+    // Force router to re-initialize on next match
+    httpRouter.reset();
+};
+/**
+ * Creates the POST handler function for a webhook gateway.
+ *
+ * Flow:
+ *  1. Check for POST-based verification (e.g. Slack `url_verification`)
+ *  2. Parse body via adapter → GatewayInboundMessage (or null to ignore)
+ *  3. Populate `wire.gateway`
+ *  4. Run user middleware (which can read `wire.gateway` for auth)
+ *  5. Call user func with parsed message
+ *  6. Auto-send response via adapter if func returns outbound content
+ */
+const createWebhookPostHandler = (config) => {
+    const { name, adapter, func: userFunc, middleware: userMiddleware } = config;
+    const userFuncConfig = userFunc;
+    return async (services, data, wire) => {
+        // Check for POST-based webhook verification (e.g. Slack url_verification)
+        if (adapter.verifyWebhook) {
+            const verifyResult = await adapter.verifyWebhook(data, wire.http?.request);
+            if (verifyResult.verified) {
+                return verifyResult.response;
+            }
+        }
+        // Parse the platform-specific payload
+        const parsed = adapter.parse(data);
+        if (!parsed) {
+            // Ignored event (delivery receipt, typing indicator, etc.)
+            return { ok: true };
+        }
+        // Populate wire.gateway
+        const gateway = {
+            gatewayName: name,
+            senderId: parsed.senderId,
+            platform: adapter.name,
+            send: (msg) => adapter.send(parsed.senderId, msg),
+        };
+        wire.gateway = gateway;
+        // Build combined middleware chain: gateway-level + func-level
+        const allMiddleware = [
+            ...(userMiddleware || []),
+            ...(userFuncConfig.middleware || []),
+        ];
+        const exec = async () => {
+            const result = await userFuncConfig.func(services, parsed, wire);
+            // Auto-send response if the func returns outbound content
+            if (result && (result.text || result.richContent || result.attachments)) {
+                await adapter.send(parsed.senderId, result);
+            }
+            return { ok: true };
+        };
+        if (allMiddleware.length > 0) {
+            return await runMiddleware(services, wire, allMiddleware, exec);
+        }
+        return await exec();
+    };
+};
+/**
+ * Creates the GET handler for webhook verification challenges.
+ * Passes query parameters to the adapter's verifyWebhook method.
+ */
+const createWebhookVerifyHandler = (adapter) => {
+    return async (_services, _data, wire) => {
+        if (!adapter.verifyWebhook) {
+            return { error: 'Verification not supported' };
+        }
+        const query = wire.http?.request?.query();
+        const result = await adapter.verifyWebhook(query, wire.http?.request);
+        if (result.verified) {
+            return result.response;
+        }
+        return { error: 'Verification failed' };
+    };
+};
+// ---------------------------------------------------------------------------
+// WebSocket gateway — client connects via WebSocket
+// ---------------------------------------------------------------------------
+const wireWebsocketGateway = (config) => {
+    const { name, route, adapter } = config;
+    if (!route) {
+        throw new Error(`WebSocket gateway '${name}' requires a route`);
+    }
+    // Store gateway config — the channel runner will reference this
+    pikkuState(null, 'gateway', 'gateways').set(config.name, config);
+    const channelsMeta = pikkuState(null, 'channel', 'meta');
+    const channels = pikkuState(null, 'channel', 'channels');
+    const messageFuncId = `gateway__${name}__message`;
+    const connectFuncId = `gateway__${name}__connect`;
+    // Add function metadata
+    const funcMeta = pikkuState(null, 'function', 'meta');
+    funcMeta[messageFuncId] = {
+        pikkuFuncId: messageFuncId,
+        inputSchemaName: null,
+        outputSchemaName: null,
+        sessionless: true,
+    };
+    funcMeta[connectFuncId] = {
+        pikkuFuncId: connectFuncId,
+        inputSchemaName: null,
+        outputSchemaName: null,
+        sessionless: true,
+    };
+    // Add channel metadata
+    channelsMeta[name] = {
+        name,
+        route,
+        gateway: true,
+        connect: { pikkuFuncId: connectFuncId },
+        message: { pikkuFuncId: messageFuncId },
+    };
+    const userFuncConfig = config.func;
+    const userMiddleware = config.middleware;
+    // Register onConnect
+    addFunction(connectFuncId, {
+        auth: false,
+        func: async (_services, _data, wire) => {
+            ;
+            wire.gateway = {
+                gatewayName: name,
+                senderId: '',
+                platform: adapter.name,
+                send: async (msg) => {
+                    wire.channel?.send(msg);
+                },
+            };
+        },
+    });
+    // Register onMessage
+    addFunction(messageFuncId, {
+        auth: false,
+        func: async (services, data, wire) => {
+            const parsed = adapter.parse(data);
+            if (!parsed)
+                return;
+            const gateway = {
+                gatewayName: name,
+                senderId: parsed.senderId,
+                platform: adapter.name,
+                send: async (msg) => {
+                    wire.channel?.send(msg);
+                },
+            };
+            wire.gateway = gateway;
+            const allMiddleware = [
+                ...(userMiddleware || []),
+                ...(userFuncConfig.middleware || []),
+            ];
+            const exec = async () => {
+                const result = await userFuncConfig.func(services, parsed, wire);
+                if (result &&
+                    (result.text || result.richContent || result.attachments)) {
+                    wire.channel?.send(result);
+                }
+            };
+            if (allMiddleware.length > 0) {
+                await runMiddleware(services, wire, allMiddleware, exec);
+            }
+            else {
+                await exec();
+            }
+        },
+    });
+    // Store channel config
+    channels.set(name, {
+        name,
+        route,
+        auth: false,
+        onConnect: { func: async () => { } },
+        onMessage: { func: async () => { } },
+    });
+    // Force router to re-initialize
+    httpRouter.reset();
+};
+// ---------------------------------------------------------------------------
+// Listener gateway — standalone event loop, no route
+// ---------------------------------------------------------------------------
+const wireListenerGateway = (config) => {
+    // Listener gateways don't register routes.
+    // They are started manually and call into the gateway's func directly.
+    // The gateway config is already stored in pikkuState.
+    pikkuState(null, 'gateway', 'gateways').set(config.name, config);
+};
+/**
+ * Create the message handler callback for a listener gateway.
+ *
+ * Returns a function `(rawData: unknown) => Promise<void>` that can be
+ * passed to `adapter.init()`.  Used by `LocalGatewayService` (and any
+ * other GatewayService implementation) to wire up listener gateways.
+ *
+ * @param name   - Gateway name (for wire.gateway metadata)
+ * @param config - The gateway configuration (adapter, func, middleware)
+ * @param singletonServices - Singleton services to pass to handler/middleware
+ */
+export const createListenerMessageHandler = (name, config, singletonServices) => {
+    const { adapter } = config;
+    const userFuncConfig = config.func;
+    const userMiddleware = config.middleware;
+    return async (rawData) => {
+        const parsed = adapter.parse(rawData);
+        if (!parsed)
+            return;
+        const wire = {};
+        const gateway = {
+            gatewayName: name,
+            senderId: parsed.senderId,
+            platform: adapter.name,
+            send: (msg) => adapter.send(parsed.senderId, msg),
+        };
+        wire.gateway = gateway;
+        const allMiddleware = [
+            ...(userMiddleware || []),
+            ...(userFuncConfig.middleware || []),
+        ];
+        const exec = async () => {
+            const result = await userFuncConfig.func(singletonServices, parsed, wire);
+            if (result && (result.text || result.richContent || result.attachments)) {
+                await adapter.send(parsed.senderId, result);
+            }
+        };
+        if (allMiddleware.length > 0) {
+            await runMiddleware(singletonServices, wire, allMiddleware, exec);
+        }
+        else {
+            await exec();
+        }
+    };
+};

package/dist/wirings/gateway/gateway.types.d.ts

@@ -0,0 +1,127 @@
+import type { CommonWireMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
+import type { CorePikkuFunctionConfig, CorePermissionGroup, CorePikkuPermission } from '../../function/functions.types.js';
+import type { PikkuHTTPRequest } from '../http/http.types.js';
+/**
+ * Attachment in gateway messages (images, files, etc.)
+ */
+export interface GatewayAttachment {
+    type: string;
+    url?: string;
+    data?: ArrayBuffer | Uint8Array;
+    mimeType?: string;
+    filename?: string;
+}
+/**
+ * Normalized inbound message from any platform
+ */
+export interface GatewayInboundMessage {
+    /** Platform-specific sender identifier (phone number, Slack user ID, etc.) */
+    senderId: string;
+    /** Message text content */
+    text: string;
+    /** Original platform-specific payload */
+    raw: unknown;
+    /** Optional file/media attachments */
+    attachments?: GatewayAttachment[];
+    /** Optional platform-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Outbound message to send back via the platform
+ */
+export interface GatewayOutboundMessage {
+    /** Plain text response */
+    text?: string;
+    /** Platform-specific rich content (Slack blocks, WhatsApp templates, etc.) */
+    richContent?: Record<string, unknown>;
+    /** Optional file/media attachments */
+    attachments?: GatewayAttachment[];
+}
+/**
+ * Result of webhook verification (e.g., WhatsApp GET challenge, Slack url_verification)
+ */
+export type WebhookVerificationResult = {
+    verified: true;
+    response: unknown;
+} | {
+    verified: false;
+};
+/**
+ * Gateway adapter interface — implemented by platform-specific addon packages.
+ *
+ * Two responsibilities:
+ * 1. Parse incoming platform-specific format into normalized GatewayInboundMessage
+ * 2. Send outgoing GatewayOutboundMessage via the platform's API
+ */
+export interface GatewayAdapter {
+    /** Platform name (e.g., 'whatsapp', 'slack', 'telegram') */
+    name: string;
+    /** Parse platform-specific payload into normalized message. Return null to ignore (e.g., delivery receipts). */
+    parse(data: unknown): GatewayInboundMessage | null;
+    /** Send a message to a specific sender via the platform's API */
+    send(senderId: string, message: GatewayOutboundMessage): Promise<void>;
+    /** Initialize the adapter (connect to platform, start listening).
+     *  Called by GatewayService.start() — the adapter should call onMessage for each incoming event. */
+    init(onMessage: (data: unknown) => Promise<void>): Promise<void>;
+    /** Tear down the adapter (disconnect, release resources). */
+    close(): Promise<void>;
+    /** Handle webhook verification challenges (only for webhook type).
+     *  Receives the data (body or query params) and the Pikku HTTP request for additional inspection. */
+    verifyWebhook?(data: unknown, request?: PikkuHTTPRequest): WebhookVerificationResult | Promise<WebhookVerificationResult>;
+}
+/**
+ * The gateway wire object available on wire.gateway inside handler functions and middleware
+ */
+export interface PikkuGateway {
+    /** Name of this gateway instance */
+    gatewayName: string;
+    /** Platform-specific sender identifier */
+    senderId: string;
+    /** Platform name from adapter.name */
+    platform: string;
+    /** Send a proactive message to the sender */
+    send(msg: GatewayOutboundMessage): Promise<void>;
+}
+/**
+ * Gateway transport type:
+ * - 'webhook': Platform POSTs to us (WhatsApp Cloud API, Slack Events API, Telegram webhooks)
+ * - 'websocket': Client connects via WebSocket (WebChat, browser widget)
+ * - 'listener': Standalone event loop, no route (Baileys, Signal CLI, Matrix sync)
+ */
+export type GatewayTransportType = 'webhook' | 'websocket' | 'listener';
+/**
+ * Core gateway configuration for wireGateway()
+ */
+export type CoreGateway<PikkuFunctionConfig = CorePikkuFunctionConfig<any, any>, PikkuPermission extends CorePikkuPermission = CorePikkuPermission, PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware> = {
+    /** Unique name for this gateway */
+    name: string;
+    /** Transport type */
+    type: GatewayTransportType;
+    /** HTTP route for webhook/websocket types */
+    route?: string;
+    /** The gateway adapter (parse inbound, send outbound) */
+    adapter: GatewayAdapter;
+    /** The handler function that processes parsed messages */
+    func: PikkuFunctionConfig;
+    /** Optional middleware chain (e.g., auth) */
+    middleware?: CorePikkuMiddlewareGroup<any, any>;
+    /** Optional permissions */
+    permissions?: CorePermissionGroup | PikkuPermission[];
+    /** Optional tags for categorization */
+    tags?: string[];
+    /** Whether authentication is required (default: true) */
+    auth?: boolean;
+};
+/**
+ * Metadata for a registered gateway, stored in state
+ */
+export type GatewayMeta = CommonWireMeta & {
+    name: string;
+    type: GatewayTransportType;
+    route?: string;
+    gateway: true;
+};
+/**
+ * All gateway metadata keyed by name
+ */
+export type GatewaysMeta = Record<string, GatewayMeta>;

package/dist/wirings/gateway/index.d.ts

@@ -0,0 +1,2 @@
+export { wireGateway, createListenerMessageHandler } from './gateway-runner.js';
+export type { GatewayAdapter, GatewayAttachment, GatewayInboundMessage, GatewayOutboundMessage, GatewayMeta, GatewaysMeta, GatewayTransportType, CoreGateway, PikkuGateway, WebhookVerificationResult, } from './gateway.types.js';

package/dist/wirings/gateway/index.js

@@ -0,0 +1 @@
+export { wireGateway, createListenerMessageHandler } from './gateway-runner.js';

package/dist/wirings/http/http-runner.d.ts

@@ -1,6 +1,6 @@
-import { CoreHTTPFunctionWiring, RunHTTPWiringOptions, RunHTTPWiringParams, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
-import { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup } from '../../function/functions.types.js';
-import { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
+import type { CoreHTTPFunctionWiring, RunHTTPWiringOptions, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
+import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup } from '../../function/functions.types.js';
+import type { CorePikkuMiddleware, CorePikkuMiddlewareGroup } from '../../types/core.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 /**
  * Registers HTTP middleware for a specific route pattern.
@@ -101,10 +101,10 @@ export declare const createHTTPWire: (request: PikkuHTTPRequest | undefined, res
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request} request - The native Fetch API Request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Additional options including services and session management.
+ * @param {RunHTTPWiringOptions} params - Additional options including services and session management.
  * @returns {Promise<Response>} A promise that resolves to a Fetch API Response object.
  */
-export declare const fetch: <In, Out>(request: Request, params: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Response>;
+export declare const fetch: <In, Out>(request: Request, params?: RunHTTPWiringOptions) => Promise<Response>;
 /**
  * Executes an HTTP route using a Pikku-specific request wrapper.
  *
@@ -114,10 +114,10 @@ export declare const fetch: <In, Out>(request: Request, params: RunHTTPWiringOpt
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Execution options including services and session configuration.
+ * @param {RunHTTPWiringOptions} params - Execution options including services and session configuration.
  * @returns {Promise<PikkuFetchHTTPResponse>} A promise that resolves to a PikkuFetchHTTPResponse object.
  */
-export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest, params: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<PikkuFetchHTTPResponse>;
+export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest, params?: RunHTTPWiringOptions) => Promise<PikkuFetchHTTPResponse>;
 /**
  * Core function to process an HTTP request through route matching, validation,
  * middleware execution, error handling, and session service cleanup.
@@ -133,7 +133,7 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The incoming HTTP request.
  * @param {PikkuHTTPResponse} response - The response object to be populated.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} options - Options such as singleton services, session handling, and error configuration.
+ * @param {RunHTTPWiringOptions} 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 declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createWireServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }?: RunHTTPWiringOptions) => Promise<Out | void>;

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

@@ -1,6 +1,7 @@
 import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
 import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
-import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
+import { getSingletonServices, getCreateWireServices, } from '../../pikku-state.js';
+import { PikkuSessionService } from '../../services/user-session-service.js';
 import { handleHTTPError } from '../../handle-error.js';
 import { pikkuState } from '../../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
@@ -8,6 +9,7 @@ import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { httpRouter } from './routers/http-router.js';
 import { validateSchema } from '../../schema.js';
+import { runMiddleware } from '../../middleware-runner.js';
 /**
  * Extract headers from a PikkuHTTPRequest based on the schema keys
  */
@@ -238,6 +240,9 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             send: (data) => {
                 response.arrayBuffer(isSerializable(data) ? JSON.stringify(data) : data);
             },
+            sendBinary: (data) => {
+                response.arrayBuffer(data);
+            },
             close: () => {
                 channel.state = 'closed';
                 response.close?.();
@@ -248,7 +253,10 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     const wire = {
         http,
         channel,
-        ...createMiddlewareSessionWireProps(userSession),
+        session: userSession.get(),
+        setSession: (s) => userSession.setInitial(s),
+        getSession: () => userSession.get(),
+        hasSessionChanged: () => userSession.sessionChanged,
     };
     result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncId, {
         singletonServices,
@@ -290,10 +298,10 @@ const executeRoute = async (services, matchedRoute, http, options) => {
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request} request - The native Fetch API Request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Additional options including services and session management.
+ * @param {RunHTTPWiringOptions} 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) => {
+export const fetch = async (request, params = {}) => {
     const pikkuResponse = new PikkuFetchHTTPResponse();
     await fetchData(request, pikkuResponse, params);
     return pikkuResponse.toResponse();
@@ -307,10 +315,10 @@ export const fetch = async (request, params) => {
  * @template In Expected input data type.
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The request object.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} params - Execution options including services and session configuration.
+ * @param {RunHTTPWiringOptions} 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) => {
+export const pikkuFetch = async (request, params = {}) => {
     const pikkuResponse = new PikkuFetchHTTPResponse();
     await fetchData(request, pikkuResponse, params);
     return pikkuResponse;
@@ -330,24 +338,39 @@ export const pikkuFetch = async (request, params) => {
  * @template Out Expected output data type.
  * @param {Request | PikkuHTTPRequest} request - The incoming HTTP request.
  * @param {PikkuHTTPResponse} response - The response object to be populated.
- * @param {RunHTTPWiringOptions & RunHTTPWiringParams} options - Options such as singleton services, session handling, and error configuration.
+ * @param {RunHTTPWiringOptions} 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 fetchData = async (request, response, { singletonServices, createWireServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
-    const requestId = request.getHeader?.('x-request-id') ||
-        generateRequestId?.() ||
-        createWeakUID();
+export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, } = {}) => {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     let wireServices;
     let result;
     // Combine the request and response into one wire object
-    const http = createHTTPWire(request instanceof Request ? new PikkuFetchHTTPRequest(request) : request, response);
+    const pikkuRequest = request instanceof Request ? new PikkuFetchHTTPRequest(request) : request;
+    let requestId = null;
+    try {
+        requestId = pikkuRequest.header('x-request-id');
+    }
+    catch { }
+    requestId = requestId || generateRequestId?.() || createWeakUID();
+    const http = createHTTPWire(pikkuRequest, 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 {
-        // If no route matches, log the occurrence and throw a NotFoundError
         if (!matchedRoute) {
+            if (apiType.toLowerCase() === 'options') {
+                const httpGroups = pikkuState(null, 'middleware', 'httpGroup');
+                const globalMiddleware = httpGroups['*'];
+                const wire = { http: http };
+                if (globalMiddleware) {
+                    await runMiddleware(singletonServices, wire, globalMiddleware);
+                }
+                response.status(204).json(undefined);
+                return;
+            }
             singletonServices.logger.info({
                 message: 'Route not found',
                 apiRoute,
@@ -366,7 +389,6 @@ export const fetchData = async (request, response, { singletonServices, createWi
         return result;
     }
     catch (e) {
-        // Handle errors and, depending on configuration, bubble them up or respond with an error
         handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {

package/dist/wirings/http/http.types.d.ts

@@ -1,7 +1,7 @@
 import type { SerializeOptions } from 'cookie';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { PikkuError } from '../../errors/error-handler.js';
-import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateWireServices, CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
+import type { PikkuError } from '../../errors/error-handler.js';
+import type { CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
 import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup, CorePikkuFunctionConfig } from '../../function/functions.types.js';
 type ExtractHTTPWiringParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractHTTPWiringParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
 export type AssertHTTPWiringParams<In, HTTPWiring extends string> = ExtractHTTPWiringParams<HTTPWiring> extends keyof In ? unknown : [
@@ -18,10 +18,6 @@ export type RunHTTPWiringOptions = Partial<{
     bubbleErrors: boolean;
     generateRequestId: () => string;
 }>;
-export type RunHTTPWiringParams = {
-    singletonServices: CoreSingletonServices;
-    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
-};
 /**
  * Represents the HTTP methods supported for API HTTP wirings.
  */

package/dist/wirings/http/log-http-routes.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../../services/index.js';
+import type { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded routes.
  * @param logger - A logger for logging information.

package/dist/wirings/http/pikku-fetch-http-request.d.ts

@@ -1,4 +1,4 @@
-import { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js';
+import type { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js';
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.

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

@@ -1,5 +1,5 @@
-import { PikkuHTTPResponse } from './http.types.js';
-import { SerializeOptions as CookieSerializeOptions } from 'cookie';
+import type { PikkuHTTPResponse } from './http.types.js';
+import type { SerializeOptions as CookieSerializeOptions } from 'cookie';
 export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     #private;
     setMode(mode: 'stream'): void;