@pikku/cli 0.8.2 → 0.9.0

package/src/pikku-cli-config.ts

@@ -1,8 +1,8 @@
 import { join, dirname, resolve, isAbsolute } from 'path'
 import { readdir, readFile } from 'fs/promises'
-import { OpenAPISpecInfo } from './events/http/openapi-spec-generator.js'
+import { OpenAPISpecInfo } from './wirings/http/openapi-spec-generator.js'
 import { InspectorFilters } from '@pikku/inspector'
-import { PikkuEventTypes } from '@pikku/core'
+import { PikkuWiringTypes } from '@pikku/core'
 
 export interface PikkuCLICoreOutputFiles {
   // Base directory
@@ -16,39 +16,39 @@ export interface PikkuCLICoreOutputFiles {
   functionsFile: string
   functionsMetaFile: string
 
-  // HTTP routes
-  httpRoutesFile: string
-  httpRoutesMetaFile: string
-  httpRoutesMapDeclarationFile: string
+  // HTTP
+  httpWiringsFile: string
+  httpWiringMetaFile: string
+  httpMapDeclarationFile: string
 
   // Channels
-  channelsFile: string
-  channelsMetaFile: string
+  channelsWiringFile: string
+  channelsWiringMetaFile: string
   channelsMapDeclarationFile: string
 
   // RPC
-  rpcMetaFile: string
+  rpcWiringMetaFile: string
   rpcMapDeclarationFile: string
 
   // Schedulers
-  schedulersFile: string
-  schedulersMetaFile: string
+  schedulersWiringFile: string
+  schedulersWiringMetaFile: string
 
   // Queue processors
-  queueWorkersFile: string
-  queueWorkersMetaFile: string
+  queueWorkersWiringFile: string
+  queueWorkersWiringMetaFile: string
   queueMapDeclarationFile: string
 
   // MCP
-  mcpEndpointsFile: string
-  mcpEndpointsMetaFile: string
+  mcpWiringsFile: string
+  mcpWiringsMetaFile: string
 
   // Services
   servicesFile: string
 
   // Application bootstrap
   bootstrapFile: string
-  bootstrapFiles: Record<PikkuEventTypes, string>
+  bootstrapFiles: Record<PikkuWiringTypes, string>
 }
 
 export type PikkuCLIConfig = {
@@ -68,8 +68,8 @@ export type PikkuCLIConfig = {
   nextHTTPFile?: string
   fetchFile?: string
   websocketFile?: string
-  rpcFile?: string
-  queueFile?: string
+  rpcWiringsFile?: string
+  queueWiringsFile?: string
   mcpJsonFile?: string
 
   openAPI?: {
@@ -87,8 +87,8 @@ const CONFIG_DIR_FILES = [
   'nextHTTPFile',
   'fetchFile',
   'websocketFile',
-  'rpcFile',
-  'queueFile',
+  'rpcWiringsFile',
+  'queueWiringsFile',
   'mcpJsonFile',
 ]
 
@@ -192,28 +192,31 @@ const _getPikkuCLIConfig = async (
       }
 
       // HTTP
-      if (!result.httpRoutesFile) {
-        result.httpRoutesFile = join(httpDir, 'pikku-http-routes.gen.ts')
+      if (!result.httpWiringsFile) {
+        result.httpWiringsFile = join(httpDir, 'pikku-http-wirings.gen.ts')
       }
-      if (!result.httpRoutesMetaFile) {
-        result.httpRoutesMetaFile = join(
+      if (!result.httpWiringMetaFile) {
+        result.httpWiringMetaFile = join(
           httpDir,
-          'pikku-http-routes-meta.gen.ts'
+          'pikku-http-wirings-meta.gen.ts'
         )
       }
-      if (!result.httpRoutesMapDeclarationFile) {
-        result.httpRoutesMapDeclarationFile = join(
+      if (!result.httpMapDeclarationFile) {
+        result.httpMapDeclarationFile = join(
           httpDir,
-          'pikku-http-routes-map.gen.d.ts'
+          'pikku-http-wirings-map.gen.d.ts'
         )
       }
 
       // Channels/WebSocket
-      if (!result.channelsFile) {
-        result.channelsFile = join(channelDir, 'pikku-channels.gen.ts')
+      if (!result.channelsWiringFile) {
+        result.channelsWiringFile = join(channelDir, 'pikku-channels.gen.ts')
       }
-      if (!result.channelsMetaFile) {
-        result.channelsMetaFile = join(channelDir, 'pikku-channels-meta.gen.ts')
+      if (!result.channelsWiringMetaFile) {
+        result.channelsWiringMetaFile = join(
+          channelDir,
+          'pikku-channels-meta.gen.ts'
+        )
       }
       if (!result.channelsMapDeclarationFile) {
         result.channelsMapDeclarationFile = join(
@@ -223,38 +226,47 @@ const _getPikkuCLIConfig = async (
       }
 
       // RPC
-      if (!result.rpcMetaFile) {
-        result.rpcMetaFile = join(rpcDir, 'pikku-rpc-meta.gen.ts')
+      if (!result.rpcWiringMetaFile) {
+        result.rpcWiringMetaFile = join(rpcDir, 'pikku-rpc-wirings-meta.gen.ts')
       }
       if (!result.rpcMapDeclarationFile) {
-        result.rpcMapDeclarationFile = join(rpcDir, 'pikku-rpc-map.gen.ts')
+        result.rpcMapDeclarationFile = join(
+          rpcDir,
+          'pikku-rpc-wirings-map.gen.d.ts'
+        )
       }
 
       // Scheduler
-      if (!result.schedulersFile) {
-        result.schedulersFile = join(schedulerDir, 'pikku-scheduler.gen.ts')
+      if (!result.schedulersWiringFile) {
+        result.schedulersWiringFile = join(
+          schedulerDir,
+          'pikku-schedulers-wirings.gen.ts'
+        )
       }
-      if (!result.schedulersMetaFile) {
-        result.schedulersMetaFile = join(
+      if (!result.schedulersWiringMetaFile) {
+        result.schedulersWiringMetaFile = join(
           schedulerDir,
-          'pikku-scheduler-meta.gen.ts'
+          'pikku-schedulers-wirings-meta.gen.ts'
         )
       }
 
       // Queue
-      if (!result.queueWorkersFile) {
-        result.queueWorkersFile = join(queueDir, 'pikku-queue-workers.gen.ts')
+      if (!result.queueWorkersWiringFile) {
+        result.queueWorkersWiringFile = join(
+          queueDir,
+          'pikku-queue-workers-wirings.gen.ts'
+        )
       }
-      if (!result.queueWorkersMetaFile) {
-        result.queueWorkersMetaFile = join(
+      if (!result.queueWorkersWiringMetaFile) {
+        result.queueWorkersWiringMetaFile = join(
           queueDir,
-          'pikku-queue-workers-meta.gen.ts'
+          'pikku-queue-workers-wirings-meta.gen.ts'
         )
       }
       if (!result.queueMapDeclarationFile) {
         result.queueMapDeclarationFile = join(
           queueDir,
-          'pikku-queue-map.gen.ts'
+          'pikku-queue-workers-wirings-map.gen.d.ts'
         )
       }
 
@@ -269,18 +281,21 @@ const _getPikkuCLIConfig = async (
       }
 
       // MCP
-      if (!result.mcpEndpointsMetaFile) {
-        result.mcpEndpointsMetaFile = join(mcpDir, 'mcp-endpoints-meta.gen.ts')
+      if (!result.mcpWiringsMetaFile) {
+        result.mcpWiringsMetaFile = join(
+          mcpDir,
+          'pikku-mcp-wirings-meta.gen.ts'
+        )
       }
-      if (!result.mcpEndpointsFile) {
-        result.mcpEndpointsFile = join(mcpDir, 'mcp-endpoints.gen.ts')
+      if (!result.mcpWiringsFile) {
+        result.mcpWiringsFile = join(mcpDir, 'pikku-mcp-wirings.gen.ts')
       }
       if (!result.mcpJsonFile) {
-        result.mcpJsonFile = join(mcpDir, 'mcp.gen.json')
+        result.mcpJsonFile = join(mcpDir, 'pikku-mcp.gen.json')
       }
 
       result.bootstrapFiles = result.bootstrapFiles || {}
-      for (const key of Object.keys(PikkuEventTypes)) {
+      for (const key of Object.keys(PikkuWiringTypes)) {
         const eventDir = join(result.outDir, key.toLowerCase())
         result.bootstrapFiles[key] = join(
           eventDir,

package/src/runtimes/nextjs/pikku-command-nextjs.ts

@@ -13,7 +13,7 @@ export const pikkuNext: PikkuCommand = async (
   {
     nextBackendFile,
     nextHTTPFile,
-    httpRoutesMapDeclarationFile,
+    httpMapDeclarationFile,
     packageMappings,
     fetchFile,
     bootstrapFiles,
@@ -72,7 +72,7 @@ export const pikkuNext: PikkuCommand = async (
 
         const routesMapDeclarationPath = getFileImportRelativePath(
           nextBackendFile,
-          httpRoutesMapDeclarationFile,
+          httpMapDeclarationFile,
           packageMappings
         )
 
@@ -89,7 +89,7 @@ export const pikkuNext: PikkuCommand = async (
       if (nextHTTPFile && fetchFile) {
         const routesMapDeclarationPath = getFileImportRelativePath(
           nextHTTPFile,
-          httpRoutesMapDeclarationFile,
+          httpMapDeclarationFile,
           packageMappings
         )
 

package/src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts

@@ -12,7 +12,7 @@ export const serializeNextJsBackendWrapper = (
  * It ensures type safety for route handling methods when integrating with the @pikku/core framework.
  */
 import { PikkuNextJS } from '@pikku/next'
-import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
 
 ${configImport}
 ${singleServicesFactoryImport}
@@ -40,7 +40,7 @@ export const pikku = (_options?: any) => {
    * Makes a dynamic action request for a specified route and method.
    * Dynamic requests may access headers and cookies and are therefore unsuitable for precompile stages.
    *
-   * @template Route - The route key from the RoutesMap.
+   * @template Route - The route key from the HTTPWiringsMap.
    * @template Method - The method key from the specified route.
    * @param route - The route identifier.
    * @param method - The HTTP method to be used for the request.
@@ -48,13 +48,13 @@ export const pikku = (_options?: any) => {
    * @returns A promise that resolves to the output of the route handler.
    */
   const dynamicActionRequest = async <
-    Route extends keyof RoutesMap,
-    Method extends keyof RoutesMap[Route]
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
   >(
     route: Route,
     method: Method,
-    data: RouteHandlerOf<Route, Method>['input'] = null
-  ): Promise<RouteHandlerOf<Route, Method>['output']> => {
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
     return _pikku!.actionRequest(route, method, data as any)
   }
 
@@ -62,7 +62,7 @@ export const pikku = (_options?: any) => {
    * Makes a static action request for a specified route and method.
    * Static requests do not depend on headers or cookies and are suitable for precompile stages.
    *
-   * @template Route - The route key from the RoutesMap.
+   * @template Route - The route key from the HTTPWiringsMap.
    * @template Method - The method key from the specified route.
    * @param route - The route identifier.
    * @param method - The HTTP method to be used for the request.
@@ -70,13 +70,13 @@ export const pikku = (_options?: any) => {
    * @returns A promise that resolves to the output of the route handler.
    */
   const staticActionRequest = async <
-    Route extends keyof RoutesMap,
-    Method extends keyof RoutesMap[Route]
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
   >(
     route: Route,
     method: Method,
-    data: RouteHandlerOf<Route, Method>['input'] = null
-  ): Promise<RouteHandlerOf<Route, Method>['output']> => {
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
     return _pikku!.staticActionRequest(route, method, data as any)
   }
 
@@ -88,10 +88,10 @@ export const pikku = (_options?: any) => {
    * @param data - The input data for the POST request, defaults to null.
    * @returns A promise that resolves to the output of the POST handler.
    */
-  const dynamicPost = <Route extends RoutesWithMethod<'POST'>>(
+  const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'POST'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
     return dynamicActionRequest(route, 'POST', data)
   }
 
@@ -103,10 +103,10 @@ export const pikku = (_options?: any) => {
    * @param data - The input data for the GET request, defaults to null.
    * @returns A promise that resolves to the output of the GET handler.
    */
-  const dynamicGet = <Route extends RoutesWithMethod<'GET'>>(
+  const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'GET'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
     return dynamicActionRequest(route, 'GET', data)
   }
 
@@ -118,10 +118,10 @@ export const pikku = (_options?: any) => {
    * @param data - The input data for the PATCH request, defaults to null.
    * @returns A promise that resolves to the output of the PATCH handler.
    */
-  const dynamicPatch = <Route extends RoutesWithMethod<'PATCH'>>(
+  const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'PATCH'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
     return dynamicActionRequest(route, 'PATCH', data)
   }
 
@@ -133,10 +133,10 @@ export const pikku = (_options?: any) => {
    * @param data - The input data for the DELETE request, defaults to null.
    * @returns A promise that resolves to the output of the DELETE handler.
    */
-  const dynamicDel = <Route extends RoutesWithMethod<'DELETE'>>(
+  const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'DELETE'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
     return dynamicActionRequest(route, 'DELETE', data)
   }
 
@@ -150,10 +150,10 @@ export const pikku = (_options?: any) => {
    * @param data - The input data for the POST request, defaults to null.
    * @returns A promise that resolves to the output of the POST handler.
    */
-  const staticPost = <Route extends RoutesWithMethod<'POST'>>(
+  const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'POST'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
     return staticActionRequest(route, 'POST', data)
   }
 
@@ -165,10 +165,10 @@ export const pikku = (_options?: any) => {
    * @param data - The input data for the GET request, defaults to null.
    * @returns A promise that resolves to the output of the GET handler.
    */
-  const staticGet = <Route extends RoutesWithMethod<'GET'>>(
+  const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'GET'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
     return staticActionRequest(route, 'GET', data)
   }
 

package/src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts

@@ -9,7 +9,7 @@ export const serializeNextJsHTTPWrapper = (
  * It ensures type safety for route handling methods when integrating with the @pikku/core framework.
  */
 import { CorePikkuFetchOptions } from '@pikku/fetch'
-import type { RoutesMap, RouteHandlerOf, RoutesWithMethod } from '${routesMapPath}'
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
 import { PikkuFetch } from '${pikkuFetchImport}'
 
 let _pikku: PikkuFetch | undefined
@@ -25,13 +25,13 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
   }
 
   const dynamicActionRequest = async <
-    Route extends keyof RoutesMap,
-    Method extends keyof RoutesMap[Route]
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
   >(
     route: Route,
     method: Method,
-    data: RouteHandlerOf<Route, Method>['input'] = null
-  ): Promise<RouteHandlerOf<Route, Method>['output']> => {
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
     return (_pikku! as any)[(method as string).toLowerCase()](route, data as any)
   }
 
@@ -39,7 +39,7 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * Makes a static action request for a specified route and method.
    * Static requests do not depend on headers or cookies and are suitable for precompile stages.
    *
-   * @template Route - The route key from the RoutesMap.
+   * @template Route - The route key from the HTTPWiringsMap.
    * @template Method - The method key from the specified route.
    * @param route - The route identifier.
    * @param method - The HTTP method to be used for the request.
@@ -47,13 +47,13 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * @returns A promise that resolves to the output of the route handler.
    */
   const staticActionRequest = async <
-    Route extends keyof RoutesMap,
-    Method extends keyof RoutesMap[Route]
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
   >(
     route: Route,
     method: Method,
-    data: RouteHandlerOf<Route, Method>['input'] = null
-  ): Promise<RouteHandlerOf<Route, Method>['output']> => {
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
     return (_pikku! as any)[(method as string).toLowerCase()](route, data as any)
   }
 
@@ -65,10 +65,10 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * @param data - The input data for the POST request, defaults to null.
    * @returns A promise that resolves to the output of the POST handler.
    */
-  const dynamicPost = <Route extends RoutesWithMethod<'POST'>>(
+  const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'POST'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
     return dynamicActionRequest(route, 'POST', data)
   }
 
@@ -80,10 +80,10 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * @param data - The input data for the GET request, defaults to null.
    * @returns A promise that resolves to the output of the GET handler.
    */
-  const dynamicGet = <Route extends RoutesWithMethod<'GET'>>(
+  const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'GET'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
     return dynamicActionRequest(route, 'GET', data)
   }
 
@@ -95,10 +95,10 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * @param data - The input data for the PATCH request, defaults to null.
    * @returns A promise that resolves to the output of the PATCH handler.
    */
-  const dynamicPatch = <Route extends RoutesWithMethod<'PATCH'>>(
+  const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'PATCH'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'PATCH'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
     return dynamicActionRequest(route, 'PATCH', data)
   }
 
@@ -110,10 +110,10 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * @param data - The input data for the DELETE request, defaults to null.
    * @returns A promise that resolves to the output of the DELETE handler.
    */
-  const dynamicDel = <Route extends RoutesWithMethod<'DELETE'>>(
+  const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'DELETE'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'DELETE'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
     return dynamicActionRequest(route, 'DELETE', data)
   }
 
@@ -127,10 +127,10 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * @param data - The input data for the POST request, defaults to null.
    * @returns A promise that resolves to the output of the POST handler.
    */
-  const staticPost = <Route extends RoutesWithMethod<'POST'>>(
+  const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'POST'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'POST'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
     return staticActionRequest(route, 'POST', data)
   }
 
@@ -142,10 +142,10 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    * @param data - The input data for the GET request, defaults to null.
    * @returns A promise that resolves to the output of the GET handler.
    */
-  const staticGet = <Route extends RoutesWithMethod<'GET'>>(
+  const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: RouteHandlerOf<Route, 'GET'>['input'] = null
-  ): Promise<RouteHandlerOf<Route, 'GET'>['output']> => {
+    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
     return staticActionRequest(route, 'GET', data)
   }
 

package/src/schema-generator.ts

@@ -2,7 +2,7 @@ import { createGenerator, RootlessError } from 'ts-json-schema-generator'
 import { CLILogger, writeFileInDir } from './utils.js'
 import { mkdir, writeFile } from 'fs/promises'
 import { FunctionsMeta, JSONValue } from '@pikku/core'
-import { HTTPRoutesMeta } from '@pikku/core/http'
+import { HTTPWiringsMeta } from '@pikku/core/http'
 import { TypesMap } from '@pikku/inspector'
 
 export async function generateSchemas(
@@ -10,7 +10,7 @@ export async function generateSchemas(
   tsconfig: string,
   typesMap: TypesMap,
   functionMeta: FunctionsMeta,
-  httpRoutesMeta: HTTPRoutesMeta
+  httpWiringsMeta: HTTPWiringsMeta
 ): Promise<Record<string, JSONValue>> {
   const schemasSet = new Set(typesMap.customTypes.keys())
   for (const { inputs, outputs } of Object.values(functionMeta)) {
@@ -22,7 +22,7 @@ export async function generateSchemas(
       }
     }
   }
-  for (const { inputTypes } of httpRoutesMeta) {
+  for (const { inputTypes } of httpWiringsMeta) {
     if (inputTypes?.body) {
       schemasSet.add(inputTypes.body)
     }