@pikku/core 0.8.2 → 0.9.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.9.0
+
+## 0.9.1
+
+### Patch Changes
+
+- fdb1593: core: bumping everything with a patch to sync up the major release inconsistencies in dependencies
+
+### Breaking Changes
+
+- Normalized all transports to use "wirings" instead of events/routes/transports for consistency across the framework
+
 ## 0.8.0
 
 ## 0.8.2
@@ -86,7 +98,7 @@ We now use the function first approach internally, which means first all the fun
 The main breaking changes for the end user are:
 
 - We now declare functions using `pikkuFunc<In, Out>(async () => {})
-- We renamed addRoute to addHTTPRoutes
+- We renamed addRoute to wireHTTPs
 
 We also removed all the different types of functions. Everything is now either an APIFunction of APIFunctionSessionless. The channel (eventHub or any other transport specific service) is now injected in the service itself.
 

package/dist/function/functions.types.d.ts

@@ -1,4 +1,4 @@
-import { PikkuChannel } from '../events/channel/channel.types.js';
+import { PikkuChannel } from '../wirings/channel/channel.types.js';
 import type { CoreServices, CoreSingletonServices, CoreUserSession, PikkuFunctionMiddleware } from '../types/core.types.js';
 /**
  * Represents a core API function that performs an operation using core services and a user session.
@@ -8,7 +8,7 @@ import type { CoreServices, CoreSingletonServices, CoreUserSession, PikkuFunctio
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CoreAPIFunction<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
+export type CorePikkuFunction<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
     channel?: PikkuChannel<unknown, Out> | undefined;
 } : {
     channel: PikkuChannel<ChannelData, Out>;
@@ -21,23 +21,23 @@ export type CoreAPIFunction<In, Out, ChannelData extends unknown | null = null,
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CoreAPIFunctionSessionless<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
+export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
     channel?: PikkuChannel<unknown, Out> | undefined;
 } : {
     channel: PikkuChannel<ChannelData, Out>;
 }), Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => ChannelData extends null ? Promise<Out> : Promise<Out> | Promise<void>;
 /**
- * Represents a function that checks permissions for a given API operation.
+ * Represents a function that checks permissions for a given operation.
  *
  * @template In - The input type.
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CoreAPIPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
-export type CorePermissionGroup<APIPermission = CoreAPIPermission<any>> = Record<string, APIPermission | APIPermission[]> | undefined;
-export type CorePikkuFunctionConfig<APIFunction extends CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>, APIPermission extends CoreAPIPermission<any> = CoreAPIPermission<any>> = {
-    func: APIFunction;
+export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
+export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
+export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any> | CorePikkuFunctionSessionless<any, any>, PikkuPermission extends CorePikkuPermission<any> = CorePikkuPermission<any>> = {
+    func: PikkuFunction;
     auth?: boolean;
-    permissions?: CorePermissionGroup<APIPermission>;
+    permissions?: CorePermissionGroup<PikkuPermission>;
     middleware?: PikkuFunctionMiddleware[];
 };

package/dist/handle-error.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from './services/logger.js';
-import { PikkuHTTP } from './events/http/http.types.js';
+import { PikkuHTTP } from './wirings/http/http.types.js';
 /**
  * Handle errors that occur during route processing
  *

package/dist/index.d.ts

@@ -10,19 +10,20 @@ export * from './services/schema-service.js';
 export * from './services/jwt-service.js';
 export * from './services/secret-service.js';
 export * from './services/user-session-service.js';
-export * from './events/http/index.js';
-export * from './events/channel/index.js';
-export * from './events/scheduler/index.js';
-export * from './events/rpc/index.js';
-export * from './events/queue/index.js';
-export * from './events/mcp/index.js';
+export * from './wirings/http/index.js';
+export * from './wirings/channel/index.js';
+export * from './wirings/scheduler/index.js';
+export * from './wirings/rpc/index.js';
+export * from './wirings/queue/index.js';
+export * from './wirings/mcp/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addHTTPRoute, addMiddleware } from './events/http/http-runner.js';
-export { addChannel } from './events/channel/channel-runner.js';
-export { addScheduledTask } from './events/scheduler/scheduler-runner.js';
-export { addMCPResource, addMCPTool, addMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, getMCPTools, getMCPResources, getMCPPrompts, getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './events/mcp/mcp-runner.js';
+export { wireHTTP, addMiddleware } from './wirings/http/http-runner.js';
+export { wireChannel } from './wirings/channel/channel-runner.js';
+export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';
+export { wireQueueWorker } from './wirings/queue/queue-runner.js';
+export { wireMCPResource, wireMCPTool, wireMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, getMCPTools, getMCPResources, getMCPPrompts, getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './wirings/mcp/mcp-runner.js';

package/dist/index.js

@@ -10,19 +10,20 @@ export * from './services/schema-service.js';
 export * from './services/jwt-service.js';
 export * from './services/secret-service.js';
 export * from './services/user-session-service.js';
-export * from './events/http/index.js';
-export * from './events/channel/index.js';
-export * from './events/scheduler/index.js';
-export * from './events/rpc/index.js';
-export * from './events/queue/index.js';
-export * from './events/mcp/index.js';
+export * from './wirings/http/index.js';
+export * from './wirings/channel/index.js';
+export * from './wirings/scheduler/index.js';
+export * from './wirings/rpc/index.js';
+export * from './wirings/queue/index.js';
+export * from './wirings/mcp/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addHTTPRoute, addMiddleware } from './events/http/http-runner.js';
-export { addChannel } from './events/channel/channel-runner.js';
-export { addScheduledTask } from './events/scheduler/scheduler-runner.js';
-export { addMCPResource, addMCPTool, addMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, getMCPTools, getMCPResources, getMCPPrompts, getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './events/mcp/mcp-runner.js';
+export { wireHTTP, addMiddleware } from './wirings/http/http-runner.js';
+export { wireChannel } from './wirings/channel/channel-runner.js';
+export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';
+export { wireQueueWorker } from './wirings/queue/queue-runner.js';
+export { wireMCPResource, wireMCPTool, wireMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, getMCPTools, getMCPResources, getMCPPrompts, getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './wirings/mcp/mcp-runner.js';

package/dist/pikku-state.d.ts

@@ -1,12 +1,12 @@
-import { ChannelsMeta, CoreAPIChannel } from './events/channel/channel.types.js';
-import { CoreHTTPFunctionRoute, HTTPMethod, HTTPRoutesMeta } from './events/http/http.types.js';
+import { ChannelsMeta, CoreChannel } from './wirings/channel/channel.types.js';
+import { CoreHTTPFunctionWiring, HTTPMethod, HTTPWiringsMeta } from './wirings/http/http.types.js';
 import { FunctionsMeta, PikkuMiddleware } from './types/core.types.js';
-import { CoreScheduledTask, ScheduledTasksMeta } from './events/scheduler/scheduler.types.js';
+import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
 import { CorePikkuFunctionConfig } from './function/functions.types.js';
-import { RPCMeta } from './events/rpc/rpc-types.js';
-import { queueWorkersMeta, CoreQueueWorker } from './events/queue/queue.types.js';
-import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './events/mcp/mcp.types.js';
+import { RPCMeta } from './wirings/rpc/rpc-types.js';
+import { queueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
+import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
 interface PikkuState {
     function: {
         meta: FunctionsMeta;
@@ -24,11 +24,11 @@ interface PikkuState {
             route: string;
             middleware: PikkuMiddleware[];
         }>;
-        routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionRoute<any, any, any>>>;
-        meta: HTTPRoutesMeta;
+        routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>;
+        meta: HTTPWiringsMeta;
     };
     channel: {
-        channels: Map<string, CoreAPIChannel<any, any>>;
+        channels: Map<string, CoreChannel<any, any>>;
         meta: ChannelsMeta;
     };
     scheduler: {

package/dist/services/user-session-service.d.ts

@@ -1,4 +1,4 @@
-import { ChannelStore } from '../events/channel/channel-store.js';
+import { ChannelStore } from '../wirings/channel/channel-store.js';
 import { CoreUserSession } from '../types/core.types.js';
 export interface UserSessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;

package/dist/types/core.types.d.ts

@@ -1,12 +1,12 @@
 import type { Logger, LogLevel } from '../services/logger.js';
 import { VariablesService } from '../services/variables-service.js';
 import { SchemaService } from '../services/schema-service.js';
-import { PikkuHTTP } from '../events/http/http.types.js';
+import { PikkuHTTP } from '../wirings/http/http.types.js';
 import { UserSessionService } from '../services/user-session-service.js';
-import { PikkuChannel } from '../events/channel/channel.types.js';
-import { PikkuRPC } from '../events/rpc/rpc-types.js';
-import { PikkuMCP } from '../events/mcp/mcp.types.js';
-export declare enum PikkuEventTypes {
+import { PikkuChannel } from '../wirings/channel/channel.types.js';
+import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
+import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
+export declare enum PikkuWiringTypes {
     http = "http",
     scheduler = "scheduler",
     channel = "channel",

package/dist/types/core.types.js

@@ -1,9 +1,9 @@
-export var PikkuEventTypes;
-(function (PikkuEventTypes) {
-    PikkuEventTypes["http"] = "http";
-    PikkuEventTypes["scheduler"] = "scheduler";
-    PikkuEventTypes["channel"] = "channel";
-    PikkuEventTypes["rpc"] = "rpc";
-    PikkuEventTypes["queue"] = "queue";
-    PikkuEventTypes["mcp"] = "mcp";
-})(PikkuEventTypes || (PikkuEventTypes = {}));
+export var PikkuWiringTypes;
+(function (PikkuWiringTypes) {
+    PikkuWiringTypes["http"] = "http";
+    PikkuWiringTypes["scheduler"] = "scheduler";
+    PikkuWiringTypes["channel"] = "channel";
+    PikkuWiringTypes["rpc"] = "rpc";
+    PikkuWiringTypes["queue"] = "queue";
+    PikkuWiringTypes["mcp"] = "mcp";
+})(PikkuWiringTypes || (PikkuWiringTypes = {}));

package/dist/wirings/channel/channel-handler.d.ts

@@ -0,0 +1,3 @@
+import { CoreServices, CoreUserSession } from '../../types/core.types.js';
+import { CoreChannel, PikkuChannelHandler } from './channel.types.js';
+export declare const processMessageHandlers: (services: CoreServices, session: CoreUserSession | undefined, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler) => (rawData: any) => Promise<unknown>;

package/dist/{events → wirings}/channel/channel-handler.js

@@ -14,7 +14,7 @@ const getRouteMeta = (channelName, routingProperty, routerValue) => {
     if (!routerValue) {
         throw new Error(`Channel ${channelName} requires a router value for ${routingProperty}`);
     }
-    const route = channelMeta.messageRoutes[routingProperty]?.[routerValue];
+    const route = channelMeta.messageWirings[routingProperty]?.[routerValue];
     if (!route) {
         throw new Error(`Channel ${channelName} has no route for ${routingProperty}:${routerValue}`);
     }
@@ -62,10 +62,10 @@ export const processMessageHandlers = (services, session, channelConfig, channel
         let result;
         let processed = false;
         // Route-specific handling
-        if (typeof rawData === 'string' && channelConfig.onMessageRoute) {
+        if (typeof rawData === 'string' && channelConfig.onMessageWiring) {
             try {
                 const messageData = JSON.parse(rawData);
-                const entries = Object.entries(channelConfig.onMessageRoute);
+                const entries = Object.entries(channelConfig.onMessageWiring);
                 for (const [routingProperty, routes] of entries) {
                     const routerValue = messageData[routingProperty];
                     if (routerValue && routes[routerValue]) {

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

@@ -0,0 +1,14 @@
+import { UserSessionService } from '../../services/user-session-service.js';
+import { ChannelMeta, CoreChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
+/**
+ * Adds a channel and registers all functions referenced in it using the
+ * function names already stored in the channel metadata
+ */
+export declare const wireChannel: <In, Channel extends string, ChannelFunction, ChannelFunctionSessionless, PikkuPermission>(channel: CoreChannel<In, Channel, ChannelFunction, PikkuPermission>) => void;
+export declare const openChannel: ({ route, singletonServices, coerceDataFromSchema, request, }: Pick<CoreChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
+    userSession: UserSessionService<any>;
+} & RunChannelOptions) => Promise<{
+    openingData: unknown;
+    channelConfig: CoreChannel<unknown, any>;
+    meta: ChannelMeta;
+}>;

package/dist/{events → wirings}/channel/channel-runner.js

@@ -7,7 +7,7 @@ import { match } from 'path-to-regexp';
  * Adds a channel and registers all functions referenced in it using the
  * function names already stored in the channel metadata
  */
-export const addChannel = (channel) => {
+export const wireChannel = (channel) => {
     // Get the channel metadata
     const channelsMeta = pikkuState('channel', 'meta');
     const channelMeta = channelsMeta[channel.name];
@@ -36,20 +36,20 @@ export const addChannel = (channel) => {
             func: messageFunc,
         });
     }
-    // Register functions in onMessageRoute
-    if (channel.onMessageRoute && channelMeta.messageRoutes) {
-        // Iterate through each channel in onMessageRoute
-        Object.entries(channel.onMessageRoute).forEach(([channelKey, routes]) => {
-            const channelRoutes = channelMeta.messageRoutes[channelKey];
-            if (!channelRoutes)
+    // Register functions in onMessageWiring
+    if (channel.onMessageWiring && channelMeta.messageWirings) {
+        // Iterate through each channel in onMessageWiring
+        Object.entries(channel.onMessageWiring).forEach(([channelKey, wirings]) => {
+            const channelWirings = channelMeta.messageWirings[channelKey];
+            if (!channelWirings)
                 return;
-            // Iterate through each route in the channel
-            Object.entries(routes).forEach(([routeKey, handler]) => {
-                const routeMeta = channelRoutes[routeKey];
-                if (!routeMeta)
+            // Iterate through each wiring in the channel
+            Object.entries(wirings).forEach(([wiringKey, handler]) => {
+                const wiringMeta = channelWirings[wiringKey];
+                if (!wiringMeta)
                     return;
                 // Extract the function from the handler
-                const routeFunc = typeof handler === 'function'
+                const wiringFunc = typeof handler === 'function'
                     ? { func: handler }
                     : {
                         func: handler.func,
@@ -57,7 +57,7 @@ export const addChannel = (channel) => {
                         permissions: handler.permissions,
                     };
                 // Register the function using the pikku name from metadata
-                addFunction(routeMeta.pikkuFuncName, routeFunc);
+                addFunction(wiringMeta.pikkuFuncName, wiringFunc);
             });
         });
     }

package/dist/{events → wirings}/channel/channel.types.d.ts

@@ -1,7 +1,7 @@
 import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
 import { APIDocs, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../../types/core.types.js';
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../../function/functions.types.js';
+import { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
@@ -30,28 +30,28 @@ export interface ChannelMeta {
     connect: ChannelMessageMeta | null;
     disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
-    messageRoutes: Record<string, Record<string, ChannelMessageMeta>>;
+    messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
     docs?: APIDocs;
     tags?: string[];
 }
 export type ChannelsMeta = Record<string, ChannelMeta>;
-export type CoreAPIChannel<ChannelData, Channel extends string, ChannelConnect = CoreAPIFunction<void, unknown, ChannelData> | CoreAPIFunctionSessionless<void, unknown, ChannelData>, ChannelDisconnect = CoreAPIFunction<void, void, ChannelData> | CoreAPIFunctionSessionless<void, void, ChannelData>, ChannelFunctionMessage = CoreAPIFunction<unknown, unknown, ChannelData> | CoreAPIFunctionSessionless<unknown, unknown, ChannelData>, APIPermission = CoreAPIPermission<ChannelData>> = {
+export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = CorePikkuFunction<void, unknown, ChannelData> | CorePikkuFunctionSessionless<void, unknown, ChannelData>, ChannelDisconnect = CorePikkuFunction<void, void, ChannelData> | CorePikkuFunctionSessionless<void, void, ChannelData>, ChannelFunctionMessage = CorePikkuFunction<unknown, unknown, ChannelData> | CorePikkuFunctionSessionless<unknown, unknown, ChannelData>, PikkuPermission = CorePikkuPermission<ChannelData>> = {
     name: string;
     route: Channel;
     onConnect?: ChannelConnect;
     onDisconnect?: ChannelDisconnect;
     onMessage?: {
         func: ChannelFunctionMessage;
-        permissions?: Record<string, APIPermission[] | APIPermission>;
+        permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
         auth?: boolean;
     } | ChannelFunctionMessage;
-    onMessageRoute?: Record<string, Record<string, ChannelFunctionMessage | {
+    onMessageWiring?: Record<string, Record<string, ChannelFunctionMessage | {
         func: ChannelFunctionMessage;
-        permissions?: Record<string, APIPermission[] | APIPermission>;
+        permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
         auth?: boolean;
     }>>;
     middleware?: PikkuMiddleware[];
-    permissions?: Record<string, APIPermission[] | APIPermission>;
+    permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
     auth?: boolean;
     docs?: Partial<{
         description: string;

package/dist/{events → wirings}/channel/eventhub-service.d.ts

@@ -1,23 +1,23 @@
 /**
  * Interface defining the methods of a EventHub Service.
  */
-export interface EventHubService<Out = unknown> {
+export interface EventHubService<Topics extends Record<string, any>> {
     /**
      * Subscribes a connection to a specific topic.
      * @param topic - The topic to subscribe to.
      * @param channelId - The unique ID of the connection to subscribe.
      */
-    subscribe(topic: string, channelId: string): Promise<void> | void;
+    subscribe<T extends keyof Topics>(topic: T, channelId: string): Promise<void> | void;
     /**
      * Unsubscribes a connection from a specific topic.
      * @param topic - The topic to unsubscribe from.
      * @param channelId - The unique ID of the connection to unsubscribe.
      */
-    unsubscribe(topic: string, channelId: string): Promise<void> | void;
+    unsubscribe<T extends keyof Topics>(topic: T, channelId: string): Promise<void> | void;
     /**
      * Sends data to all connections subscribed to a topic.
      * @param topic - The topic to send data to.
      * @param data - The data to send to the subscribers.
      */
-    publish(topic: string, channelId: string | null, data: Out, isBinary?: boolean): Promise<void> | void;
+    publish<T extends keyof Topics>(topic: T, channelId: string | null, data: Topics[T], isBinary?: boolean): Promise<void> | void;
 }

package/dist/wirings/channel/eventhub-store.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class EventHubStore<EventTopics extends Record<string, any> = {}> {
+    abstract getChannelIdsForTopic(topic: string): Promise<string[]>;
+    abstract subscribe<T extends keyof EventTopics>(topic: T, channelId: string): Promise<boolean>;
+    abstract unsubscribe<T extends keyof EventTopics>(topic: T, channelId: string): Promise<boolean>;
+}

package/dist/wirings/channel/local/local-channel-runner.d.ts

@@ -0,0 +1,3 @@
+import { CoreChannel, RunChannelOptions, RunChannelParams } from '../channel.types.js';
+import { PikkuLocalChannelHandler } from './local-channel-handler.js';
+export declare const runLocalChannel: ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession, respondWith404, coerceDataFromSchema, logWarningsForStatusCodes, bubbleErrors, }: Partial<Pick<CoreChannel<unknown, any>, "route">> & RunChannelOptions & RunChannelParams<unknown>) => Promise<PikkuLocalChannelHandler | void>;

package/dist/{events → wirings}/channel/local/local-eventhub-service.d.ts

@@ -4,7 +4,7 @@ import { EventHubService } from '../eventhub-service.js';
  * Implementation of the SubscriptionService interface.
  * Manages subscriptions and publishes messages to subscribers.
  */
-export declare class LocalEventHubService<Data = unknown> implements EventHubService<Data> {
+export declare class LocalEventHubService<Data extends Record<string, any> = {}> implements EventHubService<Data> {
     private channels;
     /**
      * A map storing topics and their associated connection IDs.
@@ -16,20 +16,20 @@ export declare class LocalEventHubService<Data = unknown> implements EventHubSer
      * @param topic - The topic to subscribe to.
      * @param channelId - The unique ID of the connection to subscribe.
      */
-    subscribe(topic: string, channelId: string): void;
+    subscribe<T extends keyof Data>(topic: T, channelId: string): void | Promise<void>;
     /**
      * Unsubscribes a connection from a specific topic.
      * Removes the topic if it has no more subscribers.
      * @param topic - The topic to unsubscribe from.
      * @param channelId - The unique ID of the connection to unsubscribe.
      */
-    unsubscribe(topic: string, channelId: string): void;
+    unsubscribe<T extends keyof Data>(topic: T, channelId: string): void | Promise<void>;
     /**
      * Sends data to all connections subscribed to a topic.
      * @param topic - The topic to send data to.
      * @param data - The data to send to the subscribers.
      */
-    publish(topic: string, channelId: string, data: Data, isBinary?: boolean): void;
+    publish<T extends keyof Data>(topic: T, channelId: string | null, data: Data[T], isBinary?: boolean): void | Promise<void>;
     /**
      * Registers a channel on open
      */

package/dist/{events → wirings}/channel/local/local-eventhub-service.js

@@ -31,7 +31,7 @@ export class LocalEventHubService {
         if (topicSubscriptions) {
             topicSubscriptions.delete(channelId);
             if (topicSubscriptions.size === 0) {
-                this.subscriptions.delete(topic); // Cleanup empty subscriptions
+                this.subscriptions.delete(topic);
             }
         }
     }

package/dist/{events → wirings}/channel/serverless/serverless-channel-runner.d.ts

@@ -1,10 +1,10 @@
-import type { CoreAPIChannel, RunChannelOptions, RunChannelParams, PikkuChannelHandlerFactory } from '../channel.types.js';
+import type { CoreChannel, RunChannelOptions, RunChannelParams, PikkuChannelHandlerFactory } from '../channel.types.js';
 import { ChannelStore } from '../channel-store.js';
 export interface RunServerlessChannelParams<ChannelData> extends RunChannelParams<ChannelData> {
     channelStore: ChannelStore;
     channelHandlerFactory: PikkuChannelHandlerFactory;
     channelObject?: unknown;
 }
-export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreAPIChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
+export declare const runChannelConnect: ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceDataFromSchema, logWarningsForStatusCodes, respondWith404, bubbleErrors, }: Pick<CoreChannel<unknown, any>, "route"> & RunChannelOptions & RunServerlessChannelParams<unknown>) => Promise<void>;
 export declare const runChannelDisconnect: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>) => Promise<void>;
 export declare const runChannelMessage: ({ singletonServices, ...params }: RunServerlessChannelParams<unknown>, data: unknown) => Promise<unknown>;

package/dist/{events → wirings}/http/http-runner.d.ts

@@ -1,4 +1,4 @@
-import { CoreHTTPFunctionRoute, RunRouteOptions, RunRouteParams, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
+import { CoreHTTPFunctionWiring, RunHTTPWiringOptions, RunHTTPWiringParams, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
 import { PikkuMiddleware } from '../../types/core.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 /**
@@ -22,13 +22,13 @@ export declare const addMiddleware: <APIMiddleware extends PikkuMiddleware>(rout
  * @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 APIPermissionGroup Type representing required permissions.
+ * @template PikkuFunction Type for the route handler function.
+ * @template PikkuFunctionSessionless Type for a sessionless handler.
+ * @template PikkuPermissionGroup 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.
+ * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, APIMiddleware>} httpWiring - The HTTP wiring configuration object.
  */
-export declare const addHTTPRoute: <In, Out, Route extends string, APIFunction, APIFunctionSessionless, APIPermissionGroup, APIMiddleware>(httpRoute: CoreHTTPFunctionRoute<In, Out, Route, APIFunction, APIFunctionSessionless, APIPermissionGroup, APIMiddleware>) => void;
+export declare const wireHTTP: <In, Out, Route extends string, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, APIMiddleware>(httpWiring: CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, APIMiddleware>) => void;
 /**
  * Combines the request and response objects into a single HTTP interaction object.
  *
@@ -52,10 +52,10 @@ export declare const createHTTPInteraction: (request: PikkuHTTPRequest | undefin
  * @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.
+ * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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: RunRouteOptions & RunRouteParams) => Promise<Response>;
+export declare const fetch: <In, Out>(request: Request, params: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Response>;
 /**
  * Executes an HTTP route using a Pikku-specific request wrapper.
  *
@@ -65,10 +65,10 @@ export declare const fetch: <In, Out>(request: Request, params: RunRouteOptions
  * @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.
+ * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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: RunRouteOptions & RunRouteParams) => Promise<PikkuFetchHTTPResponse>;
+export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest, params: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<PikkuFetchHTTPResponse>;
 /**
  * Core function to process an HTTP request through route matching, validation,
  * middleware execution, error handling, and session service cleanup.
@@ -84,7 +84,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 {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
+ * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, ignoreMiddleware, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, ignoreMiddleware, }: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Out | void>;

package/dist/{events → wirings}/http/http-runner.js

@@ -52,28 +52,28 @@ export const addMiddleware = (routeOrMiddleware, middleware) => {
  * @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 APIPermissionGroup Type representing required permissions.
+ * @template PikkuFunction Type for the route handler function.
+ * @template PikkuFunctionSessionless Type for a sessionless handler.
+ * @template PikkuPermissionGroup 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.
+ * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, APIMiddleware>} httpWiring - The HTTP wiring configuration object.
  */
-export const addHTTPRoute = (httpRoute) => {
+export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState('http', 'meta');
-    const routeMeta = httpMeta.find((meta) => meta.route === httpRoute.route && meta.method === httpRoute.method);
+    const routeMeta = httpMeta.find((meta) => meta.route === httpWiring.route && meta.method === httpWiring.method);
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
     addFunction(routeMeta.pikkuFuncName, {
-        func: httpRoute.func,
+        func: httpWiring.func,
     });
     const routes = pikkuState('http', 'routes');
-    if (!routes.has(httpRoute.method)) {
-        routes.set(httpRoute.method, new Map());
+    if (!routes.has(httpWiring.method)) {
+        routes.set(httpWiring.method, new Map());
     }
     pikkuState('http', 'routes')
-        .get(httpRoute.method)
-        ?.set(httpRoute.route, httpRoute);
+        .get(httpWiring.method)
+        ?.set(httpWiring.route, httpWiring);
 };
 /**
  * Finds a matching route based on the HTTP method and URL path.
@@ -185,7 +185,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             });
             throw new MissingSessionError();
         }
-        const data = http.request.data();
+        const data = await http.request.data();
         const getAllServices = async () => {
             let channel;
             if (matchedRoute.route.sse) {
@@ -258,7 +258,7 @@ const executeRouteWithMiddleware = 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 {RunRouteOptions & RunRouteParams} params - Additional options including services and session management.
+ * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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) => {
@@ -275,7 +275,7 @@ 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 {RunRouteOptions & RunRouteParams} params - Execution options including services and session configuration.
+ * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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) => {
@@ -298,7 +298,7 @@ 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 {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
+ * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, ignoreMiddleware = false, }) => {