@pikku/core 0.10.2 → 0.11.1

package/dist/permissions.js

@@ -1,4 +1,3 @@
-import { PikkuWiringTypes, } from './types/core.types.js';
 import { pikkuState } from './pikku-state.js';
 import { ForbiddenError } from './errors/errors.js';
 import { freezeDedupe } from './utils.js';
@@ -6,10 +5,10 @@ import { freezeDedupe } from './utils.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 const verifyPermissions = async (permissions, services, data, session) => {
+export const verifyPermissions = async (permissions, services, data, wire) => {
     if (!permissions) {
         return true;
     }
@@ -20,13 +19,13 @@ export const verifyPermissions = async (permissions, services, data, session) =>
     }
     for (const funcs of permissionGroups) {
         if (funcs instanceof Array) {
-            const permissioned = await Promise.all(funcs.map((func) => func(services, data, session)));
+            const permissioned = await Promise.all(funcs.map((func) => func(services, data, wire)));
             if (permissioned.every((result) => result)) {
                 valid = true;
             }
         }
         else {
-            valid = await funcs(services, data, session);
+            valid = await funcs(services, data, wire);
         }
         if (valid) {
             return true;
@@ -147,13 +146,14 @@ export const getPermissionsForTags = (tags) => {
     return applicablePermissions;
 };
 const combinedPermissionsCache = {
-    [PikkuWiringTypes.http]: {},
-    [PikkuWiringTypes.rpc]: {},
-    [PikkuWiringTypes.channel]: {},
-    [PikkuWiringTypes.queue]: {},
-    [PikkuWiringTypes.scheduler]: {},
-    [PikkuWiringTypes.mcp]: {},
-    [PikkuWiringTypes.cli]: {},
+    http: {},
+    rpc: {},
+    channel: {},
+    queue: {},
+    scheduler: {},
+    mcp: {},
+    cli: {},
+    workflow: {},
 };
 /**
  * Combines wiring-specific permissions with function-level permissions.
@@ -264,7 +264,7 @@ export const combinePermissions = (wireType, uid, { wireInheritedPermissions, wi
  * Runs permission checks using combined permissions from all sources.
  * Combines permissions from wire and function levels, then validates them.
  */
-export const runPermissions = async (wireType, uid, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, allServices, data, session, }) => {
+export const runPermissions = async (wireType, uid, { wireInheritedPermissions, wirePermissions, funcInheritedPermissions, funcPermissions, services, wire, data, }) => {
     // Combine all permissions: wireInheritedPermissions → wirePermissions → funcInheritedPermissions → funcPermissions
     const allPermissions = combinePermissions(wireType, uid, {
         wireInheritedPermissions,
@@ -276,14 +276,14 @@ export const runPermissions = async (wireType, uid, { wireInheritedPermissions,
     if (allPermissions.length > 0) {
         let permissioned = false;
         for (const permission of allPermissions) {
-            const result = await verifyPermissions(typeof permission === 'function' ? { permission } : permission, allServices, data, session);
+            const result = await verifyPermissions(typeof permission === 'function' ? { permission } : permission, services, data, wire);
             if (result) {
                 permissioned = true;
                 // Continue executing all permissions (don't break early)
             }
         }
         if (!permissioned) {
-            allServices.logger.debug('Permission denied - combined permissions');
+            services.logger.debug('Permission denied - combined permissions');
             throw new ForbiddenError('Permission denied');
         }
     }

package/dist/pikku-state.d.ts

@@ -4,9 +4,10 @@ import { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, FunctionS
 import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
 import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './function/functions.types.js';
-import { queueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
+import { QueueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
 import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
 import { CLIMeta, CLIProgramState } from './wirings/cli/cli.types.js';
+import { CoreWorkflow, WorkflowsMeta } from './wirings/workflow/workflow.types.js';
 interface PikkuState {
     function: {
         meta: FunctionsMeta;
@@ -35,7 +36,11 @@ interface PikkuState {
     };
     queue: {
         registrations: Map<string, CoreQueueWorker>;
-        meta: queueWorkersMeta;
+        meta: QueueWorkersMeta;
+    };
+    workflows: {
+        registrations: Map<string, CoreWorkflow>;
+        meta: WorkflowsMeta;
     };
     mcp: {
         resources: Map<string, CoreMCPResource>;

package/dist/pikku-state.js

@@ -25,6 +25,10 @@ export const resetPikkuState = () => {
             registrations: new Map(),
             meta: {},
         },
+        workflows: {
+            registrations: new Map(),
+            meta: {},
+        },
         mcp: {
             resources: new Map(),
             resourcesMeta: {},

package/dist/services/index.d.ts

@@ -8,6 +8,7 @@ export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
+export * from './scheduler-service.js';
 export * from './local-secrets.js';
 export * from './local-variables.js';
 export * from './logger-console.js';

package/dist/services/index.js

@@ -9,6 +9,7 @@ export * from './secret-service.js';
 export * from './variables-service.js';
 export * from './schema-service.js';
 export * from './user-session-service.js';
+export * from './scheduler-service.js';
 // Local implementations
 export * from './local-secrets.js';
 export * from './local-variables.js';

package/dist/services/scheduler-service.d.ts

@@ -0,0 +1,63 @@
+import { CoreUserSession } from '../types/core.types.js';
+/**
+ * Minimal metadata for listing scheduled tasks
+ */
+export interface ScheduledTaskSummary {
+    /** Unique task ID */
+    taskId: string;
+    /** RPC function name to invoke */
+    rpcName: string;
+    /** Scheduled execution time */
+    scheduledFor: Date;
+}
+/**
+ * Full metadata for a scheduled task retrieved from the queue
+ */
+export interface ScheduledTaskInfo extends ScheduledTaskSummary {
+    /** Data to pass to the RPC function */
+    data?: any;
+    /** User session */
+    session?: CoreUserSession;
+    /** Task status */
+    status?: 'scheduled' | 'active' | 'completed' | 'failed';
+}
+/**
+ * Abstract scheduler service for persistent scheduled task management
+ * Implementations use queue backends (pg-boss, BullMQ) for distributed scheduling
+ */
+export declare abstract class SchedulerService {
+    /**
+     * Initialize the scheduler service
+     */
+    abstract init(): Promise<void>;
+    /**
+     * Schedule a one-off delayed RPC call
+     * @param delay - Delay before execution (number in milliseconds or duration string like "5h", "30m")
+     * @param rpcName - RPC function name to invoke
+     * @param data - Data to pass to the RPC function
+     * @param session - Optional user session
+     * @returns Task ID
+     */
+    abstract scheduleRPC(delay: number | string, rpcName: string, data?: any, session?: CoreUserSession): Promise<string>;
+    /**
+     * Unschedule a task by ID
+     * @param taskId - Task ID
+     * @returns Success status
+     */
+    abstract unschedule(taskId: string): Promise<boolean>;
+    /**
+     * Get a scheduled task by ID with full details
+     * @param taskId - Task ID
+     * @returns Task info or null if not found
+     */
+    abstract getTask(taskId: string): Promise<ScheduledTaskInfo | null>;
+    /**
+     * Get all scheduled tasks with minimal info
+     * @returns Array of task summaries with taskId, rpcName, and schedule
+     */
+    abstract getAllTasks(): Promise<ScheduledTaskSummary[]>;
+    /**
+     * Close any open connections
+     */
+    abstract close(): Promise<void>;
+}

package/dist/services/scheduler-service.js

@@ -0,0 +1,6 @@
+/**
+ * Abstract scheduler service for persistent scheduled task management
+ * Implementations use queue backends (pg-boss, BullMQ) for distributed scheduling
+ */
+export class SchedulerService {
+}

package/dist/services/user-session-service.d.ts

@@ -1,19 +1,23 @@
 import { ChannelStore } from '../wirings/channel/channel-store.js';
 import { CoreUserSession } from '../types/core.types.js';
-export interface UserSessionService<UserSession extends CoreUserSession> {
+export interface SessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;
+    initial: UserSession | undefined;
     setInitial(session: UserSession): void;
+    freezeInitial(): UserSession | undefined;
     set(session: UserSession): Promise<void> | void;
     clear(): Promise<void> | void;
-    get(): Promise<UserSession | undefined> | UserSession | undefined;
+    get(): Promise<UserSession> | UserSession | undefined;
 }
-export declare class PikkuUserSessionService<UserSession extends CoreUserSession> implements UserSessionService<UserSession> {
+export declare class PikkuSessionService<UserSession extends CoreUserSession> implements SessionService<UserSession> {
     private channelStore?;
     private channelId?;
     sessionChanged: boolean;
+    initial: UserSession | undefined;
     private session;
     constructor(channelStore?: ChannelStore<unknown, unknown, UserSession> | undefined, channelId?: string | undefined);
     setInitial(session: UserSession): void;
+    freezeInitial(): UserSession | undefined;
     set(session: UserSession): void | Promise<void> | undefined;
     clear(): void | Promise<void> | undefined;
     get(): Promise<UserSession> | UserSession | undefined;

package/dist/services/user-session-service.js

@@ -1,7 +1,8 @@
-export class PikkuUserSessionService {
+export class PikkuSessionService {
     channelStore;
     channelId;
     sessionChanged = false;
+    initial;
     session;
     constructor(channelStore, channelId) {
         this.channelStore = channelStore;
@@ -13,6 +14,12 @@ export class PikkuUserSessionService {
     setInitial(session) {
         this.session = session;
     }
+    freezeInitial() {
+        if (this.initial === undefined) {
+            this.initial = this.session;
+        }
+        return this.initial;
+    }
     set(session) {
         this.sessionChanged = true;
         this.session = session;

package/dist/time-utils.d.ts

@@ -9,4 +9,18 @@ export declare const getRelativeTimeOffset: ({ value, unit, }: RelativeTimeInput
  * e.g. value = -1 and unit = 'day' => 1 day ago => now - 86400 seconds
  */
 export declare const getRelativeTimeOffsetFromNow: (relativeTime: RelativeTimeInput) => Date;
+/**
+ * Get duration in milliseconds from a string or number
+ * @param duration
+ * @returns
+ */
+export declare const getDurationInMilliseconds: (duration: string | number) => number;
+/**
+ * Parse a duration string to milliseconds
+ * Supports formats like: '2s', '5s', '5sec', '5seconds', '5m', '5min', '5minutes', '1h', '1hour', '2d', '2day', '1w', '1week'
+ *
+ * @param duration - Duration string (e.g., '2s', '5min', '2hours', '1day')
+ * @returns Duration in milliseconds
+ */
+export declare const parseDurationString: (duration: string) => number;
 export {};

package/dist/time-utils.js

@@ -16,3 +16,65 @@ export const getRelativeTimeOffset = ({ value, unit, }) => {
 export const getRelativeTimeOffsetFromNow = (relativeTime) => {
     return new Date(Date.now() + getRelativeTimeOffset(relativeTime));
 };
+/**
+ * Get duration in milliseconds from a string or number
+ * @param duration
+ * @returns
+ */
+export const getDurationInMilliseconds = (duration) => {
+    if (typeof duration === 'number') {
+        return duration;
+    }
+    return parseDurationString(duration);
+};
+/**
+ * Parse a duration string to milliseconds
+ * Supports formats like: '2s', '5s', '5sec', '5seconds', '5m', '5min', '5minutes', '1h', '1hour', '2d', '2day', '1w', '1week'
+ *
+ * @param duration - Duration string (e.g., '2s', '5min', '2hours', '1day')
+ * @returns Duration in milliseconds
+ */
+export const parseDurationString = (duration) => {
+    const match = duration.match(/^(\d+)(ms|milliseconds?|s|sec|seconds?|m|min|minutes?|h|hour|hours?|d|day|days?|w|week|weeks?|y|year|years?)$/);
+    if (!match) {
+        throw new Error(`Invalid duration format: ${duration}. Use formats like '2s', '5s', '5min', '1hour', '2days', '1week'`);
+    }
+    const value = parseInt(match[1], 10);
+    const unitStr = match[2];
+    // Handle milliseconds specially
+    if (unitStr === 'ms' ||
+        unitStr === 'millisecond' ||
+        unitStr === 'milliseconds') {
+        return value;
+    }
+    // Map string variations to TimeUnit
+    let unit;
+    if (unitStr === 's' ||
+        unitStr === 'sec' ||
+        unitStr === 'second' ||
+        unitStr === 'seconds') {
+        unit = 'second';
+    }
+    else if (unitStr === 'm' ||
+        unitStr === 'min' ||
+        unitStr === 'minute' ||
+        unitStr === 'minutes') {
+        unit = 'minute';
+    }
+    else if (unitStr === 'h' || unitStr === 'hour' || unitStr === 'hours') {
+        unit = 'hour';
+    }
+    else if (unitStr === 'd' || unitStr === 'day' || unitStr === 'days') {
+        unit = 'day';
+    }
+    else if (unitStr === 'w' || unitStr === 'week' || unitStr === 'weeks') {
+        unit = 'week';
+    }
+    else if (unitStr === 'y' || unitStr === 'year' || unitStr === 'years') {
+        unit = 'year';
+    }
+    else {
+        throw new Error(`Unknown time unit: ${unitStr}`);
+    }
+    return getRelativeTimeOffset({ value, unit });
+};

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

@@ -3,22 +3,16 @@ import { VariablesService } from '../services/variables-service.js';
 import { SchemaService } from '../services/schema-service.js';
 import { JWTService } from '../services/jwt-service.js';
 import { PikkuHTTP } from '../wirings/http/http.types.js';
-import { UserSessionService } from '../services/user-session-service.js';
+import { SessionService } from '../services/user-session-service.js';
 import { PikkuChannel } from '../wirings/channel/channel.types.js';
 import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
 import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
 import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
-import { PikkuQueue } from '../wirings/queue/queue.types.js';
+import { PikkuQueue, QueueService } from '../wirings/queue/queue.types.js';
 import { PikkuCLI } from '../wirings/cli/cli.types.js';
-export declare enum PikkuWiringTypes {
-    http = "http",
-    scheduler = "scheduler",
-    channel = "channel",
-    rpc = "rpc",
-    queue = "queue",
-    mcp = "mcp",
-    cli = "cli"
-}
+import { PikkuWorkflowWire, WorkflowService, WorkflowServiceConfig, WorkflowStepWire } from '../wirings/workflow/workflow.types.js';
+import { SchedulerService } from '../services/scheduler-service.js';
+export type PikkuWiringTypes = 'http' | 'scheduler' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow';
 export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
@@ -62,18 +56,18 @@ export type FunctionRuntimeMeta = {
     inputSchemaName: string | null;
     outputSchemaName: string | null;
     expose?: boolean;
+    internal?: boolean;
 };
 export type FunctionMeta = FunctionRuntimeMeta & Partial<{
     name: string;
     services: FunctionServicesMeta;
+    usedWires: string[];
     inputs: string[] | null;
     outputs: string[] | null;
-    tags: string[];
-    docs: PikkuDocs;
-    isDirectFunction: boolean;
     middleware: MiddlewareMetadata[];
     permissions: PermissionMetadata[];
-}>;
+    isDirectFunction: boolean;
+} & CommonWireMeta>;
 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>>;
@@ -109,6 +103,7 @@ export type CoreConfig<Config extends Record<string, unknown> = {}> = {
     logLevel?: LogLevel;
     /** Secrets used by the application (optional). */
     secrets?: {};
+    workflow?: WorkflowServiceConfig;
 } & Config;
 /**
  * Represents a core user session, which can be extended for more specific session information.
@@ -129,25 +124,33 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     logger: Logger;
     /** The variable service to be used */
     variables: VariablesService;
+    /** The workflow orchestrator service */
+    workflowService?: WorkflowService;
+    /** The queue service */
+    queueService?: QueueService;
+    /** The scheduler service */
+    schedulerService?: SchedulerService;
 }
 /**
- * Represents different forms of interaction within Pikku and the outside world.
+ * Represents different forms of wire within Pikku and the outside world.
  */
-export type PikkuInteraction<In = unknown, Out = unknown> = Partial<{
+export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire> = Partial<{
     http: PikkuHTTP<In>;
-    mcp: PikkuMCP;
-    rpc: PikkuRPC;
-    channel: PikkuChannel<unknown, Out>;
+    mcp: PikkuMCP<MCPTools>;
+    rpc: TypedRPC;
+    channel: [IsChannel] extends [null] ? PikkuChannel<unknown, Out> : PikkuChannel<unknown, Out> | undefined;
     scheduledTask: PikkuScheduledTask;
     queue: PikkuQueue;
     cli: PikkuCLI;
+    workflow: TypedWorkflow;
+    workflowStep: WorkflowStepWire;
+    initialSession: HasInitialSession extends true ? UserSession : UserSession | undefined;
+    session: SessionService<UserSession>;
 }>;
 /**
- * A function that can wrap an interaction and be called before or after
+ * A function that can wrap an wire and be called before or after
  */
-export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
-    userSession: UserSessionService<UserSession>;
-}, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
+export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, wires: PikkuWire<unknown, unknown, false, UserSession>, next: () => Promise<void>) => Promise<void>;
 /**
  * Configuration object for creating middleware with metadata
  *
@@ -180,7 +183,7 @@ export type CorePikkuMiddlewareGroup<SingletonServices extends CoreSingletonServ
  * ```typescript
  * // Direct function syntax
  * export const logMiddleware = pikkuMiddleware(
- *   async ({ logger }, _interaction, next) => {
+ *   async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -190,7 +193,7 @@ export type CorePikkuMiddlewareGroup<SingletonServices extends CoreSingletonServ
  * export const logMiddleware = pikkuMiddleware({
  *   name: 'Request Logger',
  *   description: 'Logs request information',
- *   func: async ({ logger }, _interaction, next) => {
+ *   func: async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -208,7 +211,7 @@ export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonSe
  *   message,
  *   level = 'info'
  * }) => {
- *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
  *     logger[level](message)
  *     await next()
  *   })
@@ -217,12 +220,10 @@ export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonSe
  */
 export declare const pikkuMiddlewareFactory: <In = any>(factory: CorePikkuMiddlewareFactory<In>) => CorePikkuMiddlewareFactory<In>;
 /**
- * Represents the core services used by Pikku, including singleton services and the request/response interaction.
+ * Represents the core services used by Pikku, including singleton services.
  */
-export type CoreServices<SingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = SingletonServices & PikkuInteraction & {
-    userSession?: UserSessionService<UserSession>;
-};
-export type SessionServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services = CoreServices<SingletonServices>> = Omit<Services, keyof SingletonServices | keyof PikkuInteraction | 'session'>;
+export type CoreServices<SingletonServices = CoreSingletonServices> = SingletonServices;
+export type WireServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services = CoreServices<SingletonServices>> = Omit<Services, keyof SingletonServices | 'session'>;
 /**
  * Defines a function type for creating singleton services from the given configuration.
  */
@@ -230,7 +231,7 @@ export type CreateSingletonServices<Config extends CoreConfig, SingletonServices
 /**
  * Defines a function type for creating session-specific services.
  */
-export type CreateSessionServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services extends CoreServices<SingletonServices> = CoreServices<SingletonServices>, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, interaction: PikkuInteraction, session: UserSession | undefined) => Promise<SessionServices<Services, SingletonServices>>;
+export type CreateWireServices<SingletonServices extends CoreSingletonServices = CoreSingletonServices, Services extends CoreServices<SingletonServices> = CoreServices<SingletonServices>, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, wire: PikkuWire<unknown, unknown, false, UserSession>) => Promise<WireServices<Services, SingletonServices>>;
 /**
  * Defines a function type for creating config.
  */
@@ -238,9 +239,21 @@ export type CreateConfig<Config extends CoreConfig, RemainingArgs extends any[]
 /**
  * Represents the documentation for a route, including summary, description, tags, and errors.
  */
-export type PikkuDocs = {
+export type CommonWireMeta = {
+    pikkuFuncName: string;
+    tags?: string[];
     summary?: string;
     description?: string;
-    tags?: string[];
     errors?: string[];
+    middleware?: MiddlewareMetadata[];
+    permissions?: PermissionMetadata[];
 };
+/**
+ * Serialized error for storage
+ */
+export interface SerializedError {
+    message: string;
+    stack?: string;
+    code?: string;
+    [key: string]: any;
+}

package/dist/types/core.types.js

@@ -1,13 +1,3 @@
-export var PikkuWiringTypes;
-(function (PikkuWiringTypes) {
-    PikkuWiringTypes["http"] = "http";
-    PikkuWiringTypes["scheduler"] = "scheduler";
-    PikkuWiringTypes["channel"] = "channel";
-    PikkuWiringTypes["rpc"] = "rpc";
-    PikkuWiringTypes["queue"] = "queue";
-    PikkuWiringTypes["mcp"] = "mcp";
-    PikkuWiringTypes["cli"] = "cli";
-})(PikkuWiringTypes || (PikkuWiringTypes = {}));
 /**
  * Factory function for creating middleware with tree-shaking support
  * Supports both direct function and configuration object syntax
@@ -16,7 +6,7 @@ export var PikkuWiringTypes;
  * ```typescript
  * // Direct function syntax
  * export const logMiddleware = pikkuMiddleware(
- *   async ({ logger }, _interaction, next) => {
+ *   async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -26,7 +16,7 @@ export var PikkuWiringTypes;
  * export const logMiddleware = pikkuMiddleware({
  *   name: 'Request Logger',
  *   description: 'Logs request information',
- *   func: async ({ logger }, _interaction, next) => {
+ *   func: async ({ logger }, next) => {
  *     logger.info('Request started')
  *     await next()
  *   }
@@ -46,7 +36,7 @@ export const pikkuMiddleware = (middleware) => {
  *   message,
  *   level = 'info'
  * }) => {
- *   return pikkuMiddleware(async ({ logger }, _interaction, next) => {
+ *   return pikkuMiddleware(async ({ logger }, next) => {
  *     logger[level](message)
  *     await next()
  *   })

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from './services/logger.js';
-export declare const closeSessionServices: (logger: Logger, sessionServices: Record<string, any>) => Promise<void>;
+export declare const closeWireServices: (logger: Logger, wireServices: Record<string, any>) => Promise<void>;
 export declare const createWeakUID: () => string;
 export declare const isSerializable: (data: any) => boolean;
 export declare const freezeDedupe: <T>(arr?: readonly T[] | T[] | undefined) => readonly T[];

package/dist/utils.js

@@ -1,8 +1,8 @@
-// TODO: SessionServices probably needs it's own type
+// TODO: WireServices probably needs it's own type
 // but is an issue for the future and will be tackled
 // with dependency injection
-export const closeSessionServices = async (logger, sessionServices) => {
-    await Promise.all(Object.values(sessionServices).map(async (service) => {
+export const closeWireServices = async (logger, wireServices) => {
+    await Promise.all(Object.values(wireServices).map(async (service) => {
         if (service?.close) {
             try {
                 await service.close();

package/dist/wirings/channel/channel-common.js

@@ -1,4 +1,3 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 import { runPikkuFuncDirectly } from '../../function/function-runner.js';
 /**
@@ -24,13 +23,13 @@ export const runChannelLifecycleWithMiddleware = async ({ channelConfig, meta, l
         ? lifecycleConfig.middleware || []
         : [];
     // Use combineMiddleware to properly resolve metadata + inline middleware
-    const allMiddleware = combineMiddleware(PikkuWiringTypes.channel, `${channelConfig.name}:${lifecycleType}`, {
+    const allMiddleware = combineMiddleware('channel', `${channelConfig.name}:${lifecycleType}`, {
         wireInheritedMiddleware: meta.middleware,
         wireMiddleware: lifecycleMiddleware,
     });
     // Run the lifecycle function
     const runLifecycle = async () => {
-        return await runPikkuFuncDirectly(meta.pikkuFuncName, { ...services, channel }, data);
+        return await runPikkuFuncDirectly(meta.pikkuFuncName, services, { channel }, data);
     };
     // Run with middleware if any
     if (allMiddleware.length > 0) {

package/dist/wirings/channel/channel-handler.d.ts

@@ -1,3 +1,4 @@
-import { CoreServices } from '../../types/core.types.js';
+import { CoreServices, CoreUserSession } from '../../types/core.types.js';
 import { CoreChannel, PikkuChannelHandler } from './channel.types.js';
-export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler) => (rawData: any) => Promise<unknown>;
+import { SessionService } from '../../services/user-session-service.js';
+export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreChannel<any, any>, channelHandler: PikkuChannelHandler, userSession?: SessionService<CoreUserSession>) => (rawData: any) => Promise<unknown>;

package/dist/wirings/channel/channel-handler.js

@@ -1,4 +1,3 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { pikkuState } from '../../pikku-state.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
@@ -32,7 +31,7 @@ const validateAuth = (requiresSession, session, onMessage) => {
     }
     return true;
 };
-export const processMessageHandlers = (services, channelConfig, channelHandler) => {
+export const processMessageHandlers = (services, channelConfig, channelHandler, userSession) => {
     const logger = services.logger;
     const requiresSession = channelConfig.auth !== false;
     const processMessage = async (data, onMessage, routingProperty, routerValue) => {
@@ -69,20 +68,18 @@ export const processMessageHandlers = (services, channelConfig, channelHandler)
         const cacheKey = routingProperty
             ? `${channelConfig.name}:${routingProperty}:${routerValue}`
             : `${channelConfig.name}:default`;
-        return await runPikkuFunc(PikkuWiringTypes.channel, cacheKey, pikkuFuncName, {
+        return await runPikkuFunc('channel', cacheKey, pikkuFuncName, {
             singletonServices: services,
-            getAllServices: () => ({
-                ...services,
-                channel: channelHandler.getChannel(),
-            }),
             data: () => data,
-            userSession: services.userSession,
             inheritedMiddleware,
             wireMiddleware,
             inheritedPermissions,
             wirePermissions,
             tags: channelConfig.tags,
-            interaction: { channel: channelHandler.getChannel() },
+            wire: {
+                channel: channelHandler.getChannel(),
+                session: userSession,
+            },
         });
     };
     return async (rawData) => {