@pikku/cli 0.7.7 → 0.8.1

package/dist/bin/pikku-all.js

@@ -1,107 +1,122 @@
-import { getFileImportRelativePath, logInfo, logPikkuLogo, writeFileInDir, } from '../src/utils/utils.js';
+import { CLILogger, getFileImportRelativePath, writeFileInDir, } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { pikkuHTTP } from './pikku-http-routes.js';
-import { pikkuFunctionTypes } from './pikku-function-types.js';
-import { pikkuHTTPMap } from './pikku-http-map.js';
+import { pikkuHTTP } from '../src/events/http/pikku-command-http-routes.js';
+import { pikkuFunctionTypes } from '../src/events/functions/pikku-command-function-types.js';
+import { pikkuHTTPMap } from '../src/events/http/pikku-command-http-map.js';
 import { existsSync } from 'fs';
-import { pikkuFetch } from './pikku-fetch.js';
-import { pikkuChannelsMap } from './pikku-channels-map.js';
-import { pikkuChannels } from './pikku-channels.js';
-import { pikkuNext } from './pikku-nextjs.js';
-import { pikkuOpenAPI } from './pikku-openapi.js';
-import { pikkuScheduler } from './pikku-scheduler.js';
-import { pikkuSchemas } from './pikku-schemas.js';
-import { pikkuWebSocket } from './pikku-websocket.js';
+import { pikkuChannelsMap } from '../src/events/channels/pikku-command-channels-map.js';
+import { pikkuChannels } from '../src/events/channels/pikku-command-channels.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
-import { pikkuFunctions } from './pikku-functions.js';
-import { pikkuRPC } from './pikku-rpc.js';
-import { pikkuRPCMap } from './pikku-rpc-map.js';
-import { PikkuEventTypes } from '@pikku/core';
-const runAll = async (cliConfig, options) => {
-    const boostrapImports = {
-        all: { meta: [], events: [] },
-    };
-    const addImport = (from, type, addTo) => {
-        const statement = `import '${getFileImportRelativePath(cliConfig.bootstrapFile, from, cliConfig.packageMappings)}'`;
-        if (type === 'meta') {
-            boostrapImports.all.meta.push(statement);
-        }
-        else {
-            boostrapImports.all.events.push(statement);
-        }
-        for (const transport of Object.keys(PikkuEventTypes)) {
-            if (!addTo || addTo?.includes(transport)) {
-                boostrapImports[transport] = boostrapImports[transport] || {
-                    meta: [],
-                    events: [],
-                };
-                if (type === 'meta') {
-                    boostrapImports[transport].meta.push(statement);
-                }
-                else {
-                    boostrapImports[transport].events.push(statement);
-                }
-            }
-        }
-    };
+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 { 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 { 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 allImports = [];
     let typesDeclarationFileExists = true;
-    let visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
+    let visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     if (!existsSync(cliConfig.typesDeclarationFile)) {
         typesDeclarationFileExists = false;
     }
-    await pikkuFunctionTypes(cliConfig, options, visitState);
+    await pikkuFunctionTypes(logger, cliConfig, visitState, options);
     // This is needed since the addHTTPRoute function will add the routes to the visitState
     if (!typesDeclarationFileExists) {
-        logInfo(`• Type file first created, inspecting again...\x1b[0m`);
-        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
+        logger.info(`• Type file first created, inspecting again...\x1b[0m`);
+        visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
     }
-    const functions = pikkuFunctions(cliConfig, visitState);
+    const functions = pikkuFunctions(logger, cliConfig, visitState);
     if (!functions) {
-        logInfo(`• No functions found, skipping remaining steps...\x1b[0m`);
+        logger.info(`• No functions found, skipping remaining steps...\x1b[0m`);
         process.exit(1);
     }
-    addImport(cliConfig.functionsMetaFile, 'meta');
-    addImport(cliConfig.functionsFile, 'events');
-    await pikkuRPC(cliConfig, visitState);
-    await pikkuRPCMap(cliConfig, visitState);
-    addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc]);
-    const schemas = await pikkuSchemas(cliConfig, visitState);
+    // 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);
+    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`);
     }
-    const http = await pikkuHTTP(cliConfig, visitState);
+    // 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(cliConfig, visitState);
-        await pikkuFetch(cliConfig);
-        addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http]);
-        addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http]);
+        await pikkuHTTPMap(logger, cliConfig, visitState);
+        await pikkuFetch(logger, cliConfig);
+        allImports.push(cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.http, [cliConfig.httpRoutesMetaFile, cliConfig.httpRoutesFile], schemas);
+    }
+    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 scheduled = await pikkuScheduler(cliConfig, visitState);
-    if (scheduled) {
-        addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled]);
-        addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled]);
+    const queues = await pikkuQueue(logger, cliConfig, visitState);
+    if (queues) {
+        await pikkuQueueMap(logger, cliConfig, visitState);
+        await pikkuQueueService(logger, cliConfig);
+        allImports.push(cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile);
+        await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.queue, [cliConfig.queueWorkersMetaFile, cliConfig.queueWorkersFile], schemas);
     }
-    const channels = await pikkuChannels(cliConfig, visitState);
+    const channels = await pikkuChannels(logger, cliConfig, visitState);
     if (channels) {
-        await pikkuChannelsMap(cliConfig, visitState);
-        await pikkuWebSocket(cliConfig);
-        addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel]);
-        addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel]);
+        await pikkuChannelsMap(logger, cliConfig, visitState);
+        await pikkuWebSocketTyped(logger, cliConfig);
+        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);
+        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(cliConfig, visitState, options);
+        await pikkuNext(logger, cliConfig, visitState, options);
     }
     if (cliConfig.openAPI) {
-        logInfo(`• OpenAPI requires a reinspection to pickup new generated types..`);
-        visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-        await pikkuOpenAPI(cliConfig, visitState);
-    }
-    for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
-        await writeFileInDir(type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type], [...meta, ...events].join('\n'));
+        logger.info(`• OpenAPI requires a reinspection to pickup new generated types..`);
+        visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
+        await pikkuOpenAPI(logger, cliConfig, visitState);
     }
+    // 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 = (cliConfig, options) => {
+const watch = (logger, cliConfig, options) => {
     const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
         ignoreInitial: true,
         ignored: /.*\.gen\.tsx?/,
@@ -109,7 +124,7 @@ const watch = (cliConfig, options) => {
     let watcher = new chokidar.FSWatcher({});
     const generatorWatcher = () => {
         watcher.close();
-        logInfo(`• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`);
+        logger.info(`• Watching directories: \n  - ${cliConfig.srcDirectories.join('\n  - ')}`);
         watcher = chokidar.watch(cliConfig.srcDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.ts/,
@@ -117,7 +132,7 @@ const watch = (cliConfig, options) => {
         watcher.on('ready', async () => {
             const handle = async () => {
                 try {
-                    await runAll(cliConfig, options);
+                    await runAll(logger, cliConfig, options);
                 }
                 catch (err) {
                     console.error(err);
@@ -141,13 +156,17 @@ const watch = (cliConfig, options) => {
     configWatcher.on('change', generatorWatcher);
 };
 export const action = async (options) => {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, [], options.tags, true);
+    const logger = new CLILogger({ logLogo: true });
+    const cliConfig = await getPikkuCLIConfig(options.config, [], {
+        tags: options.tags,
+        types: options.types,
+        directories: options.directories,
+    }, true);
     if (options.watch) {
-        watch(cliConfig, options);
+        watch(logger, cliConfig, options);
     }
     else {
-        await runAll(cliConfig, options);
+        await runAll(logger, cliConfig, options);
     }
 };
 export const all = (program) => {
@@ -159,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.d.ts

@@ -1,6 +1,4 @@
 import { Command } from 'commander';
-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>;
+import { PikkuCLIOptions } from '../src/utils.js';
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const fetch: (program: Command) => void;

package/dist/bin/pikku-fetch.js

@@ -1,20 +1,14 @@
 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) {
-            throw new Error("fetchFile is isn't set in the pikku config");
-        }
-        const routesMapDeclarationPath = getFileImportRelativePath(fetchFile, httpRoutesMapDeclarationFile, packageMappings);
-        const content = [serializeFetchWrapper(routesMapDeclarationPath)];
-        await writeFileInDir(fetchFile, content.join('\n'));
-    });
-};
+import { pikkuFetch } from '../src/events/fetch/index.js';
+import { CLILogger } from '../src/utils.js';
 export const action = async (options) => {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], options.tags, true);
-    await pikkuFetch(cliConfig);
+    const logger = new CLILogger({ logLogo: 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) => {
     program

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

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

package/dist/bin/pikku-nextjs.js

@@ -1,46 +1,16 @@
-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/utils.js';
+import { CLILogger } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuNext = async ({ nextBackendFile, nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings, fetchFile, bootstrapFiles, }, visitState, options) => {
-    return await logCommandInfoAndTime('Generating nextjs wrapper', 'Generated nextjs wrapper', [
-        nextBackendFile === undefined && nextHTTPFile === undefined,
-        'nextjs outfile is not defined',
-    ], async () => {
-        if (!nextBackendFile && !nextHTTPFile) {
-            throw new Error('nextBackendFile or nextHTTPFile is required in pikku config for nextJS');
-        }
-        if (nextHTTPFile && !fetchFile) {
-            throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
-        }
-        if (nextBackendFile) {
-            const { pikkuConfigFactory, singletonServicesFactory, sessionServicesFactory, } = await getPikkuFilesAndMethods(visitState, packageMappings, nextBackendFile, options, {
-                config: true,
-                singletonServicesFactory: true,
-                sessionServicesFactory: true,
-            });
-            const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
-            const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
-            const sessionServicesImport = `import { ${sessionServicesFactory.variable} as createSessionServices } from '${getFileImportRelativePath(nextBackendFile, sessionServicesFactory.file, packageMappings)}'`;
-            const httpBootstrapPath = getFileImportRelativePath(nextBackendFile, bootstrapFiles.http, packageMappings);
-            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpRoutesMapDeclarationFile, packageMappings);
-            const content = serializeNextBackendWrapper(httpBootstrapPath, routesMapDeclarationPath, pikkuConfigImport, singletonServicesImport, sessionServicesImport);
-            await writeFileInDir(nextBackendFile, content);
-        }
-        if (nextHTTPFile && fetchFile) {
-            const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpRoutesMapDeclarationFile, packageMappings);
-            const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
-            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, fetchPath);
-            await writeFileInDir(nextHTTPFile, content);
-        }
-    });
-};
+import { pikkuNext } from '../src/runtimes/nextjs/pikku-command-nextjs.js';
 export const action = async (options) => {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir'], options.tags, true);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuNext(cliConfig, visitState, options);
+    const logger = new CLILogger({ logLogo: 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);
 };
 export const nextjs = (program) => {
     program

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

@@ -1,5 +1,2 @@
 import { Command } from 'commander';
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { InspectorState } from '@pikku/inspector';
-export declare const pikkuOpenAPI: ({ tsconfig, openAPI }: PikkuCLIConfig, { http, functions }: InspectorState) => Promise<void>;
 export declare const openapi: (program: Command) => void;

package/dist/bin/pikku-openapi.js

@@ -1,30 +1,14 @@
-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 { CLILogger } from '../src/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { stringify } from 'yaml';
 import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuOpenAPI = async ({ tsconfig, openAPI }, { http, functions }) => {
-    await logCommandInfoAndTime('Creating OpenAPI spec', 'Created OpenAPI spec', [openAPI?.outputFile === undefined, 'openAPI outfile is not defined'], async () => {
-        if (!openAPI?.outputFile) {
-            throw new Error('openAPI is required');
-        }
-        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);
-        }
-        else if (openAPI.outputFile.endsWith('.yaml') ||
-            openAPI.outputFile.endsWith('.yml')) {
-            await writeFileInDir(openAPI.outputFile, stringify(openAPISpec), true);
-        }
-    });
-};
+import { pikkuOpenAPI } from '../src/events/http/pikku-command-openapi.js';
 async function action({ config, tags }) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(config, ['rootDir', 'httpRoutesFile', 'openAPI', 'schemaDirectory', 'tsconfig'], tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuOpenAPI(cliConfig, visitState);
+    const logger = new CLILogger({ logLogo: true });
+    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);
 }
 export const openapi = (program) => {
     program

package/dist/bin/pikku-queue-service.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import { PikkuCLIOptions } from '../src/utils.js';
+export declare const action: (options: PikkuCLIOptions) => Promise<void>;
+export declare const queue: (program: Command) => void;

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

@@ -0,0 +1,19 @@
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
+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'], {
+        tags: options.tags,
+        types: options.types,
+        directories: options.directories,
+    }, true);
+    await pikkuQueueService(logger, cliConfig);
+};
+export const queue = (program) => {
+    program
+        .command('queue')
+        .description('generate queue service wrapper')
+        .option('-c | --config <string>', 'The path to pikku cli config file')
+        .action(action);
+};

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

@@ -1,5 +1,2 @@
 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 }: InspectorState) => Promise<boolean>;
 export declare const schemas: (program: Command) => void;

package/dist/bin/pikku-schemas.js

@@ -1,22 +1,16 @@
-import { saveSchemas, generateSchemas } from '../src/schema-generator.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.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 }) => {
-    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);
-    });
-};
+import { pikkuSchemas } from '../src/schemas.js';
+import { CLILogger } from '../src/utils.js';
 async function action({ config }) {
-    logPikkuLogo();
+    const logger = new CLILogger({ logLogo: true });
     const cliConfig = await getPikkuCLIConfig(config, [
         'srcDirectories',
         'schemaDirectory',
         'tsconfig',
     ]);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuSchemas(cliConfig, visitState);
+    const visitState = await inspectorGlob(logger, cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
+    await pikkuSchemas(logger, cliConfig, visitState);
 }
 export const schemas = (program) => {
     program

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

@@ -1,6 +1,4 @@
 import { Command } from 'commander';
-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>;
+import { PikkuCLIOptions } from '../src/utils.js';
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const websocket: (program: Command) => void;

package/dist/bin/pikku-websocket.js

@@ -1,23 +1,14 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils/utils.js';
+import { CLILogger } from '../src/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, }) => {
-    await logCommandInfoAndTime('Generating websocket wrapper', 'Generated websocket wrapper', [
-        websocketFile === undefined,
-        "websocketFile isn't set in the pikku config",
-    ], async () => {
-        if (!websocketFile) {
-            throw new Error("fetchFile is isn't set in the pikku config");
-        }
-        const channelsMapDeclarationPath = getFileImportRelativePath(websocketFile, channelsMapDeclarationFile, packageMappings);
-        const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)];
-        await writeFileInDir(websocketFile, content.join('\n'));
-    });
-};
+import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js';
 export const action = async (options) => {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], options.tags, true);
-    await pikkuWebSocket(cliConfig);
+    const logger = new CLILogger({ logLogo: 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) => {
     program

package/dist/bin/pikku.js

@@ -4,10 +4,12 @@ import { schemas } from './pikku-schemas.js';
 import { nextjs } from './pikku-nextjs.js';
 import { all } from './pikku-all.js';
 import { fetch } from './pikku-fetch.js';
+import { queue } from './pikku-queue-service.js';
 const program = new Command('pikku');
 program.usage('[command]');
 all(program);
 schemas(program);
 nextjs(program);
 fetch(program);
+queue(program);
 program.parse(process.argv);

package/dist/src/events/channels/pikku-channels.d.ts

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

package/dist/src/events/channels/pikku-channels.js

@@ -0,0 +1,9 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+export const pikkuChannels = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
+        const { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
+        const { channels } = visitState;
+        await writeFileInDir(logger, channelsFile, serializeFileImports('addChannel', channelsFile, channels.files, packageMappings));
+        await writeFileInDir(logger, channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+    });
+};

package/dist/src/events/channels/pikku-command-channels-map.d.ts

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

package/dist/src/events/channels/pikku-command-channels-map.js

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

package/dist/src/events/channels/pikku-command-channels.d.ts

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

package/dist/src/events/channels/pikku-command-channels.js

@@ -0,0 +1,9 @@
+import { logCommandInfoAndTime, serializeFileImports, writeFileInDir, } from '../../utils.js';
+export const pikkuChannels = async (logger, cliConfig, visitState) => {
+    return await logCommandInfoAndTime(logger, 'Finding Channels', 'Found channels', [visitState.channels.files.size === 0], async () => {
+        const { channelsFile, channelsMetaFile, packageMappings } = cliConfig;
+        const { channels } = visitState;
+        await writeFileInDir(logger, channelsFile, serializeFileImports('addChannel', channelsFile, channels.files, packageMappings));
+        await writeFileInDir(logger, channelsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+    });
+};

package/dist/src/events/channels/pikku-command-websocket-typed.d.ts

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

package/dist/src/events/channels/pikku-command-websocket-typed.js

@@ -0,0 +1,15 @@
+import { logCommandInfoAndTime, getFileImportRelativePath, writeFileInDir, } from '../../utils.js';
+import { serializeWebsocketWrapper } from './serialize-websocket-wrapper.js';
+export const pikkuWebSocketTyped = async (logger, { websocketFile, channelsMapDeclarationFile, packageMappings }) => {
+    return await logCommandInfoAndTime(logger, 'Generating websocket wrapper', 'Generated websocket wrapper', [
+        websocketFile === undefined,
+        "websocketFile isn't set in the pikku config",
+    ], async () => {
+        if (!websocketFile) {
+            throw new Error("fetchFile is isn't set in the pikku config");
+        }
+        const channelsMapDeclarationPath = getFileImportRelativePath(websocketFile, channelsMapDeclarationFile, packageMappings);
+        const content = [serializeWebsocketWrapper(channelsMapDeclarationPath)];
+        await writeFileInDir(logger, websocketFile, content.join('\n'));
+    });
+};

package/dist/src/{serialize-typed-channel-map.js → events/channels/serialize-typed-channel-map.js}

@@ -1,5 +1,5 @@
-import { serializeImportMap } from './utils/serialize-import-map.js';
-import { generateCustomTypes } from './utils/utils.js';
+import { serializeImportMap } from '../../serialize-import-map.js';
+import { generateCustomTypes } from '../../utils.js';
 export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
     const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {

package/dist/src/events/fetch/index.d.ts

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