@pikku/cli 0.7.6 → 0.8.0

package/bin/pikku-websocket.ts

@@ -1,52 +1,18 @@
 import { Command } from 'commander'
-import {
-  getFileImportRelativePath,
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeWebsocketWrapper } from '../src/serialize-websocket-wrapper.js'
-
-export const pikkuWebSocket = async ({
-  websocketFile,
-  channelsMapDeclarationFile,
-  packageMappings,
-}: PikkuCLIConfig) => {
-  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 { CLILogger, PikkuCLIOptions } from '../src/utils.js'
+import { getPikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { pikkuWebSocketTyped } from '../src/events/channels/pikku-command-websocket-typed.js'
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  logPikkuLogo()
+  const logger = new CLILogger({ logLogo: true })
+
   const cliConfig = await getPikkuCLIConfig(
     options.config,
     ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'],
     options.tags,
     true
   )
-  await pikkuWebSocket(cliConfig)
+  await pikkuWebSocketTyped(logger, cliConfig)
 }
 
 export const websocket = (program: Command): void => {

package/bin/pikku.ts

@@ -4,6 +4,7 @@ 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]')
@@ -12,5 +13,6 @@ all(program)
 schemas(program)
 nextjs(program)
 fetch(program)
+queue(program)
 
 program.parse(process.argv)

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

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

package/dist/bin/pikku-all.js

@@ -1,34 +1,38 @@
-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 { pikkuFunctions } from '../src/events/functions/pikku-command-functions.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';
-const runAll = async (cliConfig, options) => {
+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 { 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';
+const runAll = async (logger, 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);
+            boostrapImports.all.meta.push(from);
         }
         else {
-            boostrapImports.all.events.push(statement);
+            boostrapImports.all.events.push(from);
         }
         for (const transport of Object.keys(PikkuEventTypes)) {
             if (!addTo || addTo?.includes(transport)) {
@@ -37,71 +41,87 @@ const runAll = async (cliConfig, options) => {
                     events: [],
                 };
                 if (type === 'meta') {
-                    boostrapImports[transport].meta.push(statement);
+                    boostrapImports[transport].meta.push(from);
                 }
                 else {
-                    boostrapImports[transport].events.push(statement);
+                    boostrapImports[transport].events.push(from);
                 }
             }
         }
     };
     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);
+    await pikkuRPC(logger, cliConfig, visitState);
+    await pikkuRPCMap(logger, cliConfig, visitState);
     addImport(cliConfig.rpcMetaFile, 'meta', [PikkuEventTypes.rpc]);
-    const schemas = await pikkuSchemas(cliConfig, visitState);
+    const schemas = await pikkuSchemas(logger, cliConfig, visitState);
     if (schemas) {
         addImport(`${cliConfig.schemaDirectory}/register.gen.ts`, 'other');
     }
-    const http = await pikkuHTTP(cliConfig, visitState);
+    const http = await pikkuHTTP(logger, cliConfig, visitState);
     if (http) {
-        await pikkuHTTPMap(cliConfig, visitState);
-        await pikkuFetch(cliConfig);
+        await pikkuHTTPMap(logger, cliConfig, visitState);
+        await pikkuFetch(logger, cliConfig);
         addImport(cliConfig.httpRoutesMetaFile, 'meta', [PikkuEventTypes.http]);
         addImport(cliConfig.httpRoutesFile, 'events', [PikkuEventTypes.http]);
     }
-    const scheduled = await pikkuScheduler(cliConfig, visitState);
+    const scheduled = await pikkuScheduler(logger, cliConfig, visitState);
     if (scheduled) {
         addImport(cliConfig.schedulersMetaFile, 'meta', [PikkuEventTypes.scheduled]);
         addImport(cliConfig.schedulersFile, 'events', [PikkuEventTypes.scheduled]);
     }
-    const channels = await pikkuChannels(cliConfig, visitState);
+    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]);
+    }
+    const channels = await pikkuChannels(logger, cliConfig, visitState);
     if (channels) {
-        await pikkuChannelsMap(cliConfig, visitState);
-        await pikkuWebSocket(cliConfig);
+        await pikkuChannelsMap(logger, cliConfig, visitState);
+        await pikkuWebSocketTyped(logger, cliConfig);
         addImport(cliConfig.channelsMetaFile, 'meta', [PikkuEventTypes.channel]);
         addImport(cliConfig.channelsFile, 'events', [PikkuEventTypes.channel]);
     }
+    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]);
+    }
     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);
+        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);
     }
     for (const [type, { meta, events }] of Object.entries(boostrapImports)) {
-        await writeFileInDir(type === 'all' ? cliConfig.bootstrapFile : cliConfig.bootstrapFiles[type], [...meta, ...events].join('\n'));
+        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'));
     }
 };
-const watch = (cliConfig, options) => {
+const watch = (logger, cliConfig, options) => {
     const configWatcher = chokidar.watch(cliConfig.srcDirectories, {
         ignoreInitial: true,
         ignored: /.*\.gen\.tsx?/,
@@ -109,7 +129,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 +137,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 +161,13 @@ const watch = (cliConfig, options) => {
     configWatcher.on('change', generatorWatcher);
 };
 export const action = async (options) => {
-    logPikkuLogo();
+    const logger = new CLILogger({ logLogo: true });
     const cliConfig = await getPikkuCLIConfig(options.config, [], options.tags, 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) => {

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,10 @@
 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 logger = new CLILogger({ logLogo: true });
     const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], options.tags, true);
-    await pikkuFetch(cliConfig);
+    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,12 @@
-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/events/http/pikku-command-nextjs.js';
 export const action = async (options) => {
-    logPikkuLogo();
+    const logger = new CLILogger({ logLogo: true });
     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 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,12 @@
-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 logger = new CLILogger({ logLogo: true });
     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 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,15 @@
+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'], options.tags, 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,10 @@
-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 logger = new CLILogger({ logLogo: true });
     const cliConfig = await getPikkuCLIConfig(options.config, ['rootDir', 'schemaDirectory', 'configDir', 'fetchFile'], options.tags, true);
-    await pikkuWebSocket(cliConfig);
+    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;