@pikku/core 0.11.1 → 0.12.0

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

@@ -0,0 +1,139 @@
+import { wireHTTP } from './http-runner.js';
+export function defineHTTPRoutes(configOrRoutes) {
+    // If it has a 'routes' property and contains a map (not a route config), it's config + routes
+    if ('routes' in configOrRoutes &&
+        typeof configOrRoutes.routes === 'object' &&
+        !isRouteConfig(configOrRoutes.routes)) {
+        return configOrRoutes;
+    }
+    // Otherwise it's just routes
+    return { routes: configOrRoutes };
+}
+/**
+ * Wires multiple HTTP routes from a nested map or array configuration.
+ * Inspired by ts-rest's contract pattern, provides a single place to wire an entire API.
+ *
+ * @example
+ * ```typescript
+ * // Nested object format
+ * wireHTTPRoutes({
+ *   basePath: '/api/v1',
+ *   tags: ['api'],
+ *   routes: {
+ *     todos: {
+ *       list: { method: 'get', route: '/todos', func: listTodos },
+ *       get: { method: 'get', route: '/todos/:id', func: getTodo },
+ *     },
+ *     auth: {
+ *       login: { method: 'post', route: '/auth/login', func: login, auth: false },
+ *     },
+ *   },
+ * })
+ *
+ * // Flat array format
+ * wireHTTPRoutes({
+ *   basePath: '/api',
+ *   routes: [
+ *     { method: 'get', route: '/todos', func: listTodos },
+ *     { method: 'post', route: '/todos', func: createTodo },
+ *   ],
+ * })
+ *
+ * // Composing route contracts
+ * wireHTTPRoutes({
+ *   basePath: '/api/v1',
+ *   routes: {
+ *     todos: todosRoutes,  // from defineHTTPRoutes()
+ *     auth: authRoutes,    // from defineHTTPRoutes()
+ *   },
+ * })
+ * ```
+ */
+export const wireHTTPRoutes = (config) => {
+    const { routes, ...groupConfig } = config;
+    if (Array.isArray(routes)) {
+        routes.forEach((route) => registerRoute(route, groupConfig));
+    }
+    else {
+        processRouteMap(routes, groupConfig);
+    }
+};
+/**
+ * Recursively processes a route map, handling nested maps and contracts
+ */
+function processRouteMap(map, parentConfig) {
+    for (const [_key, value] of Object.entries(map)) {
+        if (isRouteConfig(value)) {
+            registerRoute(value, parentConfig);
+        }
+        else if (isRouteContract(value)) {
+            // Merge parent config with contract config, then process routes
+            const mergedConfig = mergeGroupConfig(parentConfig, value);
+            processRouteMap(value.routes, mergedConfig);
+        }
+        else {
+            // Nested map without config
+            processRouteMap(value, parentConfig);
+        }
+    }
+}
+/**
+ * Merge group configs with proper cascading behavior:
+ * - basePath: Concatenates
+ * - tags: Merges (parent + child)
+ * - middleware: Merges (parent runs first)
+ * - auth: Inner overrides outer
+ * - permissions: Inner overrides outer
+ */
+function mergeGroupConfig(parent, child) {
+    return {
+        basePath: (parent.basePath || '') + (child.basePath || ''),
+        tags: [...(parent.tags || []), ...(child.tags || [])],
+        middleware: [...(parent.middleware || []), ...(child.middleware || [])],
+        auth: child.auth ?? parent.auth,
+        permissions: child.permissions ?? parent.permissions,
+    };
+}
+/**
+ * Registers a single route by calling wireHTTP with merged configuration
+ */
+function registerRoute(route, groupConfig) {
+    const fullRoute = (groupConfig.basePath || '') + route.route;
+    wireHTTP({
+        method: route.method,
+        route: fullRoute,
+        func: route.func,
+        auth: route.auth ?? groupConfig.auth,
+        tags: [...(groupConfig.tags || []), ...(route.tags || [])],
+        middleware: [
+            ...(groupConfig.middleware || []),
+            ...(route.middleware || []),
+        ],
+        permissions: route.permissions ?? groupConfig.permissions,
+        contentType: route.contentType,
+        timeout: route.timeout,
+        headers: route.headers,
+        docs: route.docs,
+        sse: route.sse,
+    });
+}
+/**
+ * Type guard to check if a value is an individual route config
+ */
+function isRouteConfig(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'method' in value &&
+        'func' in value &&
+        'route' in value);
+}
+/**
+ * Type guard to check if a value is a route contract (has routes property but is not a route config)
+ */
+function isRouteContract(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'routes' in value &&
+        !('method' in value) &&
+        !('func' in value));
+}

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

@@ -31,7 +31,7 @@ import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
  * ])
  * ```
  */
-export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup) => CorePikkuMiddlewareGroup;
+export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup, packageName?: string | null) => CorePikkuMiddlewareGroup;
 /**
  * Registers HTTP permissions for a specific route pattern.
  *
@@ -61,7 +61,7 @@ export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddle
  * ])
  * ```
  */
-export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermission>(pattern: string, permissions: CorePermissionGroup | CorePikkuPermission[]) => CorePermissionGroup | CorePikkuPermission[];
+export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermission>(pattern: string, permissions: CorePermissionGroup | CorePikkuPermission[], packageName?: string | null) => CorePermissionGroup | CorePikkuPermission[];
 /**
  * Adds a new route to the global HTTP route registry.
  *

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

@@ -1,12 +1,26 @@
-import { NotFoundError } from '../../errors/errors.js';
+import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
 import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
-import { PikkuSessionService } from '../../services/user-session-service.js';
+import { PikkuSessionService, createMiddlewareSessionWireProps, } 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';
 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';
+/**
+ * Extract headers from a PikkuHTTPRequest based on the schema keys
+ */
+function extractHeadersFromRequest(request, headerKeys) {
+    const headers = {};
+    for (const headerName of headerKeys) {
+        const value = request.header(headerName);
+        if (value !== null) {
+            headers[headerName] = value;
+        }
+    }
+    return headers;
+}
 /**
  * Registers HTTP middleware for a specific route pattern.
  *
@@ -36,8 +50,8 @@ import { httpRouter } from './routers/http-router.js';
  * ])
  * ```
  */
-export const addHTTPMiddleware = (pattern, middleware) => {
-    const httpGroups = pikkuState('middleware', 'httpGroup');
+export const addHTTPMiddleware = (pattern, middleware, packageName = null) => {
+    const httpGroups = pikkuState(packageName, 'middleware', 'httpGroup');
     httpGroups[pattern] = middleware;
     return middleware;
 };
@@ -70,8 +84,8 @@ export const addHTTPMiddleware = (pattern, middleware) => {
  * ])
  * ```
  */
-export const addHTTPPermission = (pattern, permissions) => {
-    const httpGroups = pikkuState('permissions', 'httpGroup');
+export const addHTTPPermission = (pattern, permissions, packageName = null) => {
+    const httpGroups = pikkuState(packageName, 'permissions', 'httpGroup');
     httpGroups[pattern] = permissions;
     return permissions;
 };
@@ -91,17 +105,19 @@ export const addHTTPPermission = (pattern, permissions) => {
  * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>} httpWiring - The HTTP wiring configuration object.
  */
 export const wireHTTP = (httpWiring) => {
-    const httpMeta = pikkuState('http', 'meta');
+    const httpMeta = pikkuState(null, 'http', 'meta');
     const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
-        throw new Error('Route metadata not found');
+        throw new PikkuMissingMetaError(`Missing generated metadata for HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}'`);
     }
-    addFunction(routeMeta.pikkuFuncName, httpWiring.func);
-    const routes = pikkuState('http', 'routes');
+    if (httpWiring.func) {
+        addFunction(routeMeta.pikkuFuncId, httpWiring.func);
+    }
+    const routes = pikkuState(null, 'http', 'routes');
     if (!routes.has(httpWiring.method)) {
         routes.set(httpWiring.method, new Map());
     }
-    pikkuState('http', 'routes')
+    pikkuState(null, 'http', 'routes')
         .get(httpWiring.method)
         ?.set(httpWiring.route, httpWiring);
 };
@@ -119,10 +135,10 @@ export const wireHTTP = (httpWiring) => {
 const getMatchingRoute = (requestType, requestPath) => {
     const matchedPath = httpRouter.match(requestType.toLowerCase(), requestPath);
     if (matchedPath) {
-        const route = pikkuState('http', 'routes')
+        const route = pikkuState(null, 'http', 'routes')
             .get(requestType.toLowerCase())
             .get(matchedPath.route);
-        const meta = pikkuState('http', 'meta')[requestType.toLowerCase()][route.route];
+        const meta = pikkuState(null, 'http', 'meta')[requestType.toLowerCase()][route.route];
         return {
             matchedPath,
             params: matchedPath.params,
@@ -179,17 +195,29 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     const userSession = new PikkuSessionService();
     const { params, route, meta } = matchedRoute;
     const { singletonServices, createWireServices, skipUserSession, requestId } = services;
+    // Attach URL parameters to the request object
+    http?.request?.setParams(params);
+    // Validate request headers if schema is defined
+    if (meta.headersSchemaName && http.request && singletonServices.schema) {
+        const headerKeys = singletonServices.schema.getSchemaKeys(meta.headersSchemaName);
+        const rawHeaders = extractHeadersFromRequest(http.request, headerKeys);
+        await validateSchema(singletonServices.logger, singletonServices.schema, meta.headersSchemaName, rawHeaders);
+    }
     const requiresSession = route.auth !== false;
     let wireServices;
     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()}`);
     // Ensure session is available when required
     if (skipUserSession && requiresSession) {
         throw new Error("Can't skip trying to get user session if auth is required");
     }
-    const data = () => http.request.data();
+    let cachedData;
+    const data = async () => {
+        if (cachedData === undefined) {
+            cachedData = await http.request.data();
+        }
+        return cachedData;
+    };
     let channel;
     if (matchedRoute.route.sse) {
         const response = http?.response;
@@ -217,8 +245,12 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             state: 'open',
         };
     }
-    const wire = { http, channel, session: userSession };
-    result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
+    const wire = {
+        http,
+        channel,
+        ...createMiddlewareSessionWireProps(userSession),
+    };
+    result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncId, {
         singletonServices,
         createWireServices,
         auth: route.auth !== false,
@@ -230,17 +262,20 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         coerceDataFromSchema: options.coerceDataFromSchema,
         tags: route.tags,
         wire,
+        sessionService: userSession,
     });
-    // Respond with either a binary or JSON response based on configuration
-    if (route.returnsJSON === false) {
-        http?.response?.arrayBuffer(result);
-    }
-    else {
-        http?.response?.json(result);
+    if (!matchedRoute.route.sse) {
+        if (result === undefined || result === null) {
+            http?.response?.status(204);
+        }
+        else if (route.returnsJSON === false) {
+            http?.response?.arrayBuffer(result);
+        }
+        else {
+            http?.response?.status(200);
+            http?.response?.json(result);
+        }
     }
-    http?.response?.status(200);
-    // TODO: Evaluate if the response stream should be explicitly ended.
-    // http?.response?.end()
     return wireServices ? { result, wireServices } : { result };
 };
 /**

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

@@ -1,5 +1,6 @@
 import type { SerializeOptions } from 'cookie';
-import type { PikkuError } from '../../errors/error-handler.js';
+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 { 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;
@@ -19,28 +20,43 @@ export type RunHTTPWiringOptions = Partial<{
 }>;
 export type RunHTTPWiringParams = {
     singletonServices: CoreSingletonServices;
-    createWireServices: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 /**
  * Represents the HTTP methods supported for API HTTP wirings.
-t */
+ */
 export type HTTPMethod = 'post' | 'get' | 'delete' | 'patch' | 'head' | 'put' | 'options';
 /**
- * Represents an API HTTP wiring without a function, including metadata such as content type, route, and timeout settings.
+ * Header schema type for request header validation.
+ * Uses Standard Schema interface - works with Zod, Valibot, ArkType, Effect Schema, etc.
+ */
+export type HTTPHeadersSchema = StandardSchemaV1<Record<string, string | string[] | undefined>>;
+/**
+ * Documentation config for OpenAPI generation
+ */
+export type HTTPRouteDocsConfig = {
+    description?: string;
+    response?: string;
+    errors?: Array<typeof PikkuError>;
+    tags?: string[];
+};
+/**
+ * Common HTTP route configuration shared between wireHTTP and wireHTTPRoutes
  */
-export type CoreHTTPFunction = {
+export type HTTPRouteBaseConfig = {
     contentType?: 'xml' | 'json';
+    timeout?: number;
+    tags?: string[];
+    headers?: HTTPHeadersSchema;
+    docs?: HTTPRouteDocsConfig;
+};
+/**
+ * Represents an API HTTP wiring without a function, including metadata such as content type, route, and timeout settings.
+ */
+export type CoreHTTPFunction = HTTPRouteBaseConfig & {
     route: string;
     eventChannel?: false;
     returnsJSON?: false;
-    timeout?: number;
-    tags?: string[];
-    docs?: Partial<{
-        description: string;
-        response: string;
-        errors: Array<typeof PikkuError>;
-        tags: string[];
-    }>;
 };
 /**
  * Represents a http wire within Pikku, including a request and response.
@@ -67,13 +83,12 @@ export type PikkuQuery<T = Record<string, string | undefined>> = Record<string,
  * @template PikkuFunctionSessionless - The sessionless API function type, defaults to `CorePikkuFunctionSessionless`.
  * @template PikkuPermission - The permission function type, defaults to `CorePikkuPermission`.
  */
-export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction extends CorePikkuFunction<In, Out, any, any> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out, any, any> = CorePikkuFunctionSessionless<In, Out>, PikkuPermission extends CorePikkuPermission<In, any, any> = CorePikkuPermission<In, any, any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any>> = (CoreHTTPFunction & {
+export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction extends CorePikkuFunction<In, Out, any, any, any> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out, any, any, any> = CorePikkuFunctionSessionless<In, Out>, PikkuPermission extends CorePikkuPermission<In, any, any> = CorePikkuPermission<In, any, any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any>> = (CoreHTTPFunction & {
     route: R;
     method: HTTPMethod;
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: true;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
     sse?: undefined;
 }) | (CoreHTTPFunction & {
@@ -82,7 +97,6 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     func: CorePikkuFunctionConfig<PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>;
     permissions?: undefined;
     auth?: false;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
     sse?: undefined;
 }) | (CoreHTTPFunction & {
@@ -91,27 +105,24 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: true;
-    sse?: boolean;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    sse?: boolean;
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'get';
     func: CorePikkuFunctionConfig<PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>;
     permissions?: undefined;
     auth?: false;
-    sse?: boolean;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    sse?: boolean;
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'post';
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: true;
-    query?: Array<keyof In>;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    query?: Array<keyof In>;
     sse?: undefined;
 }) | (CoreHTTPFunction & {
     route: R;
@@ -119,9 +130,8 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     func: CorePikkuFunctionConfig<PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>;
     permissions?: undefined;
     auth?: false;
-    query?: Array<keyof In>;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    query?: Array<keyof In>;
     sse?: undefined;
 });
 /**
@@ -141,7 +151,9 @@ export type HTTPWiringMeta = CommonWireMeta & {
     params?: string[];
     query?: string[];
     inputTypes?: HTTPFunctionMetaInputTypes;
+    headersSchemaName?: string;
     sse?: true;
+    groupBasePath?: string;
 };
 export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
 export type HTTPFunctionsMeta = Array<{
@@ -175,4 +187,45 @@ export interface PikkuHTTPResponse<Out = unknown> {
     close?: () => void;
     setMode?: (mode: 'stream') => void;
 }
+/**
+ * Single route configuration - supports all wireHTTP options
+ */
+export type HTTPRouteConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any> = CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>> = HTTPRouteBaseConfig & {
+    method: HTTPMethod;
+    route: string;
+    func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
+    auth?: boolean;
+    permissions?: CorePermissionGroup<PikkuPermission>;
+    middleware?: PikkuMiddleware[];
+    sse?: boolean;
+};
+/**
+ * Group-level configuration applied to all routes
+ */
+export type HTTPRoutesGroupConfig<PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>> = {
+    basePath?: string;
+    tags?: string[];
+    auth?: boolean;
+    middleware?: PikkuMiddleware[];
+    permissions?: CorePermissionGroup<PikkuPermission>;
+};
+/**
+ * Nested route map - allows hierarchical organization
+ * Can contain individual routes, nested maps, or contracts with config
+ */
+export type HTTPRouteMap = {
+    [key: string]: HTTPRouteConfig | HTTPRouteMap | HTTPRouteContract;
+};
+/**
+ * A route contract with optional group config (returned by defineRoutes)
+ */
+export type HTTPRouteContract<T extends HTTPRouteMap = HTTPRouteMap> = HTTPRoutesGroupConfig & {
+    routes: T;
+};
+/**
+ * Full configuration for wireHTTPRoutes
+ */
+export type WireHTTPRoutesConfig = HTTPRoutesGroupConfig & {
+    routes: HTTPRouteMap | HTTPRouteConfig[];
+};
 export {};

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

@@ -1,5 +1,6 @@
-export * from './pikku-fetch-http-request.js';
-export * from './pikku-fetch-http-response.js';
-export * from './log-http-routes.js';
+export { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
+export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
+export { logRoutes } from './log-http-routes.js';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';
-export type * from './http.types.js';
+export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js';
+export type { AssertHTTPWiringParams, CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig, HTTPWiringsMeta, PikkuHTTPRequest, PikkuHTTPResponse, PikkuQuery, RunHTTPWiringOptions, } from './http.types.js';

package/dist/wirings/http/index.js

@@ -1,4 +1,5 @@
-export * from './pikku-fetch-http-request.js';
-export * from './pikku-fetch-http-response.js';
-export * from './log-http-routes.js';
+export { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
+export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
+export { logRoutes } from './log-http-routes.js';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';
+export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js';

package/dist/wirings/http/log-http-routes.js

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
  * @param logger - A logger for logging information.
  */
 export const logRoutes = (logger) => {
-    const routesByType = pikkuState('http', 'routes');
+    const routesByType = pikkuState(null, 'http', 'routes');
     if (routesByType.size === 0) {
         logger.info('No routes added');
         return;

package/dist/wirings/http/routers/path-to-regex.js

@@ -10,8 +10,8 @@ export class PathToRegexRouter {
         this.isInitialized = false;
     }
     initialize() {
-        const routes = pikkuState('http', 'routes');
-        const channelRoutes = pikkuState('channel', 'channels');
+        const routes = pikkuState(null, 'http', 'routes');
+        const channelRoutes = pikkuState(null, 'channel', 'channels');
         // Helper function to compile routes for a given method
         const compileRoutesForMethod = (method, routeEntries) => {
             const methodCompiledRoutes = this.compiledRoutes.get(method) || new Map();

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

@@ -1,3 +1,4 @@
-export * from './mcp.types.js';
-export * from './mcp-runner.js';
-export * from './mcp-endpoint-registry.js';
+export { MCPEndpointRegistry } from './mcp-endpoint-registry.js';
+export { MCPError, wireMCPResource, wireMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, } from './mcp-runner.js';
+export { getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './mcp-runner.js';
+export type { AssertMCPResourceURIParams, CoreMCPPrompt, CoreMCPResource, CoreMCPTool, MCPPromptResponse, MCPResourceMeta, MCPResourceResponse, MCPToolMeta, MCPToolResponse, MCPPromptMeta, PikkuMCP, } from './mcp.types.js';

package/dist/wirings/mcp/index.js

@@ -1,3 +1,3 @@
-export * from './mcp.types.js';
-export * from './mcp-runner.js';
-export * from './mcp-endpoint-registry.js';
+export { MCPEndpointRegistry } from './mcp-endpoint-registry.js';
+export { MCPError, wireMCPResource, wireMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, } from './mcp-runner.js';
+export { getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './mcp-runner.js';

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

@@ -1,5 +1,5 @@
 import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateWireServices } from '../../types/core.types.js';
-import type { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
+import type { CoreMCPResource, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export declare class MCPError extends Error {
     readonly error: JsonRpcErrorResponse;
@@ -16,12 +16,10 @@ export type JsonRpcError = {
     data?: any;
 };
 export declare const wireMCPResource: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpResource: CoreMCPResource<PikkuFunctionConfig>) => void;
-export declare const wireMCPTool: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpTool: CoreMCPTool<PikkuFunctionConfig>) => void;
 export declare const wireMCPPrompt: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpPrompt: CoreMCPPrompt<PikkuFunctionConfig>) => void;
 export declare function runMCPResource(request: JsonRpcRequest, params: RunMCPEndpointParams, uri: string): Promise<JsonRpcResponse>;
 export declare function runMCPTool(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
 export declare function runMCPPrompt(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
-export declare const getMCPTools: () => Map<string, CoreMCPTool>;
 export declare const getMCPResources: () => Map<string, CoreMCPResource>;
 export declare const getMCPResourcesMeta: () => import("./mcp.types.js").MCPResourceMeta;
 export declare const getMCPToolsMeta: () => import("./mcp.types.js").MCPToolMeta;