@pikku/core 0.9.11 → 0.10.0

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

@@ -1,7 +1,12 @@
-import { CoreServices, PikkuWiringTypes } from '../../types/core.types.js'
+import {
+  CoreServices,
+  PikkuInteraction,
+  PikkuWiringTypes,
+} from '../../types/core.types.js'
 import { runPikkuFunc } from '../../function/function-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { ForbiddenError } from '../../errors/errors.js'
+import { PikkuRPC } from './rpc-types.js'
 
 // Type for the RPC service configuration
 type RPCServiceConfig = {
@@ -21,8 +26,10 @@ const getPikkuFunctionName = (rpcName: string): string => {
 class ContextAwareRPCService {
   constructor(
     private services: CoreServices,
+    private interaction: PikkuInteraction,
     private options: {
       coerceDataFromSchema?: boolean
+      requiresAuth?: boolean
     }
   ) {}
 
@@ -41,7 +48,6 @@ class ContextAwareRPCService {
     funcName: string,
     data: In
   ): Promise<Out> {
-    const session = await this.services.userSession?.get()
     const rpcDepth = this.services.rpc?.depth || 0
     const pikkuFuncName = getPikkuFunctionName(funcName)
     return runPikkuFunc<In, Out>(
@@ -49,6 +55,8 @@ class ContextAwareRPCService {
       pikkuFuncName,
       pikkuFuncName,
       {
+        auth: this.options.requiresAuth,
+        singletonServices: this.services,
         getAllServices: () => {
           this.services.rpc = this.services.rpc
             ? ({
@@ -59,16 +67,20 @@ class ContextAwareRPCService {
             : undefined
           return this.services
         },
-        data,
-        session,
+        data: () => data,
+        userSession: this.services.userSession,
         coerceDataFromSchema: this.options.coerceDataFromSchema,
+        interaction: this.interaction,
       }
     )
   }
 }
 
 // RPC Service class for the global interface
-export class PikkuRPCService {
+export class PikkuRPCService<
+  Services extends CoreServices,
+  TypedRPC = PikkuRPC,
+> {
   private config?: RPCServiceConfig
 
   // Initialize the RPC service with configuration
@@ -77,12 +89,18 @@ export class PikkuRPCService {
   }
 
   // Convenience function for initializing
-  injectRPCService(coreServices: CoreServices, depth: number = 0) {
+  injectRPCService(
+    services: Services,
+    interaction: PikkuInteraction,
+    requiresAuth?: boolean | undefined,
+    depth: number = 0
+  ): Services & { rpc: TypedRPC } {
     const serviceCopy = {
-      ...coreServices,
+      ...services,
     }
-    const serviceRPC = new ContextAwareRPCService(serviceCopy, {
+    const serviceRPC = new ContextAwareRPCService(serviceCopy, interaction, {
       coerceDataFromSchema: this.config?.coerceDataFromSchema,
+      requiresAuth,
     })
     serviceCopy.rpc = {
       depth,
@@ -90,7 +108,7 @@ export class PikkuRPCService {
       invoke: serviceRPC.rpc.bind(serviceRPC),
       invokeExposed: serviceRPC.rpc.bind(serviceRPC),
     } as any
-    return serviceCopy
+    return serviceCopy as Services & { rpc: TypedRPC }
   }
 }
 

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

@@ -1,21 +1,22 @@
 import {
+  PikkuInteraction,
   PikkuWiringTypes,
   type CoreServices,
   type CoreSingletonServices,
   type CoreUserSession,
   type CreateSessionServices,
 } from '../../types/core.types.js'
-import type {
-  CoreScheduledTask,
-  PikkuScheduledTask,
-} from './scheduler.types.js'
-import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js'
+import type { CoreScheduledTask } from './scheduler.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
 import { closeSessionServices } from '../../utils.js'
 import { pikkuState } from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
 import { rpcService } from '../rpc/rpc-runner.js'
-import { combineMiddleware, runMiddleware } from '../../middleware-runner.js'
+import { PikkuUserSessionService } from '../../services/user-session-service.js'
+import {
+  CorePikkuFunctionConfig,
+  CorePikkuFunctionSessionless,
+} from '../../function/functions.types.js'
 
 export type RunScheduledTasksParams = {
   name: string
@@ -29,16 +30,25 @@ export type RunScheduledTasksParams = {
 }
 
 export const wireScheduler = <
-  PikkuFunction extends CorePikkuFunctionSessionless<void, void>,
+  PikkuFunctionConfig extends CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<void, void>
+  >,
 >(
-  scheduledTask: CoreScheduledTask<PikkuFunction>
+  scheduledTask: CoreScheduledTask<PikkuFunctionConfig>
 ) => {
   const meta = pikkuState('scheduler', 'meta')
   const taskMeta = meta[scheduledTask.name]
   if (!taskMeta) {
     throw new Error('Task metadata not found')
   }
-  addFunction(taskMeta.pikkuFuncName, scheduledTask.func)
+  addFunction(taskMeta.pikkuFuncName, {
+    func: scheduledTask.func.func,
+    auth: scheduledTask.func.auth,
+    permissions: scheduledTask.func.permissions,
+    middleware: scheduledTask.func.middleware as any,
+    tags: scheduledTask.func.tags,
+    docs: scheduledTask.func.docs as any,
+  })
 
   const tasks = pikkuState('scheduler', 'tasks')
   if (tasks.has(scheduledTask.name)) {
@@ -72,6 +82,11 @@ export async function runScheduledTask({
   const task = pikkuState('scheduler', 'tasks').get(name)
   const meta = pikkuState('scheduler', 'meta')[name]
 
+  const userSession = new PikkuUserSessionService()
+  if (session) {
+    userSession.set(session)
+  }
+
   if (!task) {
     throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`)
   }
@@ -82,12 +97,14 @@ export async function runScheduledTask({
   }
 
   // Create the scheduled task interaction object
-  const scheduledTask: PikkuScheduledTask = {
-    name,
-    schedule: task.schedule,
-    executionTime: new Date(),
-    skip: (reason?: string) => {
-      throw new ScheduledTaskSkippedError(name, reason)
+  const interaction: PikkuInteraction = {
+    scheduledTask: {
+      name,
+      schedule: task.schedule,
+      executionTime: new Date(),
+      skip: (reason?: string) => {
+        throw new ScheduledTaskSkippedError(name, reason)
+      },
     },
   }
 
@@ -96,52 +113,37 @@ export async function runScheduledTask({
       `Running schedule task: ${name} | schedule: ${task.schedule}`
     )
 
-    let result: any
-
-    // Main scheduled task execution logic wrapped for middleware handling
-    const runMain = async () => {
-      const getAllServices = async () => {
-        if (createSessionServices) {
-          const services = await createSessionServices(
-            singletonServices,
-            { scheduledTask },
-            session
-          )
-          sessionServices = services
-          return rpcService.injectRPCService({
-            ...singletonServices,
-            ...services,
-          })
-        }
-        return singletonServices
-      }
+    const getAllServices = async () => {
+      sessionServices = await createSessionServices?.(
+        singletonServices,
+        interaction,
+        session
+      )
 
-      result = await runPikkuFunc(
-        PikkuWiringTypes.scheduler,
-        meta.name,
-        meta.pikkuFuncName,
+      return rpcService.injectRPCService(
         {
-          getAllServices,
-          session,
-          data: undefined,
-          tags: task.tags,
-        }
+          ...singletonServices,
+          ...sessionServices,
+        },
+        interaction
       )
     }
 
-    const funcConfig = pikkuState('function', 'functions').get(
-      meta.pikkuFuncName
-    )
-    await runMiddleware(
-      singletonServices,
-      { scheduledTask },
-      combineMiddleware(PikkuWiringTypes.scheduler, meta.name, {
-        wiringMiddleware: task.middleware,
-        wiringTags: task.tags,
-        funcMiddleware: funcConfig?.middleware,
-        funcTags: funcConfig?.tags,
-      }),
-      runMain
+    const result = await runPikkuFunc(
+      PikkuWiringTypes.scheduler,
+      meta.name,
+      meta.pikkuFuncName,
+      {
+        singletonServices,
+        getAllServices,
+        userSession,
+        auth: false,
+        data: () => undefined,
+        inheritedMiddleware: meta.middleware,
+        wireMiddleware: task.middleware,
+        tags: task.tags,
+        interaction,
+      }
     )
 
     return result

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

@@ -2,8 +2,12 @@ import {
   PikkuDocs,
   CoreUserSession,
   CorePikkuMiddleware,
+  MiddlewareMetadata,
 } from '../../types/core.types.js'
-import { CorePikkuFunctionSessionless } from '../../function/functions.types.js'
+import {
+  CorePikkuFunctionConfig,
+  CorePikkuFunctionSessionless,
+} from '../../function/functions.types.js'
 
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
@@ -18,6 +22,7 @@ export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> =
       session?: UserSession
       docs?: PikkuDocs
       tags?: string[]
+      middleware?: MiddlewareMetadata[] // Pre-resolved middleware chain (tag + explicit)
     }
   >
 
@@ -25,12 +30,14 @@ export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> =
  * Represents a core scheduled task.
  */
 export type CoreScheduledTask<
-  PikkuFunction = CorePikkuFunctionSessionless<void, void>,
+  PikkuFunctionConfig = CorePikkuFunctionConfig<
+    CorePikkuFunctionSessionless<void, void>
+  >,
   PikkuMiddleware = CorePikkuMiddleware<any>,
 > = {
   name: string
   schedule: string
-  func: PikkuFunction
+  func: PikkuFunctionConfig
   docs?: PikkuDocs
   tags?: string[]
   middleware?: PikkuMiddleware[]