@pikku/cli 0.8.0 → 0.8.2

package/dist/bin/pikku-all.js

@@ -9,46 +9,37 @@ import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js'
 import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
 import { pikkuFunctions } from '../src/events/functions/pikku-command-functions.js';
+import { pikkuServices } from '../src/events/functions/pikku-command-services.js';
 import { pikkuRPC } from '../src/events/rpc/pikku-command-rpc.js';
 import { pikkuRPCMap } from '../src/events/rpc/pikku-command-rpc-map.js';
-import { PikkuEventTypes } from '@pikku/core';
 import { pikkuQueue } from '../src/events/queue/pikku-command-queue.js';
 import { pikkuQueueMap } from '../src/events/queue/pikku-command-queue-map.js';
 import { pikkuFetch } from '../src/events/fetch/index.js';
+import { pikkuRPCClient } from '../src/events/rpc/pikku-command-rpc-client.js';
 import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js';
-import { pikkuNext } from '../src/events/http/pikku-command-nextjs.js';
 import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js';
 import { pikkuMCP } from '../src/events/mcp/pikku-command-mcp.js';
 import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js';
 import { pikkuScheduler } from '../src/events/scheduler/pikku-command-scheduler.js';
 import { pikkuSchemas } from '../src/schemas.js';
 import { pikkuMCPJSON } from '../src/events/mcp/pikku-command-mcp-json.js';
+import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
+const generateBootstrapFile = async (logger, cliConfig, bootstrapFile, specificImports, schemas) => {
+    // Common imports that every bootstrap file needs
+    const commonImports = [cliConfig.functionsMetaFile, cliConfig.functionsFile];
+    // Add schema if it exists
+    if (schemas) {
+        commonImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
+    }
+    // Combine common imports with specific imports
+    const allImports = [...commonImports, ...specificImports];
+    await writeFileInDir(logger, bootstrapFile, allImports
+        .map((to) => `import '${getFileImportRelativePath(bootstrapFile, to, cliConfig.packageMappings)}'`)
+        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+        .join('\n'));
+};
 const runAll = async (logger, cliConfig, options) => {
-    const boostrapImports = {
-        all: { meta: [], events: [] },
-    };
-    const addImport = (from, type, addTo) => {
-        if (type === 'meta') {
-            boostrapImports.all.meta.push(from);
-        }
-        else {
-            boostrapImports.all.events.push(from);
-        }
-        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(from);
-                }
-                else {
-                    boostrapImports[transport].events.push(from);
-                }
-            }
-        }
-    };
+    const allImports = [];
     let typesDeclarationFileExists = true;
     let visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     if (!existsSync(cliConfig.typesDeclarationFile)) {
@@ -65,46 +56,51 @@ const runAll = async (logger, cliConfig, options) => {
         logger.info(`• No functions found, skipping remaining steps...\x1b[0m`);
         process.exit(1);
     }
-    addImport(cliConfig.functionsMetaFile, 'meta');
-    addImport(cliConfig.functionsFile, 'events');
+    // Base imports for all bootstrap files
+    allImports.push(cliConfig.functionsMetaFile, cliConfig.functionsFile);
+    // Generate services map
+    await pikkuServices(logger, cliConfig, visitState);
     await pikkuRPC(logger, cliConfig, visitState);
     await pikkuRPCMap(logger, cliConfig, visitState);
-    addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc]);
+    await pikkuRPCClient(logger, cliConfig);
+    allImports.push(cliConfig.rpcMetaFile);
     const schemas = await pikkuSchemas(logger, cliConfig, visitState);
     if (schemas) {
-        addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other');
+        allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
     }
+    // RPC bootstrap is always generated since RPC is always present
+    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [cliConfig.rpcMetaFile], schemas);
     const http = await pikkuHTTP(logger, cliConfig, visitState);
     if (http) {
         await pikkuHTTPMap(logger, cliConfig, visitState);
         await pikkuFetch(logger, cliConfig);
-        addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http]);
-        addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http]);
+        allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.http, [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile], schemas);
     }
-    const scheduled = await pikkuScheduler(logger, cliConfig, visitState);
-    if (scheduled) {
-        addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled]);
-        addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled]);
+    const scheduler = await pikkuScheduler(logger, cliConfig, visitState);
+    if (scheduler) {
+        allImports.push(cliConfig.schedulersMetaFile, cliConfig.schedulersFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.scheduler, [cliConfig.schedulersMetaFile, cliConfig.schedulersFile], schemas);
     }
     const queues = await pikkuQueue(logger, cliConfig, visitState);
     if (queues) {
         await pikkuQueueMap(logger, cliConfig, visitState);
         await pikkuQueueService(logger, cliConfig);
-        addImport(cliConfig.queueWorkersMetaFile, 'meta', [PikkuEventTypes.queue]);
-        addImport(cliConfig.queueWorkersFile, 'events', [PikkuEventTypes.queue]);
+        allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.queue, [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile], schemas);
     }
     const channels = await pikkuChannels(logger, cliConfig, visitState);
     if (channels) {
         await pikkuChannelsMap(logger, cliConfig, visitState);
         await pikkuWebSocketTyped(logger, cliConfig);
-        addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel]);
-        addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel]);
+        allImports.push(cliConfig.channelsMetaFile, cliConfig.channelsFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.channel, [cliConfig.channelsMetaFile, cliConfig.channelsFile], schemas);
     }
     const mcp = await pikkuMCP(logger, cliConfig, visitState);
     if (mcp) {
         await pikkuMCPJSON(logger, cliConfig, visitState);
-        addImport(cliConfig.mcpEndpointsMetaFile, 'meta', [PikkuEventTypes.mcp]);
-        addImport(cliConfig.mcpEndpointsFile, 'events', [PikkuEventTypes.mcp]);
+        allImports.push(cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.mcp, [cliConfig.mcpEndpointsMetaFile, cliConfig.mcpEndpointsFile], schemas);
     }
     if (cliConfig.nextBackendFile || cliConfig.nextHTTPFile) {
         await pikkuNext(logger, cliConfig, visitState, options);
@@ -114,12 +110,11 @@ const runAll = async (logger, cliConfig, options) => {
         visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
         await pikkuOpenAPI(logger, cliConfig, visitState);
     }
-    for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
-        const bootstrapFile = type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type];
-        await writeFileInDir(logger, bootstrapFile, [...meta, ...events]
-            .map((to) => `import '${getFileImportRelativePath(bootstrapFile, to, cliConfig.packageMappings)}'`)
-            .join('\n'));
-    }
+    // Generate main bootstrap file (pass all imports directly since this is the main file)
+    await writeFileInDir(logger, cliConfig.bootstrapFile, allImports
+        .map((to) => `import '${getFileImportRelativePath(cliConfig.bootstrapFile, to, cliConfig.packageMappings)}'`)
+        .sort((to) => (to.includes('meta') ? -1 : 1)) // Ensure meta files are at the top
+        .join('\n'));
 };
 const watch = (logger, cliConfig, options) => {
     const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
@@ -162,7 +157,11 @@ const watch = (logger, cliConfig, options) => {
 };
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, [], options.tags, true);
+    const cliConfig = await getPikkuCLIConfig(options.config, [], {
+        tags: options.tags,
+        types: options.types,
+        directories: options.directories,
+    }, true);
     if (options.watch) {
         watch(logger, cliConfig, options);
     }
@@ -179,6 +178,8 @@ export const all = (program) => {
         .option('-se | --session-services-factory-type', 'The type of your session services factory')
         .option('-c | --config <string>', 'The path to pikku cli config file')
         .option('-t | --tags <tags...>', 'Which tags to filter by')
+        .option('--types <types...>', 'Which types to filter by (http, channel, queue, scheduler, rpc, mcp)')
+        .option('--directories <directories...>', 'Which directories to filter by')
         .option('-w | --watch', 'Whether to watch file changes')
         .action(action);
 };

package/dist/bin/pikku-fetch.js

@@ -3,7 +3,11 @@ import { pikkuFetch } from '../src/events/fetch/index.js';
 import { CLILogger } from '../src/utils.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], options.tags, true);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], {
+        tags: options.tags,
+        types: options.types,
+        directories: options.directories,
+    }, true);
     await pikkuFetch(logger, cliConfig);
 };
 export const fetch = (program) => {

package/dist/bin/pikku-nextjs.js

@@ -1,10 +1,14 @@
 import { CLILogger } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-import { pikkuNext } from '../src/events/http/pikku-command-nextjs.js';
+import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir'], options.tags, true);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir'], {
+        tags: options.tags,
+        types: options.types,
+        directories: options.directories,
+    }, true);
     const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuNext(logger, cliConfig, visitState, options);
 };

package/dist/bin/pikku-openapi.js

@@ -4,7 +4,9 @@ import { inspectorGlob } from '../src/inspector-glob.js';
 import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js';
 async function action({ config, tags }) {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], tags);
+    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], {
+        tags: tags || [],
+    });
     const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     await pikkuOpenAPI(logger, cliConfig, visitState);
 }

package/dist/bin/pikku-queue-service.js

@@ -3,7 +3,11 @@ import { CLILogger } from '../src/utils.js';
 import { pikkuQueueService } from '../src/events/queue/pikku-command-queue-service.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'], options.tags, true);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'queueFile'], {
+        tags: options.tags,
+        types: options.types,
+        directories: options.directories,
+    }, true);
     await pikkuQueueService(logger, cliConfig);
 };
 export const queue = (program) => {

package/dist/bin/pikku-websocket.js

@@ -3,7 +3,11 @@ import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js';
 export const action = async (options) => {
     const logger = new CLILogger({ logLogo: true });
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], options.tags, true);
+    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], {
+        tags: options.tags,
+        types: options.types,
+        directories: options.directories,
+    }, true);
     await pikkuWebSocketTyped(logger, cliConfig);
 };
 export const websocket = (program) => {

package/dist/src/events/functions/pikku-command-services.d.ts

@@ -0,0 +1,3 @@
+import { PikkuCommand } from '../../types.js';
+export declare const serializeServicesMap: (functionsMetaData: Record<string, any>, middlewareServices: string[] | undefined, servicesImport: string, sessionServicesImport: string) => string;
+export declare const pikkuServices: PikkuCommand;

package/dist/src/events/functions/pikku-command-services.js

@@ -0,0 +1,73 @@
+import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const serializeServicesMap = (functionsMetaData, middlewareServices = [], servicesImport, sessionServicesImport) => {
+    // Extract all unique services from all functions
+    const usedServices = new Set();
+    // Internal services that are created internally and not via the create service script
+    const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession']);
+    for (const funcMeta of Object.values(functionsMetaData)) {
+        if (funcMeta.services && Array.isArray(funcMeta.services.services)) {
+            funcMeta.services.services.forEach((service) => {
+                // Only include services that are not internal
+                if (!internalServices.has(service)) {
+                    usedServices.add(service);
+                }
+            });
+        }
+    }
+    // Add middleware services that might not be detected from function inspection
+    middlewareServices.forEach((service) => {
+        if (!internalServices.has(service)) {
+            usedServices.add(service);
+        }
+    });
+    // Create a map of services with true for all needed services
+    const servicesMap = Object.fromEntries(Array.from(usedServices)
+        .sort()
+        .map((service) => [service, true]));
+    // Generate the TypeScript code
+    const serviceKeys = Object.keys(servicesMap).sort();
+    // Services that are always required internally by the framework
+    const defaultServices = ['config', 'logger', 'variables', 'schema'];
+    // Combine default services with detected services
+    const allRequiredServices = [
+        ...new Set([...defaultServices, ...serviceKeys]),
+    ].sort();
+    // For RequiredSingletonServices, we need to pick from the actual SingletonServices interface
+    // This will be resolved at compile time based on what's actually in the SingletonServices interface
+    // We don't need to hardcode which services are singletons beyond the core framework ones
+    const code = [
+        '/**',
+        ' * This file was generated by the @pikku/cli',
+        ' */',
+        '',
+        servicesImport,
+        sessionServicesImport,
+        "import type { PikkuInteraction } from '@pikku/core'",
+        '',
+        'export const singletonServices = {',
+        ...Object.keys(servicesMap).map((service) => `    '${service}': true,`),
+        '} as const',
+        '',
+        '// Singleton services (created once at startup)',
+        '// Only includes services that are both required and available in SingletonServices',
+        `export type RequiredSingletonServices = Pick<SingletonServices, Extract<keyof SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>> & Partial<Omit<SingletonServices, ${allRequiredServices.map((key) => `'${key}'`).join(' | ')}>>`,
+        '',
+        '// Session services (created per request, can access singleton services)',
+        '// Omits singleton services and PikkuInteraction (mcp, rpc, http, channel)',
+        `export type RequiredSessionServices = Omit<Services, keyof SingletonServices | keyof PikkuInteraction>`,
+        '',
+    ].join('\n');
+    return code;
+};
+export const pikkuServices = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Generating Pikku services map', 'Generated Pikku services map', [visitState.functions.files.size === 0], async () => {
+        const { sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, cliConfig.packageMappings, cliConfig.typesDeclarationFile, {}, {
+            sessionServiceType: true,
+            singletonServicesType: true,
+        });
+        const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`;
+        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`;
+        const servicesCode = serializeServicesMap(visitState.functions.meta, cliConfig.middlewareServices, servicesImport, sessionServicesImport);
+        await writeFileInDir(logger, cliConfig.servicesFile, servicesCode);
+    });
+};

package/dist/src/events/http/serialize-typed-http-map.d.ts

@@ -2,4 +2,3 @@ import { HTTPRoutesMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
 export declare const serializeTypedRoutesMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, routesMeta: HTTPRoutesMeta, metaTypes: MetaInputTypes) => string;
-export declare function generateCustomTypes(typesMap: TypesMap, requiredTypes: Set<string>): string;

package/dist/src/events/http/serialize-typed-http-map.js

@@ -1,4 +1,5 @@
 import { serializeImportMap } from '../../serialize-import-map.js';
+import { generateCustomTypes } from '../../utils.js';
 export const serializeTypedRoutesMap = (relativeToPath, packageMappings, typesMap, functionsMeta, routesMeta, metaTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
@@ -30,20 +31,6 @@ export type RoutesWithMethod<Method extends string> = {
 }[keyof RoutesMap];
   `;
 };
-export function generateCustomTypes(typesMap, requiredTypes) {
-    return `
-// Custom types are those that are defined directly within generics
-// or are broken into simpler types
-${Array.from(typesMap.customTypes.entries())
-        .map(([name, { type, references }]) => {
-        references.forEach((name) => {
-            const originalName = typesMap.getTypeMeta(name).originalName;
-            requiredTypes.add(originalName);
-        });
-        return `export type ${name} = ${type}`;
-    })
-        .join('\n')}`;
-}
 function generateRoutes(routesMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};

package/dist/src/events/rpc/pikku-command-rpc-client.d.ts

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

package/dist/src/events/rpc/pikku-command-rpc-client.js

@@ -0,0 +1,12 @@
+import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
+import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+export const pikkuRPCClient = async (logger, { rpcFile, rpcMapDeclarationFile, packageMappings }) => {
+    return await logCommandInfoAndTime(logger, 'Generating RPC wrapper', 'Generated RPC wrapper', [rpcFile === undefined, "rpcFile isn't set in the pikku config"], async () => {
+        if (!rpcFile) {
+            throw new Error("rpcFile isn't set in the pikku config");
+        }
+        const rpcMapDeclarationPath = getFileImportRelativePath(rpcFile, rpcMapDeclarationFile, packageMappings);
+        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
+        await writeFileInDir(logger, rpcFile, content.join('\n'));
+    });
+};

package/dist/src/events/rpc/serialize-rpc-wrapper.d.ts

@@ -0,0 +1 @@
+export declare const serializeRPCWrapper: (rpcMapPath: string) => string;

package/dist/src/events/rpc/serialize-rpc-wrapper.js

@@ -0,0 +1,29 @@
+export const serializeRPCWrapper = (rpcMapPath) => {
+    return `
+import { PikkuFetch } from "./pikku-fetch.gen.js"
+import type { RPCInvoke } from '${rpcMapPath}'
+
+export class PikkuRPC {
+    pikkuFetch = new PikkuFetch()
+
+    setPikkuFetch(pikkuFetch: PikkuFetch): void {
+        this.pikkuFetch = pikkuFetch
+    }
+
+    setServerUrl(serverUrl: string): void {
+        this.pikkuFetch.setServerUrl(serverUrl)
+    }
+
+    setAuthorizationJWT(jwt: string | null): void {
+        this.pikkuFetch.setAuthorizationJWT(jwt)
+    }
+
+    // Generic RPC invoke method
+    invoke: RPCInvoke = async (name, data) => {
+       return await this.pikkuFetch.post('/rpc', { name, data })
+    }
+}
+
+export const pikkuRPC = new PikkuRPC();
+`;
+};

package/dist/src/events/rpc/serialize-typed-rpc-map.js

@@ -19,7 +19,7 @@ interface RPCHandler<I, O> {
 
 ${serializedRPCs}
 
-type RPCInvoke = <Name extends keyof RPCMap>(
+export type RPCInvoke = <Name extends keyof RPCMap>(
   name: Name,
   data: RPCMap[Name]['input'],
   options?: {

package/dist/src/inspector-glob.js

@@ -6,7 +6,7 @@ export const inspectorGlob = async (logger, rootDir, srcDirectories, filters) =>
     let result;
     await logCommandInfoAndTime(logger, 'Inspecting codebase', 'Inspected codebase', [false], async () => {
         const routeFiles = (await Promise.all(srcDirectories.map((dir) => glob(`${path.join(rootDir, dir)}/**/*.ts`)))).flat();
-        result = await inspect(routeFiles, filters);
+        result = await inspect(logger, routeFiles, filters);
     });
     return result;
 };

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

@@ -22,6 +22,7 @@ export interface PikkuCLICoreOutputFiles {
     queueMapDeclarationFile: string;
     mcpEndpointsFile: string;
     mcpEndpointsMetaFile: string;
+    servicesFile: string;
     bootstrapFile: string;
     bootstrapFiles: Record<PikkuEventTypes, string>;
 }
@@ -38,13 +39,15 @@ export type PikkuCLIConfig = {
     nextHTTPFile?: string;
     fetchFile?: string;
     websocketFile?: string;
+    rpcFile?: string;
     queueFile?: string;
     mcpJsonFile?: string;
     openAPI?: {
         outputFile: string;
         additionalInfo: OpenAPISpecInfo;
     };
+    middlewareServices?: string[];
     filters: InspectorFilters;
 } & PikkuCLICoreOutputFiles;
-export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, tags?: string[], exitProcess?: boolean) => Promise<PikkuCLIConfig>;
+export declare const getPikkuCLIConfig: (configFile: string | undefined, requiredFields: Array<keyof PikkuCLIConfig>, filters?: InspectorFilters, exitProcess?: boolean) => Promise<PikkuCLIConfig>;
 export declare const validateCLIConfig: (cliConfig: PikkuCLIConfig, required: Array<keyof PikkuCLIConfig>) => void;

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

@@ -6,14 +6,15 @@ const CONFIG_DIR_FILES = [
     'nextHTTPFile',
     'fetchFile',
     'websocketFile',
+    'rpcFile',
     'queueFile',
     'mcpJsonFile',
 ];
-export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
-    const config = await _getPikkuCLIConfig(configFile, requiredFields, tags, exitProcess);
+export const getPikkuCLIConfig = async (configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
+    const config = await _getPikkuCLIConfig(configFile, requiredFields, filters, exitProcess);
     return config;
 };
-const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags = [], exitProcess = false) => {
+const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filters = {}, exitProcess = false) => {
     if (!configFile) {
         let execDirectory = process.cwd();
         const files = await readdir(execDirectory);
@@ -34,7 +35,7 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
         const configDir = dirname(configFile);
         const config = JSON.parse(file);
         if (config.extends) {
-            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], tags, exitProcess);
+            const extendedConfig = await getPikkuCLIConfig(resolve(configDir, config.extends), [], filters, exitProcess);
             result = {
                 ...extendedConfig,
                 ...config,
@@ -57,8 +58,9 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
         }
         if (result.outDir) {
             // Create transport/event directories
+            const functionDir = join(result.outDir, 'function');
             const httpDir = join(result.outDir, 'http');
-            const channelsDir = join(result.outDir, 'channels');
+            const channelDir = join(result.outDir, 'channel');
             const rpcDir = join(result.outDir, 'rpc');
             const schedulerDir = join(result.outDir, 'scheduler');
             const queueDir = join(result.outDir, 'queue');
@@ -69,10 +71,10 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             }
             // Functions
             if (!result.functionsFile) {
-                result.functionsFile = join(result.outDir, 'pikku-functions.gen.ts');
+                result.functionsFile = join(functionDir, 'pikku-functions.gen.ts');
             }
             if (!result.functionsMetaFile) {
-                result.functionsMetaFile = join(result.outDir, 'pikku-functions-meta.gen.ts');
+                result.functionsMetaFile = join(functionDir, 'pikku-functions-meta.gen.ts');
             }
             if (!result.typesDeclarationFile) {
                 result.typesDeclarationFile = join(result.outDir, 'pikku-types.gen.ts');
@@ -89,13 +91,13 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             }
             // Channels/WebSocket
             if (!result.channelsFile) {
-                result.channelsFile = join(channelsDir, 'pikku-channels.gen.ts');
+                result.channelsFile = join(channelDir, 'pikku-channels.gen.ts');
             }
             if (!result.channelsMetaFile) {
-                result.channelsMetaFile = join(channelsDir, 'pikku-channels-meta.gen.ts');
+                result.channelsMetaFile = join(channelDir, 'pikku-channels-meta.gen.ts');
             }
             if (!result.channelsMapDeclarationFile) {
-                result.channelsMapDeclarationFile = join(channelsDir, 'pikku-channels-map.gen.d.ts');
+                result.channelsMapDeclarationFile = join(channelDir, 'pikku-channels-map.gen.d.ts');
             }
             // RPC
             if (!result.rpcMetaFile) {
@@ -106,10 +108,10 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             }
             // Scheduler
             if (!result.schedulersFile) {
-                result.schedulersFile = join(schedulerDir, 'pikku-schedules.gen.ts');
+                result.schedulersFile = join(schedulerDir, 'pikku-scheduler.gen.ts');
             }
             if (!result.schedulersMetaFile) {
-                result.schedulersMetaFile = join(schedulerDir, 'pikku-schedules-meta.gen.ts');
+                result.schedulersMetaFile = join(schedulerDir, 'pikku-scheduler-meta.gen.ts');
             }
             // Queue
             if (!result.queueWorkersFile) {
@@ -121,6 +123,10 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             if (!result.queueMapDeclarationFile) {
                 result.queueMapDeclarationFile = join(queueDir, 'pikku-queue-map.gen.ts');
             }
+            // Services
+            if (!result.servicesFile) {
+                result.servicesFile = join(result.outDir, 'pikku-services.gen.ts');
+            }
             // Bootstrap files
             if (!result.bootstrapFile) {
                 result.bootstrapFile = join(result.outDir, 'pikku-bootstrap.gen.ts');
@@ -157,8 +163,14 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, tags =
             }
         }
         result.filters = result.filters || {};
-        if (tags.length > 0) {
-            result.filters.tags = tags;
+        if (filters.tags && filters.tags.length > 0) {
+            result.filters.tags = filters.tags;
+        }
+        if (filters.types && filters.types.length > 0) {
+            result.filters.types = filters.types;
+        }
+        if (filters.directories && filters.directories.length > 0) {
+            result.filters.directories = filters.directories;
         }
         if (!isAbsolute(result.tsconfig)) {
             result.tsconfig = join(result.rootDir, result.tsconfig);

package/dist/src/schema-generator.js

@@ -43,10 +43,10 @@ export async function generateSchemas(logger, tsconfig, typesMap, functionMeta,
         catch (e) {
             // Ignore rootless errors
             if (e instanceof RootlessError) {
-                console.error('Error generating schema since it has no root:', schema);
+                logger.error(`Error generating schema since it has no root: ${schema}`);
                 return;
             }
-            throw e;
+            logger.error(`Error generating schema: ${schema}`);
         }
     });
     return schemas;

package/dist/src/utils.d.ts

@@ -8,6 +8,7 @@ export declare class CLILogger {
     info(message: string): void;
     error(message: string): void;
     warn(message: string): void;
+    debug(message: string): void;
     private logPikkuLogo;
 }
 export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;
@@ -33,6 +34,8 @@ export interface PikkuCLIOptions {
     singletonServicesFactoryType?: string;
     sessionServicesFactoryType?: string;
     tags?: string[];
+    types?: string[];
+    directories?: string[];
 }
 export declare const getPikkuFilesAndMethods: (logger: CLILogger, { singletonServicesTypeImportMap, sessionServicesTypeImportMap, userSessionTypeImportMap, sessionServicesFactories, singletonServicesFactories, configFactories, }: InspectorState, packageMappings: Record<string, string>, outputFile: string, { configFileType, singletonServicesFactoryType, sessionServicesFactoryType, }: PikkuCLIOptions, requires?: Partial<{
     config: boolean;