@pikku/cli 0.9.15 → 0.9.16-next.0

package/dist/src/functions/wirings/fetch/index.js

@@ -0,0 +1,24 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
+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';
+export const pikkuFetch = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { fetchFile, httpMapDeclarationFile, packageMappings } = config;
+        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'));
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating fetch wrapper',
+            commandEnd: 'Generated fetch wrapper',
+            skipCondition: ({ config }) => config.fetchFile === undefined,
+            skipMessage: "fetchFile isn't set in the pikku config",
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuFunctionTypesSplit: any;

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

@@ -0,0 +1,32 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeFunctionTypes } from './serialize-function-types.js';
+export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { functionTypesFile, packageMappings, rpcInternalMapDeclarationFile, } = config;
+        // Check for required types
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
+            userSessionType: true,
+            sessionServiceType: true,
+            singletonServicesType: true,
+        });
+        const { userSessionType, sessionServicesType, singletonServicesType } = visitState.filesAndMethods;
+        if (!userSessionType || !sessionServicesType || !singletonServicesType) {
+            throw new Error('Required types not found');
+        }
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, sessionServicesType.typePath, packageMappings)}'`, sessionServicesType.type, `import type { TypedPikkuRPC } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`);
+        await writeFileInDir(logger, functionTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating function types',
+            commandEnd: 'Created function types',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuFunctionTypes: any;

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

@@ -0,0 +1,20 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
+import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
+export const pikkuFunctionTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        await writeFileInDir(logger, typesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating api types hub',
+            commandEnd: 'Created api types hub',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuFunctions: any;

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

@@ -0,0 +1,28 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { generateRuntimeMeta, serializeFunctionImports, } from './serialize-function-imports.js';
+export const pikkuFunctions = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { functions, rpc } = await getInspectorState();
+        const { functionsMetaFile, functionsMetaMinFile, functionsFile, packageMappings, } = config;
+        // Generate full metadata
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`);
+        // Generate minimal metadata (runtime)
+        const runtimeMeta = generateRuntimeMeta(functions.meta);
+        await writeFileInDir(logger, functionsMetaMinFile, `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(runtimeMeta, null, 2)})`);
+        const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
+        if (hasRPCs) {
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, rpc.internalFiles, functions.meta, packageMappings));
+        }
+        return hasRPCs;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Serializing Pikku functions',
+            commandEnd: 'Serialized Pikku functions',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

package/dist/src/{wirings → functions/wirings}/functions/pikku-command-services.d.ts

@@ -1,3 +1,2 @@
-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;
+export declare const pikkuServices: any;

package/dist/src/{wirings → functions/wirings}/functions/pikku-command-services.js

@@ -1,4 +1,8 @@
-import { getFileImportRelativePath, getPikkuFilesAndMethods, logCommandInfoAndTime, writeFileInDir, } from '../../utils.js';
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 export const serializeServicesMap = (functionsMetaData, middlewareServices = [], servicesImport, sessionServicesImport) => {
     // Extract all unique services from all functions
     const usedServices = new Set();
@@ -59,15 +63,28 @@ export const serializeServicesMap = (functionsMetaData, middlewareServices = [],
     ].join('\n');
     return code;
 };
-export const pikkuServices = async (logger, cliConfig, visitState) => {
-    return await logCommandInfoAndTime(logger, 'Generating Pikku services map', 'Generated Pikku services map', [false], async () => {
-        const { sessionServicesType, singletonServicesType } = await getPikkuFilesAndMethods(logger, visitState, cliConfig.packageMappings, cliConfig.typesDeclarationFile, {}, {
+export const pikkuServices = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        // Check for required types
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
             sessionServiceType: true,
             singletonServicesType: true,
         });
-        const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, singletonServicesType.typePath, cliConfig.packageMappings)}'`;
-        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(cliConfig.typesDeclarationFile, sessionServicesType.typePath, cliConfig.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.functions.meta, cliConfig.middlewareServices, servicesImport, sessionServicesImport);
-        await writeFileInDir(logger, cliConfig.servicesFile, servicesCode);
-    });
-};
+        const { sessionServicesType, singletonServicesType } = visitState.filesAndMethods;
+        if (!sessionServicesType || !singletonServicesType) {
+            throw new Error('Required types not found: sessionServicesType or singletonServicesType');
+        }
+        const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`;
+        const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`;
+        const servicesCode = serializeServicesMap(visitState.functions.meta, config.middlewareServices, servicesImport, sessionServicesImport);
+        await writeFileInDir(logger, config.servicesFile, servicesCode);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Pikku services map',
+            commandEnd: 'Generated Pikku services map',
+            skipMessage: '',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuFunctionTypes: any;

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

@@ -0,0 +1,20 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
+import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
+export const pikkuFunctionTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, } = config;
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getFileImportRelativePath(typesFile, httpTypesFile, packageMappings), getFileImportRelativePath(typesFile, channelsTypesFile, packageMappings), getFileImportRelativePath(typesFile, schedulersTypesFile, packageMappings), getFileImportRelativePath(typesFile, queueTypesFile, packageMappings), getFileImportRelativePath(typesFile, mcpTypesFile, packageMappings), getFileImportRelativePath(typesFile, cliTypesFile, packageMappings));
+        await writeFileInDir(logger, typesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating api types hub',
+            commandEnd: 'Created api types hub',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

package/dist/src/functions/wirings/functions/schemas.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generate JSON schemas from TypeScript types
+ */
+export declare const pikkuSchemas: any;

package/dist/src/functions/wirings/functions/schemas.js

@@ -0,0 +1,22 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { saveSchemas, generateSchemas, } from '../../../utils/schema-generator.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+/**
+ * Generate JSON schemas from TypeScript types
+ */
+export const pikkuSchemas = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const schemas = await generateSchemas(logger, config.tsconfig, visitState.functions.typesMap, visitState.functions.meta, visitState.http.meta, config.schemasFromTypes);
+        await saveSchemas(logger, config.schemaDirectory, schemas, visitState.functions.typesMap, visitState.functions.meta, config.supportsImportAttributes, config.schemasFromTypes);
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating schemas',
+            commandEnd: 'Generated schemas',
+            skipCondition: false,
+            skipMessage: '',
+        }),
+    ],
+});

package/dist/src/{wirings → functions/wirings}/functions/serialize-function-imports.js

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath } from '../../utils.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
@@ -9,33 +9,16 @@ export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta
     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);
-        // Find the function metadata to check if it's a direct function
-        // The functionsMeta is keyed by the function name (exported name)
-        const funcMeta = functionsMeta[name];
-        const isDirectFunction = funcMeta?.isDirectFunction ?? false;
+        // pikkuFunc/pikkuSessionlessFunc/pikkuVoidFunc always return config objects
         // For directly exported functions, we can just import and register them
         if (name === exportedName) {
             serializedImports.push(`import { ${exportedName} } from '${filePath}'`);
-            if (isDirectFunction) {
-                // Direct function: pikkuFunc(fn) - needs to be wrapped
-                serializedRegistrations.push(`addFunction('${name}', { func: ${exportedName} })`);
-            }
-            else {
-                // Object format: pikkuFunc({ func: fn }) - can be used directly
-                serializedRegistrations.push(`addFunction('${name}', ${exportedName} as any) // TODO`);
-            }
+            serializedRegistrations.push(`addFunction('${name}', ${exportedName})`);
         }
         // For renamed functions, we need to import and alias them
         else {
             serializedImports.push(`import { ${exportedName} as ${name} } from '${filePath}'`);
-            if (isDirectFunction) {
-                // Direct function: pikkuFunc(fn) - needs to be wrapped
-                serializedRegistrations.push(`addFunction('${name}', { func: ${name} })`);
-            }
-            else {
-                // Object format: pikkuFunc({ func: fn }) - can be used directly
-                serializedRegistrations.push(`addFunction('${name}', ${name} as any) // TODO`);
-            }
+            serializedRegistrations.push(`addFunction('${name}', ${name})`);
         }
     }
     // Add a blank line between imports and registrations

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

@@ -0,0 +1,4 @@
+/**
+ * Generates core function, middleware, and permission type definitions
+ */
+export declare const serializeFunctionTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, sessionServicesTypeName: string, rpcMapTypeImport: string) => string;

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

@@ -0,0 +1,295 @@
+/**
+ * Generates core function, middleware, and permission type definitions
+ */
+export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, sessionServicesTypeImport, sessionServicesTypeName, rpcMapTypeImport) => {
+    return `/**
+ * This file was generated by the @pikku/cli
+ * Core function, middleware, and permission types for all wirings
+ */
+
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
+import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
+import { PikkuChannel, PikkuMCP } from '@pikku/core'
+
+${userSessionTypeImport}
+${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.
+ *
+ * @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 Services = Services> = CorePikkuPermission<In, RequiredServices, Session>
+
+/**
+ * Type-safe middleware definition that can access your application's services and session.
+ * Use this to define reusable middleware that can be applied to multiple wirings.
+ *
+ * @template RequiredServices - The services required for this middleware
+ */
+export 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
+}
+
+/**
+ * Factory function for creating middleware factories
+ * Use this when your middleware needs configuration/input parameters
+ *
+ * @example
+ * \`\`\`typescript
+ * export const logMiddleware = pikkuMiddlewareFactory<LogOptions>(({
+ *   message,
+ *   level = 'info'
+ * }) => {
+ *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *     logger[level](message)
+ *     await next()
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuMiddlewareFactory = <In = any>(
+  factory: (input: In) => PikkuMiddleware
+): ((input: In) => PikkuMiddleware) => {
+  return factory
+}
+
+/**
+ * A sessionless API function that doesn't require user authentication.
+ * Use this for public endpoints, health checks, or operations that don't need user context.
+ *
+ * @template In - The input type
+ * @template Out - The output type that the function returns
+ * @template ChannelData - Channel data type (null = optional channel)
+ * @template MCPData - MCP data type (null = optional MCP)
+ * @template RequiredServices - Services required by this function
+ */
+export type PikkuFunctionSessionless<
+  In = unknown,
+  Out = never,
+  ChannelData = null,  // null means optional channel
+  MCPData = null, // null means optional MCP
+  RequiredServices extends Services = Services &
+    { rpc: TypedPikkuRPC } & (
+    [ChannelData] extends [null]
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  ) & ([MCPData] extends [null]
+    ? { mcp?: PikkuMCP }  // Optional MCP
+    : { mcp: PikkuMCP }  // Required MCP
+  )
+> = CorePikkuFunctionSessionless<In, Out, ChannelData, RequiredServices, Session>
+
+/**
+ * A session-aware API function that requires user authentication.
+ * Use this for protected endpoints that need access to user session data.
+ *
+ * @template In - The input type
+ * @template Out - The output type that the function returns
+ * @template ChannelData - Channel data type (null = optional channel)
+ * @template MCPData - MCP data type (null = optional MCP)
+ * @template RequiredServices - Services required by this function
+ */
+export type PikkuFunction<
+  In = unknown,
+  Out = never,
+  ChannelData = null,  // null means optional channel
+  MCPData = null, // null means optional MCP
+  RequiredServices extends Services = Omit<Services, 'rpc'> &
+    { rpc: TypedPikkuRPC } & (
+    [ChannelData] extends [null]
+      ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
+      : { channel: PikkuChannel<ChannelData, Out> }  // Required channel with any data type
+  ) & ([MCPData] extends [null]
+    ? { mcp?: PikkuMCP }  // Optional MCP
+    : { mcp: PikkuMCP }  // Required MCP
+  )
+> = CorePikkuFunction<In, Out, ChannelData, RequiredServices, Session>
+
+/**
+ * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
+ * This type wraps CorePikkuFunctionConfig with the user's custom types.
+ *
+ * @template In - The input type
+ * @template Out - The output type
+ * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
+ */
+export type PikkuFunctionConfig<
+  In = unknown,
+  Out = unknown,
+  PikkuFunc extends PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out> = PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out>
+> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
+
+/**
+ * Creates a Pikku function that can be either session-aware or sessionless.
+ * This is the main function wrapper for creating API endpoints.
+ *
+ * @template In - Input type for the function
+ * @template Out - Output type for the function
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
+ *   func: async ({db, logger}, input) => {
+ *     logger.info('Creating user', input.name)
+ *     const user = await db.users.create(input)
+ *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
+ *   },
+ *   auth: true
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunction<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a sessionless Pikku function that doesn't require user authentication.
+ * Use this for public endpoints, webhooks, or background tasks.
+ *
+ * @template In - Input type for the function
+ * @template Out - Output type for the function
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
+ *   func: async ({logger}) => {
+ *     logger.info('Health check requested')
+ *     return {status: 'healthy', timestamp: new Date().toISOString()}
+ *   },
+ *   name: 'healthCheck'
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuSessionlessFunc = <In, Out = unknown>(
+  func:
+    | PikkuFunctionSessionless<In, Out>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<In, Out>, PikkuPermission<In>, PikkuMiddleware>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Creates a function that takes no input and returns no output.
+ * Useful for health checks, triggers, or cleanup operations.
+ *
+ * @param func - Function definition, either direct function or configuration object
+ * @returns The normalized configuration object
+ *
+ * @example
+ * \\\`\\\`\\\`typescript
+ * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
+ *     logger.info('Starting cleanup of temporary files')
+ *     await fileSystem.deleteDirectory('/tmp/uploads')
+ *     logger.info('Cleanup completed')
+ * })
+ * \\\`\\\`\\\`
+ */
+export const pikkuVoidFunc = (
+  func:
+    | PikkuFunctionSessionless<void, void>
+    | CorePikkuFunctionConfig<PikkuFunctionSessionless<void, void>, PikkuPermission<void>>
+) => {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param tag - The tag that the middleware should apply to.
+ * @param middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws Error if middleware for the tag already exists.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * \`\`\`
+ */
+export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
+  addMiddlewareCore(tag, middleware as any)
+}
+
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param tag - The tag that the permissions should apply to.
+ * @param permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws Error if permissions for the tag already exist.
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * \`\`\`
+ */
+export const addPermission = <In = unknown>(tag: string, permissions: PikkuPermission<In>[]) => {
+  addPermissionCore(tag, permissions as any)
+}
+`;
+};

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

@@ -0,0 +1,4 @@
+/**
+ * Generates the main pikku-types.gen.ts file as a re-export hub
+ */
+export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string, channelTypesImportPath: string, schedulerTypesImportPath: string, queueTypesImportPath: string, mcpTypesImportPath: string, cliTypesImportPath: string) => string;

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

@@ -0,0 +1,31 @@
+/**
+ * Generates the main pikku-types.gen.ts file as a re-export hub
+ */
+export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath) => {
+    return `/**
+ * This file was generated by the @pikku/cli
+ * Main type export hub - re-exports all wiring-specific types
+ */
+
+// Core function, middleware, and permission types
+export * from '${functionTypesImportPath}'
+
+// HTTP wiring types
+export * from '${httpTypesImportPath}'
+
+// Channel wiring types
+export * from '${channelTypesImportPath}'
+
+// Scheduler wiring types
+export * from '${schedulerTypesImportPath}'
+
+// Queue wiring types
+export * from '${queueTypesImportPath}'
+
+// MCP wiring types
+export * from '${mcpTypesImportPath}'
+
+// CLI wiring types
+export * from '${cliTypesImportPath}'
+`;
+};

package/dist/src/{wirings → functions/wirings}/http/openapi-spec-generator.d.ts

@@ -1,4 +1,5 @@
 import { FunctionsMeta, HTTPWiringsMeta } from '@pikku/core';
+import { CLILogger } from '../../../services/cli-logger.service.js';
 interface OpenAPISpec {
     openapi: string;
     info: {
@@ -75,5 +76,5 @@ export interface OpenAPISpecInfo {
         [key: string]: any[];
     }[];
 }
-export declare function generateOpenAPISpec(functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
+export declare function generateOpenAPISpec(logger: CLILogger, functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo): Promise<OpenAPISpec>;
 export {};

package/dist/src/{wirings → functions/wirings}/http/openapi-spec-generator.js

@@ -34,14 +34,14 @@ const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas)
     }));
     return Object.fromEntries(convertedEntries.filter((s) => !!s));
 };
-export async function generateOpenAPISpec(functionsMeta, httpMeta, schemas, additionalInfo) {
+export async function generateOpenAPISpec(logger, functionsMeta, httpMeta, schemas, additionalInfo) {
     const paths = {};
     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}'.`);
+                logger.error(`• No function metadata found for '${pikkuFuncName}' in route '${route}'.`);
                 continue;
             }
             const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;

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

@@ -0,0 +1 @@
+export declare const pikkuHTTPMap: any;