@pikku/cli 0.7.1 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @pikku/cli
 
+## 0.7.2
+
+### Patch Changes
+
+- 598588f: fix: generating output schemas from function meta
+- Updated dependencies [598588f]
+  - @pikku/inspector@0.7.4
+  - @pikku/core@0.7.4
+
 ## 0.7.1
 
 ### Patch Changes

package/bin/pikku-http-map.ts

@@ -23,6 +23,7 @@ export const pikkuHTTPMap = async (
         httpRoutesMapDeclarationFile,
         packageMappings,
         functions.typesMap,
+        functions.meta,
         http.meta,
         http.metaInputTypes
       )

package/bin/pikku-openapi.ts

@@ -26,10 +26,12 @@ export const pikkuOpenAPI = async (
       }
       const schemas = await generateSchemas(
         tsconfig,
-        [http.typesMap, functions.typesMap],
+        functions.typesMap,
+        functions.meta,
         http.meta
       )
       const openAPISpec = await generateOpenAPISpec(
+        functions.meta,
         http.meta,
         schemas,
         openAPI.additionalInfo

package/bin/pikku-schemas.ts

@@ -17,14 +17,15 @@ export const pikkuSchemas = async (
     async () => {
       const schemas = await generateSchemas(
         tsconfig,
-        [functions.typesMap, http.typesMap, channels.typesMap],
+        functions.typesMap,
+        functions.meta,
         http.meta
       )
       await saveSchemas(
         schemaDirectory,
         schemas,
         functions.typesMap,
-        http.meta,
+        functions.meta,
         supportsImportAttributes
       )
     }

package/dist/bin/pikku-http-map.js

@@ -4,7 +4,7 @@ import { serializeTypedRoutesMap } from '../src/serialize-typed-http-map.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuHTTPMap = async ({ httpRoutesMapDeclarationFile, packageMappings }, { http, functions }) => {
     return await logCommandInfoAndTime('Creating HTTP map', 'Created HTTP map', [http.files.size === 0], async () => {
-        const content = serializeTypedRoutesMap(httpRoutesMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes);
+        const content = serializeTypedRoutesMap(httpRoutesMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, http.meta, http.metaInputTypes);
         await writeFileInDir(httpRoutesMapDeclarationFile, content);
     });
 };

package/dist/bin/pikku-openapi.js

@@ -9,8 +9,8 @@ export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http, functions }) =
         if (!openAPI?.outputFile) {
             throw new Error('openAPI is required');
         }
-        const schemas = await generateSchemas(tsconfig, [http.typesMap, functions.typesMap], http.meta);
-        const openAPISpec = await generateOpenAPISpec(http.meta, schemas, openAPI.additionalInfo);
+        const schemas = await generateSchemas(tsconfig, functions.typesMap, functions.meta, http.meta);
+        const openAPISpec = await generateOpenAPISpec(functions.meta, http.meta, schemas, openAPI.additionalInfo);
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), true);
         }

package/dist/bin/pikku-schemas.js

@@ -4,8 +4,8 @@ import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuSchemas = async ({ tsconfig, schemaDirectory, supportsImportAttributes }, { functions, http, channels }) => {
     return await logCommandInfoAndTime('Creating schemas', 'Created schemas', [false], async () => {
-        const schemas = await generateSchemas(tsconfig, [functions.typesMap, http.typesMap, channels.typesMap], http.meta);
-        await saveSchemas(schemaDirectory, schemas, functions.typesMap, http.meta, supportsImportAttributes);
+        const schemas = await generateSchemas(tsconfig, functions.typesMap, functions.meta, http.meta);
+        await saveSchemas(schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes);
     });
 };
 async function action({ config }) {

package/dist/src/openapi-spec-generator.d.ts

@@ -1,4 +1,4 @@
-import { HTTPRoutesMeta } from '@pikku/core';
+import { FunctionsMeta, HTTPRoutesMeta } from '@pikku/core';
 interface OpenAPISpec {
     openapi: string;
     info: {
@@ -75,5 +75,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

package/dist/src/openapi-spec-generator.js

@@ -9,9 +9,12 @@ const getErrorResponseForConstructorName = (constructorName) => {
     }
     return undefined;
 };
-const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
+const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
     const requiredSchemas = new Set(routesMeta
-        .map(({ inputTypes, output }) => [inputTypes?.body, output])
+        .map(({ inputTypes, pikkuFuncName }) => {
+        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
+        return [inputTypes?.body, output];
+    })
         .flat()
         .filter((schema) => !!schema));
     const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
@@ -26,10 +29,16 @@ const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
     }));
     return Object.fromEntries(convertedEntries.filter((s) => !!s));
 };
-export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
+export async function generateOpenAPISpec(functionsMeta, routeMeta, schemas, additionalInfo) {
     const paths = {};
     routeMeta.forEach((meta) => {
-        const { route, method, inputTypes, output, params, query, docs } = meta;
+        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}'.`);
+            return;
+        }
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
         if (!paths[path]) {
             paths[path] = {};
@@ -103,7 +112,7 @@ export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
         servers: additionalInfo.servers,
         paths,
         components: {
-            schemas: await convertSchemasToBodyPayloads(routeMeta, schemas),
+            schemas: await convertSchemasToBodyPayloads(functionsMeta, routeMeta, schemas),
             responses: {},
             parameters: {},
             examples: {},

package/dist/src/schema-generator.d.ts

@@ -1,5 +1,5 @@
-import { JSONValue } from '@pikku/core';
+import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(tsconfig: string, typesMaps: TypesMap[], httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, supportsImportAttributes: boolean): Promise<void>;
+export declare function generateSchemas(tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
+export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/schema-generator.js

@@ -1,36 +1,18 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator';
 import { logInfo, writeFileInDir } from './utils.js';
 import { mkdir, writeFile } from 'fs/promises';
-export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
-    const schemasSet = new Set(typesMaps.flatMap((tm) => [...tm.customTypes.keys()]));
-    for (const { input, inputTypes } of httpRoutesMeta) {
-        if (input) {
-            let found = false;
-            for (const typesMap of typesMaps) {
-                try {
-                    const uniqueName = typesMap.getUniqueName(input);
-                    if (uniqueName) {
-                        found = true;
-                        schemasSet.add(uniqueName);
-                        break;
-                    }
-                }
-                catch (e) { }
-            }
-            if (!found) {
-                console.error('Input type not found in any types map:', input);
+export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRoutesMeta) {
+    const schemasSet = new Set(typesMap.customTypes.keys());
+    for (const { inputs, outputs } of Object.values(functionMeta)) {
+        const types = [...(inputs || []), ...(outputs || [])];
+        for (const type of types) {
+            const uniqueName = typesMap.getUniqueName(type);
+            if (uniqueName) {
+                schemasSet.add(uniqueName);
             }
         }
-        // if (output) {
-        //   for (const typesMap of typesMaps) {
-        //     const uniqueName = typesMap.getUniqueName(output)
-        //     if (uniqueName) {
-        //       console.log('Adding output schema:', uniqueName)
-        //       schemasSet.add(uniqueName)
-        //       break
-        //     }
-        //   }
-        // }
+    }
+    for (const { inputTypes } of httpRoutesMeta) {
         if (inputTypes?.body) {
             schemasSet.add(inputTypes.body);
         }
@@ -63,13 +45,13 @@ export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
     });
     return schemas;
 }
-export async function saveSchemas(schemaParentDir, schemas, typesMap, routesMeta, supportsImportAttributes) {
+export async function saveSchemas(schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes) {
     await writeFileInDir(`${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
     const desiredSchemas = new Set([
-        ...routesMeta
-            .map(({ input, output }) => [
-            input ? typesMap.getUniqueName(input) : undefined,
-            output ? typesMap.getUniqueName(output) : undefined,
+        ...Object.values(functionsMeta)
+            .map(({ inputs, outputs }) => [
+            inputs?.[0] ? typesMap.getUniqueName(inputs[0]) : undefined,
+            outputs?.[0] ? typesMap.getUniqueName(outputs[0]) : undefined,
         ])
             .flat()
             .filter((s) => !!s &&

package/dist/src/serialize-typed-function-map.d.ts

@@ -1,4 +1,5 @@
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
 export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/serialize-typed-function-map.js

@@ -1,9 +1,9 @@
 import { serializeImportMap } from './serialize-import-map.js';
-export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
+export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedRoutes = generateRoutes(functionsMeta, routesMeta, typesMap, requiredTypes);
     const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
@@ -44,11 +44,13 @@ ${Array.from(typesMap.customTypes.entries())
     })
         .join('\n')}`;
 }
-function generateRoutes(routesMeta, typesMap, requiredTypes) {
+function generateRoutes(functionsMeta, routesMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};
     for (const meta of routesMeta) {
-        const { route, method, input, output } = meta;
+        const { route, method, pikkuFuncName } = meta;
+        const input = functionsMeta[pikkuFuncName]?.inputs?.[0];
+        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
         // Initialize the route entry if it doesn't exist
         if (!routesObj[route]) {
             routesObj[route] = {};

package/dist/src/serialize-typed-http-map.d.ts

@@ -1,4 +1,5 @@
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
 export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/serialize-typed-http-map.js

@@ -1,9 +1,9 @@
 import { serializeImportMap } from './serialize-import-map.js';
-export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, routesMeta, metaTypes) => {
+export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes);
+    const serializedRoutes = generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes);
     const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
@@ -44,11 +44,17 @@ ${Array.from(typesMap.customTypes.entries())
     })
         .join('\n')}`;
 }
-function generateRoutes(routesMeta, typesMap, requiredTypes) {
+function generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};
     for (const meta of routesMeta) {
-        const { route, method, input, output } = meta;
+        const { route, method, pikkuFuncName } = meta;
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         // Initialize the route entry if it doesn't exist
         if (!routesObj[route]) {
             routesObj[route] = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.7.3",
-    "@pikku/inspector": "^0.7.3",
+    "@pikku/core": "^0.7.4",
+    "@pikku/inspector": "^0.7.4",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/openapi-spec-generator.ts

@@ -1,4 +1,4 @@
-import { HTTPRoutesMeta, pikkuState } from '@pikku/core'
+import { FunctionsMeta, HTTPRoutesMeta, pikkuState } from '@pikku/core'
 import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
 const convertSchema =
   'default' in _convertSchema ? (_convertSchema.default as any) : _convertSchema
@@ -75,12 +75,16 @@ const getErrorResponseForConstructorName = (constructorName: string) => {
 }
 
 const convertSchemasToBodyPayloads = async (
+  functionsMeta: FunctionsMeta,
   routesMeta: HTTPRoutesMeta,
   schemas: Record<string, any>
 ) => {
   const requiredSchemas = new Set(
     routesMeta
-      .map(({ inputTypes, output }) => [inputTypes?.body, output])
+      .map(({ inputTypes, pikkuFuncName }) => {
+        const output = functionsMeta[pikkuFuncName]?.outputs?.[0]
+        return [inputTypes?.body, output]
+      })
       .flat()
       .filter((schema) => !!schema)
   )
@@ -100,6 +104,7 @@ const convertSchemasToBodyPayloads = async (
 }
 
 export async function generateOpenAPISpec(
+  functionsMeta: FunctionsMeta,
   routeMeta: HTTPRoutesMeta,
   schemas: Record<string, any>,
   additionalInfo: OpenAPISpecInfo
@@ -107,7 +112,17 @@ export async function generateOpenAPISpec(
   const paths: Record<string, any> = {}
 
   routeMeta.forEach((meta) => {
-    const { route, method, inputTypes, output, params, query, docs } = meta
+    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}'.`
+      )
+      return
+    }
+    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
+
     const path = route.replace(/:(\w+)/g, '{$1}') // Convert ":param" to "{param}"
 
     if (!paths[path]) {
@@ -194,7 +209,11 @@ export async function generateOpenAPISpec(
     servers: additionalInfo.servers,
     paths,
     components: {
-      schemas: await convertSchemasToBodyPayloads(routeMeta, schemas),
+      schemas: await convertSchemasToBodyPayloads(
+        functionsMeta,
+        routeMeta,
+        schemas
+      ),
       responses: {},
       parameters: {},
       examples: {},

package/src/schema-generator.ts

@@ -1,45 +1,27 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
 import { logInfo, writeFileInDir } from './utils.js'
 import { mkdir, writeFile } from 'fs/promises'
-import { JSONValue } from '@pikku/core'
+import { FunctionsMeta, JSONValue } from '@pikku/core'
 import { HTTPRoutesMeta } from '@pikku/core/http'
 import { TypesMap } from '@pikku/inspector'
 
 export async function generateSchemas(
   tsconfig: string,
-  typesMaps: TypesMap[],
+  typesMap: TypesMap,
+  functionMeta: FunctionsMeta,
   httpRoutesMeta: HTTPRoutesMeta
 ): Promise<Record<string, JSONValue>> {
-  const schemasSet = new Set(
-    typesMaps.flatMap((tm) => [...tm.customTypes.keys()])
-  )
-  for (const { input, inputTypes } of httpRoutesMeta) {
-    if (input) {
-      let found = false
-      for (const typesMap of typesMaps) {
-        try {
-          const uniqueName = typesMap.getUniqueName(input)
-          if (uniqueName) {
-            found = true
-            schemasSet.add(uniqueName)
-            break
-          }
-        } catch (e) {}
-      }
-      if (!found) {
-        console.error('Input type not found in any types map:', input)
+  const schemasSet = new Set(typesMap.customTypes.keys())
+  for (const { inputs, outputs } of Object.values(functionMeta)) {
+    const types = [...(inputs || []), ...(outputs || [])]
+    for (const type of types) {
+      const uniqueName = typesMap.getUniqueName(type)
+      if (uniqueName) {
+        schemasSet.add(uniqueName)
       }
     }
-    // if (output) {
-    //   for (const typesMap of typesMaps) {
-    //     const uniqueName = typesMap.getUniqueName(output)
-    //     if (uniqueName) {
-    //       console.log('Adding output schema:', uniqueName)
-    //       schemasSet.add(uniqueName)
-    //       break
-    //     }
-    //   }
-    // }
+  }
+  for (const { inputTypes } of httpRoutesMeta) {
     if (inputTypes?.body) {
       schemasSet.add(inputTypes.body)
     }
@@ -78,7 +60,7 @@ export async function saveSchemas(
   schemaParentDir: string,
   schemas: Record<string, JSONValue>,
   typesMap: TypesMap,
-  routesMeta: HTTPRoutesMeta,
+  functionsMeta: FunctionsMeta,
   supportsImportAttributes: boolean
 ) {
   await writeFileInDir(
@@ -87,10 +69,10 @@ export async function saveSchemas(
   )
 
   const desiredSchemas = new Set([
-    ...routesMeta
-      .map(({ input, output }) => [
-        input ? typesMap.getUniqueName(input) : undefined,
-        output ? typesMap.getUniqueName(output) : undefined,
+    ...Object.values(functionsMeta)
+      .map(({ inputs, outputs }) => [
+        inputs?.[0] ? typesMap.getUniqueName(inputs[0]) : undefined,
+        outputs?.[0] ? typesMap.getUniqueName(outputs[0]) : undefined,
       ])
       .flat()
       .filter(

package/src/serialize-typed-function-map.ts

@@ -1,18 +1,25 @@
 import { HTTPRoutesMeta } from '@pikku/core/http'
 import { serializeImportMap } from './serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
+import { FunctionsMeta } from '@pikku/core'
 
 export const serializeTypedRoutesMap = (
   relativeToPath: string,
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
+  functionsMeta: FunctionsMeta,
   routesMeta: HTTPRoutesMeta,
   metaTypes: MetaInputTypes
 ) => {
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
   const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
-  const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes)
+  const serializedRoutes = generateRoutes(
+    functionsMeta,
+    routesMeta,
+    typesMap,
+    requiredTypes
+  )
 
   const serializedImportMap = serializeImportMap(
     relativeToPath,
@@ -66,6 +73,7 @@ ${Array.from(typesMap.customTypes.entries())
 }
 
 function generateRoutes(
+  functionsMeta: FunctionsMeta,
   routesMeta: HTTPRoutesMeta,
   typesMap: TypesMap,
   requiredTypes: Set<string>
@@ -77,7 +85,9 @@ function generateRoutes(
   > = {}
 
   for (const meta of routesMeta) {
-    const { route, method, input, output } = meta
+    const { route, method, pikkuFuncName } = meta
+    const input = functionsMeta[pikkuFuncName]?.inputs?.[0]
+    const output = functionsMeta[pikkuFuncName]?.outputs?.[0]
 
     // Initialize the route entry if it doesn't exist
     if (!routesObj[route]) {

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

@@ -1,18 +1,25 @@
 import { HTTPRoutesMeta } from '@pikku/core/http'
 import { serializeImportMap } from './serialize-import-map.js'
 import { MetaInputTypes, TypesMap } from '@pikku/inspector'
+import { FunctionsMeta } from '@pikku/core'
 
 export const serializeTypedRoutesMap = (
   relativeToPath: string,
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
+  functionsMeta: FunctionsMeta,
   routesMeta: HTTPRoutesMeta,
   metaTypes: MetaInputTypes
 ) => {
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
   const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap)
-  const serializedRoutes = generateRoutes(routesMeta, typesMap, requiredTypes)
+  const serializedRoutes = generateRoutes(
+    routesMeta,
+    functionsMeta,
+    typesMap,
+    requiredTypes
+  )
 
   const serializedImportMap = serializeImportMap(
     relativeToPath,
@@ -67,6 +74,7 @@ ${Array.from(typesMap.customTypes.entries())
 
 function generateRoutes(
   routesMeta: HTTPRoutesMeta,
+  functionsMeta: FunctionsMeta,
   typesMap: TypesMap,
   requiredTypes: Set<string>
 ) {
@@ -77,7 +85,15 @@ function generateRoutes(
   > = {}
 
   for (const meta of routesMeta) {
-    const { route, method, input, output } = meta
+    const { route, method, pikkuFuncName } = meta
+    const functionMeta = functionsMeta[pikkuFuncName]
+    if (!functionMeta) {
+      throw new Error(
+        `Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`
+      )
+    }
+    const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
+    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
     // Initialize the route entry if it doesn't exist
     if (!routesObj[route]) {