@pikku/core 0.11.0 → 0.11.1

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -1,4 +1,4 @@
-import { CoreConfig, CoreSingletonServices, CreateSessionServices, SerializedError } from '../../types/core.types.js';
+import { CoreConfig, CoreSingletonServices, CreateWireServices, SerializedError } from '../../types/core.types.js';
 import type { StepState, WorkflowRun, WorkflowStatus, WorkflowService, WorkflowStepOptions } from './workflow.types.js';
 export declare class WorkflowServiceNotInitialized extends Error {
 }
@@ -13,9 +13,9 @@ export declare class WorkflowStepNameNotString extends Error {
 export declare abstract class PikkuWorkflowService implements WorkflowService {
     private config;
     private singletonServices;
-    private createSessionServices;
+    private createWireServices;
     constructor();
-    setServices(singletonServices: CoreSingletonServices, createSessionServices: CreateSessionServices, { workflow }: CoreConfig): void;
+    setServices(singletonServices: CoreSingletonServices, createWireServices: CreateWireServices, { workflow }: CoreConfig): void;
     /**
      * Create a new workflow run
      * @param name - Workflow name
@@ -103,6 +103,14 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @returns Function result
      */
     abstract withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
+    /**
+     * Execute function within a step lock to prevent concurrent step execution
+     * @param runId - Run ID
+     * @param stepName - Step name
+     * @param fn - Function to execute
+     * @returns Function result
+     */
+    abstract withStepLock<T>(runId: string, stepName: string, fn: () => Promise<T>): Promise<T>;
     /**
      * Close any open connections
      */
@@ -146,7 +154,7 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
     private inlineStep;
     private sleepStep;
     private cancelWorkflow;
-    private createWorkflowInteraction;
+    private createWorkflowWire;
     private verifyStepName;
     private getConfig;
 }

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -1,7 +1,6 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { getDurationInMilliseconds } from '../../time-utils.js';
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { WorkflowAsyncException, WorkflowCancelledException, WorkflowNotFoundError, WorkflowRunNotFound, } from './workflow-runner.js';
 export class WorkflowServiceNotInitialized extends Error {
 }
@@ -18,11 +17,11 @@ export class WorkflowStepNameNotString extends Error {
 export class PikkuWorkflowService {
     config;
     singletonServices;
-    createSessionServices;
+    createWireServices;
     constructor() { }
-    setServices(singletonServices, createSessionServices, { workflow }) {
+    setServices(singletonServices, createWireServices, { workflow }) {
         this.singletonServices = singletonServices;
-        this.createSessionServices = createSessionServices;
+        this.createWireServices = createWireServices;
         this.config = {
             retries: workflow?.retries ?? 0,
             retryDelay: workflow?.retryDelay ?? 0,
@@ -84,49 +83,30 @@ export class PikkuWorkflowService {
         return { runId };
     }
     async runWorkflowJob(runId, rpcService) {
-        // Get the run
         const run = await this.getRun(runId);
         if (!run) {
             throw new WorkflowRunNotFound(runId);
         }
-        // Get workflow registration
         const registrations = pikkuState('workflows', 'registrations');
         const workflow = registrations.get(run.workflow);
         if (!workflow) {
             throw new WorkflowNotFoundError(run.workflow);
         }
-        // Use lock to prevent concurrent execution
         await this.withRunLock(runId, async () => {
-            // Create workflow interaction object
-            const workflowInteraction = this.createWorkflowInteraction(run.workflow, runId, rpcService);
-            // Get function metadata
             const meta = pikkuState('workflows', 'meta');
             const workflowMeta = meta[run.workflow];
-            // Execute workflow function with workflow interaction
+            const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService);
+            const wire = { workflow: workflowWire };
             try {
-                const getAllServices = () => {
-                    let sessionServices = {};
-                    const interaction = { workflow: workflowInteraction };
-                    if (this.createSessionServices) {
-                        sessionServices = this.createSessionServices(this.singletonServices, interaction, undefined);
-                    }
-                    return {
-                        ...this.singletonServices,
-                        ...sessionServices,
-                        ...interaction,
-                    };
-                };
-                const result = await runPikkuFunc(PikkuWiringTypes.workflow, workflowMeta.workflowName, workflowMeta.pikkuFuncName, {
+                const result = await runPikkuFunc('workflow', workflowMeta.workflowName, workflowMeta.pikkuFuncName, {
                     singletonServices: this.singletonServices,
-                    interaction: { workflow: workflowInteraction },
-                    getAllServices,
+                    wire,
+                    createWireServices: this.createWireServices,
                     data: () => run.input,
                 });
-                // Workflow completed successfully
                 await this.updateRunStatus(runId, 'completed', result);
             }
             catch (error) {
-                // Check if it's a WorkflowAsyncException
                 if (error instanceof WorkflowAsyncException) {
                     // Normal - workflow paused for step execution
                     throw error;
@@ -136,7 +116,6 @@ export class PikkuWorkflowService {
                     // Workflow was cancelled - status already updated, just rethrow
                     throw error;
                 }
-                // Real error - mark as failed
                 await this.updateRunStatus(runId, 'failed', undefined, {
                     message: error.message,
                     stack: error.stack,
@@ -151,56 +130,59 @@ export class PikkuWorkflowService {
      * Handles idempotency, RPC execution, result storage, retry logic, and orchestrator triggering
      */
     async executeWorkflowStep(runId, stepName, rpcName, data, rpcService) {
-        // Get step state
-        let stepState = await this.getStepState(runId, stepName);
-        // Idempotency - if already succeeded, resume orchestrator and return
-        if (stepState.status === 'succeeded') {
-            await this.resumeWorkflow(runId);
-            return;
-        }
-        // Log warning if already running (race condition)
-        if (stepState.status === 'running') {
-            return;
-        }
-        // If status is 'failed', this is a retry - create new attempt history
-        if (stepState.status === 'failed') {
-            stepState = await this.createRetryAttempt(stepState.stepId, 'running');
-        }
-        if (stepState.status !== 'pending') {
-            // Mark step as running (pending or failed status)
-            await this.setStepRunning(stepState.stepId);
-        }
-        try {
-            // Execute RPC with workflow step context
-            const result = await rpcService.rpcWithInteraction(rpcName, data, {
-                workflowStep: {
-                    runId,
-                    stepId: stepState.stepId,
-                    attemptCount: stepState.attemptCount,
-                },
-            });
-            // Store result and mark succeeded
-            await this.setStepResult(stepState.stepId, result);
-            // Resume orchestrator to continue workflow
-            try {
+        // Use step-level lock to prevent concurrent execution of same step
+        await this.withStepLock(runId, stepName, async () => {
+            // Get step state
+            let stepState = await this.getStepState(runId, stepName);
+            // Idempotency - if already succeeded, resume orchestrator and return
+            if (stepState.status === 'succeeded') {
                 await this.resumeWorkflow(runId);
+                return;
             }
-            catch (resumeError) {
-                throw resumeError;
+            // Log warning if already running (race condition)
+            if (stepState.status === 'running') {
+                return;
             }
-        }
-        catch (error) {
-            // Store error and mark failed
-            await this.setStepError(stepState.stepId, error);
-            const maxAttempts = (stepState.retries ?? 0) + 1;
-            const retriesExhausted = stepState.attemptCount >= maxAttempts;
-            if (retriesExhausted) {
-                // No more retries - resume orchestrator to mark workflow as failed
-                await this.resumeWorkflow(runId);
+            // If status is 'failed', this is a retry - create new attempt history
+            if (stepState.status === 'failed') {
+                stepState = await this.createRetryAttempt(stepState.stepId, 'running');
             }
-            // Always throw so queue knows the job failed and can retry if needed
-            throw error;
-        }
+            if (stepState.status !== 'pending') {
+                // Mark step as running (pending or failed status)
+                await this.setStepRunning(stepState.stepId);
+            }
+            try {
+                // Execute RPC with workflow step context
+                const result = await rpcService.rpcWithWire(rpcName, data, {
+                    workflowStep: {
+                        runId,
+                        stepId: stepState.stepId,
+                        attemptCount: stepState.attemptCount,
+                    },
+                });
+                // Store result and mark succeeded
+                await this.setStepResult(stepState.stepId, result);
+                // Resume orchestrator to continue workflow
+                try {
+                    await this.resumeWorkflow(runId);
+                }
+                catch (resumeError) {
+                    throw resumeError;
+                }
+            }
+            catch (error) {
+                // Store error and mark failed
+                await this.setStepError(stepState.stepId, error);
+                const maxAttempts = (stepState.retries ?? 0) + 1;
+                const retriesExhausted = stepState.attemptCount >= maxAttempts;
+                if (retriesExhausted) {
+                    // No more retries - resume orchestrator to mark workflow as failed
+                    await this.resumeWorkflow(runId);
+                }
+                // Always throw so queue knows the job failed and can retry if needed
+                throw error;
+            }
+        });
     }
     /**
      * Orchestrate workflow execution (called by orchestrator)
@@ -287,7 +269,7 @@ export class PikkuWorkflowService {
             const retryDelay = stepOptions?.retryDelay;
             const attemptCount = stepState.attemptCount;
             try {
-                const result = await rpcService.rpcWithInteraction(rpcName, data, {
+                const result = await rpcService.rpcWithWire(rpcName, data, {
                     workflowStep: {
                         runId,
                         stepId: stepState.stepId,
@@ -407,8 +389,8 @@ export class PikkuWorkflowService {
         // Throw cancellation exception to stop workflow execution
         throw new WorkflowCancelledException(runId, reason);
     }
-    createWorkflowInteraction(workflowName, runId, rpcService) {
-        const workflowInteraction = {
+    createWorkflowWire(workflowName, runId, rpcService) {
+        const workflowWire = {
             workflowName,
             runId,
             getRun: async () => (await this.getRun(runId)),
@@ -432,7 +414,7 @@ export class PikkuWorkflowService {
                 await this.cancelWorkflow(runId, reason);
             },
         };
-        return workflowInteraction;
+        return workflowWire;
     }
     verifyStepName(stepName) {
         if (typeof stepName !== 'string') {

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

@@ -1,5 +1,3 @@
-import type { CoreWorkflow } from './workflow.types.js';
-import type { CorePikkuFunctionConfig } from '../../function/functions.types.js';
 import { PikkuError } from '../../errors/error-handler.js';
 /**
  * Exception thrown when workflow needs to pause for async step
@@ -30,6 +28,7 @@ export declare class WorkflowRunNotFound extends PikkuError {
     constructor(runId: string);
 }
 /**
- * Register a workflow with the system
+ * Add a workflow to the system
+ * This is called by the generated workflow wirings
  */
-export declare const wireWorkflow: <PikkuFunctionConfig extends CorePikkuFunctionConfig<any, any, any> = CorePikkuFunctionConfig<any, any, any>>(workflow: CoreWorkflow<PikkuFunctionConfig>) => void;
+export declare const addWorkflow: (workflowName: string, workflowFunc: any) => void;

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

@@ -44,25 +44,22 @@ export class WorkflowRunNotFound extends PikkuError {
     }
 }
 /**
- * Register a workflow with the system
+ * Add a workflow to the system
+ * This is called by the generated workflow wirings
  */
-export const wireWorkflow = (workflow) => {
+export const addWorkflow = (workflowName, workflowFunc) => {
     // Get workflow metadata from inspector
     const meta = pikkuState('workflows', 'meta');
-    const workflowMeta = meta[workflow.name];
+    const workflowMeta = meta[workflowName];
     if (!workflowMeta) {
-        throw new Error(`Workflow metadata not found for '${workflow.name}'. Make sure to run the CLI to generate metadata.`);
+        throw new Error(`Workflow metadata not found for '${workflowName}'. Make sure to run the CLI to generate metadata.`);
     }
-    // Register the function with pikku
-    addFunction(workflowMeta.pikkuFuncName, {
-        func: workflow.func.func,
-        auth: workflow.func.auth,
-        permissions: workflow.func.permissions,
-        middleware: workflow.func.middleware,
-        tags: workflow.func.tags,
-        docs: workflow.func.docs,
-    });
     // Store workflow definition in state
     const registrations = pikkuState('workflows', 'registrations');
-    registrations.set(workflow.name, workflow);
+    registrations.set(workflowName, {
+        name: workflowName,
+        func: workflowFunc,
+    });
+    // Register the function with pikku
+    addFunction(workflowMeta.pikkuFuncName, workflowFunc);
 };

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

@@ -1,4 +1,4 @@
-import { PikkuDocs, MiddlewareMetadata, SerializedError, CoreSingletonServices, CreateSessionServices, CoreConfig } from '../../types/core.types.js';
+import { SerializedError, CoreSingletonServices, CreateWireServices, CoreConfig, CommonWireMeta } from '../../types/core.types.js';
 import { CorePikkuFunctionConfig } from '../../function/functions.types.js';
 export interface WorkflowServiceConfig {
     retries: number;
@@ -73,8 +73,6 @@ export interface StepState {
 export type CoreWorkflow<PikkuFunctionConfig extends CorePikkuFunctionConfig<any, any, any> = CorePikkuFunctionConfig<any, any, any>> = {
     /** Unique workflow name */
     name: string;
-    /** Description of the workflow */
-    description?: string;
     /** The workflow function */
     func: PikkuFunctionConfig;
     /** Middleware chain for this workflow */
@@ -83,8 +81,6 @@ export type CoreWorkflow<PikkuFunctionConfig extends CorePikkuFunctionConfig<any
     permissions?: PikkuFunctionConfig['permissions'];
     /** Tags for organization and filtering */
     tags?: string[];
-    /** Documentation metadata */
-    docs?: PikkuDocs;
 };
 /**
  * Workflow step options
@@ -100,30 +96,108 @@ export interface WorkflowStepOptions {
 /**
  * Type signature for workflow.do() RPC form - used by inspector
  */
-export type WorkflowInteractionDoRPC = <TOutput = any, TInput = any>(stepName: string, rpcName: string, data: TInput, options?: WorkflowStepOptions) => Promise<TOutput>;
+export type WorkflowWireDoRPC = <TOutput = any, TInput = any>(stepName: string, rpcName: string, data: TInput, options?: WorkflowStepOptions) => Promise<TOutput>;
 /**
  * Type signature for workflow.do() inline form - used by inspector
  */
-export type WorkflowInteractionDoInline = <T>(stepName: string, fn: () => Promise<T> | T, options?: WorkflowStepOptions) => Promise<T>;
+export type WorkflowWireDoInline = <T>(stepName: string, fn: () => Promise<T> | T, options?: WorkflowStepOptions) => Promise<T>;
 /**
  * Type signature for workflow.sleep() - used by inspector
  */
-export type WorkflowInteractionSleep = (stepName: string, duration: string) => Promise<void>;
+export type WorkflowWireSleep = (stepName: string, duration: string) => Promise<void>;
 /**
- * Workflow step metadata (extracted by inspector)
+ * Input source for step arguments in simple workflows
+ */
+export type InputSource = {
+    from: 'input';
+    path: string;
+} | {
+    from: 'outputVar';
+    name: string;
+    path?: string;
+} | {
+    from: 'item';
+    path: string;
+} | {
+    from: 'literal';
+    value: unknown;
+};
+/**
+ * Output binding for return statements in simple workflows
+ */
+export interface OutputBinding {
+    from: 'outputVar' | 'input';
+    name?: string;
+    path?: string;
+}
+/**
+ * RPC step metadata (base form)
  */
-export type WorkflowStepMeta = {
+export interface RpcStepMeta {
     /** RPC form - generates queue worker */
     type: 'rpc';
     /** Cache key (stepName from workflow.do) */
     stepName: string;
     /** RPC to invoke */
     rpcName: string;
-    /** Display name */
-    description?: string;
+    /** Output variable name (if assigned) */
+    outputVar?: string;
+    /** Input source mappings */
+    inputs?: Record<string, InputSource>;
     /** Step options */
     options?: WorkflowStepOptions;
-} | {
+}
+/**
+ * Branch step metadata (if/else control flow)
+ */
+export interface BranchStepMeta {
+    type: 'branch';
+    /** Condition expression (as source string) */
+    condition: string;
+    /** Branch paths */
+    branches: {
+        then: WorkflowStepMeta[];
+        else?: WorkflowStepMeta[];
+    };
+}
+/**
+ * Parallel group step metadata (Promise.all with multiple steps)
+ */
+export interface ParallelGroupStepMeta {
+    type: 'parallel';
+    /** Child steps to execute in parallel */
+    children: RpcStepMeta[];
+}
+/**
+ * Fanout step metadata (parallel or sequential iteration)
+ */
+export interface FanoutStepMeta {
+    type: 'fanout';
+    /** Step name for this fanout */
+    stepName: string;
+    /** Source array variable name */
+    sourceVar: string;
+    /** Iterator variable name */
+    itemVar: string;
+    /** Execution mode */
+    mode: 'parallel' | 'sequential';
+    /** Child step to execute per iteration */
+    child: RpcStepMeta;
+    /** Time between iterations (sequential mode only) */
+    timeBetween?: string;
+}
+/**
+ * Return step metadata (workflow output)
+ */
+export interface ReturnStepMeta {
+    type: 'return';
+    /** Output bindings */
+    outputs: Record<string, OutputBinding>;
+}
+/**
+ * Inline step metadata (legacy support)
+ */
+export interface InlineStepMeta {
     /** Inline form - local execution */
     type: 'inline';
     /** Cache key (stepName from workflow.do) */
@@ -132,19 +206,34 @@ export type WorkflowStepMeta = {
     description?: string;
     /** Step options */
     options?: WorkflowStepOptions;
-} | {
+}
+/**
+ * Sleep step metadata
+ */
+export interface SleepStepMeta {
     /** Sleep step */
     type: 'sleep';
     /** Cache key (stepName from workflow.sleep) */
     stepName: string;
     /** Sleep duration */
     duration: string | number;
-};
+}
+/**
+ * Cancel step metadata
+ */
+export interface CancelStepMeta {
+    /** Cancel step */
+    type: 'cancel';
+}
 /**
- * Workflow step interaction context for RPC functions
+ * Workflow step metadata (extracted by inspector)
+ */
+export type WorkflowStepMeta = RpcStepMeta | BranchStepMeta | ParallelGroupStepMeta | FanoutStepMeta | ReturnStepMeta | InlineStepMeta | SleepStepMeta | CancelStepMeta;
+/**
+ * Workflow step wire context for RPC functions
  * Provides step-level metadata including retry attempt tracking
  */
-export interface WorkflowStepInteraction {
+export interface WorkflowStepWire {
     /** The workflow run ID */
     runId: string;
     /** The unique step ID */
@@ -153,10 +242,10 @@ export interface WorkflowStepInteraction {
     attemptCount: number;
 }
 /**
- * Workflow interaction object for middleware
+ * Workflow wire object for middleware
  * Provides workflow-specific capabilities to function execution
  */
-export interface PikkuWorkflowInteraction {
+export interface PikkuWorkflowWire {
     /** The workflow name */
     workflowName: string;
     /** The current run ID */
@@ -164,9 +253,9 @@ export interface PikkuWorkflowInteraction {
     /** Get the current workflow run */
     getRun: () => Promise<WorkflowRun>;
     /** Execute a workflow step (overloaded - RPC or inline form) */
-    do: WorkflowInteractionDoRPC & WorkflowInteractionDoInline;
+    do: WorkflowWireDoRPC & WorkflowWireDoInline;
     /** Sleep for a duration */
-    sleep: WorkflowInteractionSleep;
+    sleep: WorkflowWireSleep;
     /** Cancel the current workflow run */
     cancel: (reason?: string) => Promise<void>;
 }
@@ -186,15 +275,11 @@ export interface PikkuWorkflow {
 /**
  * Workflows metadata for inspector/CLI
  */
-export type WorkflowsMeta = Record<string, {
-    pikkuFuncName: string;
+export type WorkflowsMeta = Record<string, CommonWireMeta & {
     workflowName: string;
-    description?: string;
-    session?: undefined;
-    docs?: PikkuDocs;
-    tags?: string[];
-    middleware?: MiddlewareMetadata[];
     steps: WorkflowStepMeta[];
+    /** Whether this workflow conforms to simple workflow DSL */
+    simple?: boolean;
 }>;
 /**
  * Interface for workflow orchestration
@@ -210,7 +295,7 @@ export interface WorkflowService {
     withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
     close(): Promise<void>;
     resumeWorkflow(runId: string): Promise<void>;
-    setServices(singletonServices: CoreSingletonServices, createSessionServices: CreateSessionServices, config: CoreConfig): void;
+    setServices(singletonServices: CoreSingletonServices, createWireServices: CreateWireServices, config: CoreConfig): void;
     startWorkflow<I>(name: string, input: I, rpcService: any): Promise<{
         runId: string;
     }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -42,7 +42,7 @@
     "picoquery": "^2.5.0"
   },
   "devDependencies": {
-    "@types/node": "^24.9.1",
+    "@types/node": "^24.10.1",
     "tsx": "^4.20.6",
     "typescript": "^5.9"
   },

package/src/errors/errors.ts

@@ -3,10 +3,10 @@
  */
 import { addError, PikkuError } from './error-handler.js'
 
-export class InvalidMiddlewareInteractionError extends PikkuError {}
-addError(InvalidMiddlewareInteractionError, {
+export class InvalidMiddlewareWireError extends PikkuError {}
+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.',
 })
 
 /**

package/src/factory-functions.test.ts

@@ -7,44 +7,22 @@ import {
   pikkuMiddlewareFactory,
 } from './index.js'
 
-test('pikkuPermission factory function', async () => {
-  const permission = pikkuPermission(async ({ logger }, data, session) => {
-    return true
-  })
-
-  assert.strictEqual(typeof permission, 'function')
-  assert.strictEqual(permission.length, 3) // services, data, session
-})
-
-test('pikkuMiddleware factory function', async () => {
-  const middleware = pikkuMiddleware(async ({ logger }, interactions, next) => {
-    await next()
-  })
-
-  assert.strictEqual(typeof middleware, 'function')
-  assert.strictEqual(middleware.length, 3) // services, interactions, next
-})
-
 test('pikkuPermission returns the same function', async () => {
-  const originalFn = async ({ logger }, data, session) => true
+  const originalFn = async () => true
   const wrappedFn = pikkuPermission(originalFn)
-
   assert.strictEqual(wrappedFn, originalFn)
 })
 
 test('pikkuMiddleware returns the same function', async () => {
-  const originalFn = async ({ logger }, interactions, next) => {
-    await next()
-  }
+  const originalFn = async ({ logger }, wires, next) => next
   const wrappedFn = pikkuMiddleware(originalFn)
-
   assert.strictEqual(wrappedFn, originalFn)
 })
 
 test('pikkuPermissionFactory creates a factory function', async () => {
   const factory = pikkuPermissionFactory<{ role: string }>(({ role }) => {
-    return pikkuPermission(async ({ logger }, data, session) => {
-      return session?.role === role
+    return pikkuPermission(async ({ logger }, data, { initialSession }) => {
+      return (initialSession as any)?.role === role
     })
   })
 
@@ -59,7 +37,7 @@ test('pikkuPermissionFactory creates a factory function', async () => {
 
 test('pikkuMiddlewareFactory creates a factory function', async () => {
   const factory = pikkuMiddlewareFactory<{ message: string }>(({ message }) => {
-    return pikkuMiddleware(async ({ logger }, interactions, next) => {
+    return pikkuMiddleware(async ({ logger }, wires, next) => {
       logger.info(message)
       await next()
     })
@@ -71,26 +49,21 @@ test('pikkuMiddlewareFactory creates a factory function', async () => {
   // Call the factory to get middleware
   const middleware = factory({ message: 'test' })
   assert.strictEqual(typeof middleware, 'function')
-  assert.strictEqual(middleware.length, 3) // services, interactions, next
+  assert.strictEqual(middleware.length, 3) // services, wires, next
 })
 
 test('pikkuPermissionFactory returns the same factory', async () => {
-  const originalFactory = ({ role }) =>
-    pikkuPermission(async ({ logger }, data, session) => {
-      return session?.role === role
-    })
-  const wrappedFactory = pikkuPermissionFactory(originalFactory)
-
+  const originalFactory = () => pikkuPermission(async () => true)
+  const wrappedFactory = pikkuPermissionFactory(originalFactory as any)
   assert.strictEqual(wrappedFactory, originalFactory)
 })
 
 test('pikkuMiddlewareFactory returns the same factory', async () => {
   const originalFactory = ({ message }) =>
-    pikkuMiddleware(async ({ logger }, interactions, next) => {
+    pikkuMiddleware(async ({ logger }, _wires, next) => {
       logger.info(message)
       await next()
     })
   const wrappedFactory = pikkuMiddlewareFactory(originalFactory)
-
   assert.strictEqual(wrappedFactory, originalFactory)
 })