@pikku/core 0.9.11 → 0.9.12-next.0

package/src/function/function-runner.test.ts

@@ -17,14 +17,19 @@ beforeEach(() => {
 // Helper function to add function with metadata for tests
 const addTestFunction = (funcName: string, funcConfig: any) => {
   addFunction(funcName, funcConfig)
+  // Convert tags to middleware metadata
+  const middleware = funcConfig.tags
+    ? funcConfig.tags.map((tag: string) => ({ type: 'tag' as const, tag }))
+    : undefined
   pikkuState('function', 'meta')[funcName] = {
     pikkuFuncName: funcName,
     inputSchemaName: null,
     outputSchemaName: null,
+    middleware,
   }
 }
 
-const mockServices: CoreServices = {
+const mockSingletonServices = {
   logger: {
     info: () => {},
     warn: () => {},
@@ -33,8 +38,12 @@ const mockServices: CoreServices = {
   },
 } as any
 
+const mockServices: CoreServices = {
+  ...mockSingletonServices,
+} as any
+
 describe('runPikkuFunc - Integration Tests', () => {
-  test('should execute middleware in correct order: wiringTags → wiringMiddleware → funcMiddleware → funcTags', async () => {
+  test('should execute middleware in correct order: wiringTags → wiringMiddleware → funcTags → funcMiddleware', async () => {
     const executionOrder: string[] = []
     const createMiddleware = (name: string): CorePikkuMiddleware => {
       return async (services, interaction, next) => {
@@ -61,20 +70,23 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
-        middleware: [createMiddleware('wiringMiddleware')],
-        tags: ['wiringTag'],
+        data: () => ({}),
+        wireMiddleware: [createMiddleware('wiringMiddleware')],
+        inheritedMiddleware: [{ type: 'tag', tag: 'wiringTag' }],
+        auth: false,
+        interaction: {},
       }
     )
 
     assert.equal(result, 'success')
-    // Order: wiringTags, wiringMiddleware, funcMiddleware, funcTags
+    // Order: wireInheritedMiddleware (tags), wireMiddleware, funcInheritedMiddleware (tags), funcMiddleware
     assert.deepEqual(executionOrder, [
       'wiringTag',
       'wiringMiddleware',
-      'funcMiddleware',
       'funcTag',
+      'funcMiddleware',
       'main',
     ])
   })
@@ -128,10 +140,13 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
         permissions: wiringPermissions,
         tags: ['wiringTag'],
+        auth: false,
+        interaction: {},
       }
     )
 
@@ -157,9 +172,12 @@ describe('runPikkuFunc - Integration Tests', () => {
 
     await assert.rejects(
       runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
         tags: ['wiringTag'],
+        auth: false,
+        interaction: {},
       }),
       {
         message: 'Permission denied',
@@ -178,9 +196,12 @@ describe('runPikkuFunc - Integration Tests', () => {
 
     await assert.rejects(
       runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
         permissions: wiringPermissions,
+        auth: false,
+        interaction: {},
       }),
       {
         message: 'Permission denied',
@@ -200,8 +221,11 @@ describe('runPikkuFunc - Integration Tests', () => {
 
     await assert.rejects(
       runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
+        auth: false,
+        interaction: {},
       }),
       {
         message: 'Permission denied',
@@ -221,8 +245,11 @@ describe('runPikkuFunc - Integration Tests', () => {
 
     await assert.rejects(
       runPikkuFunc(PikkuWiringTypes.rpc, Math.random().toString(), 'testFunc', {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
+        auth: false,
+        interaction: {},
       }),
       {
         message: 'Permission denied',
@@ -256,8 +283,11 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
+        auth: false,
+        interaction: {},
       }
     )
 
@@ -305,8 +335,11 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
+        auth: false,
+        interaction: {},
       }
     )
 
@@ -330,8 +363,11 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'simpleFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
+        auth: false,
+        interaction: {},
       }
     )
 
@@ -371,17 +407,21 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
-        middleware: [wiringMiddleware],
+        data: () => ({}),
+        wireMiddleware: [wiringMiddleware],
         permissions: wiringPermissions,
+        auth: false,
+        interaction: {},
       }
     )
 
     assert.equal(result, 'success')
+    // Permissions run after middleware (middleware can set/modify session)
     assert.deepEqual(executionOrder, [
-      'wiringPermission',
       'wiringMiddleware',
+      'wiringPermission',
       'main',
     ])
   })
@@ -421,15 +461,19 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: {},
+        data: () => ({}),
+        auth: false,
+        interaction: {},
       }
     )
 
     assert.equal(result, 'success')
+    // Permissions run after middleware (middleware can set/modify session)
     assert.deepEqual(executionOrder, [
-      'funcPermission',
       'funcMiddleware',
+      'funcPermission',
       'main',
     ])
   })
@@ -456,9 +500,12 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: () => mockServices,
-        data: testData,
-        session: testSession,
+        data: () => testData,
+        userSession: { get: () => testSession, set: () => {} } as any,
+        auth: false,
+        interaction: {},
       }
     )
 
@@ -488,8 +535,11 @@ describe('runPikkuFunc - Integration Tests', () => {
       Math.random().toString(),
       'testFunc',
       {
+        singletonServices: mockSingletonServices,
         getAllServices: asyncGetServices,
-        data: {},
+        data: () => ({}),
+        auth: false,
+        interaction: {},
       }
     )
 

package/src/function/function-runner.ts

@@ -1,4 +1,3 @@
-import { ForbiddenError } from '../errors/errors.js'
 import { runMiddleware, combineMiddleware } from '../middleware-runner.js'
 import { runPermissions } from '../permissions.js'
 import { pikkuState } from '../pikku-state.js'
@@ -8,24 +7,21 @@ import {
   CoreUserSession,
   CorePikkuMiddleware,
   PikkuWiringTypes,
+  CoreSingletonServices,
+  PikkuInteraction,
+  MiddlewareMetadata,
 } from '../types/core.types.js'
 import {
   CorePermissionGroup,
-  CorePikkuFunction,
   CorePikkuFunctionConfig,
-  CorePikkuFunctionSessionless,
 } from './functions.types.js'
+import { UserSessionService } from '../services/user-session-service.js'
+import { ForbiddenError } from '../errors/errors.js'
 
 export const addFunction = (
   funcName: string,
-  funcConfig:
-    | CorePikkuFunctionConfig<any, any>
-    | CorePikkuFunctionSessionless<any, any>
-    | CorePikkuFunction<any, any>
+  funcConfig: CorePikkuFunctionConfig<any, any>
 ) => {
-  if (funcConfig instanceof Function) {
-    funcConfig = { func: funcConfig }
-  }
   pikkuState('function', 'functions').set(funcName, funcConfig)
 }
 
@@ -48,20 +44,30 @@ export const runPikkuFunc = async <In = any, Out = any>(
   funcName: string,
   {
     getAllServices,
+    singletonServices,
     data,
-    session,
+    userSession,
+    auth: wiringAuth,
     permissions: wiringPermissions,
-    middleware: wiringMiddleware,
+    inheritedMiddleware,
+    wireMiddleware,
     coerceDataFromSchema,
     tags = [],
+    interaction,
   }: {
-    getAllServices: () => Promise<CoreServices> | CoreServices
-    data: In
-    session?: CoreUserSession
+    singletonServices: CoreSingletonServices
+    getAllServices: (
+      session?: CoreUserSession
+    ) => Promise<CoreServices> | CoreServices
+    userSession?: UserSessionService<CoreUserSession>
+    data: () => Promise<In> | In
+    auth?: boolean
     permissions?: CorePermissionGroup
-    middleware?: CorePikkuMiddleware[]
+    inheritedMiddleware?: MiddlewareMetadata[]
+    wireMiddleware?: CorePikkuMiddleware[]
     coerceDataFromSchema?: boolean
     tags?: string[]
+    interaction: PikkuInteraction
   }
 ): Promise<Out> => {
   const funcConfig = pikkuState('function', 'functions').get(funcName)
@@ -73,60 +79,73 @@ export const runPikkuFunc = async <In = any, Out = any>(
     throw new Error(`Function meta not found: ${funcName}`)
   }
 
-  if (funcConfig.auth && !session) {
-    throw new ForbiddenError(
-      `Function ${funcName} requires authentication even though transport does not`
-    )
-  }
+  // Helper function to run permissions and execute the function
+  const executeFunction = async () => {
+    const session = userSession?.get()
+    if (wiringAuth === true || funcConfig.auth === true) {
+      // This means it was explicitly enabled in either wiring or function and has to be respected
+      if (!session) {
+        throw new ForbiddenError('Authentication required')
+      }
+    }
+    if (wiringAuth === undefined && funcConfig.auth === undefined) {
+      // We always default to requiring auth unless explicitly disabled
+      if (!session) {
+        throw new ForbiddenError('Authentication required')
+      }
+    }
 
-  const allServices = await getAllServices()
+    // Evaluate the data from the lazy function
+    const actualData = await data()
 
-  const inputSchemaName = funcMeta.inputSchemaName
-  if (inputSchemaName) {
-    // Validate request data against the defined schema, if any
-    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(inputSchemaName, data)
+    // Validate and coerce data if schema is defined
+    const inputSchemaName = funcMeta.inputSchemaName
+    if (inputSchemaName) {
+      // Validate request data against the defined schema, if any
+      await validateSchema(
+        singletonServices.logger,
+        singletonServices.schema,
+        inputSchemaName,
+        actualData
+      )
+      // Coerce (top level) query string parameters or date objects if specified by the schema
+      if (coerceDataFromSchema) {
+        coerceTopLevelDataFromSchema(inputSchemaName, actualData)
+      }
     }
-  }
 
-  // Run permission checks in the specified order
-  await runPermissions(wireType, wireId, {
-    wiringTags: tags,
-    wiringPermissions,
-    funcTags: funcConfig.tags,
-    funcPermissions: funcConfig.permissions,
-    allServices,
-    data,
-    session,
-  })
+    const allServices = await getAllServices(session)
+    await runPermissions(wireType, wireId, {
+      wiringTags: tags,
+      wiringPermissions,
+      funcTags: funcConfig.tags,
+      funcPermissions: funcConfig.permissions,
+      allServices,
+      data: actualData,
+      session,
+    })
+    return await funcConfig.func(allServices, actualData, session!)
+  }
 
-  // Combine all middleware: wiring tags → wiring middleware → func middleware → func tags
+  // Combine all middleware: inheritedMiddleware → wireMiddleware → funcMiddleware
   const allMiddleware = combineMiddleware(wireType, wireId, {
-    wiringTags: tags,
-    wiringMiddleware,
+    wireInheritedMiddleware: inheritedMiddleware,
+    wireMiddleware,
+    funcInheritedMiddleware: funcMeta.middleware,
     funcMiddleware: funcConfig.middleware,
-    funcTags: funcConfig.tags,
   })
 
   if (allMiddleware.length > 0) {
     return (await runMiddleware<CorePikkuMiddleware>(
-      allServices,
       {
-        http: allServices.http,
-        mcp: allServices.mcp,
-        rpc: allServices.rpc,
+        ...singletonServices,
+        userSession,
       },
+      interaction,
       allMiddleware,
-      async () => await funcConfig.func(allServices, data, session!)
+      executeFunction
     )) as Out
   }
 
-  return (await funcConfig.func(allServices, data, session!)) as Out
+  return (await executeFunction()) as Out
 }

package/src/index.ts

@@ -16,12 +16,18 @@ export * from './wirings/scheduler/index.js'
 export * from './wirings/rpc/index.js'
 export * from './wirings/queue/index.js'
 export * from './wirings/mcp/index.js'
+export * from './wirings/cli/index.js'
 export * from './errors/index.js'
 export * from './middleware/index.js'
 export * from './utils.js'
 export * from './time-utils.js'
 export { pikkuState } from './pikku-state.js'
-export { addMiddleware, runMiddleware } from './middleware-runner.js'
+export {
+  runMiddleware,
+  registerMiddleware,
+  getMiddlewareByName,
+  addMiddleware,
+} from './middleware-runner.js'
 export { addPermission } from './permissions.js'
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js'
 export { wireChannel } from './wirings/channel/channel-runner.js'
@@ -41,3 +47,4 @@ export {
   getMCPToolsMeta,
   getMCPPromptsMeta,
 } from './wirings/mcp/mcp-runner.js'
+export { wireCLI, runCLICommand } from './wirings/cli/cli-runner.js'

package/src/middleware-runner.test.ts

@@ -55,7 +55,7 @@ describe('combineMiddleware', () => {
       PikkuWiringTypes.http,
       Math.random().toString(),
       {
-        wiringMiddleware: [mockMiddleware1, mockMiddleware2],
+        wireMiddleware: [mockMiddleware1, mockMiddleware2],
       }
     )
 
@@ -93,7 +93,7 @@ describe('combineMiddleware', () => {
     assert.equal(result[1], mockMiddleware2)
   })
 
-  test('should execute middleware in correct order: wiringTags → wiringMiddleware → funcMiddleware → funcTags', () => {
+  test('should execute middleware in correct order: wireInheritedMiddleware (tags) → wireMiddleware → funcInheritedMiddleware (tags) → funcMiddleware', () => {
     // Setup tagged middleware
     const wiringTagMiddleware: CorePikkuMiddleware = async (
       services,
@@ -132,19 +132,19 @@ describe('combineMiddleware', () => {
       PikkuWiringTypes.http,
       Math.random().toString(),
       {
-        wiringMiddleware: [wiringMiddleware],
-        wiringTags: ['wiringTag'],
+        wireInheritedMiddleware: [{ type: 'tag', tag: 'wiringTag' }],
+        wireMiddleware: [wiringMiddleware],
+        funcInheritedMiddleware: [{ type: 'tag', tag: 'funcTag' }],
         funcMiddleware: [funcMiddleware],
-        funcTags: ['funcTag'],
       }
     )
 
     assert.equal(result.length, 4)
-    // Order: wiringTags, wiringMiddleware, funcMiddleware, funcTags
-    assert.equal(result[0], wiringTagMiddleware) // wiringTags first
-    assert.equal(result[1], wiringMiddleware) // wiringMiddleware second
-    assert.equal(result[2], funcMiddleware) // funcMiddleware third
-    assert.equal(result[3], funcTagMiddleware) // funcTags last
+    // Order: wireInheritedMiddleware (tags), wireMiddleware, funcInheritedMiddleware (tags), funcMiddleware
+    assert.equal(result[0], wiringTagMiddleware) // wireInheritedMiddleware tags first
+    assert.equal(result[1], wiringMiddleware) // wireMiddleware second
+    assert.equal(result[2], funcTagMiddleware) // funcInheritedMiddleware tags third
+    assert.equal(result[3], funcMiddleware) // funcMiddleware last
   })
 
   test('should handle wiring tags only', () => {
@@ -162,7 +162,7 @@ describe('combineMiddleware', () => {
       PikkuWiringTypes.http,
       Math.random().toString(),
       {
-        wiringTags: ['testTag'],
+        wireInheritedMiddleware: [{ type: 'tag', tag: 'testTag' }],
       }
     )
 
@@ -185,7 +185,7 @@ describe('combineMiddleware', () => {
       PikkuWiringTypes.http,
       Math.random().toString(),
       {
-        funcTags: ['funcTestTag'],
+        funcInheritedMiddleware: [{ type: 'tag', tag: 'funcTestTag' }],
       }
     )
 
@@ -216,7 +216,10 @@ describe('combineMiddleware', () => {
       PikkuWiringTypes.http,
       Math.random().toString(),
       {
-        wiringTags: ['tag1', 'tag2'],
+        wireInheritedMiddleware: [
+          { type: 'tag', tag: 'tag1' },
+          { type: 'tag', tag: 'tag2' },
+        ],
       }
     )
 
@@ -240,8 +243,13 @@ describe('combineMiddleware', () => {
       PikkuWiringTypes.http,
       Math.random().toString(),
       {
-        wiringTags: ['existingTag', 'nonExistentTag'],
-        funcTags: ['anotherNonExistentTag'],
+        wireInheritedMiddleware: [
+          { type: 'tag', tag: 'existingTag' },
+          { type: 'tag', tag: 'nonExistentTag' },
+        ],
+        funcInheritedMiddleware: [
+          { type: 'tag', tag: 'anotherNonExistentTag' },
+        ],
       }
     )
 
@@ -276,7 +284,7 @@ describe('runMiddleware', () => {
       {} as any,
       {} as any,
       combineMiddleware(PikkuWiringTypes.rpc, Math.random().toString(), {
-        wiringMiddleware: [middleware1, middleware2, middleware1, middleware2],
+        wireMiddleware: [middleware1, middleware2, middleware1, middleware2],
       }),
       async () => {
         executionOrder.push('main')