@pikku/cli 0.8.3 → 0.9.1

package/dist/src/serialize-pikku-types.js

@@ -6,13 +6,13 @@ export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName,
 * This is used to provide the application types in the typescript project
 */
   
-import { CoreAPIPermission, PikkuMiddleware } from '@pikku/core'
-import { CoreAPIFunction, CoreAPIFunctionSessionless } from '@pikku/core/function'
-import { CoreHTTPFunctionRoute, AssertRouteParams, addHTTPRoute as addCoreHTTPRoute } from '@pikku/core/http'
-import { CoreScheduledTask, addScheduledTask as addCoreScheduledTask } from '@pikku/core/scheduler'
-import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pikku/core/channel'
-import { CoreQueueWorker, addQueueWorker as addCoreQueueWorker } from '@pikku/core/queue'
-import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, addMCPResource as addCoreMCPResource, addMCPTool as addCoreMCPTool, addMCPPrompt as addCoreMCPPrompt, MCPResourceResponse, MCPToolResponse, MCPPromptResponse, PikkuMCP } from '@pikku/core'
+import { CorePikkuPermission, PikkuMiddleware } from '@pikku/core'
+import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
+import { CoreHTTPFunctionWiring, AssertHTTPWiringParams, wireHTTP as wireHTTPCore } from '@pikku/core/http'
+import { CoreScheduledTask, wireScheduler as wireSchedulerCore } from '@pikku/core/scheduler'
+import { CoreChannel, PikkuChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
+import { CoreQueueWorker, wireQueueWorker as wireQueueWorkerCore } from '@pikku/core/queue'
+import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, wireMCPResource as wireMCPResourceCore, wireMCPTool as wireMCPToolCore, wireMCPPrompt as wireMCPPromptCore, MCPResourceResponse, MCPToolResponse, MCPPromptResponse, PikkuMCP } from '@pikku/core'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
@@ -26,11 +26,11 @@ ${rpcMapTypeImport}
  * @template In - The input type that the permission check will receive
  * @template RequiredServices - The services required for this permission check
  */
-export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
+export type PikkuPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CorePikkuPermission<In, RequiredServices, ${userSessionTypeName}>
 
 /**
  * Type-safe middleware definition that can access your application's services and session.
- * Use this to define reusable middleware that can be applied to multiple routes.
+ * Use this to define reusable middleware that can be applied to multiple HTTP wirings.
  * 
  * @template RequiredServices - The services required for this middleware
  */
@@ -46,7 +46,7 @@ export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName}
  * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
-type APIFunctionSessionless<
+type PikkuFunctionSessionless<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
@@ -60,7 +60,7 @@ type APIFunctionSessionless<
     ? { mcp?: PikkuMCP }  // Optional MCP
     : { mcp: PikkuMCP }  // Required MCP
   )
-> = CoreAPIFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
 
 /**
  * A session-aware API function that requires user authentication.
@@ -72,7 +72,7 @@ type APIFunctionSessionless<
  * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
-type APIFunction<
+type PikkuFunction<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
@@ -86,17 +86,17 @@ type APIFunction<
     ? { mcp?: PikkuMCP }  // Optional MCP
     : { mcp: PikkuMCP }  // Required MCP
   )
-> = CoreAPIFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
 
 /**
- * Type definition for HTTP API routes with type-safe path parameters.
+ * Type definition for HTTP API wirings with type-safe path parameters.
  * Supports both authenticated and unauthenticated functions.
  * 
- * @template In - Input type for the route
- * @template Out - Output type for the route
- * @template Route - String literal type for the route path (e.g., "/users/:id")
+ * @template In - Input type for the HTTP wiring
+ * @template Out - Output type for the HTTP wiring
+ * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
  */
-type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Route, APIFunction<In, Out>, APIFunctionSessionless<In, Out>, APIPermission<In>, APIMiddleware>
+type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out>, PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, APIMiddleware>
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -105,13 +105,13 @@ type APIRoute<In, Out, Route extends string> = CoreHTTPFunctionRoute<In, Out, Ro
  * @template ChannelData - Type of data exchanged through the channel
  * @template Channel - String literal type for the channel name
  */
-type APIChannel<ChannelData, Channel extends string> = CoreAPIChannel<ChannelData, Channel, APIFunction<void, unknown> | APIFunction<void, unknown, ChannelData>, APIFunction<void, void> | APIFunction<void, void, ChannelData>, APIFunction<any, any> | APIFunction<any, any, ChannelData>, APIPermission>
+type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<ChannelData, Channel, PikkuFunction<void, unknown> | PikkuFunction<void, unknown, ChannelData>, PikkuFunction<void, void> | PikkuFunction<void, void, ChannelData>, PikkuFunction<any, any> | PikkuFunction<any, any, ChannelData>, PikkuPermission>
 
 /**
  * Type definition for scheduled tasks that run at specified intervals.
  * These are sessionless functions that execute based on cron expressions.
  */
-type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>>
+type SchedulerWiring = CoreScheduledTask<PikkuFunctionSessionless<void, void>>
 
 /**
  * Type definition for queue workers that process background jobs.
@@ -119,28 +119,28 @@ type ScheduledTask = CoreScheduledTask<APIFunctionSessionless<void, void>>
  * @template In - Input type for the queue job
  * @template Out - Output type for the queue job
  */
-type QueueWorker<In, Out> = CoreQueueWorker<APIFunctionSessionless<In, Out>>
+type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionSessionless<In, Out>>
 
 /**
  * Type definition for MCP resources that provide data to AI models.
  * 
  * @template In - Input type for the resource request
  */
-type MCPResource<In> = CoreMCPResource<APIFunctionSessionless<In, MCPResourceResponse, null, true>>
+type MCPResourceWiring<In> = CoreMCPResource<PikkuFunctionSessionless<In, MCPResourceResponse, null, true>>
 
 /**
  * Type definition for MCP tools that AI models can invoke.
  * 
  * @template In - Input type for the tool invocation
  */
-type MCPTool<In> = CoreMCPTool<APIFunctionSessionless<In, MCPToolResponse, null, true>>
+type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionSessionless<In, MCPToolResponse, null, true>>
 
 /**
  * Type definition for MCP prompts that provide templates to AI models.
  * 
  * @template In - Input type for the prompt parameters
  */
-type MCPPrompt<In> = CoreMCPPrompt<APIFunctionSessionless<In, MCPPromptResponse, null, true>>
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionSessionless<In, MCPPromptResponse, null, true>>
 
 /**
  * Creates a Pikku function that can be either session-aware or sessionless.
@@ -165,14 +165,14 @@ type MCPPrompt<In> = CoreMCPPrompt<APIFunctionSessionless<In, MCPPromptResponse,
  */
 export const pikkuFunc = <In, Out = unknown>(
   func:
-    | APIFunction<In, Out>
+    | PikkuFunction<In, Out>
     | {
-        func: APIFunction<In, Out>
+        func: PikkuFunction<In, Out>
         auth?: true
         name?: string
       }
     | {
-        func: APIFunctionSessionless<In, Out>
+        func: PikkuFunctionSessionless<In, Out>
         auth: false
         name?: string
       }
@@ -202,9 +202,9 @@ export const pikkuFunc = <In, Out = unknown>(
  */
 export const pikkuSessionlessFunc = <In, Out = unknown>(
   func:
-    | APIFunctionSessionless<In, Out>
+    | PikkuFunctionSessionless<In, Out>
     | {
-        func: APIFunctionSessionless<In, Out>
+        func: PikkuFunctionSessionless<In, Out>
         name?: string
       }
 ) => {
@@ -233,9 +233,9 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
  */
 export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
   func:
-    | APIFunctionSessionless<void, Out, ChannelData>
+    | PikkuFunctionSessionless<void, Out, ChannelData>
     | {
-        func: APIFunctionSessionless<void, Out, ChannelData>
+        func: PikkuFunctionSessionless<void, Out, ChannelData>
         name?: string
       }
 ) => {
@@ -262,9 +262,9 @@ export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>
  */
 export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
   func:
-    | APIFunctionSessionless<void, void, ChannelData>
+    | PikkuFunctionSessionless<void, void, ChannelData>
     | {
-        func: APIFunction<void, void, ChannelData>
+        func: PikkuFunction<void, void, ChannelData>
         name?: string
       }
 ) => {
@@ -292,9 +292,9 @@ export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
  */
 export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
   func:
-    | APIFunctionSessionless<In, Out, ChannelData>
+    | PikkuFunctionSessionless<In, Out, ChannelData>
     | {
-        func: APIFunctionSessionless<In, Out, ChannelData>
+        func: PikkuFunctionSessionless<In, Out, ChannelData>
         name?: string
       }
 ) => {
@@ -319,9 +319,9 @@ export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unkn
  */
 export const pikkuVoidFunc = (
   func:
-    | APIFunctionSessionless<void, void>
+    | PikkuFunctionSessionless<void, void>
     | {
-        func: APIFunctionSessionless<void, void>
+        func: PikkuFunctionSessionless<void, void>
         name?: string
       }
 ) => {
@@ -335,24 +335,24 @@ export const pikkuVoidFunc = (
  * @template Channel - String literal type for the channel name
  * @param channel - Channel definition with connection, disconnection, and message handlers
  */
-export const addChannel = <ChannelData, Channel extends string>(
-  channel: APIChannel<ChannelData, Channel> & AssertRouteParams<ChannelData, Channel>
+export const wireChannel = <ChannelData, Channel extends string>(
+  channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
 ) => {
-  addCoreChannel(channel as any) // TODO
+  wireChannelCore(channel as any) // TODO
 }
 
 /**
- * Registers an HTTP route with the Pikku framework.
+ * Registers an HTTP wiring with the Pikku framework.
  * 
- * @template In - Input type for the route
- * @template Out - Output type for the route
- * @template Route - String literal type for the route path (e.g., "/users/:id")
- * @param route - Route definition with handler, method, and optional middleware
+ * @template In - Input type for the HTTP wiring
+ * @template Out - Output type for the HTTP wiring
+ * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
+ * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
  */
-export const addHTTPRoute = <In, Out, Route extends string>(
-  route: APIRoute<In, Out, Route> & AssertRouteParams<In, Route>
+export const wireHTTP = <In, Out, Route extends string>(
+  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
 ) => {
-  addCoreHTTPRoute(route)
+  wireHTTPCore(httpWiring)
 }
 
 /**
@@ -361,8 +361,8 @@ export const addHTTPRoute = <In, Out, Route extends string>(
  * 
  * @param task - Scheduled task definition with cron expression and handler
  */
-export const addScheduledTask = (task: ScheduledTask) => {
-  addCoreScheduledTask(task as any) // TODO
+export const wireScheduler = (task: SchedulerWiring) => {
+  wireSchedulerCore(task as any) // TODO
 }
 
 /**
@@ -371,8 +371,8 @@ export const addScheduledTask = (task: ScheduledTask) => {
  * 
  * @param queueWorker - Queue worker definition with job handler
  */
-export const addQueueWorker = (queueWorker: QueueWorker<any, any>) => {
-  addCoreQueueWorker(queueWorker as any) // TODO
+export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
+  wireQueueWorkerCore(queueWorker as any) // TODO
 }
 
 /**
@@ -382,10 +382,10 @@ export const addQueueWorker = (queueWorker: QueueWorker<any, any>) => {
  * @template In - Input type for the resource request
  * @param mcpResource - MCP resource definition with data provider function
  */
-export const addMCPResource = <In>(
-  mcpResource: MCPResource<In>
+export const wireMCPResource = <In>(
+  mcpResource: MCPResourceWiring<In>
 ) => {
-  addCoreMCPResource(mcpResource as any)
+  wireMCPResourceCore(mcpResource as any)
 }
 
 /**
@@ -395,10 +395,10 @@ export const addMCPResource = <In>(
  * @template In - Input type for the tool invocation
  * @param mcpTool - MCP tool definition with action function
  */
-export const addMCPTool = <In>(
-  mcpTool: MCPTool<In>
+export const wireMCPTool = <In>(
+  mcpTool: MCPToolWiring<In>
 ) => {
-  addCoreMCPTool(mcpTool as any)
+  wireMCPToolCore(mcpTool as any)
 }
 
 /**
@@ -408,10 +408,10 @@ export const addMCPTool = <In>(
  * @template In - Input type for the prompt parameters
  * @param mcpPrompt - MCP prompt definition with template function
  */
-export const addMCPPrompt = <In>(
-  mcpPrompt: MCPPrompt<In>
+export const wireMCPPrompt = <In>(
+  mcpPrompt: MCPPromptWiring<In>
 ) => {
-  addCoreMCPPrompt(mcpPrompt as any)
+  wireMCPPromptCore(mcpPrompt as any)
 }
 
 /**
@@ -439,9 +439,9 @@ export const addMCPPrompt = <In>(
  */
 export const pikkuMCPPromptFunc = <In>(
   func:
-    | APIFunctionSessionless<In, MCPPromptResponse>
+    | PikkuFunctionSessionless<In, MCPPromptResponse>
     | {
-        func: APIFunctionSessionless<In, MCPPromptResponse>
+        func: PikkuFunctionSessionless<In, MCPPromptResponse>
         name?: string
       }
 ) => {
@@ -471,9 +471,9 @@ export const pikkuMCPPromptFunc = <In>(
  */
 export const pikkuMCPToolFunc = <In>(
   func:
-    | APIFunctionSessionless<In, MCPToolResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
     | {
-      func: APIFunctionSessionless<In, MCPToolResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
       name?: string
     }
 ) => {
@@ -504,9 +504,9 @@ export const pikkuMCPToolFunc = <In>(
  */
 export const pikkuMCPResourceFunc = <In>(
   func:
-    | APIFunctionSessionless<In, MCPResourceResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
     | {
-      func: APIFunctionSessionless<In, MCPResourceResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
       name?: string
     }
 ) => {

package/dist/src/utils.d.ts

@@ -1,7 +1,9 @@
 import { InspectorState, TypesMap } from '@pikku/inspector';
 export declare class CLILogger {
-    constructor({ logLogo }: {
+    private silent;
+    constructor({ logLogo, silent, }: {
         logLogo: boolean;
+        silent?: boolean;
     });
     primary(message: string): void;
     success(message: string): void;
@@ -9,6 +11,7 @@ export declare class CLILogger {
     error(message: string): void;
     warn(message: string): void;
     debug(message: string): void;
+    timing(message: string): void;
     private logPikkuLogo;
 }
 export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;
@@ -36,6 +39,7 @@ export interface PikkuCLIOptions {
     tags?: string[];
     types?: string[];
     directories?: string[];
+    silent?: boolean;
 }
 export declare const getPikkuFilesAndMethods: (logger: CLILogger, { singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, packageMappings: Record<string, string>, outputFile: string, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }: PikkuCLIOptions, requires?: Partial<{
     config: boolean;

package/dist/src/utils.js

@@ -13,19 +13,27 @@ const logo = `
 |_|    |_|_| \_)_| \_)____/ 
 `;
 export class CLILogger {
-    constructor({ logLogo }) {
-        if (logLogo) {
+    silent;
+    constructor({ logLogo, silent = false, }) {
+        this.silent = silent;
+        if (logLogo && !silent) {
             this.logPikkuLogo();
         }
     }
     primary(message) {
-        console.log(chalk.green(message));
+        if (!this.silent) {
+            console.log(chalk.green(message));
+        }
     }
     success(message) {
-        console.log(chalk.green(message));
+        if (!this.silent) {
+            console.log(chalk.green(message));
+        }
     }
     info(message) {
-        console.log(chalk.blue(message));
+        if (!this.silent) {
+            console.log(chalk.blue(message));
+        }
     }
     error(message) {
         console.error(chalk.red(message));
@@ -34,10 +42,13 @@ export class CLILogger {
         console.error(chalk.yellow(message));
     }
     debug(message) {
-        if (process.env.DEBUG) {
+        if (process.env.DEBUG && !this.silent) {
             console.log(chalk.gray(message));
         }
     }
+    timing(message) {
+        console.log(chalk.gray(message));
+    }
     logPikkuLogo() {
         this.primary(logo);
         const packageJson = JSON.parse(readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8'));

package/dist/src/wirings/channels/pikku-channels.js

@@ -0,0 +1,9 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+export const pikkuChannels = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
+        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = cliConfig;
+        const { channels } = visitState;
+        await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+    });
+};

package/dist/src/wirings/channels/pikku-command-channels.js

@@ -0,0 +1,9 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+export const pikkuChannels = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
+        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = cliConfig;
+        const { channels } = visitState;
+        await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+    });
+};

package/dist/src/{events → wirings}/channels/serialize-typed-channel-map.js

@@ -28,7 +28,7 @@ export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
         ? ChannelHandler<I, O>
         : never;
 
-export type ChannelRouteHandlerOf<
+export type ChannelWiringHandlerOf<
     Channel extends keyof ChannelsMap, 
     Route extends keyof ChannelsMap[Channel]['routes'], 
     Method extends keyof ChannelsMap[Channel]['routes'][Route],
@@ -42,7 +42,7 @@ function generateChannels(functionsMeta, channelsMeta) {
     const requiredTypes = new Set();
     const channelsObject = {};
     for (const meta of Object.values(channelsMeta)) {
-        const { name, messageRoutes, message } = meta;
+        const { name, messageWirings, message } = meta;
         if (!channelsObject[name]) {
             channelsObject[name] = { message: null, routes: {} };
         }
@@ -60,7 +60,7 @@ function generateChannels(functionsMeta, channelsMeta) {
             inputTypes?.forEach((type) => requiredTypes.add(type));
             outputTypes?.forEach((type) => requiredTypes.add(type));
         }
-        for (const [key, route] of Object.entries(messageRoutes)) {
+        for (const [key, route] of Object.entries(messageWirings)) {
             if (!channelsObject[name].routes[key]) {
                 channelsObject[name].routes[key] = {};
             }

package/dist/src/{events → wirings}/channels/serialize-websocket-wrapper.js

@@ -1,11 +1,11 @@
 export const serializeWebsocketWrapper = (channelsMapPath) => {
     return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
-import { ChannelDefaultHandlerOf, ChannelRouteHandlerOf, ChannelsMap } from '${channelsMapPath}';
+import { ChannelDefaultHandlerOf, ChannelWiringHandlerOf, ChannelsMap } from '${channelsMapPath}';
 
 class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends CorePikkuRouteHandler {
     public subscribe<
         Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
+        Data extends ChannelWiringHandlerOf<Channel, Route, Method>['output']
     >(method: Method, callback: (data: Data) => void
     ) {
         super.subscribe(method.toString(), callback)
@@ -13,20 +13,20 @@ class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof
 
     public unsubscribe<
         Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
+        Data extends ChannelWiringHandlerOf<Channel, Route, Method>['output']
     >(method: Method, callback?: (data: Data) => void) {
         super.unsubscribe(method.toString(), callback)
     }
 
     public send<
         Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['input']
+        Data extends ChannelWiringHandlerOf<Channel, Route, Method>['input']
     >(method: Method, data: Data) {
         super.send(method.toString(), data)
     }
 }
 
-export class PikkuWebSocket<Channel extends keyof ChannelsMap> extends CorePikkuWebsocket {
+export class PikkuWebSocket<Channel extends keyof ChannelsMap, EventHubTopics extends Record<string, any> = {}> extends CorePikkuWebsocket {
     /**
      * Send a message to a specific route and method.
      * Validates the input data type.
@@ -56,6 +56,20 @@ export class PikkuWebSocket<Channel extends keyof ChannelsMap> extends CorePikku
     public send(data: ChannelDefaultHandlerOf<Channel>['input']) {
         super.send(data)
     }
+
+    /**
+     * Subscribe to a topic from the EventHub system with strong typing.
+     */
+    public subscribeToEventHub<Topic extends keyof EventHubTopics>(
+        topic: Topic,
+        callback: (data: EventHubTopics[Topic]) => void
+    ) {
+        super.subscribe((data) => {
+            if (data.topic === topic) {
+                callback(data as EventHubTopics[Topic])
+            }
+        })
+    }
 }
   `;
 };

package/dist/src/{events → wirings}/fetch/index.js

@@ -1,11 +1,11 @@
 import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
 import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuFetch = async (logger, { fetchFile, httpRoutesMapDeclarationFile, packageMappings }) => {
+export const pikkuFetch = async (logger, { fetchFile, httpMapDeclarationFile, packageMappings }) => {
     return await logCommandInfoAndTime(logger, 'Generating fetch wrapper', 'Generated fetch wrapper', [fetchFile === undefined, "fetchFile isn't set in the pikku config"], async () => {
         if (!fetchFile) {
             throw new Error("fetchFile is isn't set in the pikku config");
         }
-        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, httpRoutesMapDeclarationFile, packageMappings);
+        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, httpMapDeclarationFile, packageMappings);
         const content = [serializeFetchWrapper(routesMapDeclarationPath)];
         await writeFileInDir(logger, fetchFile, content.join('\n'));
     });

package/dist/src/{events → wirings}/http/openapi-spec-generator.d.ts

@@ -1,4 +1,4 @@
-import { FunctionsMeta, HTTPRoutesMeta } from '@pikku/core';
+import { FunctionsMeta, HTTPWiringsMeta } from '@pikku/core';
 interface OpenAPISpec {
     openapi: string;
     info: {
@@ -75,5 +75,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

package/dist/src/wirings/http/pikku-command-http-map.js

@@ -0,0 +1,8 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+import { serializeTypedHTTPWiringsMap } from './serialize-typed-http-map.js';
+export const pikkuHTTPMap = async (logger, { httpMapDeclarationFile, packageMappings }, { http, functions }) => {
+    return await logCommandInfoAndTime(logger, 'Creating HTTP map', 'Created HTTP map', [http.files.size === 0], async () => {
+        const content = serializeTypedHTTPWiringsMap(httpMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, http.meta, http.metaInputTypes);
+        await writeFileInDir(logger, httpMapDeclarationFile, content);
+    });
+};

package/dist/src/{events → wirings}/http/pikku-command-http-routes.js

@@ -1,9 +1,9 @@
 import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
 export const pikkuHTTP = async (logger, cliConfig, visitState) => {
     return await logCommandInfoAndTime(logger, 'Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
-        const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig;
+        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig;
         const { http } = visitState;
-        await writeFileInDir(logger, httpRoutesFile, serializeFileImports('addHTTPRoute', httpRoutesFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
     });
 };

package/dist/src/{events → wirings}/http/pikku-http-routes.js

@@ -1,9 +1,9 @@
 import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
 export const pikkuHTTP = async (logger, cliConfig, visitState) => {
     return await logCommandInfoAndTime(logger, 'Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
-        const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig;
+        const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig;
         const { http } = visitState;
-        await writeFileInDir(logger, httpRoutesFile, serializeFileImports('addHTTPRoute', httpRoutesFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
     });
 };