@pikku/cli 0.11.1 → 0.11.3

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

@@ -2,11 +2,22 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 
 export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean | undefined>({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
+    const {
+      httpWiringsFile,
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { http } = visitState
 
     await writeFileInDir(
@@ -19,10 +30,43 @@ export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean | undefined>({
         packageMappings
       )
     )
+
+    // Write minimal JSON (runtime-only fields)
+    const minimalMeta = stripVerboseFields(http.meta)
+    await writeFileInDir(
+      logger,
+      httpWiringMetaJsonFile,
+      JSON.stringify(minimalMeta, null, 2)
+    )
+
+    // Write verbose JSON only if it has additional fields
+    if (hasVerboseFields(http.meta)) {
+      const verbosePath = httpWiringMetaJsonFile.replace(
+        /\.gen\.json$/,
+        '-verbose.gen.json'
+      )
+      await writeFileInDir(
+        logger,
+        verbosePath,
+        JSON.stringify(http.meta, null, 2)
+      )
+    }
+
+    // Generate TypeScript file that imports the minimal JSON
+    const jsonImportPath = getFileImportRelativePath(
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings
+    )
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       httpWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`
     )
 
     return true

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

@@ -19,7 +19,7 @@ export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
       return
     }
 
-    const { http, functions } = await getInspectorState()
+    const { http, functions, zodLookup } = await getInspectorState()
 
     const schemas = await generateSchemas(
       logger,
@@ -28,7 +28,8 @@ export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
       functions.meta,
       http.meta,
       schemasFromTypes,
-      config.schema?.additionalProperties
+      config.schema?.additionalProperties,
+      zodLookup
     )
     const openAPISpec = await generateOpenAPISpec(
       logger,

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

@@ -2,11 +2,18 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js'
 import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
+    const {
+      httpWiringsFile,
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { http } = visitState
 
     await writeFileInDir(
@@ -19,11 +26,30 @@ export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
         packageMappings
       )
     )
+
+    await writeFileInDir(
+      logger,
+      httpWiringMetaJsonFile,
+      JSON.stringify(http.meta, null, 2)
+    )
+
+    const jsonImportPath = getFileImportRelativePath(
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings
+    )
+
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       httpWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`
     )
+
     return true
   },
   middleware: [

package/src/functions/wirings/http/serialize-http-types.ts

@@ -8,7 +8,7 @@ export const serializeHTTPTypes = (functionTypesImportPath: string) => {
 
 import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore } from '@pikku/core/http'
 import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
-import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
+import type { CoreHTTPFunctionWiring, HTTPMethod } from '@pikku/core/http'
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -18,7 +18,23 @@ import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
  * @template Out - Output type for the HTTP wiring
  * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
  */
-type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out>, PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
+
+/**
+ * HTTP wiring for workflow triggers (no function needed)
+ */
+type HTTPWorkflowWiring<Route extends string> = {
+  route: Route
+  method: HTTPMethod
+  workflow: true
+  func?: undefined
+  permissions?: undefined
+  auth?: undefined
+  tags?: undefined
+  middleware?: undefined
+  returnsJSON?: undefined
+  sse?: boolean
+}
 
 /**
  * Registers an HTTP wiring with the Pikku framework.
@@ -29,7 +45,7 @@ type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out,
  * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
  */
 export const wireHTTP = <In, Out, Route extends string>(
-  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
+  httpWiring: (HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>) | HTTPWorkflowWiring<Route>
 ) => {
   wireHTTPCore(httpWiring as any)
 }

package/src/functions/wirings/http/serialize-typed-http-map.ts

@@ -32,7 +32,7 @@ export const serializeTypedHTTPWiringsMap = (
   return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 ${serializedMetaTypes}
@@ -70,6 +70,12 @@ function generateHTTPWirings(
   for (const methods of Object.values(routesMeta)) {
     for (const meta of Object.values(methods)) {
       const { route, method, pikkuFuncName } = meta
+
+      // Skip workflow-triggered routes (they don't have a function)
+      if (meta.workflow) {
+        continue
+      }
+
       const functionMeta = functionsMeta[pikkuFuncName]
       if (!functionMeta) {
         throw new Error(
@@ -79,16 +85,28 @@ function generateHTTPWirings(
       const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
       const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
-      // Initialize the route entry if it doesn't exist
       if (!routesObj[route]) {
         routesObj[route] = {}
       }
 
-      // Store the input and output types separately for RouteHandler
-      const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
-      const outputType = output
-        ? typesMap.getTypeMeta(output).uniqueName
-        : 'null'
+      // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
+      let inputType = 'null'
+      if (input) {
+        try {
+          inputType = typesMap.getTypeMeta(input).uniqueName
+        } catch {
+          inputType = input
+        }
+      }
+      let outputType = 'null'
+      if (output) {
+        try {
+          outputType = typesMap.getTypeMeta(output).uniqueName
+        } catch {
+          // Zod-derived schema - use the schema name directly
+          outputType = output
+        }
+      }
 
       requiredTypes.add(inputType)
       requiredTypes.add(outputType)
@@ -121,7 +139,13 @@ const generateMetaTypes = (metaTypes: MetaInputTypes, typesMap: TypesMap) => {
   const nameToTypeMap = Array.from(metaTypes.entries()).reduce<
     Map<string, string>
   >((result, [_name, { query, body, params }]) => {
-    const { uniqueName } = typesMap.getTypeMeta(_name)
+    let uniqueName: string
+    try {
+      uniqueName = typesMap.getTypeMeta(_name).uniqueName
+    } catch {
+      // Zod-derived schema - use the name directly
+      uniqueName = _name
+    }
     const queryType =
       query && query.length > 0
         ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`

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

@@ -4,6 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 import { readFile } from 'fs/promises'
 import { join } from 'path'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 
 // Helper function to generate arguments from schema
 const generateArgumentsFromSchema = async (
@@ -25,12 +30,13 @@ const generateArgumentsFromSchema = async (
   const uniqueName = typesMap.getUniqueName(inputSchema)
   if (!uniqueName) return []
 
+  const schemaPath = join(
+    schemaDirectory,
+    'schemas',
+    `${uniqueName}.schema.json`
+  )
+
   try {
-    const schemaPath = join(
-      schemaDirectory,
-      'schemas',
-      `${uniqueName}.schema.json`
-    )
     const schemaContent = await readFile(schemaPath, 'utf-8')
     const schema = JSON.parse(schemaContent)
 
@@ -53,7 +59,8 @@ const generateArgumentsFromSchema = async (
     }
     return argumentsArray
   } catch (e) {
-    logger.warn(`Could not load schema for type: ${uniqueName}`)
+    logger.warn(`Command MCP: Could not load schema for type: ${uniqueName} from ${schemaPath}`)
+    console.error(e)
     return []
   }
 }
@@ -66,6 +73,7 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
       mcpWiringsMetaFile,
       packageMappings,
       schemaDirectory,
+      schema,
     } = config
 
     await writeFileInDir(
@@ -81,7 +89,7 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
 
     // Populate arguments for prompts meta before serializing
     const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta }
-    for (const promptMeta of Object.values(promptsMetaWithArguments)) {
+    for (const promptMeta of Object.values(promptsMetaWithArguments) as any[]) {
       const functionMeta = functions.meta[promptMeta.pikkuFuncName]
       if (functionMeta) {
         const inputType = functionMeta.inputs?.[0]
@@ -94,13 +102,53 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
       }
     }
 
+    const metaData = {
+      resourcesMeta: mcpEndpoints.resourcesMeta,
+      toolsMeta: mcpEndpoints.toolsMeta,
+      promptsMeta: promptsMetaWithArguments,
+    }
+
+    // Write minimal JSON (runtime-only fields)
+    const minimalMeta = stripVerboseFields(metaData)
+    await writeFileInDir(
+      logger,
+      config.mcpWiringsMetaJsonFile,
+      JSON.stringify(minimalMeta, null, 2)
+    )
+
+    // Write verbose JSON only if it has additional fields
+    if (hasVerboseFields(metaData)) {
+      const verbosePath = config.mcpWiringsMetaJsonFile.replace(
+        /\.gen\.json$/,
+        '-verbose.gen.json'
+      )
+      await writeFileInDir(
+        logger,
+        verbosePath,
+        JSON.stringify(metaData, null, 2)
+      )
+    }
+
+    const jsonImportPath = getFileImportRelativePath(
+      mcpWiringsMetaFile,
+      config.mcpWiringsMetaJsonFile,
+      packageMappings
+    )
+
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       mcpWiringsMetaFile,
       `import { pikkuState } from '@pikku/core'
-pikkuState('mcp', 'resourcesMeta', ${JSON.stringify(mcpEndpoints.resourcesMeta, null, 2)})
-pikkuState('mcp', 'toolsMeta', ${JSON.stringify(mcpEndpoints.toolsMeta, null, 2)})
-pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null, 2)})`
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
+${importStatement}
+pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
+pikkuState(null, 'mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
+pikkuState(null, 'mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`
     )
 
     return true

package/src/functions/wirings/mcp/serialize-mcp-json.ts

@@ -44,16 +44,18 @@ export const serializeMCPJson = async (
       return undefined
     }
 
+    const schemaPath = join(
+      schemaDirectory,
+      'schemas',
+      `${uniqueName}.schema.json`
+    )
+
     try {
-      const schemaPath = join(
-        schemaDirectory,
-        'schemas',
-        `${uniqueName}.schema.json`
-      )
       const schemaContent = await readFile(schemaPath, 'utf-8')
       return JSON.parse(schemaContent)
     } catch (e) {
-      logger.warn(`Could not load schema for type: ${uniqueName}`)
+      logger.warn(`Serialize MCP: Could not load schema for type: ${uniqueName} from ${schemaPath}`)
+      console.error(e)
       return undefined
     }
   }

package/src/functions/wirings/mcp/serialize-mcp-types.ts

@@ -19,7 +19,8 @@ import {
   AssertMCPResourceURIParams
 } from '@pikku/core/mcp'
 
-import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, InferZodOutput } from '${functionTypesImportPath}'
+import type { ZodLike } from '@pikku/core'
 
 /**
  * Type definition for MCP resources that provide data to AI models.
@@ -27,21 +28,21 @@ import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTy
  * @template In - Input type for the resource request
  * @template URI - URI template string type for compile-time parameter validation
  */
-type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>> & { uri: URI }
+type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
 
 /**
  * Type definition for MCP tools that AI models can invoke.
  *
  * @template In - Input type for the tool invocation
  */
-type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse>>
+type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * Type definition for MCP prompts that provide templates to AI models.
  *
  * @template In - Input type for the prompt parameters
  */
-type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse>>
+type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptResponse, 'rpc' | 'session' | 'mcp'>>
 
 /**
  * Registers an MCP resource with the Pikku framework.
@@ -83,60 +84,111 @@ export const wireMCPPrompt = <In>(
   wireMCPPromptCore(mcpPrompt as any)
 }
 
+/**
+ * Configuration for MCP prompt with Zod schema input validation.
+ */
+type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * Creates a function for handling MCP prompt requests.
  * These functions generate prompt templates for AI models.
  *
- * @template In - Input type for the prompt parameters
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPPromptFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPPromptFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the prompt parameters (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPPromptFunc = <In>(
+export function pikkuMCPPromptFunc<InputSchema extends ZodLike>(
+  config: MCPPromptFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPPromptResponse>
+    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
     | {
-        func: PikkuFunctionSessionless<In, MCPPromptResponse>
+        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
         name?: string
       }
-): PikkuFunctionConfig<In, MCPPromptResponse> => {
+): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration for MCP tool with Zod schema input validation.
+ */
+type MCPToolFuncConfigWithSchema<InputSchema extends ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * Creates a function for handling MCP tool invocations.
  * These functions perform actions that AI models can request.
  *
- * @template In - Input type for the tool invocation
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPToolFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPToolFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the tool invocation (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPToolFunc = <In>(
+export function pikkuMCPToolFunc<InputSchema extends ZodLike>(
+  config: MCPToolFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
     | {
-      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPToolResponse> => {
+): PikkuFunctionConfig<In, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration for MCP resource with Zod schema input validation.
+ */
+type MCPResourceFuncConfigWithSchema<InputSchema extends ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * Creates a function for handling MCP resource requests.
  * These functions provide data that AI models can access.
  *
- * @template In - Input type for the resource request
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPResourceFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPResourceFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the resource request (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPResourceFunc = <In>(
+export function pikkuMCPResourceFunc<InputSchema extends ZodLike>(
+  config: MCPResourceFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
     | {
-      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPResourceResponse> => {
+): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 `

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

@@ -3,6 +3,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 import { serializeMiddlewareImports } from './serialize-middleware-imports.js'
 import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
 
 export const pikkuMiddleware: any = pikkuSessionlessFunc<
   void,
@@ -11,7 +12,7 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
   func: async ({ logger, config, getInspectorState }) => {
     const state = await getInspectorState()
     const { middleware } = state
-    const { middlewareFile, packageMappings } = config
+    const { middlewareFile, packageMappings, schema } = config
 
     let filesGenerated = false
 
@@ -20,12 +21,48 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
     const hasTagGroups = state.middleware.tagMiddleware.size > 0
 
     if (hasHTTPGroups || hasTagGroups) {
+      const metaData = serializeMiddlewareGroupsMeta(state)
+
+      // Write JSON file
       await writeFileInDir(
         logger,
+        config.middlewareGroupsMetaJsonFile,
+        JSON.stringify(metaData, null, 2)
+      )
+
+      // Calculate relative path from TS file to JSON file
+      const jsonImportPath = getFileImportRelativePath(
         config.middlewareGroupsMetaFile,
-        serializeMiddlewareGroupsMeta(state)
+        config.middlewareGroupsMetaJsonFile,
+        packageMappings
       )
 
+      // Write TypeScript file that imports JSON
+      const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+      const importStatement = supportsImportAttributes
+        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+        : `import metaData from '${jsonImportPath}'`
+
+      const packageNameValue = config.externalPackageName
+        ? `'${config.externalPackageName}'`
+        : 'null'
+
+      const tsContent = `import { pikkuState } from '@pikku/core'
+${importStatement}
+
+// HTTP middleware groups metadata
+if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
+  pikkuState(${packageNameValue}, 'middleware', 'httpGroupMeta', metaData.httpGroups)
+}
+
+// Tag middleware groups metadata
+if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
+  pikkuState(${packageNameValue}, 'middleware', 'tagGroupMeta', metaData.tagGroups)
+}
+`
+
+      await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent)
+
       // Always generate middleware imports file when groups exist (even if empty)
       await writeFileInDir(
         logger,

package/src/functions/wirings/middleware/serialize-middleware-groups-meta.ts

@@ -1,14 +1,12 @@
 import type { InspectorState } from '@pikku/inspector'
 
 /**
- * Generates the middleware groups metadata file that stores metadata about
+ * Generates the middleware groups metadata that stores metadata about
  * tag-based and HTTP middleware groups for visualization and inspection.
  *
  * This includes services, middleware count, factory status, etc.
  */
 export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
-  const lines: string[] = [`import { pikkuState } from '@pikku/core'`, ``]
-
   // Serialize HTTP middleware groups metadata
   const httpGroups: Record<string, any> = {}
   for (const [pattern, meta] of state.http.routeMiddleware.entries()) {
@@ -22,14 +20,6 @@ export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
     }
   }
 
-  if (Object.keys(httpGroups).length > 0) {
-    lines.push(`// HTTP middleware groups metadata`)
-    lines.push(
-      `pikkuState('middleware', 'httpGroupMeta', ${JSON.stringify(httpGroups, null, 2)})`
-    )
-    lines.push(``)
-  }
-
   // Serialize tag middleware groups metadata
   const tagGroups: Record<string, any> = {}
   for (const [tag, meta] of state.middleware.tagMiddleware.entries()) {
@@ -43,13 +33,8 @@ export const serializeMiddlewareGroupsMeta = (state: InspectorState) => {
     }
   }
 
-  if (Object.keys(tagGroups).length > 0) {
-    lines.push(`// Tag middleware groups metadata`)
-    lines.push(
-      `pikkuState('middleware', 'tagGroupMeta', ${JSON.stringify(tagGroups, null, 2)})`
-    )
-    lines.push(``)
+  return {
+    httpGroups,
+    tagGroups,
   }
-
-  return lines.join('\n')
 }