@pikku/cli 0.7.1 → 0.7.3

package/dist/src/serialize-pikku-types.js

@@ -1,7 +1,7 @@
 /**
  *
  */
-export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, servicesTypeName) => {
+export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, rpcMapTypeImport) => {
     return `/**
 * This is used to provide the application types in the typescript project
 */
@@ -15,6 +15,7 @@ import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pik
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
+${rpcMapTypeImport}
 
 export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
 export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
@@ -23,7 +24,8 @@ type APIFunctionSessionless<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
-  RequiredServices extends Services = Services & (
+  RequiredServices extends Services = Services &
+    { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
       : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
@@ -34,7 +36,8 @@ type APIFunction<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
-  RequiredServices extends Services = Services & (
+  RequiredServices extends Services = Services &
+    { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
       : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type

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

@@ -1,5 +1,5 @@
-import { serializeImportMap } from './serialize-import-map.js';
-import { generateCustomTypes } from './serialize-typed-http-map.js';
+import { serializeImportMap } from './utils/serialize-import-map.js';
+import { generateCustomTypes } from './utils/utils.js';
 export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, channelsMeta) => {
     const { channels, requiredTypes } = generateChannels(channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {

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) => {
+import { serializeImportMap } from './utils/serialize-import-map.js';
+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/dist/src/serialize-typed-rpc-map.d.ts

@@ -0,0 +1,4 @@
+import { TypesMap } from '@pikku/inspector';
+import { FunctionsMeta } from '@pikku/core';
+import { RPCMeta } from '../../core/src/rpc/rpc-types.js';
+export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, RPCMeta>) => string;

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

@@ -0,0 +1,66 @@
+import { serializeImportMap } from './utils/serialize-import-map.js';
+import { generateCustomTypes } from './utils/utils.js';
+export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta) => {
+    const requiredTypes = new Set();
+    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
+    const serializedRPCs = generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes);
+    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    return `/**
+ * This provides the structure needed for typescript to be aware of RPCs and their return types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+
+interface RPCHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedRPCs}
+
+type RPCInvoke = <Name extends keyof RPCMap>(
+  name: Name,
+  data: RPCMap[Name]['input'],
+  options?: {
+    location?: 'local' | 'remote' | 'auto'
+  }
+) => Promise<RPCMap[Name]['output']>
+
+export type TypedPikkuRPC = {
+  depth: number;
+  global: boolean;
+  invoke: RPCInvoke;
+}
+  `;
+};
+function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
+    // Initialize an object to collect RPCs
+    const rpcsObj = {};
+    // Iterate through RPC metadata
+    for (const [funcName, { pikkuFuncName }] of Object.entries(rpcMeta)) {
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            throw new Error(`Function ${funcName} not found in functionsMeta. Please check your configuration.`);
+        }
+        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+        // Store the input and output types for RPCHandler
+        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
+        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
+        requiredTypes.add(inputType);
+        requiredTypes.add(outputType);
+        // Add RPC entry
+        rpcsObj[funcName] = {
+            inputType,
+            outputType,
+        };
+    }
+    // Build the RPCs object as a string
+    let rpcsStr = 'export type RPCMap = {\n';
+    for (const [funcName, handler] of Object.entries(rpcsObj)) {
+        rpcsStr += `  readonly '${funcName}': RPCHandler<${handler.inputType}, ${handler.outputType}>,\n`;
+    }
+    rpcsStr += '};\n';
+    return rpcsStr;
+}

package/dist/src/{utils.d.ts → utils/utils.d.ts}

@@ -1,4 +1,4 @@
-import { InspectorState } from '@pikku/inspector';
+import { InspectorState, TypesMap } from '@pikku/inspector';
 export declare const logPrimary: (message: string) => void;
 export declare const logSuccess: (message: string) => void;
 export declare const logInfo: (message: string) => void;
@@ -39,4 +39,5 @@ export declare const logCommandInfoAndTime: (commandStart: string, commandEnd: s
 export declare const logPikkuLogo: () => void;
 export declare const DO_NOT_MODIFY_COMMENT = "/**\n * This file was generated by the @pikku/cli\n */\n";
 export declare const serializeFileImports: (importType: string, outputPath: string, files: Set<string>, packageMappings?: Record<string, string>) => string;
+export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;
 export {};

package/dist/src/{utils.js → utils/utils.js}

@@ -123,7 +123,7 @@ const logo = `
 `;
 export const logPikkuLogo = () => {
     logPrimary(logo);
-    const packageJson = JSON.parse(readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8'));
+    const packageJson = JSON.parse(readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8'));
     logPrimary(`⚙️ Welcome to the Pikku CLI (v${packageJson.version})\n`);
 };
 // TODO: add version back in once the ESM dust settles
@@ -143,3 +143,17 @@ export const serializeFileImports = (importType, outputPath, files, packageMappi
     });
     return serializedOutput.join('\n');
 };
+export function generateCustomTypes(typesMap, requiredTypes) {
+    return `
+// Custom types are those that are defined directly within generics
+// or are broken into simpler types
+${Array.from(typesMap.customTypes.entries())
+        .map(([name, { type, references }]) => {
+        references.forEach((name) => {
+            const originalName = typesMap.getTypeMeta(name).originalName;
+            requiredTypes.add(originalName);
+        });
+        return `export type ${name} = ${type}`;
+    })
+        .join('\n')}`;
+}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-functions.ts","../bin/pikku-http-map.ts","../bin/pikku-http-routes.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-rpc.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/openapi-spec-generator.ts","../src/pikku-cli-config.ts","../src/schema-generator.ts","../src/serialize-fetch-wrapper.ts","../src/serialize-import-map.ts","../src/serialize-nextjs-backend-wrapper.ts","../src/serialize-nextjs-http-wrapper.ts","../src/serialize-pikku-types.ts","../src/serialize-scheduler-meta.ts","../src/serialize-typed-channel-map.ts","../src/serialize-typed-function-map.ts","../src/serialize-typed-http-map.ts","../src/serialize-websocket-wrapper.ts","../src/utils.ts"],"version":"5.7.3"}
+{"root":["../bin/pikku-all.ts","../bin/pikku-channels-map.ts","../bin/pikku-channels.ts","../bin/pikku-fetch.ts","../bin/pikku-function-types.ts","../bin/pikku-functions.ts","../bin/pikku-http-map.ts","../bin/pikku-http-routes.ts","../bin/pikku-nextjs.ts","../bin/pikku-openapi.ts","../bin/pikku-rpc-map.ts","../bin/pikku-rpc.ts","../bin/pikku-scheduler.ts","../bin/pikku-schemas.ts","../bin/pikku-websocket.ts","../bin/pikku.ts","../src/inspector-glob.ts","../src/openapi-spec-generator.ts","../src/pikku-cli-config.ts","../src/schema-generator.ts","../src/serialize-fetch-wrapper.ts","../src/serialize-nextjs-backend-wrapper.ts","../src/serialize-nextjs-http-wrapper.ts","../src/serialize-pikku-types.ts","../src/serialize-scheduler-meta.ts","../src/serialize-typed-channel-map.ts","../src/serialize-typed-http-map.ts","../src/serialize-typed-rpc-map.ts","../src/serialize-websocket-wrapper.ts","../src/utils/serialize-import-map.ts","../src/utils/utils.ts"],"version":"5.7.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "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.5",
+    "@pikku/inspector": "^0.7.4",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/inspector-glob.ts

@@ -1,7 +1,7 @@
 import * as path from 'path'
 import { glob } from 'tinyglobby'
 import { InspectorFilters, InspectorState, inspect } from '@pikku/inspector'
-import { logCommandInfoAndTime } from './utils.js'
+import { logCommandInfoAndTime } from './utils/utils.js'
 
 export const inspectorGlob = async (
   rootDir: string,

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/pikku-cli-config.ts

@@ -4,20 +4,37 @@ import { OpenAPISpecInfo } from './openapi-spec-generator.js'
 import { InspectorFilters } from '@pikku/inspector'
 
 export interface PikkuCLICoreOutputFiles {
+  // Base directory
   outDir?: string
+
+  // Schema and types
+  schemaDirectory: string
+  typesDeclarationFile: string
+
+  // Function definitions
   functionsFile: string
   functionsMetaFile: string
+
+  // HTTP routes
   httpRoutesFile: string
   httpRoutesMetaFile: string
+  httpRoutesMapDeclarationFile: string
+
+  // Channels
   channelsFile: string
   channelsMetaFile: string
+  channelsMapDeclarationFile: string
+
+  // RPC
+  rpcFile: string
+  rpcMetaFile: string
+  rpcMapDeclarationFile: string
+
+  // Schedulers
   schedulersFile: string
   schedulersMetaFile: string
-  rpcFile: string
-  schemaDirectory: string
-  typesDeclarationFile: string
-  httpRoutesMapDeclarationFile: string
-  channelsMapDeclarationFile: string
+
+  // Application bootstrap
   bootstrapFile: string
 }
 
@@ -139,6 +156,15 @@ const _getPikkuCLIConfig = async (
       if (!result.rpcFile) {
         result.rpcFile = join(result.outDir, 'pikku-rpc.gen.ts')
       }
+      if (!result.rpcMetaFile) {
+        result.rpcMetaFile = join(result.outDir, 'pikku-rpc-meta.gen.ts')
+      }
+      if (!result.rpcMapDeclarationFile) {
+        result.rpcMapDeclarationFile = join(
+          result.outDir,
+          'pikku-rpc-map.gen.ts'
+        )
+      }
       if (!result.httpRoutesFile) {
         result.httpRoutesFile = join(result.outDir, 'pikku-http-routes.gen.ts')
       }

package/src/schema-generator.ts

@@ -1,45 +1,27 @@
 import { createGenerator, RootlessError } from 'ts-json-schema-generator'
-import { logInfo, writeFileInDir } from './utils.js'
+import { logInfo, writeFileInDir } from './utils/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-pikku-types.ts

@@ -7,7 +7,7 @@ export const serializePikkuTypes = (
   singletonServicesTypeImport: string,
   singletonServicesTypeName: string,
   sessionServicesTypeImport: string,
-  servicesTypeName: string
+  rpcMapTypeImport: string
 ) => {
   return `/**
 * This is used to provide the application types in the typescript project
@@ -22,6 +22,7 @@ import { CoreAPIChannel, PikkuChannel, addChannel as addCoreChannel } from '@pik
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
+${rpcMapTypeImport}
 
 export type APIPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CoreAPIPermission<In, RequiredServices, ${userSessionTypeName}>
 export type APIMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = PikkuMiddleware<RequiredServices, ${userSessionTypeName}>
@@ -30,7 +31,8 @@ type APIFunctionSessionless<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
-  RequiredServices extends Services = Services & (
+  RequiredServices extends Services = Services &
+    { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
       : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
@@ -41,7 +43,8 @@ type APIFunction<
   In = unknown, 
   Out = never, 
   ChannelData = null,  // null means optional channel
-  RequiredServices extends Services = Services & (
+  RequiredServices extends Services = Services &
+    { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null] 
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
       : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type

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

@@ -1,7 +1,7 @@
 import { ChannelsMeta } from '@pikku/core/channel'
-import { serializeImportMap } from './serialize-import-map.js'
+import { serializeImportMap } from './utils/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
-import { generateCustomTypes } from './serialize-typed-http-map.js'
+import { generateCustomTypes } from './utils/utils.js'
 
 export const serializeTypedChannelsMap = (
   relativeToPath: string,

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 { serializeImportMap } from './utils/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]) {

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

@@ -0,0 +1,105 @@
+import { serializeImportMap } from './utils/serialize-import-map.js'
+import { TypesMap } from '@pikku/inspector'
+import { FunctionsMeta } from '@pikku/core'
+import { generateCustomTypes } from './utils/utils.js'
+import { RPCMeta } from '../../core/src/rpc/rpc-types.js'
+
+export const serializeTypedRPCMap = (
+  relativeToPath: string,
+  packageMappings: Record<string, string>,
+  typesMap: TypesMap,
+  functionsMeta: FunctionsMeta,
+  rpcMeta: Record<string, RPCMeta>
+) => {
+  const requiredTypes = new Set<string>()
+  const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
+  const serializedRPCs = generateRPCs(
+    rpcMeta,
+    functionsMeta,
+    typesMap,
+    requiredTypes
+  )
+
+  const serializedImportMap = serializeImportMap(
+    relativeToPath,
+    packageMappings,
+    typesMap,
+    requiredTypes
+  )
+
+  return `/**
+ * This provides the structure needed for typescript to be aware of RPCs and their return types
+ */
+    
+${serializedImportMap}
+${serializedCustomTypes}
+
+interface RPCHandler<I, O> {
+    input: I;
+    output: O;
+}
+
+${serializedRPCs}
+
+type RPCInvoke = <Name extends keyof RPCMap>(
+  name: Name,
+  data: RPCMap[Name]['input'],
+  options?: {
+    location?: 'local' | 'remote' | 'auto'
+  }
+) => Promise<RPCMap[Name]['output']>
+
+export type TypedPikkuRPC = {
+  depth: number;
+  global: boolean;
+  invoke: RPCInvoke;
+}
+  `
+}
+
+function generateRPCs(
+  rpcMeta: Record<string, RPCMeta>,
+  functionsMeta: FunctionsMeta,
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  // Initialize an object to collect RPCs
+  const rpcsObj: Record<string, { inputType: string; outputType: string }> = {}
+
+  // Iterate through RPC metadata
+  for (const [funcName, { pikkuFuncName }] of Object.entries(rpcMeta)) {
+    const functionMeta = functionsMeta[pikkuFuncName]
+    if (!functionMeta) {
+      throw new Error(
+        `Function ${funcName} not found in functionsMeta. Please check your configuration.`
+      )
+    }
+
+    const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
+    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
+
+    // Store the input and output types for RPCHandler
+    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
+    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
+
+    requiredTypes.add(inputType)
+    requiredTypes.add(outputType)
+
+    // Add RPC entry
+    rpcsObj[funcName] = {
+      inputType,
+      outputType,
+    }
+  }
+
+  // Build the RPCs object as a string
+  let rpcsStr = 'export type RPCMap = {\n'
+
+  for (const [funcName, handler] of Object.entries(rpcsObj)) {
+    rpcsStr += `  readonly '${funcName}': RPCHandler<${handler.inputType}, ${handler.outputType}>,\n`
+  }
+
+  rpcsStr += '};\n'
+
+  return rpcsStr
+}