@pikku/core 0.12.0 → 0.12.2

package/src/wirings/scheduler/scheduler-runner.test.ts

@@ -4,11 +4,10 @@ import {
   wireScheduler,
   runScheduledTask,
   getScheduledTasks,
-  createSchedulerRuntimeHandlers,
 } from './scheduler-runner.js'
 import { resetPikkuState, pikkuState } from '../../pikku-state.js'
-import { CoreScheduledTask } from './scheduler.types.js'
-import { CoreUserSession } from '../../types/core.types.js'
+import type { CoreScheduledTask } from './scheduler.types.js'
+import type { CoreUserSession } from '../../types/core.types.js'
 
 beforeEach(() => {
   resetPikkuState()
@@ -168,9 +167,11 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     await runScheduledTask({
       name: 'simple-task',
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.equal(taskExecuted, true)
@@ -208,12 +209,14 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const session: CoreUserSession = { userId: 'user123' }
 
     await runScheduledTask({
       name: 'task-with-session',
       session,
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.deepEqual(receivedSession, session)
@@ -221,12 +224,14 @@ describe('runScheduledTask', () => {
 
   test('should throw ScheduledTaskNotFoundError when task not found', async () => {
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'non-existent-task',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -250,12 +255,14 @@ describe('runScheduledTask', () => {
     pikkuState(null, 'scheduler', 'tasks').set('task-without-meta', mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'task-without-meta',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -290,12 +297,14 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'skipped-task',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -333,12 +342,14 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(
       async () => {
         await runScheduledTask({
           name: 'skipped-task-no-reason',
-          singletonServices: { logger: mockLogger } as any,
         })
       },
       (error: any) => {
@@ -379,10 +390,12 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await runScheduledTask({
       name: 'wire-task',
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.equal(capturedWire.scheduledTask.name, 'wire-task')
@@ -417,14 +430,18 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
-
-    await runScheduledTask({
-      name: 'session-services-task',
-      singletonServices: { logger: mockLogger } as any,
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+    pikkuState(null, 'package', 'factories', {
       createWireServices: async () => {
         createWireServicesCalled = true
         return mockWireService as any
       },
+    } as any)
+
+    await runScheduledTask({
+      name: 'session-services-task',
     })
 
     assert.equal(createWireServicesCalled, true)
@@ -462,11 +479,15 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+    pikkuState(null, 'package', 'factories', {
+      createWireServices: async () => mockWireService as any,
+    } as any)
 
     await runScheduledTask({
       name: 'cleanup-task',
-      singletonServices: { logger: mockLogger } as any,
-      createWireServices: async () => mockWireService as any,
     })
 
     assert.equal(closeCalled, true)
@@ -506,12 +527,16 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+    pikkuState(null, 'package', 'factories', {
+      createWireServices: async () => mockWireService as any,
+    } as any)
 
     await assert.rejects(async () => {
       await runScheduledTask({
         name: 'error-cleanup-task',
-        singletonServices: { logger: mockLogger } as any,
-        createWireServices: async () => mockWireService as any,
       })
     })
 
@@ -543,11 +568,13 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await assert.rejects(async () => {
       await runScheduledTask({
         name: 'error-task',
-        singletonServices: { logger: mockLogger } as any,
       })
     })
 
@@ -590,10 +617,12 @@ describe('runScheduledTask', () => {
     wireScheduler(mockTask)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
     await runScheduledTask({
       name: 'middleware-task',
-      singletonServices: { logger: mockLogger } as any,
     })
 
     assert.deepEqual(executionOrder, ['middleware', 'task'])
@@ -629,43 +658,3 @@ describe('getScheduledTasks', () => {
     assert.equal(tasks.size, 0)
   })
 })
-
-describe('createSchedulerRuntimeHandlers', () => {
-  test('invokes RPC with optional session and runs scheduled task callback', async () => {
-    const calls: Array<{ type: string; value: any }> = []
-    const logger = createMockLogger()
-    const singletonServices = { logger } as any
-
-    const handlers = createSchedulerRuntimeHandlers({
-      singletonServices,
-    })
-
-    const originalGetContextRPCService = (await import('../rpc/rpc-runner.js'))
-      .rpcService.getContextRPCService
-    ;(await import('../rpc/rpc-runner.js')).rpcService.getContextRPCService = ((
-      _services: any,
-      wire: any
-    ) => {
-      calls.push({ type: 'wire', value: wire })
-      return {
-        invoke: async (rpcName: string, data: any) => {
-          calls.push({ type: 'invoke', value: { rpcName, data } })
-        },
-      } as any
-    }) as any
-
-    try {
-      await handlers.invokeRPC('testRpc', { value: 1 }, { userId: 'u1' } as any)
-    } finally {
-      ;(await import('../rpc/rpc-runner.js')).rpcService.getContextRPCService =
-        originalGetContextRPCService
-    }
-
-    assert.equal(calls[0]?.type, 'wire')
-    assert.deepEqual(calls[0]?.value, { session: { userId: 'u1' } })
-    assert.deepEqual(calls[1]?.value, {
-      rpcName: 'testRpc',
-      data: { value: 1 },
-    })
-  })
-})

package/src/wirings/scheduler/scheduler-runner.ts

@@ -1,36 +1,25 @@
-import {
-  PikkuWire,
-  type CoreServices,
-  type CoreSingletonServices,
-  type CoreUserSession,
-  type CreateWireServices,
-} from '../../types/core.types.js'
+import type { PikkuWire, CoreUserSession } from '../../types/core.types.js'
 import type { CoreScheduledTask } from './scheduler.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
 import { PikkuMissingMetaError } from '../../errors/errors.js'
-import { closeWireServices } from '../../utils.js'
-import { pikkuState } from '../../pikku-state.js'
+import {
+  getSingletonServices,
+  getCreateWireServices,
+  pikkuState,
+} from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import {
   PikkuSessionService,
   createMiddlewareSessionWireProps,
 } from '../../services/user-session-service.js'
-import {
+import type {
   CorePikkuFunctionConfig,
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'
-import { rpcService } from '../rpc/rpc-runner.js'
-import { SchedulerRuntimeHandlers } from '../../services/scheduler-service.js'
 
 export type RunScheduledTasksParams = {
   name: string
   session?: CoreUserSession
-  singletonServices: CoreSingletonServices
-  createWireServices?: CreateWireServices<
-    CoreSingletonServices,
-    CoreServices<CoreSingletonServices>,
-    CoreUserSession
-  >
 }
 
 export const wireScheduler = <
@@ -80,10 +69,9 @@ class ScheduledTaskSkippedError extends PikkuError {
 export async function runScheduledTask({
   name,
   session,
-  singletonServices,
-  createWireServices,
 }: RunScheduledTasksParams): Promise<void> {
-  let wireServices: any
+  const singletonServices = getSingletonServices()
+  const createWireServices = getCreateWireServices()
   const task = pikkuState(null, 'scheduler', 'tasks').get(name)
   const meta = pikkuState(null, 'scheduler', 'meta')[name]
 
@@ -136,44 +124,9 @@ export async function runScheduledTask({
       singletonServices.logger.error(e)
     }
     throw e
-  } finally {
-    if (wireServices) {
-      await closeWireServices(singletonServices.logger, wireServices)
-    }
   }
 }
 
 export const getScheduledTasks = () => {
   return pikkuState(null, 'scheduler', 'tasks')
 }
-
-export const createSchedulerRuntimeHandlers = ({
-  singletonServices,
-  createWireServices,
-}: {
-  singletonServices: CoreSingletonServices
-  createWireServices?: CreateWireServices<
-    CoreSingletonServices,
-    CoreServices<CoreSingletonServices>,
-    CoreUserSession
-  >
-}): SchedulerRuntimeHandlers => {
-  return {
-    logger: singletonServices.logger,
-    invokeRPC: async (
-      rpcName: string,
-      data?: any,
-      session?: CoreUserSession
-    ) => {
-      const wire = session ? ({ session } as PikkuWire) : ({} as PikkuWire)
-      const rpc = rpcService.getContextRPCService(singletonServices, wire)
-      await rpc.invoke(rpcName, data)
-    },
-    runScheduledTask: async (name: string) =>
-      runScheduledTask({
-        name,
-        singletonServices,
-        createWireServices,
-      }),
-  }
-}

package/src/wirings/scheduler/scheduler.types.ts

@@ -1,9 +1,9 @@
-import {
+import type {
   CoreUserSession,
   CorePikkuMiddleware,
   CommonWireMeta,
 } from '../../types/core.types.js'
-import {
+import type {
   CorePikkuFunctionConfig,
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'

package/src/wirings/secret/validate-secret-definitions.test.ts

@@ -0,0 +1,140 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js'
+
+describe('validateAndBuildSecretDefinitionsMeta', () => {
+  test('should build meta from single definition', () => {
+    const definitions = [
+      {
+        name: 'stripe',
+        displayName: 'Stripe',
+        description: 'API key',
+        secretId: 'STRIPE_KEY',
+        sourceFile: 'a.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['stripe'])
+    assert.strictEqual(result['stripe'].secretId, 'STRIPE_KEY')
+    assert.strictEqual(result['stripe'].displayName, 'Stripe')
+  })
+
+  test('should allow duplicate secretId with same schema', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'Schema', sourceFile: 'types.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'Cred 1',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'Cred 2',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      schemaLookup
+    )
+    assert.ok(result['cred1'])
+    assert.ok(result['cred2'])
+  })
+
+  test('should throw when duplicate secretId has different schemas', () => {
+    const schemaLookup = new Map([
+      ['schema1', { variableName: 'SchemaA', sourceFile: 'types.ts' }],
+      ['schema2', { variableName: 'SchemaB', sourceFile: 'types2.ts' }],
+    ])
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'Cred 1',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'Cred 2',
+        description: 'd',
+        secretId: 'SHARED',
+        schema: 'schema2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildSecretDefinitionsMeta(definitions as any, schemaLookup),
+      (err: any) => err.message.includes('different schemas')
+    )
+  })
+
+  test('should throw when duplicate secretId has different oauth2 configs', () => {
+    const definitions = [
+      {
+        name: 'cred1',
+        displayName: 'C1',
+        description: 'd',
+        secretId: 'OAUTH',
+        oauth2: { provider: 'google' },
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'cred2',
+        displayName: 'C2',
+        description: 'd',
+        secretId: 'OAUTH',
+        oauth2: { provider: 'github' },
+        sourceFile: 'b.ts',
+      },
+    ]
+    assert.throws(
+      () =>
+        validateAndBuildSecretDefinitionsMeta(definitions as any, new Map()),
+      (err: any) => err.message.includes('different configurations')
+    )
+  })
+
+  test('should handle empty definitions', () => {
+    const result = validateAndBuildSecretDefinitionsMeta([], new Map())
+    assert.deepStrictEqual(result, {})
+  })
+
+  test('should not duplicate names in meta', () => {
+    const definitions = [
+      {
+        name: 'same',
+        displayName: 'Same',
+        description: 'd',
+        secretId: 'KEY1',
+        sourceFile: 'a.ts',
+      },
+      {
+        name: 'same',
+        displayName: 'Same',
+        description: 'd',
+        secretId: 'KEY2',
+        sourceFile: 'b.ts',
+      },
+    ]
+    const result = validateAndBuildSecretDefinitionsMeta(
+      definitions as any,
+      new Map()
+    )
+    assert.ok(result['same'])
+    assert.strictEqual(result['same'].secretId, 'KEY1')
+  })
+})

package/src/wirings/trigger/pikku-trigger-service.ts

@@ -1,14 +1,12 @@
-import {
-  CoreSingletonServices,
-  CreateWireServices,
-  CoreServices,
-  CoreUserSession,
-} from '../../types/core.types.js'
 import { rpcService } from '../rpc/rpc-runner.js'
 import { setupTrigger } from './trigger-runner.js'
-import { TriggerInstance } from './trigger.types.js'
-import { TriggerService } from '../../services/trigger-service.js'
-import { pikkuState } from '../../pikku-state.js'
+import type { TriggerInstance } from './trigger.types.js'
+import type { TriggerService } from '../../services/trigger-service.js'
+import {
+  getSingletonServices,
+  getCreateWireServices,
+  pikkuState,
+} from '../../pikku-state.js'
 
 export type TriggerTarget = {
   targetType: 'rpc' | 'workflow'
@@ -23,34 +21,17 @@ export type TriggerSourceInfo = {
 
 export abstract class PikkuTriggerService implements TriggerService {
   protected activeTriggers = new Map<string, TriggerInstance>()
-  protected singletonServices?: CoreSingletonServices
-  protected createWireServices?: CreateWireServices<
-    CoreSingletonServices,
-    CoreServices,
-    CoreUserSession
-  >
-
-  setServices(
-    singletonServices: CoreSingletonServices,
-    createWireServices?: CreateWireServices<
-      CoreSingletonServices,
-      CoreServices,
-      CoreUserSession
-    >
-  ): void {
-    this.singletonServices = singletonServices
-    this.createWireServices = createWireServices
-  }
 
   abstract start(): Promise<void>
 
   async stop(): Promise<void> {
+    const singletonServices = getSingletonServices()
     for (const [name, instance] of this.activeTriggers) {
       try {
         await instance.teardown()
-        this.singletonServices!.logger.info(`Stopped trigger: ${name}`)
+        singletonServices.logger.info(`Stopped trigger: ${name}`)
       } catch (error) {
-        this.singletonServices!.logger.error(
+        singletonServices.logger.error(
           `Error stopping trigger ${name}: ${error}`
         )
       }
@@ -90,8 +71,6 @@ export abstract class PikkuTriggerService implements TriggerService {
   ): Promise<TriggerInstance> {
     return setupTrigger({
       name,
-      singletonServices: this.singletonServices!,
-      createWireServices: this.createWireServices as any,
       input,
       onTrigger,
     })
@@ -102,11 +81,10 @@ export abstract class PikkuTriggerService implements TriggerService {
     targets: TriggerTarget[],
     data: unknown
   ): Promise<void> {
-    const wireServices = await this.createWireServices?.(
-      this.singletonServices!,
-      {}
-    )
-    const services = { ...this.singletonServices!, ...wireServices }
+    const singletonServices = getSingletonServices()
+    const createWireServices = getCreateWireServices()
+    const wireServices = await createWireServices?.(singletonServices, {})
+    const services = { ...singletonServices, ...wireServices }
     const rpc = rpcService.getContextRPCService(services, {}, false)
 
     for (const target of targets) {
@@ -115,17 +93,17 @@ export abstract class PikkuTriggerService implements TriggerService {
           await rpc.startWorkflow(target.targetName, data, {
             startNode: target.startNode,
           })
-          this.singletonServices!.logger.info(
+          singletonServices.logger.info(
             `Trigger '${triggerName}' started workflow '${target.targetName}'`
           )
         } else {
           await rpc.invoke(target.targetName, data)
-          this.singletonServices!.logger.info(
+          singletonServices.logger.info(
             `Trigger '${triggerName}' invoked RPC '${target.targetName}'`
           )
         }
       } catch (error) {
-        this.singletonServices!.logger.error(
+        singletonServices.logger.error(
           `Error invoking ${target.targetType} '${target.targetName}' from trigger '${triggerName}': ${error}`
         )
       }

package/src/wirings/trigger/trigger-runner.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, beforeEach } from 'node:test'
+import assert from 'node:assert'
+import {
+  wireTrigger,
+  wireTriggerSource,
+  getRegisteredTriggers,
+  getTriggerMeta,
+} from './trigger-runner.js'
+import { resetPikkuState, pikkuState } from '../../pikku-state.js'
+import { PikkuMissingMetaError } from '../../errors/errors.js'
+
+beforeEach(() => {
+  resetPikkuState()
+})
+
+describe('wireTrigger', () => {
+  test('should register a trigger when meta exists', () => {
+    const meta = pikkuState(null, 'trigger', 'meta')
+    ;(meta as any)['myTrigger'] = { pikkuFuncId: 'triggerFunc' }
+
+    wireTrigger({ name: 'myTrigger', func: async () => {} } as any)
+
+    const triggers = getRegisteredTriggers()
+    assert.ok(triggers.has('myTrigger'))
+  })
+
+  test('should throw PikkuMissingMetaError when meta is missing', () => {
+    assert.throws(
+      () => wireTrigger({ name: 'noMeta', func: async () => {} } as any),
+      (err: any) => err instanceof PikkuMissingMetaError
+    )
+  })
+})
+
+describe('wireTriggerSource', () => {
+  test('should register a trigger source when meta exists', () => {
+    const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
+    ;(sourceMeta as any)['mySource'] = { pikkuFuncId: 'sourceFunc' }
+
+    wireTriggerSource({ name: 'mySource', func: async () => {} } as any)
+
+    const sources = pikkuState(null, 'trigger', 'triggerSources')
+    assert.ok(sources.has('mySource'))
+  })
+
+  test('should throw PikkuMissingMetaError when source meta is missing', () => {
+    assert.throws(
+      () => wireTriggerSource({ name: 'noMeta', func: async () => {} } as any),
+      (err: any) => err instanceof PikkuMissingMetaError
+    )
+  })
+
+  test('should throw when trigger source already exists', () => {
+    const sourceMeta = pikkuState(null, 'trigger', 'sourceMeta')
+    ;(sourceMeta as any)['dupSource'] = { pikkuFuncId: 'sourceFunc' }
+
+    wireTriggerSource({ name: 'dupSource', func: async () => {} } as any)
+
+    assert.throws(
+      () =>
+        wireTriggerSource({ name: 'dupSource', func: async () => {} } as any),
+      { message: 'Trigger source already exists: dupSource' }
+    )
+  })
+})
+
+describe('getRegisteredTriggers', () => {
+  test('should return the triggers Map', () => {
+    const triggers = getRegisteredTriggers()
+    assert.ok(triggers instanceof Map)
+  })
+})
+
+describe('getTriggerMeta', () => {
+  test('should return the trigger meta object', () => {
+    const meta = getTriggerMeta()
+    assert.ok(typeof meta === 'object')
+  })
+})