@pikku/core 0.6.27 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.6.27",
+  "version": "0.7.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -19,6 +19,7 @@
   "exports": {
     ".": "./dist/index.js",
     "./middleware": "./dist/middleware/index.js",
+    "./function": "./dist/function/index.js",
     "./channel": "./dist/channel/index.js",
     "./channel/local": "./dist/channel/local/index.js",
     "./channel/serverless": "./dist/channel/serverless/index.js",

package/src/channel/channel-handler.ts

@@ -1,5 +1,4 @@
 import {
-  CoreSingletonServices,
   CoreServices,
   JSONValue,
   CoreUserSession,
@@ -9,18 +8,15 @@ import {
   CoreAPIChannel,
   PikkuChannelHandler,
 } from './channel.types.js'
-import { verifyPermissions } from '../permissions.js'
 import { pikkuState } from '../pikku-state.js'
+import { runPikkuFunc } from '../function/function-runner.js'
 
 const getRouteMeta = (
   channelName: string,
   routingProperty?: string,
   routerValue?: string
 ): ChannelMessageMeta => {
-  const channelsMeta = pikkuState('channel', 'meta')
-  const channelMeta = channelsMeta.find(
-    (channelMeta) => channelMeta.name === channelName
-  )
+  const channelMeta = pikkuState('channel', 'meta')[channelName]
   if (!channelMeta) {
     throw new Error(`Channel ${channelName} not found`)
   }
@@ -44,19 +40,6 @@ const getRouteMeta = (
   return route
 }
 
-const validateSchema = (
-  logger: CoreSingletonServices['logger'],
-  data: JSONValue,
-  channelRoute: ChannelMessageMeta
-) => {
-  const schemaNames = channelRoute.inputs
-  if (schemaNames) {
-    // TODO
-    // loadSchema(schemaNames, logger)
-    // validateJson(schemaNames, data)
-  }
-}
-
 const validateAuth = (
   requiresSession: boolean,
   session: CoreUserSession | undefined,
@@ -75,40 +58,6 @@ const validateAuth = (
   return true
 }
 
-const validatePermissions = async (
-  services: CoreServices,
-  session: CoreUserSession | undefined,
-  onMessage: any,
-  data: unknown
-) => {
-  const permissions =
-    typeof onMessage === 'function' ? {} : onMessage.permissions
-  return await verifyPermissions(permissions, services, data, session)
-}
-
-const runFunction = async (
-  services: CoreServices,
-  channelHandler: PikkuChannelHandler,
-  channelMessageMeta: ChannelMessageMeta,
-  session: CoreUserSession | undefined,
-  onMessage: any,
-  data: unknown
-) => {
-  const func: any = typeof onMessage === 'function' ? onMessage : onMessage.func
-  if (channelMessageMeta.type?.toLowerCase().includes('function')) {
-    return await func(
-      {
-        ...services,
-        channel: channelHandler.getChannel(),
-      },
-      data,
-      session
-    )
-  } else {
-    return await func(services, channelHandler.getChannel(), data)
-  }
-}
-
 export const processMessageHandlers = (
   services: CoreServices,
   session: CoreUserSession | undefined,
@@ -137,36 +86,25 @@ export const processMessageHandlers = (
       return
     }
 
-    const routeMeta = getRouteMeta(
+    const { pikkuFuncName } = getRouteMeta(
       channelConfig.name,
       routingProperty,
       routerValue
     )
 
-    if (routeMeta) {
-      await validateSchema(services.logger, data, routeMeta)
-    }
-
-    const hasPermission = await validatePermissions(
-      services,
-      channelHandler,
-      onMessage,
-      data
-    )
-    if (!hasPermission) {
-      logger.error(
-        `Channel ${channelConfig.name} requires permissions for ${routingProperty || 'default message route'}`
-      )
-    }
+    const permissions =
+      typeof onMessage === 'function' ? {} : onMessage.permissions
 
-    return await runFunction(
-      services,
-      channelHandler,
-      routeMeta,
+    return await runPikkuFunc(pikkuFuncName, {
+      singletonServices: services,
+      getAllServices: () => ({
+        ...services,
+        channel: channelHandler.getChannel(),
+      }),
+      data,
       session,
-      onMessage,
-      data
-    )
+      permissions,
+    })
   }
 
   const onMessage = async (rawData): Promise<unknown> => {
@@ -215,9 +153,9 @@ export const processMessageHandlers = (
 
     if (!processed) {
       logger.error(
-        `No handler found for message in channel ${channelConfig.name} for ${rawData}`
+        `No handler found for message in channel ${channelConfig.name} for ${JSON.stringify(rawData)}`
       )
-      logger.error(`Channel ${channelConfig}`)
+      logger.error(`Channel ${JSON.stringify(channelConfig)}`)
     }
 
     return result

package/src/channel/channel-runner.ts

@@ -1,14 +1,20 @@
 import { NotFoundError } from '../errors/errors.js'
+import { addFunction } from '../function/function-runner.js'
 import { pikkuState } from '../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
 import { UserSessionService } from '../services/user-session-service.js'
 import {
+  ChannelMeta,
   CoreAPIChannel,
   RunChannelOptions,
   RunChannelParams,
 } from './channel.types.js'
 import { match } from 'path-to-regexp'
 
+/**
+ * Adds a channel and registers all functions referenced in it using the
+ * function names already stored in the channel metadata
+ */
 export const addChannel = <
   In,
   Channel extends string,
@@ -16,21 +22,68 @@ export const addChannel = <
   ChannelFunctionSessionless,
   APIPermission,
 >(
-  channel: CoreAPIChannel<
-    In,
-    Channel,
-    ChannelFunction,
-    ChannelFunctionSessionless,
-    APIPermission
-  >
+  channel: CoreAPIChannel<In, Channel, ChannelFunction, APIPermission>
 ) => {
-  pikkuState('channel', 'channels').push(channel as any)
+  // Get the channel metadata
+  const channelsMeta = pikkuState('channel', 'meta')
+  const channelMeta = channelsMeta[channel.name]
+  if (!channelMeta) {
+    throw new Error(`Channel metadata not found for channel: ${channel.name}`)
+  }
+
+  pikkuState('channel', 'channels').set(channel.name, channel as any)
+
+  // Register onConnect function if provided
+  if (channel.onConnect && channelMeta.connectPikkuFuncName) {
+    addFunction(channelMeta.connectPikkuFuncName, channel.onConnect as any)
+  }
+
+  // Register onDisconnect function if provided
+  if (channel.onDisconnect && channelMeta.disconnectPikkuFuncName) {
+    addFunction(
+      channelMeta.disconnectPikkuFuncName,
+      channel.onDisconnect as any
+    )
+  }
+
+  // Register onMessage function if provided
+  if (channel.onMessage && channelMeta.message?.pikkuFuncName) {
+    const messageFunc =
+      typeof channel.onMessage === 'function'
+        ? channel.onMessage
+        : channel.onMessage.func
+    addFunction(channelMeta.message.pikkuFuncName, messageFunc as any)
+  }
+
+  // Register functions in onMessageRoute
+  if (channel.onMessageRoute && channelMeta.messageRoutes) {
+    // Iterate through each channel in onMessageRoute
+    Object.entries(channel.onMessageRoute).forEach(([channelKey, routes]) => {
+      const channelRoutes = channelMeta.messageRoutes[channelKey]
+      if (!channelRoutes) return
+
+      // Iterate through each route in the channel
+      Object.entries(routes).forEach(([routeKey, handler]) => {
+        const routeMeta = channelRoutes[routeKey]
+        if (!routeMeta) return
+
+        // Extract the function from the handler
+        const routeFunc = typeof handler === 'function' ? handler : handler.func
+
+        // Register the function using the pikku name from metadata
+        addFunction(routeMeta.pikkuFuncName, routeFunc as any)
+      })
+    })
+  }
+
+  // Store the channel configuration
+  pikkuState('channel', 'channels').set(channel.name, channel as any)
 }
 
-export const getMatchingChannelConfig = (request: string) => {
+const getMatchingChannelConfig = (request: string) => {
   const channels = pikkuState('channel', 'channels')
   const channelsMeta = pikkuState('channel', 'meta')
-  for (const channelConfig of channels) {
+  for (const channelConfig of channels.values()) {
     const cleanedRoute = channelConfig.route.replace(/^\/\//, '/')
     const cleanedRequest = request.replace(/^\/\//, '/')
     const matchFunc = match(cleanedRoute, {
@@ -38,18 +91,19 @@ export const getMatchingChannelConfig = (request: string) => {
     })
     const matchedPath = matchFunc(cleanedRequest)
     if (matchedPath) {
-      const schemaName = channelsMeta.find(
-        (channelMeta) => channelMeta.route === channelConfig.route
-      )?.input
+      const channelMeta = channelsMeta[channelConfig.name]
+      if (!channelMeta) {
+        throw new Error(`Channel ${channelConfig.name} not found in metadata`)
+      }
       return {
         matchedPath,
         params: matchedPath.params,
         channelConfig,
-        schemaName,
+        schemaName: channelMeta.input,
+        meta: channelMeta,
       }
     }
   }
-
   return null
 }
 
@@ -64,6 +118,7 @@ export const openChannel = async ({
   } & RunChannelOptions): Promise<{
   openingData: unknown
   channelConfig: CoreAPIChannel<unknown, any>
+  meta: ChannelMeta
 }> => {
   const matchingChannel = getMatchingChannelConfig(route)
   if (!matchingChannel) {
@@ -71,7 +126,7 @@ export const openChannel = async ({
     throw new NotFoundError(`Channel not found: ${route}`)
   }
 
-  const { params, channelConfig, schemaName } = matchingChannel
+  const { params, channelConfig, schemaName, meta } = matchingChannel
 
   const requiresSession = channelConfig.auth !== false
   request?.setParams(params)
@@ -94,5 +149,5 @@ export const openChannel = async ({
     )
   }
 
-  return { openingData, channelConfig }
+  return { openingData, channelConfig, meta }
 }

package/src/channel/channel.types.ts

@@ -3,15 +3,18 @@ import {
   HTTPFunctionMetaInputTypes,
   PikkuHTTPRequest,
   PikkuHTTPResponse,
-} from '../http/http-routes.types.js'
+} from '../http/http.types.js'
 import {
   APIDocs,
-  CoreServices,
   CoreSingletonServices,
   CreateSessionServices,
   PikkuMiddleware,
 } from '../types/core.types.js'
-import { CoreAPIFunction, CoreAPIPermission } from '../types/functions.types.js'
+import {
+  CoreAPIFunction,
+  CoreAPIFunctionSessionless,
+  CoreAPIPermission,
+} from '../function/functions.types.js'
 
 export type RunChannelOptions = Partial<{
   skipUserSession: boolean
@@ -30,10 +33,10 @@ export type RunChannelParams<ChannelData> = {
 }
 
 export interface ChannelMessageMeta {
+  pikkuFuncName: string
   inputs: string[] | null
   outputs: string[] | null
   docs?: APIDocs
-  type: null | string
 }
 
 export interface ChannelMeta {
@@ -44,88 +47,49 @@ export interface ChannelMeta {
   input: string | null
   inputTypes?: HTTPFunctionMetaInputTypes
   connect: boolean
+  connectPikkuFuncName: string | null
   disconnect: boolean
+  disconnectPikkuFuncName: string | null
   message: ChannelMessageMeta | null
   messageRoutes: Record<string, Record<string, ChannelMessageMeta>>
   docs?: APIDocs
   tags?: string[]
 }
 
-export type ChannelsMeta = ChannelMeta[]
-
-export type CoreChannelConnection<
-  ChannelData,
-  Out = unknown,
-  Services extends CoreServices = CoreServices,
-> = (
-  services: Services,
-  channel: PikkuChannel<ChannelData, Out>
-) => Promise<void>
-
-export type CoreChannelDisconnection<
-  ChannelData,
-  Services extends CoreServices = CoreServices,
-> = (
-  services: Services,
-  channel: PikkuChannel<ChannelData, never>
-) => Promise<void>
-
-/**
- * Represents a core channel function that performs an operation using core services and a user session.
- *
- * @template In - The input type.
- * @template Services - The services type, defaults to `CoreServices`.
- * @template Session - The session type, defaults to `CoreUserSession`.
- */
-export type CoreChannelMessage<
-  In,
-  Out,
-  ChannelData,
-  Services extends CoreServices = CoreServices,
-> = (
-  services: Services,
-  channel: PikkuChannel<ChannelData, Out>,
-  data: In
-) => Promise<void | Out>
-
-export type CoreAPIChannelMessage<
-  ChannelFunctionMessage = CoreChannelMessage<unknown, unknown, unknown>,
-> = {
-  func: ChannelFunctionMessage
-  route: string
-}
+export type ChannelsMeta = Record<string, ChannelMeta>
 
 export type CoreAPIChannel<
   ChannelData,
   Channel extends string,
-  ChannelFunctionConnection = CoreChannelConnection<ChannelData>,
-  ChannelFunctionDisconnection = CoreChannelDisconnection<ChannelData>,
-  ChannelFunctionDefaultMessage =
-    | CoreChannelMessage<unknown, unknown, unknown>
-    | CoreAPIFunction<unknown, unknown>,
-  ChannelFunctionMessageRoute =
-    | CoreChannelMessage<unknown, unknown, unknown>
-    | CoreAPIFunction<unknown, unknown>,
+  ChannelConnect =
+    | CoreAPIFunction<void, unknown, ChannelData>
+    | CoreAPIFunctionSessionless<void, unknown, ChannelData>,
+  ChannelDisconnect =
+    | CoreAPIFunction<void, void, ChannelData>
+    | CoreAPIFunctionSessionless<void, void, ChannelData>,
+  ChannelFunctionMessage =
+    | CoreAPIFunction<unknown, unknown, ChannelData>
+    | CoreAPIFunctionSessionless<unknown, unknown, ChannelData>,
   APIPermission = CoreAPIPermission<ChannelData>,
 > = {
   name: string
   route: Channel
-  onConnect?: ChannelFunctionConnection
-  onDisconnect?: ChannelFunctionDisconnection
+  onConnect?: ChannelConnect
+  onDisconnect?: ChannelDisconnect
   onMessage?:
     | {
-        func: ChannelFunctionDefaultMessage
+        func: ChannelFunctionMessage
         permissions?: Record<string, APIPermission[] | APIPermission>
         auth?: boolean
       }
-    | ChannelFunctionDefaultMessage
+    | ChannelFunctionMessage
   onMessageRoute?: Record<
     string,
     Record<
       string,
-      | ChannelFunctionMessageRoute
+      | ChannelFunctionMessage
       | {
-          func: ChannelFunctionMessageRoute
+          func: ChannelFunctionMessage
           permissions?: Record<string, APIPermission[] | APIPermission>
           auth?: boolean
         }
@@ -143,8 +107,6 @@ export type CoreAPIChannel<
   tags?: string[]
 }
 
-export type CoreAPIChannels = CoreAPIChannel<any, string>[]
-
 export interface PikkuChannel<OpeningData, Out> {
   // The channel identifier
   channelId: string

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

@@ -1,14 +1,14 @@
 import { test, beforeEach, afterEach } from 'node:test'
 import * as assert from 'node:assert/strict'
 import { runLocalChannel } from './local-channel-runner.js'
-import { resetPikkuState } from '../../pikku-state.js'
+import { pikkuState, resetPikkuState } from '../../pikku-state.js'
 import { addChannel } from '../channel-runner.js'
 import {
   HTTPMethod,
   PikkuHTTPRequest,
   PikkuHTTPResponse,
   PikkuQuery,
-} from '../../http/http-routes.types.js'
+} from '../../http/http.types.js'
 import { SerializeOptions } from 'cookie'
 
 /**
@@ -126,22 +126,21 @@ test('runChannel should return undefined and 404 if no matching channel is found
 
 test('runChannel should return a channel handler if channel matches and no auth required', async () => {
   resetPikkuState()
+
+  pikkuState('channel', 'meta', {
+    test: {
+      name: 'test',
+      route: '/test-channel',
+    },
+  } as any)
   addChannel({
     name: 'test',
     route: '/test-channel',
     auth: false,
   })
 
-  // Provide a fake channelPermissionService if needed
-  const singletonServicesWithPerm = {
-    ...mockSingletonServices,
-    channelPermissionService: {
-      verifyChannelAccess: async () => {},
-    },
-  }
-
   const result = await runLocalChannel({
-    singletonServices: singletonServicesWithPerm,
+    singletonServices: mockSingletonServices,
     channelId: 'test-channel-id',
     request: new PikkuMockRequest('/test-channel', 'get'),
     response: new PikkuMockResponse(),

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

@@ -1,5 +1,5 @@
 import { openChannel } from '../channel-runner.js'
-import { createHTTPInteraction } from '../../http/http-route-runner.js'
+import { createHTTPInteraction } from '../../http/http-runner.js'
 import { closeSessionServices } from '../../utils.js'
 import { processMessageHandlers } from '../channel-handler.js'
 import {
@@ -12,7 +12,8 @@ import { SessionServices } from '../../types/core.types.js'
 import { handleError } from '../../handle-error.js'
 import { runMiddleware } from '../../middleware-runner.js'
 import { PikkuUserSessionService } from '../../services/user-session-service.js'
-import { PikkuHTTP } from '../../http/http-routes.types.js'
+import { PikkuHTTP } from '../../http/http.types.js'
+import { runPikkuFuncDirectly } from '../../function/function-runner.js'
 
 export const runLocalChannel = async ({
   singletonServices,
@@ -42,7 +43,7 @@ export const runLocalChannel = async ({
 
   const main = async () => {
     try {
-      const { openingData, channelConfig } = await openChannel({
+      const { openingData, channelConfig, meta } = await openChannel({
         channelId,
         createSessionServices,
         respondWith404,
@@ -77,11 +78,23 @@ export const runLocalChannel = async ({
       }
 
       channelHandler.registerOnOpen(() => {
-        channelConfig.onConnect?.(allServices, channel)
+        if (channelConfig.onConnect && meta.connectPikkuFuncName) {
+          runPikkuFuncDirectly(
+            meta.connectPikkuFuncName,
+            { ...allServices, channel },
+            openingData
+          )
+        }
       })
 
       channelHandler.registerOnClose(async () => {
-        channelConfig.onDisconnect?.(allServices, channel)
+        if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
+          runPikkuFuncDirectly(
+            meta.disconnectPikkuFuncName,
+            { ...allServices, channel },
+            openingData
+          )
+        }
         if (sessionServices) {
           await closeSessionServices(singletonServices.logger, sessionServices)
         }
@@ -91,7 +104,7 @@ export const runLocalChannel = async ({
         processMessageHandlers(
           allServices,
           session,
-          channelConfig,
+          channelConfig as any,
           channelHandler
         )
       )
@@ -122,5 +135,5 @@ export const runLocalChannel = async ({
     main
   )
 
-  return channelHandler!
+  return channelHandler
 }

package/src/channel/log-channels.ts

@@ -7,14 +7,14 @@ import { Logger } from '../services/index.js'
  */
 export const logChannels = (logger: Logger) => {
   const channels = pikkuState('channel', 'channels')
-  if (channels.length === 0) {
+  if (channels.size === 0) {
     logger.info('No channels added')
     return
   }
 
   let scheduledChannels = 'Channels:'
-  for (const { name, route } of channels) {
-    scheduledChannels += `\n\t- ${name} at ${route}`
-  }
+  channels.forEach((channel) => {
+    scheduledChannels += `\n\t- ${channel.name} at ${channel.route}`
+  })
   logger.info(scheduledChannels)
 }

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

@@ -8,14 +8,15 @@ import type {
   RunChannelParams,
   PikkuChannelHandlerFactory,
 } from '../channel.types.js'
-import { createHTTPInteraction } from '../../http/http-route-runner.js'
+import { createHTTPInteraction } from '../../http/http-runner.js'
 import { ChannelStore } from '../channel-store.js'
 import { handleError } from '../../handle-error.js'
 import { PikkuUserSessionService } from '../../services/user-session-service.js'
 import { runMiddleware } from '../../middleware-runner.js'
 import { pikkuState } from '../../pikku-state.js'
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js'
-import { PikkuHTTP } from '../../http/http-routes.types.js'
+import { PikkuHTTP } from '../../http/http.types.js'
+import { runPikkuFuncDirectly } from '../../function/function-runner.js'
 
 export interface RunServerlessChannelParams<ChannelData>
   extends RunChannelParams<ChannelData> {
@@ -36,12 +37,15 @@ const getVariablesForChannel = ({
   openingData?: unknown
 }) => {
   const channels = pikkuState('channel', 'channels')
-  const channelConfig = channels.find(
-    (channelConfig) => channelConfig.name === channelName
-  )
+  const channelConfig = channels[channelName]
+  const channelsMeta = pikkuState('channel', 'meta')
+  const meta = channelsMeta[channelName]
   if (!channelConfig) {
     throw new Error(`Channel not found: ${channelName}`)
   }
+  if (!meta) {
+    throw new Error(`Channel meta not found: ${channelName}`)
+  }
   const channelHandler = channelHandlerFactory(
     channelId,
     channelConfig.name,
@@ -51,6 +55,7 @@ const getVariablesForChannel = ({
     channelConfig,
     channelHandler,
     channel: channelHandler.getChannel(),
+    meta,
   }
 }
 
@@ -80,7 +85,7 @@ export const runChannelConnect = async ({
 
   const userSession = new PikkuUserSessionService(channelStore, channelId)
 
-  const { channelConfig, openingData } = await openChannel({
+  const { channelConfig, openingData, meta } = await openChannel({
     channelId,
     createSessionServices,
     request,
@@ -110,10 +115,13 @@ export const runChannelConnect = async ({
           await userSession.get()
         )
       }
-      await channelConfig.onConnect?.(
-        { ...singletonServices, ...sessionServices },
-        channel
-      )
+      if (channelConfig.onConnect && meta.connectPikkuFuncName) {
+        await runPikkuFuncDirectly(
+          meta.connectPikkuFuncName,
+          { ...singletonServices, ...sessionServices, channel },
+          openingData
+        )
+      }
       http?.response?.status(101)
     } catch (e: any) {
       handleError(
@@ -150,7 +158,7 @@ export const runChannelDisconnect = async ({
   let sessionServices: SessionServices | undefined
   const { openingData, channelName, session } =
     await params.channelStore.getChannelAndSession(params.channelId)
-  const { channel, channelConfig } = getVariablesForChannel({
+  const { channel, channelConfig, meta } = getVariablesForChannel({
     ...params,
     openingData,
     channelName,
@@ -162,10 +170,13 @@ export const runChannelDisconnect = async ({
       session
     )
   }
-  await channelConfig.onDisconnect?.(
-    { ...singletonServices, ...sessionServices },
-    channel
-  )
+  if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
+    await runPikkuFuncDirectly(
+      meta.disconnectPikkuFuncName,
+      { ...singletonServices, ...sessionServices, channel },
+      undefined
+    )
+  }
   await params.channelStore.removeChannels([channel.channelId])
   if (sessionServices) {
     await closeSessionServices(singletonServices.logger, sessionServices)