@pikku/cli 0.11.3 → 0.12.0

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

@@ -1,104 +0,0 @@
-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 { serializeFunctionImports } from './serialize-function-imports.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import {
-  stripVerboseFields,
-  hasVerboseFields,
-} from '../../../utils/strip-verbose-meta.js'
-
-export const pikkuFunctions: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { functions, rpc } = await getInspectorState()
-    const {
-      functionsMetaFile,
-      functionsMetaJsonFile,
-      functionsFile,
-      packageMappings,
-      schema,
-    } = config
-
-    // Write minimal JSON (runtime-only fields)
-    const minimalMeta = stripVerboseFields(functions.meta)
-    await writeFileInDir(
-      logger,
-      functionsMetaJsonFile,
-      JSON.stringify(minimalMeta, null, 2)
-    )
-
-    // Write verbose JSON only if it has additional fields
-    if (hasVerboseFields(functions.meta)) {
-      const verbosePath = functionsMetaJsonFile.replace(
-        /\.gen\.json$/,
-        '-verbose.gen.json'
-      )
-      await writeFileInDir(
-        logger,
-        verbosePath,
-        JSON.stringify(functions.meta, null, 2)
-      )
-    }
-
-    const jsonImportPath = getFileImportRelativePath(
-      functionsMetaFile,
-      functionsMetaJsonFile,
-      packageMappings
-    )
-
-    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-    const importStatement = supportsImportAttributes
-      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${jsonImportPath}'`
-
-    const packageName = config.externalPackageName
-      ? `'${config.externalPackageName}'`
-      : 'null'
-
-    await writeFileInDir(
-      logger,
-      functionsMetaFile,
-      `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`
-    )
-
-    // For external packages, register ALL functions (they'll be invoked by consumers)
-    // For main packages, only register functions that are invoked via internal RPCs
-    const isExternalPackage = !!config.externalPackageName
-    const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0
-    const hasFunctions = functions.files.size > 0
-
-    const shouldGenerateFunctionsFile = isExternalPackage
-      ? hasFunctions
-      : hasRPCs
-
-    if (shouldGenerateFunctionsFile) {
-      // For external packages, use all function files; for main packages, use internal RPC files
-      const filesToRegister = isExternalPackage
-        ? functions.files
-        : rpc.internalFiles
-
-      await writeFileInDir(
-        logger,
-        functionsFile,
-        serializeFunctionImports(
-          functionsFile,
-          filesToRegister,
-          functions.meta,
-          packageMappings,
-          config.externalPackageName
-        )
-      )
-    }
-
-    return shouldGenerateFunctionsFile
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Serializing Pikku functions',
-      commandEnd: 'Serialized Pikku functions',
-    }),
-  ],
-})

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

@@ -1,140 +0,0 @@
-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 = (
-  allSingletonServices: string[],
-  allWireServices: string[],
-  requiredServices: Set<string>,
-  forceRequiredServices: string[] = [],
-  servicesImport: string,
-  wireServicesImport: 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 by the framework (PikkuWire)
-  // These should not appear in the services maps
-  const internalServices = new Set([
-    'rpc',
-    'mcp',
-    'channel',
-    'userSession',
-    'cli',
-    'http',
-    'queue',
-    'scheduledTask',
-  ])
-
-  // Add force-required services that might not be detected from function inspection
-  forceRequiredServices.forEach((service) => {
-    if (!internalServices.has(service)) {
-      usedServices.add(service)
-    }
-  })
-
-  // Services that are always required internally by the framework
-  const defaultServices = ['config', 'logger', 'variables', 'schema', 'secrets']
-  defaultServices.forEach((service) => usedServices.add(service))
-
-  // Create singleton services map: all singleton services with true/false based on usage
-  const singletonServicesMap: Record<string, boolean> = {}
-  allSingletonServices.forEach((service) => {
-    singletonServicesMap[service] = usedServices.has(service)
-  })
-
-  // Create wire services map: all wire services with true/false based on usage
-  // Exclude internal framework services (PikkuWire)
-  const wireServicesMap: Record<string, boolean> = {}
-  allWireServices.forEach((service) => {
-    if (!internalServices.has(service)) {
-      wireServicesMap[service] = usedServices.has(service)
-    }
-  })
-
-  // Get all required service names (those marked as true)
-  const requiredSingletonServiceNames = Object.keys(singletonServicesMap)
-    .filter((key) => singletonServicesMap[key])
-    .sort()
-  const requiredWireServiceNames = Object.keys(wireServicesMap)
-    .filter((key) => wireServicesMap[key])
-    .sort()
-
-  const code = [
-    servicesImport,
-    wireServicesImport,
-    '',
-    '// Singleton services map: true if required, false if available but unused',
-    'export const requiredSingletonServices = {',
-    ...Object.keys(singletonServicesMap)
-      .sort()
-      .map((service) => `  '${service}': ${singletonServicesMap[service]},`),
-    '} as const',
-    '',
-    '// Wire services map: true if required, false if available but unused',
-    'export const requiredWireServices = {',
-    ...Object.keys(wireServicesMap)
-      .sort()
-      .map((service) => `  '${service}': ${wireServicesMap[service]},`),
-    '} as const',
-    '',
-    '// Type exports',
-    requiredSingletonServiceNames.length > 0
-      ? `export type RequiredSingletonServices = Pick<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<SingletonServices, ${requiredSingletonServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
-      : 'export type RequiredSingletonServices = Partial<SingletonServices>',
-    '',
-    requiredWireServiceNames.length > 0
-      ? `export type RequiredWireServices = Pick<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
-      : 'export type RequiredWireServices = Partial<Services>',
-    '',
-  ].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, {
-      wireServiceType: true,
-      singletonServicesType: true,
-    })
-
-    const { wireServicesType, singletonServicesType } =
-      visitState.filesAndMethods
-
-    if (!wireServicesType || !singletonServicesType) {
-      throw new Error(
-        'Required types not found: wireServicesType or singletonServicesType'
-      )
-    }
-
-    const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`
-    const wireServicesImport = `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, wireServicesType.typePath, config.packageMappings)}'`
-
-    const servicesCode = serializeServicesMap(
-      visitState.serviceAggregation.allSingletonServices,
-      visitState.serviceAggregation.allWireServices,
-      visitState.serviceAggregation.requiredServices,
-      config.forceRequiredServices,
-      servicesImport,
-      wireServicesImport
-    )
-    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

@@ -1,45 +0,0 @@
-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,
-      forgeTypesFile,
-    } = 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),
-      getFileImportRelativePath(typesFile, forgeTypesFile, 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

@@ -1,56 +0,0 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
-import {
-  saveSchemas,
-  generateSchemas,
-  generateZodSchemas,
-} from '../../../utils/schema-generator.js'
-import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
-
-/**
- * Generate JSON schemas from TypeScript types and Zod schemas
- */
-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,
-      config.schema?.additionalProperties,
-      visitState.zodLookup
-    )
-
-    const zodSchemas = await generateZodSchemas(
-      logger,
-      visitState.zodLookup,
-      visitState.functions.typesMap
-    )
-
-    await saveSchemas(
-      logger,
-      config.schemaDirectory,
-      { ...schemas, ...zodSchemas},
-      visitState.functions.typesMap,
-      visitState.functions.meta,
-      config.schema?.supportsImportAttributes || true,
-      config.schemasFromTypes,
-      visitState.zodLookup,
-      config.externalPackageName || null
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating schemas',
-      commandEnd: 'Generated schemas',
-    }),
-  ],
-})

package/src/functions/wirings/functions/serialize-function-imports.ts

@@ -1,80 +0,0 @@
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core'
-
-export const serializeFunctionImports = (
-  outputPath: string,
-  functionsMap: Map<string, { path: string; exportedName: string }>,
-  functionsMeta: FunctionsMeta,
-  packageMappings: Record<string, string> = {},
-  /** Package name for external packages (e.g., '@pikku/templates-function-external') */
-  externalPackageName?: string
-) => {
-  const serializedImports: string[] = [
-    `/* Import and register functions used by RPCs */`,
-    `import { addFunction } from '@pikku/core'`,
-  ]
-
-  const serializedRegistrations: string[] = []
-
-  // Sort by function name for consistent output
-  const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) =>
-    a[0].localeCompare(b[0])
-  )
-
-  // Third argument to addFunction is the package name (null for main package)
-  const packageArg = externalPackageName ? `, '${externalPackageName}'` : ''
-
-  for (const [name, { path, exportedName }] of sortedEntries) {
-    const filePath = getFileImportRelativePath(
-      outputPath,
-      path,
-      packageMappings
-    )
-
-    // 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}'`)
-      serializedRegistrations.push(
-        `addFunction('${name}', ${exportedName}${packageArg})`
-      )
-    }
-    // For renamed functions, we need to import and alias them
-    else {
-      serializedImports.push(
-        `import { ${exportedName} as ${name} } from '${filePath}'`
-      )
-      serializedRegistrations.push(
-        `addFunction('${name}', ${name}${packageArg})`
-      )
-    }
-  }
-
-  // Add a blank line between imports and registrations
-  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-    serializedImports.push('')
-  }
-
-  // Combine the imports and registrations
-  return [...serializedImports, ...serializedRegistrations].join('\n')
-}
-
-export const generateRuntimeMeta = (
-  functions: FunctionsMeta
-): FunctionsRuntimeMeta => {
-  const runtimeMeta: FunctionsRuntimeMeta = {}
-
-  for (const [
-    key,
-    { pikkuFuncName, inputSchemaName, outputSchemaName, expose },
-  ] of Object.entries(functions)) {
-    runtimeMeta[key] = {
-      pikkuFuncName,
-      inputSchemaName,
-      outputSchemaName,
-      expose,
-    }
-  }
-
-  return runtimeMeta
-}