@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,35 @@
+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'
+
+export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const visitState = await getInspectorState()
+    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
+    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)})`
+    )
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding HTTP routes',
+      commandEnd: 'Found HTTP routes',
+    }),
+  ],
+})

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

@@ -0,0 +1,89 @@
+/**
+ * Generates type definitions for HTTP wirings
+ */
+export const serializeHTTPTypes = (functionTypesImportPath: string) => {
+  return `/**
+ * HTTP-specific type definitions for tree-shaking optimization
+ */
+
+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'
+
+/**
+ * Type definition for HTTP API wirings with type-safe path parameters.
+ * Supports both authenticated and unauthenticated functions.
+ *
+ * @template In - Input type for the HTTP wiring
+ * @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>
+
+/**
+ * Registers an HTTP wiring with the Pikku framework.
+ *
+ * @template In - Input type for the HTTP wiring
+ * @template Out - Output type for the HTTP wiring
+ * @template Route - String literal type for the HTTP path (e.g., "/users/:id")
+ * @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>
+) => {
+  wireHTTPCore(httpWiring as any)
+}
+
+/**
+ * Registers HTTP middleware either globally or for a specific route pattern.
+ *
+ * When a string route pattern is provided along with middleware, the middleware
+ * is applied only to that route. Otherwise, if an array is provided, it is treated
+ * as global middleware (applied to all routes).
+ *
+ * @param routeOrMiddleware - Either a global middleware array or a route pattern string
+ * @param middleware - The middleware array to apply when a route pattern is specified
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add global HTTP middleware
+ * addHTTPMiddleware([authMiddleware, loggingMiddleware])
+ *
+ * // Add route-specific middleware
+ * addHTTPMiddleware('/api/admin/*', [adminAuthMiddleware])
+ * \`\`\`
+ */
+export const addHTTPMiddleware = (
+  routeOrMiddleware: PikkuMiddleware[] | string,
+  middleware?: PikkuMiddleware[]
+) => {
+  addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
+}
+
+/**
+ * Registers HTTP permissions either globally or for a specific route pattern.
+ *
+ * When a string route pattern is provided along with permissions, the permissions
+ * are applied only to that route. Permissions can be passed as an array or as a
+ * permission group object.
+ *
+ * @param pattern - Route pattern string (e.g., '*' for all routes, '/api/*' for specific routes)
+ * @param permissions - The permissions to apply for the specified route pattern
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add global HTTP permissions
+ * addHTTPPermission('*', { global: globalPermission })
+ *
+ * // Add route-specific permissions
+ * addHTTPPermission('/api/admin/*', { admin: adminPermission })
+ * \`\`\`
+ */
+export const addHTTPPermission = <In = unknown>(
+  pattern: string,
+  permissions: Record<string, PikkuPermission<In>> | PikkuPermission<In>[]
+) => {
+  addHTTPPermissionCore(pattern, permissions as any)
+}
+`
+}

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

@@ -1,8 +1,8 @@
 import { HTTPWiringsMeta } from '@pikku/core/http'
-import { serializeImportMap } from '../../serialize-import-map.js'
+import { serializeImportMap } from '../../../utils/serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
-import { generateCustomTypes } from '../../utils.js'
+import { generateCustomTypes } from '../../../utils/custom-types-generator.js'
 
 export const serializeTypedHTTPWiringsMap = (
   relativeToPath: string,

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

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeMCPJson } from './serialize-mcp-json.js'
+
+export const pikkuMCPJSON: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { mcpEndpoints, functions } = await getInspectorState()
+    const { mcpJsonFile, schemaDirectory } = config
+
+    // 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,
+      })
+    }
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating MCP JSON',
+      commandEnd: 'Generated MCP JSON',
+    }),
+  ],
+})

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

@@ -0,0 +1,25 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializeMCPTypes } from './serialize-mcp-types.js'
+
+export const pikkuMCPTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { mcpTypesFile, functionTypesFile, packageMappings } = config
+
+    const functionTypesImportPath = getFileImportRelativePath(
+      mcpTypesFile,
+      functionTypesFile,
+      packageMappings
+    )
+    const content = serializeMCPTypes(functionTypesImportPath)
+    await writeFileInDir(logger, mcpTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating MCP types',
+      commandEnd: 'Created MCP types',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/mcp/pikku-command-mcp.ts

@@ -1,9 +1,7 @@
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
+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 { readFile } from 'fs/promises'
 import { join } from 'path'
 
@@ -60,51 +58,57 @@ const generateArgumentsFromSchema = async (
   }
 }
 
-export const pikkuMCP: PikkuCommand = async (
-  logger,
-  { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory },
-  { mcpEndpoints, functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding MCP endpoints',
-    'Found MCP endpoints',
-    [mcpEndpoints.files.size === 0],
-    async () => {
-      await writeFileInDir(
-        logger,
+export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { mcpEndpoints, functions } = await getInspectorState()
+    const {
+      mcpWiringsFile,
+      mcpWiringsMetaFile,
+      packageMappings,
+      schemaDirectory,
+    } = config
+
+    await writeFileInDir(
+      logger,
+      mcpWiringsFile,
+      serializeFileImports(
+        'wireMCPResource or wireMCPTool',
         mcpWiringsFile,
-        serializeFileImports(
-          'wireMCPResource or wireMCPTool',
-          mcpWiringsFile,
-          mcpEndpoints.files,
-          packageMappings
-        )
+        mcpEndpoints.files,
+        packageMappings
       )
+    )
 
-      // Populate arguments for prompts meta before serializing
-      const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta }
-      for (const promptMeta of Object.values(promptsMetaWithArguments)) {
-        const functionMeta = functions.meta[promptMeta.pikkuFuncName]
-        if (functionMeta) {
-          const inputType = functionMeta.inputs?.[0]
-          promptMeta.arguments = await generateArgumentsFromSchema(
-            inputType || null,
-            schemaDirectory || '',
-            functions.typesMap,
-            logger
-          )
-        }
+    // Populate arguments for prompts meta before serializing
+    const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta }
+    for (const promptMeta of Object.values(promptsMetaWithArguments)) {
+      const functionMeta = functions.meta[promptMeta.pikkuFuncName]
+      if (functionMeta) {
+        const inputType = functionMeta.inputs?.[0]
+        promptMeta.arguments = await generateArgumentsFromSchema(
+          inputType || null,
+          schemaDirectory || '',
+          functions.typesMap,
+          logger
+        )
       }
+    }
 
-      await writeFileInDir(
-        logger,
-        mcpWiringsMetaFile,
-        `import { pikkuState } from '@pikku/core'
+    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)})`
-      )
-    }
-  )
-}
+    )
+
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Finding MCP endpoints',
+      commandEnd: 'Found MCP endpoints',
+    }),
+  ],
+})

package/src/{wirings → functions/wirings}/mcp/serialize-mcp-json.ts

@@ -1,9 +1,9 @@
 import { readFile } from 'fs/promises'
 import { join } from 'path'
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core'
+import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 import { FunctionsMeta, JSONValue } from '@pikku/core'
 import { TypesMap } from '@pikku/inspector'
-import { CLILogger } from '../../utils.js'
+import { CLILogger } from '../../../services/cli-logger.service.js'
 
 interface MCPEndpoint {
   name: string

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

@@ -0,0 +1,143 @@
+/**
+ * Generates type definitions for MCP wirings
+ */
+export const serializeMCPTypes = (functionTypesImportPath: string) => {
+  return `/**
+ * MCP-specific type definitions for tree-shaking optimization
+ */
+
+import {
+  CoreMCPResource,
+  CoreMCPTool,
+  CoreMCPPrompt,
+  wireMCPResource as wireMCPResourceCore,
+  wireMCPTool as wireMCPToolCore,
+  wireMCPPrompt as wireMCPPromptCore,
+  MCPResourceResponse,
+  MCPToolResponse,
+  MCPPromptResponse,
+  AssertMCPResourceURIParams
+} from '@pikku/core/mcp'
+
+import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
+
+/**
+ * Type definition for MCP resources that provide data to AI models.
+ *
+ * @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 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 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>>
+
+/**
+ * Registers an MCP resource with the Pikku framework.
+ * Resources provide data that AI models can access.
+ *
+ * @template In - Input type for the resource request
+ * @template URI - URI template string for compile-time parameter validation
+ * @param mcpResource - MCP resource definition with data provider function
+ */
+export const wireMCPResource = <In, URI extends string>(
+  mcpResource: MCPResourceWiring<In, URI> & AssertMCPResourceURIParams<In, URI>
+) => {
+  wireMCPResourceCore(mcpResource as any)
+}
+
+/**
+ * Registers an MCP tool with the Pikku framework.
+ * Tools are functions that AI models can invoke.
+ *
+ * @template In - Input type for the tool invocation
+ * @param mcpTool - MCP tool definition with action function
+ */
+export const wireMCPTool = <In>(
+  mcpTool: MCPToolWiring<In>
+) => {
+  wireMCPToolCore(mcpTool as any)
+}
+
+/**
+ * Registers an MCP prompt with the Pikku framework.
+ * Prompts provide templates that AI models can use.
+ *
+ * @template In - Input type for the prompt parameters
+ * @param mcpPrompt - MCP prompt definition with template function
+ */
+export const wireMCPPrompt = <In>(
+  mcpPrompt: MCPPromptWiring<In>
+) => {
+  wireMCPPromptCore(mcpPrompt as any)
+}
+
+/**
+ * Creates a function for handling MCP prompt requests.
+ * These functions generate prompt templates for AI models.
+ *
+ * @template In - Input type for the prompt parameters
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPPromptFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPPromptResponse>
+    | {
+        func: PikkuFunctionSessionless<In, MCPPromptResponse>
+        name?: string
+      }
+): PikkuFunctionConfig<In, MCPPromptResponse> => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * 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
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPToolFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+    | {
+      func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
+      name?: string
+    }
+): PikkuFunctionConfig<In, MCPToolResponse> => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * 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
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The unwrapped function for internal use
+ */
+export const pikkuMCPResourceFunc = <In>(
+  func:
+    | PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+    | {
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
+      name?: string
+    }
+): PikkuFunctionConfig<In, MCPResourceResponse> => {
+  return typeof func === 'function' ? { func } : func
+}
+`
+}

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

@@ -0,0 +1,63 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+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'
+
+export const pikkuMiddleware: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const state = await getInspectorState()
+    const { middleware } = state
+    const { middlewareFile, packageMappings } = config
+
+    let filesGenerated = false
+
+    // Check if there are any middleware group factories
+    const hasHTTPFactories = Array.from(
+      state.http.routeMiddleware.values()
+    ).some((meta) => meta.exportName && meta.isFactory)
+    const hasTagFactories = Array.from(
+      state.middleware.tagMiddleware.values()
+    ).some((meta) => meta.exportName && meta.isFactory)
+    const hasFactories = hasHTTPFactories || hasTagFactories
+
+    // Generate middleware imports file if there are factories
+    if (hasFactories) {
+      await writeFileInDir(
+        logger,
+        middlewareFile,
+        serializeMiddlewareImports(
+          middlewareFile,
+          middleware,
+          state.http,
+          packageMappings
+        )
+      )
+      filesGenerated = true
+    }
+
+    // Generate middleware groups metadata file
+    const hasHTTPGroups = state.http.routeMiddleware.size > 0
+    const hasTagGroups = state.middleware.tagMiddleware.size > 0
+
+    if (hasHTTPGroups || hasTagGroups) {
+      await writeFileInDir(
+        logger,
+        config.middlewareGroupsMetaFile,
+        serializeMiddlewareGroupsMeta(state)
+      )
+      filesGenerated = true
+    }
+
+    return filesGenerated
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Serializing Pikku middleware',
+      commandEnd: 'Serialized Pikku middleware',
+    }),
+  ],
+})

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

@@ -0,0 +1,55 @@
+import type { InspectorState } from '@pikku/inspector'
+
+/**
+ * Generates the middleware groups metadata file 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()) {
+    httpGroups[pattern] = {
+      exportName: meta.exportName,
+      sourceFile: meta.sourceFile,
+      position: meta.position,
+      services: meta.services,
+      middlewareCount: meta.middlewareCount,
+      isFactory: meta.isFactory,
+    }
+  }
+
+  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()) {
+    tagGroups[tag] = {
+      exportName: meta.exportName,
+      sourceFile: meta.sourceFile,
+      position: meta.position,
+      services: meta.services,
+      middlewareCount: meta.middlewareCount,
+      isFactory: meta.isFactory,
+    }
+  }
+
+  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 lines.join('\n')
+}

package/src/functions/wirings/middleware/serialize-middleware-imports.ts

@@ -0,0 +1,78 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import type {
+  InspectorMiddlewareState,
+  InspectorHTTPState,
+  InspectorState,
+} from '@pikku/inspector'
+
+export const serializeMiddlewareImports = (
+  outputPath: string,
+  middlewareState: InspectorMiddlewareState,
+  httpState: InspectorHTTPState,
+  packageMappings: Record<string, string> = {},
+  fullState?: InspectorState
+) => {
+  const serializedImports: string[] = []
+  const serializedFactoryCalls: string[] = []
+
+  // Collect factory imports and calls for HTTP middleware groups
+  const httpFactories = new Map<
+    string,
+    { exportName: string; filePath: string }
+  >()
+  for (const [, groupMeta] of httpState.routeMiddleware.entries()) {
+    if (groupMeta.exportName && groupMeta.isFactory) {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        groupMeta.sourceFile,
+        packageMappings
+      )
+      httpFactories.set(groupMeta.exportName, {
+        exportName: groupMeta.exportName,
+        filePath,
+      })
+    }
+  }
+
+  // Collect factory imports and calls for tag middleware groups
+  const tagFactories = new Map<
+    string,
+    { exportName: string; filePath: string }
+  >()
+  for (const [, groupMeta] of middlewareState.tagMiddleware.entries()) {
+    if (groupMeta.exportName && groupMeta.isFactory) {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        groupMeta.sourceFile,
+        packageMappings
+      )
+      tagFactories.set(groupMeta.exportName, {
+        exportName: groupMeta.exportName,
+        filePath,
+      })
+    }
+  }
+
+  // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
+  const allFactories = new Map([...httpFactories, ...tagFactories])
+
+  // Add factory imports and calls
+  if (allFactories.size > 0) {
+    serializedImports.push(
+      '/* Call middleware group factories to register at module evaluation */'
+    )
+
+    // Import factories
+    for (const [exportName, { filePath }] of allFactories) {
+      serializedImports.push(`import { ${exportName} } from '${filePath}'`)
+    }
+
+    // Call factories
+    for (const [exportName] of allFactories) {
+      serializedFactoryCalls.push(`${exportName}()`)
+    }
+  }
+
+  // Return combined output
+  return [...serializedImports, ...serializedFactoryCalls].join('\n')
+}