@pikku/cli 0.11.2 → 0.12.0

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

@@ -1,94 +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 {
-  generateRuntimeMeta,
-  serializeFunctionImports,
-} from './serialize-function-imports.js'
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
-
-export const pikkuFunctions: any = pikkuSessionlessFunc<
-  void,
-  boolean | undefined
->({
-  func: async ({ logger, config, getInspectorState }) => {
-    const { functions, rpc } = await getInspectorState()
-    const {
-      functionsMetaFile,
-      functionsMetaJsonFile,
-      functionsMetaMinFile,
-      functionsMetaMinJsonFile,
-      functionsFile,
-      packageMappings,
-      schema,
-    } = config
-
-    await writeFileInDir(
-      logger,
-      functionsMetaJsonFile,
-      JSON.stringify(functions.meta, null, 2)
-    )
-
-    const fullJsonImportPath = getFileImportRelativePath(
-      functionsMetaFile,
-      functionsMetaJsonFile,
-      packageMappings
-    )
-
-    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
-    const fullImportStatement = supportsImportAttributes
-      ? `import metaData from '${fullJsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${fullJsonImportPath}'`
-
-    await writeFileInDir(
-      logger,
-      functionsMetaFile,
-      `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${fullImportStatement}\npikkuState('function', 'meta', metaData as FunctionsMeta)`
-    )
-
-    const runtimeMeta = generateRuntimeMeta(functions.meta)
-    await writeFileInDir(
-      logger,
-      functionsMetaMinJsonFile,
-      JSON.stringify(runtimeMeta, null, 2)
-    )
-
-    const minJsonImportPath = getFileImportRelativePath(
-      functionsMetaMinFile,
-      functionsMetaMinJsonFile,
-      packageMappings
-    )
-
-    const minImportStatement = supportsImportAttributes
-      ? `import metaData from '${minJsonImportPath}' with { type: 'json' }`
-      : `import metaData from '${minJsonImportPath}'`
-
-    await writeFileInDir(
-      logger,
-      functionsMetaMinFile,
-      `import { pikkuState, FunctionsRuntimeMeta } from '@pikku/core'\n${minImportStatement}\npikkuState('function', 'meta', metaData as FunctionsRuntimeMeta)`
-    )
-
-    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

@@ -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']
-  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,43 +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,
-    } = 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

@@ -1,46 +0,0 @@
-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,
-      config.schema?.additionalProperties
-    )
-
-    await saveSchemas(
-      logger,
-      config.schemaDirectory,
-      schemas,
-      visitState.functions.typesMap,
-      visitState.functions.meta,
-      config.schema?.supportsImportAttributes || true,
-      config.schemasFromTypes
-    )
-
-    return true
-  },
-  middleware: [
-    logCommandInfoAndTime({
-      commandStart: 'Generating schemas',
-      commandEnd: 'Generated schemas',
-    }),
-  ],
-})

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

@@ -1,71 +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> = {}
-) => {
-  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])
-  )
-
-  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})`)
-    }
-    // For renamed functions, we need to import and alias them
-    else {
-      serializedImports.push(
-        `import { ${exportedName} as ${name} } from '${filePath}'`
-      )
-      serializedRegistrations.push(`addFunction('${name}', ${name})`)
-    }
-  }
-
-  // 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
-}