@pikku/cli 0.11.3 → 0.12.0

package/dist/src/functions/wirings/mcp/pikku-command-mcp-json.js

@@ -1,14 +1,13 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { serializeMCPJson } from './serialize-mcp-json.js';
+import { serializeMCPJson } from '@pikku/inspector';
 export const pikkuMCPJSON = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { mcpEndpoints, functions } = await getInspectorState();
-        const { mcpJsonFile, schemaDirectory } = config;
-        // Generate MCP JSON file
+        const state = await getInspectorState();
+        const { mcpJsonFile } = config;
         if (mcpJsonFile) {
-            const mcpJson = await serializeMCPJson(logger, schemaDirectory, functions.meta, functions.typesMap, mcpEndpoints.resourcesMeta, mcpEndpoints.toolsMeta, mcpEndpoints.promptsMeta);
+            const mcpJson = serializeMCPJson(logger, state);
             await writeFileInDir(logger, mcpJsonFile, mcpJson, {
                 ignoreModifyComment: true,
             });

package/dist/src/functions/wirings/mcp/pikku-command-mcp-types.d.ts

@@ -1 +1 @@
-export declare const pikkuMCPTypes: any;
+export declare const pikkuMCPTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/mcp/pikku-command-mcp.d.ts

@@ -1 +1 @@
-export declare const pikkuMCP: any;
+export declare const pikkuMCP: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/mcp/pikku-command-mcp.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -10,7 +10,16 @@ import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verb
 const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
     if (!inputSchema)
         return [];
-    if (['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(inputSchema)) {
+    if ([
+        'boolean',
+        'string',
+        'number',
+        'null',
+        'undefined',
+        'void',
+        'unknown',
+        'never',
+    ].includes(inputSchema)) {
         return [];
     }
     const uniqueName = typesMap.getUniqueName(inputSchema);
@@ -44,11 +53,11 @@ export const pikkuMCP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { mcpEndpoints, functions } = await getInspectorState();
         const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, schema, } = config;
-        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
+        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
         for (const promptMeta of Object.values(promptsMetaWithArguments)) {
-            const functionMeta = functions.meta[promptMeta.pikkuFuncName];
+            const functionMeta = functions.meta[promptMeta.pikkuFuncId];
             if (functionMeta) {
                 const inputType = functionMeta.inputs?.[0];
                 promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);

package/dist/src/functions/wirings/mcp/serialize-mcp-types.js

@@ -8,10 +8,8 @@ export const serializeMCPTypes = (functionTypesImportPath) => {
 
 import {
   CoreMCPResource,
-  CoreMCPTool,
   CoreMCPPrompt,
   wireMCPResource as wireMCPResourceCore,
-  wireMCPTool as wireMCPToolCore,
   wireMCPPrompt as wireMCPPromptCore,
   MCPResourceResponse,
   MCPToolResponse,
@@ -19,8 +17,9 @@ import {
   AssertMCPResourceURIParams
 } from '@pikku/core/mcp'
 
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, InferZodOutput } from '${functionTypesImportPath}'
-import type { ZodLike } from '@pikku/core'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuMiddleware, PikkuPermission, InferSchemaOutput } from '${functionTypesImportPath}'
+import type { CorePermissionGroup } from '@pikku/core'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**
  * Type definition for MCP resources that provide data to AI models.
@@ -30,13 +29,6 @@ import type { ZodLike } from '@pikku/core'
  */
 type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
 
-/**
- * Type definition for MCP tools that AI models can invoke.
- *
- * @template In - Input type for the tool invocation
- */
-type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse, 'rpc' | 'session' | 'mcp'>>
-
 /**
  * Type definition for MCP prompts that provide templates to AI models.
  *
@@ -58,19 +50,6 @@ export const wireMCPResource = <In, URI extends string>(
   wireMCPResourceCore(mcpResource as any)
 }
 
-/**
- * Registers an MCP tool with the Pikku framework.
- * Tools are functions that AI models can invoke.
- *
- * @template In - Input type for the tool invocation
- * @param mcpTool - MCP tool definition with action function
- */
-export const wireMCPTool = <In>(
-  mcpTool: MCPToolWiring<In>
-) => {
-  wireMCPToolCore(mcpTool as any)
-}
-
 /**
  * Registers an MCP prompt with the Pikku framework.
  * Prompts provide templates that AI models can use.
@@ -87,8 +66,8 @@ export const wireMCPPrompt = <In>(
 /**
  * Configuration for MCP prompt with Zod schema input validation.
  */
-type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+type MCPPromptFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
   name?: string
   input: InputSchema
 }
@@ -105,9 +84,9 @@ type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export function pikkuMCPPromptFunc<InputSchema extends ZodLike>(
+export function pikkuMCPPromptFunc<InputSchema extends StandardSchemaV1>(
   config: MCPPromptFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
 export function pikkuMCPPromptFunc<In>(
   func:
     | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
@@ -123,9 +102,15 @@ export function pikkuMCPPromptFunc(func: any): any {
 /**
  * Configuration for MCP tool with Zod schema input validation.
  */
-type MCPToolFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+type MCPToolFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+  description?: string
+  tags?: string[]
+  title?: string
+  summary?: string
   name?: string
+  middleware?: PikkuMiddleware[]
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
   input: InputSchema
 }
 
@@ -141,15 +126,21 @@ type MCPToolFuncConfigWithSchema<InputSchema extends ZodLike> = {
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export function pikkuMCPToolFunc<InputSchema extends ZodLike>(
+export function pikkuMCPToolFunc<InputSchema extends StandardSchemaV1>(
   config: MCPToolFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
 export function pikkuMCPToolFunc<In>(
   func:
     | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
     | {
       func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
+      description?: string
+      tags?: string[]
+      title?: string
+      summary?: string
       name?: string
+      middleware?: PikkuMiddleware[]
+      permissions?: CorePermissionGroup<PikkuPermission<In>>
     }
 ): PikkuFunctionConfig<In, MCPToolResponse, 'mcp' | 'rpc'>
 export function pikkuMCPToolFunc(func: any): any {
@@ -159,8 +150,8 @@ export function pikkuMCPToolFunc(func: any): any {
 /**
  * Configuration for MCP resource with Zod schema input validation.
  */
-type MCPResourceFuncConfigWithSchema<InputSchema extends ZodLike> = {
-  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+type MCPResourceFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
   name?: string
   input: InputSchema
 }
@@ -177,9 +168,9 @@ type MCPResourceFuncConfigWithSchema<InputSchema extends ZodLike> = {
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export function pikkuMCPResourceFunc<InputSchema extends ZodLike>(
+export function pikkuMCPResourceFunc<InputSchema extends StandardSchemaV1>(
   config: MCPResourceFuncConfigWithSchema<InputSchema>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
 export function pikkuMCPResourceFunc<In>(
   func:
     | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>

package/dist/src/functions/wirings/middleware/pikku-command-middleware.d.ts

@@ -1 +1 @@
-export declare const pikkuMiddleware: any;
+export declare const pikkuMiddleware: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/middleware/pikku-command-middleware.js

@@ -1,48 +1,25 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeMiddlewareImports } from './serialize-middleware-imports.js';
-import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuMiddleware = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { middleware } = state;
-        const { middlewareFile, packageMappings, schema } = config;
+        const { middlewareFile, packageMappings } = config;
         let filesGenerated = false;
-        // Check if there are any middleware groups
         const hasHTTPGroups = state.http.routeMiddleware.size > 0;
         const hasTagGroups = state.middleware.tagMiddleware.size > 0;
-        if (hasHTTPGroups || hasTagGroups) {
-            const metaData = serializeMiddlewareGroupsMeta(state);
-            // Write JSON file
+        const hasDefinitions = Object.keys(state.middleware.definitions).length > 0;
+        const hasChannelMiddleware = state.channelMiddleware.tagMiddleware.size > 0 ||
+            Object.keys(state.channelMiddleware.definitions).length > 0;
+        if (hasHTTPGroups ||
+            hasTagGroups ||
+            hasDefinitions ||
+            hasChannelMiddleware) {
+            const metaData = state.middlewareGroupsMeta;
             await writeFileInDir(logger, config.middlewareGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
-            // Calculate relative path from TS file to JSON file
-            const jsonImportPath = getFileImportRelativePath(config.middlewareGroupsMetaFile, config.middlewareGroupsMetaJsonFile, packageMappings);
-            // Write TypeScript file that imports JSON
-            const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-            const importStatement = supportsImportAttributes
-                ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-                : `import metaData from '${jsonImportPath}'`;
-            const packageNameValue = config.externalPackageName
-                ? `'${config.externalPackageName}'`
-                : 'null';
-            const tsContent = `import { pikkuState } from '@pikku/core'
-${importStatement}
-
-// HTTP middleware groups metadata
-if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
-  pikkuState(${packageNameValue}, 'middleware', 'httpGroupMeta', metaData.httpGroups)
-}
-
-// Tag middleware groups metadata
-if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
-  pikkuState(${packageNameValue}, 'middleware', 'tagGroupMeta', metaData.tagGroups)
-}
-`;
-            await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent);
-            // Always generate middleware imports file when groups exist (even if empty)
-            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
+            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings, state));
             filesGenerated = true;
         }
         return filesGenerated;

package/dist/src/functions/wirings/middleware/serialize-middleware-imports.js

@@ -1,43 +1,38 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-export const serializeMiddlewareImports = (outputPath, middlewareState, httpState, packageMappings = {}, fullState) => {
-    const serializedImports = [];
-    const serializedFactoryCalls = [];
-    // Collect factory imports and calls for HTTP middleware groups
-    const httpFactories = new Map();
-    for (const [, groupMeta] of httpState.routeMiddleware.entries()) {
-        if (groupMeta.exportName && groupMeta.isFactory) {
-            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
-            httpFactories.set(groupMeta.exportName, {
-                exportName: groupMeta.exportName,
-                filePath,
-            });
-        }
-    }
-    // Collect factory imports and calls for tag middleware groups
-    const tagFactories = new Map();
-    for (const [, groupMeta] of middlewareState.tagMiddleware.entries()) {
+const collectFactories = (groupMap, outputPath, packageMappings) => {
+    const factories = new Map();
+    for (const [, groupMeta] of groupMap.entries()) {
         if (groupMeta.exportName && groupMeta.isFactory) {
             const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
-            tagFactories.set(groupMeta.exportName, {
+            factories.set(groupMeta.exportName, {
                 exportName: groupMeta.exportName,
                 filePath,
             });
         }
     }
-    // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
-    const allFactories = new Map([...httpFactories, ...tagFactories]);
-    // Add factory imports and calls
+    return factories;
+};
+export const serializeMiddlewareImports = (outputPath, middlewareState, httpState, packageMappings = {}, fullState) => {
+    const serializedImports = [];
+    const serializedFactoryCalls = [];
+    const httpFactories = collectFactories(httpState.routeMiddleware, outputPath, packageMappings);
+    const tagFactories = collectFactories(middlewareState.tagMiddleware, outputPath, packageMappings);
+    const channelMiddlewareFactories = fullState
+        ? collectFactories(fullState.channelMiddleware.tagMiddleware, outputPath, packageMappings)
+        : new Map();
+    const allFactories = new Map([
+        ...httpFactories,
+        ...tagFactories,
+        ...channelMiddlewareFactories,
+    ]);
     if (allFactories.size > 0) {
         serializedImports.push('/* Call middleware group factories to register at module evaluation */');
-        // Import factories
         for (const [exportName, { filePath }] of allFactories) {
             serializedImports.push(`import { ${exportName} } from '${filePath}'`);
         }
-        // Call factories
         for (const [exportName] of allFactories) {
             serializedFactoryCalls.push(`${exportName}()`);
         }
     }
-    // Return combined output
     return [...serializedImports, ...serializedFactoryCalls].join('\n');
 };

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

@@ -0,0 +1,2 @@
+export declare const pikkuSecretDefinitionTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuVariableDefinitionTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -0,0 +1,30 @@
+import { pikkuVoidFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeSecretDefinitionTypes, serializeVariableDefinitionTypes, } from './serialize-package-types.js';
+export const pikkuSecretDefinitionTypes = pikkuVoidFunc({
+    func: async ({ logger, config }) => {
+        const { secretTypesFile } = config;
+        const content = serializeSecretDefinitionTypes();
+        await writeFileInDir(logger, secretTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Secret definition types',
+            commandEnd: 'Created Secret definition types',
+        }),
+    ],
+});
+export const pikkuVariableDefinitionTypes = pikkuVoidFunc({
+    func: async ({ logger, config }) => {
+        const { variableTypesFile } = config;
+        const content = serializeVariableDefinitionTypes();
+        await writeFileInDir(logger, variableTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating Variable definition types',
+            commandEnd: 'Created Variable definition types',
+        }),
+    ],
+});

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

@@ -1 +1 @@
-export declare const pikkuPackage: any;
+export declare const pikkuPackage: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePackageFactories } from './serialize-package.js';
@@ -7,14 +7,14 @@ export const pikkuPackage = pikkuSessionlessFunc({
         const { externalPackageName, packageMappings, packageFile } = config;
         // Only generate for external packages
         if (!externalPackageName) {
-            logger.info({
+            logger.debug({
                 message: 'Skipping package factories - not an external package (externalPackageName not set)',
                 type: 'skip',
             });
             return false;
         }
         if (!packageFile) {
-            logger.info({
+            logger.debug({
                 message: 'Skipping package factories - packageFile not configured',
                 type: 'skip',
             });

package/dist/src/functions/wirings/package/serialize-package-types.d.ts

@@ -0,0 +1,2 @@
+export declare const serializeSecretDefinitionTypes: () => string;
+export declare const serializeVariableDefinitionTypes: () => string;

package/dist/src/functions/wirings/package/serialize-package-types.js

@@ -0,0 +1,10 @@
+export const serializeSecretDefinitionTypes = () => {
+    return `export { wireSecret } from '@pikku/core/secret'
+export type { CoreSecret, SecretDefinitionMeta, SecretDefinitionsMeta } from '@pikku/core/secret'
+`;
+};
+export const serializeVariableDefinitionTypes = () => {
+    return `export { wireVariable } from '@pikku/core/variable'
+export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/variable'
+`;
+};

package/dist/src/functions/wirings/permissions/pikku-command-permissions.d.ts

@@ -1 +1 @@
-export declare const pikkuPermissions: any;
+export declare const pikkuPermissions: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/permissions/pikku-command-permissions.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePermissionsImports } from './serialize-permissions-imports.js';
@@ -8,12 +8,17 @@ export const pikkuPermissions = pikkuSessionlessFunc({
         const { permissions } = state;
         const { permissionsFile, packageMappings } = config;
         let filesGenerated = false;
-        // Check if there are any permission group factories
+        const hasHTTPGroups = state.http.routePermissions.size > 0;
+        const hasTagGroups = state.permissions.tagPermissions.size > 0;
+        const hasIndividual = Object.keys(state.permissions.definitions).length > 0;
+        if (hasHTTPGroups || hasTagGroups || hasIndividual) {
+            const metaData = state.permissionsGroupsMeta;
+            await writeFileInDir(logger, config.permissionsGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
+            filesGenerated = true;
+        }
         const hasHTTPFactories = Array.from(state.http.routePermissions.values()).some((meta) => meta.exportName && meta.isFactory);
         const hasTagFactories = Array.from(state.permissions.tagPermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasFactories = hasHTTPFactories || hasTagFactories;
-        // Generate permissions imports file if there are factories
-        if (hasFactories) {
+        if (hasHTTPFactories || hasTagFactories) {
             await writeFileInDir(logger, permissionsFile, serializePermissionsImports(permissionsFile, permissions, state.http, packageMappings));
             filesGenerated = true;
         }

package/dist/src/functions/wirings/queue/pikku-command-queue-map.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueMap: any;
+export declare const pikkuQueueMap: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-command-queue-map.js

@@ -1,12 +1,12 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';
 export const pikkuQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { queueWorkers, functions } = await getInspectorState();
+        const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        const content = serializeQueueMap(logger, queueMapDeclarationFile, packageMappings, functions.typesMap, queueWorkers.meta, resolvedIOTypes);
         await writeFileInDir(logger, queueMapDeclarationFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/queue/pikku-command-queue-service.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueService: any;
+export declare const pikkuQueueService: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-command-queue-service.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -8,7 +8,7 @@ export const pikkuQueueService = pikkuSessionlessFunc({
         const { queueWiringsFile, queueMapDeclarationFile, packageMappings } = config;
         // If queueWiringsFile is not set, clean up any existing file and return
         if (!queueWiringsFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating queue service wrapper since queueWiringsFile isn't set in the pikku config.",
                 type: 'skip',
             });

package/dist/src/functions/wirings/queue/pikku-command-queue-types.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueTypes: any;
+export declare const pikkuQueueTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/queue/pikku-command-queue.d.ts

@@ -1 +1 @@
-export declare const pikkuQueue: any;
+export declare const pikkuQueue: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-command-queue.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/queue/pikku-queue-map.d.ts

@@ -1 +1 @@
-export declare const pikkuQueueMap: any;
+export declare const pikkuQueueMap: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-queue-map.js

@@ -1,12 +1,12 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';
 export const pikkuQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { queueWorkers, functions } = await getInspectorState();
+        const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        const content = serializeQueueMap(logger, queueMapDeclarationFile, packageMappings, functions.typesMap, queueWorkers.meta, resolvedIOTypes);
         await writeFileInDir(logger, queueMapDeclarationFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/queue/pikku-queue.d.ts

@@ -1 +1 @@
-export declare const pikkuQueue: any;
+export declare const pikkuQueue: import("#pikku").PikkuFunctionConfig<void, boolean, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/queue/pikku-queue.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/queue/serialize-queue-map.d.ts

@@ -1,4 +1,7 @@
 import type { QueueWorkersMeta } from '@pikku/core/queue';
 import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: QueueWorkersMeta) => string;
+import { Logger } from '@pikku/core/services';
+export declare const serializeQueueMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, queueWorkersMeta: QueueWorkersMeta, resolvedIOTypes: Record<string, {
+    inputType: string;
+    outputType: string;
+}>) => string;