@pikku/cli 0.7.2 → 0.7.3

package/dist/bin/pikku-channels.js

@@ -1,6 +1,4 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../src/utils/utils.js';
 export const pikkuChannels = async (cliConfig, visitState) => {
     return await logCommandInfoAndTime('Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
         const { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
@@ -9,16 +7,3 @@ export const pikkuChannels = async (cliConfig, visitState) => {
         await writeFileInDir(channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuChannels(cliConfig, visitState);
-}
-export const channels = (program) => {
-    program
-        .command('channels')
-        .description('Find all channels to import')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

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

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { PikkuCLIOptions } from '../src/utils/utils.js';
 export declare const pikkuFetch: ({ fetchFile, httpRoutesMapDeclarationFile, packageMappings, }: PikkuCLIConfig) => Promise<void>;
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const fetch: (program: Command) => void;

package/dist/bin/pikku-fetch.js

@@ -1,6 +1,6 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { serializeFetchWrapper } from '../src/serialize-fetch-wrapper.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils/utils.js';
 export const pikkuFetch = async ({ fetchFile, httpRoutesMapDeclarationFile, packageMappings, }) => {
     await logCommandInfoAndTime('Generating fetch wrapper', 'Generated fetch wrapper', [fetchFile === undefined, "fetchFile isn't set in the pikku config"], async () => {
         if (!fetchFile) {

package/dist/bin/pikku-function-types.d.ts

@@ -1,6 +1,4 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-import { PikkuCLIOptions } from '../src/utils.js';
-export declare const pikkuFunctionTypes: ({ typesDeclarationFile: typesFile, packageMappings }: PikkuCLIConfig, options: PikkuCLIOptions, visitState: InspectorState) => Promise<void>;
-export declare const functionTypes: (program: Command) => void;
+import { PikkuCLIOptions } from '../src/utils/utils.js';
+export declare const pikkuFunctionTypes: ({ typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile, }: PikkuCLIConfig, options: PikkuCLIOptions, visitState: InspectorState) => Promise<void>;

package/dist/bin/pikku-function-types.js

@@ -1,32 +1,13 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
-import { pikkuHTTP } from './pikku-http-routes.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../src/utils/utils.js';
 import { serializePikkuTypes } from '../src/serialize-pikku-types.js';
-export const pikkuFunctionTypes = async ({ typesDeclarationFile: typesFile, packageMappings }, options, visitState) => {
+export const pikkuFunctionTypes = async ({ typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile, }, options, visitState) => {
     await logCommandInfoAndTime('Creating api types', 'Created api types', [false], async () => {
         const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(visitState, packageMappings, typesFile, options, {
             userSessionType: true,
             sessionServiceType: true,
             singletonServicesType: true,
         });
-        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type);
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
         await writeFileInDir(typesFile, content);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'typesDeclarationFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuHTTP(cliConfig, visitState);
-}
-export const functionTypes = (program) => {
-    program
-        .command('types')
-        .description('Generate the core API')
-        .option('-ct | --pikku-config-type', 'The type of your pikku config object')
-        .option('-ss | --singleton-services-factory-type', 'The type of your singleton services factory')
-        .option('-se | --session-services-factory-type', 'The type of your session services factory')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-functions.js

@@ -1,9 +1,8 @@
-import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../src/utils.js';
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
 export const pikkuFunctions = async (cliConfig, visitState) => {
-    return await logCommandInfoAndTime('Finding Pikku functions', 'Found Pikku functions', [visitState.functions.files.size === 0], async () => {
-        const { functionsFile, functionsMetaFile, packageMappings } = cliConfig;
+    return await logCommandInfoAndTime('Finding Pikku functions', 'Found Pikku functions', [true], async () => {
+        const { functionsMetaFile } = cliConfig;
         const { functions } = visitState;
-        await writeFileInDir(functionsFile, serializeFileImports('addFunction', 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-http-map.d.ts

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
 export declare const pikkuHTTPMap: ({ httpRoutesMapDeclarationFile, packageMappings }: PikkuCLIConfig, { http, functions }: InspectorState) => Promise<boolean>;
-export declare const routesMap: (program: Command) => void;

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

@@ -1,23 +1,8 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
 import { serializeTypedRoutesMap } from '../src/serialize-typed-http-map.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuHTTPMap = async ({ httpRoutesMapDeclarationFile, packageMappings }, { http, functions }) => {
     return await logCommandInfoAndTime('Creating HTTP map', 'Created HTTP map', [http.files.size === 0], async () => {
         const content = serializeTypedRoutesMap(httpRoutesMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, http.meta, http.metaInputTypes);
         await writeFileInDir(httpRoutesMapDeclarationFile, content);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuHTTPMap(cliConfig, visitState);
-}
-export const routesMap = (program) => {
-    program
-        .command('map')
-        .description('Generate a map of all routes to aid in type checking')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-http-routes.d.ts

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
 export declare const pikkuHTTP: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
-export declare const routes: (program: Command) => void;

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

@@ -1,6 +1,4 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../src/utils/utils.js';
 export const pikkuHTTP = async (cliConfig, visitState) => {
     return await logCommandInfoAndTime('Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
         const { httpRoutesFile, httpRoutesMetaFile, packageMappings } = cliConfig;
@@ -9,16 +7,3 @@ export const pikkuHTTP = async (cliConfig, visitState) => {
         await writeFileInDir(httpRoutesMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuHTTP(cliConfig, visitState);
-}
-export const routes = (program) => {
-    program
-        .command('routes')
-        .description('Find all routes to import')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

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

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
+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>;

package/dist/bin/pikku-nextjs.js

@@ -1,6 +1,6 @@
 import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from '../src/serialize-nextjs-backend-wrapper.js';
 import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from '../src/serialize-nextjs-http-wrapper.js';
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+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) => {

package/dist/bin/pikku-openapi.js

@@ -1,4 +1,4 @@
-import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils/utils.js';
 import { generateSchemas } from '../src/schema-generator.js';
 import { generateOpenAPISpec } from '../src/openapi-spec-generator.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';

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

@@ -0,0 +1,3 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
+import { InspectorState } from '@pikku/inspector';
+export declare const pikkuRPCMap: ({ rpcMapDeclarationFile, packageMappings }: PikkuCLIConfig, { functions, rpc }: InspectorState) => Promise<boolean>;

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

@@ -0,0 +1,8 @@
+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 () => {
+        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.meta);
+        await writeFileInDir(rpcMapDeclarationFile, content);
+    });
+};

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

@@ -1,3 +1,7 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuRPC: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
+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>;

package/dist/bin/pikku-rpc.js

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

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

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
 export declare const pikkuScheduler: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
-export declare const schedules: (program: Command) => void;

package/dist/bin/pikku-scheduler.js

@@ -1,7 +1,5 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../src/utils/utils.js';
 import { serializeSchedulerMeta } from '../src/serialize-scheduler-meta.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuScheduler = async (cliConfig, visitState) => {
     return await logCommandInfoAndTime('Finding scheduled tasks', 'Found scheduled tasks', [visitState.scheduledTasks.files.size === 0], async () => {
         const { schedulersFile, schedulersMetaFile, packageMappings } = cliConfig;
@@ -10,16 +8,3 @@ export const pikkuScheduler = async (cliConfig, visitState) => {
         await writeFileInDir(schedulersFile, serializeFileImports('addSerializedTasks', schedulersFile, scheduledTasks.files, packageMappings));
     });
 };
-async function action(options) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], options.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuScheduler(cliConfig, visitState);
-}
-export const schedules = (program) => {
-    program
-        .command('scheduler')
-        .description('Find all scheduled tasks to import')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

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

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
-export declare const pikkuSchemas: ({ tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig, { functions, http, channels }: InspectorState) => Promise<boolean>;
+export declare const pikkuSchemas: ({ tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig, { functions, http }: InspectorState) => Promise<boolean>;
 export declare const schemas: (program: Command) => void;

package/dist/bin/pikku-schemas.js

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

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

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
+import { PikkuCLIOptions } from '../src/utils/utils.js';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 export declare const pikkuWebSocket: ({ websocketFile, channelsMapDeclarationFile, packageMappings, }: PikkuCLIConfig) => Promise<void>;
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;

package/dist/bin/pikku-websocket.js

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { serializeWebsocketWrapper } from '../src/serialize-websocket-wrapper.js';
 export const pikkuWebSocket = async ({ websocketFile, channelsMapDeclarationFile, packageMappings, }) => {

package/dist/bin/pikku.js

@@ -1,23 +1,13 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { schemas } from './pikku-schemas.js';
-import { routes } from './pikku-http-routes.js';
 import { nextjs } from './pikku-nextjs.js';
 import { all } from './pikku-all.js';
-import { functionTypes } from './pikku-function-types.js';
-import { routesMap } from './pikku-http-map.js';
 import { fetch } from './pikku-fetch.js';
-import { channels } from './pikku-channels.js';
-import { schedules } from './pikku-scheduler.js';
 const program = new Command('pikku');
 program.usage('[command]');
 all(program);
-routes(program);
-routesMap(program);
-functionTypes(program);
 schemas(program);
 nextjs(program);
 fetch(program);
-channels(program);
-schedules(program);
 program.parse(process.argv);

package/dist/src/inspector-glob.js

@@ -1,7 +1,7 @@
 import * as path from 'path';
 import { glob } from 'tinyglobby';
 import { inspect } from '@pikku/inspector';
-import { logCommandInfoAndTime } from './utils.js';
+import { logCommandInfoAndTime } from './utils/utils.js';
 export const inspectorGlob = async (rootDir, srcDirectories, filters) => {
     let result;
     await logCommandInfoAndTime('Inspecting codebase', 'Inspected codebase', [false], async () => {

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

@@ -2,19 +2,21 @@ import { OpenAPISpecInfo } from './openapi-spec-generator.js';
 import { InspectorFilters } from '@pikku/inspector';
 export interface PikkuCLICoreOutputFiles {
     outDir?: string;
+    schemaDirectory: string;
+    typesDeclarationFile: string;
     functionsFile: string;
     functionsMetaFile: string;
     httpRoutesFile: string;
     httpRoutesMetaFile: string;
+    httpRoutesMapDeclarationFile: string;
     channelsFile: string;
     channelsMetaFile: string;
+    channelsMapDeclarationFile: string;
+    rpcFile: string;
+    rpcMetaFile: string;
+    rpcMapDeclarationFile: string;
     schedulersFile: string;
     schedulersMetaFile: string;
-    rpcFile: string;
-    schemaDirectory: string;
-    typesDeclarationFile: string;
-    httpRoutesMapDeclarationFile: string;
-    channelsMapDeclarationFile: string;
     bootstrapFile: string;
 }
 export type PikkuCLIConfig = {

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

@@ -65,6 +65,12 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             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/dist/src/schema-generator.js

@@ -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';
 export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRoutesMeta) {
     const schemasSet = new Set(typesMap.customTypes.keys());

package/dist/src/serialize-pikku-types.d.ts

@@ -1,4 +1,4 @@
 /**
  *
  */
-export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, servicesTypeName: string) => string;
+export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, rpcMapTypeImport: string) => string;

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.js

@@ -1,4 +1,4 @@
-import { serializeImportMap } from './serialize-import-map.js';
+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);

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