@pikku/cli 0.8.3 → 0.9.1

package/dist/src/pikku-cli-config.d.ts

@@ -1,30 +1,30 @@
-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 {
     outDir?: string;
     schemaDirectory: string;
     typesDeclarationFile: string;
     functionsFile: string;
     functionsMetaFile: string;
-    httpRoutesFile: string;
-    httpRoutesMetaFile: string;
-    httpRoutesMapDeclarationFile: string;
-    channelsFile: string;
-    channelsMetaFile: string;
+    httpWiringsFile: string;
+    httpWiringMetaFile: string;
+    httpMapDeclarationFile: string;
+    channelsWiringFile: string;
+    channelsWiringMetaFile: string;
     channelsMapDeclarationFile: string;
-    rpcMetaFile: string;
+    rpcWiringMetaFile: string;
     rpcMapDeclarationFile: string;
-    schedulersFile: string;
-    schedulersMetaFile: string;
-    queueWorkersFile: string;
-    queueWorkersMetaFile: string;
+    schedulersWiringFile: string;
+    schedulersWiringMetaFile: string;
+    queueWorkersWiringFile: string;
+    queueWorkersWiringMetaFile: string;
     queueMapDeclarationFile: string;
-    mcpEndpointsFile: string;
-    mcpEndpointsMetaFile: string;
+    mcpWiringsFile: string;
+    mcpWiringsMetaFile: string;
     servicesFile: string;
     bootstrapFile: string;
-    bootstrapFiles: Record<PikkuEventTypes, string>;
+    bootstrapFiles: Record<PikkuWiringTypes, string>;
 }
 export type PikkuCLIConfig = {
     $schema?: string;
@@ -39,8 +39,8 @@ export type PikkuCLIConfig = {
     nextHTTPFile?: string;
     fetchFile?: string;
     websocketFile?: string;
-    rpcFile?: string;
-    queueFile?: string;
+    rpcWiringsFile?: string;
+    queueWiringsFile?: string;
     mcpJsonFile?: string;
     openAPI?: {
         outputFile: string;

package/dist/src/pikku-cli-config.js

@@ -1,13 +1,13 @@
 import { join, dirname, resolve, isAbsolute } from 'path';
 import { readdir, readFile } from 'fs/promises';
-import { PikkuEventTypes } from '@pikku/core';
+import { PikkuWiringTypes } from '@pikku/core';
 const CONFIG_DIR_FILES = [
     'nextBackendFile',
     'nextHTTPFile',
     'fetchFile',
     'websocketFile',
-    'rpcFile',
-    'queueFile',
+    'rpcWiringsFile',
+    'queueWiringsFile',
     'mcpJsonFile',
 ];
 export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
@@ -80,48 +80,48 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filter
                 result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
             }
             // 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(httpDir, 'pikku-http-routes-meta.gen.ts');
+            if (!result.httpWiringMetaFile) {
+                result.httpWiringMetaFile = join(httpDir, 'pikku-http-wirings-meta.gen.ts');
             }
-            if (!result.httpRoutesMapDeclarationFile) {
-                result.httpRoutesMapDeclarationFile = join(httpDir, 'pikku-http-routes-map.gen.d.ts');
+            if (!result.httpMapDeclarationFile) {
+                result.httpMapDeclarationFile = join(httpDir, '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(channelDir, 'pikku-channels-map.gen.d.ts');
             }
             // 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(schedulerDir, 'pikku-scheduler-meta.gen.ts');
+            if (!result.schedulersWiringMetaFile) {
+                result.schedulersWiringMetaFile = join(schedulerDir, '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(queueDir, 'pikku-queue-workers-meta.gen.ts');
+            if (!result.queueWorkersWiringMetaFile) {
+                result.queueWorkersWiringMetaFile = join(queueDir, 'pikku-queue-workers-wirings-meta.gen.ts');
             }
             if (!result.queueMapDeclarationFile) {
-                result.queueMapDeclarationFile = join(queueDir, 'pikku-queue-map.gen.ts');
+                result.queueMapDeclarationFile = join(queueDir, 'pikku-queue-workers-wirings-map.gen.d.ts');
             }
             // Services
             if (!result.servicesFile) {
@@ -132,17 +132,17 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filter
                 result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
             }
             // 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, `pikku-bootstrap-${key}.gen.ts`);
             }

package/dist/src/runtimes/nextjs/pikku-command-nextjs.js

@@ -1,7 +1,7 @@
 import { logCommandInfoAndTime, getPikkuFilesAndMethods, getFileImportRelativePath, writeFileInDir, } from '../../utils.js';
 import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js';
 import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js';
-export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options = {}) => {
+export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options = {}) => {
     return await logCommandInfoAndTime(logger, 'Generating nextjs wrapper', 'Generated nextjs wrapper', [
         nextBackendFile === undefined && nextHTTPFile === undefined,
         'nextjs outfile is not defined',
@@ -22,12 +22,12 @@ export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpRou
             const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
             const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
             const httpBootstrapPath = getFileImportRelativePath(nextBackendFile, bootstrapFiles.http, packageMappings);
-            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpRoutesMapDeclarationFile, packageMappings);
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
             const content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
             await writeFileInDir(logger, nextBackendFile, content);
         }
         if (nextHTTPFile && fetchFile) {
-            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
+            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpMapDeclarationFile, packageMappings);
             const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
             const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
             await writeFileInDir(logger, nextHTTPFile, content);

package/dist/src/runtimes/nextjs/serialize-nextjs-backend-wrapper.js

@@ -6,7 +6,7 @@ export const serializeNextJsBackendWrapper = (httpBootstrapPath, routesMapPath,
  * 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}
@@ -34,7 +34,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.
@@ -42,13 +42,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)
   }
 
@@ -56,7 +56,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.
@@ -64,13 +64,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)
   }
 
@@ -82,10 +82,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)
   }
 
@@ -97,10 +97,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)
   }
 
@@ -112,10 +112,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)
   }
 
@@ -127,10 +127,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)
   }
 
@@ -144,10 +144,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)
   }
 
@@ -159,10 +159,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/dist/src/runtimes/nextjs/serialize-nextjs-http-wrapper.js

@@ -6,7 +6,7 @@ export const serializeNextJsHTTPWrapper = (routesMapPath, pikkuFetchImport) => {
  * 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
@@ -22,13 +22,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)
   }
 
@@ -36,7 +36,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.
@@ -44,13 +44,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)
   }
 
@@ -62,10 +62,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)
   }
 
@@ -77,10 +77,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)
   }
 
@@ -92,10 +92,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)
   }
 
@@ -107,10 +107,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)
   }
 
@@ -124,10 +124,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)
   }
 
@@ -139,10 +139,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/dist/src/schema-generator.d.ts

@@ -1,6 +1,6 @@
 import { CLILogger } from './utils.js';
 import { FunctionsMeta, JSONValue } from '@pikku/core';
-import { HTTPRoutesMeta } from '@pikku/core/http';
+import { HTTPWiringsMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
+export declare function generateSchemas(logger: CLILogger, tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpWiringsMeta: HTTPWiringsMeta): Promise<Record<string, JSONValue>>;
 export declare function saveSchemas(logger: CLILogger, schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/schema-generator.js

@@ -1,7 +1,7 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
 import { writeFileInDir } from './utils.js';
 import { mkdir, writeFile } from 'fs/promises';
-export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpRoutesMeta) {
+export async function generateSchemas(logger, tsconfig, typesMap, functionMeta, httpWiringsMeta) {
     const schemasSet = new Set(typesMap.customTypes.keys());
     for (const { inputs, outputs } of Object.values(functionMeta)) {
         const types = [...(inputs || []), ...(outputs || [])];
@@ -12,7 +12,7 @@ export async function generateSchemas(logger, tsconfig, typesMap, functionMeta,
             }
         }
     }
-    for (const { inputTypes } of httpRoutesMeta) {
+    for (const { inputTypes } of httpWiringsMeta) {
         if (inputTypes?.body) {
             schemasSet.add(inputTypes.body);
         }