@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,80 @@
+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.bootstrapFile,
+    config.packageMappings
+  )
+
+  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}'
+import '${cliBootstrapPath}'
+
+/**
+ * ${capitalizedName} CLI function
+ * Handles command line arguments and executes the appropriate function
+ */
+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
+export default ${capitalizedName}CLI
+
+// For direct execution (if this file is run directly)
+if (import.meta.url === \`file://\${process.argv[1]}\`) {
+  ${capitalizedName}CLI(process.argv.slice(2)).catch(error => {
+    console.error('Fatal error:', error.message)
+    process.exit(1)
+  })
+}
+`
+}

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

@@ -0,0 +1,36 @@
+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 is not set, clean up any existing file and return
+    if (!fetchFile) {
+      logger.info({
+        message:
+          "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
+        type: 'skip',
+      })
+      return
+    }
+
+    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',
+    }),
+  ],
+})

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

@@ -0,0 +1,60 @@
+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,
+      servicesFile,
+    } = config
+
+    // Check for required types
+    checkRequiredTypes(visitState.filesAndMethodsErrors, {
+      userSessionType: true,
+      sessionServiceType: true,
+      singletonServicesType: true,
+    })
+
+    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,
+      `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)}'`,
+      `import type { RequiredSingletonServices, RequiredSessionServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`,
+      configTypeImport
+    )
+
+    await writeFileInDir(logger, functionTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating function types',
+      commandEnd: 'Created function types',
+    }),
+  ],
+})

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

@@ -0,0 +1,43 @@
+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',
+    }),
+  ],
+})

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

@@ -0,0 +1,59 @@
+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',
+    }),
+  ],
+})

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

@@ -0,0 +1,111 @@
+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 = (
+  requiredServices: Set<string>,
+  forceRequiredServices: string[] = [],
+  servicesImport: string,
+  sessionServicesImport: string
+): string => {
+  // Use pre-aggregated services from inspector state
+  // This includes services from:
+  // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
+  // - Middleware used by wired functions
+  // - Permissions used by wired functions
+  // - Session factories
+  const usedServices = new Set(requiredServices)
+
+  // Internal services that are created internally and not via the create service script
+  const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
+
+  // Add force-required services that might not be detected from function inspection
+  forceRequiredServices.forEach((service) => {
+    if (!internalServices.has(service)) {
+      usedServices.add(service)
+    }
+  })
+
+  // Create a map of services with true for all needed services
+  const servicesMap = Object.fromEntries(
+    Array.from(usedServices)
+      .sort()
+      .map((service) => [service, true])
+  )
+
+  // Generate the TypeScript code
+  const serviceKeys = Object.keys(servicesMap).sort()
+
+  // Services that are always required internally by the framework
+  const defaultServices = ['config', 'logger', 'variables', 'schema']
+
+  // Combine default services with detected services
+  const allRequiredServices = [
+    ...new Set([...defaultServices, ...serviceKeys]),
+  ].sort()
+
+  // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
+  // This will be resolved at compile time based on what's actually in the SingletonServices interface
+  // We don't need to hardcode which services are singletons beyond the core framework ones
+
+  const code = [
+    servicesImport,
+    sessionServicesImport,
+    "import type { PikkuInteraction } from '@pikku/core'",
+    '',
+    'export const singletonServices = {',
+    ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+    '} as const',
+    '',
+    '// Singleton services (created once at startup)',
+    '// Only includes services that are both required and available in SingletonServices',
+    `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
+    '',
+    '// Session services (created per request, can access singleton services)',
+    '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
+    `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
+    '',
+  ].join('\n')
+
+  return code
+}
+
+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'
+      )
+    }
+
+    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.serviceAggregation.requiredServices,
+      config.forceRequiredServices,
+      servicesImport,
+      sessionServicesImport
+    )
+    await writeFileInDir(logger, config.servicesFile, servicesCode)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating Pikku services map',
+      commandEnd: 'Generated Pikku services map',
+    }),
+  ],
+})

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

@@ -0,0 +1,43 @@
+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',
+    }),
+  ],
+})

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

@@ -0,0 +1,45 @@
+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',
+    }),
+  ],
+})

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})`)
     }
   }