@pikku/core 0.11.1 → 0.12.0

package/src/permissions.ts

@@ -10,7 +10,7 @@ import {
 } 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.
@@ -19,7 +19,7 @@ import { freezeDedupe } from './utils.js'
  * @param wire - The wire object containing request/response context and session.
  * @returns A promise that resolves to void.
  */
-export const verifyPermissions = async <Out = any>(
+const verifyPermissions = async <Out = any>(
   permissions: CorePermissionGroup,
   services: CoreServices,
   data: any,
@@ -53,46 +53,19 @@ export const verifyPermissions = async <Out = any>(
   return false
 }
 
-/**
- * Registers a single permission function by name in the global permission store.
- *
- * This function is used by CLI-generated code to register permission functions
- * that can be referenced by name in metadata. It stores permissions in a special
- * namespace to avoid conflicts with tag-based permissions.
- *
- * @param {string} name - The unique name (pikkuFuncName) of the permission function.
- * @param {CorePikkuPermission} permission - The permission function to register.
- *
- * @example
- * ```typescript
- * // Called by CLI-generated pikku-permissions.gen.ts
- * registerPermission('adminPermission_src_permissions_ts_10_5', adminPermission)
- * registerPermission('readPermission_src_permissions_ts_20_10', readPermission)
- * ```
- */
-export const registerPermission = (
-  name: string,
-  permission: CorePikkuPermission<any>
-) => {
-  const permissionStore = pikkuState('misc', 'permissions')
-  permissionStore[name] = [permission]
-}
-
 /**
  * Retrieves a registered permission function by its name.
  *
  * 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
  */
-export const getPermissionByName = (
-  name: string
-): CorePikkuPermission | undefined => {
-  const permissionStore = pikkuState('misc', 'permissions')
+const getPermissionByName = (name: string): CorePikkuPermission | undefined => {
+  const permissionStore = pikkuState(null, 'misc', 'permissions')
   const permission = permissionStore[name]
   if (Array.isArray(permission) && permission.length === 1) {
     return permission[0]
@@ -130,9 +103,10 @@ export const getPermissionByName = (
  */
 export const addPermission = (
   tag: string,
-  permissions: CorePermissionGroup | CorePikkuPermission[]
+  permissions: CorePermissionGroup | CorePikkuPermission[],
+  packageName: string | null = null
 ): CorePermissionGroup | CorePikkuPermission[] => {
-  const tagGroups = pikkuState('permissions', 'tagGroup')
+  const tagGroups = pikkuState(packageName, 'permissions', 'tagGroup')
   if (tagGroups[tag]) {
     throw new Error(
       `Permissions for tag '${tag}' already exist. Use a different tag or remove the existing permissions first.`
@@ -142,50 +116,6 @@ export const addPermission = (
   return permissions
 }
 
-const EMPTY: readonly (CorePermissionGroup | CorePikkuPermission)[] = []
-
-/**
- * Retrieves permissions for a given set of tags.
- *
- * This function looks up all permissions registered for any of the provided tags
- * and returns them as a flattened array.
- *
- * @param {string[]} tags - Array of tags to look up permissions for.
- * @returns {any[]} Array of permission functions that apply to the given tags.
- *
- * @example
- * ```typescript
- * // Get all permissions for tags 'api' and 'auth'
- * const permissions = getPermissionsForTags(['api', 'auth'])
- * ```
- */
-export const getPermissionsForTags = (
-  tags?: string[]
-): readonly (CorePermissionGroup | CorePikkuPermission)[] => {
-  if (!tags || tags.length === 0) {
-    return EMPTY
-  }
-
-  const permissionsStore = pikkuState('permissions', 'tagGroup')
-  const applicablePermissions: Array<
-    CorePermissionGroup | CorePikkuPermission
-  > = []
-
-  // Collect permissions for all matching tags
-  for (const tag of new Set(tags)) {
-    const tagPermissions = permissionsStore[tag]
-    if (tagPermissions) {
-      if (Array.isArray(tagPermissions)) {
-        applicablePermissions.push(...tagPermissions)
-      } else {
-        applicablePermissions.push(tagPermissions)
-      }
-    }
-  }
-
-  return applicablePermissions
-}
-
 const combinedPermissionsCache: Record<
   PikkuWiringTypes,
   Record<string, readonly (CorePermissionGroup | CorePikkuPermission)[]>
@@ -195,7 +125,9 @@ const combinedPermissionsCache: Record<
   channel: {},
   queue: {},
   scheduler: {},
+  trigger: {},
   mcp: {},
+  agent: {},
   cli: {},
   workflow: {},
 }
@@ -224,7 +156,7 @@ const combinedPermissionsCache: Record<
  * })
  * ```
  */
-export const combinePermissions = (
+const combinePermissions = (
   wireType: PikkuWiringTypes,
   uid: string,
   {
@@ -232,11 +164,13 @@ export const combinePermissions = (
     wirePermissions,
     funcInheritedPermissions,
     funcPermissions,
+    packageName = null,
   }: {
     wireInheritedPermissions?: PermissionMetadata[]
     wirePermissions?: CorePermissionGroup | CorePikkuPermission[]
     funcInheritedPermissions?: PermissionMetadata[]
     funcPermissions?: CorePermissionGroup | CorePikkuPermission[]
+    packageName?: string | null
   } = {}
 ): readonly (CorePermissionGroup | CorePikkuPermission)[] => {
   if (combinedPermissionsCache[wireType][uid]) {
@@ -250,7 +184,9 @@ export const combinePermissions = (
     for (const meta of wireInheritedPermissions) {
       if (meta.type === 'http') {
         // Look up HTTP permission group from pikkuState
-        const group = pikkuState('permissions', 'httpGroup')[meta.route]
+        const group = pikkuState(packageName, 'permissions', 'httpGroup')[
+          meta.route
+        ]
         if (group) {
           if (Array.isArray(group)) {
             resolved.push(...group)
@@ -259,9 +195,11 @@ export const combinePermissions = (
           }
         }
       } else if (meta.type === 'tag') {
-        // Look up tag permission group from pikkuState
-        const group = pikkuState('permissions', 'tagGroup')[meta.tag]
-        if (group) {
+        const groups = getTagGroups(
+          pikkuState(packageName, 'permissions', 'tagGroup'),
+          meta.tag
+        )
+        for (const group of groups) {
           if (Array.isArray(group)) {
             resolved.push(...group)
           } else {
@@ -291,9 +229,11 @@ export const combinePermissions = (
   if (funcInheritedPermissions) {
     for (const meta of funcInheritedPermissions) {
       if (meta.type === 'tag') {
-        // Look up tag permission group from pikkuState
-        const group = pikkuState('permissions', 'tagGroup')[meta.tag]
-        if (group) {
+        const groups = getTagGroups(
+          pikkuState(packageName, 'permissions', 'tagGroup'),
+          meta.tag
+        )
+        for (const group of groups) {
           if (Array.isArray(group)) {
             resolved.push(...group)
           } else {
@@ -338,6 +278,7 @@ export const runPermissions = async (
     services,
     wire,
     data,
+    packageName = null,
   }: {
     wireInheritedPermissions?: PermissionMetadata[]
     wirePermissions?: CorePermissionGroup | CorePikkuPermission[]
@@ -346,6 +287,7 @@ export const runPermissions = async (
     services: CoreServices
     wire: PikkuWire<any, never, any, never, never, never>
     data: any
+    packageName?: string | null
   }
 ) => {
   // Combine all permissions: wireInheritedPermissions → wirePermissions → funcInheritedPermissions → funcPermissions
@@ -354,11 +296,11 @@ export const runPermissions = async (
     wirePermissions,
     funcInheritedPermissions,
     funcPermissions,
+    packageName,
   })
 
   // 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,
@@ -367,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.ts

@@ -1,230 +1,197 @@
-import { ChannelsMeta, CoreChannel } from './wirings/channel/channel.types.js'
+import { PikkuPackageState } from './index.js'
+import { HTTPWiringsMeta } from './wirings/http/http.types.js'
 import {
-  CoreHTTPFunctionWiring,
-  HTTPMethod,
-  HTTPWiringsMeta,
-} from './wirings/http/http.types.js'
-import {
-  FunctionsMeta,
-  CorePikkuMiddleware,
-  CorePikkuMiddlewareGroup,
-  FunctionServicesMeta,
-} from './types/core.types.js'
-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 {
-  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'
+import { AIAgentMeta } from './wirings/ai-agent/ai-agent.types.js'
+import { ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js'
+import { TriggerMeta } from './wirings/trigger/trigger.types.js'
 
-interface PikkuState {
-  function: {
-    meta: FunctionsMeta
-    functions: Map<string, CorePikkuFunctionConfig<any, any>>
+declare global {
+  // eslint-disable-next-line no-var
+  var pikkuState: Map<string, PikkuPackageState> | undefined
+}
+
+/**
+ * Get or set package-scoped pikku state
+ *
+ * @param packageName - Package name (null for main package, '@scope/package' for external packages)
+ * @param type - State category (function, rpc, http, etc.)
+ * @param content - Content key within the category
+ * @param value - Optional value to set
+ * @returns The current value of the state
+ *
+ * @example
+ * // Main package
+ * pikkuState(null, 'function', 'functions').get(funcName)
+ *
+ * // External package
+ * pikkuState('@acme/stripe-functions', 'rpc', 'meta')
+ */
+export const pikkuState = <
+  Type extends keyof PikkuPackageState,
+  Content extends keyof PikkuPackageState[Type],
+>(
+  packageName: string | null,
+  type: Type,
+  content: Content,
+  value?: PikkuPackageState[Type][Content]
+): PikkuPackageState[Type][Content] => {
+  const resolvedPackageName = packageName ?? '__main__'
+
+  // Initialize package state if it doesn't exist
+  if (
+    !globalThis.pikkuState ||
+    !globalThis.pikkuState.has(resolvedPackageName)
+  ) {
+    initializePikkuState(resolvedPackageName)
   }
-  rpc: {
-    meta: Record<string, string>
-    files: Map<
-      string,
-      {
-        exportedName: string
-        path: string
-      }
-    >
+
+  const packageState = globalThis.pikkuState!.get(resolvedPackageName)!
+
+  if (value !== undefined) {
+    packageState[type][content] = value
   }
+
+  return packageState[type][content]
+}
+
+const createEmptyPackageState = (): PikkuPackageState => ({
+  function: {
+    meta: {},
+    functions: new Map(),
+  },
+  rpc: {
+    meta: {},
+    files: new Map(),
+    externalPackages: new Map(),
+  },
   http: {
-    middleware: Map<string, CorePikkuMiddleware<any, any>[]>
-    permissions: Map<string, CorePermissionGroup | CorePikkuPermission[]>
-    routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>
-    meta: HTTPWiringsMeta
-  }
+    middleware: new Map(),
+    permissions: new Map(),
+    routes: new Map(),
+    meta: {
+      post: {},
+      get: {},
+      delete: {},
+      patch: {},
+      head: {},
+      put: {},
+      options: {},
+    } as HTTPWiringsMeta,
+  },
   channel: {
-    channels: Map<string, CoreChannel<any, any>>
-    meta: ChannelsMeta
-  }
+    channels: new Map(),
+    meta: {},
+  },
   scheduler: {
-    tasks: Map<string, CoreScheduledTask>
-    meta: ScheduledTasksMeta
-  }
+    tasks: new Map(),
+    meta: [] as unknown as ScheduledTasksMeta,
+  },
   queue: {
-    registrations: Map<string, CoreQueueWorker>
-    meta: QueueWorkersMeta
-  }
+    registrations: new Map(),
+    meta: {},
+  },
   workflows: {
-    registrations: Map<string, CoreWorkflow>
-    meta: WorkflowsMeta
-  }
+    registrations: new Map(),
+    meta: {},
+  },
+  trigger: {
+    functions: new Map(),
+    triggers: new Map(),
+    triggerSources: new Map(),
+    meta: {} as TriggerMeta,
+    sourceMeta: {},
+  },
   mcp: {
-    resources: Map<string, CoreMCPResource>
-    resourcesMeta: MCPResourceMeta
-    tools: Map<string, CoreMCPTool>
-    toolsMeta: MCPToolMeta
-    prompts: Map<string, CoreMCPPrompt>
-    promptsMeta: MCPPromptMeta
-  }
+    resources: new Map(),
+    resourcesMeta: {} as MCPResourceMeta,
+    toolsMeta: {} as MCPToolMeta,
+    prompts: new Map(),
+    promptsMeta: {} as MCPPromptMeta,
+  },
+  agent: {
+    agents: new Map(),
+    agentsMeta: {} as AIAgentMeta,
+  },
   cli: {
-    meta: CLIMeta | Record<string, any> // Backward compatible with old published CLI format
-    programs: Record<string, CLIProgramState>
-  }
+    meta: { programs: {}, renderers: {} },
+    programs: {},
+  },
   middleware: {
-    tagGroup: Record<string, CorePikkuMiddlewareGroup>
-    httpGroup: Record<string, CorePikkuMiddlewareGroup>
-    tagGroupMeta: Record<
-      string,
-      {
-        exportName: string | null
-        sourceFile: string
-        position: number
-        services: FunctionServicesMeta
-        middlewareCount: number
-        isFactory: boolean
-      }
-    >
-    httpGroupMeta: Record<
-      string,
-      {
-        exportName: string | null
-        sourceFile: string
-        position: number
-        services: FunctionServicesMeta
-        middlewareCount: number
-        isFactory: boolean
-      }
-    >
-  }
+    tagGroup: {},
+    httpGroup: {},
+  },
+  channelMiddleware: {
+    tagGroup: {},
+  },
   permissions: {
-    tagGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>
-    httpGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>
-    tagGroupMeta: Record<
-      string,
-      {
-        exportName: string | null
-        sourceFile: string
-        position: number
-        services: FunctionServicesMeta
-        permissionCount: number
-        isFactory: boolean
-      }
-    >
-    httpGroupMeta: Record<
-      string,
-      {
-        exportName: string | null
-        sourceFile: string
-        position: number
-        services: FunctionServicesMeta
-        permissionCount: number
-        isFactory: boolean
-      }
-    >
-  }
+    tagGroup: {},
+    httpGroup: {},
+  },
   misc: {
-    errors: Map<PikkuError, ErrorDetails>
-    schemas: Map<string, any>
-    middleware: Record<string, CorePikkuMiddleware[]>
-    permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>
+    errors: new Map(),
+    schemas: new Map(),
+    middleware: {},
+    channelMiddleware: {},
+    permissions: {},
+  },
+  models: {
+    config: null,
+  },
+  package: {
+    factories: null,
+    singletonServices: null,
+    metaDir: null,
+  },
+})
+
+/**
+ * Initialize state for a new package
+ */
+export const initializePikkuState = (packageName: string): void => {
+  if (!globalThis.pikkuState) {
+    globalThis.pikkuState = new Map()
+  }
+  if (!globalThis.pikkuState.has(packageName)) {
+    globalThis.pikkuState.set(packageName, createEmptyPackageState())
   }
 }
 
 export const resetPikkuState = () => {
-  globalThis.pikkuState = {
-    function: {
-      meta: {},
-      functions: new Map(),
-    },
-    rpc: {
-      meta: {},
-      files: new Map(),
-    },
-    http: {
-      permissions: new Map(),
-      routes: new Map(),
-      meta: {},
-    },
-    channel: {
-      channels: new Map(),
-      meta: {},
-    },
-    scheduler: {
-      tasks: new Map(),
-      meta: [] as unknown as ScheduledTasksMeta,
-    },
-    queue: {
-      registrations: new Map(),
-      meta: {},
-    },
-    workflows: {
-      registrations: new Map(),
-      meta: {},
-    },
-    mcp: {
-      resources: new Map(),
-      resourcesMeta: {} as MCPResourceMeta,
-      tools: new Map(),
-      toolsMeta: {} as MCPToolMeta,
-      prompts: new Map(),
-      promptsMeta: {} as MCPPromptMeta,
-    },
-    cli: {
-      meta: { programs: {}, renderers: {} },
-      programs: {},
-    },
-    middleware: {
-      tagGroup: {},
-      httpGroup: {},
-      tagGroupMeta: {},
-      httpGroupMeta: {},
-    },
-    permissions: {
-      tagGroup: {},
-      httpGroup: {},
-      tagGroupMeta: {},
-      httpGroupMeta: {},
-    },
-    misc: {
-      errors: globalThis.pikkuState?.misc?.errors || new Map(),
-      schemas: new Map(),
-      middleware: {},
-      permissions: {},
-    },
-  } as PikkuState
+  // Preserve the errors map before resetting
+  const existingErrors = globalThis.pikkuState?.get('__main__')?.misc.errors
+
+  globalThis.pikkuState = new Map()
+  initializePikkuState('__main__')
+
+  // Restore the errors map if it existed
+  if (existingErrors) {
+    const mainState = globalThis.pikkuState.get('__main__')!
+    mainState.misc.errors = existingErrors
+  }
 }
 
 if (!globalThis.pikkuState) {
   resetPikkuState()
 }
 
-export const pikkuState = <
-  Type extends keyof PikkuState,
-  Content extends keyof PikkuState[Type],
->(
-  type: Type,
-  content: Content,
-  value?: PikkuState[Type][Content]
-): PikkuState[Type][Content] => {
-  if (value) {
-    globalThis.pikkuState[type][content] = value
-  }
-  return globalThis.pikkuState[type][content]
+export const getPikkuMetaDir = (packageName?: string | null): string | null => {
+  return pikkuState(packageName ?? null, 'package', 'metaDir')
+}
+
+/**
+ * Register service factories for an external package.
+ * These factories are used to create services when the package's functions are invoked.
+ *
+ * @param packageName - The package name (e.g., '@pikku/templates-function-external')
+ * @param factories - The service factory functions
+ */
+export const addPackageServiceFactories = (
+  packageName: string,
+  factories: NonNullable<PikkuPackageState['package']['factories']>
+): void => {
+  pikkuState(packageName, 'package', 'factories', factories)
 }

package/src/run-tests-script.test.ts

@@ -0,0 +1,49 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const thisDir = path.dirname(fileURLToPath(import.meta.url))
+const packageRoot = path.resolve(thisDir, '..')
+const runTestsScriptPath = path.join(packageRoot, 'run-tests.sh')
+
+describe('run-tests.sh discovery behavior', () => {
+  test('returns success by default when no tests are found', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikku-core-tests-'))
+    const srcDir = path.join(tempDir, 'src')
+    fs.mkdirSync(srcDir, { recursive: true })
+    fs.copyFileSync(runTestsScriptPath, path.join(tempDir, 'run-tests.sh'))
+
+    const result = spawnSync('bash', ['run-tests.sh'], {
+      cwd: tempDir,
+      encoding: 'utf8',
+      env: { ...process.env, CI: 'false' },
+    })
+
+    assert.equal(result.status, 0)
+    assert.match(result.stdout, /No test files found matching pattern/)
+
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  test('returns failure in strict mode when no tests are found', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikku-core-tests-'))
+    const srcDir = path.join(tempDir, 'src')
+    fs.mkdirSync(srcDir, { recursive: true })
+    fs.copyFileSync(runTestsScriptPath, path.join(tempDir, 'run-tests.sh'))
+
+    const result = spawnSync('bash', ['run-tests.sh'], {
+      cwd: tempDir,
+      encoding: 'utf8',
+      env: { ...process.env, STRICT_TEST_DISCOVERY: '1' },
+    })
+
+    assert.equal(result.status, 1)
+    assert.match(result.stdout, /No test files found matching pattern/)
+
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+})