@pikku/core 0.11.1 → 0.12.0

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

@@ -4,6 +4,7 @@ import {
   wireScheduler,
   runScheduledTask,
   getScheduledTasks,
+  createSchedulerRuntimeHandlers,
 } from './scheduler-runner.js'
 import { resetPikkuState, pikkuState } from '../../pikku-state.js'
 import { CoreScheduledTask } from './scheduler.types.js'
@@ -37,15 +38,15 @@ describe('wireScheduler', () => {
     }
 
     // Set up metadata first
-    pikkuState('scheduler', 'meta')['test-task'] = {
-      pikkuFuncName: 'scheduler_test-task',
+    pikkuState(null, 'scheduler', 'meta')['test-task'] = {
+      pikkuFuncId: 'scheduler_test-task',
       name: 'test-task',
       schedule: '0 0 * * *',
     }
 
     wireScheduler(mockTask)
 
-    const tasks = pikkuState('scheduler', 'tasks')
+    const tasks = pikkuState(null, 'scheduler', 'tasks')
     assert.equal(tasks.has('test-task'), true)
     assert.equal(tasks.get('test-task'), mockTask)
   })
@@ -63,7 +64,10 @@ describe('wireScheduler', () => {
     assert.throws(
       () => wireScheduler(mockTask),
       (error: any) => {
-        assert.equal(error.message, 'Task metadata not found')
+        assert.equal(
+          error.message,
+          "Missing generated metadata for scheduled task 'missing-meta-task'"
+        )
         return true
       }
     )
@@ -80,8 +84,8 @@ describe('wireScheduler', () => {
     }
 
     // Set up metadata
-    pikkuState('scheduler', 'meta')['duplicate-task'] = {
-      pikkuFuncName: 'scheduler_duplicate-task',
+    pikkuState(null, 'scheduler', 'meta')['duplicate-task'] = {
+      pikkuFuncId: 'scheduler_duplicate-task',
       name: 'duplicate-task',
       schedule: '0 0 * * *',
     }
@@ -120,15 +124,15 @@ describe('wireScheduler', () => {
       tags: ['scheduled'],
     }
 
-    pikkuState('scheduler', 'meta')['task-with-middleware'] = {
-      pikkuFuncName: 'scheduler_task-with-middleware',
+    pikkuState(null, 'scheduler', 'meta')['task-with-middleware'] = {
+      pikkuFuncId: 'scheduler_task-with-middleware',
       name: 'task-with-middleware',
       schedule: '0 0 * * *',
     }
 
     wireScheduler(mockTask)
 
-    const tasks = pikkuState('scheduler', 'tasks')
+    const tasks = pikkuState(null, 'scheduler', 'tasks')
     const task = tasks.get('task-with-middleware')
     assert.equal(task?.middleware?.length, 1)
     assert.deepEqual(task?.tags, ['scheduled'])
@@ -151,13 +155,13 @@ describe('runScheduledTask', () => {
     }
 
     // Set up metadata and task
-    pikkuState('scheduler', 'meta')['simple-task'] = {
-      pikkuFuncName: 'scheduler_simple-task',
+    pikkuState(null, 'scheduler', 'meta')['simple-task'] = {
+      pikkuFuncId: 'scheduler_simple-task',
       name: 'simple-task',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_simple-task'] = {
-      pikkuFuncName: 'scheduler_simple-task',
+    pikkuState(null, 'function', 'meta')['scheduler_simple-task'] = {
+      pikkuFuncId: 'scheduler_simple-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -185,19 +189,19 @@ describe('runScheduledTask', () => {
       schedule: '0 0 * * *',
       func: {
         func: async (services: any, data: any, wire: any) => {
-          receivedSession = await wire.session.get()
+          receivedSession = await wire.getSession()
         },
         auth: false,
       },
     }
 
-    pikkuState('scheduler', 'meta')['task-with-session'] = {
-      pikkuFuncName: 'scheduler_task-with-session',
+    pikkuState(null, 'scheduler', 'meta')['task-with-session'] = {
+      pikkuFuncId: 'scheduler_task-with-session',
       name: 'task-with-session',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_task-with-session'] = {
-      pikkuFuncName: 'scheduler_task-with-session',
+    pikkuState(null, 'function', 'meta')['scheduler_task-with-session'] = {
+      pikkuFuncId: 'scheduler_task-with-session',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -243,7 +247,7 @@ describe('runScheduledTask', () => {
     }
 
     // Add task but not metadata
-    pikkuState('scheduler', 'tasks').set('task-without-meta', mockTask)
+    pikkuState(null, 'scheduler', 'tasks').set('task-without-meta', mockTask)
 
     const mockLogger = createMockLogger()
 
@@ -273,13 +277,13 @@ describe('runScheduledTask', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['skipped-task'] = {
-      pikkuFuncName: 'scheduler_skipped-task',
+    pikkuState(null, 'scheduler', 'meta')['skipped-task'] = {
+      pikkuFuncId: 'scheduler_skipped-task',
       name: 'skipped-task',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_skipped-task'] = {
-      pikkuFuncName: 'scheduler_skipped-task',
+    pikkuState(null, 'function', 'meta')['scheduler_skipped-task'] = {
+      pikkuFuncId: 'scheduler_skipped-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -316,13 +320,13 @@ describe('runScheduledTask', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['skipped-task-no-reason'] = {
-      pikkuFuncName: 'scheduler_skipped-task-no-reason',
+    pikkuState(null, 'scheduler', 'meta')['skipped-task-no-reason'] = {
+      pikkuFuncId: 'scheduler_skipped-task-no-reason',
       name: 'skipped-task-no-reason',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_skipped-task-no-reason'] = {
-      pikkuFuncName: 'scheduler_skipped-task-no-reason',
+    pikkuState(null, 'function', 'meta')['scheduler_skipped-task-no-reason'] = {
+      pikkuFuncId: 'scheduler_skipped-task-no-reason',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -362,13 +366,13 @@ describe('runScheduledTask', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['wire-task'] = {
-      pikkuFuncName: 'scheduler_wire-task',
+    pikkuState(null, 'scheduler', 'meta')['wire-task'] = {
+      pikkuFuncId: 'scheduler_wire-task',
       name: 'wire-task',
       schedule: '*/5 * * * *',
     }
-    pikkuState('function', 'meta')['scheduler_wire-task'] = {
-      pikkuFuncName: 'scheduler_wire-task',
+    pikkuState(null, 'function', 'meta')['scheduler_wire-task'] = {
+      pikkuFuncId: 'scheduler_wire-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -400,13 +404,13 @@ describe('runScheduledTask', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['session-services-task'] = {
-      pikkuFuncName: 'scheduler_session-services-task',
+    pikkuState(null, 'scheduler', 'meta')['session-services-task'] = {
+      pikkuFuncId: 'scheduler_session-services-task',
       name: 'session-services-task',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_session-services-task'] = {
-      pikkuFuncName: 'scheduler_session-services-task',
+    pikkuState(null, 'function', 'meta')['scheduler_session-services-task'] = {
+      pikkuFuncId: 'scheduler_session-services-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -445,13 +449,13 @@ describe('runScheduledTask', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['cleanup-task'] = {
-      pikkuFuncName: 'scheduler_cleanup-task',
+    pikkuState(null, 'scheduler', 'meta')['cleanup-task'] = {
+      pikkuFuncId: 'scheduler_cleanup-task',
       name: 'cleanup-task',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_cleanup-task'] = {
-      pikkuFuncName: 'scheduler_cleanup-task',
+    pikkuState(null, 'function', 'meta')['scheduler_cleanup-task'] = {
+      pikkuFuncId: 'scheduler_cleanup-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -489,13 +493,13 @@ describe('runScheduledTask', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['error-cleanup-task'] = {
-      pikkuFuncName: 'scheduler_error-cleanup-task',
+    pikkuState(null, 'scheduler', 'meta')['error-cleanup-task'] = {
+      pikkuFuncId: 'scheduler_error-cleanup-task',
       name: 'error-cleanup-task',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_error-cleanup-task'] = {
-      pikkuFuncName: 'scheduler_error-cleanup-task',
+    pikkuState(null, 'function', 'meta')['scheduler_error-cleanup-task'] = {
+      pikkuFuncId: 'scheduler_error-cleanup-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -526,13 +530,13 @@ describe('runScheduledTask', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['error-task'] = {
-      pikkuFuncName: 'scheduler_error-task',
+    pikkuState(null, 'scheduler', 'meta')['error-task'] = {
+      pikkuFuncId: 'scheduler_error-task',
       name: 'error-task',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_error-task'] = {
-      pikkuFuncName: 'scheduler_error-task',
+    pikkuState(null, 'function', 'meta')['scheduler_error-task'] = {
+      pikkuFuncId: 'scheduler_error-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -573,13 +577,13 @@ describe('runScheduledTask', () => {
       middleware: [middleware],
     }
 
-    pikkuState('scheduler', 'meta')['middleware-task'] = {
-      pikkuFuncName: 'scheduler_middleware-task',
+    pikkuState(null, 'scheduler', 'meta')['middleware-task'] = {
+      pikkuFuncId: 'scheduler_middleware-task',
       name: 'middleware-task',
       schedule: '0 0 * * *',
     }
-    pikkuState('function', 'meta')['scheduler_middleware-task'] = {
-      pikkuFuncName: 'scheduler_middleware-task',
+    pikkuState(null, 'function', 'meta')['scheduler_middleware-task'] = {
+      pikkuFuncId: 'scheduler_middleware-task',
       inputSchemaName: null,
       outputSchemaName: null,
     }
@@ -607,8 +611,8 @@ describe('getScheduledTasks', () => {
       },
     }
 
-    pikkuState('scheduler', 'meta')['test-task'] = {
-      pikkuFuncName: 'scheduler_test-task',
+    pikkuState(null, 'scheduler', 'meta')['test-task'] = {
+      pikkuFuncId: 'scheduler_test-task',
       name: 'test-task',
       schedule: '0 0 * * *',
     }
@@ -625,3 +629,43 @@ 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

@@ -7,14 +7,20 @@ import {
 } 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 { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { PikkuSessionService } from '../../services/user-session-service.js'
+import {
+  PikkuSessionService,
+  createMiddlewareSessionWireProps,
+} from '../../services/user-session-service.js'
 import {
   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
@@ -34,12 +40,14 @@ export const wireScheduler = <
 >(
   scheduledTask: CoreScheduledTask<PikkuFunctionConfig>
 ) => {
-  const meta = pikkuState('scheduler', 'meta')
+  const meta = pikkuState(null, 'scheduler', 'meta')
   const taskMeta = meta[scheduledTask.name]
   if (!taskMeta) {
-    throw new Error('Task metadata not found')
+    throw new PikkuMissingMetaError(
+      `Missing generated metadata for scheduled task '${scheduledTask.name}'`
+    )
   }
-  addFunction(taskMeta.pikkuFuncName, {
+  addFunction(taskMeta.pikkuFuncId, {
     func: scheduledTask.func.func,
     auth: scheduledTask.func.auth,
     permissions: scheduledTask.func.permissions,
@@ -47,7 +55,7 @@ export const wireScheduler = <
     tags: scheduledTask.func.tags,
   })
 
-  const tasks = pikkuState('scheduler', 'tasks')
+  const tasks = pikkuState(null, 'scheduler', 'tasks')
   if (tasks.has(scheduledTask.name)) {
     throw new Error(`Scheduled task already exists: ${scheduledTask.name}`)
   }
@@ -76,8 +84,8 @@ export async function runScheduledTask({
   createWireServices,
 }: RunScheduledTasksParams): Promise<void> {
   let wireServices: any
-  const task = pikkuState('scheduler', 'tasks').get(name)
-  const meta = pikkuState('scheduler', 'meta')[name]
+  const task = pikkuState(null, 'scheduler', 'tasks').get(name)
+  const meta = pikkuState(null, 'scheduler', 'meta')[name]
 
   const userSession = new PikkuSessionService()
   if (session) {
@@ -103,7 +111,7 @@ export async function runScheduledTask({
         throw new ScheduledTaskSkippedError(name, reason)
       },
     },
-    session: userSession,
+    ...createMiddlewareSessionWireProps(userSession),
   }
 
   try {
@@ -111,7 +119,7 @@ export async function runScheduledTask({
       `Running schedule task: ${name} | schedule: ${task.schedule}`
     )
 
-    await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncName, {
+    await runPikkuFunc('scheduler', meta.name, meta.pikkuFuncId, {
       singletonServices,
       createWireServices,
       auth: false,
@@ -120,6 +128,7 @@ export async function runScheduledTask({
       wireMiddleware: task.middleware,
       tags: task.tags,
       wire,
+      sessionService: userSession,
     })
   } catch (e: any) {
     const errorResponse = getErrorResponse(e)
@@ -135,5 +144,36 @@ export async function runScheduledTask({
 }
 
 export const getScheduledTasks = () => {
-  return pikkuState('scheduler', 'tasks')
+  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/secret/index.ts

@@ -0,0 +1,9 @@
+export { wireSecret } from './secret.types.js'
+export type {
+  CoreSecret,
+  OAuth2CredentialConfig,
+  SecretDefinitionMeta,
+  SecretDefinitionsMeta,
+  SecretDefinitions,
+} from './secret.types.js'
+export { validateAndBuildSecretDefinitionsMeta } from './validate-secret-definitions.js'

package/src/wirings/secret/secret.types.ts

@@ -0,0 +1,32 @@
+export type CoreSecret<T = unknown> = {
+  name: string
+  displayName: string
+  description?: string
+  secretId: string
+  schema: T
+}
+
+export type OAuth2CredentialConfig = {
+  tokenSecretId: string
+  authorizationUrl: string
+  tokenUrl: string
+  scopes: string[]
+  pkce?: boolean
+  additionalParams?: Record<string, string>
+}
+
+export type SecretDefinitionMeta = {
+  name: string
+  displayName: string
+  description?: string
+  secretId: string
+  schema?: Record<string, unknown> | string
+  oauth2?: OAuth2CredentialConfig
+  sourceFile?: string
+}
+
+export type SecretDefinitionsMeta = Record<string, SecretDefinitionMeta>
+
+export type SecretDefinitions = SecretDefinitionMeta[]
+
+export const wireSecret = <T>(_config: CoreSecret<T>): void => {}

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

@@ -0,0 +1,82 @@
+import type {
+  SecretDefinitions,
+  SecretDefinitionsMeta,
+} from './secret.types.js'
+
+export interface SchemaRefLike {
+  variableName: string
+  sourceFile: string
+}
+
+export function validateAndBuildSecretDefinitionsMeta(
+  definitions: SecretDefinitions,
+  schemaLookup: Map<string, SchemaRefLike>
+): SecretDefinitionsMeta {
+  const meta: SecretDefinitionsMeta = {}
+  const secretIdToDefinition: Map<string, SecretDefinitions[0]> = new Map()
+
+  for (const def of definitions) {
+    const existingDef = secretIdToDefinition.get(def.secretId)
+
+    if (existingDef) {
+      if (def.schema && existingDef.schema) {
+        const defSchemaRef = schemaLookup.get(def.schema as string)
+        const existingSchemaRef = schemaLookup.get(existingDef.schema as string)
+
+        if (defSchemaRef && existingSchemaRef) {
+          if (
+            defSchemaRef.variableName !== existingSchemaRef.variableName ||
+            defSchemaRef.sourceFile !== existingSchemaRef.sourceFile
+          ) {
+            throw new Error(
+              `Secret '${def.secretId}' is defined with different schemas.\n` +
+                `  First definition: ${existingDef.sourceFile} (schema: ${existingSchemaRef.variableName})\n` +
+                `  Second definition: ${def.sourceFile} (schema: ${defSchemaRef.variableName})\n` +
+                `Credentials sharing a secretId must use the same schema.`
+            )
+          }
+        }
+      }
+
+      if (def.oauth2 && existingDef.oauth2) {
+        if (JSON.stringify(def.oauth2) !== JSON.stringify(existingDef.oauth2)) {
+          throw new Error(
+            `OAuth2 secret '${def.secretId}' is defined with different configurations.\n` +
+              `  First definition: ${existingDef.sourceFile}\n` +
+              `  Second definition: ${def.sourceFile}\n` +
+              `Credentials sharing a secretId must use the same configuration.`
+          )
+        }
+      }
+
+      if (!meta[def.name]) {
+        meta[def.name] = {
+          name: def.name,
+          displayName: def.displayName,
+          description: def.description,
+          secretId: def.secretId,
+          schema: def.schema,
+          oauth2: def.oauth2,
+          sourceFile: def.sourceFile,
+        }
+      }
+      continue
+    }
+
+    secretIdToDefinition.set(def.secretId, def)
+
+    if (!meta[def.name]) {
+      meta[def.name] = {
+        name: def.name,
+        displayName: def.displayName,
+        description: def.description,
+        secretId: def.secretId,
+        schema: def.schema,
+        oauth2: def.oauth2,
+        sourceFile: def.sourceFile,
+      }
+    }
+  }
+
+  return meta
+}

package/src/wirings/trigger/index.ts

@@ -0,0 +1,10 @@
+export { wireTrigger, wireTriggerSource } from './trigger-runner.js'
+export { PikkuTriggerService } from './pikku-trigger-service.js'
+export type {
+  TriggerMeta,
+  TriggerSourceMeta,
+  CorePikkuTriggerFunction,
+  CorePikkuTriggerFunctionConfig,
+  CoreTrigger,
+  PikkuTrigger,
+} from './trigger.types.js'