@pikku/cli 0.7.4 → 0.7.6

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @pikku/cli
 
+## 0.7.6
+
+### Patch Changes
+
+- 8b4f52e: refactor: moving schemas in channels to functions
+- 1d70184: feat: adding multiple bootstrap files for different transports
+- 5c4f56f: fix: adding more options to schema generator to support complex types
+- a9427b8: fix: import bootstrap file to include all rpc/function code in nextjs wrapper
+- Updated dependencies [8b4f52e]
+- Updated dependencies [8b4f52e]
+- Updated dependencies [1d70184]
+  - @pikku/core@0.7.8
+  - @pikku/inspector@0.7.7
+
+## 0.7.5
+
+### Patch Changes
+
+- faa1369: refactor: moving function imports into pikku-fun.gen file
+- Updated dependencies [faa1369]
+  - @pikku/inspector@0.7.6
+
 ## 0.7.4
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -24,16 +24,39 @@ import chokidar from 'chokidar'
 import { pikkuFunctions } from './pikku-functions.js'
 import { pikkuRPC } from './pikku-rpc.js'
 import { pikkuRPCMap } from './pikku-rpc-map.js'
+import { PikkuEventTypes } from '@pikku/core'
 
 const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
-  const metaImports: string[] = []
-  const imports: string[] = []
-  const addImport = (from: string, type: 'meta' | 'events' | 'other') => {
+  const boostrapImports: Partial<
+    Record<PikkuEventTypes, { meta: string[]; events: string[] }>
+  > & { all: { meta: string[]; events: string[] } } = {
+    all: { meta: [], events: [] },
+  }
+
+  const addImport = (
+    from: string,
+    type: 'meta' | 'events' | 'other',
+    addTo?: PikkuEventTypes[]
+  ) => {
     const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`
     if (type === 'meta') {
-      metaImports.push(statement)
+      boostrapImports.all.meta.push(statement)
     } else {
-      imports.push(statement)
+      boostrapImports.all.events.push(statement)
+    }
+
+    for (const transport of Object.keys(PikkuEventTypes)) {
+      if (!addTo || addTo?.includes(transport as PikkuEventTypes)) {
+        boostrapImports[transport] = boostrapImports[transport] || {
+          meta: [],
+          events: [],
+        }
+        if (type === 'meta') {
+          boostrapImports[transport].meta.push(statement)
+        } else {
+          boostrapImports[transport].events.push(statement)
+        }
+      }
     }
   }
 
@@ -69,34 +92,33 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
 
   await pikkuRPC(cliConfig, visitState)
   await pikkuRPCMap(cliConfig, visitState)
-  addImport(cliConfig.rpcMetaFile, 'meta')
-  addImport(cliConfig.rpcFile, 'events')
+  addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc])
+
+  const schemas = await pikkuSchemas(cliConfig, visitState)
+  if (schemas) {
+    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other')
+  }
 
-  const routes = await pikkuHTTP(cliConfig, visitState)
-  if (routes) {
+  const http = await pikkuHTTP(cliConfig, visitState)
+  if (http) {
     await pikkuHTTPMap(cliConfig, visitState)
     await pikkuFetch(cliConfig)
-    addImport(cliConfig.httpRoutesMetaFile, 'meta')
-    addImport(cliConfig.httpRoutesFile, 'events')
+    addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http])
+    addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http])
   }
 
   const scheduled = await pikkuScheduler(cliConfig, visitState)
   if (scheduled) {
-    addImport(cliConfig.schedulersMetaFile, 'meta')
-    addImport(cliConfig.schedulersFile, 'events')
+    addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled])
+    addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled])
   }
 
   const channels = await pikkuChannels(cliConfig, visitState)
   if (channels) {
     await pikkuChannelsMap(cliConfig, visitState)
     await pikkuWebSocket(cliConfig)
-    addImport(cliConfig.channelsMetaFile, 'meta')
-    addImport(cliConfig.channelsFile, 'events')
-  }
-
-  const schemas = await pikkuSchemas(cliConfig, visitState)
-  if (schemas) {
-    addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other')
+    addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel])
+    addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel])
   }
 
   if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
@@ -113,10 +135,12 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
     await pikkuOpenAPI(cliConfig, visitState)
   }
 
-  await writeFileInDir(
-    cliConfig.bootstrapFile,
-    [...metaImports, ...imports].join('\n')
-  )
+  for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
+    await writeFileInDir(
+      type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type],
+      [...meta, ...events].join('\n')
+    )
+  }
 }
 
 const watch = (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {

package/bin/pikku-channels-map.ts

@@ -16,6 +16,7 @@ export const pikkuChannelsMap = async (
         channelsMapDeclarationFile,
         packageMappings,
         state.functions.typesMap,
+        state.functions.meta,
         state.channels.meta
       )
       await writeFileInDir(channelsMapDeclarationFile, content)

package/bin/pikku-functions.ts

@@ -1,9 +1,62 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../src/utils/utils.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 = async (
-  { functionsMetaFile }: PikkuCLIConfig,
+  { functionsMetaFile, functionsFile, packageMappings }: PikkuCLIConfig,
   { functions }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
@@ -11,6 +64,14 @@ export const pikkuFunctions = async (
     'Serialized Pikku functions',
     [false],
     async () => {
+      await writeFileInDir(
+        functionsFile,
+        serializeFunctionImports(
+          functionsFile,
+          functions.files,
+          packageMappings
+        )
+      )
       await writeFileInDir(
         functionsMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`

package/bin/pikku-nextjs.ts

@@ -17,11 +17,10 @@ export const pikkuNext = async (
   {
     nextBackendFile,
     nextHTTPFile,
-    httpRoutesFile,
     httpRoutesMapDeclarationFile,
-    schemaDirectory,
     packageMappings,
     fetchFile,
+    bootstrapFiles,
   }: PikkuCLIConfig,
   visitState: InspectorState,
   options: PikkuCLIOptions
@@ -67,9 +66,9 @@ export const pikkuNext = async (
         const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`
         const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`
 
-        const routesPath = getFileImportRelativePath(
+        const httpBootstrapPath = getFileImportRelativePath(
           nextBackendFile,
-          httpRoutesFile,
+          bootstrapFiles.http,
           packageMappings
         )
 
@@ -78,16 +77,10 @@ export const pikkuNext = async (
           httpRoutesMapDeclarationFile,
           packageMappings
         )
-        const schemasPath = getFileImportRelativePath(
-          nextBackendFile,
-          `${schemaDirectory}/register.gen.ts`,
-          packageMappings
-        )
 
         const content = serializeNextBackendWrapper(
-          routesPath,
+          httpBootstrapPath,
           routesMapDeclarationPath,
-          schemasPath,
           pikkuConfigImport,
           singletonServicesImport,
           sessionServicesImport
@@ -95,22 +88,22 @@ export const pikkuNext = async (
         await writeFileInDir(nextBackendFile, content)
       }
 
-      if (nextHTTPFile) {
-        const routesPath = getFileImportRelativePath(
+      if (nextHTTPFile && fetchFile) {
+        const routesMapDeclarationPath = getFileImportRelativePath(
           nextHTTPFile,
-          httpRoutesFile,
+          httpRoutesMapDeclarationFile,
           packageMappings
         )
 
-        const routesMapDeclarationPath = getFileImportRelativePath(
+        const fetchPath = getFileImportRelativePath(
           nextHTTPFile,
-          httpRoutesMapDeclarationFile,
+          fetchFile,
           packageMappings
         )
 
         const content = serializeNextHTTPWrapper(
-          routesPath,
-          routesMapDeclarationPath
+          routesMapDeclarationPath,
+          fetchPath
         )
         await writeFileInDir(nextHTTPFile, content)
       }

package/bin/pikku-rpc-map.ts

@@ -10,7 +10,7 @@ export const pikkuRPCMap = async (
   return await logCommandInfoAndTime(
     'Creating RPC map',
     'Created RPC map',
-    [rpc.files.size === 0],
+    [false],
     async () => {
       const content = serializeTypedRPCMap(
         rpcMapDeclarationFile,

package/bin/pikku-rpc.ts

@@ -1,73 +1,16 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-
-export const serializeRPCImports = (
-  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')
-}
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
 
 export const pikkuRPC = async (
-  { rpcFile, rpcMetaFile, packageMappings }: PikkuCLIConfig,
+  { rpcMetaFile }: PikkuCLIConfig,
   { rpc }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
     'Finding RPCs tasks',
     'Found RPCs',
-    [rpc.files.size === 0],
+    [false],
     async () => {
-      await writeFileInDir(
-        rpcFile,
-        serializeRPCImports(rpcFile, rpc.files, packageMappings)
-      )
       await writeFileInDir(
         rpcMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`

package/dist/bin/pikku-all.js

@@ -17,16 +17,32 @@ import chokidar from 'chokidar';
 import { pikkuFunctions } from './pikku-functions.js';
 import { pikkuRPC } from './pikku-rpc.js';
 import { pikkuRPCMap } from './pikku-rpc-map.js';
+import { PikkuEventTypes } from '@pikku/core';
 const runAll = async (cliConfig, options) => {
-    const metaImports = [];
-    const imports = [];
-    const addImport = (from, type) => {
+    const boostrapImports = {
+        all: { meta: [], events: [] },
+    };
+    const addImport = (from, type, addTo) => {
         const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`;
         if (type === 'meta') {
-            metaImports.push(statement);
+            boostrapImports.all.meta.push(statement);
         }
         else {
-            imports.push(statement);
+            boostrapImports.all.events.push(statement);
+        }
+        for (const transport of Object.keys(PikkuEventTypes)) {
+            if (!addTo || addTo?.includes(transport)) {
+                boostrapImports[transport] = boostrapImports[transport] || {
+                    meta: [],
+                    events: [],
+                };
+                if (type === 'meta') {
+                    boostrapImports[transport].meta.push(statement);
+                }
+                else {
+                    boostrapImports[transport].events.push(statement);
+                }
+            }
         }
     };
     let typesDeclarationFileExists = true;
@@ -49,30 +65,29 @@ const runAll = async (cliConfig, options) => {
     addImport(cliConfig.functionsFile, 'events');
     await pikkuRPC(cliConfig, visitState);
     await pikkuRPCMap(cliConfig, visitState);
-    addImport(cliConfig.rpcMetaFile, 'meta');
-    addImport(cliConfig.rpcFile, 'events');
-    const routes = await pikkuHTTP(cliConfig, visitState);
-    if (routes) {
+    addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc]);
+    const schemas = await pikkuSchemas(cliConfig, visitState);
+    if (schemas) {
+        addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other');
+    }
+    const http = await pikkuHTTP(cliConfig, visitState);
+    if (http) {
         await pikkuHTTPMap(cliConfig, visitState);
         await pikkuFetch(cliConfig);
-        addImport(cliConfig.httpRoutesMetaFile, 'meta');
-        addImport(cliConfig.httpRoutesFile, 'events');
+        addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http]);
+        addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http]);
     }
     const scheduled = await pikkuScheduler(cliConfig, visitState);
     if (scheduled) {
-        addImport(cliConfig.schedulersMetaFile, 'meta');
-        addImport(cliConfig.schedulersFile, 'events');
+        addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled]);
+        addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled]);
     }
     const channels = await pikkuChannels(cliConfig, visitState);
     if (channels) {
         await pikkuChannelsMap(cliConfig, visitState);
         await pikkuWebSocket(cliConfig);
-        addImport(cliConfig.channelsMetaFile, 'meta');
-        addImport(cliConfig.channelsFile, 'events');
-    }
-    const schemas = await pikkuSchemas(cliConfig, visitState);
-    if (schemas) {
-        addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other');
+        addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel]);
+        addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel]);
     }
     if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
         await pikkuNext(cliConfig, visitState, options);
@@ -82,7 +97,9 @@ const runAll = async (cliConfig, options) => {
         visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
         await pikkuOpenAPI(cliConfig, visitState);
     }
-    await writeFileInDir(cliConfig.bootstrapFile, [...metaImports, ...imports].join('\n'));
+    for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
+        await writeFileInDir(type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type], [...meta, ...events].join('\n'));
+    }
 };
 const watch = (cliConfig, options) => {
     const configWatcher = chokidar.watch(cliConfig.srcDirectories, {

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

@@ -2,7 +2,7 @@ import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
 import { serializeTypedChannelsMap } from '../src/serialize-typed-channel-map.js';
 export const pikkuChannelsMap = async ({ channelsMapDeclarationFile, packageMappings }, state) => {
     return await logCommandInfoAndTime('Creating channels map', 'Created channels map', [state.channels.files.size === 0], async () => {
-        const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.channels.meta);
+        const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.functions.meta, state.channels.meta);
         await writeFileInDir(channelsMapDeclarationFile, content);
     });
 };

package/dist/bin/pikku-functions.d.ts

@@ -1,3 +1,7 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuFunctions: ({ functionsMetaFile }: PikkuCLIConfig, { functions }: InspectorState) => Promise<boolean>;
+export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
+    path: string;
+    exportedName: string;
+}>, packageMappings?: Record<string, string>) => string;
+export declare const pikkuFunctions: ({ functionsMetaFile, functionsFile, packageMappings }: PikkuCLIConfig, { functions }: InspectorState) => Promise<boolean>;

package/dist/bin/pikku-functions.js

@@ -1,6 +1,35 @@
-import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
-export const pikkuFunctions = async ({ functionsMetaFile }, { functions }) => {
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../src/utils/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 ({ functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
     return await logCommandInfoAndTime('Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
+        await writeFileInDir(functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
         await writeFileInDir(functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
     });
 };

package/dist/bin/pikku-nextjs.d.ts

@@ -2,6 +2,6 @@ import { Command } from 'commander';
 import { PikkuCLIOptions } from '../src/utils/utils.js';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuNext: ({ nextBackendFile, nextHTTPFile, httpRoutesFile, httpRoutesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }: PikkuCLIConfig, visitState: InspectorState, options: PikkuCLIOptions) => Promise<boolean>;
+export declare const pikkuNext: ({ nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }: PikkuCLIConfig, visitState: InspectorState, options: PikkuCLIOptions) => Promise<boolean>;
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const nextjs: (program: Command) => void;

package/dist/bin/pikku-nextjs.js

@@ -3,7 +3,7 @@ import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/s
 import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, httpRoutesFile, httpRoutesMapDeclarationFile, schemaDirectory, packageMappings, fetchFile, }, visitState, options) => {
+export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options) => {
     return await logCommandInfoAndTime('Generating nextjs wrapper', 'Generated nextjs wrapper', [
         nextBackendFile === undefined && nextHTTPFile === undefined,
         'nextjs outfile is not defined',
@@ -23,16 +23,15 @@ export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, httpRoutesFile,
             const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
             const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
             const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
-            const routesPath = getFileImportRelativePath(nextBackendFile, httpRoutesFile, packageMappings);
+            const httpBootstrapPath = getFileImportRelativePath(nextBackendFile, bootstrapFiles.http, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpRoutesMapDeclarationFile, packageMappings);
-            const schemasPath = getFileImportRelativePath(nextBackendFile, `${schemaDirectory}/register.gen.ts`, packageMappings);
-            const content = serializeNextBackendWrapper(routesPath, routesMapDeclarationPath, schemasPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
+            const content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
             await writeFileInDir(nextBackendFile, content);
         }
-        if (nextHTTPFile) {
-            const routesPath = getFileImportRelativePath(nextHTTPFile, httpRoutesFile, packageMappings);
+        if (nextHTTPFile && fetchFile) {
             const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
-            const content = serializeNextHTTPWrapper(routesPath, routesMapDeclarationPath);
+            const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
             await writeFileInDir(nextHTTPFile, content);
         }
     });

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

@@ -1,7 +1,7 @@
 import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
 import { serializeTypedRPCMap } from '../src/serialize-typed-rpc-map.js';
 export const pikkuRPCMap = async ({ rpcMapDeclarationFile, packageMappings }, { functions, rpc }) => {
-    return await logCommandInfoAndTime('Creating RPC map', 'Created RPC map', [rpc.files.size === 0], async () => {
+    return await logCommandInfoAndTime('Creating RPC map', 'Created RPC map', [false], async () => {
         const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.meta);
         await writeFileInDir(rpcMapDeclarationFile, content);
     });

package/dist/bin/pikku-rpc.d.ts

@@ -1,7 +1,3 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const serializeRPCImports: (outputPath: string, functionsMap: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;
-export declare const pikkuRPC: ({ rpcFile, rpcMetaFile, packageMappings }: PikkuCLIConfig, { rpc }: InspectorState) => Promise<boolean>;
+export declare const pikkuRPC: ({ rpcMetaFile }: PikkuCLIConfig, { rpc }: InspectorState) => Promise<boolean>;

package/dist/bin/pikku-rpc.js

@@ -1,35 +1,6 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../src/utils/utils.js';
-export const serializeRPCImports = (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 pikkuRPC = async ({ rpcFile, rpcMetaFile, packageMappings }, { rpc }) => {
-    return await logCommandInfoAndTime('Finding RPCs tasks', 'Found RPCs', [rpc.files.size === 0], async () => {
-        await writeFileInDir(rpcFile, serializeRPCImports(rpcFile, rpc.files, packageMappings));
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
+export const pikkuRPC = async ({ rpcMetaFile }, { rpc }) => {
+    return await logCommandInfoAndTime('Finding RPCs tasks', 'Found RPCs', [false], async () => {
         await writeFileInDir(rpcMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`);
     });
 };

package/dist/src/pikku-cli-config.d.ts

@@ -1,5 +1,6 @@
 import { OpenAPISpecInfo } from './openapi-spec-generator.js';
 import { InspectorFilters } from '@pikku/inspector';
+import { PikkuEventTypes } from '@pikku/core';
 export interface PikkuCLICoreOutputFiles {
     outDir?: string;
     schemaDirectory: string;
@@ -12,12 +13,12 @@ export interface PikkuCLICoreOutputFiles {
     channelsFile: string;
     channelsMetaFile: string;
     channelsMapDeclarationFile: string;
-    rpcFile: string;
     rpcMetaFile: string;
     rpcMapDeclarationFile: string;
     schedulersFile: string;
     schedulersMetaFile: string;
     bootstrapFile: string;
+    bootstrapFiles: Record<PikkuEventTypes, string>;
 }
 export type PikkuCLIConfig = {
     $schema?: string;

package/dist/src/pikku-cli-config.js

@@ -1,5 +1,6 @@
 import { join, dirname, resolve, isAbsolute } from 'path';
 import { readdir, readFile } from 'fs/promises';
+import { PikkuEventTypes } from '@pikku/core';
 const CONFIG_DIR_FILES = [
     'nextBackendFile',
     'nextHTTPFile',
@@ -62,9 +63,6 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.functionsMetaFile) {
                 result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
             }
-            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');
             }
@@ -101,6 +99,10 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.bootstrapFile) {
                 result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
             }
+            result.bootstrapFiles = result.bootstrapFiles || {};
+            for (const key of Object.keys(PikkuEventTypes)) {
+                result.bootstrapFiles[key] = join(result.outDir, `pikku-bootstrap-${key}.gen.ts`);
+            }
         }
         if (requiredFields.length > 0) {
             validateCLIConfig(result, requiredFields);

package/dist/src/schema-generator.js

@@ -28,6 +28,12 @@ export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRout
         skipTypeCheck: true,
         topRef: false,
         discriminatorType: 'open-api',
+        expose: 'export',
+        jsDoc: 'extended',
+        sortProps: true,
+        strictTuples: false,
+        encodeRefs: false,
+        additionalProperties: false,
     });
     const schemas = {};
     schemasSet.forEach((schema) => {

package/dist/src/serialize-nextjs-backend-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsBackendWrapper: (routesPath: string, routesMapPath: string, schemasPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;
+export declare const serializeNextJsBackendWrapper: (httpBootstrapPath: string, routesMapPath: string, configImport: string, singleServicesFactoryImport: string, sessionServicesImport: string) => string;

package/dist/src/serialize-nextjs-backend-wrapper.js

@@ -1,4 +1,4 @@
-export const serializeNextJsBackendWrapper = (routesPath, routesMapPath, schemasPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
+export const serializeNextJsBackendWrapper = (httpBootstrapPath, routesMapPath, configImport, singleServicesFactoryImport, sessionServicesImport) => {
     return `'server-only'
   
 /**
@@ -12,8 +12,7 @@ ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
 
-import '${routesPath}'
-import '${schemasPath}'
+import '${httpBootstrapPath}'
 
 let _pikku: PikkuNextJS | undefined
 

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

@@ -1,3 +1,4 @@
 import { ChannelsMeta } from '@pikku/core/channel';
 import { TypesMap } from '@pikku/inspector';
-export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, channelsMeta: ChannelsMeta) => string;
+import { FunctionsMeta } from '@pikku/core';
+export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, channelsMeta: ChannelsMeta) => string;

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

@@ -1,7 +1,7 @@
 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);
+export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
+    const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {
         for (const reference of references) {
             requiredTypes.add(reference);
@@ -38,21 +38,39 @@ export type ChannelRouteHandlerOf<
         : never;
 `;
 };
-function generateChannels(channelsMeta) {
+function generateChannels(functionsMeta, channelsMeta) {
     const requiredTypes = new Set();
     const channelsObject = {};
     for (const meta of Object.values(channelsMeta)) {
         const { name, messageRoutes, message } = meta;
         if (!channelsObject[name]) {
-            channelsObject[name] = { message, routes: {} };
+            channelsObject[name] = { message: null, routes: {} };
+        }
+        if (message) {
+            const func = functionsMeta[message.pikkuFuncName];
+            if (!func) {
+                throw new Error(`Function ${message.pikkuFuncName} not found in functionsMeta for channel ${name}`);
+            }
+            const inputTypes = func.inputs || null;
+            const outputTypes = func.outputs || null;
+            channelsObject[name].message = {
+                inputs: inputTypes,
+                outputs: outputTypes,
+            };
+            inputTypes?.forEach((type) => requiredTypes.add(type));
+            outputTypes?.forEach((type) => requiredTypes.add(type));
         }
         for (const [key, route] of Object.entries(messageRoutes)) {
             if (!channelsObject[name].routes[key]) {
                 channelsObject[name].routes[key] = {};
             }
-            for (const [method, { inputs, outputs }] of Object.entries(route)) {
-                const inputTypes = inputs || null;
-                const outputTypes = outputs || null;
+            for (const [method, { pikkuFuncName }] of Object.entries(route)) {
+                const func = functionsMeta[pikkuFuncName];
+                if (!func) {
+                    throw new Error(`Function ${pikkuFuncName} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
+                }
+                const inputTypes = func.inputs || null;
+                const outputTypes = func.outputs || null;
                 channelsObject[name].routes[key][method] = {
                     inputTypes,
                     outputTypes,

package/package.json

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

package/src/pikku-cli-config.ts

@@ -2,6 +2,7 @@ import { join, dirname, resolve, isAbsolute } from 'path'
 import { readdir, readFile } from 'fs/promises'
 import { OpenAPISpecInfo } from './openapi-spec-generator.js'
 import { InspectorFilters } from '@pikku/inspector'
+import { PikkuEventTypes } from '@pikku/core'
 
 export interface PikkuCLICoreOutputFiles {
   // Base directory
@@ -26,7 +27,6 @@ export interface PikkuCLICoreOutputFiles {
   channelsMapDeclarationFile: string
 
   // RPC
-  rpcFile: string
   rpcMetaFile: string
   rpcMapDeclarationFile: string
 
@@ -36,6 +36,7 @@ export interface PikkuCLICoreOutputFiles {
 
   // Application bootstrap
   bootstrapFile: string
+  bootstrapFiles: Record<PikkuEventTypes, string>
 }
 
 export type PikkuCLIConfig = {
@@ -153,9 +154,6 @@ const _getPikkuCLIConfig = async (
           'pikku-functions-meta.gen.ts'
         )
       }
-      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')
       }
@@ -210,6 +208,14 @@ const _getPikkuCLIConfig = async (
       if (!result.bootstrapFile) {
         result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts')
       }
+
+      result.bootstrapFiles = result.bootstrapFiles || {}
+      for (const key of Object.keys(PikkuEventTypes)) {
+        result.bootstrapFiles[key] = join(
+          result.outDir,
+          `pikku-bootstrap-${key}.gen.ts`
+        )
+      }
     }
 
     if (requiredFields.length > 0) {

package/src/schema-generator.ts

@@ -38,6 +38,12 @@ export async function generateSchemas(
     skipTypeCheck: true,
     topRef: false,
     discriminatorType: 'open-api',
+    expose: 'export',
+    jsDoc: 'extended',
+    sortProps: true,
+    strictTuples: false,
+    encodeRefs: false,
+    additionalProperties: false,
   })
   const schemas: Record<string, JSONValue> = {}
   schemasSet.forEach((schema) => {

package/src/serialize-nextjs-backend-wrapper.ts

@@ -1,7 +1,6 @@
 export const serializeNextJsBackendWrapper = (
-  routesPath: string,
+  httpBootstrapPath: string,
   routesMapPath: string,
-  schemasPath: string,
   configImport: string,
   singleServicesFactoryImport: string,
   sessionServicesImport: string
@@ -19,8 +18,7 @@ ${configImport}
 ${singleServicesFactoryImport}
 ${sessionServicesImport}
 
-import '${routesPath}'
-import '${schemasPath}'
+import '${httpBootstrapPath}'
 
 let _pikku: PikkuNextJS | undefined
 

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

@@ -2,14 +2,19 @@ import { ChannelsMeta } from '@pikku/core/channel'
 import { serializeImportMap } from './utils/serialize-import-map.js'
 import { TypesMap } from '@pikku/inspector'
 import { generateCustomTypes } from './utils/utils.js'
+import { FunctionsMeta } from '@pikku/core'
 
 export const serializeTypedChannelsMap = (
   relativeToPath: string,
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
+  functionsMeta: FunctionsMeta,
   channelsMeta: ChannelsMeta
 ): string => {
-  const { channels, requiredTypes } = generateChannels(channelsMeta)
+  const { channels, requiredTypes } = generateChannels(
+    functionsMeta,
+    channelsMeta
+  )
   typesMap.customTypes.forEach(({ references }) => {
     for (const reference of references) {
       requiredTypes.add(reference)
@@ -52,7 +57,10 @@ export type ChannelRouteHandlerOf<
 `
 }
 
-function generateChannels(channelsMeta: ChannelsMeta) {
+function generateChannels(
+  functionsMeta: FunctionsMeta,
+  channelsMeta: ChannelsMeta
+) {
   const requiredTypes = new Set<string>()
   const channelsObject: Record<
     string,
@@ -75,16 +83,39 @@ function generateChannels(channelsMeta: ChannelsMeta) {
     const { name, messageRoutes, message } = meta
 
     if (!channelsObject[name]) {
-      channelsObject[name] = { message, routes: {} }
+      channelsObject[name] = { message: null, routes: {} }
+    }
+
+    if (message) {
+      const func = functionsMeta[message.pikkuFuncName]
+      if (!func) {
+        throw new Error(
+          `Function ${message.pikkuFuncName} not found in functionsMeta for channel ${name}`
+        )
+      }
+      const inputTypes = func.inputs || null
+      const outputTypes = func.outputs || null
+      channelsObject[name].message = {
+        inputs: inputTypes,
+        outputs: outputTypes,
+      }
+      inputTypes?.forEach((type) => requiredTypes.add(type))
+      outputTypes?.forEach((type) => requiredTypes.add(type))
     }
 
     for (const [key, route] of Object.entries(messageRoutes)) {
       if (!channelsObject[name].routes[key]) {
         channelsObject[name].routes[key] = {}
       }
-      for (const [method, { inputs, outputs }] of Object.entries(route)) {
-        const inputTypes = inputs || null
-        const outputTypes = outputs || null
+      for (const [method, { pikkuFuncName }] of Object.entries(route)) {
+        const func = functionsMeta[pikkuFuncName]
+        if (!func) {
+          throw new Error(
+            `Function ${pikkuFuncName} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`
+          )
+        }
+        const inputTypes = func.inputs || null
+        const outputTypes = func.outputs || null
         channelsObject[name].routes[key][method] = {
           inputTypes,
           outputTypes,