@pikku/core 0.7.2 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -24,6 +24,7 @@
     "./channel/local": "./dist/channel/local/index.js",
     "./channel/serverless": "./dist/channel/serverless/index.js",
     "./http": "./dist/http/index.js",
+    "./rpc": "./dist/rpc/index.js",
     "./errors": "./dist/errors/index.js",
     "./scheduler": "./dist/scheduler/index.js",
     "./services": "./dist/services/index.js",

package/src/channel/channel-handler.ts

@@ -96,7 +96,6 @@ export const processMessageHandlers = (
       typeof onMessage === 'function' ? {} : onMessage.permissions
 
     return await runPikkuFunc(pikkuFuncName, {
-      singletonServices: services,
       getAllServices: () => ({
         ...services,
         channel: channelHandler.getChannel(),

package/src/channel/channel-runner.ts

@@ -35,15 +35,16 @@ export const addChannel = <
 
   // Register onConnect function if provided
   if (channel.onConnect && channelMeta.connectPikkuFuncName) {
-    addFunction(channelMeta.connectPikkuFuncName, channel.onConnect as any)
+    addFunction(channelMeta.connectPikkuFuncName, {
+      func: channel.onConnect as any,
+    })
   }
 
   // Register onDisconnect function if provided
   if (channel.onDisconnect && channelMeta.disconnectPikkuFuncName) {
-    addFunction(
-      channelMeta.disconnectPikkuFuncName,
-      channel.onDisconnect as any
-    )
+    addFunction(channelMeta.disconnectPikkuFuncName, {
+      func: channel.onDisconnect,
+    })
   }
 
   // Register onMessage function if provided
@@ -52,7 +53,9 @@ export const addChannel = <
       typeof channel.onMessage === 'function'
         ? channel.onMessage
         : channel.onMessage.func
-    addFunction(channelMeta.message.pikkuFuncName, messageFunc as any)
+    addFunction(channelMeta.message.pikkuFuncName, {
+      func: messageFunc,
+    })
   }
 
   // Register functions in onMessageRoute
@@ -68,10 +71,17 @@ export const addChannel = <
         if (!routeMeta) return
 
         // Extract the function from the handler
-        const routeFunc = typeof handler === 'function' ? handler : handler.func
+        const routeFunc =
+          typeof handler === 'function'
+            ? { func: handler }
+            : {
+                func: handler.func,
+                auth: handler.auth,
+                permissions: handler.permissions,
+              }
 
         // Register the function using the pikku name from metadata
-        addFunction(routeMeta.pikkuFuncName, routeFunc as any)
+        addFunction(routeMeta.pikkuFuncName, routeFunc)
       })
     })
   }

package/src/channel/local/local-channel-runner.ts

@@ -14,6 +14,7 @@ import { runMiddleware } from '../../middleware-runner.js'
 import { PikkuUserSessionService } from '../../services/user-session-service.js'
 import { PikkuHTTP } from '../../http/http.types.js'
 import { runPikkuFuncDirectly } from '../../function/function-runner.js'
+import { rpcService } from '../../rpc/rpc-runner.js'
 
 export const runLocalChannel = async ({
   singletonServices,
@@ -71,11 +72,11 @@ export const runLocalChannel = async ({
         )
       }
 
-      const allServices = {
+      const allServices = rpcService.injectRPCService({
         ...singletonServices,
         ...sessionServices,
         userSession: userSession,
-      }
+      })
 
       channelHandler.registerOnOpen(() => {
         if (channelConfig.onConnect && meta.connectPikkuFuncName) {

package/src/function/function-runner.ts

@@ -2,22 +2,68 @@ import { ForbiddenError } from '../errors/errors.js'
 import { verifyPermissions } from '../permissions.js'
 import { pikkuState } from '../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
+import { Logger } from '../services/logger.js'
+import { CoreServices, CoreUserSession } from '../types/core.types.js'
 import {
-  CoreServices,
-  CoreSingletonServices,
-  CoreUserSession,
-} from '../types/core.types.js'
-import {
-  CoreAPIFunction,
-  CoreAPIFunctionSessionless,
   CorePermissionGroup,
+  CorePikkuFunctionConfig,
 } from './functions.types.js'
 
+// Permission merging function
+function mergePermissions(
+  logger: Logger,
+  funcName: string,
+  funcPermissions?: CorePermissionGroup,
+  transportPermissions?: CorePermissionGroup
+): CorePermissionGroup | undefined {
+  if (!funcPermissions && !transportPermissions) {
+    return undefined
+  }
+
+  if (!funcPermissions) {
+    return transportPermissions
+  }
+
+  if (!transportPermissions) {
+    return funcPermissions
+  }
+
+  // Start with a copy of function permissions
+  const mergedPermissions = { ...funcPermissions }
+
+  // Merge in transport permissions
+  for (const [key, transportValue] of Object.entries(transportPermissions)) {
+    if (key in mergedPermissions) {
+      // For permission arrays, concatenate and deduplicate values
+      if (
+        Array.isArray(mergedPermissions[key]) &&
+        Array.isArray(transportValue)
+      ) {
+        mergedPermissions[key] = [
+          ...new Set([...mergedPermissions[key], ...transportValue]),
+        ]
+      }
+      // For other types, warn about conflict and use the more restrictive (transport-level) value
+      else {
+        logger.warn(
+          `Permission conflict on key "${key}" for function "${funcName}". Using transport-level permission.`
+        )
+        mergedPermissions[key] = transportValue
+      }
+    } else {
+      // If key doesn't exist in function permissions, add it
+      mergedPermissions[key] = transportValue
+    }
+  }
+
+  return mergedPermissions
+}
+
 export const addFunction = (
   funcName: string,
-  func: CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>
+  funcConfig: CorePikkuFunctionConfig<any, any>
 ) => {
-  pikkuState('functions', 'nameToFunction').set(funcName, func)
+  pikkuState('function', 'functions').set(funcName, funcConfig)
 }
 
 export const runPikkuFuncDirectly = async <In, Out>(
@@ -26,24 +72,22 @@ export const runPikkuFuncDirectly = async <In, Out>(
   data: In,
   session?: CoreUserSession
 ) => {
-  const func = pikkuState('functions', 'nameToFunction').get(funcName)
-  if (!func) {
+  const funcConfig = pikkuState('function', 'functions').get(funcName)
+  if (!funcConfig) {
     throw new Error(`Function not found: ${funcName}`)
   }
-  return (await func(allServices, data, session!)) as Out
+  return (await funcConfig.func(allServices, data, session!)) as Out
 }
 
 export const runPikkuFunc = async <In = any, Out = any>(
   funcName: string,
   {
-    singletonServices,
     getAllServices,
     data,
     session,
-    permissions,
+    permissions: transportPermissions,
     coerceDataFromSchema,
   }: {
-    singletonServices: CoreSingletonServices
     getAllServices: () => Promise<CoreServices> | CoreServices
     data: In
     session?: CoreUserSession
@@ -51,20 +95,29 @@ export const runPikkuFunc = async <In = any, Out = any>(
     coerceDataFromSchema?: boolean
   }
 ): Promise<Out> => {
-  const func = pikkuState('functions', 'nameToFunction').get(funcName)
-  if (!func) {
+  const funcConfig = pikkuState('function', 'functions').get(funcName)
+  if (!funcConfig) {
     throw new Error(`Function not found: ${funcName}`)
   }
-  const funcMeta = pikkuState('functions', 'meta')[funcName]
+  const funcMeta = pikkuState('function', 'meta')[funcName]
   if (!funcMeta) {
     throw new Error(`Function meta not found: ${funcName}`)
   }
+
+  if (funcConfig.auth && !session) {
+    throw new ForbiddenError(
+      `Function ${funcName} requires authentication even though transport does not`
+    )
+  }
+
+  const allServices = await getAllServices()
+
   const schemaName = funcMeta.schemaName
   if (schemaName) {
     // Validate request data against the defined schema, if any
     await validateSchema(
-      singletonServices.logger,
-      singletonServices.schema,
+      allServices.logger,
+      allServices.schema,
       schemaName,
       data
     )
@@ -74,11 +127,15 @@ export const runPikkuFunc = async <In = any, Out = any>(
     }
   }
 
-  const allServices = await getAllServices()
-
   // Execute permission checks
+  const mergedPermissions = mergePermissions(
+    allServices.logger,
+    funcName,
+    funcConfig.permissions,
+    transportPermissions
+  )
   const permissioned = await verifyPermissions(
-    permissions,
+    mergedPermissions,
     allServices,
     data,
     session
@@ -88,5 +145,5 @@ export const runPikkuFunc = async <In = any, Out = any>(
     throw new ForbiddenError('Permission denied')
   }
 
-  return (await func(allServices, data, session!)) as Out
+  return (await funcConfig.func(allServices, data, session!)) as Out
 }

package/src/function/functions.types.ts

@@ -75,3 +75,14 @@ export type CoreAPIPermission<
 export type CorePermissionGroup<APIPermission = CoreAPIPermission<any>> =
   | Record<string, APIPermission | APIPermission[]>
   | undefined
+
+export type CorePikkuFunctionConfig<
+  APIFunction extends
+    | CoreAPIFunction<any, any>
+    | CoreAPIFunctionSessionless<any, any>,
+  APIPermission extends CoreAPIPermission<any> = CoreAPIPermission<any>,
+> = {
+  func: APIFunction
+  auth?: boolean
+  permissions?: CorePermissionGroup<APIPermission>
+}

package/src/http/http-runner.test.ts

@@ -15,8 +15,8 @@ const sessionMiddleware: PikkuMiddleware = async (services, _, next) => {
   await next()
 }
 
-const setHTTPFunctionMap = (fun: any) => {
-  pikkuState('functions', 'meta', {
+const setHTTPFunctionMap = (func: any) => {
+  pikkuState('function', 'meta', {
     pikku_func_name: {
       pikkuFuncName: 'pikku_func_name',
       services: ['userSession'],
@@ -31,7 +31,7 @@ const setHTTPFunctionMap = (fun: any) => {
       output: null,
     },
   ])
-  addFunction('pikku_func_name', fun)
+  addFunction('pikku_func_name', { func })
 }
 
 describe('fetch', () => {

package/src/http/http-runner.ts

@@ -31,6 +31,7 @@ import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js'
 import { PikkuChannel } from '../channel/channel.types.js'
 import { addFunction, runPikkuFunc } from '../function/function-runner.js'
+import { rpcService } from '../rpc/rpc-runner.js'
 
 /**
  * Registers middleware either globally or for a specific route.
@@ -101,7 +102,11 @@ export const addHTTPRoute = <
   if (!routeMeta) {
     throw new Error('Route metadata not found')
   }
-  addFunction(routeMeta.pikkuFuncName, httpRoute.func as any)
+  addFunction(routeMeta.pikkuFuncName, {
+    func: httpRoute.func,
+    auth: httpRoute.auth,
+    permissions: httpRoute.permissions,
+  })
   const routes = pikkuState('http', 'routes')
   if (!routes.has(httpRoute.method)) {
     routes.set(httpRoute.method, new Map())
@@ -309,17 +314,17 @@ const executeRouteWithMiddleware = async (
         { http },
         session
       )
-      return {
+
+      return rpcService.injectRPCService({
         ...singletonServices,
         ...sessionServices,
         http,
         userSession,
         channel,
-      }
+      })
     }
 
     const result = await runPikkuFunc(meta.pikkuFuncName, {
-      singletonServices,
       getAllServices,
       session,
       data,

package/src/http/http.types.ts

@@ -196,8 +196,6 @@ export type HTTPRouteMeta = {
   method: HTTPMethod
   params?: string[]
   query?: string[]
-  input: string | null
-  output: string | null
   inputTypes?: HTTPFunctionMetaInputTypes
   docs?: APIDocs
   tags?: string[]

package/src/pikku-state.ts

@@ -10,18 +10,16 @@ import {
   ScheduledTasksMeta,
 } from './scheduler/scheduler.types.js'
 import { ErrorDetails, PikkuError } from './errors/error-handler.js'
-import {
-  CoreAPIFunction,
-  CoreAPIFunctionSessionless,
-} from './function/functions.types.js'
+import { CorePikkuFunctionConfig } from './function/functions.types.js'
+import { RPCMeta } from './rpc/rpc-types.js'
 
 interface PikkuState {
-  functions: {
+  function: {
     meta: FunctionsMeta
-    nameToFunction: Map<
-      string,
-      CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>
-    >
+    functions: Map<string, CorePikkuFunctionConfig<any, any>>
+  }
+  rpc: {
+    meta: Record<string, RPCMeta>
   }
   http: {
     middleware: Array<{ route: string; middleware: PikkuMiddleware[] }>
@@ -44,9 +42,12 @@ interface PikkuState {
 
 export const resetPikkuState = () => {
   globalThis.pikkuState = {
-    functions: {
+    function: {
+      meta: {},
+      functions: new Map(),
+    },
+    rpc: {
       meta: {},
-      nameToFunction: new Map(),
     },
     http: {
       middleware: [],
@@ -59,13 +60,13 @@ export const resetPikkuState = () => {
     },
     scheduler: {
       tasks: new Map(),
-      meta: [],
+      meta: [] as unknown as ScheduledTasksMeta,
     },
     misc: {
       errors: globalThis.pikkuState?.misc?.errors || new Map(),
       schemas: globalThis.pikkuState?.misc?.schema || new Map(),
     },
-  }
+  } as PikkuState
 }
 
 if (!globalThis.pikkuState) {

package/src/rpc/index.ts

@@ -0,0 +1 @@
+export { initialize } from './rpc-runner.js'

package/src/rpc/rpc-runner.ts

@@ -0,0 +1,149 @@
+import {
+  CoreSingletonServices,
+  CoreServices,
+  CreateSessionServices,
+  CoreUserSession,
+} from '../types/core.types.js'
+import { runPikkuFunc } from '../function/function-runner.js'
+import { pikkuState } from '../pikku-state.js'
+import { RPCMeta } from './rpc-types.js'
+import { PikkuUserSessionService } from '../services/user-session-service.js'
+
+// Type for the RPC service configuration
+type RPCServiceConfig = {
+  singletonServices: CoreSingletonServices
+  createSessionServices: CreateSessionServices
+  coerceDataFromSchema: boolean
+}
+
+const getRPCMeta = (rpcName: string): RPCMeta => {
+  const rpc = pikkuState('rpc', 'meta')
+  const rpcMeta = rpc[rpcName]
+  if (!rpcMeta) {
+    throw new Error(`RPC function not found: ${rpcName}`)
+  }
+  return rpcMeta
+}
+
+// Context-aware RPC client for use within services
+class ServiceRPC {
+  constructor(
+    private services: CoreServices,
+    private options: {
+      coerceDataFromSchema?: boolean
+    }
+  ) {}
+
+  public async rpc<In = any, Out = any>(
+    funcName: string,
+    data: In
+  ): Promise<Out> {
+    const session = await this.services.userSession?.get()
+    const rpcDepth = this.services.rpc?.depth || 0
+    const rpcMeta = getRPCMeta(funcName)
+    return runPikkuFunc<In, Out>(rpcMeta.pikkuFuncName, {
+      getAllServices: () => {
+        this.services.rpc = this.services.rpc
+          ? {
+              ...this.services.rpc,
+              depth: rpcDepth + 1,
+              global: false,
+            }
+          : undefined
+        return this.services
+      },
+      data,
+      session,
+      coerceDataFromSchema: this.options.coerceDataFromSchema,
+    })
+  }
+}
+
+// RPC Service class for the global interface
+export class PikkuRPCService {
+  private config?: RPCServiceConfig
+
+  // Initialize the RPC service with configuration
+  initialize(config: RPCServiceConfig) {
+    this.config = config
+  }
+
+  // Convenience function for initializing
+  injectRPCService(coreServices: CoreServices, depth: number = 0) {
+    const serviceCopy = {
+      ...coreServices,
+    }
+    const serviceRPC = new ServiceRPC(serviceCopy, {
+      coerceDataFromSchema: this.config?.coerceDataFromSchema,
+    })
+    serviceCopy.rpc = {
+      depth,
+      global: false,
+      invoke: serviceRPC.rpc.bind(serviceRPC),
+    }
+    return serviceCopy
+  }
+
+  //   Global RPC method to call functions by name
+  async rpc<In = any, Out = any>(
+    funcName: string,
+    data: In,
+    session?: CoreUserSession
+  ): Promise<Out> {
+    if (!this.config) {
+      throw new Error('RPC service not initialized')
+    }
+
+    const rpcMeta = getRPCMeta(funcName)
+    const { singletonServices, createSessionServices, coerceDataFromSchema } =
+      this.config
+
+    // Define the getAllServices function for runPikkuFunc
+    const getAllServices = async () => {
+      const userSession = new PikkuUserSessionService()
+      if (session) {
+        userSession.set(session)
+      }
+
+      const sessionServices = await createSessionServices(
+        singletonServices,
+        {},
+        session
+      )
+
+      return this.injectRPCService(
+        {
+          ...singletonServices,
+          ...sessionServices,
+          userSession,
+        },
+        0
+      )
+    }
+
+    // Call the function using runPikkuFunc - it will handle permission merging
+    return runPikkuFunc<In, Out>(rpcMeta.pikkuFuncName, {
+      getAllServices,
+      data,
+      session,
+      coerceDataFromSchema: coerceDataFromSchema ?? true,
+    })
+  }
+}
+
+// Create a singleton instance
+export const rpcService = new PikkuRPCService()
+
+// Convenience function for initializing
+export const initialize = (config: RPCServiceConfig) => {
+  rpcService.initialize(config)
+}
+
+// Convenience function for making standalone RPC calls
+export const pikkuRPC = <In = any, Out = any, session = CoreUserSession>(
+  funcName: string,
+  data: In,
+  session?: CoreUserSession
+): Promise<Out> => {
+  return rpcService.rpc(funcName, data, session)
+}

package/src/rpc/rpc-types.ts

@@ -0,0 +1,10 @@
+export type PikkuRPC = {
+  depth: number
+  global: boolean
+  invoke: any
+}
+
+export type RPCMeta = {
+  pikkuFuncName: string
+  exposed: boolean
+}

package/src/scheduler/scheduler-runner.ts

@@ -10,6 +10,7 @@ import { getErrorResponse } 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'
 
 export type RunScheduledTasksParams = {
   name: string
@@ -32,7 +33,9 @@ export const addScheduledTask = <
   if (!taskMeta) {
     throw new Error('Task metadata not found')
   }
-  addFunction(taskMeta.pikkuFuncName, scheduledTask.func)
+  addFunction(taskMeta.pikkuFuncName, {
+    func: scheduledTask.func,
+  })
 
   const tasks = pikkuState('scheduler', 'tasks')
   if (tasks.has(scheduledTask.name)) {
@@ -80,13 +83,15 @@ export async function runScheduledTask<
           {},
           session
         )
-        return { ...singletonServices, ...sessionServices }
+        return rpcService.injectRPCService({
+          ...singletonServices,
+          ...sessionServices,
+        })
       }
       return singletonServices
     }
 
     return await runPikkuFunc(meta.pikkuFuncName, {
-      singletonServices,
       getAllServices,
       session,
       data: undefined,

package/src/schema.ts

@@ -41,10 +41,12 @@ const validateAllSchemasLoaded = (
   const missingSchemas: string[] = []
 
   for (const route of routesMeta) {
-    if (!route.input || validators.has(route.input)) {
+    const inputs = pikkuState('function', 'meta')[route.pikkuFuncName]?.inputs
+    const input = inputs?.[0]
+    if (!input || validators.has(input)) {
       continue
     }
-    missingSchemas.push(route.input)
+    missingSchemas.push(input)
   }
 
   if (missingSchemas.length > 0) {

package/src/types/core.types.ts

@@ -7,6 +7,7 @@ import { UserSessionService } from '../services/user-session-service.js'
 import { JWTService } from '../services/jwt-service.js'
 import { SecretService } from '../services/secret-service.js'
 import { PikkuChannel } from '../channel/channel.types.js'
+import { PikkuRPC } from '../rpc/rpc-types.js'
 
 export interface FunctionServicesMeta {
   optimized: boolean
@@ -126,6 +127,7 @@ export type CoreServices<
   CoreServices extends Record<string, unknown> = {},
 > = SingletonServices &
   PikkuInteraction & {
+    rpc?: PikkuRPC
     userSession?: UserSessionService<UserSession>
     channel?: PikkuChannel<unknown, unknown>
   } & CoreServices