@pikku/core 0.11.2 → 0.12.1

package/src/middleware-runner.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   CoreSingletonServices,
   PikkuWire,
   CorePikkuMiddleware,
@@ -7,7 +7,7 @@ import {
   MiddlewareMetadata,
 } from './types/core.types.js'
 import { pikkuState } from './pikku-state.js'
-import { freezeDedupe } from './utils.js'
+import { freezeDedupe, getTagGroups } from './utils.js'
 
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
@@ -96,7 +96,7 @@ export const addMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
  * This function looks up middleware that was registered with registerMiddleware.
  * It's used internally by the framework to resolve middleware references in metadata.
  *
- * @param {string} name - The unique name (pikkuFuncName) of the middleware function.
+ * @param {string} name - The unique name (pikkuFuncId) of the middleware function.
  * @returns {CorePikkuMiddleware | undefined} The middleware function, or undefined if not found.
  *
  * @internal
@@ -116,7 +116,9 @@ const middlewareCache: Record<
   channel: {},
   queue: {},
   scheduler: {},
+  trigger: {},
   mcp: {},
+  agent: {},
   cli: {},
   workflow: {},
 }
@@ -179,12 +181,11 @@ export const combineMiddleware = (
           resolved.push(...(group as CorePikkuMiddleware[]))
         }
       } else if (meta.type === 'tag') {
-        // Look up tag middleware group from pikkuState
-        const group = pikkuState(packageName, 'middleware', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'middleware', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
-          // At runtime, all factories should be resolved to middleware
+        )
+        for (const group of groups) {
           resolved.push(...(group as CorePikkuMiddleware[]))
         }
       } else if (meta.type === 'wire') {
@@ -206,12 +207,11 @@ export const combineMiddleware = (
   if (funcInheritedMiddleware) {
     for (const meta of funcInheritedMiddleware) {
       if (meta.type === 'tag') {
-        // Look up tag middleware group from pikkuState
-        const group = pikkuState(packageName, 'middleware', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'middleware', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
-          // At runtime, all factories should be resolved to middleware
+        )
+        for (const group of groups) {
           resolved.push(...(group as CorePikkuMiddleware[]))
         }
       }

package/src/permissions.test.ts

@@ -2,8 +2,8 @@ import { describe, test, beforeEach } from 'node:test'
 import * as assert from 'node:assert'
 import { addPermission, runPermissions } from './permissions.js'
 import { pikkuState, resetPikkuState } from './pikku-state.js'
-import { CoreServices, CoreUserSession } from './types/core.types.js'
-import {
+import type { CoreServices, CoreUserSession } from './types/core.types.js'
+import type {
   CorePermissionGroup,
   CorePikkuPermission,
 } from './function/functions.types.js'
@@ -82,6 +82,85 @@ describe('addPermission', () => {
     assert.equal(permissions[0], mockPermissionGroup)
   })
 
+  test('should apply parent tag permission to namespaced tag via runPermissions', async () => {
+    const billingPermission = async () => true
+
+    addPermission('billing', [billingPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      wireInheritedPermissions: [{ type: 'tag', tag: 'billing:write' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+  })
+
+  test('should apply both parent and exact tag permissions', async () => {
+    const executionOrder: string[] = []
+    const billingPermission = async () => {
+      executionOrder.push('billing')
+      return true
+    }
+    const billingReadPermission = async () => {
+      executionOrder.push('billing:read')
+      return true
+    }
+
+    addPermission('billing', [billingPermission])
+    addPermission('billing:read', [billingReadPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      wireInheritedPermissions: [{ type: 'tag', tag: 'billing:read' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+
+    assert.deepEqual(executionOrder, ['billing:read'])
+  })
+
+  test('should resolve multi-level namespace permissions', async () => {
+    const executionOrder: string[] = []
+    const billingPermission = async () => {
+      executionOrder.push('billing')
+      return false
+    }
+    const billingReadPermission = async () => {
+      executionOrder.push('billing:read')
+      return false
+    }
+    const billingReadAdminPermission = async () => {
+      executionOrder.push('billing:read:admin')
+      return true
+    }
+
+    addPermission('billing', [billingPermission])
+    addPermission('billing:read', [billingReadPermission])
+    addPermission('billing:read:admin', [billingReadAdminPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      wireInheritedPermissions: [{ type: 'tag', tag: 'billing:read:admin' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+
+    assert.deepEqual(executionOrder, ['billing:read:admin'])
+  })
+
+  test('should apply parent tag permission via funcInheritedPermissions', async () => {
+    const billingPermission = async () => true
+
+    addPermission('billing', [billingPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      funcInheritedPermissions: [{ type: 'tag', tag: 'billing:delete' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+  })
+
   test('should throw error when tag already exists', () => {
     const mockPermission = async () => true
 
@@ -171,13 +250,8 @@ describe('runPermissions', () => {
       data: {},
     })
 
-    // Order: wireInheritedPermissions (wiringTag) → wirePermissions → funcInheritedPermissions (funcTag) → funcPermissions
-    assert.deepEqual(executionOrder, [
-      'wiringTag',
-      'wiringPermission',
-      'funcTag',
-      'funcPermission',
-    ])
+    // Order: wireInheritedPermissions (wiringTag) only (short-circuit on first passing group)
+    assert.deepEqual(executionOrder, ['wiringTag'])
   })
 
   test('should implement "at least one must pass" logic for tag permissions', async () => {

package/src/permissions.ts

@@ -1,16 +1,16 @@
-import {
+import type {
   CoreServices,
   PikkuWiringTypes,
   PermissionMetadata,
   PikkuWire,
 } from './types/core.types.js'
-import {
+import type {
   CorePermissionGroup,
   CorePikkuPermission,
 } from './function/functions.types.js'
 import { pikkuState } from './pikku-state.js'
 import { ForbiddenError } from './errors/errors.js'
-import { freezeDedupe } from './utils.js'
+import { freezeDedupe, getTagGroups } 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.
@@ -59,7 +59,7 @@ const verifyPermissions = async <Out = any>(
  * This function looks up permissions that was registered with registerPermission.
  * It's used internally by the framework to resolve permission references in metadata.
  *
- * @param {string} name - The unique name (pikkuFuncName) of the permission function.
+ * @param {string} name - The unique name (pikkuFuncId) of the permission function.
  * @returns {CorePikkuPermission | undefined} The permission function, or undefined if not found.
  *
  * @internal
@@ -125,7 +125,9 @@ const combinedPermissionsCache: Record<
   channel: {},
   queue: {},
   scheduler: {},
+  trigger: {},
   mcp: {},
+  agent: {},
   cli: {},
   workflow: {},
 }
@@ -193,11 +195,11 @@ const combinePermissions = (
           }
         }
       } else if (meta.type === 'tag') {
-        // Look up tag permission group from pikkuState
-        const group = pikkuState(packageName, 'permissions', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'permissions', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
+        )
+        for (const group of groups) {
           if (Array.isArray(group)) {
             resolved.push(...group)
           } else {
@@ -227,11 +229,11 @@ const combinePermissions = (
   if (funcInheritedPermissions) {
     for (const meta of funcInheritedPermissions) {
       if (meta.type === 'tag') {
-        // Look up tag permission group from pikkuState
-        const group = pikkuState(packageName, 'permissions', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'permissions', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
+        )
+        for (const group of groups) {
           if (Array.isArray(group)) {
             resolved.push(...group)
           } else {
@@ -299,7 +301,6 @@ export const runPermissions = async (
 
   // Check all combined permissions - at least one must pass if any exist
   if (allPermissions.length > 0) {
-    let permissioned = false
     for (const permission of allPermissions) {
       const result = await verifyPermissions(
         typeof permission === 'function' ? { permission } : permission,
@@ -308,13 +309,10 @@ export const runPermissions = async (
         wire
       )
       if (result) {
-        permissioned = true
-        // Continue executing all permissions (don't break early)
+        return
       }
     }
-    if (!permissioned) {
-      services.logger.debug('Permission denied - combined permissions')
-      throw new ForbiddenError('Permission denied')
-    }
+    services.logger.debug('Permission denied - combined permissions')
+    throw new ForbiddenError('Permission denied')
   }
 }

package/src/pikku-state.test.ts

@@ -0,0 +1,224 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert'
+import {
+  pikkuState,
+  resetPikkuState,
+  initializePikkuState,
+  getAllPackageStates,
+  getSingletonServices,
+  getCreateWireServices,
+  getPikkuMetaDir,
+  addPackageServiceFactories,
+} from './pikku-state.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+describe('pikkuState', () => {
+  test('should get state for main package with null name', () => {
+    const functions = pikkuState(null, 'function', 'functions')
+    assert.ok(functions instanceof Map)
+  })
+
+  test('should get state for main package with __main__ name', () => {
+    const functions = pikkuState('__main__', 'function', 'functions')
+    assert.ok(functions instanceof Map)
+  })
+
+  test('should set and get state values', () => {
+    const testMeta = { key: 'value' }
+    pikkuState(null, 'function', 'meta', testMeta as any)
+    const result = pikkuState(null, 'function', 'meta')
+    assert.deepStrictEqual(result, testMeta)
+  })
+
+  test('should auto-initialize package state on first access', () => {
+    const states = getAllPackageStates()
+    assert.ok(!states.has('@test/package'))
+
+    pikkuState('@test/package', 'function', 'functions')
+
+    assert.ok(states.has('@test/package'))
+  })
+
+  test('should isolate state between packages', () => {
+    pikkuState(null, 'function', 'meta', { main: true } as any)
+    pikkuState('@addon/pkg', 'function', 'meta', { addon: true } as any)
+
+    assert.deepStrictEqual(pikkuState(null, 'function', 'meta'), { main: true })
+    assert.deepStrictEqual(pikkuState('@addon/pkg', 'function', 'meta'), {
+      addon: true,
+    })
+  })
+
+  test('should return correct state types', () => {
+    const httpRoutes = pikkuState(null, 'http', 'routes')
+    assert.ok(httpRoutes instanceof Map)
+
+    const schemas = pikkuState(null, 'misc', 'schemas')
+    assert.ok(schemas instanceof Map)
+
+    const errors = pikkuState(null, 'misc', 'errors')
+    assert.ok(errors instanceof Map)
+  })
+})
+
+describe('getAllPackageStates', () => {
+  test('should return a Map', () => {
+    const states = getAllPackageStates()
+    assert.ok(states instanceof Map)
+  })
+
+  test('should contain __main__ after reset', () => {
+    const states = getAllPackageStates()
+    assert.ok(states.has('__main__'))
+  })
+
+  test('should return same reference on multiple calls', () => {
+    const states1 = getAllPackageStates()
+    const states2 = getAllPackageStates()
+    assert.strictEqual(states1, states2)
+  })
+})
+
+describe('initializePikkuState', () => {
+  test('should create a new package state', () => {
+    const states = getAllPackageStates()
+    assert.ok(!states.has('@new/package'))
+
+    initializePikkuState('@new/package')
+
+    assert.ok(states.has('@new/package'))
+  })
+
+  test('should not overwrite existing package state', () => {
+    pikkuState('@existing/pkg', 'function', 'meta', { test: true } as any)
+
+    initializePikkuState('@existing/pkg')
+
+    const meta = pikkuState('@existing/pkg', 'function', 'meta')
+    assert.deepStrictEqual(meta, { test: true })
+  })
+})
+
+describe('resetPikkuState', () => {
+  test('should clear all package states', () => {
+    initializePikkuState('@addon/one')
+    initializePikkuState('@addon/two')
+    assert.ok(getAllPackageStates().has('@addon/one'))
+
+    resetPikkuState()
+
+    assert.ok(!getAllPackageStates().has('@addon/one'))
+    assert.ok(!getAllPackageStates().has('@addon/two'))
+  })
+
+  test('should preserve errors map from __main__', () => {
+    const errors = pikkuState(null, 'misc', 'errors')
+    errors.set('TestError', { status: 400, message: 'test' })
+
+    resetPikkuState()
+
+    const restoredErrors = pikkuState(null, 'misc', 'errors')
+    assert.strictEqual(restoredErrors.get('TestError')?.message, 'test')
+  })
+
+  test('should re-initialize __main__ package', () => {
+    resetPikkuState()
+
+    const states = getAllPackageStates()
+    assert.ok(states.has('__main__'))
+    assert.ok(pikkuState(null, 'function', 'functions') instanceof Map)
+  })
+
+  test('should create fresh state objects after reset', () => {
+    const functionsBefore = pikkuState(null, 'function', 'functions')
+    functionsBefore.set('testFunc', {} as any)
+
+    resetPikkuState()
+
+    const functionsAfter = pikkuState(null, 'function', 'functions')
+    assert.strictEqual(functionsAfter.size, 0)
+  })
+})
+
+describe('getSingletonServices', () => {
+  test('should throw when singleton services not initialized', () => {
+    assert.throws(() => getSingletonServices(), {
+      message: 'Singleton services not initialized',
+    })
+  })
+
+  test('should return services when initialized', () => {
+    const mockServices = { logger: { info: () => {} } }
+    pikkuState(null, 'package', 'singletonServices', mockServices as any)
+
+    const result = getSingletonServices()
+    assert.strictEqual(result, mockServices)
+  })
+})
+
+describe('getCreateWireServices', () => {
+  test('should return undefined when no factories set', () => {
+    const result = getCreateWireServices()
+    assert.strictEqual(result, undefined)
+  })
+
+  test('should return createWireServices when factories set', () => {
+    const mockCreateWire = async () => ({})
+    pikkuState(null, 'package', 'factories', {
+      createWireServices: mockCreateWire,
+    } as any)
+
+    const result = getCreateWireServices()
+    assert.strictEqual(result, mockCreateWire)
+  })
+})
+
+describe('getPikkuMetaDir', () => {
+  test('should return null by default', () => {
+    const result = getPikkuMetaDir()
+    assert.strictEqual(result, null)
+  })
+
+  test('should return metaDir when set', () => {
+    pikkuState(null, 'package', 'metaDir', '/some/path' as any)
+    const result = getPikkuMetaDir()
+    assert.strictEqual(result, '/some/path')
+  })
+
+  test('should return metaDir for specific package', () => {
+    pikkuState('@test/pkg', 'package', 'metaDir', '/addon/path' as any)
+    const result = getPikkuMetaDir('@test/pkg')
+    assert.strictEqual(result, '/addon/path')
+  })
+
+  test('should treat null packageName as main', () => {
+    pikkuState(null, 'package', 'metaDir', '/main/path' as any)
+    const result = getPikkuMetaDir(null)
+    assert.strictEqual(result, '/main/path')
+  })
+})
+
+describe('addPackageServiceFactories', () => {
+  test('should register factories for addon package', () => {
+    const mockFactories = {
+      createSingletonServices: async () => ({}),
+      createWireServices: async () => ({}),
+    }
+
+    addPackageServiceFactories('@addon/pkg', mockFactories as any)
+
+    const result = pikkuState('@addon/pkg', 'package', 'factories')
+    assert.strictEqual(result, mockFactories)
+  })
+
+  test('should not affect main package factories', () => {
+    const addonFactories = { createSingletonServices: async () => ({}) }
+    addPackageServiceFactories('@addon/pkg', addonFactories as any)
+
+    const mainFactories = pikkuState(null, 'package', 'factories')
+    assert.strictEqual(mainFactories, null)
+  })
+})