@pikku/cli 0.11.3 → 0.12.1

package/run-tests.sh

@@ -1,53 +0,0 @@
-#!/bin/bash
-
-# Enable nullglob to handle cases where no files match the pattern
-shopt -s nullglob
-
-# Initialize variables for options
-watch_mode=false
-coverage_mode=false
-
-# Parse command-line options
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --watch)
-      watch_mode=true
-      shift
-      ;;
-    --coverage)
-      coverage_mode=true
-      shift
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Define the pattern to match your test files
-pattern="src/*.test.ts"
-
-# Expand the pattern into an array of files
-files=($(find src -type f -name "*.test.ts"))
-
-# Check if any files matched the pattern
-if [ ${#files[@]} -eq 0 ]; then
-  echo "No test files found matching pattern: $pattern"
-  exit 0
-fi
-
-# Construct the node command
-node_cmd="node --import tsx --test"
-
-# Append options based on flags
-if [ "$watch_mode" = true ]; then
-  node_cmd="$node_cmd --watch"
-fi
-
-if [ "$coverage_mode" = true ]; then
-  node_cmd="$node_cmd --test-coverage-include=\"src/**/*.{ts,js}\" --test-coverage-exclude=\"**/dist/**\" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info"
-fi
-
-# Execute the node command with the expanded list of files
-$node_cmd "${files[@]}"

package/src/cli.wiring.ts

@@ -1,112 +0,0 @@
-import { pikkuSchemas } from './functions/wirings/functions/schemas.js'
-import { pikkuFetch } from './functions/wirings/fetch/index.js'
-import { pikkuWebSocketTyped } from './functions/wirings/channels/pikku-command-websocket-typed.js'
-import { pikkuRPCClient } from './functions/wirings/rpc/pikku-command-rpc-client.js'
-import { pikkuQueueService } from './functions/wirings/queue/pikku-command-queue-service.js'
-import { pikkuOpenAPI } from './functions/wirings/http/pikku-command-openapi.js'
-import { pikkuNext } from './functions/runtimes/nextjs/pikku-command-nextjs.js'
-import { pikkuCLICommand, wireCLI } from '../.pikku/cli/pikku-cli-types.gen.js'
-import { all } from './functions/commands/all.js'
-import { bootstrap } from './functions/commands/bootstrap.js'
-import { watch } from './functions/commands/watch.js'
-// import { clientCLIRenderer } from './services.js'
-
-wireCLI({
-  program: 'pikku',
-  description:
-    'Pikku CLI - Code generation tool for type-safe backend development',
-  // render: clientCLIRenderer,
-  options: {
-    config: {
-      description: 'Path to pikku.config.json file',
-      short: 'c',
-    },
-    logLevel: {
-      description: 'Set log level',
-      default: 'info' as const,
-      short: 'l',
-    },
-    userSessionType: {
-      description:
-        'Specify which UserSession type to use (when multiple exist)',
-    },
-    singletonServicesFactoryType: {
-      description: 'Specify which singleton services factory to use',
-    },
-    wireServicesFactoryType: {
-      description: 'Specify which wire services factory to use',
-    },
-    stateOutput: {
-      description: 'Save inspector state to JSON file for reuse',
-    },
-    stateInput: {
-      description: 'Load inspector state from JSON file (skips inspection)',
-    },
-  },
-  commands: {
-    all: pikkuCLICommand({
-      func: all,
-      description: 'Generate all Pikku files (types, schemas, wirings, etc.)',
-      isDefault: true,
-      options: {
-        tags: {
-          description: 'Filter functions by tags (comma-separated)',
-          short: 't',
-        },
-        types: {
-          description: 'Filter functions by types (comma-separated)',
-        },
-        directories: {
-          description: 'Filter functions by directories (comma-separated)',
-          short: 'd',
-        },
-        httpMethods: {
-          description: 'Filter HTTP routes by methods (comma-separated)',
-        },
-        httpRoutes: {
-          description: 'Filter HTTP routes by route patterns (comma-separated)',
-        },
-        names: {
-          description: 'Filter functions by name patterns (supports wildcards)',
-          short: 'n',
-        },
-      },
-    }),
-    bootstrap: pikkuCLICommand({
-      func: bootstrap,
-      description: 'Generate only type files (setup phase only)',
-    }),
-    watch: pikkuCLICommand({
-      func: watch,
-      description: 'Watch for file changes and regenerate automatically',
-    }),
-    schemas: pikkuCLICommand({
-      func: pikkuSchemas,
-      description: 'Generate JSON schemas for function input/output types',
-    }),
-    fetch: pikkuCLICommand({
-      func: pikkuFetch,
-      description: 'Generate type-safe HTTP fetch client',
-    }),
-    websocket: pikkuCLICommand({
-      func: pikkuWebSocketTyped,
-      description: 'Generate type-safe WebSocket client',
-    }),
-    rpc: pikkuCLICommand({
-      func: pikkuRPCClient,
-      description: 'Generate RPC client wrappers',
-    }),
-    'queue-service': pikkuCLICommand({
-      func: pikkuQueueService,
-      description: 'Generate queue service wrapper',
-    }),
-    openapi: pikkuCLICommand({
-      func: pikkuOpenAPI,
-      description: 'Generate OpenAPI specification from HTTP routes',
-    }),
-    nextjs: pikkuCLICommand({
-      func: pikkuNext,
-      description: 'Generate Next.js backend and HTTP wrappers',
-    }),
-  },
-})

package/src/functions/commands/all.ts

@@ -1,313 +0,0 @@
-import { existsSync } from 'fs'
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
-import { getFileImportRelativePath } from '../../utils/file-import-path.js'
-import { writeFileInDir } from '../../utils/file-writer.js'
-import { CommandSummary } from '../../utils/command-summary.js'
-
-import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js'
-import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js'
-import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js'
-import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js'
-import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js'
-import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js'
-import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js'
-import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js'
-import { pikkuFunctions } from '../wirings/functions/pikku-command-functions.js'
-import { pikkuMiddleware } from '../wirings/middleware/pikku-command-middleware.js'
-import { pikkuPermissions } from '../wirings/permissions/pikku-command-permissions.js'
-import { pikkuServices } from '../wirings/functions/pikku-command-services.js'
-import { pikkuServiceMetadata } from '../wirings/services/pikku-command-service-metadata.js'
-import { pikkuRPC } from '../wirings/rpc/pikku-command-rpc.js'
-import {
-  pikkuRPCExposedMap,
-  pikkuRPCInternalMap,
-} from '../wirings/rpc/pikku-command-rpc-map.js'
-import { pikkuPublicRPC } from '../wirings/rpc/pikku-command-public-rpc.js'
-import { pikkuRPCClient } from '../wirings/rpc/pikku-command-rpc-client.js'
-import { pikkuSchemas } from '../wirings/functions/schemas.js'
-import { pikkuHTTP } from '../wirings/http/pikku-command-http-routes.js'
-import { pikkuHTTPMap } from '../wirings/http/pikku-command-http-map.js'
-import { pikkuFetch } from '../wirings/fetch/index.js'
-import { pikkuScheduler } from '../wirings/scheduler/pikku-command-scheduler.js'
-import { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.js'
-import { pikkuRemoteRPC } from '../wirings/rpc/pikku-command-remote-rpc.js'
-import { pikkuQueue } from '../wirings/queue/pikku-command-queue.js'
-import { pikkuQueueMap } from '../wirings/queue/pikku-command-queue-map.js'
-import { pikkuQueueService } from '../wirings/queue/pikku-command-queue-service.js'
-import { pikkuChannels } from '../wirings/channels/pikku-command-channels.js'
-import { pikkuChannelsMap } from '../wirings/channels/pikku-command-channels-map.js'
-import { pikkuWebSocketTyped } from '../wirings/channels/pikku-command-websocket-typed.js'
-import { pikkuMCP } from '../wirings/mcp/pikku-command-mcp.js'
-import { pikkuMCPJSON } from '../wirings/mcp/pikku-command-mcp-json.js'
-import { pikkuCLI } from '../wirings/cli/pikku-command-cli.js'
-import { pikkuCLIEntry } from '../wirings/cli/pikku-command-cli-entry.js'
-import { pikkuNext } from '../runtimes/nextjs/pikku-command-nextjs.js'
-import { pikkuOpenAPI } from '../wirings/http/pikku-command-openapi.js'
-import { pikkuPackage } from '../wirings/package/pikku-command-package.js'
-import { pikkuForgeNodes } from '../wirings/forge/pikku-command-forge-nodes.js'
-import { pikkuForgeTypes } from '../wirings/forge/pikku-command-forge-types.js'
-import { PikkuWire } from '@pikku/core'
-
-export const all: any = pikkuVoidFunc({
-  func: async ({ logger, config, getInspectorState }) => {
-    const wire: PikkuWire = {}
-    const services = { logger, config, getInspectorState }
-    const summary = new CommandSummary('all')
-    const allImports: string[] = []
-    let typesDeclarationFileExists = true
-
-    if (!existsSync(config.typesDeclarationFile)) {
-      typesDeclarationFileExists = false
-    }
-
-    await pikkuFunctionTypes.func(services, null, wire)
-
-    if (!typesDeclarationFileExists) {
-      logger.debug(`• Type file first created, inspecting again...`)
-      await getInspectorState(true)
-    }
-
-    await pikkuFunctionTypesSplit.func(services, null, wire)
-
-    if (!config.externalPackage) {
-      await pikkuHTTPTypes.func(services, null, wire)
-      await pikkuChannelTypes.func(services, null, wire)
-      await pikkuSchedulerTypes.func(services, null, wire)
-      await pikkuQueueTypes.func(services, null, wire)
-      await pikkuMCPTypes.func(services, null, wire)
-      await pikkuCLITypes.func(services, null, wire)
-    }
-
-    const hasFunctionRegistrations = await pikkuFunctions.func(
-      services,
-      wire,
-      null
-    )
-
-    const middleware = await pikkuMiddleware.func(services, null, wire)
-    if (middleware) {
-      allImports.push(config.middlewareFile)
-    }
-
-    const permissions = await pikkuPermissions.func(services, null, wire)
-    if (permissions) {
-      allImports.push(config.permissionsFile)
-    }
-
-    allImports.push(config.functionsMetaFile)
-
-    if (hasFunctionRegistrations) {
-      allImports.push(config.functionsFile)
-    }
-
-    await pikkuServices.func(services, null, wire)
-    await pikkuServiceMetadata.func(services, null, wire)
-
-    const hasPackageFactories = await pikkuPackage.func(services, null, wire)
-    if (hasPackageFactories) {
-      allImports.push(config.packageFile)
-    }
-
-    const hasInternalRPCs = await pikkuRPC.func(services, null, wire)
-
-    const schemas = await pikkuSchemas.func(services, null, wire)
-    if (schemas) {
-      allImports.push(`${config.schemaDirectory}/register.gen.ts`)
-    }
-
-    await pikkuRPCInternalMap.func(services, null, wire)
-    await pikkuRPCExposedMap.func(services, null, wire)
-    await pikkuPublicRPC.func(services, null, wire)
-    await pikkuRPCClient.func(services, null, wire)
-
-    await pikkuForgeTypes.func(services, null, wire)
-
-    if (hasInternalRPCs) {
-      allImports.push(config.rpcInternalWiringMetaFile)
-    }
-
-    if (!config.externalPackage) {
-      const http = await pikkuHTTP.func(services, null, wire)
-      if (http) {
-        await pikkuHTTPMap.func(services, null, wire)
-        await pikkuFetch.func(services, null, wire)
-        allImports.push(config.httpWiringMetaFile, config.httpWiringsFile)
-      }
-
-      const scheduler = await pikkuScheduler.func(services, null, wire)
-      if (scheduler) {
-        allImports.push(
-          config.schedulersWiringMetaFile,
-          config.schedulersWiringFile
-        )
-      }
-    }
-
-    const workflows = await pikkuWorkflow.func(services, null, wire)
-
-    let remoteRPC = false
-    if (!config.externalPackage) {
-      remoteRPC = await pikkuRemoteRPC.func(services, null, wire)
-    }
-
-    if (workflows || remoteRPC) {
-      await getInspectorState(true)
-    }
-
-    if (workflows) {
-      allImports.push(config.workflowsWiringFile)
-    }
-
-    if (!config.externalPackage) {
-      const queues = await pikkuQueue.func(services, null, wire)
-      if (queues) {
-        await pikkuQueueMap.func(services, null, wire)
-        await pikkuQueueService.func(services, null, wire)
-        allImports.push(
-          config.queueWorkersWiringMetaFile,
-          config.queueWorkersWiringFile
-        )
-      }
-
-      const channels = await pikkuChannels.func(services, null, wire)
-      if (channels) {
-        await pikkuChannelsMap.func(services, null, wire)
-        await pikkuWebSocketTyped.func(services, null, wire)
-        allImports.push(
-          config.channelsWiringMetaFile,
-          config.channelsWiringFile
-        )
-      }
-
-      const mcp = await pikkuMCP.func(services, null, wire)
-      if (mcp) {
-        await pikkuMCPJSON.func(services, null, wire)
-        allImports.push(config.mcpWiringsMetaFile, config.mcpWiringsFile)
-      }
-
-      const cli = await pikkuCLI.func(services, null, wire)
-      if (cli) {
-        await pikkuCLIEntry.func(services, null, wire)
-        allImports.push(config.cliWiringMetaFile, config.cliWiringsFile)
-      }
-    }
-
-    await pikkuForgeNodes.func(services, null, wire)
-
-    if (config.nextBackendFile || config.nextHTTPFile) {
-      await pikkuNext.func(services, null, wire)
-    }
-
-    if (config.openAPI) {
-      logger.debug(
-        `• OpenAPI requires a reinspection to pickup new generated types..`
-      )
-      await getInspectorState(true)
-      await pikkuOpenAPI.func(services, null, wire)
-    }
-
-    const stateBeforeBootstrap = await getInspectorState()
-    const externalPackageBootstraps: string[] = []
-    const usedExternalPackages: Record<string, string> = {}
-    if (
-      config.externalPackages &&
-      stateBeforeBootstrap.rpc?.usedExternalPackages?.size > 0
-    ) {
-      for (const namespace of stateBeforeBootstrap.rpc.usedExternalPackages) {
-        const packageName = config.externalPackages[namespace]
-        if (packageName) {
-          const packageBootstrap = `${packageName}/.pikku/pikku-bootstrap.gen.js`
-          externalPackageBootstraps.push(packageBootstrap)
-          usedExternalPackages[namespace] = packageName
-          logger.debug(
-            `• External package detected: ${namespace} (${packageName})`
-          )
-        }
-      }
-    }
-
-    const localImports = allImports.map(
-      (to) =>
-        `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`
-    )
-    const externalImports = externalPackageBootstraps.map(
-      (packagePath) => `import '${packagePath}'`
-    )
-
-    let externalPackagesRegistration = ''
-    if (Object.keys(usedExternalPackages).length > 0) {
-      externalPackagesRegistration = `
-// Register external package mappings
-import { pikkuState } from '@pikku/core'
-const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
-${Object.entries(usedExternalPackages)
-  .map(([ns, pkg]) => `externalPackages.set('${ns}', '${pkg}')`)
-  .join('\n')}
-`
-    }
-
-    const allBootstrapImports =
-      [...localImports, ...externalImports]
-        .sort((a, b) => {
-          const aMeta = a.includes('meta')
-          const bMeta = b.includes('meta')
-          if (aMeta && !bMeta) return -1
-          if (!aMeta && bMeta) return 1
-          return 0
-        })
-        .join('\n') + externalPackagesRegistration
-
-    await writeFileInDir(logger, config.bootstrapFile, allBootstrapImports)
-
-    const state = await getInspectorState()
-    if (state.http?.meta) {
-      const httpRouteCount = (
-        Object.values(state.http.meta) as Record<string, unknown>[]
-      ).reduce((sum, routes) => sum + Object.keys(routes).length, 0)
-      if (httpRouteCount > 0) summary.set('httpRoutes', httpRouteCount)
-    }
-    if (state.channels?.meta)
-      summary.set('channels', Object.keys(state.channels.meta).length)
-    if (state.scheduledTasks?.meta)
-      summary.set(
-        'scheduledTasks',
-        Object.keys(state.scheduledTasks.meta).length
-      )
-    if (state.queueWorkers?.meta)
-      summary.set('queueWorkers', Object.keys(state.queueWorkers.meta).length)
-    if (state.mcpEndpoints) {
-      const mcpTotal =
-        Object.keys(state.mcpEndpoints.toolsMeta || {}).length +
-        Object.keys(state.mcpEndpoints.resourcesMeta || {}).length +
-        Object.keys(state.mcpEndpoints.promptsMeta || {}).length
-      if (mcpTotal > 0) summary.set('mcpEndpoints', mcpTotal)
-    }
-    if (state.cli?.meta) {
-      const totalCommands: number = Object.values(state.cli.meta).reduce(
-        (sum: number, program: any) => sum + (program.commands?.length || 0),
-        0
-      )
-      if (totalCommands > 0) summary.set('cliCommands', totalCommands)
-    }
-    if (state.workflows?.meta) {
-      summary.set('workflows', Object.keys(state.workflows.meta).length)
-    }
-    if (state.forgeNodes?.meta) {
-      const forgeNodesCount = Object.keys(state.forgeNodes.meta).length
-      if (forgeNodesCount > 0) summary.set('forgeNodes', forgeNodesCount)
-    }
-    if (state.workflows?.graphMeta) {
-      const workflowGraphsCount = Object.keys(state.workflows.graphMeta).length
-      if (workflowGraphsCount > 0)
-        summary.set('workflowGraphs', workflowGraphsCount)
-    }
-
-    if (!logger.isSilent()) {
-      console.log(summary.format())
-    }
-
-    if (logger.hasCriticalErrors()) {
-      process.exit(1)
-    }
-  },
-})

package/src/functions/commands/bootstrap.ts

@@ -1,35 +0,0 @@
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
-import { pikkuFunctionTypes } from '../wirings/functions/pikku-command-function-types.js'
-import { pikkuFunctionTypesSplit } from '../wirings/functions/pikku-command-function-types-split.js'
-import { pikkuHTTPTypes } from '../wirings/http/pikku-command-http-types.js'
-import { pikkuChannelTypes } from '../wirings/channels/pikku-command-channel-types.js'
-import { pikkuSchedulerTypes } from '../wirings/scheduler/pikku-command-scheduler-types.js'
-import { pikkuQueueTypes } from '../wirings/queue/pikku-command-queue-types.js'
-import { pikkuWorkflow } from '../wirings/workflow/pikku-command-workflow.js'
-import { pikkuMCPTypes } from '../wirings/mcp/pikku-command-mcp-types.js'
-import { pikkuCLITypes } from '../wirings/cli/pikku-command-cli-types.js'
-import { PikkuWire } from '@pikku/core'
-
-export const bootstrap: any = pikkuVoidFunc({
-  func: async ({ logger, config, getInspectorState }) => {
-    const wire: PikkuWire = {}
-    const services = { logger, config, getInspectorState }
-
-    await getInspectorState(false, false, true)
-
-    await pikkuFunctionTypes.func(services, null, wire)
-
-    await pikkuFunctionTypesSplit.func(services, null, wire)
-    await pikkuHTTPTypes.func(services, null, wire)
-    await pikkuChannelTypes.func(services, null, wire)
-    await pikkuSchedulerTypes.func(services, null, wire)
-    await pikkuQueueTypes.func(services, null, wire)
-    await pikkuWorkflow.func(services, null, wire)
-    await pikkuMCPTypes.func(services, null, wire)
-    await pikkuCLITypes.func(services, null, wire)
-
-    if (logger.hasCriticalErrors()) {
-      process.exit(1)
-    }
-  },
-})

package/src/functions/commands/watch.ts

@@ -1,61 +0,0 @@
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js'
-import chokidar from 'chokidar'
-import { all } from './all.js'
-
-export const watch: any = pikkuVoidFunc({
-  func: async ({ logger, config, getInspectorState }) => {
-    const services = { logger, config, getInspectorState }
-    const configWatcher = chokidar.watch(config.srcDirectories, {
-      ignoreInitial: true,
-      ignored: /.*\.gen\.tsx?/,
-    })
-
-    let watcher = new chokidar.FSWatcher({})
-
-    const generatorWatcher = () => {
-      watcher.close()
-
-      logger.info(
-        `• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`
-      )
-      watcher = chokidar.watch(config.srcDirectories, {
-        ignoreInitial: true,
-        ignored: /.*\.gen\.ts/,
-      })
-
-      watcher.on('ready', async () => {
-        const handle = async () => {
-          try {
-            const start = Date.now()
-            await all.func(services, null, {})
-            logger.info({
-              message: `✓ Generated in ${Date.now() - start}ms`,
-              type: 'timing',
-            })
-          } catch (err) {
-            console.error(err)
-            logger.error('Error running watch')
-          }
-        }
-
-        await handle()
-
-        let timeout: ReturnType<typeof setTimeout> | undefined
-
-        const deduped = (_file: string) => {
-          if (timeout) {
-            clearTimeout(timeout)
-          }
-          timeout = setTimeout(handle, 10)
-        }
-
-        watcher.on('change', deduped)
-        watcher.on('add', deduped)
-        watcher.on('unlink', deduped)
-      })
-    }
-
-    configWatcher.on('ready', generatorWatcher)
-    configWatcher.on('change', generatorWatcher)
-  },
-})