@pikku/cli 0.9.0 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @pikku/cli
 
+## 0.9.1
+
+### Patch Changes
+
+- fdb1593: feat: adding silent option to cli
+- fdb1593: core: bumping everything with a patch to sync up the major release inconsistencies in dependencies
+- Updated dependencies [fdb1593]
+  - @pikku/core@0.9.1
+  - @pikku/inspector@0.9.1
+
 ## 0.9.0
 
 ### Breaking Changes

package/bin/pikku-all.ts

@@ -262,7 +262,11 @@ const watch = (
     watcher.on('ready', async () => {
       const handle = async () => {
         try {
+          const start = Date.now()
           await runAll(logger, cliConfig, options)
+          if (options.silent) {
+            logger.timing(`✓ Generated in ${Date.now() - start}ms`)
+          }
         } catch (err) {
           console.error(err)
           console.info()
@@ -291,7 +295,7 @@ const watch = (
 }
 
 export const action = async (options: PikkuCLIOptions): Promise<void> => {
-  const logger = new CLILogger({ logLogo: true })
+  const logger = new CLILogger({ logLogo: true, silent: options.silent })
 
   const cliConfig = await getPikkuCLIConfig(
     options.config,
@@ -332,5 +336,6 @@ export const all = (program: Command): void => {
     )
     .option('--directories <directories...>', 'Which directories to filter by')
     .option('-w | --watch', 'Whether to watch file changes')
+    .option('-s | --silent', 'Silent mode - only show errors')
     .action(action)
 }

package/dist/bin/pikku-all.js

@@ -132,7 +132,11 @@ const watch = (logger, cliConfig, options) => {
         watcher.on('ready', async () => {
             const handle = async () => {
                 try {
+                    const start = Date.now();
                     await runAll(logger, cliConfig, options);
+                    if (options.silent) {
+                        logger.timing(`✓ Generated in ${Date.now() - start}ms`);
+                    }
                 }
                 catch (err) {
                     console.error(err);
@@ -156,7 +160,7 @@ const watch = (logger, cliConfig, options) => {
     configWatcher.on('change', generatorWatcher);
 };
 export const action = async (options) => {
-    const logger = new CLILogger({ logLogo: true });
+    const logger = new CLILogger({ logLogo: true, silent: options.silent });
     const cliConfig = await getPikkuCLIConfig(options.config, [], {
         tags: options.tags,
         types: options.types,
@@ -181,5 +185,6 @@ export const all = (program) => {
         .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')
+        .option('-s | --silent', 'Silent mode - only show errors')
         .action(action);
 };

package/dist/src/utils.d.ts

@@ -1,7 +1,9 @@
 import { InspectorState, TypesMap } from '@pikku/inspector';
 export declare class CLILogger {
-    constructor({ logLogo }: {
+    private silent;
+    constructor({ logLogo, silent, }: {
         logLogo: boolean;
+        silent?: boolean;
     });
     primary(message: string): void;
     success(message: string): void;
@@ -9,6 +11,7 @@ export declare class CLILogger {
     error(message: string): void;
     warn(message: string): void;
     debug(message: string): void;
+    timing(message: string): void;
     private logPikkuLogo;
 }
 export declare const getFileImportRelativePath: (from: string, to: string, packageMappings: Record<string, string>) => string;
@@ -36,6 +39,7 @@ export interface PikkuCLIOptions {
     tags?: string[];
     types?: string[];
     directories?: string[];
+    silent?: boolean;
 }
 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;

package/dist/src/utils.js

@@ -13,19 +13,27 @@ const logo = `
 |_|    |_|_| \_)_| \_)____/ 
 `;
 export class CLILogger {
-    constructor({ logLogo }) {
-        if (logLogo) {
+    silent;
+    constructor({ logLogo, silent = false, }) {
+        this.silent = silent;
+        if (logLogo && !silent) {
             this.logPikkuLogo();
         }
     }
     primary(message) {
-        console.log(chalk.green(message));
+        if (!this.silent) {
+            console.log(chalk.green(message));
+        }
     }
     success(message) {
-        console.log(chalk.green(message));
+        if (!this.silent) {
+            console.log(chalk.green(message));
+        }
     }
     info(message) {
-        console.log(chalk.blue(message));
+        if (!this.silent) {
+            console.log(chalk.blue(message));
+        }
     }
     error(message) {
         console.error(chalk.red(message));
@@ -34,10 +42,13 @@ export class CLILogger {
         console.error(chalk.yellow(message));
     }
     debug(message) {
-        if (process.env.DEBUG) {
+        if (process.env.DEBUG && !this.silent) {
             console.log(chalk.gray(message));
         }
     }
+    timing(message) {
+        console.log(chalk.gray(message));
+    }
     logPikkuLogo() {
         this.primary(logo);
         const packageJson = JSON.parse(readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^3.0.2",
-    "@pikku/core": "^0.9.0",
-    "@pikku/inspector": "^0.9.0",
+    "@pikku/core": "^0.9.1",
+    "@pikku/inspector": "^0.9.1",
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.4.1",

package/src/utils.ts

@@ -17,20 +17,35 @@ const logo = `
 `
 
 export class CLILogger {
-  constructor({ logLogo }: { logLogo: boolean }) {
-    if (logLogo) {
+  private silent: boolean
+
+  constructor({
+    logLogo,
+    silent = false,
+  }: {
+    logLogo: boolean
+    silent?: boolean
+  }) {
+    this.silent = silent
+    if (logLogo && !silent) {
       this.logPikkuLogo()
     }
   }
 
   primary(message: string) {
-    console.log(chalk.green(message))
+    if (!this.silent) {
+      console.log(chalk.green(message))
+    }
   }
   success(message: string) {
-    console.log(chalk.green(message))
+    if (!this.silent) {
+      console.log(chalk.green(message))
+    }
   }
   info(message: string) {
-    console.log(chalk.blue(message))
+    if (!this.silent) {
+      console.log(chalk.blue(message))
+    }
   }
   error(message: string) {
     console.error(chalk.red(message))
@@ -39,11 +54,15 @@ export class CLILogger {
     console.error(chalk.yellow(message))
   }
   debug(message: string) {
-    if (process.env.DEBUG) {
+    if (process.env.DEBUG && !this.silent) {
       console.log(chalk.gray(message))
     }
   }
 
+  timing(message: string) {
+    console.log(chalk.gray(message))
+  }
+
   private logPikkuLogo() {
     this.primary(logo)
     const packageJson = JSON.parse(
@@ -129,6 +148,7 @@ export interface PikkuCLIOptions {
   tags?: string[]
   types?: string[]
   directories?: string[]
+  silent?: boolean
 }
 
 const getMetaTypes = (

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

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

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

@@ -1,9 +0,0 @@
-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 { channelsWiringFile, channelsWiringMetaFile, packageMappings } = cliConfig;
-        const { channels } = visitState;
-        await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsWiringMetaFile, `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

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

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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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 { channelsWiringFile, channelsWiringMetaFile, packageMappings } = cliConfig;
-        const { channels } = visitState;
-        await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsWiringMetaFile, `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

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

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

@@ -1,15 +0,0 @@
-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/events/channels/serialize-typed-channel-map.d.ts

@@ -1,4 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, channelsMeta: ChannelsMeta) => string;

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

@@ -1,111 +0,0 @@
-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 }) => {
-        for (const reference of references) {
-            requiredTypes.add(reference);
-        }
-    });
-    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for TypeScript to be aware of channels
- */
-    
-${imports}
-${serializedCustomTypes}
-
-interface ChannelHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${channels}
-
-export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
-    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-
-export type ChannelRouteHandlerOf<
-    Channel extends keyof ChannelsMap, 
-    Route extends keyof ChannelsMap[Channel]['routes'], 
-    Method extends keyof ChannelsMap[Channel]['routes'][Route],
-> =
-    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-`;
-};
-function generateChannels(functionsMeta, channelsMeta) {
-    const requiredTypes = new Set();
-    const channelsObject = {};
-    for (const meta of Object.values(channelsMeta)) {
-        const { name, messageWirings, message } = meta;
-        if (!channelsObject[name]) {
-            channelsObject[name] = { message: null, routes: {} };
-        }
-        if (message) {
-            const func = functionsMeta[message.pikkuFuncName];
-            if (!func) {
-                throw new Error(`Function ${message.pikkuFuncName} not found in functionsMeta for channel ${name}`);
-            }
-            const inputTypes = func.inputs || null;
-            const outputTypes = func.outputs || null;
-            channelsObject[name].message = {
-                inputs: inputTypes,
-                outputs: outputTypes,
-            };
-            inputTypes?.forEach((type) => requiredTypes.add(type));
-            outputTypes?.forEach((type) => requiredTypes.add(type));
-        }
-        for (const [key, route] of Object.entries(messageWirings)) {
-            if (!channelsObject[name].routes[key]) {
-                channelsObject[name].routes[key] = {};
-            }
-            for (const [method, { pikkuFuncName }] of Object.entries(route)) {
-                const func = functionsMeta[pikkuFuncName];
-                if (!func) {
-                    throw new Error(`Function ${pikkuFuncName} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
-                }
-                const inputTypes = func.inputs || null;
-                const outputTypes = func.outputs || null;
-                channelsObject[name].routes[key][method] = {
-                    inputTypes,
-                    outputTypes,
-                };
-                inputTypes?.forEach((type) => requiredTypes.add(type));
-                outputTypes?.forEach((type) => requiredTypes.add(type));
-            }
-        }
-    }
-    let routesStr = 'export type ChannelsMap = {\n';
-    for (const [channelPath, { routes, message }] of Object.entries(channelsObject)) {
-        routesStr += `  readonly '${channelPath}': {\n`;
-        // Add `routes` object
-        routesStr += `    readonly routes: {\n`;
-        for (const [key, methods] of Object.entries(routes)) {
-            routesStr += `      readonly ${key}: {\n`;
-            for (const [method, handler] of Object.entries(methods)) {
-                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes) || 'void'}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
-            }
-            routesStr += '      },\n';
-        }
-        routesStr += '    },\n';
-        // Add `defaultMessage` outside `routes`
-        if (message) {
-            routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
-        }
-        else {
-            routesStr += `    readonly defaultMessage: never,\n`;
-        }
-        routesStr += '  },\n';
-    }
-    routesStr += '};';
-    return { channels: routesStr, requiredTypes };
-}
-// Utility to format type arrays
-function formatTypeArray(types) {
-    return types ? types.join(' | ') : 'null';
-}

package/dist/src/events/channels/serialize-websocket-wrapper.d.ts

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

package/dist/src/events/channels/serialize-websocket-wrapper.js

@@ -1,75 +0,0 @@
-export const serializeWebsocketWrapper = (channelsMapPath) => {
-    return `import { CorePikkuWebsocket, CorePikkuRouteHandler } from '@pikku/websocket'
-import { ChannelDefaultHandlerOf, ChannelRouteHandlerOf, ChannelsMap } from '${channelsMapPath}';
-
-class PikkuWebSocketRoute<Channel extends keyof ChannelsMap, Route extends keyof ChannelsMap[Channel]['routes']> extends CorePikkuRouteHandler {
-    public subscribe<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
-    >(method: Method, callback: (data: Data) => void
-    ) {
-        super.subscribe(method.toString(), callback)
-    }
-
-    public unsubscribe<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['output']
-    >(method: Method, callback?: (data: Data) => void) {
-        super.unsubscribe(method.toString(), callback)
-    }
-
-    public send<
-        Method extends keyof ChannelsMap[Channel]['routes'][Route],
-        Data extends ChannelRouteHandlerOf<Channel, Route, Method>['input']
-    >(method: Method, data: Data) {
-        super.send(method.toString(), data)
-    }
-}
-
-export class PikkuWebSocket<Channel extends keyof ChannelsMap, Topics extends Record<string, any> = {}> extends CorePikkuWebsocket {
-    /**
-     * Send a message to a specific route and method.
-     * Validates the input data type.
-     */
-    public getRoute<Route extends keyof ChannelsMap[Channel]['routes']>(route: Route): PikkuWebSocketRoute<Channel, Route> {
-        return super.getRoute(route)
-    }
-
-    /**
-     * Subscribe to a specific route and method.
-     */
-    public subscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
-        callback: (data: Data) => void
-    ) {
-        super.subscribe(callback)
-    }
-
-    /**
-     * Subscribe to a specific route and method.
-     */
-    public unsubscribe<Data extends ChannelDefaultHandlerOf<Channel>['output']>(
-        callback?: (data: Data) => void
-    ) {
-        super.unsubscribe(callback)
-    }
-
-    public send(data: ChannelDefaultHandlerOf<Channel>['input']) {
-        super.send(data)
-    }
-
-    /**
-     * Subscribe to a topic from the EventHub system with strong typing.
-     */
-    public subscribeToEventHub<Topic extends keyof EventHubTopics>(
-        topic: Topic,
-        callback: (data: EventHubTopics[Topic]) => void
-    ) {
-        super.subscribe((data) => {
-            if (data.topic === topic) {
-                callback(data as EventHubTopics[Topic])
-            }
-        })
-    }
-}
-  `;
-};

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

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

package/dist/src/events/fetch/index.js

@@ -1,12 +0,0 @@
-import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuFetch = async (logger, { fetchFile, httpMapDeclarationFile, packageMappings }) => {
-    return await logCommandInfoAndTime(logger, '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, httpMapDeclarationFile, packageMappings);
-        const content = [serializeFetchWrapper(routesMapDeclarationPath)];
-        await writeFileInDir(logger, fetchFile, content.join('\n'));
-    });
-};

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

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

package/dist/src/events/functions/pikku-command-function-types.js

@@ -1,13 +0,0 @@
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-import { serializePikkuTypes } from '../../serialize-pikku-types.js';
-export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFile, packageMappings, rpcMapDeclarationFile }, visitState, options = {}) => {
-    return await logCommandInfoAndTime(logger, 'Creating api types', 'Created api types', [false], async () => {
-        const { userSessionType, sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, packageMappings, typesFile, options, {
-            userSessionType: true,
-            sessionServiceType: true,
-            singletonServicesType: true,
-        });
-        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`);
-        await writeFileInDir(logger, typesFile, content);
-    });
-};

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

@@ -1,6 +0,0 @@
-import { PikkuCommand } from '../../types.js';
-export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
-    path: string;
-    exportedName: string;
-}>, packageMappings?: Record<string, string>) => string;
-export declare const pikkuFunctions: PikkuCommand;

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

@@ -1,35 +0,0 @@
-import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const serializeFunctionImports = (outputPath, functionsMap, packageMappings = {}) => {
-    const serializedImports = [
-        `/* Import and register RPCs */`,
-        `import { addFunction } from '@pikku/core'`,
-    ];
-    const serializedRegistrations = [];
-    // Sort by function name for consistent output
-    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
-    for (const [name, { path, exportedName }] of sortedEntries) {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        // For directly exported functions, we can just import and register them
-        if (name === exportedName) {
-            serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-        }
-        // For renamed functions, we need to import and alias them
-        else {
-            serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            serializedRegistrations.push(`addFunction('${name}', ${name})`);
-        }
-    }
-    // Add a blank line between imports and registrations
-    if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
-        serializedImports.push('');
-    }
-    // Combine the imports and registrations
-    return [...serializedImports, ...serializedRegistrations].join('\n');
-};
-export const pikkuFunctions = async (logger, { functionsMetaFile, functionsFile, packageMappings }, { functions }) => {
-    return await logCommandInfoAndTime(logger, 'Serializing Pikku functions', 'Serialized Pikku functions', [false], async () => {
-        await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, functions.files, packageMappings));
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
-    });
-};

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

@@ -1,3 +0,0 @@
-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;