@pikku/cli 0.11.0 → 0.11.2

package/dist/src/cli.wiring.js

@@ -1,107 +1,109 @@
-// import { pikkuSchemas } from './functions/wirings/functions/schemas.js'
-// import { pikkuFetch } from './functions/wirings/fetch/index.js'
-// import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js'
-// import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js'
-// import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js'
-// import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js'
-// import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js'
-// import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js'
-// import { all } from './functions/commands/all.js'
-// import { bootstrap } from './functions/commands/bootstrap.js'
+import { pikkuSchemas } from './functions/wirings/functions/schemas.js';
+import { pikkuFetch } from './functions/wirings/fetch/index.js';
+import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js';
+import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js';
+import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js';
+import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js';
+import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js';
+import { all } from './functions/commands/all.js';
+import { bootstrap } from './functions/commands/bootstrap.js';
+import { watch } from './functions/commands/watch.js';
 // import { clientCLIRenderer } from './services.js'
-export {};
-// wireCLI({
-//   program: 'pikku',
-//   description:
-//     'Pikku CLI - Code generation tool for type-safe backend development',
-//   render: clientCLIRenderer,
-//   options: {
-//     config: {
-//       description: 'Path to pikku.config.json file',
-//       short: 'c',
-//     },
-//     logLevel: {
-//       description: 'Set log level',
-//       default: 'info' as const,
-//       short: 'l',
-//     },
-//     userSessionType: {
-//       description:
-//         'Specify which UserSession type to use (when multiple exist)',
-//     },
-//     singletonServicesFactoryType: {
-//       description: 'Specify which singleton services factory to use',
-//     },
-//     sessionServicesFactoryType: {
-//       description: 'Specify which session services factory to use',
-//     },
-//     stateOutput: {
-//       description: 'Save inspector state to JSON file for reuse',
-//     },
-//     stateInput: {
-//       description: 'Load inspector state from JSON file (skips inspection)',
-//     },
-//   },
-//   commands: {
-//     all: pikkuCLICommand({
-//       func: all,
-//       description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
-//       isDefault: true,
-//       options: {
-//         tags: {
-//           description: 'Filter functions by tags (comma-separated)',
-//           short: 't',
-//         },
-//         types: {
-//           description: 'Filter functions by types (comma-separated)',
-//         },
-//         directories: {
-//           description: 'Filter functions by directories (comma-separated)',
-//           short: 'd',
-//         },
-//         httpMethods: {
-//           description: 'Filter HTTP routes by methods (comma-separated)',
-//         },
-//         httpRoutes: {
-//           description: 'Filter HTTP routes by route patterns (comma-separated)',
-//         },
-//         names: {
-//           description: 'Filter functions by name patterns (supports wildcards)',
-//           short: 'n',
-//         },
-//       },
-//     }),
-//     bootstrap: pikkuCLICommand({
-//       func: bootstrap,
-//       description: 'Generate only type files (setup phase only)',
-//     }),
-//     schemas: pikkuCLICommand({
-//       func: pikkuSchemas,
-//       description: 'Generate JSON schemas for function input/output types',
-//     }),
-//     fetch: pikkuCLICommand({
-//       func: pikkuFetch,
-//       description: 'Generate type-safe HTTP fetch client',
-//     }),
-//     websocket: pikkuCLICommand({
-//       func: pikkuWebSocketTyped,
-//       description: 'Generate type-safe WebSocket client',
-//     }),
-//     rpc: pikkuCLICommand({
-//       func: pikkuRPCClient,
-//       description: 'Generate RPC client wrappers',
-//     }),
-//     'queue-service': pikkuCLICommand({
-//       func: pikkuQueueService,
-//       description: 'Generate queue service wrapper',
-//     }),
-//     openapi: pikkuCLICommand({
-//       func: pikkuOpenAPI,
-//       description: 'Generate OpenAPI specification from HTTP routes',
-//     }),
-//     nextjs: pikkuCLICommand({
-//       func: pikkuNext,
-//       description: 'Generate Next.js backend and HTTP wrappers',
-//     }),
-//   },
-// })
+wireCLI({
+    program: 'pikku',
+    description: 'Pikku CLI - Code generation tool for type-safe backend development',
+    // render: clientCLIRenderer,
+    options: {
+        config: {
+            description: 'Path to pikku.config.json file',
+            short: 'c',
+        },
+        logLevel: {
+            description: 'Set log level',
+            default: 'info',
+            short: 'l',
+        },
+        userSessionType: {
+            description: 'Specify which UserSession type to use (when multiple exist)',
+        },
+        singletonServicesFactoryType: {
+            description: 'Specify which singleton services factory to use',
+        },
+        wireServicesFactoryType: {
+            description: 'Specify which wire services factory to use',
+        },
+        stateOutput: {
+            description: 'Save inspector state to JSON file for reuse',
+        },
+        stateInput: {
+            description: 'Load inspector state from JSON file (skips inspection)',
+        },
+    },
+    commands: {
+        all: pikkuCLICommand({
+            func: all,
+            description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
+            isDefault: true,
+            options: {
+                tags: {
+                    description: 'Filter functions by tags (comma-separated)',
+                    short: 't',
+                },
+                types: {
+                    description: 'Filter functions by types (comma-separated)',
+                },
+                directories: {
+                    description: 'Filter functions by directories (comma-separated)',
+                    short: 'd',
+                },
+                httpMethods: {
+                    description: 'Filter HTTP routes by methods (comma-separated)',
+                },
+                httpRoutes: {
+                    description: 'Filter HTTP routes by route patterns (comma-separated)',
+                },
+                names: {
+                    description: 'Filter functions by name patterns (supports wildcards)',
+                    short: 'n',
+                },
+            },
+        }),
+        bootstrap: pikkuCLICommand({
+            func: bootstrap,
+            description: 'Generate only type files (setup phase only)',
+        }),
+        watch: pikkuCLICommand({
+            func: watch,
+            description: 'Watch for file changes and regenerate automatically',
+        }),
+        schemas: pikkuCLICommand({
+            func: pikkuSchemas,
+            description: 'Generate JSON schemas for function input/output types',
+        }),
+        fetch: pikkuCLICommand({
+            func: pikkuFetch,
+            description: 'Generate type-safe HTTP fetch client',
+        }),
+        websocket: pikkuCLICommand({
+            func: pikkuWebSocketTyped,
+            description: 'Generate type-safe WebSocket client',
+        }),
+        rpc: pikkuCLICommand({
+            func: pikkuRPCClient,
+            description: 'Generate RPC client wrappers',
+        }),
+        'queue-service': pikkuCLICommand({
+            func: pikkuQueueService,
+            description: 'Generate queue service wrapper',
+        }),
+        openapi: pikkuCLICommand({
+            func: pikkuOpenAPI,
+            description: 'Generate OpenAPI specification from HTTP routes',
+        }),
+        nextjs: pikkuCLICommand({
+            func: pikkuNext,
+            description: 'Generate Next.js backend and HTTP wrappers',
+        }),
+    },
+});

package/dist/src/functions/commands/all.js

@@ -3,38 +3,79 @@ import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
 import { getFileImportRelativePath } from '../../utils/file-import-path.js';
 import { writeFileInDir } from '../../utils/file-writer.js';
 import { CommandSummary } from '../../utils/command-summary.js';
+// Import all command functions directly
+import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js';
+import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js';
+import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js';
+import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js';
+import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js';
+import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js';
+import { pikkuWorkflowTypes } from '../wirings/workflow/pikku-command-workflow-types.js';
+import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js';
+import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js';
+import { pikkuFunctions } from '../wirings/functions/pikku-command-functions.js';
+import { pikkuMiddleware } from '../wirings/middleware/pikku-command-middleware.js';
+import { pikkuPermissions } from '../wirings/permissions/pikku-command-permissions.js';
+import { pikkuServices } from '../wirings/functions/pikku-command-services.js';
+import { pikkuServiceMetadata } from '../wirings/services/pikku-command-service-metadata.js';
+import { pikkuRPC } from '../wirings/rpc/pikku-command-rpc.js';
+import { pikkuRPCExposedMap, pikkuRPCInternalMap, } from '../wirings/rpc/pikku-command-rpc-map.js';
+import { pikkuPublicRPC } from '../wirings/rpc/pikku-command-public-rpc.js';
+import { pikkuRPCClient } from '../wirings/rpc/pikku-command-rpc-client.js';
+import { pikkuSchemas } from '../wirings/functions/schemas.js';
+import { pikkuHTTP } from '../wirings/http/pikku-command-http-routes.js';
+import { pikkuHTTPMap } from '../wirings/http/pikku-command-http-map.js';
+import { pikkuFetch } from '../wirings/fetch/index.js';
+import { pikkuScheduler } from '../wirings/scheduler/pikku-command-scheduler.js';
+import { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.js';
+import { pikkuRemoteRPC } from '../wirings/rpc/pikku-command-remote-rpc.js';
+import { pikkuWorkflowMap } from '../wirings/workflow/pikku-command-workflow-map.js';
+import { pikkuQueue } from '../wirings/queue/pikku-command-queue.js';
+import { pikkuQueueMap } from '../wirings/queue/pikku-command-queue-map.js';
+import { pikkuQueueService } from '../wirings/queue/pikku-command-queue-service.js';
+import { pikkuChannels } from '../wirings/channels/pikku-command-channels.js';
+import { pikkuChannelsMap } from '../wirings/channels/pikku-command-channels-map.js';
+import { pikkuWebSocketTyped } from '../wirings/channels/pikku-command-websocket-typed.js';
+import { pikkuMCP } from '../wirings/mcp/pikku-command-mcp.js';
+import { pikkuMCPJSON } from '../wirings/mcp/pikku-command-mcp-json.js';
+import { pikkuCLI } from '../wirings/cli/pikku-command-cli.js';
+import { pikkuCLIEntry } from '../wirings/cli/pikku-command-cli-entry.js';
+import { pikkuNext } from '../runtimes/nextjs/pikku-command-nextjs.js';
+import { pikkuOpenAPI } from '../wirings/http/pikku-command-openapi.js';
 export const all = pikkuVoidFunc({
-    func: async ({ logger, config, rpc, getInspectorState }) => {
+    func: async ({ logger, config, getInspectorState }) => {
+        const wire = {};
+        const services = { logger, config, getInspectorState };
         const summary = new CommandSummary('all');
         const allImports = [];
         let typesDeclarationFileExists = true;
         if (!existsSync(config.typesDeclarationFile)) {
             typesDeclarationFileExists = false;
         }
-        await rpc.invoke('pikkuFunctionTypes', null);
+        await pikkuFunctionTypes.func(services, null, wire);
         // This is needed since the wireHTTP function will add the routes to the visitState
         if (!typesDeclarationFileExists) {
             logger.debug(`• Type file first created, inspecting again...`);
             await getInspectorState(true);
         }
         // Generate wiring-specific type files for tree-shaking
-        await rpc.invoke('pikkuFunctionTypesSplit', null);
-        await rpc.invoke('pikkuHTTPTypes', null);
-        await rpc.invoke('pikkuChannelTypes', null);
-        await rpc.invoke('pikkuSchedulerTypes', null);
-        await rpc.invoke('pikkuQueueTypes', null);
-        await rpc.invoke('pikkuWorkflowTypes', null);
-        await rpc.invoke('pikkuMCPTypes', null);
-        await rpc.invoke('pikkuCLITypes', null);
-        const hasFunctionRegistrations = await rpc.invoke('pikkuFunctions', null);
+        await pikkuFunctionTypesSplit.func(services, null, wire);
+        await pikkuHTTPTypes.func(services, null, wire);
+        await pikkuChannelTypes.func(services, null, wire);
+        await pikkuSchedulerTypes.func(services, null, wire);
+        await pikkuQueueTypes.func(services, null, wire);
+        await pikkuWorkflowTypes.func(services, null, wire);
+        await pikkuMCPTypes.func(services, null, wire);
+        await pikkuCLITypes.func(services, null, wire);
+        const hasFunctionRegistrations = await pikkuFunctions.func(services, wire, null);
         // Generate and register middleware
-        const middleware = await rpc.invoke('pikkuMiddleware', null);
+        const middleware = await pikkuMiddleware.func(services, null, wire);
         // Middleware must be imported before functions meta to ensure registration happens first
         if (middleware) {
             allImports.push(config.middlewareFile);
         }
         // Generate and register permissions
-        const permissions = await rpc.invoke('pikkuPermissions', null);
+        const permissions = await pikkuPermissions.func(services, null, wire);
         // Permissions must be imported before functions meta to ensure registration happens first
         if (permissions) {
             allImports.push(config.permissionsFile);
@@ -46,79 +87,78 @@ export const all = pikkuVoidFunc({
             allImports.push(config.functionsFile);
         }
         // Generate services map
-        await rpc.invoke('pikkuServices', null);
-        const hasInternalRPCs = await rpc.invoke('pikkuRPC', null);
-        await rpc.invoke('pikkuRPCInternalMap', null);
-        await rpc.invoke('pikkuRPCExposedMap', null);
-        await rpc.invoke('pikkuRPCClient', null);
+        await pikkuServices.func(services, null, wire);
+        // Generate service metadata JSON files for AI consumption
+        await pikkuServiceMetadata.func(services, null, wire);
+        const hasInternalRPCs = await pikkuRPC.func(services, null, wire);
+        await pikkuRPCInternalMap.func(services, null, wire);
+        await pikkuRPCExposedMap.func(services, null, wire);
+        await pikkuPublicRPC.func(services, null, wire);
+        await pikkuRPCClient.func(services, null, wire);
         if (hasInternalRPCs) {
             allImports.push(config.rpcInternalWiringMetaFile);
         }
-        const schemas = await rpc.invoke('pikkuSchemas', null);
+        const schemas = await pikkuSchemas.func(services, null, wire);
         if (schemas) {
             allImports.push(`${config.schemaDirectory}/register.gen.ts`);
         }
         // Generate HTTP
-        const http = await rpc.invoke('pikkuHTTP', null);
+        const http = await pikkuHTTP.func(services, null, wire);
         if (http) {
-            await rpc.invoke('pikkuHTTPMap', null);
-            await rpc.invoke('pikkuFetch', null);
+            await pikkuHTTPMap.func(services, null, wire);
+            await pikkuFetch.func(services, null, wire);
             allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
         }
         // Generate Scheduler
-        const scheduler = await rpc.invoke('pikkuScheduler', null);
+        const scheduler = await pikkuScheduler.func(services, null, wire);
         if (scheduler) {
             allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
         }
         // Generate Workflows
-        const workflows = await rpc.invoke('pikkuWorkflow', null);
+        const workflows = await pikkuWorkflow.func(services, null, wire);
         // Generate Remote RPC Workers (must be before queue discovery so wireQueueWorker calls are picked up)
-        const remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
+        const remoteRPC = await pikkuRemoteRPC.func(services, null, wire);
         // Reinspect to pick up generated workflow workers and remote RPC workers BEFORE generating maps
         if (workflows || remoteRPC) {
             await getInspectorState(true);
         }
         if (workflows) {
-            await rpc.invoke('pikkuWorkflowMap', null);
+            await pikkuWorkflowMap.func(services, null, wire);
             allImports.push(config.workflowsWiringMetaFile, config.workflowsWiringFile);
         }
-        if (remoteRPC && config.rpc?.remoteRpcWorkersPath) {
-            // Only add to imports if we actually generated the file
-            allImports.push(config.rpc.remoteRpcWorkersPath);
-        }
         // Generate Queues
-        const queues = await rpc.invoke('pikkuQueue', null);
+        const queues = await pikkuQueue.func(services, null, wire);
         if (queues) {
-            await rpc.invoke('pikkuQueueMap', null);
-            await rpc.invoke('pikkuQueueService', null);
+            await pikkuQueueMap.func(services, null, wire);
+            await pikkuQueueService.func(services, null, wire);
             allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
         }
         // Generate Channels
-        const channels = await rpc.invoke('pikkuChannels', null);
+        const channels = await pikkuChannels.func(services, null, wire);
         if (channels) {
-            await rpc.invoke('pikkuChannelsMap', null);
-            await rpc.invoke('pikkuWebSocketTyped', null);
+            await pikkuChannelsMap.func(services, null, wire);
+            await pikkuWebSocketTyped.func(services, null, wire);
             allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
         }
         // Generate MCP
-        const mcp = await rpc.invoke('pikkuMCP', null);
+        const mcp = await pikkuMCP.func(services, null, wire);
         if (mcp) {
-            await rpc.invoke('pikkuMCPJSON', null);
+            await pikkuMCPJSON.func(services, null, wire);
             allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
         }
         // Generate CLI
-        const cli = await rpc.invoke('pikkuCLI', null);
+        const cli = await pikkuCLI.func(services, null, wire);
         if (cli) {
-            await rpc.invoke('pikkuCLIEntry', null);
+            await pikkuCLIEntry.func(services, null, wire);
             allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
         }
         if (config.nextBackendFile || config.nextHTTPFile) {
-            await rpc.invoke('pikkuNext', null);
+            await pikkuNext.func(services, null, wire);
         }
         if (config.openAPI) {
             logger.debug(`• OpenAPI requires a reinspection to pickup new generated types..`);
             await getInspectorState(true);
-            await rpc.invoke('pikkuOpenAPI', null);
+            await pikkuOpenAPI.func(services, null, wire);
         }
         // Generate main bootstrap file (pass all imports directly since this is the main file)
         await writeFileInDir(logger, config.bootstrapFile, allImports

package/dist/src/functions/commands/bootstrap.js

@@ -1,21 +1,33 @@
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+// Import command functions directly
+import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js';
+import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js';
+import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js';
+import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js';
+import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js';
+import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js';
+import { pikkuWorkflowTypes } from '../wirings/workflow/pikku-command-workflow-types.js';
+import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js';
+import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js';
 export const bootstrap = pikkuVoidFunc({
-    func: async ({ logger, config, rpc, getInspectorState }) => {
+    func: async ({ logger, config, getInspectorState }) => {
+        const wire = {};
+        const services = { logger, config, getInspectorState };
         // Initialize inspector state in bootstrap mode with core types only
         // This allows bootstrap to run immediately without inspecting the codebase
         // All subsequent RPC commands will use this cached state
         await getInspectorState(false, false, true);
-        await rpc.invoke('pikkuFunctionTypes', null);
+        await pikkuFunctionTypes.func(services, null, wire);
         // Generate wiring-specific type files for tree-shaking
         // These use the bootstrap mode state with core types
-        await rpc.invoke('pikkuFunctionTypesSplit', null);
-        await rpc.invoke('pikkuHTTPTypes', null);
-        await rpc.invoke('pikkuChannelTypes', null);
-        await rpc.invoke('pikkuSchedulerTypes', null);
-        await rpc.invoke('pikkuQueueTypes', null);
-        await rpc.invoke('pikkuWorkflowTypes', null);
-        await rpc.invoke('pikkuMCPTypes', null);
-        await rpc.invoke('pikkuCLITypes', null);
+        await pikkuFunctionTypesSplit.func(services, null, wire);
+        await pikkuHTTPTypes.func(services, null, wire);
+        await pikkuChannelTypes.func(services, null, wire);
+        await pikkuSchedulerTypes.func(services, null, wire);
+        await pikkuQueueTypes.func(services, null, wire);
+        await pikkuWorkflowTypes.func(services, null, wire);
+        await pikkuMCPTypes.func(services, null, wire);
+        await pikkuCLITypes.func(services, null, wire);
         // Check for critical errors and exit if any were logged
         if (logger.hasCriticalErrors()) {
             process.exit(1);

package/dist/src/functions/commands/watch.js

@@ -1,7 +1,9 @@
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
 import chokidar from 'chokidar';
+import { all } from './all.js';
 export const watch = pikkuVoidFunc({
-    func: async ({ logger, config, rpc }) => {
+    func: async ({ logger, config, getInspectorState }) => {
+        const services = { logger, config, getInspectorState };
         const configWatcher = chokidar.watch(config.srcDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
@@ -18,14 +20,15 @@ export const watch = pikkuVoidFunc({
                 const handle = async () => {
                     try {
                         const start = Date.now();
-                        await rpc.invoke('all', null);
+                        await all.func(services, null, {});
                         logger.info({
                             message: `✓ Generated in ${Date.now() - start}ms`,
                             type: 'timing',
                         });
                     }
                     catch (err) {
-                        logger.error(err);
+                        console.error(err);
+                        logger.error('Error running watch');
                     }
                 };
                 await handle();

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

@@ -7,7 +7,7 @@ import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './
 import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js';
 export const pikkuNext = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, packageMappings, fetchFile, } = config;
+        const { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, rpcMapDeclarationFile, packageMappings, fetchFile, } = config;
         // If both files are undefined, clean up any existing files and return
         if (!nextBackendFile && !nextHTTPFile) {
             logger.info({
@@ -20,31 +20,36 @@ export const pikkuNext = pikkuSessionlessFunc({
         if (nextHTTPFile && !fetchFile) {
             throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
         }
+        if ((nextBackendFile || nextHTTPFile) && !rpcMapDeclarationFile) {
+            throw new Error('rpcMapDeclarationFile is required in pikku config in order for nextJS wrapper to work');
+        }
         if (nextBackendFile) {
             // Check for required types
             checkRequiredTypes(visitState.filesAndMethodsErrors, {
                 config: true,
                 singletonServicesFactory: true,
-                sessionServicesFactory: true,
+                wireServicesFactory: true,
             });
-            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = visitState.filesAndMethods;
+            const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = visitState.filesAndMethods;
             if (!pikkuConfigFactory ||
                 !singletonServicesFactory ||
-                !sessionServicesFactory) {
+                !wireServicesFactory) {
                 throw new Error('Required types not found');
             }
             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 wireServicesImport = `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`;
             const bootstrapPath = getFileImportRelativePath(nextBackendFile, config.bootstrapFile, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
-            const content = serializeNextBackendWrapper(bootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);
+            const content = serializeNextBackendWrapper(bootstrapPath, routesMapDeclarationPath, rpcMapDeclarationPath, pikkuConfigImport, singletonServicesImport, wireServicesImport);
             await writeFileInDir(logger, nextBackendFile, content);
         }
         if (nextHTTPFile && fetchFile) {
             const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpMapDeclarationFile, packageMappings);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, rpcMapDeclarationFile, packageMappings);
             const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
-            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, fetchPath);
             await writeFileInDir(logger, nextHTTPFile, content);
         }
     },

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;
+export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string) => string;