@pikku/cli 0.9.14 → 0.9.16-next.0

package/bin/pikku-all.ts

@@ -1,349 +0,0 @@
-import { Command } from 'commander'
-import {
-  CLILogger,
-  getFileImportRelativePath,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuHTTP } from '../src/wirings/http/pikku-command-http-routes.js'
-import { pikkuFunctionTypes } from '../src/wirings/functions/pikku-command-function-types.js'
-import { pikkuHTTPMap } from '../src/wirings/http/pikku-command-http-map.js'
-import { existsSync } from 'fs'
-import { pikkuChannelsMap } from '../src/wirings/channels/pikku-command-channels-map.js'
-import { pikkuChannels } from '../src/wirings/channels/pikku-command-channels.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-import chokidar from 'chokidar'
-import { pikkuFunctions } from '../src/wirings/functions/pikku-command-functions.js'
-import { pikkuServices } from '../src/wirings/functions/pikku-command-services.js'
-import { pikkuRPC } from '../src/wirings/rpc/pikku-command-rpc.js'
-import {
-  pikkuRPCExposedMap,
-  pikkuRPCInternalMap,
-} from '../src/wirings/rpc/pikku-command-rpc-map.js'
-import { pikkuQueue } from '../src/wirings/queue/pikku-command-queue.js'
-import { pikkuQueueMap } from '../src/wirings/queue/pikku-command-queue-map.js'
-import { pikkuFetch } from '../src/wirings/fetch/index.js'
-import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js'
-import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js'
-import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js'
-import { pikkuMCP } from '../src/wirings/mcp/pikku-command-mcp.js'
-import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js'
-import { pikkuScheduler } from '../src/wirings/scheduler/pikku-command-scheduler.js'
-import { pikkuSchemas } from '../src/schemas.js'
-import { pikkuMCPJSON } from '../src/wirings/mcp/pikku-command-mcp-json.js'
-import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js'
-
-const generateBootstrapFile = async (
-  logger: CLILogger,
-  cliConfig: PikkuCLIConfig,
-  bootstrapFile: string,
-  specificImports: string[],
-  schemas?: boolean
-) => {
-  // Common imports that every bootstrap file needs
-  const commonImports = [
-    cliConfig.functionsMetaMinFile,
-    cliConfig.functionsFile,
-  ]
-
-  // Add schema if it exists
-  if (schemas) {
-    commonImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`)
-  }
-
-  // Combine common imports with specific imports
-  const allImports = [...commonImports, ...specificImports]
-
-  await writeFileInDir(
-    logger,
-    bootstrapFile,
-    allImports
-      .map(
-        (to) =>
-          `import '${getFileImportRelativePath(bootstrapFile, to, cliConfig.packageMappings)}'`
-      )
-      .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
-      .join('\n')
-  )
-}
-
-const runAll = async (
-  logger: CLILogger,
-  cliConfig: PikkuCLIConfig,
-  options: PikkuCLIOptions
-) => {
-  const allImports: string[] = []
-
-  let typesDeclarationFileExists = true
-  let visitState = await inspectorGlob(
-    logger,
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-
-  if (!existsSync(cliConfig.typesDeclarationFile)) {
-    typesDeclarationFileExists = false
-  }
-  await pikkuFunctionTypes(logger, cliConfig, visitState, options)
-
-  // This is needed since the wireHTTP function will add the routes to the visitState
-  if (!typesDeclarationFileExists) {
-    logger.info(`• Type file first created, inspecting again...\x1b[0m`)
-    visitState = await inspectorGlob(
-      logger,
-      cliConfig.rootDir,
-      cliConfig.srcDirectories,
-      cliConfig.filters
-    )
-  }
-
-  const functions = pikkuFunctions(logger, cliConfig, visitState)
-  if (!functions) {
-    logger.info(`• No functions found, skipping remaining steps...\x1b[0m`)
-    process.exit(1)
-  }
-
-  // Base imports for all bootstrap files
-  allImports.push(cliConfig.functionsMetaFile, cliConfig.functionsFile)
-
-  // Generate services map
-  await pikkuServices(logger, cliConfig, visitState)
-
-  await pikkuRPC(logger, cliConfig, visitState)
-  await pikkuRPCInternalMap(logger, cliConfig, visitState)
-  await pikkuRPCExposedMap(logger, cliConfig, visitState)
-  await pikkuRPCClient(logger, cliConfig)
-
-  allImports.push(cliConfig.rpcInternalWiringMetaFile)
-
-  const schemas = await pikkuSchemas(logger, cliConfig, visitState)
-  if (schemas) {
-    allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`)
-  }
-
-  // RPC bootstrap is always generated since RPC is always present
-  await generateBootstrapFile(
-    logger,
-    cliConfig,
-    cliConfig.bootstrapFiles.rpc,
-    [],
-    schemas
-  )
-
-  const http = await pikkuHTTP(logger, cliConfig, visitState)
-  if (http) {
-    await pikkuHTTPMap(logger, cliConfig, visitState)
-    await pikkuFetch(logger, cliConfig)
-    allImports.push(cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile)
-
-    await generateBootstrapFile(
-      logger,
-      cliConfig,
-      cliConfig.bootstrapFiles.http,
-      [cliConfig.httpWiringMetaFile, cliConfig.httpWiringsFile],
-      schemas
-    )
-  }
-
-  const scheduler = await pikkuScheduler(logger, cliConfig, visitState)
-  if (scheduler) {
-    allImports.push(
-      cliConfig.schedulersWiringMetaFile,
-      cliConfig.schedulersWiringFile
-    )
-
-    await generateBootstrapFile(
-      logger,
-      cliConfig,
-      cliConfig.bootstrapFiles.scheduler,
-      [cliConfig.schedulersWiringMetaFile, cliConfig.schedulersWiringFile],
-      schemas
-    )
-  }
-
-  const queues = await pikkuQueue(logger, cliConfig, visitState)
-  if (queues) {
-    await pikkuQueueMap(logger, cliConfig, visitState)
-    await pikkuQueueService(logger, cliConfig)
-    allImports.push(
-      cliConfig.queueWorkersWiringMetaFile,
-      cliConfig.queueWorkersWiringFile
-    )
-
-    await generateBootstrapFile(
-      logger,
-      cliConfig,
-      cliConfig.bootstrapFiles.queue,
-      [cliConfig.queueWorkersWiringMetaFile, cliConfig.queueWorkersWiringFile],
-      schemas
-    )
-  }
-
-  const channels = await pikkuChannels(logger, cliConfig, visitState)
-  if (channels) {
-    await pikkuChannelsMap(logger, cliConfig, visitState)
-    await pikkuWebSocketTyped(logger, cliConfig)
-    allImports.push(
-      cliConfig.channelsWiringMetaFile,
-      cliConfig.channelsWiringFile
-    )
-
-    await generateBootstrapFile(
-      logger,
-      cliConfig,
-      cliConfig.bootstrapFiles.channel,
-      [cliConfig.channelsWiringMetaFile, cliConfig.channelsWiringFile],
-      schemas
-    )
-  }
-
-  const mcp = await pikkuMCP(logger, cliConfig, visitState)
-  if (mcp) {
-    await pikkuMCPJSON(logger, cliConfig, visitState)
-    allImports.push(cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile)
-
-    await generateBootstrapFile(
-      logger,
-      cliConfig,
-      cliConfig.bootstrapFiles.mcp,
-      [cliConfig.mcpWiringsMetaFile, cliConfig.mcpWiringsFile],
-      schemas
-    )
-  }
-
-  if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
-    await pikkuNext(logger, cliConfig, visitState, options)
-  }
-
-  if (cliConfig.openAPI) {
-    logger.info(
-      `• OpenAPI requires a reinspection to pickup new generated types..`
-    )
-    visitState = await inspectorGlob(
-      logger,
-      cliConfig.rootDir,
-      cliConfig.srcDirectories,
-      cliConfig.filters
-    )
-    await pikkuOpenAPI(logger, cliConfig, visitState)
-  }
-
-  // Generate main bootstrap file (pass all imports directly since this is the main file)
-  await writeFileInDir(
-    logger,
-    cliConfig.bootstrapFile,
-    allImports
-      .map(
-        (to) =>
-          `import '${getFileImportRelativePath(cliConfig.bootstrapFile, to, cliConfig.packageMappings)}'`
-      )
-      .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
-      .join('\n')
-  )
-}
-
-const watch = (
-  logger: CLILogger,
-  cliConfig: PikkuCLIConfig,
-  options: PikkuCLIOptions
-) => {
-  const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
-    ignoreInitial: true,
-    ignored: /.*\.gen\.tsx?/,
-  })
-
-  let watcher = new chokidar.FSWatcher({})
-
-  const generatorWatcher = () => {
-    watcher.close()
-
-    logger.info(
-      `• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`
-    )
-    watcher = chokidar.watch(cliConfig.srcDirectories, {
-      ignoreInitial: true,
-      ignored: /.*\.gen\.ts/,
-    })
-
-    watcher.on('ready', async () => {
-      const handle = async () => {
-        try {
-          const start = Date.now()
-          await runAll(logger, cliConfig, options)
-          if (options.silent) {
-            logger.timing(`✓ Generated in ${Date.now() - start}ms`)
-          }
-        } catch (err) {
-          console.error(err)
-          console.info()
-        }
-      }
-
-      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)
-}
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true, silent: options.silent })
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    [],
-    {
-      tags: options.tags,
-      types: options.types,
-      directories: options.directories,
-    },
-    true
-  )
-
-  if (options.watch) {
-    watch(logger, cliConfig, options)
-  } else {
-    await runAll(logger, cliConfig, options)
-  }
-}
-
-export const all = (program: Command): void => {
-  program
-    .command('all', { isDefault: true })
-    .description('Generate all the files used by pikku')
-    .option('--pikku-config-type', 'The type of your pikku config object')
-    .option(
-      '--singleton-services-factory-type',
-      'The type of your singleton services factory'
-    )
-    .option(
-      '--session-services-factory-type',
-      'The type of your session services factory'
-    )
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .option('-t | --tags <tags...>', 'Which tags to filter by')
-    .option(
-      '--types <types...>',
-      'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)'
-    )
-    .option('--directories <directories...>', 'Which directories to filter by')
-    .option('-w | --watch', 'Whether to watch file changes')
-    .option('-s | --silent', 'Silent mode - only show errors')
-    .action(action)
-}

package/bin/pikku-fetch.ts

@@ -1,27 +0,0 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuFetch } from '../src/wirings/fetch/index.js'
-import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true })
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    {
-      tags: options.tags,
-      types: options.types,
-      directories: options.directories,
-    },
-    true
-  )
-  await pikkuFetch(logger, cliConfig)
-}
-
-export const fetch = (program: Command): void => {
-  program
-    .command('fetch')
-    .description('generate fetch wrapper')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-nextjs.ts

@@ -1,44 +0,0 @@
-import { Command } from 'commander'
-import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js'
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true })
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'schemaDirectory', 'configDir'],
-    {
-      tags: options.tags,
-      types: options.types,
-      directories: options.directories,
-    },
-    true
-  )
-  const visitState = await inspectorGlob(
-    logger,
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuNext(logger, cliConfig, visitState, options)
-}
-
-export const nextjs = (program: Command): void => {
-  program
-    .command('nextjs')
-    .description('generate nextjs wrapper')
-    .option('--pikku-config-type', 'The type of your pikku config object')
-    .option(
-      '--singleton-services-factory-type',
-      'The type of your singleton services factory'
-    )
-    .option(
-      '--session-services-factory-type',
-      'The type of your session services factory'
-    )
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-openapi.ts

@@ -1,31 +0,0 @@
-import { Command } from 'commander'
-import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-import { pikkuOpenAPI } from '../src/wirings/http/pikku-command-openapi.js'
-
-async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
-  const logger = new CLILogger({ logLogo: true })
-  const cliConfig = await getPikkuCLIConfig(
-    config,
-    ['rootDir', 'httpWiringsFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
-    {
-      tags: tags || [],
-    }
-  )
-  const visitState = await inspectorGlob(
-    logger,
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuOpenAPI(logger, cliConfig, visitState)
-}
-
-export const openapi = (program: Command): void => {
-  program
-    .command('openapi')
-    .description('Generate an openapi spec')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-queue-service.ts

@@ -1,28 +0,0 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
-import { pikkuQueueService } from '../src/wirings/queue/pikku-command-queue-service.js'
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true })
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'schemaDirectory', 'configDir', 'queueWiringsFile'],
-    {
-      tags: options.tags,
-      types: options.types,
-      directories: options.directories,
-    },
-    true
-  )
-  await pikkuQueueService(logger, cliConfig)
-}
-
-export const queue = (program: Command): void => {
-  program
-    .command('queue')
-    .description('generate queue service wrapper')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-rpc.ts

@@ -1,28 +0,0 @@
-import { Command } from 'commander'
-import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuRPCClient } from '../src/wirings/rpc/pikku-command-rpc-client.js'
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true })
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    {
-      tags: options.tags,
-      types: options.types,
-      directories: options.directories,
-    },
-    true
-  )
-  await pikkuRPCClient(logger, cliConfig)
-}
-
-export const rpc = (program: Command): void => {
-  program
-    .command('rpc')
-    .description('generate rpc wrapper')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-schemas.ts

@@ -1,31 +0,0 @@
-import { Command } from 'commander'
-
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
-import { pikkuSchemas } from '../src/schemas.js'
-import { CLILogger } from '../src/utils.js'
-
-async function action({ config }: { config?: string }): Promise<void> {
-  const logger = new CLILogger({ logLogo: true })
-
-  const cliConfig = await getPikkuCLIConfig(config, [
-    'srcDirectories',
-    'schemaDirectory',
-    'tsconfig',
-  ])
-  const visitState = await inspectorGlob(
-    logger,
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuSchemas(logger, cliConfig, visitState)
-}
-
-export const schemas = (program: Command): void => {
-  program
-    .command('schemas')
-    .description('Generate schemas for all the expected function input types')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-websocket.ts

@@ -1,28 +0,0 @@
-import { Command } from 'commander'
-import { CLILogger, PikkuCLIOptions } from '../src/utils.js'
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { pikkuWebSocketTyped } from '../src/wirings/channels/pikku-command-websocket-typed.js'
-
-export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true })
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    {
-      tags: options.tags,
-      types: options.types,
-      directories: options.directories,
-    },
-    true
-  )
-  await pikkuWebSocketTyped(logger, cliConfig)
-}
-
-export const websocket = (program: Command): void => {
-  program
-    .command('websocket')
-    .description('generate websocket wrapper')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/dist/bin/pikku-all.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
-export declare const action: (options: PikkuCLIOptions) => Promise<void>;
-export declare const all: (program: Command) => void;