@pikku/cli 0.8.3 → 0.9.1

package/src/utils.ts

@@ -17,20 +17,35 @@ const logo = `
 `
 
 export class CLILogger {
-  constructor({ logLogo }: { logLogo: boolean }) {
-    if (logLogo) {
+  private silent: boolean
+
+  constructor({
+    logLogo,
+    silent = false,
+  }: {
+    logLogo: boolean
+    silent?: boolean
+  }) {
+    this.silent = silent
+    if (logLogo && !silent) {
       this.logPikkuLogo()
     }
   }
 
   primary(message: string) {
-    console.log(chalk.green(message))
+    if (!this.silent) {
+      console.log(chalk.green(message))
+    }
   }
   success(message: string) {
-    console.log(chalk.green(message))
+    if (!this.silent) {
+      console.log(chalk.green(message))
+    }
   }
   info(message: string) {
-    console.log(chalk.blue(message))
+    if (!this.silent) {
+      console.log(chalk.blue(message))
+    }
   }
   error(message: string) {
     console.error(chalk.red(message))
@@ -39,11 +54,15 @@ export class CLILogger {
     console.error(chalk.yellow(message))
   }
   debug(message: string) {
-    if (process.env.DEBUG) {
+    if (process.env.DEBUG && !this.silent) {
       console.log(chalk.gray(message))
     }
   }
 
+  timing(message: string) {
+    console.log(chalk.gray(message))
+  }
+
   private logPikkuLogo() {
     this.primary(logo)
     const packageJson = JSON.parse(
@@ -129,6 +148,7 @@ export interface PikkuCLIOptions {
   tags?: string[]
   types?: string[]
   directories?: string[]
+  silent?: boolean
 }
 
 const getMetaTypes = (

package/src/{events → wirings}/channels/pikku-channels.ts

@@ -18,21 +18,22 @@ export const pikkuChannels: PikkuCommand = async (
     '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,
+        channelsWiringFile,
         serializeFileImports(
           'addChannel',
-          channelsFile,
+          channelsWiringFile,
           channels.files,
           packageMappings
         )
       )
       await writeFileInDir(
         logger,
-        channelsMetaFile,
+        channelsWiringMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
       )
     }

package/src/{events → wirings}/channels/pikku-command-channels.ts

@@ -16,21 +16,22 @@ export const pikkuChannels: PikkuCommand = async (
     '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,
+        channelsWiringFile,
         serializeFileImports(
           'addChannel',
-          channelsFile,
+          channelsWiringFile,
           channels.files,
           packageMappings
         )
       )
       await writeFileInDir(
         logger,
-        channelsMetaFile,
+        channelsWiringMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`
       )
     }

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

@@ -46,7 +46,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],
@@ -80,7 +80,7 @@ function generateChannels(
   > = {}
 
   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: {} }
@@ -103,7 +103,7 @@ function generateChannels(
       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/src/{events → wirings}/channels/serialize-websocket-wrapper.ts

@@ -1,11 +1,11 @@
 export const serializeWebsocketWrapper = (channelsMapPath: string) => {
   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/src/{events → wirings}/fetch/index.ts

@@ -8,7 +8,7 @@ import { PikkuCommandWithoutState } from '../../types.js'
 
 export const pikkuFetch: PikkuCommandWithoutState = async (
   logger,
-  { fetchFile, httpRoutesMapDeclarationFile, packageMappings }
+  { fetchFile, httpMapDeclarationFile, packageMappings }
 ) => {
   return await logCommandInfoAndTime(
     logger,
@@ -22,7 +22,7 @@ export const pikkuFetch: PikkuCommandWithoutState = async (
 
       const routesMapDeclarationPath = getFileImportRelativePath(
         fetchFile,
-        httpRoutesMapDeclarationFile,
+        httpMapDeclarationFile,
         packageMappings
       )
 

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

@@ -1,4 +1,4 @@
-import { FunctionsMeta, HTTPRoutesMeta, pikkuState } from '@pikku/core'
+import { FunctionsMeta, HTTPWiringsMeta, pikkuState } from '@pikku/core'
 import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
 const convertSchema =
   'default' in _convertSchema ? (_convertSchema.default as any) : _convertSchema
@@ -76,7 +76,7 @@ const getErrorResponseForConstructorName = (constructorName: string) => {
 
 const convertSchemasToBodyPayloads = async (
   functionsMeta: FunctionsMeta,
-  routesMeta: HTTPRoutesMeta,
+  routesMeta: HTTPWiringsMeta,
   schemas: Record<string, any>
 ) => {
   const requiredSchemas = new Set(
@@ -105,7 +105,7 @@ const convertSchemasToBodyPayloads = async (
 
 export async function generateOpenAPISpec(
   functionsMeta: FunctionsMeta,
-  routeMeta: HTTPRoutesMeta,
+  routeMeta: HTTPWiringsMeta,
   schemas: Record<string, any>,
   additionalInfo: OpenAPISpecInfo
 ): Promise<OpenAPISpec> {

package/src/{events → wirings}/http/pikku-command-http-map.ts

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

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

@@ -18,21 +18,21 @@ export const pikkuHTTP: PikkuCommand = async (
     '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,
+        httpWiringsFile,
         serializeFileImports(
-          'addHTTPRoute',
-          httpRoutesFile,
+          'wireHTTP',
+          httpWiringsFile,
           http.files,
           packageMappings
         )
       )
       await writeFileInDir(
         logger,
-        httpRoutesMetaFile,
+        httpWiringMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
       )
     }

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

@@ -18,21 +18,21 @@ export const pikkuHTTP: PikkuCommand = async (
     '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,
+        httpWiringsFile,
         serializeFileImports(
-          'addHTTPRoute',
-          httpRoutesFile,
+          'wireHTTP',
+          httpWiringsFile,
           http.files,
           packageMappings
         )
       )
       await writeFileInDir(
         logger,
-        httpRoutesMetaFile,
+        httpWiringMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
       )
     }

package/src/wirings/http/serialize-fetch-wrapper.ts

@@ -0,0 +1,67 @@
+export const serializeFetchWrapper = (routesMapPath: string) => {
+  return `
+import { CorePikkuFetch, HTTPMethod } from '@pikku/fetch'
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
+
+export class PikkuFetch extends CorePikkuFetch {
+    public async post<Route extends HTTPWiringsWithMethod<'POST'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'POST'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'POST'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'POST'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'POST', data, options);
+    }
+
+    public async get<Route extends HTTPWiringsWithMethod<'GET'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'GET'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'GET'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'GET'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'GET', data, options);
+    }
+
+    public async patch<Route extends HTTPWiringsWithMethod<'PATCH'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'PATCH'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'PATCH'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'PATCH', data, options);
+    }
+
+    public async head<Route extends HTTPWiringsWithMethod<'HEAD'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'HEAD'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'HEAD'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'HEAD'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'HEAD'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'HEAD', data, options);
+    }
+
+    public async delete<Route extends HTTPWiringsWithMethod<'DELETE'>>(
+        route: Route,
+        ...args: null extends HTTPWiringHandlerOf<Route, 'DELETE'>['input']
+            ? [data?: Exclude<HTTPWiringHandlerOf<Route, 'DELETE'>['input'], null>, options?: Omit<RequestInit, 'body'>]
+            : [data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'], options?: Omit<RequestInit, 'body'>]
+    ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> {
+        const [data, options] = args;
+        return super.api(route, 'DELETE', data, options);
+    }
+
+    public async fetch<
+        Route extends keyof HTTPWiringsMap,
+        Method extends keyof HTTPWiringsMap[Route]
+    >(route: Route, method: Method, data: HTTPWiringHandlerOf<Route, Method>['input'], options?: Omit<RequestInit, 'body'>): Promise<Response> {
+        return await super.fetch(route, method as HTTPMethod, data, options);
+    }
+}
+
+export const pikkuFetch = new PikkuFetch();
+`
+}

package/src/{events → wirings}/http/serialize-typed-http-map.ts

@@ -1,22 +1,22 @@
-import { HTTPRoutesMeta } from '@pikku/core/http'
+import { HTTPWiringsMeta } from '@pikku/core/http'
 import { serializeImportMap } from '../../serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
 import { generateCustomTypes } from '../../utils.js'
 
-export const serializeTypedRoutesMap = (
+export const serializeTypedHTTPWiringsMap = (
   relativeToPath: string,
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  routesMeta: HTTPRoutesMeta,
+  wiringsMeta: HTTPWiringsMeta,
   metaTypes: MetaInputTypes
 ) => {
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
   const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
-  const serializedRoutes = generateRoutes(
-    routesMeta,
+  const serializedHTTPWirings = generateHTTPWirings(
+    wiringsMeta,
     functionsMeta,
     typesMap,
     requiredTypes
@@ -37,26 +37,26 @@ ${serializedImportMap}
 ${serializedCustomTypes}
 ${serializedMetaTypes}
 
-interface RouteHandler<I, O> {
+interface HTTPWiringHandler<I, O> {
     input: I;
     output: O;
 }
 
-${serializedRoutes}
+${serializedHTTPWirings}
 
-export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
-    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
-        ? RouteHandler<I, O>
+export type HTTPWiringHandlerOf<HTTPWiring extends keyof HTTPWiringsMap, Method extends keyof HTTPWiringsMap[HTTPWiring]> =
+    HTTPWiringsMap[HTTPWiring][Method] extends { input: infer I; output: infer O }
+        ? HTTPWiringHandler<I, O>
         : never;
 
-export type RoutesWithMethod<Method extends string> = {
-  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
-}[keyof RoutesMap];
+export type HTTPWiringsWithMethod<Method extends string> = {
+  [HTTPWiring in keyof HTTPWiringsMap]: Method extends keyof HTTPWiringsMap[HTTPWiring] ? HTTPWiring : never;
+}[keyof HTTPWiringsMap];
   `
 }
 
-function generateRoutes(
-  routesMeta: HTTPRoutesMeta,
+function generateHTTPWirings(
+  routesMeta: HTTPWiringsMeta,
   functionsMeta: FunctionsMeta,
   typesMap: TypesMap,
   requiredTypes: Set<string>
@@ -98,12 +98,12 @@ function generateRoutes(
   }
 
   // Build the routes object as a string
-  let routesStr = 'export type RoutesMap = {\n'
+  let routesStr = 'export type HTTPWiringsMap = {\n'
 
   for (const [routePath, methods] of Object.entries(routesObj)) {
     routesStr += `  readonly '${routePath}': {\n`
     for (const [method, handler] of Object.entries(methods)) {
-      routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`
+      routesStr += `    readonly ${method.toUpperCase()}: HTTPWiringHandler<${handler.inputType}, ${handler.outputType}>,\n`
     }
     routesStr += '  },\n'
   }

package/src/{events → wirings}/mcp/pikku-command-mcp.ts

@@ -62,7 +62,7 @@ const generateArgumentsFromSchema = async (
 
 export const pikkuMCP: PikkuCommand = async (
   logger,
-  { mcpEndpointsFile, mcpEndpointsMetaFile, packageMappings, schemaDirectory },
+  { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory },
   { mcpEndpoints, functions }
 ) => {
   return await logCommandInfoAndTime(
@@ -73,10 +73,10 @@ export const pikkuMCP: PikkuCommand = async (
     async () => {
       await writeFileInDir(
         logger,
-        mcpEndpointsFile,
+        mcpWiringsFile,
         serializeFileImports(
-          'addMCPResource or addMCPTool',
-          mcpEndpointsFile,
+          'wireMCPResource or wireMCPTool',
+          mcpWiringsFile,
           mcpEndpoints.files,
           packageMappings
         )
@@ -99,7 +99,7 @@ export const pikkuMCP: PikkuCommand = async (
 
       await writeFileInDir(
         logger,
-        mcpEndpointsMetaFile,
+        mcpWiringsMetaFile,
         `import { pikkuState } from '@pikku/core'
 pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
 pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})

package/src/{events → wirings}/queue/pikku-command-queue-service.ts

@@ -8,26 +8,29 @@ import { PikkuCommandWithoutState } from '../../types.js'
 
 export const pikkuQueueService: PikkuCommandWithoutState = async (
   logger,
-  { queueFile, queueMapDeclarationFile, packageMappings }
+  { queueWiringsFile, queueMapDeclarationFile, packageMappings }
 ) => {
   return await logCommandInfoAndTime(
     logger,
     'Generating queue service wrapper',
     'Generated queue service wrapper',
-    [queueFile === undefined, "queueFile isn't set in the pikku config"],
+    [
+      queueWiringsFile === undefined,
+      "queueWiringsFile isn't set in the pikku config",
+    ],
     async () => {
-      if (!queueFile) {
-        throw new Error("queueFile is isn't set in the pikku config")
+      if (!queueWiringsFile) {
+        throw new Error("queueWiringsFile is isn't set in the pikku config")
       }
 
       const queueMapDeclarationPath = getFileImportRelativePath(
-        queueFile,
+        queueWiringsFile,
         queueMapDeclarationFile,
         packageMappings
       )
 
       const content = [serializeQueueWrapper(queueMapDeclarationPath)]
-      await writeFileInDir(logger, queueFile, content.join('\n'))
+      await writeFileInDir(logger, queueWiringsFile, content.join('\n'))
     }
   )
 }

package/src/{events → wirings}/queue/pikku-command-queue.ts

@@ -19,20 +19,23 @@ export const pikkuQueue: PikkuCommand = async (
     'Found queue',
     [visitState.queueWorkers.files.size === 0],
     async () => {
-      const { queueWorkersFile, queueWorkersMetaFile, packageMappings } =
-        cliConfig
+      const {
+        queueWorkersWiringFile,
+        queueWorkersWiringMetaFile,
+        packageMappings,
+      } = cliConfig
       const { queueWorkers } = visitState
       await writeFileInDir(
         logger,
-        queueWorkersMetaFile,
+        queueWorkersWiringMetaFile,
         serializeQueueMeta(queueWorkers.meta)
       )
       await writeFileInDir(
         logger,
-        queueWorkersFile,
+        queueWorkersWiringFile,
         serializeFileImports(
           'addQueueWorkers',
-          queueWorkersFile,
+          queueWorkersWiringFile,
           queueWorkers.files,
           packageMappings
         )

package/src/{events → wirings}/queue/pikku-queue.ts

@@ -17,20 +17,23 @@ export const pikkuQueue: PikkuCommand = async (
     'Found queue',
     [visitState.queueWorkers.files.size === 0],
     async () => {
-      const { queueWorkersFile, queueWorkersMetaFile, packageMappings } =
-        cliConfig
+      const {
+        queueWorkersWiringFile,
+        queueWorkersWiringMetaFile,
+        packageMappings,
+      } = cliConfig
       const { queueWorkers } = visitState
       await writeFileInDir(
         logger,
-        queueWorkersMetaFile,
+        queueWorkersWiringMetaFile,
         serializeQueueMeta(queueWorkers.meta)
       )
       await writeFileInDir(
         logger,
-        queueWorkersFile,
+        queueWorkersWiringFile,
         serializeFileImports(
           'addQueueWorkers',
-          queueWorkersFile,
+          queueWorkersWiringFile,
           queueWorkers.files,
           packageMappings
         )

package/src/{events → wirings}/rpc/pikku-command-rpc-client.ts

@@ -8,26 +8,29 @@ import { PikkuCommandWithoutState } from '../../types.js'
 
 export const pikkuRPCClient: PikkuCommandWithoutState = async (
   logger,
-  { rpcFile, rpcMapDeclarationFile, packageMappings }
+  { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }
 ) => {
   return await logCommandInfoAndTime(
     logger,
     'Generating RPC wrapper',
     'Generated RPC wrapper',
-    [rpcFile === undefined, "rpcFile isn't set in the pikku config"],
+    [
+      rpcWiringsFile === undefined,
+      "rpcWiringsFile isn't set in the pikku config",
+    ],
     async () => {
-      if (!rpcFile) {
-        throw new Error("rpcFile isn't set in the pikku config")
+      if (!rpcWiringsFile) {
+        throw new Error("rpcWiringsFile isn't set in the pikku config")
       }
 
       const rpcMapDeclarationPath = getFileImportRelativePath(
-        rpcFile,
+        rpcWiringsFile,
         rpcMapDeclarationFile,
         packageMappings
       )
 
       const content = [serializeRPCWrapper(rpcMapDeclarationPath)]
-      await writeFileInDir(logger, rpcFile, content.join('\n'))
+      await writeFileInDir(logger, rpcWiringsFile, content.join('\n'))
     }
   )
 }