@pikku/cli 0.11.2 → 0.11.3

package/src/functions/commands/all.ts

@@ -4,14 +4,12 @@ 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'
@@ -33,7 +31,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'
@@ -46,6 +43,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'
 import { PikkuWire } from '@pikku/core'
 
 export const all: any = pikkuVoidFunc({
@@ -62,21 +62,21 @@ export const all: any = pikkuVoidFunc({
 
     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,
@@ -84,117 +84,115 @@ export const all: any = pikkuVoidFunc({
       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)
-    }
-
-    // Generate Scheduler
-    const scheduler = await pikkuScheduler.func(services, null, wire)
-    if (scheduler) {
-      allImports.push(
-        config.schedulersWiringMetaFile,
-        config.schedulersWiringFile
-      )
+    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 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)
+    let remoteRPC = false
+    if (!config.externalPackage) {
+      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 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
-      )
+      allImports.push(config.workflowsWiringFile)
     }
 
-    // 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)
+    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)
+      }
     }
 
-    // Generate CLI
-    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)
@@ -208,23 +206,66 @@ export const all: any = pikkuVoidFunc({
       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')
+    const stateBeforeBootstrap = await getInspectorState()
+    const externalPackageBootstraps: string[] = []
+    const usedExternalPackages: Record<string, string> = {}
+    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}'`
     )
 
-    // Get final inspector state and collect stats for summary
+    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) as Record<string, unknown>[]
+      ).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)
@@ -242,7 +283,6 @@ export const all: any = pikkuVoidFunc({
       if (mcpTotal > 0) summary.set('mcpEndpoints', mcpTotal)
     }
     if (state.cli?.meta) {
-      // Count total CLI commands across all programs
       const totalCommands: number = Object.values(state.cli.meta).reduce(
         (sum: number, program: any) => sum + (program.commands?.length || 0),
         0
@@ -252,13 +292,20 @@ export const all: any = pikkuVoidFunc({
     if (state.workflows?.meta) {
       summary.set('workflows', Object.keys(state.workflows.meta).length)
     }
+    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)
+    }
 
-    // Display summary (unless in silent mode)
     if (!logger.isSilent()) {
       console.log(summary.format())
     }
 
-    // Check for critical errors and exit if any were logged
     if (logger.hasCriticalErrors()) {
       process.exit(1)
     }

package/src/functions/commands/bootstrap.ts

@@ -1,13 +1,11 @@
 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'
 import { PikkuWire } from '@pikku/core'
@@ -17,25 +15,19 @@ export const bootstrap: any = pikkuVoidFunc({
     const wire: PikkuWire = {}
     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/src/functions/runtimes/nextjs/pikku-command-nextjs.ts

@@ -42,7 +42,6 @@ export const pikkuNext: any = pikkuSessionlessFunc<void, void>({
     }
 
     if (nextBackendFile) {
-      // Check for required types
       checkRequiredTypes(visitState.filesAndMethodsErrors, {
         config: true,
         singletonServicesFactory: true,

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

@@ -15,7 +15,7 @@ export const serializeNextJsBackendWrapper = (
 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[]>> }
 
@@ -95,14 +95,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)
   }
 
   /**
@@ -110,14 +112,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)
   }
 
   /**
@@ -125,14 +129,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)
   }
 
   /**
@@ -140,14 +146,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
@@ -157,14 +165,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)
   }
 
   /**
@@ -172,49 +182,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 {