@pikku/cli 0.9.16-next.0 → 0.10.0

package/src/functions/wirings/channels/serialize-channel-types.ts

@@ -3,14 +3,14 @@
  */
 export const serializeChannelTypes = (functionTypesImportPath: string) => {
   return `/**
- * This file was generated by the @pikku/cli
+
  * Channel-specific type definitions for tree-shaking optimization
  */
 
 import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
 import { CorePikkuFunctionConfig } from '@pikku/core'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -19,64 +19,63 @@ import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMid
  * @template ChannelData - Type of data exchanged through the channel
  * @template Channel - String literal type for the channel name
  */
-type ChannelWiringFunction<I, O, C = {}> = PikkuFunctionSessionless<I, O, C> | PikkuFunction<I, O, C>
-type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<ChannelData, Channel, ChannelWiringFunction<void, unknown> | ChannelWiringFunction<void, unknown, ChannelData>, ChannelWiringFunction<void, void> | ChannelWiringFunction<void, void, ChannelData>, ChannelWiringFunction<any, any> | ChannelWiringFunction<any, any, ChannelData>, PikkuPermission, PikkuMiddleware>
+type ChannelWiring<ChannelData, Channel extends string> = CoreChannel<
+  ChannelData,
+  Channel,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, any, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, ChannelData>, PikkuPermission<void>, PikkuMiddleware>,
+  CorePikkuFunctionConfig<PikkuFunctionSessionless<any, any, ChannelData>, PikkuPermission<any>, PikkuMiddleware>,
+  PikkuPermission,
+  PikkuMiddleware
+>
 
 /**
  * Creates a function that handles WebSocket channel connections.
  * Called when a client connects to a channel.
  *
  * @template Out - Output type for connection response
- * @template ChannelData - Type of data associated with the channel
  * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
+ * @returns The normalized configuration object
  */
-export const pikkuChannelConnectionFunc = <Out = unknown, ChannelData = unknown>(
+export const pikkuChannelConnectionFunc = <Out = unknown>(
   func:
-    | PikkuFunctionSessionless<void, Out, ChannelData>
-    | {
-        func: PikkuFunctionSessionless<void, Out, ChannelData>
-        name?: string
-      }
+    | PikkuFunctionSessionless<void, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, Out, unknown>, PikkuPermission<void>, PikkuMiddleware>
 ) => {
-  return typeof func === 'function' ? func : func.func
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
  * Creates a function that handles WebSocket channel disconnections.
  * Called when a client disconnects from a channel.
  *
- * @template ChannelData - Type of data associated with the channel
  * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
+ * @returns The normalized configuration object
  */
-export const pikkuChannelDisconnectionFunc = <ChannelData = unknown>(
+export const pikkuChannelDisconnectionFunc = (
   func:
-    | PikkuFunctionSessionless<void, void, ChannelData>
-    | {
-        func: PikkuFunction<void, void, ChannelData>
-        name?: string
-      }
+    | PikkuFunctionSessionless<void, void, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void, unknown>, PikkuPermission<void>, PikkuMiddleware>
 ) => {
-  return typeof func === 'function' ? func : func.func
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
  * Creates a function that handles WebSocket channel messages.
  * Called when a message is received on a channel.
+ * This is the same as pikkuSessionlessFunc but with ChannelData = unknown by default.
  *
  * @template In - Input type for channel messages
  * @template Out - Output type for channel responses
- * @template ChannelData - Type of data associated with the channel
  * @param func - Function definition, either direct function or configuration object
- * @returns The unwrapped function for internal use
+ * @returns The normalized configuration object
  */
-export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unknown>(
+export const pikkuChannelFunc = <In, Out = unknown>(
   func:
-    | PikkuFunctionSessionless<In, Out, ChannelData>
-    | CorePikkuFunctionConfig<PikkuFunction<In, Out, ChannelData>, PikkuPermission<In>>
+    | PikkuFunctionSessionless<In, Out, unknown>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out, unknown>, PikkuPermission<In>, PikkuMiddleware>
 ) => {
-  return typeof func === 'function' ? func : func.func
+  return typeof func === 'function' ? { func } : func
 }
 
 /**

package/src/functions/wirings/channels/serialize-typed-channel-map.ts

@@ -17,7 +17,10 @@ export const serializeTypedChannelsMap = (
   )
   typesMap.customTypes.forEach(({ references }) => {
     for (const reference of references) {
-      requiredTypes.add(reference)
+      // Skip __object types (placeholder types for invalid/broken functions)
+      if (reference !== '__object' && !reference.startsWith('__object_')) {
+        requiredTypes.add(reference)
+      }
     }
   })
   const imports = serializeImportMap(

package/src/functions/wirings/cli/pikku-command-cli-entry.ts

@@ -5,7 +5,13 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { join } from 'node:path'
 import { serializeLocalCLIBootstrap } from './serialize-local-cli-bootstrap.js'
 import { serializeChannelCLI } from './serialize-channel-cli.js'
-import { serializeChannelCLIClient } from './serialize-channel-cli-client.js'
+import {
+  serializeChannelCLIClient,
+  collectRendererNames,
+} from './serialize-channel-cli-client.js'
+import { existsSync } from 'fs'
+import { rm } from 'fs/promises'
+import { ErrorCode } from '@pikku/inspector'
 
 export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config, getInspectorState }) => {
@@ -28,7 +34,7 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
     for (const [programName, entrypointConfigs] of Object.entries(
       config.cli.entrypoints
     )) {
-      const programMeta = visitState.cli.meta[programName]
+      const programMeta = visitState.cli.meta.programs[programName]
 
       if (!programMeta) {
         logger.warn(
@@ -86,13 +92,55 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
           if (channelClientPath) {
             const channelClientFile = join(config.rootDir, channelClientPath)
 
+            // Validate that renderers don't depend on services (client-side renderers can't access server services)
+            const rendererNames = collectRendererNames(programMeta)
+            const problematicRenderers: Array<{
+              name: string
+              services: string[]
+            }> = []
+
+            for (const rendererName of rendererNames) {
+              const rendererMeta = visitState.cli.meta.renderers[rendererName]
+              if (rendererMeta?.services?.services?.length > 0) {
+                problematicRenderers.push({
+                  name: rendererName,
+                  services: rendererMeta.services.services,
+                })
+              }
+            }
+
+            // If any renderers depend on services, abort client generation
+            if (problematicRenderers.length > 0) {
+              const details = problematicRenderers
+                .map(
+                  (r) => `  - ${r.name} depends on: ${r.services.join(', ')}`
+                )
+                .join('\n')
+
+              logger.critical(
+                ErrorCode.CLI_CLIENTSIDE_RENDERER_HAS_SERVICES,
+                `Cannot generate CLI channel client for '${programName}': renderers cannot depend on services (client-side execution)\n${details}\n\nRenderers used in CLI-over-channel must be service-free since they execute on the client.`
+              )
+
+              // Delete existing client file if it exists
+              if (existsSync(channelClientFile)) {
+                await rm(channelClientFile)
+                logger.debug(
+                  `Deleted existing CLI channel client: ${channelClientFile}`
+                )
+              }
+
+              continue
+            }
+
             const clientCode = serializeChannelCLIClient(
               programName,
               programMeta,
               channelClientFile,
               config,
-              config.bootstrapFiles.cli,
-              channelRoute
+              config.bootstrapFile,
+              channelRoute,
+              visitState.cli.meta.renderers
             )
 
             await writeFileInDir(logger, channelClientFile, clientCode)
@@ -163,11 +211,6 @@ export const pikkuCLIEntry: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Serializing CLI',
       commandEnd: 'Serialized CLI',
-      skipCondition: async ({ getInspectorState }) => {
-        const visitState = await getInspectorState()
-        return visitState.cli.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/cli/pikku-command-cli-types.ts

@@ -43,8 +43,6 @@ export const pikkuCLITypes: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating CLI types',
       commandEnd: 'Created CLI types',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/cli/pikku-command-cli.ts

@@ -34,8 +34,6 @@ export const pikkuCLI: any = pikkuSessionlessFunc<void, boolean | undefined>({
     logCommandInfoAndTime({
       commandStart: 'Finding CLI commands',
       commandEnd: 'Found CLI commands',
-      skipCondition: false,
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/cli/serialize-channel-cli-client.ts

@@ -1,7 +1,73 @@
-import { CLIProgramMeta } from '@pikku/core'
+import { CLIProgramMeta, CLICommandMeta } from '@pikku/core/cli'
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 import { Config } from '../../../../types/application-types.js'
 
+/**
+ * Collect all unique renderer names from CLI metadata (populated by inspector)
+ */
+export function collectRendererNames(programMeta: CLIProgramMeta): Set<string> {
+  const rendererNames = new Set<string>()
+
+  // Add program-level default renderer
+  if (programMeta.defaultRenderName) {
+    rendererNames.add(programMeta.defaultRenderName)
+  }
+
+  // Recursively collect renderer names from commands
+  function collectFromCommand(command: CLICommandMeta): void {
+    if (command.renderName) {
+      rendererNames.add(command.renderName)
+    }
+
+    // Recursively process subcommands
+    if (command.subcommands) {
+      for (const subCommand of Object.values(command.subcommands)) {
+        collectFromCommand(subCommand)
+      }
+    }
+  }
+
+  // Process all commands
+  for (const command of Object.values(programMeta.commands)) {
+    collectFromCommand(command)
+  }
+
+  return rendererNames
+}
+
+/**
+ * Build a renderers map for CLI commands
+ */
+function buildRenderersMap(programMeta: CLIProgramMeta): string {
+  const entries: string[] = []
+
+  // Build map entries for each command that has a renderer
+  function addCommandRenderer(command: CLICommandMeta, path: string[]): void {
+    const commandId = path.join('.')
+    if (command.renderName) {
+      entries.push(`    '${commandId}': ${command.renderName}`)
+    }
+
+    // Recursively process subcommands
+    if (command.subcommands) {
+      for (const [subName, subCommand] of Object.entries(command.subcommands)) {
+        addCommandRenderer(subCommand, [...path, subName])
+      }
+    }
+  }
+
+  // Process all commands
+  for (const [commandName, command] of Object.entries(programMeta.commands)) {
+    addCommandRenderer(command, [commandName])
+  }
+
+  if (entries.length === 0) {
+    return '{}'
+  }
+
+  return `{\n${entries.join(',\n')}\n  }`
+}
+
 /**
  * Serializes a CLI-over-Channel client bootstrap file
  * Similar to local CLI bootstrap but uses WebSocket connection
@@ -12,7 +78,8 @@ export function serializeChannelCLIClient(
   clientFile: string,
   config: Config,
   cliBootstrapPath: string,
-  channelRoute?: string
+  channelRoute?: string,
+  renderersMeta?: Record<string, any>
 ): string {
   const capitalizedName =
     programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '')
@@ -25,16 +92,48 @@ export function serializeChannelCLIClient(
     config.packageMappings
   )
 
-  // TODO: Collect renderer imports and create renderers map
-  // For now, renderers are not implemented
+  // Collect all unique renderer names from CLI metadata (populated by inspector)
+  const rendererNames = collectRendererNames(programMeta)
 
-  return `/**
- * This file was generated by the @pikku/cli
- */
+  // Generate renderer imports from their source files
+  let rendererImports = ''
+  if (rendererNames.size > 0 && renderersMeta) {
+    const importsByFile = new Map<string, string[]>()
+
+    for (const rendererName of rendererNames) {
+      const meta = renderersMeta[rendererName]
+      if (meta?.exportedName && meta?.filePath) {
+        const relativePath = getFileImportRelativePath(
+          clientFile,
+          meta.filePath,
+          config.packageMappings
+        )
+        if (!importsByFile.has(relativePath)) {
+          importsByFile.set(relativePath, [])
+        }
+        importsByFile.get(relativePath)!.push(meta.exportedName)
+      }
+    }
+
+    // Generate import statements
+    for (const [path, names] of importsByFile) {
+      rendererImports += `import { ${names.join(', ')} } from '${path}'\n`
+    }
+  }
+
+  // Build renderers map
+  const renderersMap = buildRenderersMap(programMeta)
+
+  // Determine default renderer
+  const defaultRendererCode = programMeta.defaultRenderName
+    ? `,\n    defaultRenderer: ${programMeta.defaultRenderName}`
+    : ''
+
+  return `
 import { executeCLIViaChannel } from '@pikku/core/cli/channel'
 import { CorePikkuWebsocket } from '@pikku/websocket'
 import '${bootstrapImportPath}'
-
+${rendererImports}
 /**
  * ${capitalizedName} CLI Client (via WebSocket Channel)
  * Executes CLI commands over a WebSocket connection
@@ -46,14 +145,14 @@ export async function ${capitalizedName}CLIClient(
   // Create WebSocket connection
   const pikkuWS = new CorePikkuWebsocket(url)
 
-  // TODO: Import and register renderers when renderer tracking is implemented
-  const renderers = {}
+  // Register renderers for CLI commands
+  const renderers = ${renderersMap}
 
   await executeCLIViaChannel({
     programName: '${programName}',
     pikkuWS,
     args,
-    renderers,
+    renderers${defaultRendererCode},
   })
 }
 
@@ -63,7 +162,7 @@ export default ${capitalizedName}CLIClient
 // For direct execution (if this file is run directly)
 if (import.meta.url === \`file://\${process.argv[1]}\`) {
   const url = process.env.PIKKU_WS_URL || 'ws://localhost:3000${finalChannelRoute}'
-  ${capitalizedName}CLIClient(url).catch(error => {
+  ${capitalizedName}CLIClient(url, process.argv.slice(2)).catch(error => {
     console.error('Fatal error:', error.message)
     process.exit(1)
   })

package/src/functions/wirings/cli/serialize-channel-cli.ts

@@ -1,4 +1,4 @@
-import { CLIProgramMeta } from '@pikku/core'
+import { CLIProgramMeta } from '@pikku/core/cli'
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 /**
@@ -74,44 +74,23 @@ export function serializeChannelCLI(
     })
     .join('\n')
 
-  // Get relative paths to type files
+  // Get relative path to channel types file
   const channelTypesPath = getFileImportRelativePath(
     channelFile,
     channelTypesFile,
     packageMappings
   )
-  const functionTypesPath = getFileImportRelativePath(
-    channelFile,
-    functionTypesFile,
-    packageMappings
-  )
 
   return `/**
- * This file was generated by the @pikku/cli
  * WebSocket channel backend for '${programName}' CLI commands
  */
 import { wireChannel } from '${channelTypesPath}'
-import { PikkuMiddleware } from '${functionTypesPath}'
 ${imports}
 
-// Middleware to close channel after command execution
-const closeAfterExecution: PikkuMiddleware = async (_services, interaction, next) => {
-  try {
-    const result = await next()
-    return result
-  } finally {
-    // Close the channel after function completes
-    if (interaction.channel) {
-      await interaction.channel.close()
-    }
-  }
-}
-
 wireChannel({
   name: '${finalChannelName}',
   route: '${finalChannelRoute}',
   auth: false,
-  middleware: [closeAfterExecution],
   onMessageWiring: {
     command: {
 ${commandEntries}

package/src/functions/wirings/cli/serialize-cli-types.ts

@@ -9,11 +9,11 @@ export const serializeCLITypes = (
   singletonServicesTypeName: string
 ) => {
   return `/**
- * This file was generated by the @pikku/cli
+
  * CLI-specific type definitions for tree-shaking optimization
  */
 
-import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core'
+import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/cli'
 import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
@@ -34,12 +34,7 @@ type PikkuCLIRender<Data, RequiredServices extends SingletonServices = Singleton
  * CLI command configuration with project-specific types.
  * Uses CoreCLICommandConfig from @pikku/core with local middleware and render types.
  */
-type CLICommandConfig<Func extends PikkuFunctionConfig<any, any>> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>>
-
-/**
- * Result type for CLI command configuration
- */
-type CLICommandResult<Func extends PikkuFunctionConfig<any, any>> = CLICommandConfig<Func>
+type CLICommandConfig<Func extends PikkuFunctionConfig<In, Out>, In = any, Out = any, Params extends string = string> = CoreCLICommandConfig<Func, PikkuMiddleware, PikkuCLIRender<any>, Params>
 
 /**
  * Type definition for CLI applications with commands and global options.
@@ -47,7 +42,7 @@ type CLICommandResult<Func extends PikkuFunctionConfig<any, any>> = CLICommandCo
  * @template Commands - Type describing the command structure
  * @template GlobalOptions - Type for global CLI options
  */
-type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>
+type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions> = CoreCLI<Commands, GlobalOptions, PikkuMiddleware, PikkuCLIRender<any>>
 
 /**
  * Registers a CLI application with the Pikku framework.
@@ -57,7 +52,7 @@ type CLIWiring<Commands extends Record<string, CoreCLICommandConfig<any, PikkuMi
  * @template GlobalOptions - Type for global CLI options
  * @param cli - CLI definition with program name, commands, and global options
  */
-export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>>>, GlobalOptions>(
+export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any, PikkuMiddleware, PikkuCLIRender<any>, any>>, GlobalOptions>(
   cli: CLIWiring<Commands, GlobalOptions>
 ) => {
   wireCLICore(cli as any)
@@ -67,13 +62,17 @@ export const wireCLI = <Commands extends Record<string, CoreCLICommandConfig<any
  * Creates a CLI command definition with automatic option inference from the function's input type.
  * This allows TypeScript to automatically derive CLI options from the function signature.
  *
- * @template Func - The Pikku function config type to create a CLI command for
+ * @template FuncConfig - The Pikku function config type
+ * @template Params - The parameters string literal type
  * @param config - CLI command configuration
  * @returns CLI command configuration with inferred types
  */
-export const pikkuCLICommand = <Func extends PikkuFunctionConfig<any, any>>(
-  config: CLICommandConfig<Func>
-): CLICommandResult<Func> => {
+export const pikkuCLICommand = <
+  FuncConfig extends PikkuFunctionConfig<any, any>,
+  Params extends string
+>(
+  config: CLICommandConfig<FuncConfig, any, any, Params>
+): CoreCLICommandConfig<FuncConfig, PikkuMiddleware, PikkuCLIRender<any>, string> => {
   return config as any
 }
 `

package/src/functions/wirings/cli/serialize-local-cli-bootstrap.ts

@@ -34,14 +34,12 @@ export function serializeLocalCLIBootstrap(
   )
   const cliBootstrapPath = getFileImportRelativePath(
     bootstrapFile,
-    config.bootstrapFiles.cli,
+    config.bootstrapFile,
     config.packageMappings
   )
 
-  return `/**
- * This file was generated by the @pikku/cli
- */
-import { executeCLI } from '@pikku/core'
+  return `
+import { executeCLI, CLIError } from '@pikku/core/cli'
 import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
 import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
@@ -51,14 +49,21 @@ import '${cliBootstrapPath}'
  * ${capitalizedName} CLI function
  * Handles command line arguments and executes the appropriate function
  */
-export async function ${capitalizedName}CLI(args?: string[]): Promise<void> {
-  await executeCLI({
-    programName: '${programName}',
-    args,
-    createConfig,
-    createSingletonServices,
-    createSessionServices,
-  })
+export async function ${capitalizedName}CLI(args: string[]): Promise<void> {
+  try {
+    await executeCLI({
+      programName: '${programName}',
+      args: args || process.argv.slice(2),
+      createConfig,
+      createSingletonServices,
+      createSessionServices,
+    })
+  } catch (error) {
+    if (error instanceof CLIError) {
+      process.exit(error.exitCode)
+    }
+    throw error
+  }
 }
 
 // Export as default for easy importing
@@ -66,7 +71,7 @@ export default ${capitalizedName}CLI
 
 // For direct execution (if this file is run directly)
 if (import.meta.url === \`file://\${process.argv[1]}\`) {
-  ${capitalizedName}CLI().catch(error => {
+  ${capitalizedName}CLI(process.argv.slice(2)).catch(error => {
     console.error('Fatal error:', error.message)
     process.exit(1)
   })

package/src/functions/wirings/fetch/index.ts

@@ -8,8 +8,14 @@ export const pikkuFetch: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config }) => {
     const { fetchFile, httpMapDeclarationFile, packageMappings } = config
 
+    // If fetchFile is not set, clean up any existing file and return
     if (!fetchFile) {
-      throw new Error("fetchFile is isn't set in the pikku config")
+      logger.info({
+        message:
+          "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
+        type: 'skip',
+      })
+      return
     }
 
     const routesMapDeclarationPath = getFileImportRelativePath(
@@ -25,8 +31,6 @@ export const pikkuFetch: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Generating fetch wrapper',
       commandEnd: 'Generated fetch wrapper',
-      skipCondition: ({ config }) => config.fetchFile === undefined,
-      skipMessage: "fetchFile isn't set in the pikku config",
     }),
   ],
 })

package/src/functions/wirings/functions/pikku-command-function-types-split.ts

@@ -12,6 +12,7 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
       functionTypesFile,
       packageMappings,
       rpcInternalMapDeclarationFile,
+      servicesFile,
     } = config
 
     // Check for required types
@@ -21,13 +22,21 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
       singletonServicesType: true,
     })
 
-    const { userSessionType, sessionServicesType, singletonServicesType } =
-      visitState.filesAndMethods
+    const {
+      userSessionType,
+      sessionServicesType,
+      singletonServicesType,
+      pikkuConfigType,
+    } = visitState.filesAndMethods
 
     if (!userSessionType || !sessionServicesType || !singletonServicesType) {
       throw new Error('Required types not found')
     }
 
+    const configTypeImport = pikkuConfigType
+      ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
+      : '// Config type not found, will use fallback'
+
     const content = serializeFunctionTypes(
       `import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`,
       userSessionType.type,
@@ -35,7 +44,9 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
       singletonServicesType.type,
       `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`,
       sessionServicesType.type,
-      `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
+      `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`,
+      `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`,
+      configTypeImport
     )
 
     await writeFileInDir(logger, functionTypesFile, content)
@@ -44,8 +55,6 @@ export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating function types',
       commandEnd: 'Created function types',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/functions/pikku-command-function-types.ts

@@ -38,8 +38,6 @@ export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating api types hub',
       commandEnd: 'Created api types hub',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })