@pikku/cli 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @pikku/cli
 
+## 0.8.1
+
+### Patch Changes
+
+- 44e3ff4: feat: enhance CLI filtering with type and directory filters
+
+  - Add --types filter to filter by PikkuEventTypes (http, channel, queue, scheduler, rpc, mcp)
+  - Add --directories filter to filter by file paths/directories
+  - All filters (tags, types, directories) now work together with AND logic
+  - Add comprehensive logging interface to inspector package
+  - Add comprehensive test suite for matchesFilters function
+  - Support cross-platform path handling
+
+- 7c592b8: feat: support for required services and improved service configuration
+
+  This release includes several enhancements to service management and configuration:
+
+  - Added support for required services configuration
+  - Improved service discovery and registration
+  - Added typed RPC clients for service communication
+  - Updated middleware to run per function
+
+- Updated dependencies [3261090]
+- Updated dependencies [44e3ff4]
+- Updated dependencies [7c592b8]
+- Updated dependencies [30a082f]
+  - @pikku/core@0.8.1
+  - @pikku/inspector@0.8.1
+
 ## 0.8.0
 
 ### Major Features

package/bin/pikku-all.ts

@@ -15,58 +15,60 @@ import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 import chokidar from 'chokidar'
 import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js'
+import { pikkuServices } from '../src/events/functions/pikku-command-services.js'
 import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js'
 import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js'
-import { PikkuEventTypes } from '@pikku/core'
 import { pikkuQueue } from '../src/events/queue/pikku-command-queue.js'
 import { pikkuQueueMap } from '../src/events/queue/pikku-command-queue-map.js'
 import { pikkuFetch } from '../src/events/fetch/index.js'
+import { pikkuRPCClient } from '../src/events/rpc/pikku-command-rpc-client.js'
 import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
-import { pikkuNext } from '../src/events/http/pikku-command-nextjs.js'
 import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js'
 import { pikkuMCP } from '../src/events/mcp/pikku-command-mcp.js'
 import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js'
 import { pikkuScheduler } from '../src/events/scheduler/pikku-command-scheduler.js'
 import { pikkuSchemas } from '../src/schemas.js'
 import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js'
+import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js'
 
-const runAll = async (
+const generateBootstrapFile = async (
   logger: CLILogger,
   cliConfig: PikkuCLIConfig,
-  options: PikkuCLIOptions
+  bootstrapFile: string,
+  specificImports: string[],
+  schemas?: boolean
 ) => {
-  const boostrapImports: Partial<
-    Record<PikkuEventTypes, { meta: string[]; events: string[] }>
-  > & { all: { meta: string[]; events: string[] } } = {
-    all: { meta: [], events: [] },
-  }
+  // Common imports that every bootstrap file needs
+  const commonImports = [cliConfig.functionsMetaFile, cliConfig.functionsFile]
 
-  const addImport = (
-    from: string,
-    type: 'meta' | 'events' | 'other',
-    addTo?: PikkuEventTypes[]
-  ) => {
-    if (type === 'meta') {
-      boostrapImports.all.meta.push(from)
-    } else {
-      boostrapImports.all.events.push(from)
-    }
-
-    for (const transport of Object.keys(PikkuEventTypes)) {
-      if (!addTo || addTo?.includes(transport as PikkuEventTypes)) {
-        boostrapImports[transport] = boostrapImports[transport] || {
-          meta: [],
-          events: [],
-        }
-        if (type === 'meta') {
-          boostrapImports[transport].meta.push(from)
-        } else {
-          boostrapImports[transport].events.push(from)
-        }
-      }
-    }
+  // 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,
@@ -96,53 +98,102 @@ const runAll = async (
     logger.info(`• No functions found, skipping remaining steps...\x1b[0m`)
     process.exit(1)
   }
-  addImport(cliConfig.functionsMetaFile, 'meta')
-  addImport(cliConfig.functionsFile, 'events')
+
+  // 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 pikkuRPCMap(logger, cliConfig, visitState)
-  addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc])
+  await pikkuRPCClient(logger, cliConfig)
+  allImports.push(cliConfig.rpcMetaFile)
 
   const schemas = await pikkuSchemas(logger, cliConfig, visitState)
   if (schemas) {
-    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other')
+    allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`)
   }
 
+  // RPC bootstrap is always generated since RPC is always present
+  await generateBootstrapFile(
+    logger,
+    cliConfig,
+    cliConfig.bootstrapFiles.rpc,
+    [cliConfig.rpcMetaFile],
+    schemas
+  )
+
   const http = await pikkuHTTP(logger, cliConfig, visitState)
   if (http) {
     await pikkuHTTPMap(logger, cliConfig, visitState)
     await pikkuFetch(logger, cliConfig)
-    addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http])
-    addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http])
+    allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.http,
+      [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile],
+      schemas
+    )
   }
 
-  const scheduled = await pikkuScheduler(logger, cliConfig, visitState)
-  if (scheduled) {
-    addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled])
-    addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled])
+  const scheduler = await pikkuScheduler(logger, cliConfig, visitState)
+  if (scheduler) {
+    allImports.push(cliConfig.schedulersMetaFile, cliConfig.schedulersFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.scheduler,
+      [cliConfig.schedulersMetaFile, cliConfig.schedulersFile],
+      schemas
+    )
   }
 
   const queues = await pikkuQueue(logger, cliConfig, visitState)
   if (queues) {
     await pikkuQueueMap(logger, cliConfig, visitState)
     await pikkuQueueService(logger, cliConfig)
-    addImport(cliConfig.queueWorkersMetaFile, 'meta', [PikkuEventTypes.queue])
-    addImport(cliConfig.queueWorkersFile, 'events', [PikkuEventTypes.queue])
+    allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.queue,
+      [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile],
+      schemas
+    )
   }
 
   const channels = await pikkuChannels(logger, cliConfig, visitState)
   if (channels) {
     await pikkuChannelsMap(logger, cliConfig, visitState)
     await pikkuWebSocketTyped(logger, cliConfig)
-    addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel])
-    addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel])
+    allImports.push(cliConfig.channelsMetaFile, cliConfig.channelsFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.channel,
+      [cliConfig.channelsMetaFile, cliConfig.channelsFile],
+      schemas
+    )
   }
 
   const mcp = await pikkuMCP(logger, cliConfig, visitState)
   if (mcp) {
     await pikkuMCPJSON(logger, cliConfig, visitState)
-    addImport(cliConfig.mcpEndpointsMetaFile, 'meta', [PikkuEventTypes.mcp])
-    addImport(cliConfig.mcpEndpointsFile, 'events', [PikkuEventTypes.mcp])
+    allImports.push(cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile)
+
+    await generateBootstrapFile(
+      logger,
+      cliConfig,
+      cliConfig.bootstrapFiles.mcp,
+      [cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile],
+      schemas
+    )
   }
 
   if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
@@ -162,20 +213,18 @@ const runAll = async (
     await pikkuOpenAPI(logger, cliConfig, visitState)
   }
 
-  for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
-    const bootstrapFile =
-      type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type]
-    await writeFileInDir(
-      logger,
-      bootstrapFile,
-      [...meta, ...events]
-        .map(
-          (to) =>
-            `import '${getFileImportRelativePath(bootstrapFile, to, cliConfig.packageMappings)}'`
-        )
-        .join('\n')
-    )
-  }
+  // 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 = (
@@ -238,7 +287,11 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     [],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
 
@@ -264,6 +317,11 @@ export const all = (program: Command): void => {
     )
     .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')
     .action(action)
 }

package/bin/pikku-fetch.ts

@@ -8,7 +8,11 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
   await pikkuFetch(logger, cliConfig)

package/bin/pikku-nextjs.ts

@@ -2,7 +2,7 @@ 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/events/http/pikku-command-nextjs.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 })
@@ -10,7 +10,11 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir'],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
   const visitState = await inspectorGlob(

package/bin/pikku-openapi.ts

@@ -9,7 +9,9 @@ async function action({ config, tags }: PikkuCLIOptions): Promise<void> {
   const cliConfig = await getPikkuCLIConfig(
     config,
     ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'],
-    tags
+    {
+      tags: tags || [],
+    }
   )
   const visitState = await inspectorGlob(
     logger,

package/bin/pikku-queue-service.ts

@@ -9,7 +9,11 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
   await pikkuQueueService(logger, cliConfig)

package/bin/pikku-websocket.ts

@@ -9,7 +9,11 @@ export const action = async (options: PikkuCLIOptions): Promise<void> => {
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
-    options.tags,
+    {
+      tags: options.tags,
+      types: options.types,
+      directories: options.directories,
+    },
     true
   )
   await pikkuWebSocketTyped(logger, cliConfig)

package/cli.schema.json

@@ -2,6 +2,18 @@
   "$ref": "#/definitions/PikkuCLIConfig",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
+    "InspectorFilters": {
+      "additionalProperties": false,
+      "properties": {
+        "tags": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        }
+      },
+      "type": "object"
+    },
     "OpenAPISpecInfo": {
       "additionalProperties": false,
       "properties": {
@@ -123,12 +135,40 @@
         "bootstrapFile": {
           "type": "string"
         },
+        "bootstrapFiles": {
+          "additionalProperties": false,
+          "properties": {
+            "channel": {
+              "type": "string"
+            },
+            "http": {
+              "type": "string"
+            },
+            "mcp": {
+              "type": "string"
+            },
+            "queue": {
+              "type": "string"
+            },
+            "rpc": {
+              "type": "string"
+            },
+            "scheduled": {
+              "type": "string"
+            }
+          },
+          "required": ["http", "scheduled", "channel", "rpc", "queue", "mcp"],
+          "type": "object"
+        },
         "channelsFile": {
           "type": "string"
         },
         "channelsMapDeclarationFile": {
           "type": "string"
         },
+        "channelsMetaFile": {
+          "type": "string"
+        },
         "configDir": {
           "type": "string"
         },
@@ -138,6 +178,33 @@
         "fetchFile": {
           "type": "string"
         },
+        "filters": {
+          "$ref": "#/definitions/InspectorFilters"
+        },
+        "functionsFile": {
+          "type": "string"
+        },
+        "functionsMetaFile": {
+          "type": "string"
+        },
+        "httpRoutesFile": {
+          "type": "string"
+        },
+        "httpRoutesMapDeclarationFile": {
+          "type": "string"
+        },
+        "httpRoutesMetaFile": {
+          "type": "string"
+        },
+        "mcpEndpointsFile": {
+          "type": "string"
+        },
+        "mcpEndpointsMetaFile": {
+          "type": "string"
+        },
+        "mcpJsonFile": {
+          "type": "string"
+        },
         "nextBackendFile": {
           "type": "string"
         },
@@ -166,27 +233,48 @@
           },
           "type": "object"
         },
+        "queueFile": {
+          "type": "string"
+        },
+        "queueMapDeclarationFile": {
+          "type": "string"
+        },
+        "queueWorkersFile": {
+          "type": "string"
+        },
+        "queueWorkersMetaFile": {
+          "type": "string"
+        },
         "rootDir": {
           "type": "string"
         },
-        "srcDirectories": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
+        "rpcFile": {
+          "type": "string"
         },
-        "routesFile": {
+        "rpcMapDeclarationFile": {
           "type": "string"
         },
-        "routesMapDeclarationFile": {
+        "rpcMetaFile": {
           "type": "string"
         },
         "schedulersFile": {
           "type": "string"
         },
+        "schedulersMetaFile": {
+          "type": "string"
+        },
         "schemaDirectory": {
           "type": "string"
         },
+        "servicesFile": {
+          "type": "string"
+        },
+        "srcDirectories": {
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
         "supportsImportAttributes": {
           "type": "boolean"
         },
@@ -202,16 +290,31 @@
       },
       "required": [
         "bootstrapFile",
+        "bootstrapFiles",
         "channelsFile",
         "channelsMapDeclarationFile",
+        "channelsMetaFile",
         "configDir",
+        "filters",
+        "functionsFile",
+        "functionsMetaFile",
+        "httpRoutesFile",
+        "httpRoutesMapDeclarationFile",
+        "httpRoutesMetaFile",
+        "mcpEndpointsFile",
+        "mcpEndpointsMetaFile",
         "packageMappings",
+        "queueMapDeclarationFile",
+        "queueWorkersFile",
+        "queueWorkersMetaFile",
         "rootDir",
-        "srcDirectories",
-        "routesFile",
-        "routesMapDeclarationFile",
+        "rpcMapDeclarationFile",
+        "rpcMetaFile",
         "schedulersFile",
+        "schedulersMetaFile",
         "schemaDirectory",
+        "servicesFile",
+        "srcDirectories",
         "supportsImportAttributes",
         "tsconfig",
         "typesDeclarationFile"