@pikku/cli 0.9.15 → 0.10.0

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

@@ -0,0 +1,453 @@
+/**
+ * Generates core function, middleware, and permission type definitions
+ */
+export const serializeFunctionTypes = (
+  userSessionTypeImport: string,
+  userSessionTypeName: string,
+  singletonServicesTypeImport: string,
+  singletonServicesTypeName: string,
+  sessionServicesTypeImport: string,
+  sessionServicesTypeName: string,
+  rpcMapTypeImport: string,
+  requiredServicesTypeImport: string,
+  configTypeImport: string
+) => {
+  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 { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
+import { PikkuChannel } from '@pikku/core/channel'
+import { PikkuMCP } from '@pikku/core/mcp'
+
+${userSessionTypeImport}
+${singletonServicesTypeImport}
+${sessionServicesTypeImport}
+${configTypeImport}
+${rpcMapTypeImport}
+${requiredServicesTypeImport}
+
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
+${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
+
+/**
+ * Type-safe API permission definition that integrates with your application's session type.
+ * Use this to define authorization logic for your API endpoints.
+ *
+ * @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>
+
+/**
+ * Type-safe middleware definition that can access your application's services and session.
+ * Use this to define reusable middleware that can be applied to multiple wirings.
+ *
+ * @template RequiredServices - The services required for this middleware
+ */
+export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
+
+/**
+ * Configuration object for creating a permission with metadata
+ */
+export type PikkuPermissionConfig<In = unknown, RequiredServices extends Services = Services> = {
+  /** The permission function */
+  func: PikkuPermission<In, RequiredServices>
+  /** Optional human-readable name for the permission */
+  name?: string
+  /** Optional description of what the permission checks */
+  description?: string
+}
+
+/**
+ * Factory function for creating permissions with tree-shaking support.
+ * Supports both direct function and configuration object syntax.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Direct function syntax
+ * const permission = pikkuPermission(({ logger }, data, session) => {
+ *   return session?.role === 'admin'
+ * })
+ *
+ * // Configuration object syntax with metadata
+ * const adminPermission = pikkuPermission({
+ *   name: 'Admin Permission',
+ *   description: 'Checks if user has admin role',
+ *   func: async ({ logger }, data, session) => {
+ *     return session?.role === 'admin'
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuPermission = <In>(
+  permission: PikkuPermission<In> | PikkuPermissionConfig<In>
+): PikkuPermission<In> => {
+  return typeof permission === 'function' ? permission : permission.func
+}
+
+/**
+ * Configuration object for creating middleware with metadata
+ */
+export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = SingletonServices> = {
+  /** The middleware function */
+  func: PikkuMiddleware<RequiredServices>
+  /** Optional human-readable name for the middleware */
+  name?: string
+  /** Optional description of what the middleware does */
+  description?: string
+}
+
+/**
+ * Factory function for creating middleware with tree-shaking support.
+ * Supports both direct function and configuration object syntax.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Direct function syntax
+ * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
+ *   logger.info('Middleware executed')
+ *   await next()
+ * })
+ *
+ * // Configuration object syntax with metadata
+ * const logMiddleware = pikkuMiddleware({
+ *   name: 'Request Logger',
+ *   description: 'Logs all incoming requests',
+ *   func: async ({ logger }, interactions, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddleware = <RequiredServices extends SingletonServices = SingletonServices>(
+  middleware: PikkuMiddleware<RequiredServices> | PikkuMiddlewareConfig<RequiredServices>
+): PikkuMiddleware<RequiredServices> => {
+  return typeof middleware === 'function' ? middleware : middleware.func
+}
+
+/**
+ * Factory function for creating middleware factories
+ * Use this when your middleware needs configuration/input parameters
+ *
+ * @example
+ * \`\`\`typescript
+ * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
+ *   message,
+ *   level = 'info'
+ * }) => {
+ *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *     logger[level](message)
+ *     await next()
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddlewareFactory = <In = any>(
+  factory: (input: In) => PikkuMiddleware
+): ((input: In) => PikkuMiddleware) => {
+  return factory
+}
+
+/**
+ * Factory function for creating permission factories
+ * Use this when your permission needs configuration/input parameters
+ *
+ * @example
+ * \`\`\`typescript
+ * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
+ *   role
+ * }) => {
+ *   return pikkuPermission(async ({ logger }, data, session) => {
+ *     if (!session || session.role !== role) {
+ *       logger.warn(\`Permission denied: required role '\${role}'\`)
+ *       return false
+ *     }
+ *     return true
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuPermissionFactory = <In = any>(
+  factory: (input: In) => PikkuPermission<any>
+): ((input: In) => PikkuPermission<any>) => {
+  return factory
+}
+
+/**
+ * A sessionless API function that doesn't require user authentication.
+ * Use this for public endpoints, health checks, or operations that don't need user context.
+ *
+ * @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>
+
+/**
+ * A session-aware API function that requires user authentication.
+ * Use this for protected endpoints that need access to user session data.
+ *
+ * @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>
+
+/**
+ * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
+ * This type wraps CorePikkuFunctionConfig with the user's custom types.
+ *
+ * @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>
+
+/**
+ * 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
+ * @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)
+ *     const user = await db.users.create(input)
+ *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
+ *   },
+ *   auth: true
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunction<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * 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
+ * @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}>({
+ *   func: async ({logger}) => {
+ *     logger.info('Health check requested')
+ *     return {status: 'healthy', timestamp: new Date().toISOString()}
+ *   },
+ *   name: 'healthCheck'
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuSessionlessFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionSessionless<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function that takes no input and returns no output.
+ * Useful for health checks, triggers, or cleanup operations.
+ *
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * \\\`\\\`\\\`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>>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a Pikku config factory.
+ * Use this to define your application's configuration factory.
+ *
+ * @param func - Config factory function that returns your application's config
+ * @returns The config factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createConfig = pikkuConfig(async () => {
+ *   return {
+ *     apiUrl: process.env.API_URL || 'http://localhost:3000',
+ *     dbUrl: process.env.DATABASE_URL
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuConfig = (
+  func: (variables?: any, ...args: any[]) => Promise<Config>
+) => func
+
+/**
+ * Creates a Pikku singleton services factory.
+ * Use this to define services that are created once and shared across all requests.
+ *
+ * @param func - Singleton services factory function
+ * @returns The singleton services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSingletonServices = pikkuServices(async (config, existingServices) => {
+ *   return {
+ *     config,
+ *     logger: new CustomLogger(),
+ *     db: await createDatabaseConnection(config.dbUrl)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuServices = (
+  func: (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
+) => func
+
+/**
+ * Creates a Pikku session 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
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSessionServices = pikkuSessionServices(async (services, interaction, session) => {
+ *   return {
+ *     userCache: new UserCache(session?.userId)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuSessionServices = (
+  func: (
+    services: SingletonServices,
+    interaction: any,
+    session: Session | undefined
+  ) => Promise<RequiredSessionServices>
+) => func
+
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param tag - The tag that the middleware should apply to.
+ * @param middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws Error if middleware for the tag already exists.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * \`\`\`
+ */
+export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
+  addMiddlewareCore(tag, middleware as any)
+}
+
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param tag - The tag that the permissions should apply to.
+ * @param permissions - The permissions array or object to apply for the specified tag.
+ *
+ * @throws Error if permissions for the tag already exist.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints (as object)
+ * addPermission('api', { read: readPermission })
+ * \`\`\`
+ */
+export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
+  addPermissionCore(tag, permissions as any)
+}
+`
+}

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

@@ -0,0 +1,38 @@
+/**
+ * Generates the main pikku-types.gen.ts file as a re-export hub
+ */
+export const serializePikkuTypesHub = (
+  functionTypesImportPath: string,
+  httpTypesImportPath: string,
+  channelTypesImportPath: string,
+  schedulerTypesImportPath: string,
+  queueTypesImportPath: string,
+  mcpTypesImportPath: string,
+  cliTypesImportPath: string
+) => {
+  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}'
+`
+}

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

@@ -1,5 +1,7 @@
-import { FunctionsMeta, HTTPWiringsMeta, pikkuState } from '@pikku/core'
+import { FunctionsMeta, pikkuState } from '@pikku/core'
+import { HTTPWiringsMeta } from '@pikku/core/http'
 import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
+import { CLILogger } from '../../../services/cli-logger.service.js'
 const convertSchema =
   'default' in _convertSchema ? (_convertSchema.default as any) : _convertSchema
 
@@ -108,6 +110,7 @@ const convertSchemasToBodyPayloads = async (
 }
 
 export async function generateOpenAPISpec(
+  logger: CLILogger,
   functionsMeta: FunctionsMeta,
   httpMeta: HTTPWiringsMeta,
   schemas: Record<string, any>,
@@ -121,7 +124,7 @@ export async function generateOpenAPISpec(
         meta
       const functionMeta = functionsMeta[pikkuFuncName]
       if (!functionMeta) {
-        console.error(
+        logger.error(
           `• No function metadata found for '${pikkuFuncName}' in route '${route}'.`
         )
         continue

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

@@ -0,0 +1,27 @@
+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 { serializeTypedHTTPWiringsMap } from './serialize-typed-http-map.js'
+
+export const pikkuHTTPMap: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { http, functions } = await getInspectorState()
+    const { httpMapDeclarationFile, packageMappings } = config
+
+    const content = serializeTypedHTTPWiringsMap(
+      httpMapDeclarationFile,
+      packageMappings,
+      functions.typesMap,
+      functions.meta,
+      http.meta,
+      http.metaInputTypes
+    )
+    await writeFileInDir(logger, httpMapDeclarationFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating HTTP map',
+      commandEnd: 'Created HTTP map',
+    }),
+  ],
+})

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

@@ -0,0 +1,36 @@
+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 | undefined>({
+  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/pikku-command-http-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 { serializeHTTPTypes } from './serialize-http-types.js'
+
+export const pikkuHTTPTypes: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config }) => {
+    const { httpTypesFile, functionTypesFile, packageMappings } = config
+
+    const functionTypesImportPath = getFileImportRelativePath(
+      httpTypesFile,
+      functionTypesFile,
+      packageMappings
+    )
+    const content = serializeHTTPTypes(functionTypesImportPath)
+    await writeFileInDir(logger, httpTypesFile, content)
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating HTTP types',
+      commandEnd: 'Created HTTP types',
+    }),
+  ],
+})

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

@@ -0,0 +1,62 @@
+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 { generateSchemas } from '../../../utils/schema-generator.js'
+import { generateOpenAPISpec } from './openapi-spec-generator.js'
+import { stringify } from 'yaml'
+
+export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { tsconfig, openAPI, schemasFromTypes } = config
+
+    // If openAPI outputFile is not defined, clean up any existing file and return
+    if (!openAPI?.outputFile) {
+      logger.info({
+        message:
+          'Skipping creating OpenAPI spec since openAPI outfile is not defined.',
+        type: 'skip',
+      })
+      return
+    }
+
+    const { http, functions } = await getInspectorState()
+
+    const schemas = await generateSchemas(
+      logger,
+      tsconfig,
+      functions.typesMap,
+      functions.meta,
+      http.meta,
+      schemasFromTypes
+    )
+    const openAPISpec = await generateOpenAPISpec(
+      logger,
+      functions.meta,
+      http.meta,
+      schemas,
+      openAPI.additionalInfo
+    )
+
+    if (openAPI.outputFile.endsWith('.json')) {
+      await writeFileInDir(
+        logger,
+        openAPI.outputFile,
+        JSON.stringify(openAPISpec, null, 2),
+        { ignoreModifyComment: true }
+      )
+    } else if (
+      openAPI.outputFile.endsWith('.yaml') ||
+      openAPI.outputFile.endsWith('.yml')
+    ) {
+      await writeFileInDir(logger, openAPI.outputFile, stringify(openAPISpec), {
+        ignoreModifyComment: true,
+      })
+    }
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Creating OpenAPI spec',
+      commandEnd: 'Created OpenAPI spec',
+    }),
+  ],
+})