@pikku/core 0.9.1 → 0.9.3

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## 0.9.0
 
+## 0.9.3
+
+### Patch Changes
+
+- 9691aba: fix: add-functions should support both functions only and objects
+- 2ab0278: refactor: no longer import ALL functions, only the ones used by rpcs
+- 81005ba: feat: creating a smaller meta file for functions to reduce size
+
+## 0.9.2
+
+### Patch Changes
+
+- 1256238: feat: pikkufunc in types extends function config to include all the different params
+- 6cf8efd: feat: Adding PikkuDocs to function definition
+
+  refactor: renaming APIDocs to PikkuDocs
+
+- d3a9a09: refactor: change addMiddleware to addHTTPMiddleware due to route support'
+
+  chore: export addHTTPMiddleware from pikku-types for consistency
+
+- 840e078: refactor: change APIMiddleware type to PikkuMiddleware
+- 667d23c: feat: adding expose to function config (although it isn't yet wired up)
+- a5905a9: chore: updating all dependencies
+
 ## 0.9.1
 
 ### Patch Changes

package/dist/function/function-runner.d.ts

@@ -1,12 +1,12 @@
-import { CoreServices, CoreUserSession, PikkuFunctionMiddleware } from '../types/core.types.js';
-import { CorePermissionGroup, CorePikkuFunctionConfig } from './functions.types.js';
-export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any>) => void;
+import { CoreServices, CoreUserSession, CorePikkuMiddleware } from '../types/core.types.js';
+import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from './functions.types.js';
+export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any> | CorePikkuFunctionSessionless<any, any> | CorePikkuFunction<any, any>) => void;
 export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, data: In, session?: CoreUserSession) => Promise<Out>;
 export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;
     permissions?: CorePermissionGroup;
-    middleware?: PikkuFunctionMiddleware[];
+    middleware?: CorePikkuMiddleware[];
     coerceDataFromSchema?: boolean;
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -4,6 +4,9 @@ import { verifyPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 export const addFunction = (funcName, funcConfig) => {
+    if (funcConfig instanceof Function) {
+        funcConfig = { func: funcConfig };
+    }
     pikkuState('function', 'functions').set(funcName, funcConfig);
 };
 export const runPikkuFuncDirectly = async (funcName, allServices, data, session) => {
@@ -26,13 +29,13 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
         throw new ForbiddenError(`Function ${funcName} requires authentication even though transport does not`);
     }
     const allServices = await getAllServices();
-    const schemaName = funcMeta.schemaName;
-    if (schemaName) {
+    const inputSchemaName = funcMeta.inputSchemaName;
+    if (inputSchemaName) {
         // Validate request data against the defined schema, if any
-        await validateSchema(allServices.logger, allServices.schema, schemaName, data);
+        await validateSchema(allServices.logger, allServices.schema, inputSchemaName, data);
         // Coerce (top level) query string parameters or date objects if specified by the schema
         if (coerceDataFromSchema) {
-            coerceTopLevelDataFromSchema(schemaName, data);
+            coerceTopLevelDataFromSchema(inputSchemaName, data);
         }
     }
     let permissioned = true;

package/dist/function/functions.types.d.ts

@@ -1,5 +1,5 @@
 import { PikkuChannel } from '../wirings/channel/channel.types.js';
-import type { CoreServices, CoreSingletonServices, CoreUserSession, PikkuFunctionMiddleware } from '../types/core.types.js';
+import type { CoreServices, CoreSingletonServices, CoreUserSession, PikkuDocs, CorePikkuMiddleware } from '../types/core.types.js';
 /**
  * Represents a core API function that performs an operation using core services and a user session.
  *
@@ -35,9 +35,12 @@ export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown |
  */
 export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
-export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any> | CorePikkuFunctionSessionless<any, any>, PikkuPermission extends CorePikkuPermission<any> = CorePikkuPermission<any>> = {
+export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>> = {
+    name?: string;
+    expose?: boolean;
     func: PikkuFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;
-    middleware?: PikkuFunctionMiddleware[];
+    middleware?: CorePikkuMiddleware[];
+    docs?: PikkuDocs;
 };

package/dist/index.d.ts

@@ -22,7 +22,7 @@ export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { wireHTTP, addMiddleware } from './wirings/http/http-runner.js';
+export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';
 export { wireQueueWorker } from './wirings/queue/queue-runner.js';

package/dist/index.js

@@ -22,7 +22,7 @@ export * from './time-utils.js';
 export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { wireHTTP, addMiddleware } from './wirings/http/http-runner.js';
+export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';
 export { wireQueueWorker } from './wirings/queue/queue-runner.js';

package/dist/middleware/auth-apikey.d.ts

@@ -1,4 +1,4 @@
-import { CoreConfig, CoreSingletonServices, CoreUserSession, PikkuMiddleware } from '../types/core.types.js';
+import { CoreConfig, CoreSingletonServices, CoreUserSession, CorePikkuMiddleware } from '../types/core.types.js';
 /**
  * API key middleware that retrieves a session from the 'x-api-key' header using a provided callback.
  *
@@ -12,4 +12,4 @@ export declare const authAPIKey: <SingletonServices extends CoreSingletonService
 } | {
     getSessionForAPIKey: (services: SingletonServices, apiKey: string) => Promise<any>;
     jwt?: false;
-})) => PikkuMiddleware;
+})) => CorePikkuMiddleware;

package/dist/middleware/auth-bearer.d.ts

@@ -1,4 +1,4 @@
-import { CoreConfig, CoreSingletonServices, CoreUserSession, PikkuMiddleware } from '../types/core.types.js';
+import { CoreConfig, CoreSingletonServices, CoreUserSession, CorePikkuMiddleware } from '../types/core.types.js';
 /**
  * Extracts the Bearer token from the Authorization header
  */
@@ -9,4 +9,4 @@ export declare const authBearer: <SingletonServices extends CoreSingletonService
     };
     jwt?: boolean;
     getSession?: (services: SingletonServices, token: string) => Promise<UserSession> | UserSession;
-}) => PikkuMiddleware;
+}) => CorePikkuMiddleware;

package/dist/middleware/auth-cookie.d.ts

@@ -1,5 +1,5 @@
 import { SerializeOptions } from 'cookie';
-import { CoreConfig, CoreSingletonServices, CoreUserSession, PikkuMiddleware } from '../types/core.types.js';
+import { CoreConfig, CoreSingletonServices, CoreUserSession, CorePikkuMiddleware } from '../types/core.types.js';
 import { RelativeTimeInput } from '../time-utils.js';
 /**
  * Cookie middleware that extracts a session from cookies.
@@ -17,4 +17,4 @@ export declare const authCookie: <SingletonServices extends CoreSingletonService
 } | {
     getSessionForCookieValue?: undefined;
     jwt: true;
-})) => PikkuMiddleware;
+})) => CorePikkuMiddleware;

package/dist/middleware/timeout.d.ts

@@ -1,2 +1,2 @@
-import { PikkuMiddleware } from '../types/core.types.js';
-export declare const timeout: (timeout: number) => PikkuMiddleware;
+import { CorePikkuMiddleware } from '../types/core.types.js';
+export declare const timeout: (timeout: number) => CorePikkuMiddleware;

package/dist/middleware-runner.d.ts

@@ -1,5 +1,5 @@
 import { UserSessionService } from './services/user-session-service.js';
-import { CoreSingletonServices, PikkuFunctionMiddleware, PikkuInteraction, PikkuMiddleware } from './types/core.types.js';
+import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware } from './types/core.types.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -17,6 +17,6 @@ import { CoreSingletonServices, PikkuFunctionMiddleware, PikkuInteraction, Pikku
  *   async () => { return await runMain(); }
  * );
  */
-export declare const runMiddleware: <Middleware extends PikkuMiddleware | PikkuFunctionMiddleware = PikkuMiddleware>(services: CoreSingletonServices & {
+export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(services: CoreSingletonServices & {
     userSession?: UserSessionService<any>;
 }, interaction: PikkuInteraction, middlewares: Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;

package/dist/pikku-state.d.ts

@@ -1,10 +1,9 @@
 import { ChannelsMeta, CoreChannel } from './wirings/channel/channel.types.js';
 import { CoreHTTPFunctionWiring, HTTPMethod, HTTPWiringsMeta } from './wirings/http/http.types.js';
-import { FunctionsMeta, PikkuMiddleware } from './types/core.types.js';
+import { FunctionsMeta, CorePikkuMiddleware } from './types/core.types.js';
 import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
 import { CorePikkuFunctionConfig } from './function/functions.types.js';
-import { RPCMeta } from './wirings/rpc/rpc-types.js';
 import { queueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
 import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
 interface PikkuState {
@@ -13,7 +12,7 @@ interface PikkuState {
         functions: Map<string, CorePikkuFunctionConfig<any, any>>;
     };
     rpc: {
-        meta: Record<string, RPCMeta>;
+        meta: Record<string, string>;
         files: Map<string, {
             exportedName: string;
             path: string;
@@ -22,7 +21,7 @@ interface PikkuState {
     http: {
         middleware: Array<{
             route: string;
-            middleware: PikkuMiddleware[];
+            middleware: CorePikkuMiddleware[];
         }>;
         routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>;
         meta: HTTPWiringsMeta;

package/dist/types/core.types.d.ts

@@ -18,14 +18,23 @@ export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
 }
-export type FunctionsMeta = Record<string, {
+export type FunctionRuntimeMeta = {
     pikkuFuncName: string;
-    name?: string;
+    inputSchemaName: string | null;
+    outputSchemaName: string | null;
+    expose?: boolean;
+};
+export type FunctionMeta = FunctionRuntimeMeta & Partial<{
+    name: string;
     services: FunctionServicesMeta;
-    schemaName: string | null;
     inputs: string[] | null;
     outputs: string[] | null;
+    tags: string[];
+    docs: PikkuDocs;
+    isDirectFunction: boolean;
 }>;
+export type FunctionsRuntimeMeta = Record<string, FunctionRuntimeMeta>;
+export type FunctionsMeta = Record<string, FunctionMeta>;
 export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 /**
  * Represents a JSON primitive type which can be a string, number, boolean, null, or undefined.
@@ -89,13 +98,7 @@ export interface PikkuInteraction {
 /**
  * A function that can wrap an interaction and be called before or after
  */
-export type PikkuFunctionMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
-    userSession?: UserSessionService<UserSession>;
-}, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
-/**
- * A function that can wrap an interaction and be called before or after
- */
-export type PikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
+export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
     userSession: UserSessionService<UserSession>;
 }, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
 /**
@@ -123,7 +126,7 @@ export type CreateConfig<Config extends CoreConfig> = (variables?: VariablesServ
 /**
  * Represents the documentation for a route, including summary, description, tags, and errors.
  */
-export type APIDocs = {
+export type PikkuDocs = {
     summary?: string;
     description?: string;
     tags?: string[];

package/dist/wirings/channel/channel.types.d.ts

@@ -1,6 +1,6 @@
 import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import { APIDocs, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../../types/core.types.js';
+import { PikkuDocs, CoreSingletonServices, CreateSessionServices, CorePikkuMiddleware } from '../../types/core.types.js';
 import { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
@@ -18,7 +18,7 @@ export type RunChannelParams<ChannelData> = {
 };
 export interface ChannelMessageMeta {
     pikkuFuncName: string;
-    docs?: APIDocs;
+    docs?: PikkuDocs;
 }
 export interface ChannelMeta {
     name: string;
@@ -31,7 +31,7 @@ export interface ChannelMeta {
     disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
     messageWirings: Record<string, Record<string, ChannelMessageMeta>>;
-    docs?: APIDocs;
+    docs?: PikkuDocs;
     tags?: string[];
 }
 export type ChannelsMeta = Record<string, ChannelMeta>;
@@ -50,7 +50,7 @@ export type CoreChannel<ChannelData, Channel extends string, ChannelConnect = Co
         permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
         auth?: boolean;
     }>>;
-    middleware?: PikkuMiddleware[];
+    middleware?: CorePikkuMiddleware[];
     permissions?: Record<string, PikkuPermission[] | PikkuPermission>;
     auth?: boolean;
     docs?: Partial<{

package/dist/wirings/http/http-runner.d.ts

@@ -1,5 +1,5 @@
 import { CoreHTTPFunctionWiring, RunHTTPWiringOptions, RunHTTPWiringParams, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
-import { PikkuMiddleware } from '../../types/core.types.js';
+import { CorePikkuMiddleware } from '../../types/core.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 /**
  * Registers middleware either globally or for a specific route.
@@ -8,11 +8,11 @@ import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
  * is applied only to that route. Otherwise, if an array is provided, it is treated
  * as global middleware (applied to all routes).
  *
- * @template APIMiddleware The middleware type.
- * @param {APIMiddleware[] | string} routeOrMiddleware - Either a global middleware array or a route pattern string.
- * @param {APIMiddleware[]} [middleware] - The middleware array to apply when a route pattern is specified.
+ * @template PikkuMiddleware The middleware type.
+ * @param {PikkuMiddleware[] | string} routeOrMiddleware - Either a global middleware array or a route pattern string.
+ * @param {PikkuMiddleware[]} [middleware] - The middleware array to apply when a route pattern is specified.
  */
-export declare const addMiddleware: <APIMiddleware extends PikkuMiddleware>(routeOrMiddleware: APIMiddleware[] | string, middleware?: APIMiddleware[]) => void;
+export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(routeOrMiddleware: PikkuMiddleware[] | string, middleware?: PikkuMiddleware[]) => void;
 /**
  * Adds a new route to the global HTTP route registry.
  *
@@ -25,10 +25,10 @@ export declare const addMiddleware: <APIMiddleware extends PikkuMiddleware>(rout
  * @template PikkuFunction Type for the route handler function.
  * @template PikkuFunctionSessionless Type for a sessionless handler.
  * @template PikkuPermissionGroup Type representing required permissions.
- * @template APIMiddleware Middleware type to be used with the route.
- * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, APIMiddleware>} httpWiring - The HTTP wiring configuration object.
+ * @template PikkuMiddleware Middleware type to be used with the route.
+ * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>} httpWiring - The HTTP wiring configuration object.
  */
-export declare const wireHTTP: <In, Out, Route extends string, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, APIMiddleware>(httpWiring: CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, APIMiddleware>) => void;
+export declare const wireHTTP: <In, Out, Route extends string, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, PikkuMiddleware>(httpWiring: CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, PikkuMiddleware>) => void;
 /**
  * Combines the request and response objects into a single HTTP interaction object.
  *

package/dist/wirings/http/http-runner.js

@@ -16,11 +16,11 @@ import { rpcService } from '../rpc/rpc-runner.js';
  * is applied only to that route. Otherwise, if an array is provided, it is treated
  * as global middleware (applied to all routes).
  *
- * @template APIMiddleware The middleware type.
- * @param {APIMiddleware[] | string} routeOrMiddleware - Either a global middleware array or a route pattern string.
- * @param {APIMiddleware[]} [middleware] - The middleware array to apply when a route pattern is specified.
+ * @template PikkuMiddleware The middleware type.
+ * @param {PikkuMiddleware[] | string} routeOrMiddleware - Either a global middleware array or a route pattern string.
+ * @param {PikkuMiddleware[]} [middleware] - The middleware array to apply when a route pattern is specified.
  */
-export const addMiddleware = (routeOrMiddleware, middleware) => {
+export const addHTTPMiddleware = (routeOrMiddleware, middleware) => {
     const middlewareStore = pikkuState('http', 'middleware');
     if (typeof routeOrMiddleware === 'string' && middleware) {
         const route = routeOrMiddleware;
@@ -55,8 +55,8 @@ export const addMiddleware = (routeOrMiddleware, middleware) => {
  * @template PikkuFunction Type for the route handler function.
  * @template PikkuFunctionSessionless Type for a sessionless handler.
  * @template PikkuPermissionGroup Type representing required permissions.
- * @template APIMiddleware Middleware type to be used with the route.
- * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, APIMiddleware>} httpWiring - The HTTP wiring configuration object.
+ * @template PikkuMiddleware Middleware type to be used with the route.
+ * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>} httpWiring - The HTTP wiring configuration object.
  */
 export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState('http', 'meta');
@@ -64,9 +64,7 @@ export const wireHTTP = (httpWiring) => {
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
-    addFunction(routeMeta.pikkuFuncName, {
-        func: httpWiring.func,
-    });
+    addFunction(routeMeta.pikkuFuncName, httpWiring.func);
     const routes = pikkuState('http', 'routes');
     if (!routes.has(httpWiring.method)) {
         routes.set(httpWiring.method, new Map());

package/dist/wirings/http/http.types.d.ts

@@ -1,6 +1,6 @@
 import type { SerializeOptions } from 'cookie';
 import type { PikkuError } from '../../errors/error-handler.js';
-import type { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../../types/core.types.js';
+import type { PikkuDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, CorePikkuMiddleware } from '../../types/core.types.js';
 import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup } from '../../function/functions.types.js';
 type ExtractHTTPWiringParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractHTTPWiringParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
 export type AssertHTTPWiringParams<In, HTTPWiring extends string> = ExtractHTTPWiringParams<HTTPWiring> extends keyof In ? unknown : [
@@ -67,14 +67,14 @@ export type PikkuQuery<T = Record<string, string | undefined>> = Record<string,
  * @template PikkuFunctionSessionless - The sessionless API function type, defaults to `CorePikkuFunctionSessionless`.
  * @template PikkuPermission - The permission function type, defaults to `CorePikkuPermission`.
  */
-export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction = CorePikkuFunction<In, Out>, PikkuFunctionSessionless = CorePikkuFunctionSessionless<In, Out>, PikkuPermission = CorePikkuPermission<In>, APIMiddleware = PikkuMiddleware> = (CoreHTTPFunction & {
+export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction = CorePikkuFunction<In, Out>, PikkuFunctionSessionless = CorePikkuFunctionSessionless<In, Out>, PikkuPermission = CorePikkuPermission<In>, PikkuMiddleware = CorePikkuMiddleware> = (CoreHTTPFunction & {
     route: R;
     method: HTTPMethod;
     func: PikkuFunction;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: true;
     tags?: string[];
-    middleware?: APIMiddleware[];
+    middleware?: PikkuMiddleware[];
     sse?: undefined;
 }) | (CoreHTTPFunction & {
     route: R;
@@ -83,7 +83,7 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction = Co
     permissions?: undefined;
     auth?: false;
     tags?: string[];
-    middleware?: APIMiddleware[];
+    middleware?: PikkuMiddleware[];
     sse?: undefined;
 }) | (CoreHTTPFunction & {
     route: R;
@@ -93,7 +93,7 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction = Co
     auth?: true;
     sse?: boolean;
     tags?: string[];
-    middleware?: APIMiddleware[];
+    middleware?: PikkuMiddleware[];
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'get';
@@ -102,7 +102,7 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction = Co
     auth?: false;
     sse?: boolean;
     tags?: string[];
-    middleware?: APIMiddleware[];
+    middleware?: PikkuMiddleware[];
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'post';
@@ -111,7 +111,7 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction = Co
     auth?: true;
     query?: Array<keyof In>;
     tags?: string[];
-    middleware?: APIMiddleware[];
+    middleware?: PikkuMiddleware[];
     sse?: undefined;
 }) | (CoreHTTPFunction & {
     route: R;
@@ -121,7 +121,7 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction = Co
     auth?: false;
     query?: Array<keyof In>;
     tags?: string[];
-    middleware?: APIMiddleware[];
+    middleware?: PikkuMiddleware[];
     sse?: undefined;
 });
 /**
@@ -142,7 +142,7 @@ export type HTTPWiringMeta = {
     params?: string[];
     query?: string[];
     inputTypes?: HTTPFunctionMetaInputTypes;
-    docs?: APIDocs;
+    docs?: PikkuDocs;
     tags?: string[];
     sse?: true;
 };
@@ -154,7 +154,7 @@ export type HTTPFunctionsMeta = Array<{
 }>;
 export type HTTPWiringMiddleware = {
     route: string;
-    middleware: PikkuMiddleware[];
+    middleware: CorePikkuMiddleware[];
 };
 export interface PikkuHTTPRequest<In = unknown> {
     method(): HTTPMethod;

package/dist/wirings/mcp/mcp-runner.js

@@ -19,9 +19,7 @@ export const wireMCPResource = (mcpResource) => {
     if (!mcpResourceMeta) {
         throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
     }
-    addFunction(mcpResourceMeta.pikkuFuncName, {
-        func: mcpResource.func,
-    });
+    addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func);
     const resources = pikkuState('mcp', 'resources');
     if (resources.has(mcpResource.uri)) {
         throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
@@ -34,9 +32,7 @@ export const wireMCPTool = (mcpTool) => {
     if (!mcpToolMeta) {
         throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`);
     }
-    addFunction(mcpToolMeta.pikkuFuncName, {
-        func: mcpTool.func,
-    });
+    addFunction(mcpToolMeta.pikkuFuncName, mcpTool.func);
     const tools = pikkuState('mcp', 'tools');
     if (tools.has(mcpTool.name)) {
         throw new Error(`MCP tool already exists: ${mcpTool.name}`);
@@ -49,9 +45,7 @@ export const wireMCPPrompt = (mcpPrompt) => {
     if (!mcpPromptMeta) {
         throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`);
     }
-    addFunction(mcpPromptMeta.pikkuFuncName, {
-        func: mcpPrompt.func,
-    });
+    addFunction(mcpPromptMeta.pikkuFuncName, mcpPrompt.func);
     const prompts = pikkuState('mcp', 'prompts');
     if (prompts.has(mcpPrompt.name)) {
         throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`);

package/dist/wirings/queue/queue-runner.js

@@ -20,9 +20,7 @@ export const wireQueueWorker = (queueWorker) => {
         throw new Error(`Queue processor metadata not found for '${queueWorker.queueName}'. Make sure to run the CLI to generate metadata.`);
     }
     // Register the function with pikku
-    addFunction(processorMeta.pikkuFuncName, {
-        func: queueWorker.func,
-    });
+    addFunction(processorMeta.pikkuFuncName, queueWorker.func);
     // Store processor definition in state - runtime adapters will pick this up
     const registrations = pikkuState('queue', 'registrations');
     registrations.set(queueWorker.queueName, queueWorker);

package/dist/wirings/queue/queue.types.d.ts

@@ -1,4 +1,4 @@
-import { APIDocs } from '../../types/core.types.js';
+import { PikkuDocs } from '../../types/core.types.js';
 import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 import { QueueConfigMapping } from './validate-worker-config.js';
 /**
@@ -137,7 +137,7 @@ export type queueWorkersMeta = Record<string, {
     schemaName?: string;
     queueName: string;
     session?: undefined;
-    docs?: APIDocs;
+    docs?: PikkuDocs;
     tags?: string[];
     config?: PikkuWorkerConfig;
 }>;
@@ -148,7 +148,7 @@ export type CoreQueueWorker<PikkuFunction = CorePikkuFunctionSessionless<any, an
     queueName: string;
     func: PikkuFunction;
     config?: PikkuWorkerConfig;
-    docs?: APIDocs;
+    docs?: PikkuDocs;
     session?: undefined;
     tags?: string[];
 };

package/dist/wirings/rpc/rpc-runner.js

@@ -1,6 +1,7 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
-const getRPCMeta = (rpcName) => {
+import { ForbiddenError } from '../../errors/errors.js';
+const getPikkuFunctionName = (rpcName) => {
     const rpc = pikkuState('rpc', 'meta');
     const rpcMeta = rpc[rpcName];
     if (!rpcMeta) {
@@ -16,11 +17,21 @@ class ContextAwareRPCService {
         this.services = services;
         this.options = options;
     }
+    async rpcExposed(funcName, data) {
+        const functionMeta = pikkuState('function', 'meta')[funcName];
+        if (!functionMeta) {
+            throw new Error(`Function not found: ${funcName}`);
+        }
+        if (!functionMeta.expose) {
+            throw new ForbiddenError();
+        }
+        return await this.rpc(funcName, data);
+    }
     async rpc(funcName, data) {
         const session = await this.services.userSession?.get();
         const rpcDepth = this.services.rpc?.depth || 0;
-        const rpcMeta = getRPCMeta(funcName);
-        return runPikkuFunc(rpcMeta.pikkuFuncName, {
+        const pikkuFuncName = getPikkuFunctionName(funcName);
+        return runPikkuFunc(pikkuFuncName, {
             getAllServices: () => {
                 this.services.rpc = this.services.rpc
                     ? {
@@ -56,6 +67,7 @@ export class PikkuRPCService {
             depth,
             global: false,
             invoke: serviceRPC.rpc.bind(serviceRPC),
+            invokeExposed: serviceRPC.rpc.bind(serviceRPC),
         };
         return serviceCopy;
     }

package/dist/wirings/rpc/rpc-types.d.ts

@@ -5,7 +5,7 @@ export type PikkuRPC<invoke extends Function = any> = {
 };
 export type RPCMeta = {
     pikkuFuncName: string;
-    exposed: boolean;
+    expose: boolean;
 };
 /**
  * Type for RPC handlers

package/dist/wirings/scheduler/scheduler-runner.js

@@ -9,9 +9,7 @@ export const wireScheduler = (scheduledTask) => {
     if (!taskMeta) {
         throw new Error('Task metadata not found');
     }
-    addFunction(taskMeta.pikkuFuncName, {
-        func: scheduledTask.func,
-    });
+    addFunction(taskMeta.pikkuFuncName, scheduledTask.func);
     const tasks = pikkuState('scheduler', 'tasks');
     if (tasks.has(scheduledTask.name)) {
         throw new Error(`Scheduled task already exists: ${scheduledTask.name}`);

package/dist/wirings/scheduler/scheduler.types.d.ts

@@ -1,4 +1,4 @@
-import { APIDocs, CoreUserSession } from '../../types/core.types.js';
+import { PikkuDocs, CoreUserSession } from '../../types/core.types.js';
 import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
@@ -8,7 +8,7 @@ export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> = Reco
     name: string;
     schedule: string;
     session?: UserSession;
-    docs?: APIDocs;
+    docs?: PikkuDocs;
     tags?: string[];
 }>;
 /**
@@ -18,6 +18,6 @@ export type CoreScheduledTask<PikkuFunction = CorePikkuFunctionSessionless<void,
     name: string;
     schedule: string;
     func: PikkuFunction;
-    docs?: APIDocs;
+    docs?: PikkuDocs;
     tags?: string[];
 };