@pikku/cli 0.9.5 → 0.9.7

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @pikku/cli
 
+## 0.9.7
+
+### Patch Changes
+
+- 4fd5e19: fix: removing rpcMeta and duplicate imports
+- d1babed: fix: pikkuVoidFunc should use a sessionless function -- Since its used mostly by scheduled tasks
+
+## 0.9.6
+
+### Patch Changes
+
+- 6059c87: refactor: move PikkuPermission to pikkuPermission and same for middleware for api consistency to to improve future features
+- 6db63bb: perf: changing http meta to a lookup map to reduce loops
+- Updated dependencies [6059c87]
+- Updated dependencies [6db63bb]
+- Updated dependencies [74f8634]
+- Updated dependencies [766fef1]
+  - @pikku/inspector@0.9.4
+  - @pikku/core@0.9.6
+
 ## 0.9.5
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -115,7 +115,6 @@ const runAll = async (
   await pikkuRPCInternalMap(logger, cliConfig, visitState)
   await pikkuRPCExposedMap(logger, cliConfig, visitState)
   await pikkuRPCClient(logger, cliConfig)
-  allImports.push(cliConfig.rpcWiringMetaFile)
 
   const schemas = await pikkuSchemas(logger, cliConfig, visitState)
   if (schemas) {
@@ -127,7 +126,7 @@ const runAll = async (
     logger,
     cliConfig,
     cliConfig.bootstrapFiles.rpc,
-    [cliConfig.rpcWiringMetaFile],
+    [],
     schemas
   )
 

package/dist/bin/pikku-all.js

@@ -67,13 +67,12 @@ const runAll = async (logger, cliConfig, options) => {
     await pikkuRPCInternalMap(logger, cliConfig, visitState);
     await pikkuRPCExposedMap(logger, cliConfig, visitState);
     await pikkuRPCClient(logger, cliConfig);
-    allImports.push(cliConfig.rpcWiringMetaFile);
     const schemas = await pikkuSchemas(logger, cliConfig, visitState);
     if (schemas) {
         allImports.push(`${cliConfig.schemaDirectory}/register.gen.ts`);
     }
     // RPC bootstrap is always generated since RPC is always present
-    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [cliConfig.rpcWiringMetaFile], schemas);
+    await generateBootstrapFile(logger, cliConfig, cliConfig.bootstrapFiles.rpc, [], schemas);
     const http = await pikkuHTTP(logger, cliConfig, visitState);
     if (http) {
         await pikkuHTTPMap(logger, cliConfig, visitState);

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

@@ -16,7 +16,6 @@ export interface PikkuCLICoreOutputFiles {
     channelsMapDeclarationFile: string;
     rpcInternalWiringMetaFile: string;
     rpcInternalMapDeclarationFile: string;
-    rpcWiringMetaFile: string;
     rpcMapDeclarationFile: string;
     schedulersWiringFile: string;
     schedulersWiringMetaFile: string;

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

@@ -111,9 +111,6 @@ const _getPikkuCLIConfig = async (configFile = undefined, requiredFields, filter
                 result.rpcInternalMapDeclarationFile = join(internalRPCDirectory, 'pikku-rpc-wirings-map.internal.gen.d.ts');
             }
             // External
-            if (!result.rpcWiringMetaFile) {
-                result.rpcWiringMetaFile = join(externalRPCDirectory, 'pikku-rpc-wirings-meta.gen.ts');
-            }
             if (!result.rpcMapDeclarationFile) {
                 result.rpcMapDeclarationFile = join(externalRPCDirectory, 'pikku-rpc-wirings-map.gen.d.ts');
             }

package/dist/src/schema-generator.js

@@ -12,15 +12,17 @@ export async function generateSchemas(logger, tsconfig, typesMap, functionMeta,
             }
         }
     }
-    for (const { inputTypes } of httpWiringsMeta) {
-        if (inputTypes?.body) {
-            schemasSet.add(inputTypes.body);
-        }
-        if (inputTypes?.query) {
-            schemasSet.add(inputTypes.query);
-        }
-        if (inputTypes?.params) {
-            schemasSet.add(inputTypes.params);
+    for (const wiringRoutes of Object.values(httpWiringsMeta)) {
+        for (const { inputTypes } of Object.values(wiringRoutes)) {
+            if (inputTypes?.body) {
+                schemasSet.add(inputTypes.body);
+            }
+            if (inputTypes?.query) {
+                schemasSet.add(inputTypes.query);
+            }
+            if (inputTypes?.params) {
+                schemasSet.add(inputTypes.params);
+            }
         }
     }
     const generator = createGenerator({

package/dist/src/serialize-import-map.js

@@ -72,11 +72,11 @@ export const serializeImportMap = (relativeToPath, packageMappings, typesMap, re
         if (uniqueName === '__object') {
             return;
         }
-        if (originalName === uniqueName) {
-            variables.push(originalName);
-        }
-        else {
-            variables.push(`${originalName} as ${uniqueName}`);
+        const importName = originalName === uniqueName
+            ? originalName
+            : `${originalName} as ${uniqueName}`;
+        if (!variables.includes(importName)) {
+            variables.push(importName);
         }
         paths.set(path, variables);
     });

package/dist/src/serialize-pikku-types.d.ts

@@ -1,4 +1,4 @@
 /**
  *
  */
-export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, rpcMapTypeImport: string) => string;
+export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, sessionServicesTypeName: string, rpcMapTypeImport: string) => string;

package/dist/src/serialize-pikku-types.js

@@ -1,7 +1,7 @@
 /**
  *
  */
-export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, rpcMapTypeImport) => {
+export const serializePikkuTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, sessionServicesTypeName, rpcMapTypeImport) => {
     return `/**
 * This is used to provide the application types in the typescript project
 */
@@ -19,6 +19,10 @@ ${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
 ${rpcMapTypeImport}
 
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
+${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+
 /**
  * Type-safe API permission definition that integrates with your application's session type.
  * Use this to define authorization logic for your API endpoints.
@@ -26,7 +30,7 @@ ${rpcMapTypeImport}
  * @template In - The input type that the permission check will receive
  * @template RequiredServices - The services required for this permission check
  */
-export type PikkuPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CorePikkuPermission<In, RequiredServices, ${userSessionTypeName}>
+type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, Session>
 
 /**
  * Type-safe middleware definition that can access your application's services and session.
@@ -34,7 +38,38 @@ export type PikkuPermission<In = unknown, RequiredServices extends ${singletonSe
  * 
  * @template RequiredServices - The services required for this middleware
  */
-export type PikkuMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CorePikkuMiddleware<RequiredServices, ${userSessionTypeName}>
+type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
+
+/**
+ * Factory function for creating permissions with tree-shaking support.
+ * This enables the bundler to detect which services your permission actually uses.
+ * 
+ * @example
+ * \`\`\`typescript
+ * const permission = pikkuPermission(({ logger }, data, session) => {
+ *   return session?.isAdmin || false
+ * })
+ * \`\`\`
+ */
+export const pikkuPermission = <In>(func: PikkuPermission<In>) => {
+  return func
+}
+
+/**
+ * Factory function for creating middleware with tree-shaking support.
+ * This enables the bundler to detect which services your middleware actually uses.
+ * 
+ * @example
+ * \`\`\`typescript
+ * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
+ *   logger.info('Middleware executed')
+ *   await next()
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddleware = (func: PikkuMiddleware) => {
+  return func
+}
 
 /**
  * A sessionless API function that doesn't require user authentication.
@@ -60,7 +95,7 @@ type PikkuFunctionSessionless<
     ? { mcp?: PikkuMCP }  // Optional MCP
     : { mcp: PikkuMCP }  // Required MCP
   )
-> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, Session>
 
 /**
  * A session-aware API function that requires user authentication.
@@ -86,7 +121,7 @@ type PikkuFunction<
     ? { mcp?: PikkuMCP }  // Optional MCP
     : { mcp: PikkuMCP }  // Required MCP
   )
-> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, Session>
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -305,7 +340,7 @@ export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unkn
 export const pikkuVoidFunc = (
   func:
     | PikkuFunctionSessionless<void, void>
-    | CorePikkuFunctionConfig<PikkuFunction<void, void>, PikkuPermission<void>>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
 ) => {
   return typeof func === 'function' ? func : func.func
 }
@@ -516,7 +551,7 @@ export const pikkuMCPPromptFunc = <In>(
  *     const results = await fileSystem.search(input.query, input.directory)
  *     return [{
  *         type: 'text',
- *         text: \`Found \${results.length} files matching \"\${input.query}\"\`
+ *         text: \`Found \${results.length} files matching "\${input.query}"\`
  *       }]
  *   }
  * })

package/dist/src/utils.js

@@ -10,7 +10,7 @@ const logo = `
  _____) )| |  _| |  _ _   _ 
 |  ____/ | |_/ ) |_/ ) | | |
 | |    | |  _ (|  _ (| |_| |
-|_|    |_|_| \_)_| \_)____/ 
+|_|    |_|_| _)_| _)____/ 
 `;
 export class CLILogger {
     silent;

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

@@ -7,7 +7,7 @@ export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFi
             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, rpcInternalMapDeclarationFile, packageMappings)}'`);
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`);
         await writeFileInDir(logger, typesFile, content);
     });
 };

package/dist/src/wirings/functions/pikku-function-types.js

@@ -7,7 +7,7 @@ export const pikkuFunctionTypes = async (logger, { typesDeclarationFile: typesFi
             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, rpcInternalMapDeclarationFile, packageMappings)}'`);
+        const content = serializePikkuTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(typesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`);
         await writeFileInDir(logger, typesFile, content);
     });
 };

package/dist/src/wirings/http/openapi-spec-generator.d.ts

@@ -75,5 +75,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, routeMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

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

@@ -10,13 +10,18 @@ const getErrorResponseForConstructorName = (constructorName) => {
     return undefined;
 };
 const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
-    const requiredSchemas = new Set(routesMeta
-        .map(({ inputTypes, pikkuFuncName }) => {
-        const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
-        return [inputTypes?.body, output];
-    })
-        .flat()
-        .filter((schema) => !!schema));
+    const requiredSchemas = new Set();
+    for (const routeMeta of Object.values(routesMeta)) {
+        for (const { inputTypes, pikkuFuncName } of Object.values(routeMeta)) {
+            const output = functionsMeta[pikkuFuncName]?.outputs?.[0];
+            if (inputTypes?.body) {
+                requiredSchemas.add(inputTypes?.body);
+            }
+            if (output) {
+                requiredSchemas.add(output);
+            }
+        }
+    }
     const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
         if (requiredSchemas.has(key)) {
             const convertedSchema = await convertSchema(schema, {
@@ -29,90 +34,92 @@ const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas)
     }));
     return Object.fromEntries(convertedEntries.filter((s) => !!s));
 };
-export async function generateOpenAPISpec(functionsMeta, routeMeta, schemas, additionalInfo) {
+export async function generateOpenAPISpec(functionsMeta, httpMeta, schemas, additionalInfo) {
     const paths = {};
-    routeMeta.forEach((meta) => {
-        const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            console.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
-            return;
-        }
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
-        if (!paths[path]) {
-            paths[path] = {};
-        }
-        const responses = {};
-        docs?.errors?.forEach((error) => {
-            const errorResponse = getErrorResponseForConstructorName(error);
-            if (errorResponse) {
-                responses[errorResponse.status] = {
-                    description: errorResponse.message,
-                };
+    for (const routeMeta of Object.values(httpMeta)) {
+        for (const meta of Object.values(routeMeta)) {
+            const { route, method, inputTypes, pikkuFuncName, params, query, docs } = meta;
+            const functionMeta = functionsMeta[pikkuFuncName];
+            if (!functionMeta) {
+                console.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
+                continue;
             }
-        });
-        const operation = {
-            description: docs?.description ||
-                `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-            tags: docs?.tags || [route.split('/')[1] || 'default'],
-            parameters: [],
-            responses: {
-                ...responses,
-                '200': {
-                    description: 'Successful response',
-                    content: output
-                        ? {
-                            'application/json': {
-                                schema: typeof output === 'string' &&
-                                    ['boolean', 'string', 'number'].includes(output)
-                                    ? { type: output }
-                                    : { $ref: `#/components/schemas/${output}` },
-                            },
-                        }
-                        : undefined,
-                },
-            },
-        };
-        const bodyType = inputTypes?.body;
-        if (bodyType) {
-            operation.requestBody = {
-                required: true,
-                content: {
-                    'application/json': {
-                        schema: typeof bodyType === 'string' &&
-                            ['boolean', 'string', 'number'].includes(bodyType)
-                            ? { type: bodyType }
-                            : { $ref: `#/components/schemas/${bodyType}` },
+            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+            const path = route.replace(/:(\w+)/g, '{$1}'); // Convert ":param" to "{param}"
+            if (!paths[path]) {
+                paths[path] = {};
+            }
+            const responses = {};
+            docs?.errors?.forEach((error) => {
+                const errorResponse = getErrorResponseForConstructorName(error);
+                if (errorResponse) {
+                    responses[errorResponse.status] = {
+                        description: errorResponse.message,
+                    };
+                }
+            });
+            const operation = {
+                description: docs?.description ||
+                    `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+                tags: docs?.tags || [route.split('/')[1] || 'default'],
+                parameters: [],
+                responses: {
+                    ...responses,
+                    '200': {
+                        description: 'Successful response',
+                        content: output
+                            ? {
+                                'application/json': {
+                                    schema: typeof output === 'string' &&
+                                        ['boolean', 'string', 'number'].includes(output)
+                                        ? { type: output }
+                                        : { $ref: `#/components/schemas/${output}` },
+                                },
+                            }
+                            : undefined,
                     },
                 },
             };
+            const bodyType = inputTypes?.body;
+            if (bodyType) {
+                operation.requestBody = {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: typeof bodyType === 'string' &&
+                                ['boolean', 'string', 'number'].includes(bodyType)
+                                ? { type: bodyType }
+                                : { $ref: `#/components/schemas/${bodyType}` },
+                        },
+                    },
+                };
+            }
+            if (params) {
+                operation.parameters = params.map((param) => ({
+                    name: param,
+                    in: 'path',
+                    required: true,
+                    schema: { type: 'string' },
+                }));
+            }
+            if (query) {
+                operation.parameters.push(...query.map((query) => ({
+                    name: query,
+                    in: 'query',
+                    required: false,
+                    schema: { type: 'string' },
+                })));
+            }
+            paths[path][method] = operation;
         }
-        if (params) {
-            operation.parameters = params.map((param) => ({
-                name: param,
-                in: 'path',
-                required: true,
-                schema: { type: 'string' },
-            }));
-        }
-        if (query) {
-            operation.parameters.push(...query.map((query) => ({
-                name: query,
-                in: 'query',
-                required: false,
-                schema: { type: 'string' },
-            })));
-        }
-        paths[path][method] = operation;
-    });
+    }
     return {
         openapi: '3.1.0',
         info: additionalInfo.info,
         servers: additionalInfo.servers,
         paths,
         components: {
-            schemas: await convertSchemasToBodyPayloads(functionsMeta, routeMeta, schemas),
+            schemas: await convertSchemasToBodyPayloads(functionsMeta, httpMeta, schemas),
             responses: {},
             parameters: {},
             examples: {},

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

@@ -34,28 +34,32 @@ export type HTTPWiringsWithMethod<Method extends string> = {
 function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes) {
     // Initialize an object to collect routes
     const routesObj = {};
-    for (const meta of routesMeta) {
-        const { route, method, pikkuFuncName } = meta;
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
+    for (const methods of Object.values(routesMeta)) {
+        for (const meta of Object.values(methods)) {
+            const { route, method, pikkuFuncName } = meta;
+            const functionMeta = functionsMeta[pikkuFuncName];
+            if (!functionMeta) {
+                throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
+            }
+            const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
+            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+            // Initialize the route entry if it doesn't exist
+            if (!routesObj[route]) {
+                routesObj[route] = {};
+            }
+            // Store the input and output types separately for RouteHandler
+            const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
+            const outputType = output
+                ? typesMap.getTypeMeta(output).uniqueName
+                : 'null';
+            requiredTypes.add(inputType);
+            requiredTypes.add(outputType);
+            // Add method entry
+            routesObj[route][method] = {
+                inputType,
+                outputType,
+            };
         }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Initialize the route entry if it doesn't exist
-        if (!routesObj[route]) {
-            routesObj[route] = {};
-        }
-        // Store the input and output types separately for RouteHandler
-        const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-        const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null';
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add method entry
-        routesObj[route][method] = {
-            inputType,
-            outputType,
-        };
     }
     // Build the routes object as a string
     let routesStr = 'export type HTTPWiringsMap = {\n';

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

@@ -1,6 +1,6 @@
 import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
 import { getFileImportRelativePath, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
-export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, rpcInternalMapDeclarationFile, packageMappings, }) => {
+export const pikkuRPCClient = async (logger, { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }) => {
     return await logCommandInfoAndTime(logger, 'Generating RPC wrappers', 'Generated RPC wrappers', [
         rpcWiringsFile === undefined || rpcWiringsFile === null,
         "rpcWiringsFile isn't set in the pikku config",

package/dist/src/wirings/rpc/pikku-command-rpc.js

@@ -1,11 +1,8 @@
 import { logCommandInfoAndTime, writeFileInDir } from '../../utils.js';
-export const pikkuRPC = async (logger, { rpcInternalWiringMetaFile, rpcWiringMetaFile }, { rpc }) => {
+export const pikkuRPC = async (logger, { rpcInternalWiringMetaFile }, { rpc }) => {
     return await logCommandInfoAndTime(logger, 'Finding RPCs tasks', 'Found RPCs', [false], async () => {
         if (rpc.internalFiles.size > 0) {
             await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`);
         }
-        if (rpc.exposedFiles.size > 0) {
-            await writeFileInDir(logger, rpcWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.exposedFiles, null, 2)})`);
-        }
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/cli",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "bin": {
@@ -22,8 +22,8 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.0.2",
-    "@pikku/core": "^0.9.5",
-    "@pikku/inspector": "^0.9.3",
+    "@pikku/core": "^0.9.6",
+    "@pikku/inspector": "^0.9.4",
     "@types/cookie": "^1.0.0",
     "@types/uuid": "^10.0.0",
     "chalk": "^5.5.0",

package/src/pikku-cli-config.ts

@@ -32,7 +32,6 @@ export interface PikkuCLICoreOutputFiles {
   rpcInternalMapDeclarationFile: string
 
   // RPC Exposed
-  rpcWiringMetaFile: string
   rpcMapDeclarationFile: string
 
   // Schedulers
@@ -253,12 +252,6 @@ const _getPikkuCLIConfig = async (
       }
 
       // External
-      if (!result.rpcWiringMetaFile) {
-        result.rpcWiringMetaFile = join(
-          externalRPCDirectory,
-          'pikku-rpc-wirings-meta.gen.ts'
-        )
-      }
       if (!result.rpcMapDeclarationFile) {
         result.rpcMapDeclarationFile = join(
           externalRPCDirectory,

package/src/schema-generator.ts

@@ -22,15 +22,18 @@ export async function generateSchemas(
       }
     }
   }
-  for (const { inputTypes } of httpWiringsMeta) {
-    if (inputTypes?.body) {
-      schemasSet.add(inputTypes.body)
-    }
-    if (inputTypes?.query) {
-      schemasSet.add(inputTypes.query)
-    }
-    if (inputTypes?.params) {
-      schemasSet.add(inputTypes.params)
+
+  for (const wiringRoutes of Object.values(httpWiringsMeta)) {
+    for (const { inputTypes } of Object.values(wiringRoutes)) {
+      if (inputTypes?.body) {
+        schemasSet.add(inputTypes.body)
+      }
+      if (inputTypes?.query) {
+        schemasSet.add(inputTypes.query)
+      }
+      if (inputTypes?.params) {
+        schemasSet.add(inputTypes.params)
+      }
     }
   }
 

package/src/serialize-import-map.ts

@@ -86,10 +86,12 @@ export const serializeImportMap = (
       return
     }
 
-    if (originalName === uniqueName) {
-      variables.push(originalName)
-    } else {
-      variables.push(`${originalName} as ${uniqueName}`)
+    const importName =
+      originalName === uniqueName
+        ? originalName
+        : `${originalName} as ${uniqueName}`
+    if (!variables.includes(importName)) {
+      variables.push(importName)
     }
     paths.set(path, variables)
   })

package/src/serialize-pikku-types.ts

@@ -7,6 +7,7 @@ export const serializePikkuTypes = (
   singletonServicesTypeImport: string,
   singletonServicesTypeName: string,
   sessionServicesTypeImport: string,
+  sessionServicesTypeName: string,
   rpcMapTypeImport: string
 ) => {
   return `/**
@@ -26,6 +27,10 @@ ${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
 ${rpcMapTypeImport}
 
+${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
+${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
+${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+
 /**
  * Type-safe API permission definition that integrates with your application's session type.
  * Use this to define authorization logic for your API endpoints.
@@ -33,7 +38,7 @@ ${rpcMapTypeImport}
  * @template In - The input type that the permission check will receive
  * @template RequiredServices - The services required for this permission check
  */
-export type PikkuPermission<In = unknown, RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CorePikkuPermission<In, RequiredServices, ${userSessionTypeName}>
+type PikkuPermission<In = unknown, RequiredServices extends Services = Services> = CorePikkuPermission<In, RequiredServices, Session>
 
 /**
  * Type-safe middleware definition that can access your application's services and session.
@@ -41,7 +46,38 @@ export type PikkuPermission<In = unknown, RequiredServices extends ${singletonSe
  * 
  * @template RequiredServices - The services required for this middleware
  */
-export type PikkuMiddleware<RequiredServices extends ${singletonServicesTypeName} = ${singletonServicesTypeName}> = CorePikkuMiddleware<RequiredServices, ${userSessionTypeName}>
+type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
+
+/**
+ * Factory function for creating permissions with tree-shaking support.
+ * This enables the bundler to detect which services your permission actually uses.
+ * 
+ * @example
+ * \`\`\`typescript
+ * const permission = pikkuPermission(({ logger }, data, session) => {
+ *   return session?.isAdmin || false
+ * })
+ * \`\`\`
+ */
+export const pikkuPermission = <In>(func: PikkuPermission<In>) => {
+  return func
+}
+
+/**
+ * Factory function for creating middleware with tree-shaking support.
+ * This enables the bundler to detect which services your middleware actually uses.
+ * 
+ * @example
+ * \`\`\`typescript
+ * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
+ *   logger.info('Middleware executed')
+ *   await next()
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddleware = (func: PikkuMiddleware) => {
+  return func
+}
 
 /**
  * A sessionless API function that doesn't require user authentication.
@@ -67,7 +103,7 @@ type PikkuFunctionSessionless<
     ? { mcp?: PikkuMCP }  // Optional MCP
     : { mcp: PikkuMCP }  // Required MCP
   )
-> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, Session>
 
 /**
  * A session-aware API function that requires user authentication.
@@ -93,7 +129,7 @@ type PikkuFunction<
     ? { mcp?: PikkuMCP }  // Optional MCP
     : { mcp: PikkuMCP }  // Required MCP
   )
-> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, ${userSessionTypeName}>
+> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, Session>
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -312,7 +348,7 @@ export const pikkuChannelFunc = <In = unknown, Out = unknown, ChannelData = unkn
 export const pikkuVoidFunc = (
   func:
     | PikkuFunctionSessionless<void, void>
-    | CorePikkuFunctionConfig<PikkuFunction<void, void>, PikkuPermission<void>>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
 ) => {
   return typeof func === 'function' ? func : func.func
 }
@@ -523,7 +559,7 @@ export const pikkuMCPPromptFunc = <In>(
  *     const results = await fileSystem.search(input.query, input.directory)
  *     return [{
  *         type: 'text',
- *         text: \`Found \${results.length} files matching \"\${input.query}\"\`
+ *         text: \`Found \${results.length} files matching "\${input.query}"\`
  *       }]
  *   }
  * })

package/src/utils.ts

@@ -13,7 +13,7 @@ const logo = `
  _____) )| |  _| |  _ _   _ 
 |  ____/ | |_/ ) |_/ ) | | |
 | |    | |  _ (|  _ (| |_| |
-|_|    |_|_| \_)_| \_)____/ 
+|_|    |_|_| _)_| _)____/ 
 `
 
 export class CLILogger {

package/src/wirings/functions/pikku-command-function-types.ts

@@ -43,6 +43,7 @@ export const pikkuFunctionTypes: PikkuCommand = async (
         `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
         singletonServicesType.type,
         `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
+        sessionServicesType.type,
         `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
       )
 

package/src/wirings/functions/pikku-function-types.ts

@@ -43,6 +43,7 @@ export const pikkuFunctionTypes: PikkuCommand = async (
         `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
         singletonServicesType.type,
         `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
+        sessionServicesType.type,
         `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcInternalMapDeclarationFile, packageMappings)}'`
       )
       await writeFileInDir(logger, typesFile, content)

package/src/wirings/http/openapi-spec-generator.ts

@@ -79,15 +79,19 @@ const convertSchemasToBodyPayloads = async (
   routesMeta: HTTPWiringsMeta,
   schemas: Record<string, any>
 ) => {
-  const requiredSchemas = new Set(
-    routesMeta
-      .map(({ inputTypes, pikkuFuncName }) => {
-        const output = functionsMeta[pikkuFuncName]?.outputs?.[0]
-        return [inputTypes?.body, output]
-      })
-      .flat()
-      .filter((schema) => !!schema)
-  )
+  const requiredSchemas = new Set<string>()
+  for (const routeMeta of Object.values(routesMeta)) {
+    for (const { inputTypes, pikkuFuncName } of Object.values(routeMeta)) {
+      const output = functionsMeta[pikkuFuncName]?.outputs?.[0]
+      if (inputTypes?.body) {
+        requiredSchemas.add(inputTypes?.body)
+      }
+      if (output) {
+        requiredSchemas.add(output)
+      }
+    }
+  }
+
   const convertedEntries = await Promise.all(
     Object.entries(schemas).map(async ([key, schema]) => {
       if (requiredSchemas.has(key)) {
@@ -105,103 +109,106 @@ const convertSchemasToBodyPayloads = async (
 
 export async function generateOpenAPISpec(
   functionsMeta: FunctionsMeta,
-  routeMeta: HTTPWiringsMeta,
+  httpMeta: HTTPWiringsMeta,
   schemas: Record<string, any>,
   additionalInfo: OpenAPISpecInfo
 ): Promise<OpenAPISpec> {
   const paths: Record<string, any> = {}
 
-  routeMeta.forEach((meta) => {
-    const { route, method, inputTypes, pikkuFuncName, params, query, docs } =
-      meta
-    const functionMeta = functionsMeta[pikkuFuncName]
-    if (!functionMeta) {
-      console.error(
-        `• No function metadata found for '${pikkuFuncName}' in route '${route}'.`
-      )
-      return
-    }
-    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
+  for (const routeMeta of Object.values(httpMeta)) {
+    for (const meta of Object.values(routeMeta)) {
+      const { route, method, inputTypes, pikkuFuncName, params, query, docs } =
+        meta
+      const functionMeta = functionsMeta[pikkuFuncName]
+      if (!functionMeta) {
+        console.error(
+          `• No function metadata found for '${pikkuFuncName}' in route '${route}'.`
+        )
+        continue
+      }
 
-    const path = route.replace(/:(\w+)/g, '{$1}') // Convert ":param" to "{param}"
+      const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
-    if (!paths[path]) {
-      paths[path] = {}
-    }
+      const path = route.replace(/:(\w+)/g, '{$1}') // Convert ":param" to "{param}"
 
-    const responses = {}
-    docs?.errors?.forEach((error) => {
-      const errorResponse = getErrorResponseForConstructorName(error)
-      if (errorResponse) {
-        responses[errorResponse.status] = {
-          description: errorResponse.message,
-        }
+      if (!paths[path]) {
+        paths[path] = {}
       }
-    })
 
-    const operation: any = {
-      description:
-        docs?.description ||
-        `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
-      tags: docs?.tags || [route.split('/')[1] || 'default'],
-      parameters: [],
-      responses: {
-        ...responses,
-        '200': {
-          description: 'Successful response',
-          content: output
-            ? {
-                'application/json': {
-                  schema:
-                    typeof output === 'string' &&
-                    ['boolean', 'string', 'number'].includes(output)
-                      ? { type: output }
-                      : { $ref: `#/components/schemas/${output}` },
-                },
-              }
-            : undefined,
-        },
-      },
-    }
+      const responses = {}
+      docs?.errors?.forEach((error) => {
+        const errorResponse = getErrorResponseForConstructorName(error)
+        if (errorResponse) {
+          responses[errorResponse.status] = {
+            description: errorResponse.message,
+          }
+        }
+      })
 
-    const bodyType = inputTypes?.body
-    if (bodyType) {
-      operation.requestBody = {
-        required: true,
-        content: {
-          'application/json': {
-            schema:
-              typeof bodyType === 'string' &&
-              ['boolean', 'string', 'number'].includes(bodyType)
-                ? { type: bodyType }
-                : { $ref: `#/components/schemas/${bodyType}` },
+      const operation: any = {
+        description:
+          docs?.description ||
+          `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+        tags: docs?.tags || [route.split('/')[1] || 'default'],
+        parameters: [],
+        responses: {
+          ...responses,
+          '200': {
+            description: 'Successful response',
+            content: output
+              ? {
+                  'application/json': {
+                    schema:
+                      typeof output === 'string' &&
+                      ['boolean', 'string', 'number'].includes(output)
+                        ? { type: output }
+                        : { $ref: `#/components/schemas/${output}` },
+                  },
+                }
+              : undefined,
           },
         },
       }
-    }
 
-    if (params) {
-      operation.parameters = params.map((param) => ({
-        name: param,
-        in: 'path',
-        required: true,
-        schema: { type: 'string' },
-      }))
-    }
+      const bodyType = inputTypes?.body
+      if (bodyType) {
+        operation.requestBody = {
+          required: true,
+          content: {
+            'application/json': {
+              schema:
+                typeof bodyType === 'string' &&
+                ['boolean', 'string', 'number'].includes(bodyType)
+                  ? { type: bodyType }
+                  : { $ref: `#/components/schemas/${bodyType}` },
+            },
+          },
+        }
+      }
 
-    if (query) {
-      operation.parameters.push(
-        ...query.map((query) => ({
-          name: query,
-          in: 'query',
-          required: false,
+      if (params) {
+        operation.parameters = params.map((param) => ({
+          name: param,
+          in: 'path',
+          required: true,
           schema: { type: 'string' },
         }))
-      )
-    }
+      }
 
-    paths[path][method] = operation
-  })
+      if (query) {
+        operation.parameters.push(
+          ...query.map((query) => ({
+            name: query,
+            in: 'query',
+            required: false,
+            schema: { type: 'string' },
+          }))
+        )
+      }
+
+      paths[path][method] = operation
+    }
+  }
 
   return {
     openapi: '3.1.0',
@@ -211,7 +218,7 @@ export async function generateOpenAPISpec(
     components: {
       schemas: await convertSchemasToBodyPayloads(
         functionsMeta,
-        routeMeta,
+        httpMeta,
         schemas
       ),
       responses: {},

package/src/wirings/http/serialize-typed-http-map.ts

@@ -67,33 +67,37 @@ function generateHTTPWirings(
     Record<string, { inputType: string; outputType: string }>
   > = {}
 
-  for (const meta of routesMeta) {
-    const { route, method, pikkuFuncName } = meta
-    const functionMeta = functionsMeta[pikkuFuncName]
-    if (!functionMeta) {
-      throw new Error(
-        `Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`
-      )
-    }
-    const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
-    const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
-
-    // Initialize the route entry if it doesn't exist
-    if (!routesObj[route]) {
-      routesObj[route] = {}
-    }
-
-    // Store the input and output types separately for RouteHandler
-    const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
-    const outputType = output ? typesMap.getTypeMeta(output).uniqueName : 'null'
-
-    requiredTypes.add(inputType)
-    requiredTypes.add(outputType)
-
-    // Add method entry
-    routesObj[route][method] = {
-      inputType,
-      outputType,
+  for (const methods of Object.values(routesMeta)) {
+    for (const meta of Object.values(methods)) {
+      const { route, method, pikkuFuncName } = meta
+      const functionMeta = functionsMeta[pikkuFuncName]
+      if (!functionMeta) {
+        throw new Error(
+          `Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`
+        )
+      }
+      const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined
+      const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
+
+      // Initialize the route entry if it doesn't exist
+      if (!routesObj[route]) {
+        routesObj[route] = {}
+      }
+
+      // Store the input and output types separately for RouteHandler
+      const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null'
+      const outputType = output
+        ? typesMap.getTypeMeta(output).uniqueName
+        : 'null'
+
+      requiredTypes.add(inputType)
+      requiredTypes.add(outputType)
+
+      // Add method entry
+      routesObj[route][method] = {
+        inputType,
+        outputType,
+      }
     }
   }
 

package/src/wirings/rpc/pikku-command-rpc-client.ts

@@ -8,12 +8,7 @@ import { PikkuCommandWithoutState } from '../../types.js'
 
 export const pikkuRPCClient: PikkuCommandWithoutState = async (
   logger,
-  {
-    rpcWiringsFile,
-    rpcMapDeclarationFile,
-    rpcInternalMapDeclarationFile,
-    packageMappings,
-  }
+  { rpcWiringsFile, rpcMapDeclarationFile, packageMappings }
 ) => {
   return await logCommandInfoAndTime(
     logger,

package/src/wirings/rpc/pikku-command-rpc.ts

@@ -3,7 +3,7 @@ import { PikkuCommand } from '../../types.js'
 
 export const pikkuRPC: PikkuCommand = async (
   logger,
-  { rpcInternalWiringMetaFile, rpcWiringMetaFile },
+  { rpcInternalWiringMetaFile },
   { rpc }
 ) => {
   return await logCommandInfoAndTime(
@@ -19,14 +19,6 @@ export const pikkuRPC: PikkuCommand = async (
           `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.internalMeta, null, 2)})`
         )
       }
-
-      if (rpc.exposedFiles.size > 0) {
-        await writeFileInDir(
-          logger,
-          rpcWiringMetaFile,
-          `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.exposedFiles, null, 2)})`
-        )
-      }
     }
   )
 }