@pikku/cli 0.7.2 → 0.7.4

package/package.json

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

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/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,5 +1,5 @@
 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 { FunctionsMeta, JSONValue } from '@pikku/core'
 import { HTTPRoutesMeta } from '@pikku/core/http'

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,5 +1,5 @@
 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'
 

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
+}

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

@@ -1,5 +1,5 @@
 import { relative, dirname } from 'path'
-import { PathToNameAndType, InspectorState } from '@pikku/inspector'
+import { PathToNameAndType, InspectorState, TypesMap } from '@pikku/inspector'
 import { mkdir, writeFile } from 'fs/promises'
 import chalk from 'chalk'
 import { fileURLToPath } from 'url'
@@ -248,7 +248,7 @@ export const logPikkuLogo = () => {
   logPrimary(logo)
 
   const packageJson = JSON.parse(
-    readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8')
+    readFileSync(`${dirname(__filename)}/../../../package.json`, 'utf-8')
   )
   logPrimary(`⚙️ Welcome to the Pikku CLI (v${packageJson.version})\n`)
 }
@@ -282,3 +282,21 @@ export const serializeFileImports = (
 
   return serializedOutput.join('\n')
 }
+
+export function generateCustomTypes(
+  typesMap: TypesMap,
+  requiredTypes: Set<string>
+) {
+  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/src/serialize-typed-function-map.d.ts

@@ -1,5 +0,0 @@
-import { HTTPRoutesMeta } from '@pikku/core/http';
-import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-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,109 +0,0 @@
-import { serializeImportMap } from './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(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
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-${serializedMetaTypes}
-
-interface RouteHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedRoutes}
-
-export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
-    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
-        ? RouteHandler<I, O>
-        : never;
-
-export type RoutesWithMethod<Method extends string> = {
-  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
-}[keyof RoutesMap];
-  `;
-};
-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')}`;
-}
-function generateRoutes(functionsMeta, routesMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect routes
-    const routesObj = {};
-    for (const meta of routesMeta) {
-        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] = {};
-        }
-        // Store the input and output types separately for RouteHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add method entry
-        routesObj[route][method] = {
-            inputType,
-            outputType,
-        };
-    }
-    // Build the routes object as a string
-    let routesStr = 'export type RoutesMap = {\n';
-    for (const [routePath, methods] of Object.entries(routesObj)) {
-        routesStr += `  readonly '${routePath}': {\n`;
-        for (const [method, handler] of Object.entries(methods)) {
-            routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`;
-        }
-        routesStr += '  },\n';
-    }
-    routesStr += '};';
-    return routesStr;
-}
-const generateMetaTypes = (metaTypes, typesMap) => {
-    const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
-        const { uniqueName } = typesMap.getTypeMeta(_name);
-        const queryType = query && query.length > 0
-            ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
-            : undefined;
-        if (queryType) {
-            result.set(`${uniqueName}Query`, queryType);
-        }
-        const paramsType = params && params.length > 0
-            ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
-            : undefined;
-        if (paramsType) {
-            result.set(`${uniqueName}Params`, paramsType);
-        }
-        const bodyType = (body && body.length > 0) || (params && params.length > 0)
-            ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
-            : uniqueName;
-        if (bodyType) {
-            result.set(`${uniqueName}Body`, bodyType);
-        }
-        return result;
-    }, new Map());
-    return `
-// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
-${Array.from(nameToTypeMap.entries())
-        .map(([name, type]) => `export type ${name} = ${type} & {}`)
-        .join('\n')}`;
-};

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

@@ -1,161 +0,0 @@
-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(
-    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
- */
-    
-${serializedImportMap}
-${serializedCustomTypes}
-${serializedMetaTypes}
-
-interface RouteHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${serializedRoutes}
-
-export type RouteHandlerOf<Route extends keyof RoutesMap, Method extends keyof RoutesMap[Route]> =
-    RoutesMap[Route][Method] extends { input: infer I; output: infer O }
-        ? RouteHandler<I, O>
-        : never;
-
-export type RoutesWithMethod<Method extends string> = {
-  [Route in keyof RoutesMap]: Method extends keyof RoutesMap[Route] ? Route : never;
-}[keyof RoutesMap];
-  `
-}
-
-export function generateCustomTypes(
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  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')}`
-}
-
-function generateRoutes(
-  functionsMeta: FunctionsMeta,
-  routesMeta: HTTPRoutesMeta,
-  typesMap: TypesMap,
-  requiredTypes: Set<string>
-) {
-  // Initialize an object to collect routes
-  const routesObj: Record<
-    string,
-    Record<string, { inputType: string; outputType: string }>
-  > = {}
-
-  for (const meta of routesMeta) {
-    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] = {}
-    }
-
-    // Store the input and output types separately for RouteHandler
-    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
-    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
-
-    requiredTypes.add(inputType)
-    requiredTypes.add(outputType)
-
-    // Add method entry
-    routesObj[route][method] = {
-      inputType,
-      outputType,
-    }
-  }
-
-  // Build the routes object as a string
-  let routesStr = 'export type RoutesMap = {\n'
-
-  for (const [routePath, methods] of Object.entries(routesObj)) {
-    routesStr += `  readonly '${routePath}': {\n`
-    for (const [method, handler] of Object.entries(methods)) {
-      routesStr += `    readonly ${method.toUpperCase()}: RouteHandler<${handler.inputType}, ${handler.outputType}>,\n`
-    }
-    routesStr += '  },\n'
-  }
-
-  routesStr += '};'
-
-  return routesStr
-}
-
-const generateMetaTypes = (metaTypes: MetaInputTypes, typesMap: TypesMap) => {
-  const nameToTypeMap = Array.from(metaTypes.entries()).reduce<
-    Map<string, string>
-  >((result, [_name, { query, body, params }]) => {
-    const { uniqueName } = typesMap.getTypeMeta(_name)
-    const queryType =
-      query && query.length > 0
-        ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
-        : undefined
-    if (queryType) {
-      result.set(`${uniqueName}Query`, queryType)
-    }
-    const paramsType =
-      params && params.length > 0
-        ? `Pick<${uniqueName}, '${params.join("' | '")}'>`
-        : undefined
-    if (paramsType) {
-      result.set(`${uniqueName}Params`, paramsType)
-    }
-    const bodyType =
-      (body && body.length > 0) || (params && params.length > 0)
-        ? `Omit<${uniqueName}, '${[...new Set([...(query || []), ...(params || [])])].join("' | '")}'>`
-        : uniqueName!
-    if (bodyType) {
-      result.set(`${uniqueName}Body`, bodyType)
-    }
-    return result
-  }, new Map())
-
-  return `
-// The '& {}' is a workaround for not directly refering to a type since it confuses typescript
-${Array.from(nameToTypeMap.entries())
-  .map(([name, type]) => `export type ${name} = ${type} & {}`)
-  .join('\n')}`
-}