@pikku/cli 0.7.1 → 0.7.3

package/dist/bin/pikku-channels-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 { serializeTypedChannelsMap } from '../src/serialize-typed-channel-map.js';
-import { inspectorGlob } from '../src/inspector-glob.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);
         await writeFileInDir(channelsMapDeclarationFile, content);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags, false);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuChannelsMap(cliConfig, visitState);
-}
-export const channelsMap = (program) => {
-    program
-        .command('channels-map')
-        .description('Generate a map of all channels to aid in type checking')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-channels.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 pikkuChannels: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
-export declare const channels: (program: Command) => void;

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, http.meta, http.metaInputTypes);
+        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';
@@ -9,8 +9,8 @@ export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http, functions }) =
         if (!openAPI?.outputFile) {
             throw new Error('openAPI is required');
         }
-        const schemas = await generateSchemas(tsconfig, [http.typesMap, functions.typesMap], http.meta);
-        const openAPISpec = await generateOpenAPISpec(http.meta, schemas, openAPI.additionalInfo);
+        const schemas = await generateSchemas(tsconfig, functions.typesMap, functions.meta, http.meta);
+        const openAPISpec = await generateOpenAPISpec(functions.meta, http.meta, schemas, openAPI.additionalInfo);
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), true);
         }

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,11 +1,11 @@
 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, http.typesMap, channels.typesMap], http.meta);
-        await saveSchemas(schemaDirectory, schemas, functions.typesMap, http.meta, supportsImportAttributes);
+        const schemas = await generateSchemas(tsconfig, functions.typesMap, functions.meta, http.meta);
+        await saveSchemas(schemaDirectory, schemas, functions.typesMap, functions.meta, supportsImportAttributes);
     });
 };
 async function action({ config }) {

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/openapi-spec-generator.d.ts

@@ -1,4 +1,4 @@
-import { HTTPRoutesMeta } from '@pikku/core';
+import { FunctionsMeta, HTTPRoutesMeta } from '@pikku/core';
 interface OpenAPISpec {
     openapi: string;
     info: {
@@ -75,5 +75,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPRoutesMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

package/dist/src/openapi-spec-generator.js

@@ -9,9 +9,12 @@ const getErrorResponseForConstructorName = (constructorName) => {
     }
     return undefined;
 };
-const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
+const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
     const requiredSchemas = new Set(routesMeta
-        .map(({ inputTypes, output }) => [inputTypes?.body, output])
+        .map(({ inputTypes, pikkuFuncName }) => {
+        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
+        return [inputTypes?.body, output];
+    })
         .flat()
         .filter((schema) => !!schema));
     const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
@@ -26,10 +29,16 @@ const convertSchemasToBodyPayloads = async (routesMeta, schemas) => {
     }));
     return Object.fromEntries(convertedEntries.filter((s) => !!s));
 };
-export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
+export async function generateOpenAPISpec(functionsMeta, routeMeta, schemas, additionalInfo) {
     const paths = {};
     routeMeta.forEach((meta) => {
-        const { route, method, inputTypes, output, params, query, docs } = meta;
+        const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
+        const functionMeta = functionsMeta[pikkuFuncName];
+        if (!functionMeta) {
+            console.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
+            return;
+        }
+        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
         const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
         if (!paths[path]) {
             paths[path] = {};
@@ -103,7 +112,7 @@ export async function generateOpenAPISpec(routeMeta, schemas, additionalInfo) {
         servers: additionalInfo.servers,
         paths,
         components: {
-            schemas: await convertSchemasToBodyPayloads(routeMeta, schemas),
+            schemas: await convertSchemasToBodyPayloads(functionsMeta, routeMeta, schemas),
             responses: {},
             parameters: {},
             examples: {},

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.d.ts

@@ -1,5 +1,5 @@
-import { JSONValue } from '@pikku/core';
+import { FunctionsMeta, JSONValue } from '@pikku/core';
 import { HTTPRoutesMeta } from '@pikku/core/http';
 import { TypesMap } from '@pikku/inspector';
-export declare function generateSchemas(tsconfig: string, typesMaps: TypesMap[], httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
-export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, routesMeta: HTTPRoutesMeta, supportsImportAttributes: boolean): Promise<void>;
+export declare function generateSchemas(tsconfig: string, typesMap: TypesMap, functionMeta: FunctionsMeta, httpRoutesMeta: HTTPRoutesMeta): Promise<Record<string, JSONValue>>;
+export declare function saveSchemas(schemaParentDir: string, schemas: Record<string, JSONValue>, typesMap: TypesMap, functionsMeta: FunctionsMeta, supportsImportAttributes: boolean): Promise<void>;

package/dist/src/schema-generator.js

@@ -1,36 +1,18 @@
 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, typesMaps, httpRoutesMeta) {
-    const schemasSet = new Set(typesMaps.flatMap((tm) => [...tm.customTypes.keys()]));
-    for (const { input, inputTypes } of httpRoutesMeta) {
-        if (input) {
-            let found = false;
-            for (const typesMap of typesMaps) {
-                try {
-                    const uniqueName = typesMap.getUniqueName(input);
-                    if (uniqueName) {
-                        found = true;
-                        schemasSet.add(uniqueName);
-                        break;
-                    }
-                }
-                catch (e) { }
-            }
-            if (!found) {
-                console.error('Input type not found in any types map:', input);
+export async function generateSchemas(tsconfig, typesMap, functionMeta, httpRoutesMeta) {
+    const schemasSet = new Set(typesMap.customTypes.keys());
+    for (const { inputs, outputs } of Object.values(functionMeta)) {
+        const types = [...(inputs || []), ...(outputs || [])];
+        for (const type of types) {
+            const uniqueName = typesMap.getUniqueName(type);
+            if (uniqueName) {
+                schemasSet.add(uniqueName);
             }
         }
-        // if (output) {
-        //   for (const typesMap of typesMaps) {
-        //     const uniqueName = typesMap.getUniqueName(output)
-        //     if (uniqueName) {
-        //       console.log('Adding output schema:', uniqueName)
-        //       schemasSet.add(uniqueName)
-        //       break
-        //     }
-        //   }
-        // }
+    }
+    for (const { inputTypes } of httpRoutesMeta) {
         if (inputTypes?.body) {
             schemasSet.add(inputTypes.body);
         }
@@ -63,13 +45,13 @@ export async function generateSchemas(tsconfig, typesMaps, httpRoutesMeta) {
     });
     return schemas;
 }
-export async function saveSchemas(schemaParentDir, schemas, typesMap, routesMeta, supportsImportAttributes) {
+export async function saveSchemas(schemaParentDir, schemas, typesMap, functionsMeta, supportsImportAttributes) {
     await writeFileInDir(`${schemaParentDir}/register.gen.ts`, 'export const empty = null;');
     const desiredSchemas = new Set([
-        ...routesMeta
-            .map(({ input, output }) => [
-            input ? typesMap.getUniqueName(input) : undefined,
-            output ? typesMap.getUniqueName(output) : undefined,
+        ...Object.values(functionsMeta)
+            .map(({ inputs, outputs }) => [
+            inputs?.[0] ? typesMap.getUniqueName(inputs[0]) : undefined,
+            outputs?.[0] ? typesMap.getUniqueName(outputs[0]) : undefined,
         ])
             .flat()
             .filter((s) => !!s &&

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;