@pikku/cli 0.9.1 → 0.9.3

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

@@ -0,0 +1,97 @@
+import { getFileImportRelativePath } from '../../utils.js'
+import { FunctionsMeta, FunctionsRuntimeMeta } from '@pikku/core'
+
+export const serializeFunctionImports = (
+  outputPath: string,
+  functionsMap: Map<string, { path: string; exportedName: string }>,
+  functionsMeta: FunctionsMeta,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedImports: string[] = [
+    `/* Import and register functions used by RPCs */`,
+    `import { addFunction } from '@pikku/core'`,
+  ]
+
+  const serializedRegistrations: string[] = []
+
+  // Sort by function name for consistent output
+  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
+
+    // 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`
+        )
+      }
+    }
+    // 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`
+        )
+      }
+    }
+  }
+
+  // Add a blank line between imports and registrations
+  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+    serializedImports.push('')
+  }
+
+  // Combine the imports and registrations
+  return [...serializedImports, ...serializedRegistrations].join('\n')
+}
+
+export const generateRuntimeMeta = (
+  functions: FunctionsMeta
+): FunctionsRuntimeMeta => {
+  const runtimeMeta: FunctionsRuntimeMeta = {}
+
+  for (const [
+    key,
+    { pikkuFuncName, inputSchemaName, outputSchemaName, expose },
+  ] of Object.entries(functions)) {
+    runtimeMeta[key] = {
+      pikkuFuncName,
+      inputSchemaName,
+      outputSchemaName,
+      expose,
+    }
+  }
+
+  return runtimeMeta
+}

package/src/wirings/rpc/pikku-command-rpc-client.ts

@@ -8,14 +8,19 @@ import { PikkuCommandWithoutState } from '../../types.js'
 
 export const pikkuRPCClient: PikkuCommandWithoutState = async (
   logger,
-  { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }
+  {
+    rpcWiringsFile,
+    rpcMapDeclarationFile,
+    rpcInternalMapDeclarationFile,
+    packageMappings,
+  }
 ) => {
   return await logCommandInfoAndTime(
     logger,
-    'Generating RPC wrapper',
-    'Generated RPC wrapper',
+    'Generating RPC wrappers',
+    'Generated RPC wrappers',
     [
-      rpcWiringsFile === undefined,
+      rpcWiringsFile === undefined || rpcWiringsFile === null,
       "rpcWiringsFile isn't set in the pikku config",
     ],
     async () => {
@@ -28,7 +33,6 @@ export const pikkuRPCClient: PikkuCommandWithoutState = async (
         rpcMapDeclarationFile,
         packageMappings
       )
-
       const content = [serializeRPCWrapper(rpcMapDeclarationPath)]
       await writeFileInDir(logger, rpcWiringsFile, content.join('\n'))
     }

package/src/wirings/rpc/pikku-command-rpc-map.ts

@@ -2,15 +2,38 @@ import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
 import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js'
 import { PikkuCommand } from '../../types.js'
 
-export const pikkuRPCMap: PikkuCommand = async (
+export const pikkuRPCInternalMap: PikkuCommand = async (
+  logger,
+  { rpcInternalMapDeclarationFile, packageMappings },
+  { functions, rpc }
+) => {
+  return await logCommandInfoAndTime(
+    logger,
+    'Creating RPC internal map',
+    'Created RPC internal map',
+    [false],
+    async () => {
+      const content = serializeTypedRPCMap(
+        rpcInternalMapDeclarationFile,
+        packageMappings,
+        functions.typesMap,
+        functions.meta,
+        rpc.internalMeta
+      )
+      await writeFileInDir(logger, rpcInternalMapDeclarationFile, content)
+    }
+  )
+}
+
+export const pikkuRPCExposedMap: PikkuCommand = async (
   logger,
   { rpcMapDeclarationFile, packageMappings },
   { functions, rpc }
 ) => {
   return await logCommandInfoAndTime(
     logger,
-    'Creating RPC map',
-    'Created RPC map',
+    'Creating RPC external map',
+    'Created RPC external map',
     [false],
     async () => {
       const content = serializeTypedRPCMap(
@@ -18,7 +41,7 @@ export const pikkuRPCMap: PikkuCommand = async (
         packageMappings,
         functions.typesMap,
         functions.meta,
-        rpc.meta
+        rpc.exposedMeta
       )
       await writeFileInDir(logger, rpcMapDeclarationFile, content)
     }

package/src/wirings/rpc/pikku-command-rpc.ts

@@ -3,7 +3,7 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuRPC: PikkuCommand = async (
   logger,
-  { rpcWiringMetaFile },
+  { rpcInternalWiringMetaFile, rpcWiringMetaFile },
   { rpc }
 ) => {
   return await logCommandInfoAndTime(
@@ -12,11 +12,21 @@ export const pikkuRPC: PikkuCommand = async (
     'Found RPCs',
     [false],
     async () => {
-      await writeFileInDir(
-        logger,
-        rpcWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`
-      )
+      if (rpc.internalFiles.size > 0) {
+        await writeFileInDir(
+          logger,
+          rpcInternalWiringMetaFile,
+          `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`
+        )
+      }
+
+      if (rpc.exposedFiles.size > 0) {
+        await writeFileInDir(
+          logger,
+          rpcWiringMetaFile,
+          `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.exposedFiles, null, 2)})`
+        )
+      }
     }
   )
 }

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

@@ -1,5 +1,3 @@
-import type { RPCMeta } from '@pikku/core/rpc'
-
 import { serializeImportMap } from '../../serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
 import { FunctionsMeta } from '@pikku/core'
@@ -10,7 +8,7 @@ export const serializeTypedRPCMap = (
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  rpcMeta: Record<string, RPCMeta>
+  rpcMeta: Record<string, string>
 ) => {
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
@@ -54,12 +52,13 @@ export type TypedPikkuRPC = {
   depth: number;
   global: boolean;
   invoke: RPCInvoke;
+  invokeExposed: (name: string, data: any) => Promise<any> 
 }
   `
 }
 
 function generateRPCs(
-  rpcMeta: Record<string, RPCMeta>,
+  rpcMeta: Record<string, string>,
   functionsMeta: FunctionsMeta,
   typesMap: TypesMap,
   requiredTypes: Set<string>
@@ -68,7 +67,7 @@ function generateRPCs(
   const rpcsObj: Record<string, { inputType: string; outputType: string }> = {}
 
   // Iterate through RPC metadata
-  for (const [funcName, { pikkuFuncName }] of Object.entries(rpcMeta)) {
+  for (const [funcName, pikkuFuncName] of Object.entries(rpcMeta)) {
     const functionMeta = functionsMeta[pikkuFuncName]
     if (!functionMeta) {
       throw new Error(

package/dist/src/wirings/functions/pikku-functions.d.ts

@@ -1,6 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;
-export declare const pikkuFunctions: PikkuCommand;

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

@@ -1,35 +0,0 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
-    const serializedImports = [
-        `/* Import and register RPCs */`,
-        `import { addFunction } from '@pikku/core'`,
-    ];
-    const serializedRegistrations = [];
-    // Sort by function name for consistent output
-    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);
-        // For directly exported functions, we can just import and register them
-        if (name === exportedName) {
-            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-        }
-        // For renamed functions, we need to import and alias them
-        else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name})`);
-        }
-    }
-    // Add a blank line between imports and registrations
-    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-        serializedImports.push('');
-    }
-    // Combine the imports and registrations
-    return [...serializedImports, ...serializedRegistrations].join('\n');
-};
-export const pikkuFunctions = async (logger, { functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
-    return await logCommandInfoAndTime(logger, 'Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
-        await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
-    });
-};

package/dist/src/wirings/rpc/pikku-rpc.d.ts

@@ -1,2 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const pikkuRPC: PikkuCommand;

package/dist/src/wirings/rpc/pikku-rpc.js

@@ -1,6 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-export const pikkuRPC = async (logger, { rpcWiringMetaFile }, { rpc }) => {
-    return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
-        await writeFileInDir(logger, rpcWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
-    });
-};

package/src/wirings/functions/pikku-functions.ts

@@ -1,84 +0,0 @@
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-
-export const serializeFunctionImports = (
-  outputPath: string,
-  functionsMap: Map<string, { path: string; exportedName: string }>,
-  packageMappings: Record<string, string> = {}
-) => {
-  const serializedImports: string[] = [
-    `/* Import and register RPCs */`,
-    `import { addFunction } from '@pikku/core'`,
-  ]
-
-  const serializedRegistrations: string[] = []
-
-  // Sort by function name for consistent output
-  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
-    )
-
-    // For directly exported functions, we can just import and register them
-    if (name === exportedName) {
-      serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
-      serializedRegistrations.push(
-        `addFunction('${name}', { func: ${exportedName} })`
-      )
-    }
-    // For renamed functions, we need to import and alias them
-    else {
-      serializedImports.push(
-        `import { ${exportedName} as ${name} } from '${filePath}'`
-      )
-      serializedRegistrations.push(`addFunction('${name}', ${name})`)
-    }
-  }
-
-  // Add a blank line between imports and registrations
-  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-    serializedImports.push('')
-  }
-
-  // Combine the imports and registrations
-  return [...serializedImports, ...serializedRegistrations].join('\n')
-}
-
-export const pikkuFunctions: PikkuCommand = async (
-  logger,
-  { functionsMetaFile, functionsFile, packageMappings },
-  { functions }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Serializing Pikku functions',
-    'Serialized Pikku functions',
-    [false],
-    async () => {
-      await writeFileInDir(
-        logger,
-        functionsFile,
-        serializeFunctionImports(
-          functionsFile,
-          functions.files,
-          packageMappings
-        )
-      )
-      await writeFileInDir(
-        logger,
-        functionsMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`
-      )
-    }
-  )
-}

package/src/wirings/rpc/pikku-rpc.ts

@@ -1,22 +0,0 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js'
-import { PikkuCommand } from '../../types.js'
-
-export const pikkuRPC: PikkuCommand = async (
-  logger,
-  { rpcWiringMetaFile },
-  { rpc }
-) => {
-  return await logCommandInfoAndTime(
-    logger,
-    'Finding RPCs tasks',
-    'Found RPCs',
-    [false],
-    async () => {
-      await writeFileInDir(
-        logger,
-        rpcWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`
-      )
-    }
-  )
-}