@pikku/cli 0.8.2 → 0.9.0

package/dist/src/events/http/openapi-spec-generator.d.ts

@@ -1,4 +1,4 @@
-import { FunctionsMeta, HTTPRoutesMeta } from '@pikku/core';
+import { FunctionsMeta, HTTPWiringsMeta } from '@pikku/core';
 interface OpenAPISpec {
     openapi: string;
     info: {
@@ -75,5 +75,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

package/dist/src/events/http/pikku-command-http-map.js

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

package/dist/src/events/http/pikku-command-http-routes.js

@@ -1,9 +1,9 @@
 import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
 export const pikkuHTTP = async (logger, cliConfig, visitState) => {
     return await logCommandInfoAndTime(logger, 'Finding HTTP routes', '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, serializeFileImports('addHTTPRoute', httpRoutesFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
     });
 };

package/dist/src/events/http/pikku-command-nextjs.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommand } from '../../types.js';
+export declare const pikkuNext: PikkuCommand;

package/dist/src/events/http/pikku-command-nextjs.js

@@ -0,0 +1,36 @@
+import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../../runtimes/nextjs/serialize-nextjs-backend-wrapper.js';
+import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../../runtimes/nextjs/serialize-nextjs-http-wrapper.js';
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const pikkuNext = async (logger, { nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options = {}) => {
+    return await logCommandInfoAndTime(logger, 'Generating nextjs wrapper', 'Generated nextjs wrapper', [
+        nextBackendFile === undefined && nextHTTPFile === undefined,
+        'nextjs outfile is not defined',
+    ], async () => {
+        if (!nextBackendFile && !nextHTTPFile) {
+            throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
+        }
+        if (nextHTTPFile && !fetchFile) {
+            throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
+        }
+        if (nextBackendFile) {
+            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, nextBackendFile, options, {
+                config: true,
+                singletonServicesFactory: true,
+                sessionServicesFactory: true,
+            });
+            const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
+            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 content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+            await writeFileInDir(logger, nextBackendFile, content);
+        }
+        if (nextHTTPFile && fetchFile) {
+            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
+            const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
+            await writeFileInDir(logger, nextHTTPFile, content);
+        }
+    });
+};

package/dist/src/events/http/pikku-http-routes.js

@@ -1,9 +1,9 @@
 import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
 export const pikkuHTTP = async (logger, cliConfig, visitState) => {
     return await logCommandInfoAndTime(logger, 'Finding HTTP routes', '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, serializeFileImports('addHTTPRoute', httpRoutesFile, http.files, packageMappings));
-        await writeFileInDir(logger, httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
+        await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
     });
 };

package/dist/src/events/http/serialize-typed-http-map.d.ts

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

package/dist/src/events/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) {

package/dist/src/events/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/events/queue/pikku-command-queue-service.js

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

package/dist/src/events/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/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/events/rpc/index.d.ts

@@ -0,0 +1,2 @@
+import { PikkuCommandWithoutState } from '../../types.js';
+export declare const pikkuRPCClient: PikkuCommandWithoutState;

package/dist/src/events/rpc/index.js

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

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

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

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

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

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

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

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

@@ -3,22 +3,61 @@ export const serializeRPCWrapper = (rpcMapPath) => {
 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)
     }
 
-    // Generic RPC invoke method
+    /**
+     * 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 })
     }

package/dist/src/events/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/src/inspector-glob.js

@@ -5,8 +5,8 @@ import { logCommandInfoAndTime } from './utils.js';
 export const inspectorGlob = async (logger, rootDir, srcDirectories, filters) => {
     let result;
     await logCommandInfoAndTime(logger, 'Inspecting codebase', 'Inspected codebase', [false], async () => {
-        const routeFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
-        result = await inspect(logger, routeFiles, filters);
+        const wiringFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
+        result = await inspect(logger, wiringFiles, filters);
     });
     return result;
 };

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);