@pikku/cli 0.11.1 → 0.11.3

package/dist/src/cli.wiring.js

@@ -9,11 +9,11 @@ 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';
+// import { clientCLIRenderer } from './services.js'
 wireCLI({
     program: 'pikku',
     description: 'Pikku CLI - Code generation tool for type-safe backend development',
-    render: clientCLIRenderer,
+    // render: clientCLIRenderer,
     options: {
         config: {
             description: 'Path to pikku.config.json file',
@@ -30,8 +30,8 @@ wireCLI({
         singletonServicesFactoryType: {
             description: 'Specify which singleton services factory to use',
         },
-        sessionServicesFactoryType: {
-            description: 'Specify which session services factory to use',
+        wireServicesFactoryType: {
+            description: 'Specify which wire services factory to use',
         },
         stateOutput: {
             description: 'Save inspector state to JSON file for reuse',

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

@@ -3,132 +3,203 @@ 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 { 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 { 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 { 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';
+import { pikkuPackage } from '../wirings/package/pikku-command-package.js';
+import { pikkuForgeNodes } from '../wirings/forge/pikku-command-forge-nodes.js';
+import { pikkuForgeTypes } from '../wirings/forge/pikku-command-forge-types.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);
-        // This is needed since the wireHTTP function will add the routes to the visitState
+        await pikkuFunctionTypes.func(services, null, wire);
         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);
-        // Generate and register middleware
-        const middleware = await rpc.invoke('pikkuMiddleware', null);
-        // Middleware must be imported before functions meta to ensure registration happens first
+        await pikkuFunctionTypesSplit.func(services, null, wire);
+        if (!config.externalPackage) {
+            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 pikkuMCPTypes.func(services, null, wire);
+            await pikkuCLITypes.func(services, null, wire);
+        }
+        const hasFunctionRegistrations = await pikkuFunctions.func(services, wire, null);
+        const middleware = await pikkuMiddleware.func(services, null, wire);
         if (middleware) {
             allImports.push(config.middlewareFile);
         }
-        // Generate and register permissions
-        const permissions = await rpc.invoke('pikkuPermissions', null);
-        // Permissions must be imported before functions meta to ensure registration happens first
+        const permissions = await pikkuPermissions.func(services, null, wire);
         if (permissions) {
             allImports.push(config.permissionsFile);
         }
-        // Always import functions meta (needed for all function metadata)
         allImports.push(config.functionsMetaFile);
-        // Only import functionsFile if it was generated (has internal/external RPCs)
         if (hasFunctionRegistrations) {
             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);
-        if (hasInternalRPCs) {
-            allImports.push(config.rpcInternalWiringMetaFile);
+        await pikkuServices.func(services, null, wire);
+        await pikkuServiceMetadata.func(services, null, wire);
+        const hasPackageFactories = await pikkuPackage.func(services, null, wire);
+        if (hasPackageFactories) {
+            allImports.push(config.packageFile);
         }
-        const schemas = await rpc.invoke('pikkuSchemas', null);
+        const hasInternalRPCs = await pikkuRPC.func(services, null, wire);
+        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);
-        if (http) {
-            await rpc.invoke('pikkuHTTPMap', null);
-            await rpc.invoke('pikkuFetch', null);
-            allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
-        }
-        // Generate Scheduler
-        const scheduler = await rpc.invoke('pikkuScheduler', null);
-        if (scheduler) {
-            allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
-        }
-        // Generate Workflows
-        const workflows = await rpc.invoke('pikkuWorkflow', null);
-        // Generate Remote RPC Workers (must be before queue discovery so wireQueueWorker calls are picked up)
-        const remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
-        // Reinspect to pick up generated workflow workers and remote RPC workers BEFORE generating maps
+        await pikkuRPCInternalMap.func(services, null, wire);
+        await pikkuRPCExposedMap.func(services, null, wire);
+        await pikkuPublicRPC.func(services, null, wire);
+        await pikkuRPCClient.func(services, null, wire);
+        await pikkuForgeTypes.func(services, null, wire);
+        if (hasInternalRPCs) {
+            allImports.push(config.rpcInternalWiringMetaFile);
+        }
+        if (!config.externalPackage) {
+            const http = await pikkuHTTP.func(services, null, wire);
+            if (http) {
+                await pikkuHTTPMap.func(services, null, wire);
+                await pikkuFetch.func(services, null, wire);
+                allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
+            }
+            const scheduler = await pikkuScheduler.func(services, null, wire);
+            if (scheduler) {
+                allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
+            }
+        }
+        const workflows = await pikkuWorkflow.func(services, null, wire);
+        let remoteRPC = false;
+        if (!config.externalPackage) {
+            remoteRPC = await pikkuRemoteRPC.func(services, null, wire);
+        }
         if (workflows || remoteRPC) {
             await getInspectorState(true);
         }
         if (workflows) {
-            await rpc.invoke('pikkuWorkflowMap', null);
-            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);
-        if (queues) {
-            await rpc.invoke('pikkuQueueMap', null);
-            await rpc.invoke('pikkuQueueService', null);
-            allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
-        }
-        // Generate Channels
-        const channels = await rpc.invoke('pikkuChannels', null);
-        if (channels) {
-            await rpc.invoke('pikkuChannelsMap', null);
-            await rpc.invoke('pikkuWebSocketTyped', null);
-            allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
-        }
-        // Generate MCP
-        const mcp = await rpc.invoke('pikkuMCP', null);
-        if (mcp) {
-            await rpc.invoke('pikkuMCPJSON', null);
-            allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
-        }
-        // Generate CLI
-        const cli = await rpc.invoke('pikkuCLI', null);
-        if (cli) {
-            await rpc.invoke('pikkuCLIEntry', null);
-            allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
-        }
+            allImports.push(config.workflowsWiringFile);
+        }
+        if (!config.externalPackage) {
+            const queues = await pikkuQueue.func(services, null, wire);
+            if (queues) {
+                await pikkuQueueMap.func(services, null, wire);
+                await pikkuQueueService.func(services, null, wire);
+                allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);
+            }
+            const channels = await pikkuChannels.func(services, null, wire);
+            if (channels) {
+                await pikkuChannelsMap.func(services, null, wire);
+                await pikkuWebSocketTyped.func(services, null, wire);
+                allImports.push(config.channelsWiringMetaFile, config.channelsWiringFile);
+            }
+            const mcp = await pikkuMCP.func(services, null, wire);
+            if (mcp) {
+                await pikkuMCPJSON.func(services, null, wire);
+                allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
+            }
+            const cli = await pikkuCLI.func(services, null, wire);
+            if (cli) {
+                await pikkuCLIEntry.func(services, null, wire);
+                allImports.push(config.cliWiringMetaFile, config.cliWiringsFile);
+            }
+        }
+        await pikkuForgeNodes.func(services, null, wire);
         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);
-        }
-        // Generate main bootstrap file (pass all imports directly since this is the main file)
-        await writeFileInDir(logger, config.bootstrapFile, allImports
-            .map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`)
-            .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
-            .join('\n'));
-        // Get final inspector state and collect stats for summary
+            await pikkuOpenAPI.func(services, null, wire);
+        }
+        const stateBeforeBootstrap = await getInspectorState();
+        const externalPackageBootstraps = [];
+        const usedExternalPackages = {};
+        if (config.externalPackages &&
+            stateBeforeBootstrap.rpc?.usedExternalPackages?.size > 0) {
+            for (const namespace of stateBeforeBootstrap.rpc.usedExternalPackages) {
+                const packageName = config.externalPackages[namespace];
+                if (packageName) {
+                    const packageBootstrap = `${packageName}/.pikku/pikku-bootstrap.gen.js`;
+                    externalPackageBootstraps.push(packageBootstrap);
+                    usedExternalPackages[namespace] = packageName;
+                    logger.debug(`• External package detected: ${namespace} (${packageName})`);
+                }
+            }
+        }
+        const localImports = allImports.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
+        const externalImports = externalPackageBootstraps.map((packagePath) => `import '${packagePath}'`);
+        let externalPackagesRegistration = '';
+        if (Object.keys(usedExternalPackages).length > 0) {
+            externalPackagesRegistration = `
+// Register external package mappings
+import { pikkuState } from '@pikku/core'
+const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
+${Object.entries(usedExternalPackages)
+                .map(([ns, pkg]) => `externalPackages.set('${ns}', '${pkg}')`)
+                .join('\n')}
+`;
+        }
+        const allBootstrapImports = [...localImports, ...externalImports]
+            .sort((a, b) => {
+            const aMeta = a.includes('meta');
+            const bMeta = b.includes('meta');
+            if (aMeta && !bMeta)
+                return -1;
+            if (!aMeta && bMeta)
+                return 1;
+            return 0;
+        })
+            .join('\n') + externalPackagesRegistration;
+        await writeFileInDir(logger, config.bootstrapFile, allBootstrapImports);
         const state = await getInspectorState();
-        if (state.http?.meta)
-            summary.set('httpRoutes', Object.keys(state.http.meta).length);
+        if (state.http?.meta) {
+            const httpRouteCount = Object.values(state.http.meta).reduce((sum, routes) => sum + Object.keys(routes).length, 0);
+            if (httpRouteCount > 0)
+                summary.set('httpRoutes', httpRouteCount);
+        }
         if (state.channels?.meta)
             summary.set('channels', Object.keys(state.channels.meta).length);
         if (state.scheduledTasks?.meta)
@@ -143,7 +214,6 @@ export const all = pikkuVoidFunc({
                 summary.set('mcpEndpoints', mcpTotal);
         }
         if (state.cli?.meta) {
-            // Count total CLI commands across all programs
             const totalCommands = Object.values(state.cli.meta).reduce((sum, program) => sum + (program.commands?.length || 0), 0);
             if (totalCommands > 0)
                 summary.set('cliCommands', totalCommands);
@@ -151,11 +221,19 @@ export const all = pikkuVoidFunc({
         if (state.workflows?.meta) {
             summary.set('workflows', Object.keys(state.workflows.meta).length);
         }
-        // Display summary (unless in silent mode)
+        if (state.forgeNodes?.meta) {
+            const forgeNodesCount = Object.keys(state.forgeNodes.meta).length;
+            if (forgeNodesCount > 0)
+                summary.set('forgeNodes', forgeNodesCount);
+        }
+        if (state.workflows?.graphMeta) {
+            const workflowGraphsCount = Object.keys(state.workflows.graphMeta).length;
+            if (workflowGraphsCount > 0)
+                summary.set('workflowGraphs', workflowGraphsCount);
+        }
         if (!logger.isSilent()) {
             console.log(summary.format());
         }
-        // Check for critical errors and exit if any were logged
         if (logger.hasCriticalErrors()) {
             process.exit(1);
         }

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

@@ -1,22 +1,27 @@
 import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+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 { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.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 }) => {
-        // 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
+    func: async ({ logger, config, getInspectorState }) => {
+        const wire = {};
+        const services = { logger, config, getInspectorState };
         await getInspectorState(false, false, true);
-        await rpc.invoke('pikkuFunctionTypes', null);
-        // 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);
-        // Check for critical errors and exit if any were logged
+        await pikkuFunctionTypes.func(services, null, wire);
+        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 pikkuWorkflow.func(services, null, wire);
+        await pikkuMCPTypes.func(services, null, wire);
+        await pikkuCLITypes.func(services, null, wire);
         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,35 @@ 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;