@pikku/cli 0.9.14 → 0.9.16-next.0

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

@@ -0,0 +1,80 @@
+/**
+ * Generates type definitions for CLI wirings
+ */
+export const serializeCLITypes = (
+  functionTypesImportPath: string,
+  userSessionTypeImport: string,
+  userSessionTypeName: string,
+  singletonServicesTypeImport: string,
+  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 type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
+${userSessionTypeImport}
+${singletonServicesTypeImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+
+/**
+ * Type-safe CLI renderer definition that can access your application's services.
+ * Use this to define custom renderers for CLI command output.
+ *
+ * @template Data - The output data type from the CLI command
+ * @template RequiredServices - The services required for this renderer
+ */
+type PikkuCLIRender<Data, RequiredServices extends SingletonServices = SingletonServices> = CorePikkuCLIRender<Data, RequiredServices, Session>
+
+/**
+ * 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 definition for CLI applications with commands and global options.
+ *
+ * @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>>
+
+/**
+ * Registers a CLI application with the Pikku framework.
+ * Creates command-line interfaces with type-safe commands and options.
+ *
+ * @template Commands - Type describing the command structure
+ * @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>(
+  cli: CLIWiring<Commands, GlobalOptions>
+) => {
+  wireCLICore(cli as 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
+ * @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> => {
+  return config as any
+}
+`
+}

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

@@ -0,0 +1,75 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { Config } from '../../../../types/application-types.js'
+
+/**
+ * Serializes the local (in-program) CLI bootstrap code
+ */
+export function serializeLocalCLIBootstrap(
+  programName: string,
+  _programMeta: any,
+  bootstrapFile: string,
+  config: Config,
+  pikkuConfigFactory: { file: string; variable: string },
+  singletonServicesFactory: { file: string; variable: string },
+  sessionServicesFactory: { file: string; variable: string }
+): string {
+  const capitalizedName =
+    programName.charAt(0).toUpperCase() + programName.slice(1).replace(/-/g, '')
+
+  // Get relative import paths
+  const pikkuConfigPath = getFileImportRelativePath(
+    bootstrapFile,
+    pikkuConfigFactory.file,
+    config.packageMappings
+  )
+  const singletonServicesPath = getFileImportRelativePath(
+    bootstrapFile,
+    singletonServicesFactory.file,
+    config.packageMappings
+  )
+  const sessionServicesPath = getFileImportRelativePath(
+    bootstrapFile,
+    sessionServicesFactory.file,
+    config.packageMappings
+  )
+  const cliBootstrapPath = getFileImportRelativePath(
+    bootstrapFile,
+    config.bootstrapFiles.cli,
+    config.packageMappings
+  )
+
+  return `/**
+ * This file was generated by the @pikku/cli
+ */
+import { executeCLI } from '@pikku/core'
+import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'
+import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
+import { ${sessionServicesFactory.variable} as createSessionServices } from '${sessionServicesPath}'
+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 as default for easy importing
+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 => {
+    console.error('Fatal error:', error.message)
+    process.exit(1)
+  })
+}
+`
+}

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

@@ -0,0 +1,32 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+
+export const pikkuFetch: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { fetchFile, httpMapDeclarationFile, packageMappings } = config
+
+    if (!fetchFile) {
+      throw new Error("fetchFile is isn't set in the pikku config")
+    }
+
+    const routesMapDeclarationPath = getFileImportRelativePath(
+      fetchFile,
+      httpMapDeclarationFile,
+      packageMappings
+    )
+
+    const content = [serializeFetchWrapper(routesMapDeclarationPath)]
+    await writeFileInDir(logger, fetchFile, content.join('\n'))
+  },
+  middleware: [
+    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

@@ -0,0 +1,51 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { checkRequiredTypes } from '../../../utils/check-required-types.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeFunctionTypes } from './serialize-function-types.js'
+
+export const pikkuFunctionTypesSplit: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const {
+      functionTypesFile,
+      packageMappings,
+      rpcInternalMapDeclarationFile,
+    } = config
+
+    // Check for required types
+    checkRequiredTypes(visitState.filesAndMethodsErrors, {
+      userSessionType: true,
+      sessionServiceType: true,
+      singletonServicesType: true,
+    })
+
+    const { userSessionType, sessionServicesType, singletonServicesType } =
+      visitState.filesAndMethods
+
+    if (!userSessionType || !sessionServicesType || !singletonServicesType) {
+      throw new Error('Required types not found')
+    }
+
+    const content = serializeFunctionTypes(
+      `import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`,
+      userSessionType.type,
+      `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`,
+      singletonServicesType.type,
+      `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`,
+      sessionServicesType.type,
+      `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
+    )
+
+    await writeFileInDir(logger, functionTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating function types',
+      commandEnd: 'Created function types',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

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

@@ -0,0 +1,45 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js'
+
+export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const {
+      typesDeclarationFile: typesFile,
+      packageMappings,
+      functionTypesFile,
+      httpTypesFile,
+      channelsTypesFile,
+      schedulersTypesFile,
+      queueTypesFile,
+      mcpTypesFile,
+      cliTypesFile,
+    } = config
+
+    const content = serializePikkuTypesHub(
+      getFileImportRelativePath(typesFile, functionTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, httpTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings),
+      getFileImportRelativePath(
+        typesFile,
+        schedulersTypesFile,
+        packageMappings
+      ),
+      getFileImportRelativePath(typesFile, queueTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, cliTypesFile, packageMappings)
+    )
+
+    await writeFileInDir(logger, typesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating api types hub',
+      commandEnd: 'Created api types hub',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

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

@@ -0,0 +1,61 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import {
+  generateRuntimeMeta,
+  serializeFunctionImports,
+} from './serialize-function-imports.js'
+
+export const pikkuFunctions: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { functions, rpc } = await getInspectorState()
+    const {
+      functionsMetaFile,
+      functionsMetaMinFile,
+      functionsFile,
+      packageMappings,
+    } = config
+
+    // Generate full metadata
+    await writeFileInDir(
+      logger,
+      functionsMetaFile,
+      `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
+    )
+
+    // Generate minimal metadata (runtime)
+    const runtimeMeta = generateRuntimeMeta(functions.meta)
+    await writeFileInDir(
+      logger,
+      functionsMetaMinFile,
+      `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`
+    )
+
+    const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0
+    if (hasRPCs) {
+      await writeFileInDir(
+        logger,
+        functionsFile,
+        serializeFunctionImports(
+          functionsFile,
+          rpc.internalFiles,
+          functions.meta,
+          packageMappings
+        )
+      )
+    }
+
+    return hasRPCs
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Serializing Pikku functions',
+      commandEnd: 'Serialized Pikku functions',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/functions/pikku-command-services.ts

@@ -1,12 +1,8 @@
-import {
-  getFileImportRelativePath,
-  getPikkuFilesAndMethods,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-import { PikkuCLIConfig } from '../../pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { checkRequiredTypes } from '../../../utils/check-required-types.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 
 export const serializeServicesMap = (
   functionsMetaData: Record<string, any>,
@@ -86,40 +82,41 @@ export const serializeServicesMap = (
   return code
 }
 
-export const pikkuServices: PikkuCommand = async (
-  logger,
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Generating Pikku services map',
-    'Generated Pikku services map',
-    [false],
-    async () => {
-      const { sessionServicesType, singletonServicesType } =
-        await getPikkuFilesAndMethods(
-          logger,
-          visitState,
-          cliConfig.packageMappings,
-          cliConfig.typesDeclarationFile,
-          {},
-          {
-            sessionServiceType: true,
-            singletonServicesType: true,
-          }
-        )
-
-      const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`
-      const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`
-
-      const servicesCode = serializeServicesMap(
-        visitState.functions.meta,
-        cliConfig.middlewareServices,
-        servicesImport,
-        sessionServicesImport
+export const pikkuServices: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+
+    // Check for required types
+    checkRequiredTypes(visitState.filesAndMethodsErrors, {
+      sessionServiceType: true,
+      singletonServicesType: true,
+    })
+
+    const { sessionServicesType, singletonServicesType } =
+      visitState.filesAndMethods
+
+    if (!sessionServicesType || !singletonServicesType) {
+      throw new Error(
+        'Required types not found: sessionServicesType or singletonServicesType'
       )
-      await writeFileInDir(logger, cliConfig.servicesFile, servicesCode)
     }
-  )
-}
+
+    const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`
+    const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`
+
+    const servicesCode = serializeServicesMap(
+      visitState.functions.meta,
+      config.middlewareServices,
+      servicesImport,
+      sessionServicesImport
+    )
+    await writeFileInDir(logger, config.servicesFile, servicesCode)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating Pikku services map',
+      commandEnd: 'Generated Pikku services map',
+      skipMessage: '',
+    }),
+  ],
+})

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

@@ -0,0 +1,45 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js'
+
+export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const {
+      typesDeclarationFile: typesFile,
+      packageMappings,
+      functionTypesFile,
+      httpTypesFile,
+      channelsTypesFile,
+      schedulersTypesFile,
+      queueTypesFile,
+      mcpTypesFile,
+      cliTypesFile,
+    } = config
+
+    const content = serializePikkuTypesHub(
+      getFileImportRelativePath(typesFile, functionTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, httpTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings),
+      getFileImportRelativePath(
+        typesFile,
+        schedulersTypesFile,
+        packageMappings
+      ),
+      getFileImportRelativePath(typesFile, queueTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings),
+      getFileImportRelativePath(typesFile, cliTypesFile, packageMappings)
+    )
+
+    await writeFileInDir(logger, typesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating api types hub',
+      commandEnd: 'Created api types hub',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/functions/wirings/functions/schemas.ts

@@ -0,0 +1,47 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import {
+  saveSchemas,
+  generateSchemas,
+} from '../../../utils/schema-generator.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+
+/**
+ * Generate JSON schemas from TypeScript types
+ */
+export const pikkuSchemas: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+
+    const schemas = await generateSchemas(
+      logger,
+      config.tsconfig,
+      visitState.functions.typesMap,
+      visitState.functions.meta,
+      visitState.http.meta,
+      config.schemasFromTypes
+    )
+
+    await saveSchemas(
+      logger,
+      config.schemaDirectory,
+      schemas,
+      visitState.functions.typesMap,
+      visitState.functions.meta,
+      config.supportsImportAttributes,
+      config.schemasFromTypes
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating schemas',
+      commandEnd: 'Generated schemas',
+      skipCondition: false,
+      skipMessage: '',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/functions/serialize-function-imports.ts

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath } from '../../utils.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core'
 
 export const serializeFunctionImports = (
@@ -26,44 +26,18 @@ export const serializeFunctionImports = (
       packageMappings
     )
 
-    // Find the function metadata to check if it's a direct function
-    // The functionsMeta is keyed by the function name (exported name)
-    const funcMeta = functionsMeta[name]
-    const isDirectFunction = funcMeta?.isDirectFunction ?? false
-
+    // pikkuFunc/pikkuSessionlessFunc/pikkuVoidFunc always return config objects
     // For directly exported functions, we can just import and register them
     if (name === exportedName) {
       serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
-
-      if (isDirectFunction) {
-        // Direct function: pikkuFunc(fn) - needs to be wrapped
-        serializedRegistrations.push(
-          `addFunction('${name}', { func: ${exportedName} })`
-        )
-      } else {
-        // Object format: pikkuFunc({ func: fn }) - can be used directly
-        serializedRegistrations.push(
-          `addFunction('${name}', ${exportedName} as any) // TODO`
-        )
-      }
+      serializedRegistrations.push(`addFunction('${name}', ${exportedName})`)
     }
     // For renamed functions, we need to import and alias them
     else {
       serializedImports.push(
         `import { ${exportedName} as ${name} } from '${filePath}'`
       )
-
-      if (isDirectFunction) {
-        // Direct function: pikkuFunc(fn) - needs to be wrapped
-        serializedRegistrations.push(
-          `addFunction('${name}', { func: ${name} })`
-        )
-      } else {
-        // Object format: pikkuFunc({ func: fn }) - can be used directly
-        serializedRegistrations.push(
-          `addFunction('${name}', ${name} as any) // TODO`
-        )
-      }
+      serializedRegistrations.push(`addFunction('${name}', ${name})`)
     }
   }