@pikku/cli 0.11.1 → 0.11.3

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

@@ -6,30 +6,30 @@ export const serializeFunctionTypes = (
   userSessionTypeName: string,
   singletonServicesTypeImport: string,
   singletonServicesTypeName: string,
-  sessionServicesTypeImport: string,
-  sessionServicesTypeName: string,
+  wireServicesTypeImport: string,
+  wireServicesTypeName: string,
   rpcMapTypeImport: string,
   requiredServicesTypeImport: string,
-  configTypeImport: string
+  configTypeImport: string,
+  packageName?: string
 ) => {
+  const packageNameValue = packageName ? `'${packageName}'` : 'null'
   return `/**
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, ZodLike, CreateWireServices } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
-import { PikkuChannel } from '@pikku/core/channel'
-import { PikkuMCP } from '@pikku/core/mcp'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
-${sessionServicesTypeImport}
+${wireServicesTypeImport}
 ${configTypeImport}
 ${rpcMapTypeImport}
 ${requiredServicesTypeImport}
 
 ${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
-${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
+${wireServicesTypeName !== 'Services' ? `type Services = ${wireServicesTypeName}` : ''}
 ${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
 ${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
 
@@ -40,7 +40,7 @@ ${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
  * @template In - The input type that the permission check will receive
  * @template RequiredServices - The services required for this permission check
  */
-export type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, Session>
+export type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, PikkuWire<In, never, false, Session>>
 
 /**
  * Type-safe middleware definition that can access your application's services and session.
@@ -48,7 +48,7 @@ export type PikkuPermission<In = unknown, RequiredServices extends Services = Se
  *
  * @template RequiredServices - The services required for this middleware
  */
-export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
+export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices>
 
 /**
  * Configuration object for creating a permission with metadata
@@ -69,7 +69,8 @@ export type PikkuPermissionConfig<In = unknown, RequiredServices extends Service
  * @example
  * \`\`\`typescript
  * // Direct function syntax
- * const permission = pikkuPermission(({ logger }, data, session) => {
+ * const permission = pikkuPermission(async ({ logger }, data, { session }) => {
+ *   const session = await session?.get()
  *   return session?.role === 'admin'
  * })
  *
@@ -77,7 +78,8 @@ export type PikkuPermissionConfig<In = unknown, RequiredServices extends Service
  * const adminPermission = pikkuPermission({
  *   name: 'Admin Permission',
  *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, data, session) => {
+ *   func: async ({ logger }, data, { session }) => {
+ *     const session = await session?.get()
  *     return session?.role === 'admin'
  *   }
  * })
@@ -108,7 +110,7 @@ export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = S
  * @example
  * \`\`\`typescript
  * // Direct function syntax
- * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
+ * const middleware = pikkuMiddleware(({ logger }, wires, next) => {
  *   logger.info('Middleware executed')
  *   await next()
  * })
@@ -117,7 +119,7 @@ export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = S
  * const logMiddleware = pikkuMiddleware({
  *   name: 'Request Logger',
  *   description: 'Logs all incoming requests',
- *   func: async ({ logger }, interactions, next) => {
+ *   func: async ({ logger }, wires, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -140,7 +142,7 @@ export const pikkuMiddleware = <RequiredServices extends SingletonServices = Sin
  *   message,
  *   level = 'info'
  * }) => {
- *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
  *     logger[level](message)
  *     await next()
  *   })
@@ -162,8 +164,8 @@ export const pikkuMiddlewareFactory = <In = any>(
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, session) => {
- *     if (!session || session.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { initialSession }) => {
+ *     if (!initialSession || initialSession.role !== role) {
  *       logger.warn(\`Permission denied: required role '\${role}'\`)
  *       return false
  *     }
@@ -184,25 +186,19 @@ export const pikkuPermissionFactory = <In = any>(
  *
  * @template In - The input type
  * @template Out - The output type that the function returns
- * @template ChannelData - Channel data type (null = optional channel)
- * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
 export type PikkuFunctionSessionless<
   In = unknown,
   Out = never,
-  ChannelData = null,  // null means optional channel
-  MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
-    { rpc: TypedPikkuRPC } & (
-    [ChannelData] extends [null]
-      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
-      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
-  ) & ([MCPData] extends [null]
-    ? { mcp?: PikkuMCP }  // Optional MCP
-    : { mcp: PikkuMCP }  // Required MCP
-  )
-> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, Session>
+  RequiredWires extends keyof PikkuWire = never,
+  RequiredServices extends Services = Services
+> = CorePikkuFunctionSessionless<
+    In,
+    Out,
+    RequiredServices,
+    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any>, RequiredWires>
+  >
 
 /**
  * A session-aware API function that requires user authentication.
@@ -210,25 +206,24 @@ export type PikkuFunctionSessionless<
  *
  * @template In - The input type
  * @template Out - The output type that the function returns
- * @template ChannelData - Channel data type (null = optional channel)
- * @template MCPData - MCP data type (null = optional MCP)
  * @template RequiredServices - Services required by this function
  */
 export type PikkuFunction<
   In = unknown,
   Out = never,
-  ChannelData = null,  // null means optional channel
-  MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
-    { rpc: TypedPikkuRPC } & (
-    [ChannelData] extends [null]
-      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
-      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
-  ) & ([MCPData] extends [null]
-    ? { mcp?: PikkuMCP }  // Optional MCP
-    : { mcp: PikkuMCP }  // Required MCP
-  )
-> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, Session>
+  RequiredWires extends keyof PikkuWire = 'session',
+  RequiredServices extends Services = Services
+> = CorePikkuFunction<
+    In,
+    Out,
+    RequiredServices,
+    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
+  >
+
+/**
+ * Helper type to infer the output type from a Zod schema
+ */
+export type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
 
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
@@ -236,72 +231,172 @@ export type PikkuFunction<
  *
  * @template In - The input type
  * @template Out - The output type
- * @template ChannelData - Channel data type
- * @template MCPData - MCP data type
  * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
  */
 export type PikkuFunctionConfig<
   In = unknown,
   Out = unknown,
-  ChannelData = unknown,
-  MCPData = unknown,
-  PikkuFunc extends PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData> = PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData>
-> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
+  RequiredWires extends keyof PikkuWire = never,
+  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>,
+  InputSchema extends ZodLike | undefined = undefined,
+  OutputSchema extends ZodLike | undefined = undefined
+> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>
+
+/**
+ * Configuration object for Pikku functions with Zod schema validation.
+ * Use this when you want to define input/output schemas using Zod.
+ * Types are automatically inferred from the schemas.
+ */
+export type PikkuFunctionConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunction<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  > | PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
 
 /**
  * Creates a Pikku function that can be either session-aware or sessionless.
  * This is the main function wrapper for creating API endpoints.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuFunc<Input, Output>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuFunc({ input: z.object(...), output: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
- * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input) => {
- *     logger.info('Creating user', input.name)
+ * \`\`\`typescript
+ * // Pattern 1: Using generic types
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number}>({
+ *   func: async ({db}, input) => {
  *     const user = await db.users.create(input)
- *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
- *   },
- *   auth: true
+ *     return { id: user.id }
+ *   }
  * })
- * \\\`\\\`\\\`
+ *
+ * // Pattern 2: Using Zod schemas (types inferred automatically)
+ * const createUserInput = z.object({ name: z.string(), email: z.string() })
+ * const createUserOutput = z.object({ id: z.number() })
+ *
+ * const createUser = pikkuFunc({
+ *   input: createUserInput,
+ *   output: createUserOutput,
+ *   func: async ({db}, input) => {
+ *     // input is typed as { name: string, email: string }
+ *     const user = await db.users.create(input)
+ *     return { id: user.id } // must match output schema
+ *   }
+ * })
+ * \`\`\`
  */
-export const pikkuFunc = <In, Out = unknown>(
+export function pikkuFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuFunc<In, Out = unknown>(
   func:
-    | PikkuFunction<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>, PikkuMiddleware>
-) => {
+    | PikkuFunction<In, Out, 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration object for sessionless Pikku functions with Zod schema validation.
+ */
+export type PikkuFunctionSessionlessConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  description?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
+
 /**
  * Creates a sessionless Pikku function that doesn't require user authentication.
  * Use this for public endpoints, webhooks, or background tasks.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuSessionlessFunc<Input, Output>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuSessionlessFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
- * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
+ * \`\`\`typescript
+ * // Pattern 1: Using generic types
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string}>({
  *   func: async ({logger}) => {
- *     logger.info('Health check requested')
- *     return {status: 'healthy', timestamp: new Date().toISOString()}
- *   },
- *   name: 'healthCheck'
+ *     return { status: 'healthy' }
+ *   }
+ * })
+ *
+ * // Pattern 2: Using Zod schemas
+ * const greetInput = z.object({ name: z.string() })
+ * const greetOutput = z.object({ message: z.string() })
+ *
+ * const greet = pikkuSessionlessFunc({
+ *   input: greetInput,
+ *   output: greetOutput,
+ *   func: async (_services, { name }) => {
+ *     return { message: \`Hello, \${name}!\` }
+ *   }
  * })
- * \\\`\\\`\\\`
+ * \`\`\`
  */
-export const pikkuSessionlessFunc = <In, Out = unknown>(
+export function pikkuSessionlessFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuSessionlessFunc<In, Out = unknown>(
   func:
-    | PikkuFunctionSessionless<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
-) => {
+    | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
+    | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuSessionlessFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -313,22 +408,61 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
+ * \`\`\`typescript
  * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
  *     logger.info('Starting cleanup of temporary files')
  *     await fileSystem.deleteDirectory('/tmp/uploads')
  *     logger.info('Cleanup completed')
  * })
- * \\\`\\\`\\\`
+ * \`\`\`
  */
 export const pikkuVoidFunc = (
   func:
-    | PikkuFunctionSessionless<void, void>
-    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
+    | PikkuFunctionSessionless<void, void, 'session' | 'rpc'>
+    | PikkuFunctionConfig<void, void, 'session' | 'rpc'>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Creates a wrapper function for external package functions that are exposed via RPC.
+ * This allows you to wire external functions to any wiring type (HTTP, queue, etc.)
+ * without type compatibility issues.
+ *
+ * @template Name - The RPC method name (must be a key in FlattenedRPCMap)
+ * @param rpcName - The name of the RPC method to invoke
+ * @returns A Pikku function that proxies calls to the external RPC method
+ *
+ * @example
+ * \`\`\`typescript
+ * // Wire an external function via HTTP
+ * wireHTTP({
+ *   auth: false,
+ *   method: 'get',
+ *   route: '/external/hello',
+ *   func: external('ext:hello'),
+ *   tags: ['external'],
+ * })
+ * \`\`\`
+ */
+export const external = <Name extends keyof FlattenedRPCMap>(
+  rpcName: Name
+): PikkuFunctionConfig<
+  FlattenedRPCMap[Name]['input'],
+  FlattenedRPCMap[Name]['output'],
+  'session' | 'rpc'
+> => {
+  return {
+    func: (async (_services: any, data: any, { rpc }: any) => {
+      return rpc.invoke(rpcName, data)
+    }) as any
+  } as PikkuFunctionConfig<
+    FlattenedRPCMap[Name]['input'],
+    FlattenedRPCMap[Name]['output'],
+    'session' | 'rpc'
+  >
+}
+
 /**
  * Creates a Pikku config factory.
  * Use this to define your application's configuration factory.
@@ -373,28 +507,28 @@ export const pikkuServices = (
 ) => func
 
 /**
- * Creates a Pikku session services factory.
+ * Creates a Pikku wire services factory.
  * Use this to define services that are created per-request/session.
  *
- * @param func - Session services factory function
- * @returns The session services factory function
+ * @param func - Wire services factory function
+ * @returns The wire services factory function
  *
  * @example
  * \`\`\`typescript
- * export const createSessionServices = pikkuSessionServices(async (services, interaction, session) => {
+ * export const createWireServices = pikkuWireServices(async (services, wire) => {
+ *   const session = await wire.session?.get()
  *   return {
  *     userCache: new UserCache(session?.userId)
  *   }
  * })
  * \`\`\`
  */
-export const pikkuSessionServices = (
+export const pikkuWireServices = (
   func: (
     services: SingletonServices,
-    interaction: any,
-    session: Session | undefined
-  ) => Promise<RequiredSessionServices>
-) => func
+    wire: any
+  ) => Promise<RequiredWireServices>
+): CreateWireServices => func as unknown as CreateWireServices
 
 /**
  * Adds global middleware for a specific tag.
@@ -420,7 +554,7 @@ export const pikkuSessionServices = (
  * \`\`\`
  */
 export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
-  addMiddlewareCore(tag, middleware as any)
+  addMiddlewareCore(tag, middleware as any, ${packageNameValue})
 }
 
 /**
@@ -447,7 +581,7 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * \`\`\`
  */
 export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
-  addPermissionCore(tag, permissions as any)
+  addPermissionCore(tag, permissions as any, ${packageNameValue})
 }
 `
 }

package/src/functions/wirings/functions/serialize-pikku-types-hub.ts

@@ -3,36 +3,37 @@
  */
 export const serializePikkuTypesHub = (
   functionTypesImportPath: string,
-  httpTypesImportPath: string,
-  channelTypesImportPath: string,
-  schedulerTypesImportPath: string,
-  queueTypesImportPath: string,
-  mcpTypesImportPath: string,
-  cliTypesImportPath: string
+  httpTypesImportPath: string | null,
+  channelTypesImportPath: string | null,
+  schedulerTypesImportPath: string | null,
+  queueTypesImportPath: string | null,
+  mcpTypesImportPath: string | null,
+  cliTypesImportPath: string | null,
+  forgeTypesImportPath: string | null
 ) => {
+  const exports = [
+    {
+      comment: 'Core function, middleware, and permission types',
+      path: functionTypesImportPath,
+    },
+    { comment: 'HTTP wiring types', path: httpTypesImportPath },
+    { comment: 'Channel wiring types', path: channelTypesImportPath },
+    { comment: 'Scheduler wiring types', path: schedulerTypesImportPath },
+    { comment: 'Queue wiring types', path: queueTypesImportPath },
+    { comment: 'MCP wiring types', path: mcpTypesImportPath },
+    { comment: 'CLI wiring types', path: cliTypesImportPath },
+    { comment: 'Forge wiring types', path: forgeTypesImportPath },
+  ]
+
+  const exportStatements = exports
+    .filter((e) => e.path)
+    .map((e) => `// ${e.comment}\nexport * from '${e.path}'`)
+    .join('\n\n')
+
   return `/**
  * Main type export hub - re-exports all wiring-specific types
  */
 
-// Core function, middleware, and permission types
-export * from '${functionTypesImportPath}'
-
-// HTTP wiring types
-export * from '${httpTypesImportPath}'
-
-// Channel wiring types
-export * from '${channelTypesImportPath}'
-
-// Scheduler wiring types
-export * from '${schedulerTypesImportPath}'
-
-// Queue wiring types
-export * from '${queueTypesImportPath}'
-
-// MCP wiring types
-export * from '${mcpTypesImportPath}'
-
-// CLI wiring types
-export * from '${cliTypesImportPath}'
+${exportStatements}
 `
 }

package/src/functions/wirings/http/openapi-spec-generator.ts

@@ -68,7 +68,7 @@ export interface OpenAPISpecInfo {
 }
 
 const getErrorResponseForConstructorName = (constructorName: string) => {
-  const errors = Array.from(pikkuState('misc', 'errors').entries())
+  const errors = Array.from(pikkuState(null, 'misc', 'errors').entries())
   const foundError = errors.find(([e]) => e.name === constructorName)
   if (foundError) {
     return foundError[1]
@@ -120,8 +120,17 @@ export async function generateOpenAPISpec(
 
   for (const routeMeta of Object.values(httpMeta)) {
     for (const meta of Object.values(routeMeta)) {
-      const { route, method, inputTypes, pikkuFuncName, params, query, docs } =
-        meta
+      const {
+        route,
+        method,
+        inputTypes,
+        pikkuFuncName,
+        params,
+        query,
+        errors,
+        description,
+        tags,
+      } = meta
       const functionMeta = functionsMeta[pikkuFuncName]
       if (!functionMeta) {
         logger.error(
@@ -139,7 +148,7 @@ export async function generateOpenAPISpec(
       }
 
       const responses = {}
-      docs?.errors?.forEach((error) => {
+      errors?.forEach((error) => {
         const errorResponse = getErrorResponseForConstructorName(error)
         if (errorResponse) {
           responses[errorResponse.status] = {
@@ -150,9 +159,9 @@ export async function generateOpenAPISpec(
 
       const operation: any = {
         description:
-          docs?.description ||
+          description ||
           `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-        tags: docs?.tags || [route.split('/')[1] || 'default'],
+        tags: tags || [route.split('/')[1] || 'default'],
         parameters: [],
         responses: {
           ...responses,