@pikku/cli 0.9.14 → 0.9.16-next.0

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

@@ -1,48 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-import {
-  generateRuntimeMeta,
-  serializeFunctionImports,
-} from './serialize-function-imports.js'
-
-export const pikkuFunctions: PikkuCommand = async (
-  logger,
-  { functionsMetaFile, functionsMetaMinFile, functionsFile, packageMappings },
-  { functions, rpc }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Serializing Pikku functions',
-    'Serialized Pikku functions',
-    [false],
-    async () => {
-      // 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)})`
-      )
-
-      if (rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0) {
-        await writeFileInDir(
-          logger,
-          functionsFile,
-          serializeFunctionImports(
-            functionsFile,
-            rpc.internalFiles,
-            functions.meta,
-            packageMappings
-          )
-        )
-      }
-    }
-  )
-}

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

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

@@ -1,43 +0,0 @@
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { serializeSchedulerMeta } from './serialize-scheduler-meta.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuScheduler: PikkuCommand = async (
-  logger,
-  cliConfig,
-  visitState
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding scheduled tasks',
-    'Found scheduled tasks',
-    [visitState.scheduledTasks.files.size === 0],
-    async () => {
-      const {
-        schedulersWiringFile,
-        schedulersWiringMetaFile,
-        packageMappings,
-      } = cliConfig
-      const { scheduledTasks } = visitState
-      await writeFileInDir(
-        logger,
-        schedulersWiringMetaFile,
-        serializeSchedulerMeta(scheduledTasks.meta)
-      )
-      await writeFileInDir(
-        logger,
-        schedulersWiringFile,
-        serializeFileImports(
-          'addScheduledTasks',
-          schedulersWiringFile,
-          scheduledTasks.files,
-          packageMappings
-        )
-      )
-    }
-  )
-}