@pikku/cli 0.8.3 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pikku/cli
 
+## 0.9.0
+
+### Breaking Changes
+
+- Normalized all transports to use "wirings" instead of events/routes/transports for consistency across the framework
+
 ## 0.8.3
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -6,29 +6,29 @@ import {
   writeFileInDir,
 } from '../src/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuHTTP } from '../src/events/http/pikku-command-http-routes.js'
-import { pikkuFunctionTypes } from '../src/events/functions/pikku-command-function-types.js'
-import { pikkuHTTPMap } from '../src/events/http/pikku-command-http-map.js'
+import { pikkuHTTP } from '../src/wirings/http/pikku-command-http-routes.js'
+import { pikkuFunctionTypes } from '../src/wirings/functions/pikku-command-function-types.js'
+import { pikkuHTTPMap } from '../src/wirings/http/pikku-command-http-map.js'
 import { existsSync } from 'fs'
-import { pikkuChannelsMap } from '../src/events/channels/pikku-command-channels-map.js'
-import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js'
+import { pikkuChannelsMap } from '../src/wirings/channels/pikku-command-channels-map.js'
+import { pikkuChannels } from '../src/wirings/channels/pikku-command-channels.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 import chokidar from 'chokidar'
-import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js'
-import { pikkuServices } from '../src/events/functions/pikku-command-services.js'
-import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js'
-import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js'
-import { pikkuQueue } from '../src/events/queue/pikku-command-queue.js'
-import { pikkuQueueMap } from '../src/events/queue/pikku-command-queue-map.js'
-import { pikkuFetch } from '../src/events/fetch/index.js'
-import { pikkuRPCClient } from '../src/events/rpc/pikku-command-rpc-client.js'
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
-import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
-import { pikkuMCP } from '../src/events/mcp/pikku-command-mcp.js'
-import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js'
-import { pikkuScheduler } from '../src/events/scheduler/pikku-command-scheduler.js'
+import { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js'
+import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js'
+import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js'
+import { pikkuRPCMap } from '../src/wirings/rpc/pikku-command-rpc-map.js'
+import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js'
+import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js'
+import { pikkuFetch } from '../src/wirings/fetch/index.js'
+import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js'
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js'
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js'
+import { pikkuMCP } from '../src/wirings/mcp/pikku-command-mcp.js'
+import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js'
+import { pikkuScheduler } from '../src/wirings/scheduler/pikku-command-scheduler.js'
 import { pikkuSchemas } from '../src/schemas.js'
-import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js'
+import { pikkuMCPJSON } from '../src/wirings/mcp/pikku-command-mcp-json.js'
 import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js'
 
 const generateBootstrapFile = async (
@@ -82,7 +82,7 @@ const runAll = async (
   }
   await pikkuFunctionTypes(logger, cliConfig, visitState, options)
 
-  // This is needed since the addHTTPRoute function will add the routes to the visitState
+  // This is needed since the wireHTTP function will add the routes to the visitState
   if (!typesDeclarationFileExists) {
     logger.info(`• Type file first created, inspecting again...\x1b[0m`)
     visitState = await inspectorGlob(
@@ -108,7 +108,7 @@ const runAll = async (
   await pikkuRPC(logger, cliConfig, visitState)
   await pikkuRPCMap(logger, cliConfig, visitState)
   await pikkuRPCClient(logger, cliConfig)
-  allImports.push(cliConfig.rpcMetaFile)
+  allImports.push(cliConfig.rpcWiringMetaFile)
 
   const schemas = await pikkuSchemas(logger, cliConfig, visitState)
   if (schemas) {
@@ -120,7 +120,7 @@ const runAll = async (
     logger,
     cliConfig,
     cliConfig.bootstrapFiles.rpc,
-    [cliConfig.rpcMetaFile],
+    [cliConfig.rpcWiringMetaFile],
     schemas
   )
 
@@ -128,26 +128,29 @@ const runAll = async (
   if (http) {
     await pikkuHTTPMap(logger, cliConfig, visitState)
     await pikkuFetch(logger, cliConfig)
-    allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile)
+    allImports.push(cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile)
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.http,
-      [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile],
+      [cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile],
       schemas
     )
   }
 
   const scheduler = await pikkuScheduler(logger, cliConfig, visitState)
   if (scheduler) {
-    allImports.push(cliConfig.schedulersMetaFile, cliConfig.schedulersFile)
+    allImports.push(
+      cliConfig.schedulersWiringMetaFile,
+      cliConfig.schedulersWiringFile
+    )
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.scheduler,
-      [cliConfig.schedulersMetaFile, cliConfig.schedulersFile],
+      [cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile],
       schemas
     )
   }
@@ -156,13 +159,16 @@ const runAll = async (
   if (queues) {
     await pikkuQueueMap(logger, cliConfig, visitState)
     await pikkuQueueService(logger, cliConfig)
-    allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile)
+    allImports.push(
+      cliConfig.queueWorkersWiringMetaFile,
+      cliConfig.queueWorkersWiringFile
+    )
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.queue,
-      [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile],
+      [cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile],
       schemas
     )
   }
@@ -171,13 +177,16 @@ const runAll = async (
   if (channels) {
     await pikkuChannelsMap(logger, cliConfig, visitState)
     await pikkuWebSocketTyped(logger, cliConfig)
-    allImports.push(cliConfig.channelsMetaFile, cliConfig.channelsFile)
+    allImports.push(
+      cliConfig.channelsWiringMetaFile,
+      cliConfig.channelsWiringFile
+    )
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.channel,
-      [cliConfig.channelsMetaFile, cliConfig.channelsFile],
+      [cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile],
       schemas
     )
   }
@@ -185,13 +194,13 @@ const runAll = async (
   const mcp = await pikkuMCP(logger, cliConfig, visitState)
   if (mcp) {
     await pikkuMCPJSON(logger, cliConfig, visitState)
-    allImports.push(cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile)
+    allImports.push(cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile)
 
     await generateBootstrapFile(
       logger,
       cliConfig,
       cliConfig.bootstrapFiles.mcp,
-      [cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile],
+      [cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile],
       schemas
     )
   }

package/bin/pikku-fetch.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuFetch } from '../src/events/fetch/index.js'
+import { pikkuFetch } from '../src/wirings/fetch/index.js'
 import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {

package/bin/pikku-openapi.ts

@@ -2,13 +2,13 @@ import { Command } from 'commander'
 import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
-import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js'
 
 async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
   const logger = new CLILogger({ logLogo: true })
   const cliConfig = await getPikkuCLIConfig(
     config,
-    ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
+    ['rootDir', 'httpWiringsFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
     {
       tags: tags || [],
     }

package/bin/pikku-queue-service.ts

@@ -1,14 +1,14 @@
 import { Command } from 'commander'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
-import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js'
+import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const logger = new CLILogger({ logLogo: true })
 
   const cliConfig = await getPikkuCLIConfig(
     options.config,
-    ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'],
+    ['rootDir', 'schemaDirectory', 'configDir', 'queueWiringsFile'],
     {
       tags: options.tags,
       types: options.types,

package/bin/pikku-websocket.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander'
 import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const logger = new CLILogger({ logLogo: true })

package/cli.schema.json

@@ -172,13 +172,13 @@
           "required": ["http", "scheduler", "channel", "rpc", "queue", "mcp"],
           "type": "object"
         },
-        "channelsFile": {
+        "channelsMapDeclarationFile": {
           "type": "string"
         },
-        "channelsMapDeclarationFile": {
+        "channelsWiringFile": {
           "type": "string"
         },
-        "channelsMetaFile": {
+        "channelsWiringMetaFile": {
           "type": "string"
         },
         "configDir": {
@@ -199,22 +199,22 @@
         "functionsMetaFile": {
           "type": "string"
         },
-        "httpRoutesFile": {
+        "httpMapDeclarationFile": {
           "type": "string"
         },
-        "httpRoutesMapDeclarationFile": {
+        "httpWiringMetaFile": {
           "type": "string"
         },
-        "httpRoutesMetaFile": {
+        "httpWiringsFile": {
           "type": "string"
         },
-        "mcpEndpointsFile": {
+        "mcpJsonFile": {
           "type": "string"
         },
-        "mcpEndpointsMetaFile": {
+        "mcpWiringsFile": {
           "type": "string"
         },
-        "mcpJsonFile": {
+        "mcpWiringsMetaFile": {
           "type": "string"
         },
         "middlewareServices": {
@@ -251,34 +251,34 @@
           },
           "type": "object"
         },
-        "queueFile": {
+        "queueMapDeclarationFile": {
           "type": "string"
         },
-        "queueMapDeclarationFile": {
+        "queueWiringsFile": {
           "type": "string"
         },
-        "queueWorkersFile": {
+        "queueWorkersWiringFile": {
           "type": "string"
         },
-        "queueWorkersMetaFile": {
+        "queueWorkersWiringMetaFile": {
           "type": "string"
         },
         "rootDir": {
           "type": "string"
         },
-        "rpcFile": {
+        "rpcMapDeclarationFile": {
           "type": "string"
         },
-        "rpcMapDeclarationFile": {
+        "rpcWiringMetaFile": {
           "type": "string"
         },
-        "rpcMetaFile": {
+        "rpcWiringsFile": {
           "type": "string"
         },
-        "schedulersFile": {
+        "schedulersWiringFile": {
           "type": "string"
         },
-        "schedulersMetaFile": {
+        "schedulersWiringMetaFile": {
           "type": "string"
         },
         "schemaDirectory": {
@@ -309,27 +309,27 @@
       "required": [
         "bootstrapFile",
         "bootstrapFiles",
-        "channelsFile",
         "channelsMapDeclarationFile",
-        "channelsMetaFile",
+        "channelsWiringFile",
+        "channelsWiringMetaFile",
         "configDir",
         "filters",
         "functionsFile",
         "functionsMetaFile",
-        "httpRoutesFile",
-        "httpRoutesMapDeclarationFile",
-        "httpRoutesMetaFile",
-        "mcpEndpointsFile",
-        "mcpEndpointsMetaFile",
+        "httpMapDeclarationFile",
+        "httpWiringMetaFile",
+        "httpWiringsFile",
+        "mcpWiringsFile",
+        "mcpWiringsMetaFile",
         "packageMappings",
         "queueMapDeclarationFile",
-        "queueWorkersFile",
-        "queueWorkersMetaFile",
+        "queueWorkersWiringFile",
+        "queueWorkersWiringMetaFile",
         "rootDir",
         "rpcMapDeclarationFile",
-        "rpcMetaFile",
-        "schedulersFile",
-        "schedulersMetaFile",
+        "rpcWiringMetaFile",
+        "schedulersWiringFile",
+        "schedulersWiringMetaFile",
         "schemaDirectory",
         "servicesFile",
         "srcDirectories",

package/dist/bin/pikku-all.js

@@ -1,28 +1,28 @@
 import { CLILogger, getFileImportRelativePath, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuHTTP } from '../src/events/http/pikku-command-http-routes.js';
-import { pikkuFunctionTypes } from '../src/events/functions/pikku-command-function-types.js';
-import { pikkuHTTPMap } from '../src/events/http/pikku-command-http-map.js';
+import { pikkuHTTP } from '../src/wirings/http/pikku-command-http-routes.js';
+import { pikkuFunctionTypes } from '../src/wirings/functions/pikku-command-function-types.js';
+import { pikkuHTTPMap } from '../src/wirings/http/pikku-command-http-map.js';
 import { existsSync } from 'fs';
-import { pikkuChannelsMap } from '../src/events/channels/pikku-command-channels-map.js';
-import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js';
+import { pikkuChannelsMap } from '../src/wirings/channels/pikku-command-channels-map.js';
+import { pikkuChannels } from '../src/wirings/channels/pikku-command-channels.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
-import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js';
-import { pikkuServices } from '../src/events/functions/pikku-command-services.js';
-import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js';
-import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js';
-import { pikkuQueue } from '../src/events/queue/pikku-command-queue.js';
-import { pikkuQueueMap } from '../src/events/queue/pikku-command-queue-map.js';
-import { pikkuFetch } from '../src/events/fetch/index.js';
-import { pikkuRPCClient } from '../src/events/rpc/pikku-command-rpc-client.js';
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js';
-import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js';
-import { pikkuMCP } from '../src/events/mcp/pikku-command-mcp.js';
-import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js';
-import { pikkuScheduler } from '../src/events/scheduler/pikku-command-scheduler.js';
+import { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js';
+import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js';
+import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js';
+import { pikkuRPCMap } from '../src/wirings/rpc/pikku-command-rpc-map.js';
+import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js';
+import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js';
+import { pikkuFetch } from '../src/wirings/fetch/index.js';
+import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js';
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js';
+import { pikkuMCP } from '../src/wirings/mcp/pikku-command-mcp.js';
+import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js';
+import { pikkuScheduler } from '../src/wirings/scheduler/pikku-command-scheduler.js';
 import { pikkuSchemas } from '../src/schemas.js';
-import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js';
+import { pikkuMCPJSON } from '../src/wirings/mcp/pikku-command-mcp-json.js';
 import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
 const generateBootstrapFile = async (logger, cliConfig, bootstrapFile, specificImports, schemas) => {
     // Common imports that every bootstrap file needs
@@ -46,7 +46,7 @@ const runAll = async (logger, cliConfig, options) => {
         typesDeclarationFileExists = false;
     }
     await pikkuFunctionTypes(logger, cliConfig, visitState, options);
-    // This is needed since the addHTTPRoute function will add the routes to the visitState
+    // This is needed since the wireHTTP function will add the routes to the visitState
     if (!typesDeclarationFileExists) {
         logger.info(`• Type file first created, inspecting again...\x1b[0m`);
         visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
@@ -63,44 +63,44 @@ const runAll = async (logger, cliConfig, options) => {
     await pikkuRPC(logger, cliConfig, visitState);
     await pikkuRPCMap(logger, cliConfig, visitState);
     await pikkuRPCClient(logger, cliConfig);
-    allImports.push(cliConfig.rpcMetaFile);
+    allImports.push(cliConfig.rpcWiringMetaFile);
     const schemas = await pikkuSchemas(logger, cliConfig, visitState);
     if (schemas) {
         allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
     }
     // RPC bootstrap is always generated since RPC is always present
-    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [cliConfig.rpcMetaFile], schemas);
+    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [cliConfig.rpcWiringMetaFile], schemas);
     const http = await pikkuHTTP(logger, cliConfig, visitState);
     if (http) {
         await pikkuHTTPMap(logger, cliConfig, visitState);
         await pikkuFetch(logger, cliConfig);
-        allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.http, [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile], schemas);
+        allImports.push(cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.http, [cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile], schemas);
     }
     const scheduler = await pikkuScheduler(logger, cliConfig, visitState);
     if (scheduler) {
-        allImports.push(cliConfig.schedulersMetaFile, cliConfig.schedulersFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.scheduler, [cliConfig.schedulersMetaFile, cliConfig.schedulersFile], schemas);
+        allImports.push(cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.scheduler, [cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile], schemas);
     }
     const queues = await pikkuQueue(logger, cliConfig, visitState);
     if (queues) {
         await pikkuQueueMap(logger, cliConfig, visitState);
         await pikkuQueueService(logger, cliConfig);
-        allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.queue, [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile], schemas);
+        allImports.push(cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.queue, [cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile], schemas);
     }
     const channels = await pikkuChannels(logger, cliConfig, visitState);
     if (channels) {
         await pikkuChannelsMap(logger, cliConfig, visitState);
         await pikkuWebSocketTyped(logger, cliConfig);
-        allImports.push(cliConfig.channelsMetaFile, cliConfig.channelsFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.channel, [cliConfig.channelsMetaFile, cliConfig.channelsFile], schemas);
+        allImports.push(cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.channel, [cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile], schemas);
     }
     const mcp = await pikkuMCP(logger, cliConfig, visitState);
     if (mcp) {
         await pikkuMCPJSON(logger, cliConfig, visitState);
-        allImports.push(cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile);
-        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.mcp, [cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile], schemas);
+        allImports.push(cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.mcp, [cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile], schemas);
     }
     if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
         await pikkuNext(logger, cliConfig, visitState, options);

package/dist/bin/pikku-fetch.js

@@ -1,5 +1,5 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuFetch } from '../src/events/fetch/index.js';
+import { pikkuFetch } from '../src/wirings/fetch/index.js';
 import { CLILogger } from '../src/utils.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });

package/dist/bin/pikku-openapi.js

@@ -1,10 +1,10 @@
 import { CLILogger } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js';
+import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js';
 async function action({ config, tags }) {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], {
+    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpWiringsFile', 'openAPI', 'schemaDirectory', 'tsconfig'], {
         tags: tags || [],
     });
     const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);

package/dist/bin/pikku-queue-service.js

@@ -1,9 +1,9 @@
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { CLILogger } from '../src/utils.js';
-import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js';
+import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'], {
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'queueWiringsFile'], {
         tags: options.tags,
         types: options.types,
         directories: options.directories,

package/dist/bin/pikku-websocket.js

@@ -1,6 +1,6 @@
 import { CLILogger } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js';
+import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
     const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], {

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

@@ -1,9 +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 { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
+        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = cliConfig;
         const { channels } = visitState;
-        await writeFileInDir(logger, channelsFile, serializeFileImports('addChannel', channelsFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+        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/channels/pikku-command-channels.js

@@ -1,9 +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 { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
+        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = cliConfig;
         const { channels } = visitState;
-        await writeFileInDir(logger, channelsFile, serializeFileImports('addChannel', channelsFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+        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/channels/serialize-typed-channel-map.js

@@ -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/channels/serialize-websocket-wrapper.js

@@ -26,7 +26,7 @@ class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof
     }
 }
 
-export class PikkuWebSocket<Channel extends keyof ChannelsMap> extends CorePikkuWebsocket {
+export class PikkuWebSocket<Channel extends keyof ChannelsMap, Topics 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/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/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 {};