@pikku/cli 0.9.15 → 0.10.0

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

@@ -1,125 +0,0 @@
-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'
-
-export const serializeServicesMap = (
-  functionsMetaData: Record<string, any>,
-  middlewareServices: string[] = [],
-  servicesImport: string,
-  sessionServicesImport: string
-): string => {
-  // Extract all unique services from all functions
-  const usedServices = new Set<string>()
-
-  // Internal services that are created internally and not via the create service script
-  const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
-
-  for (const funcMeta of Object.values(functionsMetaData)) {
-    if (funcMeta.services && Array.isArray(funcMeta.services.services)) {
-      funcMeta.services.services.forEach((service: string) => {
-        // Only include services that are not internal
-        if (!internalServices.has(service)) {
-          usedServices.add(service)
-        }
-      })
-    }
-  }
-
-  // Add middleware services that might not be detected from function inspection
-  middlewareServices.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 = [
-    '/**',
-    ' * This file was generated by the @pikku/cli',
-    ' */',
-    '',
-    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: 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
-      )
-      await writeFileInDir(logger, cliConfig.servicesFile, servicesCode)
-    }
-  )
-}

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

@@ -1,52 +0,0 @@
-import {
-  getFileImportRelativePath,
-  getPikkuFilesAndMethods,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
-import { serializePikkuTypes } from '../../serialize-pikku-types.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuFunctionTypes: PikkuCommand = async (
-  logger,
-  {
-    typesDeclarationFile: typesFile,
-    packageMappings,
-    rpcInternalMapDeclarationFile,
-  },
-  visitState,
-  options = {}
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating api types',
-    'Created api types',
-    [false],
-    async () => {
-      const { userSessionType, sessionServicesType, singletonServicesType } =
-        await getPikkuFilesAndMethods(
-          logger,
-          visitState,
-          packageMappings,
-          typesFile,
-          options,
-          {
-            userSessionType: true,
-            sessionServiceType: true,
-            singletonServicesType: true,
-          }
-        )
-
-      const content = serializePikkuTypes(
-        `import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`,
-        userSessionType.type,
-        `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
-        singletonServicesType.type,
-        `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
-        sessionServicesType.type,
-        `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
-      )
-      await writeFileInDir(logger, typesFile, content)
-    }
-  )
-}

package/src/wirings/http/pikku-command-http-map.ts

@@ -1,27 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { serializeTypedHTTPWiringsMap } from './serialize-typed-http-map.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuHTTPMap: PikkuCommand = async (
-  logger,
-  { httpMapDeclarationFile, packageMappings },
-  { http, functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating HTTP map',
-    'Created HTTP map',
-    [http.files.size === 0],
-    async () => {
-      const content = serializeTypedHTTPWiringsMap(
-        httpMapDeclarationFile,
-        packageMappings,
-        functions.typesMap,
-        functions.meta,
-        http.meta,
-        http.metaInputTypes
-      )
-      await writeFileInDir(logger, httpMapDeclarationFile, content)
-    }
-  )
-}

package/src/wirings/http/pikku-command-http-routes.ts

@@ -1,40 +0,0 @@
-import { PikkuCLIConfig } from '../../pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuHTTP: PikkuCommand = async (
-  logger,
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding HTTP routes',
-    'Found HTTP routes',
-    [visitState.http.files.size === 0],
-    async () => {
-      const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig
-      const { http } = visitState
-      await writeFileInDir(
-        logger,
-        httpWiringsFile,
-        serializeFileImports(
-          'wireHTTP',
-          httpWiringsFile,
-          http.files,
-          packageMappings
-        )
-      )
-      await writeFileInDir(
-        logger,
-        httpWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
-      )
-    }
-  )
-}

package/src/wirings/http/pikku-command-openapi.ts

@@ -1,55 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { generateSchemas } from '../../schema-generator.js'
-import { generateOpenAPISpec } from './openapi-spec-generator.js'
-import { stringify } from 'yaml'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuOpenAPI: PikkuCommand = async (
-  logger,
-  { tsconfig, openAPI, schemasFromTypes },
-  { http, functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating OpenAPI spec',
-    'Created OpenAPI spec',
-    [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'],
-    async () => {
-      if (!openAPI?.outputFile) {
-        throw new Error('openAPI is required')
-      }
-      const schemas = await generateSchemas(
-        logger,
-        tsconfig,
-        functions.typesMap,
-        functions.meta,
-        http.meta,
-        schemasFromTypes
-      )
-      const openAPISpec = await generateOpenAPISpec(
-        functions.meta,
-        http.meta,
-        schemas,
-        openAPI.additionalInfo
-      )
-      if (openAPI.outputFile.endsWith('.json')) {
-        await writeFileInDir(
-          logger,
-          openAPI.outputFile,
-          JSON.stringify(openAPISpec, null, 2),
-          { ignoreModifyComment: true }
-        )
-      } else if (
-        openAPI.outputFile.endsWith('.yaml') ||
-        openAPI.outputFile.endsWith('.yml')
-      ) {
-        await writeFileInDir(
-          logger,
-          openAPI.outputFile,
-          stringify(openAPISpec),
-          { ignoreModifyComment: true }
-        )
-      }
-    }
-  )
-}

package/src/wirings/http/pikku-http-routes.ts

@@ -1,40 +0,0 @@
-import { PikkuCLIConfig } from '../../pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuHTTP: PikkuCommand = async (
-  logger,
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding HTTP routes',
-    'Found HTTP routes',
-    [visitState.http.files.size === 0],
-    async () => {
-      const { httpWiringsFile, httpWiringMetaFile, packageMappings } = cliConfig
-      const { http } = visitState
-      await writeFileInDir(
-        logger,
-        httpWiringsFile,
-        serializeFileImports(
-          'wireHTTP',
-          httpWiringsFile,
-          http.files,
-          packageMappings
-        )
-      )
-      await writeFileInDir(
-        logger,
-        httpWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
-      )
-    }
-  )
-}

package/src/wirings/mcp/pikku-command-mcp-json.ts

@@ -1,33 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { serializeMCPJson } from './serialize-mcp-json.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuMCPJSON: PikkuCommand = async (
-  logger,
-  { mcpJsonFile, schemaDirectory },
-  { mcpEndpoints, functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Generating MCP JSON',
-    'Generated MCP JSON',
-    [mcpEndpoints.files.size === 0 || !mcpJsonFile],
-    async () => {
-      // Generate MCP JSON file
-      if (mcpJsonFile) {
-        const mcpJson = await serializeMCPJson(
-          logger,
-          schemaDirectory,
-          functions.meta,
-          functions.typesMap,
-          mcpEndpoints.resourcesMeta,
-          mcpEndpoints.toolsMeta,
-          mcpEndpoints.promptsMeta
-        )
-        await writeFileInDir(logger, mcpJsonFile, mcpJson, {
-          ignoreModifyComment: true,
-        })
-      }
-    }
-  )
-}

package/src/wirings/queue/pikku-command-queue-map.ts

@@ -1,26 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { serializeQueueMap } from './serialize-queue-map.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuQueueMap: PikkuCommand = async (
-  logger,
-  { queueMapDeclarationFile, packageMappings },
-  { queueWorkers, functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating Queue map',
-    'Created Queue map',
-    [queueWorkers.files.size === 0],
-    async () => {
-      const content = serializeQueueMap(
-        queueMapDeclarationFile,
-        packageMappings,
-        functions.typesMap,
-        functions.meta,
-        queueWorkers.meta
-      )
-      await writeFileInDir(logger, queueMapDeclarationFile, content)
-    }
-  )
-}

package/src/wirings/queue/pikku-command-queue-service.ts

@@ -1,36 +0,0 @@
-import { serializeQueueWrapper } from './serialize-queue-wrapper.js'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommandWithoutState } from '../../types.js'
-
-export const pikkuQueueService: PikkuCommandWithoutState = async (
-  logger,
-  { queueWiringsFile, queueMapDeclarationFile, packageMappings }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Generating queue service wrapper',
-    'Generated queue service wrapper',
-    [
-      queueWiringsFile === undefined,
-      "queueWiringsFile isn't set in the pikku config",
-    ],
-    async () => {
-      if (!queueWiringsFile) {
-        throw new Error("queueWiringsFile is isn't set in the pikku config")
-      }
-
-      const queueMapDeclarationPath = getFileImportRelativePath(
-        queueWiringsFile,
-        queueMapDeclarationFile,
-        packageMappings
-      )
-
-      const content = [serializeQueueWrapper(queueMapDeclarationPath)]
-      await writeFileInDir(logger, queueWiringsFile, content.join('\n'))
-    }
-  )
-}

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

@@ -1,45 +0,0 @@
-import { PikkuCLIConfig } from '../../pikku-cli-config.js'
-import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { serializeQueueMeta } from './serialize-queue-meta.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuQueue: PikkuCommand = async (
-  logger,
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding queues',
-    'Found queue',
-    [visitState.queueWorkers.files.size === 0],
-    async () => {
-      const {
-        queueWorkersWiringFile,
-        queueWorkersWiringMetaFile,
-        packageMappings,
-      } = cliConfig
-      const { queueWorkers } = visitState
-      await writeFileInDir(
-        logger,
-        queueWorkersWiringMetaFile,
-        serializeQueueMeta(queueWorkers.meta)
-      )
-      await writeFileInDir(
-        logger,
-        queueWorkersWiringFile,
-        serializeFileImports(
-          'addQueueWorkers',
-          queueWorkersWiringFile,
-          queueWorkers.files,
-          packageMappings
-        )
-      )
-    }
-  )
-}

package/src/wirings/queue/pikku-queue-map.ts

@@ -1,26 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { serializeQueueMap } from './serialize-queue-map.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuQueueMap: PikkuCommand = async (
-  logger,
-  { queueMapDeclarationFile, packageMappings },
-  { queueWorkers, functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating Queue map',
-    'Created Queue map',
-    [queueWorkers.files.size === 0],
-    async () => {
-      const content = serializeQueueMap(
-        queueMapDeclarationFile,
-        packageMappings,
-        functions.typesMap,
-        functions.meta,
-        queueWorkers.meta
-      )
-      await writeFileInDir(logger, queueMapDeclarationFile, content)
-    }
-  )
-}

package/src/wirings/queue/pikku-queue.ts

@@ -1,43 +0,0 @@
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { serializeQueueMeta } from './serialize-queue-meta.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuQueue: PikkuCommand = async (
-  logger,
-  cliConfig,
-  visitState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding queues',
-    'Found queue',
-    [visitState.queueWorkers.files.size === 0],
-    async () => {
-      const {
-        queueWorkersWiringFile,
-        queueWorkersWiringMetaFile,
-        packageMappings,
-      } = cliConfig
-      const { queueWorkers } = visitState
-      await writeFileInDir(
-        logger,
-        queueWorkersWiringMetaFile,
-        serializeQueueMeta(queueWorkers.meta)
-      )
-      await writeFileInDir(
-        logger,
-        queueWorkersWiringFile,
-        serializeFileImports(
-          'addQueueWorkers',
-          queueWorkersWiringFile,
-          queueWorkers.files,
-          packageMappings
-        )
-      )
-    }
-  )
-}

package/src/wirings/rpc/pikku-command-rpc-client.ts

@@ -1,35 +0,0 @@
-import { serializeRPCWrapper } from './serialize-rpc-wrapper.js'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommandWithoutState } from '../../types.js'
-
-export const pikkuRPCClient: PikkuCommandWithoutState = async (
-  logger,
-  { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Generating RPC wrappers',
-    'Generated RPC wrappers',
-    [
-      rpcWiringsFile === undefined || rpcWiringsFile === null,
-      "rpcWiringsFile isn't set in the pikku config",
-    ],
-    async () => {
-      if (!rpcWiringsFile) {
-        throw new Error("rpcWiringsFile isn't set in the pikku config")
-      }
-
-      const rpcMapDeclarationPath = getFileImportRelativePath(
-        rpcWiringsFile,
-        rpcMapDeclarationFile,
-        packageMappings
-      )
-      const content = [serializeRPCWrapper(rpcMapDeclarationPath)]
-      await writeFileInDir(logger, rpcWiringsFile, content.join('\n'))
-    }
-  )
-}

package/src/wirings/rpc/pikku-command-rpc-map.ts

@@ -1,49 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuRPCInternalMap: PikkuCommand = async (
-  logger,
-  { rpcInternalMapDeclarationFile, packageMappings },
-  { functions, rpc }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating RPC internal map',
-    'Created RPC internal map',
-    [false],
-    async () => {
-      const content = serializeTypedRPCMap(
-        rpcInternalMapDeclarationFile,
-        packageMappings,
-        functions.typesMap,
-        functions.meta,
-        rpc.internalMeta
-      )
-      await writeFileInDir(logger, rpcInternalMapDeclarationFile, content)
-    }
-  )
-}
-
-export const pikkuRPCExposedMap: PikkuCommand = async (
-  logger,
-  { rpcMapDeclarationFile, packageMappings },
-  { functions, rpc }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Creating RPC external map',
-    'Created RPC external map',
-    [false],
-    async () => {
-      const content = serializeTypedRPCMap(
-        rpcMapDeclarationFile,
-        packageMappings,
-        functions.typesMap,
-        functions.meta,
-        rpc.exposedMeta
-      )
-      await writeFileInDir(logger, rpcMapDeclarationFile, content)
-    }
-  )
-}

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

@@ -1,24 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuRPC: PikkuCommand = async (
-  logger,
-  { rpcInternalWiringMetaFile },
-  { rpc }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding RPCs tasks',
-    'Found RPCs',
-    [false],
-    async () => {
-      if (rpc.internalFiles.size > 0) {
-        await writeFileInDir(
-          logger,
-          rpcInternalWiringMetaFile,
-          `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`
-        )
-      }
-    }
-  )
-}