@pikku/cli 0.11.2 → 0.11.3

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

@@ -3,14 +3,12 @@ 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';
@@ -29,7 +27,6 @@ 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';
@@ -42,6 +39,9 @@ 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, getInspectorState }) => {
         const wire = {};
@@ -53,105 +53,99 @@ export const all = pikkuVoidFunc({
             typesDeclarationFileExists = false;
         }
         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 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);
+        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);
-        // Generate and register middleware
         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 pikkuPermissions.func(services, null, wire);
-        // Permissions must be imported before functions meta to ensure registration happens first
         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 pikkuServices.func(services, null, wire);
-        // Generate service metadata JSON files for AI consumption
         await pikkuServiceMetadata.func(services, null, wire);
+        const hasPackageFactories = await pikkuPackage.func(services, null, wire);
+        if (hasPackageFactories) {
+            allImports.push(config.packageFile);
+        }
         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`);
+        }
         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);
         }
-        const schemas = await pikkuSchemas.func(services, null, wire);
-        if (schemas) {
-            allImports.push(`${config.schemaDirectory}/register.gen.ts`);
-        }
-        // Generate HTTP
-        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);
+        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);
+            }
         }
-        // Generate Scheduler
-        const scheduler = await pikkuScheduler.func(services, null, wire);
-        if (scheduler) {
-            allImports.push(config.schedulersWiringMetaFile, config.schedulersWiringFile);
-        }
-        // Generate Workflows
         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 pikkuRemoteRPC.func(services, null, wire);
-        // Reinspect to pick up generated workflow workers and remote RPC workers BEFORE generating maps
+        let remoteRPC = false;
+        if (!config.externalPackage) {
+            remoteRPC = await pikkuRemoteRPC.func(services, null, wire);
+        }
         if (workflows || remoteRPC) {
             await getInspectorState(true);
         }
         if (workflows) {
-            await pikkuWorkflowMap.func(services, null, wire);
-            allImports.push(config.workflowsWiringMetaFile, config.workflowsWiringFile);
-        }
-        // Generate Queues
-        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);
-        }
-        // Generate Channels
-        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);
-        }
-        // Generate MCP
-        const mcp = await pikkuMCP.func(services, null, wire);
-        if (mcp) {
-            await pikkuMCPJSON.func(services, null, wire);
-            allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile);
-        }
-        // Generate CLI
-        const cli = await pikkuCLI.func(services, null, wire);
-        if (cli) {
-            await pikkuCLIEntry.func(services, null, wire);
-            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 pikkuNext.func(services, null, wire);
         }
@@ -160,15 +154,52 @@ export const all = pikkuVoidFunc({
             await getInspectorState(true);
             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
-            .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
+        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)
@@ -183,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);
@@ -191,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,34 +1,27 @@
 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 { 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, 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 pikkuFunctionTypes.func(services, null, wire);
-        // Generate wiring-specific type files for tree-shaking
-        // These use the bootstrap mode state with core types
         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 pikkuWorkflow.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/runtimes/nextjs/pikku-command-nextjs.js

@@ -24,7 +24,6 @@ export const pikkuNext = pikkuSessionlessFunc({
             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,

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

@@ -8,7 +8,7 @@ export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcM
 import { PikkuNextJS } from '@pikku/next'
 import { NextRequest } from 'next/server.js'
 import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
-import type { RPCMap } from '${rpcMapPath}'
+import type { FlattenedRPCMap } from '${rpcMapPath}'
 
 type RouteContext = { params: Promise<Record<string, string | string[]>> }
 
@@ -88,14 +88,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the POST method.
    * @param route - The route identifier.
-   * @param data - The input data for the POST request, defaults to null.
+   * @param data - The input data for the POST request (required if input type is defined).
    * @returns A promise that resolves to the output of the POST handler.
    */
   const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return dynamicActionRequest(route, 'POST', data)
+    return dynamicActionRequest(route, 'POST', args[0] ?? null)
   }
 
   /**
@@ -103,14 +105,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the GET method.
    * @param route - The route identifier.
-   * @param data - The input data for the GET request, defaults to null.
+   * @param data - The input data for the GET request (required if input type is defined).
    * @returns A promise that resolves to the output of the GET handler.
    */
   const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return dynamicActionRequest(route, 'GET', data)
+    return dynamicActionRequest(route, 'GET', args[0] ?? null)
   }
 
   /**
@@ -118,14 +122,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the PATCH method.
    * @param route - The route identifier.
-   * @param data - The input data for the PATCH request, defaults to null.
+   * @param data - The input data for the PATCH request (required if input type is defined).
    * @returns A promise that resolves to the output of the PATCH handler.
    */
   const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'PATCH'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'PATCH'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
-    return dynamicActionRequest(route, 'PATCH', data)
+    return dynamicActionRequest(route, 'PATCH', args[0] ?? null)
   }
 
   /**
@@ -133,14 +139,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the DELETE method.
    * @param route - The route identifier.
-   * @param data - The input data for the DELETE request, defaults to null.
+   * @param data - The input data for the DELETE request (required if input type is defined).
    * @returns A promise that resolves to the output of the DELETE handler.
    */
   const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'DELETE'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'DELETE'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
-    return dynamicActionRequest(route, 'DELETE', data)
+    return dynamicActionRequest(route, 'DELETE', args[0] ?? null)
   }
 
   // Static Requests
@@ -150,14 +158,16 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the POST method.
    * @param route - The route identifier.
-   * @param data - The input data for the POST request, defaults to null.
+   * @param data - The input data for the POST request (required if input type is defined).
    * @returns A promise that resolves to the output of the POST handler.
    */
   const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'POST'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
-    return staticActionRequest(route, 'POST', data)
+    return staticActionRequest(route, 'POST', args[0] ?? null)
   }
 
   /**
@@ -165,49 +175,53 @@ export const pikku = (_options?: any) => {
    *
    * @template Route - The route key with the GET method.
    * @param route - The route identifier.
-   * @param data - The input data for the GET request, defaults to null.
+   * @param data - The input data for the GET request (required if input type is defined).
    * @returns A promise that resolves to the output of the GET handler.
    */
   const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
     route: Route,
-    data: HTTPWiringHandlerOf<Route, 'GET'>['input'] = null
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
   ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
-    return staticActionRequest(route, 'GET', data)
+    return staticActionRequest(route, 'GET', args[0] ?? null)
   }
 
   // RPC Requests
 
-  /**
-   * Type definition for RPC invocation with dynamic context.
-   */
-  type RPCInvoke = <Name extends keyof RPCMap>(
-    name: Name,
-    data: RPCMap[Name]['input']
-  ) => Promise<RPCMap[Name]['output']>
-
   /**
    * Makes a dynamic RPC request.
    *
-   * @template Name - The RPC function name from the RPCMap.
+   * @template Name - The RPC function name from the FlattenedRPCMap.
    * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request.
+   * @param data - The input data for the RPC request (required if input type is defined).
    * @returns A promise that resolves to the output of the RPC handler.
    */
-  const rpc: RPCInvoke = async (name, data) => {
-    return dynamicActionRequest(\`/rpc/\${name}\` as any, 'POST', { data }) as any
+  const rpc = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
+      ? [data?: FlattenedRPCMap[Name]['input']]
+      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   /**
    * Makes a static RPC request.
    * Note: In HTTP wrapper context, both rpc and staticRPC behave the same way.
    *
-   * @template Name - The RPC function name from the RPCMap.
+   * @template Name - The RPC function name from the FlattenedRPCMap.
    * @param name - The RPC function identifier.
-   * @param data - The input data for the RPC request.
+   * @param data - The input data for the RPC request (required if input type is defined).
    * @returns A promise that resolves to the output of the RPC handler.
    */
-  const staticRPC: RPCInvoke = async (name, data) => {
-    return staticActionRequest(\`/rpc/\${name}\` as any, 'POST', { data }) as any
+  const staticRPC = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
+      ? [data?: FlattenedRPCMap[Name]['input']]
+      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   return {