@pikku/core 0.6.21 → 0.6.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.6.21",
+  "version": "0.6.22",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -23,8 +23,6 @@
     "./channel/local": "./dist/channel/local/index.js",
     "./channel/serverless": "./dist/channel/serverless/index.js",
     "./http": "./dist/http/index.js",
-    "./http/pikku-http-abstract-response": "./dist/http/pikku-http-abstract-response.js",
-    "./http/pikku-http-abstract-request": "./dist/http/pikku-http-abstract-request.js",
     "./errors": "./dist/errors/index.js",
     "./scheduler": "./dist/scheduler/index.js",
     "./services": "./dist/services/index.js",
@@ -35,7 +33,8 @@
     "@types/cookie": "^0.6.0",
     "@types/uuid": "^10.0.0",
     "cookie": "^1.0.1",
-    "path-to-regexp": "^8.2.0"
+    "path-to-regexp": "^8.2.0",
+    "picoquery": "^2.4.0"
   },
   "devDependencies": {
     "@types/node": "^22.7.8",

package/src/channel/channel-handler.ts

@@ -4,38 +4,62 @@ import {
   JSONValue,
   CoreUserSession,
 } from '../types/core.types.js'
-import { CoreAPIChannel, PikkuChannelHandler } from './channel.types.js'
+import {
+  ChannelMessageMeta,
+  CoreAPIChannel,
+  PikkuChannelHandler,
+} from './channel.types.js'
 import { verifyPermissions } from '../permissions.js'
 import { pikkuState } from '../pikku-state.js'
 
-const validateSchema = (
-  logger: CoreSingletonServices['logger'],
-  data: JSONValue,
+const getRouteMeta = (
   channelName: string,
   routingProperty?: string,
   routerValue?: string
-) => {
+): ChannelMessageMeta => {
   const channelsMeta = pikkuState('channel', 'meta')
-  for (const channelMeta of channelsMeta) {
-    if (routingProperty && routerValue) {
-      const channelRoute =
-        channelMeta.messageRoutes[routingProperty]?.[routerValue]
-      if (channelRoute) {
-        const schemaNames = channelRoute.inputs
-        if (schemaNames) {
-          // TODO
-          // loadSchema(schemaNames, logger)
-          // validateJson(schemaNames, data)
-        }
-        return
-      }
+  const channelMeta = channelsMeta.find(
+    (channelMeta) => channelMeta.name === channelName
+  )
+  if (!channelMeta) {
+    throw new Error(`Channel ${channelName} not found`)
+  }
+  if (!routingProperty) {
+    if (!channelMeta.message) {
+      throw new Error(`Channel ${channelName} has no default message route`)
     }
+    return channelMeta.message
+  }
+  if (!routerValue) {
+    throw new Error(
+      `Channel ${channelName} requires a router value for ${routingProperty}`
+    )
+  }
+  const route = channelMeta.messageRoutes[routingProperty]?.[routerValue]
+  if (!route) {
+    throw new Error(
+      `Channel ${channelName} has no route for ${routingProperty}:${routerValue}`
+    )
+  }
+  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,
-  userSession: CoreUserSession | undefined,
+  session: CoreUserSession | undefined,
   onMessage: any
 ) => {
   const auth =
@@ -45,7 +69,7 @@ const validateAuth = (
         ? requiresSession
         : onMessage.auth
 
-  if (auth && !userSession) {
+  if (auth && !session) {
     return false
   }
   return true
@@ -53,27 +77,41 @@ const validateAuth = (
 
 const validatePermissions = async (
   services: CoreServices,
-  userSession: CoreUserSession | undefined,
+  session: CoreUserSession | undefined,
   onMessage: any,
   data: unknown
 ) => {
   const permissions =
     typeof onMessage === 'function' ? {} : onMessage.permissions
-  return await verifyPermissions(permissions, services, data, userSession)
+  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
-  return await func(services, channelHandler.getChannel(), data)
+  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,
   channelConfig: CoreAPIChannel<any, any>,
   channelHandler: PikkuChannelHandler
 ) => {
@@ -83,6 +121,7 @@ export const processMessageHandlers = (
   const processMessage = async (
     data: JSONValue,
     onMessage: any,
+    session: CoreUserSession | undefined,
     routingProperty?: string,
     routerValue?: string
   ): Promise<unknown> => {
@@ -98,14 +137,16 @@ export const processMessageHandlers = (
       return
     }
 
-    validateSchema(
-      services.logger,
-      data,
+    const routeMeta = getRouteMeta(
       channelConfig.name,
       routingProperty,
       routerValue
     )
 
+    if (routeMeta) {
+      validateSchema(services.logger, data, routeMeta)
+    }
+
     const hasPermission = await validatePermissions(
       services,
       channelHandler,
@@ -118,7 +159,14 @@ export const processMessageHandlers = (
       )
     }
 
-    return await runFunction(services, channelHandler, onMessage, data)
+    return await runFunction(
+      services,
+      channelHandler,
+      routeMeta,
+      session,
+      onMessage,
+      data
+    )
   }
 
   const onMessage = async (rawData): Promise<unknown> => {
@@ -137,6 +185,7 @@ export const processMessageHandlers = (
             result = await processMessage(
               messageData,
               routes[routerValue],
+              session,
               routingProperty,
               routerValue
             )
@@ -147,7 +196,11 @@ export const processMessageHandlers = (
         // Default handler if no routes matched but json data was parsed
         if (!processed && channelConfig.onMessage) {
           processed = true
-          result = await processMessage(messageData, channelConfig.onMessage)
+          result = await processMessage(
+            messageData,
+            channelConfig.onMessage,
+            session
+          )
         }
       } catch (error) {
         // Most likely a json error.. ignore
@@ -157,7 +210,7 @@ export const processMessageHandlers = (
     // Default handler if no routes matched and json data wasn't parsed
     if (!processed && channelConfig.onMessage) {
       processed = true
-      result = await processMessage(rawData, channelConfig.onMessage)
+      result = await processMessage(rawData, channelConfig.onMessage, session)
     }
 
     if (!processed) {

package/src/channel/channel-runner.ts

@@ -57,10 +57,10 @@ export const openChannel = async ({
   route,
   singletonServices,
   coerceToArray = false,
-  http,
+  request,
 }: Pick<CoreAPIChannel<unknown, string>, 'route'> &
-  Omit<RunChannelParams<unknown>, 'response' | 'request'> & {
-    userSessionService?: UserSessionService<any>
+  RunChannelParams<unknown> & {
+    userSessionService: UserSessionService<any>
   } & RunChannelOptions): Promise<{
   openingData: unknown
   channelConfig: CoreAPIChannel<unknown, any>
@@ -74,15 +74,15 @@ export const openChannel = async ({
   const { params, channelConfig, schemaName } = matchingChannel
 
   const requiresSession = channelConfig.auth !== false
-  http?.request?.setParams(params)
+  request?.setParams(params)
 
   singletonServices.logger.info(
     `Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`
   )
 
   let openingData: any | undefined
-  if (http?.request) {
-    openingData = await http.request.getData()
+  if (request) {
+    openingData = await request.data()
     if (coerceToArray && schemaName) {
       coerceQueryStringToArray(schemaName, openingData)
     }

package/src/channel/channel.types.ts

@@ -1,10 +1,9 @@
 import { PikkuError } from '../errors/error-handler.js'
 import {
   HTTPFunctionMetaInputTypes,
-  PikkuHTTP,
+  PikkuHTTPRequest,
+  PikkuHTTPResponse,
 } from '../http/http-routes.types.js'
-import { PikkuHTTPAbstractRequest } from '../http/pikku-http-abstract-request.js'
-import { PikkuHTTPAbstractResponse } from '../http/pikku-http-abstract-response.js'
 import {
   APIDocs,
   CoreServices,
@@ -12,9 +11,7 @@ import {
   CreateSessionServices,
   PikkuMiddleware,
 } from '../types/core.types.js'
-import { CoreAPIPermission } from '../types/functions.types.js'
-import { PikkuRequest } from '../pikku-request.js'
-import { PikkuResponse } from '../pikku-response.js'
+import { CoreAPIFunction, CoreAPIPermission } from '../types/functions.types.js'
 
 export type RunChannelOptions = Partial<{
   skipUserSession: boolean
@@ -27,13 +24,17 @@ export type RunChannelOptions = Partial<{
 export type RunChannelParams<ChannelData> = {
   channelId: string
   singletonServices: CoreSingletonServices
-  request?: PikkuRequest<ChannelData> | PikkuHTTPAbstractRequest<ChannelData>
-  response?: PikkuResponse | PikkuHTTPAbstractResponse
-  http?: PikkuHTTP
+  request?: PikkuHTTPRequest<ChannelData>
+  response?: PikkuHTTPResponse
   createSessionServices?: CreateSessionServices
 }
 
-export interface HandlerMeta {}
+export interface ChannelMessageMeta {
+  inputs: string[] | null
+  outputs: string[] | null
+  docs?: APIDocs
+  type: null | string
+}
 
 export interface ChannelMeta {
   name: string
@@ -44,17 +45,8 @@ export interface ChannelMeta {
   inputTypes?: HTTPFunctionMetaInputTypes
   connect: boolean
   disconnect: boolean
-  message: { inputs: string[] | null; outputs: string[] | null } | null
-  messageRoutes: Record<
-    string,
-    Record<
-      string,
-      {
-        inputs: string[] | null
-        outputs: string[] | null
-      }
-    >
-  >
+  message: ChannelMessageMeta | null
+  messageRoutes: Record<string, Record<string, ChannelMessageMeta>>
   docs?: APIDocs
   tags?: string[]
 }
@@ -108,8 +100,12 @@ export type CoreAPIChannel<
   Channel extends string,
   ChannelFunctionConnection = CoreChannelConnection<ChannelData>,
   ChannelFunctionDisconnection = CoreChannelDisconnection<ChannelData>,
-  ChannelFunctionDefaultMessage = CoreChannelMessage<unknown, unknown, unknown>,
-  ChannelFunctionMessageRoute = CoreChannelMessage<unknown, unknown, unknown>,
+  ChannelFunctionDefaultMessage =
+    | CoreChannelMessage<unknown, unknown, unknown>
+    | CoreAPIFunction<unknown, unknown>,
+  ChannelFunctionMessageRoute =
+    | CoreChannelMessage<unknown, unknown, unknown>
+    | CoreAPIFunction<unknown, unknown>,
   APIPermission = CoreAPIPermission<ChannelData>,
 > = {
   name: string

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

@@ -1,11 +1,15 @@
 import { test, beforeEach, afterEach } from 'node:test'
 import * as assert from 'node:assert/strict'
-import { JSONValue } from '../../types/core.types.js'
-import { PikkuHTTPAbstractRequest } from '../../http/pikku-http-abstract-request.js'
-import { PikkuHTTPAbstractResponse } from '../../http/pikku-http-abstract-response.js'
 import { runLocalChannel } from './local-channel-runner.js'
 import { resetPikkuState } from '../../pikku-state.js'
 import { addChannel } from '../channel-runner.js'
+import {
+  HTTPMethod,
+  PikkuHTTPRequest,
+  PikkuHTTPResponse,
+  PikkuQuery,
+} from '../../http/http-routes.types.js'
+import { SerializeOptions } from 'cookie'
 
 /**
  * Minimal stubs for dependencies that runChannel expects.
@@ -24,29 +28,69 @@ const mockSingletonServices = {
 } as any
 
 // Mock request and response objects
-class MockRequest extends PikkuHTTPAbstractRequest {
-  public getBody(): Promise<unknown> {
+export class PikkuMockRequest implements PikkuHTTPRequest {
+  private _params: Record<string, string | string[] | undefined> = {}
+
+  constructor(
+    private _route: string,
+    private _method: HTTPMethod
+  ) {}
+
+  method(): HTTPMethod {
+    return this._method
+  }
+  path(): string {
+    return this._route
+  }
+  json(): Promise<unknown> {
+    throw new Error('Method not implemented.')
+  }
+  arrayBuffer(): Promise<ArrayBuffer> {
     throw new Error('Method not implemented.')
   }
-  public getHeader(headerName: string): string | undefined {
+  header(headerName: string): string | null {
+    throw new Error('Method not implemented.')
+  }
+  cookie(name?: string): string | null {
+    throw new Error('Method not implemented.')
+  }
+  params(): Partial<Record<string, string | string[]>> {
+    return this._params
+  }
+  setParams(params: Record<string, string | string[] | undefined>): void {
+    this._params = params
+  }
+  query(): PikkuQuery {
     throw new Error('Method not implemented.')
   }
-  public async getData() {
+  public async data() {
     return { test: 'data' }
   }
 }
 
-class MockResponse extends PikkuHTTPAbstractResponse {
-  public statusSet: boolean | undefined
-  public ended: boolean | undefined
+export class PikkuMockResponse implements PikkuHTTPResponse {
+  public _status: number | undefined
+
+  status(code: number): this {
+    this._status = code
+    return this
+  }
 
-  public setJson(body: JSONValue): void {}
-  public setResponse(response: string | Buffer): void {}
-  public setStatus(code) {
-    this.statusSet = code
+  cookie(name: string, value: string | null, options: SerializeOptions): this {
+    throw new Error('Method not implemented.')
   }
-  public end() {
-    this.ended = true
+  header(name: string, value: string | string[]): this {
+    throw new Error('Method not implemented.')
+  }
+  arrayBuffer(data: XMLHttpRequestBodyInit): this {
+    throw new Error('Method not implemented.')
+  }
+  json(data: unknown): this {
+    // We don't need to implement this for our test
+    return this
+  }
+  redirect(location: string, status?: number): this {
+    throw new Error('Method not implemented.')
   }
 }
 
@@ -61,14 +105,13 @@ afterEach(() => {
 })
 
 test('runChannel should return undefined and 404 if no matching channel is found', async () => {
-  const mockResponse = new MockResponse()
+  const mockResponse = new PikkuMockResponse()
 
   const result = await runLocalChannel({
     singletonServices: mockSingletonServices,
     channelId: 'test-channel-id',
-    request: new MockRequest('/non-existent-channel', 'get'),
+    request: new PikkuMockRequest('/non-existent-channel', 'get'),
     response: mockResponse,
-    route: '/non-existent-channel',
     createSessionServices: mockCreateSessionServices,
   })
 
@@ -77,8 +120,8 @@ test('runChannel should return undefined and 404 if no matching channel is found
     undefined,
     'Should return undefined if no channel matches'
   )
-  assert.equal(mockResponse.statusSet, 404, 'Should set response status to 404')
-  assert.equal(mockResponse.ended, true, 'Should end the response')
+  assert.equal(mockResponse._status, 404, 'Should set response status to 404')
+  // assert.equal(mockResponse._ended, true, 'Should end the response')
 })
 
 test('runChannel should return a channel handler if channel matches and no auth required', async () => {
@@ -100,12 +143,14 @@ test('runChannel should return a channel handler if channel matches and no auth
   const result = await runLocalChannel({
     singletonServices: singletonServicesWithPerm,
     channelId: 'test-channel-id',
-    request: new MockRequest('/test-channel', 'get'),
-    response: new MockResponse(),
+    request: new PikkuMockRequest('/test-channel', 'get'),
+    response: new PikkuMockResponse(),
     route: '/test-channel',
     createSessionServices: mockCreateSessionServices,
   })
 
+  console.log(result)
+
   assert.ok(result, 'Should return a PikkuChannelHandler instance')
 
   // Simulate opening the channel

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

@@ -11,7 +11,8 @@ import { PikkuLocalChannelHandler } from './local-channel-handler.js'
 import { SessionServices } from '../../types/core.types.js'
 import { handleError } from '../../handle-error.js'
 import { runMiddleware } from '../../middleware-runner.js'
-import { LocalUserSessionService } from '../../services/user-session-service.js'
+import { PikkuUserSessionService } from '../../services/user-session-service.js'
+import { PikkuHTTP } from '../../http/http-routes.types.js'
 
 export const runLocalChannel = async ({
   singletonServices,
@@ -25,14 +26,19 @@ export const runLocalChannel = async ({
   coerceToArray = false,
   logWarningsForStatusCodes = [],
   bubbleErrors = false,
-}: Pick<CoreAPIChannel<unknown, any>, 'route'> &
+}: Partial<Pick<CoreAPIChannel<unknown, any>, 'route'>> &
   RunChannelOptions &
   RunChannelParams<unknown>): Promise<PikkuLocalChannelHandler | void> => {
   let sessionServices: SessionServices<typeof singletonServices> | undefined
 
   let channelHandler: PikkuLocalChannelHandler | undefined
-  const userSessionService = new LocalUserSessionService()
-  const http = createHTTPInteraction(request, response)
+  const userSessionService = new PikkuUserSessionService()
+
+  let http: PikkuHTTP | undefined
+  if (request) {
+    http = createHTTPInteraction(request, response)
+    route = http?.request?.path()
+  }
 
   const main = async () => {
     try {
@@ -40,11 +46,13 @@ export const runLocalChannel = async ({
         channelId,
         createSessionServices,
         respondWith404,
-        http,
+        request,
+        response,
         route,
         singletonServices,
         skipUserSession,
         coerceToArray,
+        userSessionService,
       })
 
       channelHandler = new PikkuLocalChannelHandler(
@@ -53,14 +61,15 @@ export const runLocalChannel = async ({
         openingData
       )
       const channel = channelHandler.getChannel()
-      const userSession = await userSessionService.get()
+      const session = await userSessionService.get()
       if (createSessionServices) {
         sessionServices = await createSessionServices(
           singletonServices,
           { http },
-          userSession
+          session
         )
       }
+
       const allServices = {
         ...singletonServices,
         ...sessionServices,
@@ -79,7 +88,12 @@ export const runLocalChannel = async ({
       })
 
       channelHandler.registerOnMessage(
-        processMessageHandlers(allServices, channelConfig, channelHandler)
+        processMessageHandlers(
+          allServices,
+          session,
+          channelConfig,
+          channelHandler
+        )
       )
     } catch (e: any) {
       handleError(
@@ -101,7 +115,7 @@ export const runLocalChannel = async ({
   await runMiddleware(
     {
       ...singletonServices,
-      userSession: userSessionService,
+      userSessionService,
     },
     { http },
     route.middleware || [],

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

@@ -11,9 +11,11 @@ import type {
 import { createHTTPInteraction } from '../../http/http-route-runner.js'
 import { ChannelStore } from '../channel-store.js'
 import { handleError } from '../../handle-error.js'
-import { RemoteUserSessionService } from '../../services/user-session-service.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'
 
 export interface RunServerlessChannelParams<ChannelData>
   extends RunChannelParams<ChannelData> {
@@ -70,8 +72,13 @@ export const runChannelConnect = async ({
   RunChannelOptions &
   RunServerlessChannelParams<unknown>) => {
   let sessionServices: SessionServices | undefined
-  const http = createHTTPInteraction(request, response)
-  const userSessionService = new RemoteUserSessionService(
+
+  let http: PikkuHTTP | undefined
+  if (request instanceof Request) {
+    http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response)
+  }
+
+  const userSessionService = new PikkuUserSessionService(
     channelStore,
     channelId
   )
@@ -79,10 +86,11 @@ export const runChannelConnect = async ({
   const { channelConfig, openingData } = await openChannel({
     channelId,
     createSessionServices,
-    http,
+    request,
     route,
     singletonServices,
     coerceToArray,
+    userSessionService,
   })
 
   const main = async () => {
@@ -109,7 +117,7 @@ export const runChannelConnect = async ({
         { ...singletonServices, ...sessionServices },
         channel
       )
-      http?.response?.setStatus(101)
+      http?.response?.status(101)
     } catch (e: any) {
       handleError(
         e,
@@ -130,7 +138,7 @@ export const runChannelConnect = async ({
   await runMiddleware(
     {
       ...singletonServices,
-      userSession: userSessionService,
+      userSessionService,
     },
     { http },
     channelConfig.middleware || [],
@@ -190,6 +198,7 @@ export const runChannelMessage = async (
   try {
     const onMessage = processMessageHandlers(
       { ...singletonServices, ...sessionServices },
+      session,
       channelConfig,
       channelHandler
     )

package/src/handle-error.ts

@@ -32,8 +32,8 @@ export const handleError = (
   const errorResponse = getErrorResponse(e)
   if (errorResponse != null) {
     // Set status and response body
-    http?.response?.setStatus(errorResponse.status)
-    http?.response?.setJson({
+    http?.response?.status(errorResponse.status)
+    http?.response?.json({
       message: errorResponse.message,
       payload: (e as any).payload,
       traceId: trackerId,
@@ -49,23 +49,25 @@ export const handleError = (
   } else {
     // Handle unexpected errors
     logger.error(e)
-    http?.response?.setStatus(500)
+    http?.response?.status(500)
 
     if (trackerId) {
       logger.warn(`Error id: ${trackerId}`)
-      http?.response?.setJson({ errorId: trackerId })
+      http?.response?.json({ errorId: trackerId })
     }
   }
 
   // Handle 404 errors specifically
   if (e instanceof NotFoundError) {
-    http?.response?.end()
+    // TODO
+    // http?.response?.end()
   }
 
   // Either bubble up or end the response
   if (bubbleError) {
     throw e
   } else {
-    http?.response?.end()
+    // TODO
+    // http?.response?.end()
   }
 }