@pikku/core 0.11.0 → 0.11.1

package/CHANGELOG.md

@@ -1,12 +1,22 @@
 ## 0.11.0
 
+## 0.11.1
+
+### Patch Changes
+
+- 4b811db: chore: updating all dependencies
+- e12a00c: feat: adding initialSession to PikkuWire which is correctly typed (undefined / not depending on function type)
+- 4579434: breaking: changing the signature of functions
+- 28aeb7f: breaking: extract docs in the wiring meta
+- ce902b1: feat: adding in pikkuSimpleWorkflowFunc
+- 06e1a31: breaking: change session services to wire services
+
 ### Minor Changes
 
 - Add workflow orchestration engine with step execution and retries
 - Add scheduler service abstraction
 - Remove file-based channel and eventhub stores
 
-
 # @pikku/core
 
 ## 0.10.2

package/dist/errors/errors.d.ts

@@ -2,7 +2,7 @@
  * The server cannot or will not process the request due to client error (e.g., malformed request syntax).
  */
 import { PikkuError } from './error-handler.js';
-export declare class InvalidMiddlewareInteractionError extends PikkuError {
+export declare class InvalidMiddlewareWireError extends PikkuError {
 }
 /**
  * The server cannot or will not process the request due to client error (e.g., malformed request syntax).

package/dist/errors/errors.js

@@ -2,11 +2,11 @@
  * The server cannot or will not process the request due to client error (e.g., malformed request syntax).
  */
 import { addError, PikkuError } from './error-handler.js';
-export class InvalidMiddlewareInteractionError extends PikkuError {
+export class InvalidMiddlewareWireError extends PikkuError {
 }
-addError(InvalidMiddlewareInteractionError, {
+addError(InvalidMiddlewareWireError, {
     status: 500,
-    message: 'The middleware interaction is invalid for the current wiring type.',
+    message: 'The middleware wire is invalid for the current wiring type.',
 });
 /**
  * The server cannot or will not process the request due to client error (e.g., malformed request syntax).

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

@@ -1,12 +1,11 @@
-import { CoreServices, CoreUserSession, CorePikkuMiddleware, PikkuWiringTypes, CoreSingletonServices, PikkuInteraction, MiddlewareMetadata, PermissionMetadata } from '../types/core.types.js';
+import { CoreServices, CoreUserSession, CorePikkuMiddleware, PikkuWiringTypes, PikkuWire, MiddlewareMetadata, PermissionMetadata, CoreSingletonServices, CreateWireServices } from '../types/core.types.js';
 import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './functions.types.js';
-import { UserSessionService } from '../services/user-session-service.js';
+import { SessionService } from '../services/user-session-service.js';
 export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<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>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { getAllServices, singletonServices, data, userSession, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags, interaction, }: {
+export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, wire: PikkuWire, data: In, userSession?: SessionService<CoreUserSession>) => Promise<Out>;
+export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTypes, wireId: string, funcName: string, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags, wire, }: {
     singletonServices: CoreSingletonServices;
-    getAllServices: (session?: CoreUserSession) => Promise<CoreServices> | CoreServices;
-    userSession?: UserSessionService<CoreUserSession>;
+    createWireServices?: CreateWireServices;
     data: () => Promise<In> | In;
     auth?: boolean;
     inheritedMiddleware?: MiddlewareMetadata[];
@@ -15,5 +14,5 @@ export declare const runPikkuFunc: <In = any, Out = any>(wireType: PikkuWiringTy
     wirePermissions?: CorePermissionGroup | CorePikkuPermission[];
     coerceDataFromSchema?: boolean;
     tags?: string[];
-    interaction: PikkuInteraction;
+    wire: PikkuWire;
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -3,17 +3,24 @@ import { runPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 import { ForbiddenError } from '../errors/errors.js';
+import { rpcService } from '../wirings/rpc/rpc-runner.js';
+import { closeWireServices } from '../utils.js';
 export const addFunction = (funcName, funcConfig) => {
     pikkuState('function', 'functions').set(funcName, funcConfig);
 };
-export const runPikkuFuncDirectly = async (funcName, allServices, data, session) => {
+export const runPikkuFuncDirectly = async (funcName, allServices, wire, data, userSession) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
     }
-    return (await funcConfig.func(allServices, data, session));
+    // Inject session into wire
+    const wireWithSession = {
+        ...wire,
+        session: userSession,
+    };
+    return (await funcConfig.func(allServices, data, wireWithSession));
 };
-export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices, singletonServices, data, userSession, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags = [], interaction, }) => {
+export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServices, createWireServices, data, auth: wiringAuth, inheritedMiddleware, wireMiddleware, inheritedPermissions, wirePermissions, coerceDataFromSchema, tags = [], wire, }) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
@@ -29,16 +36,21 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices,
     ];
     // Helper function to run permissions and execute the function
     const executeFunction = async () => {
-        const session = await userSession?.get();
+        const initialSession = wire.session?.freezeInitial();
+        const wireWithInitialSession = {
+            ...wire,
+            initialSession,
+        };
         if (wiringAuth === true || funcConfig.auth === true) {
             // This means it was explicitly enabled in either wiring or function and has to be respected
-            if (!session) {
+            if (!initialSession) {
                 throw new ForbiddenError('Authentication required');
             }
         }
         if (wiringAuth === undefined && funcConfig.auth === undefined) {
             // We always default to requiring auth unless explicitly disabled
-            if (!session) {
+            if (!initialSession) {
+                // TODO: Critical, we need to figure out how to make this work with different wirings
                 // throw new ForbiddenError('Authentication required')
             }
         }
@@ -54,20 +66,30 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices,
                 coerceTopLevelDataFromSchema(inputSchemaName, actualData);
             }
         }
-        const allServices = await getAllServices(session);
-        // Run permissions check with combined permissions: inheritedPermissions (including tags) → wirePermissions → funcPermissions
         await runPermissions(wireType, wireId, {
             wireInheritedPermissions: mergedInheritedPermissions,
             wirePermissions: wirePermissions,
             funcInheritedPermissions: funcMeta.permissions,
             funcPermissions: funcConfig.permissions,
-            allServices,
+            services: singletonServices,
+            wire: { ...wireWithInitialSession, rpc: undefined },
             data: actualData,
-            session,
         });
-        return await funcConfig.func(allServices, actualData, session);
+        const wireServices = await createWireServices?.(singletonServices, wireWithInitialSession);
+        try {
+            const services = { ...singletonServices, ...wireServices };
+            const rpc = rpcService.getContextRPCService(services, wireWithInitialSession);
+            return await funcConfig.func(services, actualData, {
+                ...wireWithInitialSession,
+                rpc,
+            });
+        }
+        finally {
+            if (wireServices) {
+                await closeWireServices(singletonServices.logger, wireServices);
+            }
+        }
     };
-    // Combine all middleware: inheritedMiddleware → wireMiddleware → funcMiddleware
     const allMiddleware = combineMiddleware(wireType, wireId, {
         wireInheritedMiddleware: inheritedMiddleware,
         wireMiddleware,
@@ -75,10 +97,7 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { getAllServices,
         funcMiddleware: funcConfig.middleware,
     });
     if (allMiddleware.length > 0) {
-        return (await runMiddleware({
-            ...singletonServices,
-            userSession,
-        }, interaction, allMiddleware, executeFunction));
+        return (await runMiddleware(singletonServices, wire, allMiddleware, executeFunction));
     }
     return (await executeFunction());
 };

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

@@ -1,33 +1,23 @@
-import { PikkuChannel } from '../wirings/channel/channel.types.js';
-import type { CoreServices, CoreSingletonServices, CoreUserSession, PikkuDocs, CorePikkuMiddleware } from '../types/core.types.js';
+import type { CoreServices, CoreSingletonServices, CoreUserSession, CorePikkuMiddleware, PikkuWire, PickRequired } from '../types/core.types.js';
+import { Session } from 'inspector';
 /**
  * Represents a core API function that performs an operation using core services and a user session.
  *
  * @template In - The input type.
  * @template Out - The output type.
- * @template ChannelData - The channel data type.
  * @template Services - The services type, defaults to `CoreServices`.
- * @template Session - The session type, defaults to `CoreUserSession`.
+ * @template Wire - The wire type, defaults to `PikkuWire<In, Out>`.
  */
-export type CorePikkuFunction<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
-    channel?: PikkuChannel<unknown, Out> | undefined;
-} : {
-    channel: PikkuChannel<ChannelData, Out>;
-}), Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session: Session) => ChannelData extends null ? Promise<Out> : Promise<Out> | Promise<void>;
+export type CorePikkuFunction<In, Out, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, Out> = PikkuWire<In, Out, true, Session>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Out> : Promise<Out> | Promise<void>;
 /**
  * Represents a core API function that can be used without a session.
  *
  * @template In - The input type.
  * @template Out - The output type.
- * @template ChannelData - The channel data type.
  * @template Services - The services type, defaults to `CoreServices`.
- * @template Session - The session type, defaults to `CoreUserSession`.
+ * @template Wire - The wire type, defaults to `PikkuWire<In, Out>`.
  */
-export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
-    channel?: PikkuChannel<unknown, Out> | undefined;
-} : {
-    channel: PikkuChannel<ChannelData, Out>;
-}), Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => ChannelData extends null ? Promise<Out> : Promise<Out> | Promise<void>;
+export type CorePikkuFunctionSessionless<In, Out, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, Out, false, CoreUserSession, any, any, any> = PikkuWire<In, Out, false, CoreUserSession, any, any, any>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Out> : Promise<Out> | Promise<void>;
 /**
  * Represents a function that checks permissions for a given operation.
  *
@@ -35,7 +25,7 @@ export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown |
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
+export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, never, false, CoreUserSession, any, never, never> = PikkuWire<In, never, false, CoreUserSession, never, never, never>> = (services: Services, data: In, wire: Wire) => Promise<boolean>;
 /**
  * Configuration object for creating a permission with metadata
  *
@@ -43,9 +33,9 @@ export type CorePikkuPermission<In = any, Services extends CoreSingletonServices
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = {
+export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, never, false, CoreUserSession> = PikkuWire<In, never, false, CoreUserSession>> = {
     /** The permission function */
-    func: CorePikkuPermission<In, Services, Session>;
+    func: CorePikkuPermission<In, Services, Wire>;
     /** Optional human-readable name for the permission */
     name?: string;
     /** Optional description of what the permission checks */
@@ -59,8 +49,9 @@ export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonSe
  * ```typescript
  * // Direct function syntax
  * export const adminPermission = pikkuPermission(
- *   async ({ logger }, data, session) => {
- *     return session?.role === 'admin'
+ *   async ({ logger }, _data, { session }) => {
+ *     const currentSession = await session.get()
+ *     return currentSession?.role === 'admin'
  *   }
  * )
  *
@@ -68,13 +59,14 @@ export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonSe
  * export const adminPermission = pikkuPermission({
  *   name: 'Admin Permission',
  *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, data, session) => {
- *     return session?.role === 'admin'
+ *   func: async ({ logger }, _data, { session }) => {
+ *     const currentSession = await session.get()
+ *     return currentSession?.role === 'admin'
  *   }
  * })
  * ```
  */
-export declare const pikkuPermission: <In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession>(permission: CorePikkuPermission<In, Services, Session> | CorePikkuPermissionConfig<In, Services, Session>) => CorePikkuPermission<In, Services, Session>;
+export declare const pikkuPermission: <In = any, Services extends CoreSingletonServices = CoreServices, Wire extends PickRequired<PikkuWire<In, never, false, CoreUserSession>, "session"> = PickRequired<PikkuWire<In, never, false, CoreUserSession>, "session">>(permission: CorePikkuPermission<In, Services, Wire> | CorePikkuPermissionConfig<In, Services, Wire>) => CorePikkuPermission<In, Services, Wire>;
 /**
  * A factory function that takes input and returns a permission
  * Used when permissions need configuration/input parameters
@@ -83,7 +75,7 @@ export declare const pikkuPermission: <In = any, Services extends CoreSingletonS
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CorePikkuPermissionFactory<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (input: In) => CorePikkuPermission<any, Services, Session>;
+export type CorePikkuPermissionFactory<In = any, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, never, false, CoreUserSession> = PikkuWire<In, never, false, CoreUserSession>> = (input: In) => CorePikkuPermission<any, Services, Wire>;
 /**
  * Factory function for creating permission factories
  * Use this when your permission needs configuration/input parameters
@@ -93,8 +85,9 @@ export type CorePikkuPermissionFactory<In = any, Services extends CoreSingletonS
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, session) => {
- *     if (!session || session.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { session }) => {
+ *      const currentSession = await session.get()
+ *     if (!currentSession || currentSession.role !== role) {
  *       logger.warn(`Permission denied: required role '${role}'`)
  *       return false
  *     }
@@ -105,14 +98,13 @@ export type CorePikkuPermissionFactory<In = any, Services extends CoreSingletonS
  */
 export declare const pikkuPermissionFactory: <In = any>(factory: CorePikkuPermissionFactory<In>) => CorePikkuPermissionFactory<In>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
-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>, PikkuMiddleware extends CorePikkuMiddleware<any> = CorePikkuMiddleware<any>> = {
+export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>> = {
     name?: string;
+    tags?: string[];
     expose?: boolean;
     internal?: boolean;
     func: PikkuFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;
     middleware?: PikkuMiddleware[];
-    tags?: string[];
-    docs?: PikkuDocs;
 };

package/dist/function/functions.types.js

@@ -6,8 +6,9 @@
  * ```typescript
  * // Direct function syntax
  * export const adminPermission = pikkuPermission(
- *   async ({ logger }, data, session) => {
- *     return session?.role === 'admin'
+ *   async ({ logger }, _data, { session }) => {
+ *     const currentSession = await session.get()
+ *     return currentSession?.role === 'admin'
  *   }
  * )
  *
@@ -15,8 +16,9 @@
  * export const adminPermission = pikkuPermission({
  *   name: 'Admin Permission',
  *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, data, session) => {
- *     return session?.role === 'admin'
+ *   func: async ({ logger }, _data, { session }) => {
+ *     const currentSession = await session.get()
+ *     return currentSession?.role === 'admin'
  *   }
  * })
  * ```
@@ -33,8 +35,9 @@ export const pikkuPermission = (permission) => {
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, session) => {
- *     if (!session || session.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { session }) => {
+ *      const currentSession = await session.get()
+ *     if (!currentSession || currentSession.role !== role) {
  *       logger.warn(`Permission denied: required role '${role}'`)
  *       return false
  *     }

package/dist/handle-error.d.ts

@@ -4,7 +4,7 @@ import { PikkuHTTP } from './wirings/http/http.types.js';
  * Handle errors that occur during route processing
  *
  * @param {any} e - The error that occurred
- * @param {PikkuHTTP | undefined} http - HTTP interaction object
+ * @param {PikkuHTTP | undefined} http - HTTP wire object
  * @param {string} trackerId - Unique ID for tracking this error
  * @param {Logger} logger - Logger service
  * @param {number[]} logWarningsForStatusCodes - HTTP status codes to log as warnings

package/dist/handle-error.js

@@ -4,7 +4,7 @@ import { NotFoundError } from './errors/errors.js';
  * Handle errors that occur during route processing
  *
  * @param {any} e - The error that occurred
- * @param {PikkuHTTP | undefined} http - HTTP interaction object
+ * @param {PikkuHTTP | undefined} http - HTTP wire object
  * @param {string} trackerId - Unique ID for tracking this error
  * @param {Logger} logger - Logger service
  * @param {number[]} logWarningsForStatusCodes - HTTP status codes to log as warnings

package/dist/middleware/auth-apikey.js

@@ -16,8 +16,8 @@ import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js'
  * ])
  * ```
  */
-export const authAPIKey = pikkuMiddlewareFactory(({ source }) => pikkuMiddleware(async ({ userSession: userSessionService, jwt: jwtService }, { http }, next) => {
-    if (!http?.request || userSessionService.get()) {
+export const authAPIKey = pikkuMiddlewareFactory(({ source }) => pikkuMiddleware(async ({ jwt: jwtService }, { http, session: SessionService }, next) => {
+    if (!http?.request || !SessionService || SessionService.get()) {
         return next();
     }
     let apiKey = null;
@@ -30,7 +30,7 @@ export const authAPIKey = pikkuMiddlewareFactory(({ source }) => pikkuMiddleware
     if (apiKey && jwtService) {
         const userSession = await jwtService.decode(apiKey);
         if (userSession) {
-            userSessionService.setInitial(userSession);
+            SessionService.setInitial(userSession);
         }
     }
     return next();

package/dist/middleware/auth-bearer.js

@@ -29,9 +29,9 @@ import { pikkuMiddleware, pikkuMiddlewareFactory, } from '../types/core.types.js
  * ])
  * ```
  */
-export const authBearer = pikkuMiddlewareFactory(({ token } = {}) => pikkuMiddleware(async ({ userSession: userSessionService, jwt: jwtService }, { http }, next) => {
+export const authBearer = pikkuMiddlewareFactory(({ token } = {}) => pikkuMiddleware(async ({ jwt: jwtService }, { http, session }, next) => {
     // Skip if session already exists.
-    if (!http?.request || userSessionService.get()) {
+    if (!http?.request || !session || session.get()) {
         return next();
     }
     const authHeader = http.request.header('authorization') ||
@@ -51,7 +51,7 @@ export const authBearer = pikkuMiddlewareFactory(({ token } = {}) => pikkuMiddle
             userSession = await jwtService.decode(bearerToken);
         }
         if (userSession) {
-            userSessionService.setInitial(userSession);
+            session.setInitial(userSession);
         }
     }
     return next();

package/dist/middleware/auth-cookie.js

@@ -28,8 +28,8 @@ import { getRelativeTimeOffsetFromNow, } from '../time-utils.js';
  * ])
  * ```
  */
-export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn }) => pikkuMiddleware(async ({ userSession: userSessionService, jwt: jwtService, logger }, { http }, next) => {
-    if (!http?.request || userSessionService.get()) {
+export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn }) => pikkuMiddleware(async ({ jwt: jwtService, logger }, { http, session: SessionService }, next) => {
+    if (!http?.request || !SessionService || SessionService.get()) {
         return next();
     }
     // Try to decode session from cookie
@@ -37,7 +37,7 @@ export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn })
     if (cookieValue && jwtService) {
         const userSession = await jwtService.decode(cookieValue);
         if (userSession) {
-            userSessionService.setInitial(userSession);
+            SessionService.setInitial(userSession);
         }
     }
     await next();
@@ -45,8 +45,8 @@ export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn })
     if (!http?.response) {
         return;
     }
-    if (userSessionService.sessionChanged) {
-        const session = userSessionService.get();
+    if (SessionService.sessionChanged) {
+        const session = SessionService.get();
         if (jwtService) {
             http.response.cookie(name, await jwtService.encode(expiresIn, session), {
                 ...options,

package/dist/middleware/timeout.js

@@ -1,8 +1,9 @@
 import { RequestTimeoutError } from '../errors/errors.js';
 import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js';
-export const timeout = () => pikkuMiddlewareFactory(({ timeout }) => pikkuMiddleware(async (_services, _interaction, next) => {
-    setTimeout(() => {
+export const timeout = () => pikkuMiddlewareFactory(({ timeout }) => pikkuMiddleware(async (_services, _wire, next) => {
+    const timeoutId = setTimeout(() => {
         throw new RequestTimeoutError();
     }, timeout);
     await next();
+    clearTimeout(timeoutId);
 }));

package/dist/middleware-runner.d.ts

@@ -1,10 +1,9 @@
-import { UserSessionService } from './services/user-session-service.js';
-import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware, CorePikkuMiddlewareGroup, PikkuWiringTypes, MiddlewareMetadata } from './types/core.types.js';
+import { CoreSingletonServices, PikkuWire, CorePikkuMiddleware, CorePikkuMiddlewareGroup, PikkuWiringTypes, MiddlewareMetadata } from './types/core.types.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
  * @param services - An object containing services (e.g., singletonServices, userSession, etc.)
- * @param interaction - The interaction context, e.g., { http }.
+ * @param wire - The wire context, e.g., { http }.
  * @param middlewares - An array of middleware functions to run.
  * @param main - The main function to execute after all middleware have run.
  * @returns A promise resolving to the result of the main function.
@@ -17,9 +16,7 @@ import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware, CorePikku
  *   async () => { return await runMain(); }
  * );
  */
-export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(services: CoreSingletonServices & {
-    userSession?: UserSessionService<any>;
-}, interaction: PikkuInteraction, middlewares: readonly Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
+export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(services: CoreSingletonServices, wire: PikkuWire, middlewares: readonly Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
 /**
  * Registers global middleware for a specific tag.
  *

package/dist/middleware-runner.js

@@ -1,11 +1,10 @@
-import { PikkuWiringTypes, } from './types/core.types.js';
 import { pikkuState } from './pikku-state.js';
 import { freezeDedupe } from './utils.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
  * @param services - An object containing services (e.g., singletonServices, userSession, etc.)
- * @param interaction - The interaction context, e.g., { http }.
+ * @param wire - The wire context, e.g., { http }.
  * @param middlewares - An array of middleware functions to run.
  * @param main - The main function to execute after all middleware have run.
  * @returns A promise resolving to the result of the main function.
@@ -18,12 +17,12 @@ import { freezeDedupe } from './utils.js';
  *   async () => { return await runMain(); }
  * );
  */
-export const runMiddleware = async (services, interaction, middlewares, main) => {
+export const runMiddleware = async (services, wire, middlewares, main) => {
     // Deduplicate middleware using Set to avoid running the same middleware multiple times
     let result;
     const dispatch = async (index) => {
         if (middlewares && index < middlewares.length) {
-            return await middlewares[index](services, interaction, () => dispatch(index + 1));
+            return await middlewares[index](services, wire, () => dispatch(index + 1));
         }
         else if (main) {
             result = await main();
@@ -87,14 +86,14 @@ export const getMiddlewareByName = (name) => {
     return middleware?.[0];
 };
 const middlewareCache = {
-    [PikkuWiringTypes.http]: {},
-    [PikkuWiringTypes.rpc]: {},
-    [PikkuWiringTypes.channel]: {},
-    [PikkuWiringTypes.queue]: {},
-    [PikkuWiringTypes.scheduler]: {},
-    [PikkuWiringTypes.mcp]: {},
-    [PikkuWiringTypes.cli]: {},
-    [PikkuWiringTypes.workflow]: {},
+    http: {},
+    rpc: {},
+    channel: {},
+    queue: {},
+    scheduler: {},
+    mcp: {},
+    cli: {},
+    workflow: {},
 };
 /**
  * Combines wiring-specific middleware with function-level middleware.

package/dist/permissions.d.ts

@@ -1,13 +1,13 @@
-import { CoreServices, CoreUserSession, PikkuWiringTypes, PermissionMetadata } from './types/core.types.js';
+import { CoreServices, PikkuWiringTypes, PermissionMetadata, PikkuWire } from './types/core.types.js';
 import { CorePermissionGroup, CorePikkuPermission } from './function/functions.types.js';
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
  * @param services - The core services required for permission validation.
  * @param data - The data to be used in the permission validation functions.
- * @param session - An optional user session for permission validation.
+ * @param wire - The wire object containing request/response context and session.
  * @returns A promise that resolves to void.
  */
-export declare const verifyPermissions: (permissions: CorePermissionGroup, services: CoreServices, data: any, session?: CoreUserSession) => Promise<boolean>;
+export declare const verifyPermissions: <Out = any>(permissions: CorePermissionGroup, services: CoreServices, data: any, wire: PikkuWire<any, never, any, never, never, never>) => Promise<boolean>;
 /**
  * Registers a single permission function by name in the global permission store.
  *
@@ -117,12 +117,12 @@ export declare const combinePermissions: (wireType: PikkuWiringTypes, uid: strin
  * Runs permission checks using combined permissions from all sources.
  * Combines permissions from wire and function levels, then validates them.
  */
-export declare const runPermissions: (wireType: PikkuWiringTypes, uid: string, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, allServices, data, session, }: {
+export declare const runPermissions: (wireType: PikkuWiringTypes, uid: string, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, services, wire, data, }: {
     wireInheritedPermissions?: PermissionMetadata[];
     wirePermissions?: CorePermissionGroup | CorePikkuPermission[];
     funcInheritedPermissions?: PermissionMetadata[];
     funcPermissions?: CorePermissionGroup | CorePikkuPermission[];
-    allServices: CoreServices;
+    services: CoreServices;
+    wire: PikkuWire<any, never, any, never, never, never>;
     data: any;
-    session?: CoreUserSession;
 }) => Promise<void>;