@pikku/cli 0.8.3 → 0.9.1

package/dist/src/wirings/http/serialize-fetch-wrapper.js

@@ -0,0 +1,67 @@
+export const serializeFetchWrapper = (routesMapPath) => {
+    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/dist/src/wirings/http/serialize-typed-http-map.d.ts

@@ -0,0 +1,4 @@
+import { HTTPWiringsMeta } from '@pikku/core/http';
+import { MetaInputTypes, TypesMap } from '@pikku/inspector';
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeTypedHTTPWiringsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes) => string;

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

@@ -1,10 +1,10 @@
 import { serializeImportMap } from '../../serialize-import-map.js';
 import { generateCustomTypes } from '../../utils.js';
-export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
+export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, wiringsMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedRoutes = generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes);
+    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, functionsMeta, typesMap, requiredTypes);
     const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
@@ -14,24 +14,24 @@ ${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, functionsMeta, typesMap, requiredTypes) {
+function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};
     for (const meta of routesMeta) {
@@ -58,11 +58,11 @@ function generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes) {
         };
     }
     // 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/dist/src/{events → wirings}/mcp/pikku-command-mcp.js

@@ -34,9 +34,9 @@ const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMa
         return [];
     }
 };
-export const pikkuMCP = async (logger, { mcpEndpointsFile, mcpEndpointsMetaFile, packageMappings, schemaDirectory }, { mcpEndpoints, functions }) => {
+export const pikkuMCP = async (logger, { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory }, { mcpEndpoints, functions }) => {
     return await logCommandInfoAndTime(logger, 'Finding MCP endpoints', 'Found MCP endpoints', [mcpEndpoints.files.size === 0], async () => {
-        await writeFileInDir(logger, mcpEndpointsFile, serializeFileImports('addMCPResource or addMCPTool', mcpEndpointsFile, mcpEndpoints.files, packageMappings));
+        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
         for (const promptMeta of Object.values(promptsMetaWithArguments)) {
@@ -46,7 +46,7 @@ export const pikkuMCP = async (logger, { mcpEndpointsFile, mcpEndpointsMetaFile,
                 promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);
             }
         }
-        await writeFileInDir(logger, mcpEndpointsMetaFile, `import { pikkuState } from '@pikku/core'
+        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
 pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
 pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})
 pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null, 2)})`);

package/dist/src/wirings/queue/pikku-command-queue-service.js

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

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

@@ -2,9 +2,9 @@ import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '..
 import { serializeQueueMeta } from './serialize-queue-meta.js';
 export const pikkuQueue = async (logger, cliConfig, visitState) => {
     return await logCommandInfoAndTime(logger, 'Finding queues', '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, serializeQueueMeta(queueWorkers.meta));
-        await writeFileInDir(logger, queueWorkersFile, serializeFileImports('addQueueWorkers', queueWorkersFile, queueWorkers.files, packageMappings));
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
     });
 };

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

@@ -2,9 +2,9 @@ import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '..
 import { serializeQueueMeta } from './serialize-queue-meta.js';
 export const pikkuQueue = async (logger, cliConfig, visitState) => {
     return await logCommandInfoAndTime(logger, 'Finding queues', '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, serializeQueueMeta(queueWorkers.meta));
-        await writeFileInDir(logger, queueWorkersFile, serializeFileImports('addQueueWorkers', queueWorkersFile, queueWorkers.files, packageMappings));
+        await writeFileInDir(logger, queueWorkersWiringMetaFile, serializeQueueMeta(queueWorkers.meta));
+        await writeFileInDir(logger, queueWorkersWiringFile, serializeFileImports('addQueueWorkers', queueWorkersWiringFile, queueWorkers.files, packageMappings));
     });
 };

package/dist/src/wirings/rpc/pikku-command-rpc-client.js

@@ -0,0 +1,15 @@
+import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }) => {
+    return await logCommandInfoAndTime(logger, 'Generating RPC wrapper', 'Generated RPC wrapper', [
+        rpcWiringsFile === undefined,
+        "rpcWiringsFile isn't set in the pikku config",
+    ], async () => {
+        if (!rpcWiringsFile) {
+            throw new Error("rpcWiringsFile isn't set in the pikku config");
+        }
+        const rpcMapDeclarationPath = getFileImportRelativePath(rpcWiringsFile, rpcMapDeclarationFile, packageMappings);
+        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
+        await writeFileInDir(logger, rpcWiringsFile, content.join('\n'));
+    });
+};

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

@@ -0,0 +1,6 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+export const pikkuRPC = async (logger, { rpcWiringMetaFile }, { rpc }) => {
+    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
+        await writeFileInDir(logger, rpcWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
+    });
+};

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

@@ -0,0 +1,6 @@
+import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
+export const pikkuRPC = async (logger, { rpcWiringMetaFile }, { rpc }) => {
+    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
+        await writeFileInDir(logger, rpcWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
+    });
+};

package/dist/src/wirings/rpc/serialize-rpc-wrapper.js

@@ -0,0 +1,68 @@
+export const serializeRPCWrapper = (rpcMapPath) => {
+    return `
+import { PikkuFetch } from "./pikku-fetch.gen.js"
+import type { RPCInvoke } from '${rpcMapPath}'
+
+/**
+ * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC) 
+ * to your Pikku server. It wraps the underlying HTTP client and provides a 
+ * simple interface for invoking server-side functions.
+ */
+export class PikkuRPC {
+    /** The underlying HTTP client used for making RPC calls */
+    pikkuFetch = new PikkuFetch()
+
+    /**
+     * Sets a custom PikkuFetch instance to use for RPC calls.
+     * This allows you to configure custom settings or use a shared client instance.
+     * 
+     * @param pikkuFetch - The PikkuFetch instance to use
+     */
+    setPikkuFetch(pikkuFetch: PikkuFetch): void {
+        this.pikkuFetch = pikkuFetch
+    }
+
+    /**
+     * Sets the base server URL for all RPC calls.
+     * 
+     * @param serverUrl - The base URL of your Pikku server (e.g., 'https://api.example.com')
+     */
+    setServerUrl(serverUrl: string): void {
+        this.pikkuFetch.setServerUrl(serverUrl)
+    }
+
+    /**
+     * Sets the JWT token for authorization on all RPC calls.
+     * 
+     * @param jwt - The JWT token to use for authorization, or null to remove authorization
+     */
+    setAuthorizationJWT(jwt: string | null): void {
+        this.pikkuFetch.setAuthorizationJWT(jwt)
+    }
+
+    /**
+     * Sets the API key for authorization on all RPC calls.
+     * 
+     * @param apiKey - The API key to use for authorization, or null to remove the API key
+     */
+    setAPIKey(apiKey: string | null): void {
+        this.pikkuFetch.setAPIKey(apiKey)
+    }
+
+    /**
+     * Invokes a remote procedure call on the server.
+     * This is a generic method that routes to the appropriate server function
+     * based on the function name and passes the provided data.
+     * 
+     * @param name - The name of the server function to invoke
+     * @param data - The data to pass to the server function
+     * @returns A promise that resolves with the function's return value
+     */
+    invoke: RPCInvoke = async (name, data) => {
+       return await this.pikkuFetch.post('/rpc', { name, data })
+    }
+}
+
+export const pikkuRPC = new PikkuRPC();
+`;
+};

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

@@ -2,9 +2,9 @@ import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '..
 import { serializeSchedulerMeta } from './serialize-scheduler-meta.js';
 export const pikkuScheduler = async (logger, cliConfig, visitState) => {
     return await logCommandInfoAndTime(logger, 'Finding scheduled tasks', 'Found scheduled tasks', [visitState.scheduledTasks.files.size === 0], async () => {
-        const { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig;
+        const { schedulersWiringFile, schedulersWiringMetaFile, packageMappings, } = cliConfig;
         const { scheduledTasks } = visitState;
-        await writeFileInDir(logger, schedulersMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
-        await writeFileInDir(logger, schedulersFile, serializeFileImports('addScheduledTasks', schedulersFile, scheduledTasks.files, packageMappings));
+        await writeFileInDir(logger, schedulersWiringMetaFile, serializeSchedulerMeta(scheduledTasks.meta));
+        await writeFileInDir(logger, schedulersWiringFile, serializeFileImports('addScheduledTasks', schedulersWiringFile, scheduledTasks.files, packageMappings));
     });
 };

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/events/channels/pikku-channels.ts","../src/events/channels/pikku-command-channels-map.ts","../src/events/channels/pikku-command-channels.ts","../src/events/channels/pikku-command-websocket-typed.ts","../src/events/channels/serialize-typed-channel-map.ts","../src/events/channels/serialize-websocket-wrapper.ts","../src/events/fetch/index.ts","../src/events/functions/pikku-command-function-types.ts","../src/events/functions/pikku-command-functions.ts","../src/events/functions/pikku-command-services.ts","../src/events/functions/pikku-function-types.ts","../src/events/functions/pikku-functions.ts","../src/events/http/openapi-spec-generator.ts","../src/events/http/pikku-command-http-map.ts","../src/events/http/pikku-command-http-routes.ts","../src/events/http/pikku-command-openapi.ts","../src/events/http/pikku-http-routes.ts","../src/events/http/serialize-fetch-wrapper.ts","../src/events/http/serialize-typed-http-map.ts","../src/events/mcp/pikku-command-mcp-json.ts","../src/events/mcp/pikku-command-mcp.ts","../src/events/mcp/serialize-mcp-json.ts","../src/events/queue/pikku-command-queue-map.ts","../src/events/queue/pikku-command-queue-service.ts","../src/events/queue/pikku-command-queue.ts","../src/events/queue/pikku-queue-map.ts","../src/events/queue/pikku-queue.ts","../src/events/queue/serialize-queue-map.ts","../src/events/queue/serialize-queue-meta.ts","../src/events/queue/serialize-queue-wrapper.ts","../src/events/rpc/pikku-command-rpc-client.ts","../src/events/rpc/pikku-command-rpc-map.ts","../src/events/rpc/pikku-command-rpc.ts","../src/events/rpc/pikku-rpc.ts","../src/events/rpc/serialize-rpc-wrapper.ts","../src/events/rpc/serialize-typed-rpc-map.ts","../src/events/scheduler/pikku-command-scheduler.ts","../src/events/scheduler/serialize-scheduler-meta.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts"],"version":"5.8.3"}
+{"root":["../bin/pikku-all.ts","../bin/pikku-fetch.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-queue-service.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/pikku-cli-config.ts","../src/pikku-command-schemas.ts","../src/schema-generator.ts","../src/schemas.ts","../src/serialize-import-map.ts","../src/serialize-pikku-types.ts","../src/types.ts","../src/utils.ts","../src/runtimes/nextjs/pikku-command-nextjs.ts","../src/runtimes/nextjs/serialize-nextjs-backend-wrapper.ts","../src/runtimes/nextjs/serialize-nextjs-http-wrapper.ts","../src/wirings/channels/pikku-channels.ts","../src/wirings/channels/pikku-command-channels-map.ts","../src/wirings/channels/pikku-command-channels.ts","../src/wirings/channels/pikku-command-websocket-typed.ts","../src/wirings/channels/serialize-typed-channel-map.ts","../src/wirings/channels/serialize-websocket-wrapper.ts","../src/wirings/fetch/index.ts","../src/wirings/functions/pikku-command-function-types.ts","../src/wirings/functions/pikku-command-functions.ts","../src/wirings/functions/pikku-command-services.ts","../src/wirings/functions/pikku-function-types.ts","../src/wirings/functions/pikku-functions.ts","../src/wirings/http/openapi-spec-generator.ts","../src/wirings/http/pikku-command-http-map.ts","../src/wirings/http/pikku-command-http-routes.ts","../src/wirings/http/pikku-command-openapi.ts","../src/wirings/http/pikku-http-routes.ts","../src/wirings/http/serialize-fetch-wrapper.ts","../src/wirings/http/serialize-typed-http-map.ts","../src/wirings/mcp/pikku-command-mcp-json.ts","../src/wirings/mcp/pikku-command-mcp.ts","../src/wirings/mcp/serialize-mcp-json.ts","../src/wirings/queue/pikku-command-queue-map.ts","../src/wirings/queue/pikku-command-queue-service.ts","../src/wirings/queue/pikku-command-queue.ts","../src/wirings/queue/pikku-queue-map.ts","../src/wirings/queue/pikku-queue.ts","../src/wirings/queue/serialize-queue-map.ts","../src/wirings/queue/serialize-queue-meta.ts","../src/wirings/queue/serialize-queue-wrapper.ts","../src/wirings/rpc/pikku-command-rpc-client.ts","../src/wirings/rpc/pikku-command-rpc-map.ts","../src/wirings/rpc/pikku-command-rpc.ts","../src/wirings/rpc/pikku-rpc.ts","../src/wirings/rpc/serialize-rpc-wrapper.ts","../src/wirings/rpc/serialize-typed-rpc-map.ts","../src/wirings/scheduler/pikku-command-scheduler.ts","../src/wirings/scheduler/serialize-scheduler-meta.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.8.3",
+  "version": "0.9.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.8.2",
-    "@pikku/inspector": "^0.8.1",
+    "@pikku/core": "^0.9.1",
+    "@pikku/inspector": "^0.9.1",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/inspector-glob.ts

@@ -16,14 +16,14 @@ export const inspectorGlob = async (
     'Inspected codebase',
     [false],
     async () => {
-      const routeFiles = (
+      const wiringFiles = (
         await Promise.all(
           srcDirectories.map((dir) =>
             glob(`${path.join(rootDir, dir)}/**/*.ts`)
           )
         )
       ).flat()
-      result = await inspect(logger, routeFiles, filters)
+      result = await inspect(logger, wiringFiles, filters)
     }
   )
   return result!

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
         )