@pikku/cli 0.9.15 → 0.10.0

package/dist/src/functions/wirings/functions/pikku-function-types.js

@@ -0,0 +1,18 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
+export const pikkuFunctionTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        await writeFileInDir(logger, typesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating api types hub',
+            commandEnd: 'Created api types hub',
+        }),
+    ],
+});

package/dist/src/functions/wirings/functions/schemas.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate JSON schemas from TypeScript types
+ */
+export declare const pikkuSchemas: any;

package/dist/src/functions/wirings/functions/schemas.js

@@ -0,0 +1,20 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { saveSchemas, generateSchemas, } from '../../../utils/schema-generator.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+/**
+ * Generate JSON schemas from TypeScript types
+ */
+export const pikkuSchemas = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes);
+        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.supportsImportAttributes, config.schemasFromTypes);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating schemas',
+            commandEnd: 'Generated schemas',
+        }),
+    ],
+});

package/dist/src/{wirings → functions/wirings}/functions/serialize-function-imports.js

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath } from '../../utils.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
@@ -9,33 +9,16 @@ export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta
     const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
     for (const [name, { path, exportedName }] of sortedEntries) {
         const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // Find the function metadata to check if it's a direct function
-        // The functionsMeta is keyed by the function name (exported name)
-        const funcMeta = functionsMeta[name];
-        const isDirectFunction = funcMeta?.isDirectFunction ?? false;
+        // pikkuFunc/pikkuSessionlessFunc/pikkuVoidFunc always return config objects
         // For directly exported functions, we can just import and register them
         if (name === exportedName) {
             serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            if (isDirectFunction) {
-                // Direct function: pikkuFunc(fn) - needs to be wrapped
-                serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-            }
-            else {
-                // Object format: pikkuFunc({ func: fn }) - can be used directly
-                serializedRegistrations.push(`addFunction('${name}', ${exportedName} as any) // TODO`);
-            }
+            serializedRegistrations.push(`addFunction('${name}', ${exportedName})`);
         }
         // For renamed functions, we need to import and alias them
         else {
             serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            if (isDirectFunction) {
-                // Direct function: pikkuFunc(fn) - needs to be wrapped
-                serializedRegistrations.push(`addFunction('${name}', { func: ${name} })`);
-            }
-            else {
-                // Object format: pikkuFunc({ func: fn }) - can be used directly
-                serializedRegistrations.push(`addFunction('${name}', ${name} as any) // TODO`);
-            }
+            serializedRegistrations.push(`addFunction('${name}', ${name})`);
         }
     }
     // Add a blank line between imports and registrations

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

@@ -0,0 +1,4 @@
+/**
+ * Generates core function, middleware, and permission type definitions
+ */
+export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, sessionServicesTypeName: string, rpcMapTypeImport: string, requiredServicesTypeImport: string, configTypeImport: string) => string;

package/dist/src/functions/wirings/functions/serialize-function-types.js

@@ -0,0 +1,443 @@
+/**
+ * Generates core function, middleware, and permission type definitions
+ */
+export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, sessionServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport) => {
+    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/dist/src/functions/wirings/functions/serialize-pikku-types-hub.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generates the main pikku-types.gen.ts file as a re-export hub
+ */
+export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string, channelTypesImportPath: string, schedulerTypesImportPath: string, queueTypesImportPath: string, mcpTypesImportPath: string, cliTypesImportPath: string) => string;

package/dist/src/functions/wirings/functions/serialize-pikku-types-hub.js

@@ -0,0 +1,30 @@
+/**
+ * Generates the main pikku-types.gen.ts file as a re-export hub
+ */
+export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath) => {
+    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/dist/src/{wirings → functions/wirings}/http/openapi-spec-generator.d.ts

@@ -1,4 +1,6 @@
-import { FunctionsMeta, HTTPWiringsMeta } from '@pikku/core';
+import { FunctionsMeta } from '@pikku/core';
+import { HTTPWiringsMeta } from '@pikku/core/http';
+import { CLILogger } from '../../../services/cli-logger.service.js';
 interface OpenAPISpec {
     openapi: string;
     info: {
@@ -75,5 +77,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(logger: CLILogger, functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

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

@@ -34,14 +34,14 @@ const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas)
     }));
     return Object.fromEntries(convertedEntries.filter((s) => !!s));
 };
-export async function generateOpenAPISpec(functionsMeta, httpMeta, schemas, additionalInfo) {
+export async function generateOpenAPISpec(logger, functionsMeta, httpMeta, schemas, additionalInfo) {
     const paths = {};
     for (const routeMeta of Object.values(httpMeta)) {
         for (const meta of Object.values(routeMeta)) {
             const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
             const functionMeta = functionsMeta[pikkuFuncName];
             if (!functionMeta) {
-                console.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
+                logger.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
                 continue;
             }
             const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;

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

@@ -0,0 +1 @@
+export declare const pikkuHTTPMap: any;

package/dist/src/functions/wirings/http/pikku-command-http-map.js

@@ -0,0 +1,18 @@
+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 = pikkuSessionlessFunc({
+    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/dist/src/functions/wirings/http/pikku-command-http-routes.d.ts

@@ -0,0 +1 @@
+export declare const pikkuHTTP: any;

package/dist/src/functions/wirings/http/pikku-command-http-routes.js

@@ -0,0 +1,20 @@
+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 = pikkuSessionlessFunc({
+    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/dist/src/functions/wirings/http/pikku-command-http-types.d.ts

@@ -0,0 +1 @@
+export declare const pikkuHTTPTypes: any;