@pikku/core 0.6.26 → 0.7.0

package/src/channel/channel-handler.ts

@@ -1,227 +0,0 @@
-import {
-  CoreSingletonServices,
-  CoreServices,
-  JSONValue,
-  CoreUserSession,
-} from '../types/core.types.js'
-import {
-  ChannelMessageMeta,
-  CoreAPIChannel,
-  PikkuChannelHandler,
-} from './channel.types.js'
-import { verifyPermissions } from '../permissions.js'
-import { pikkuState } from '../pikku-state.js'
-
-const getRouteMeta = (
-  channelName: string,
-  routingProperty?: string,
-  routerValue?: string
-): ChannelMessageMeta => {
-  const channelsMeta = pikkuState('channel', 'meta')
-  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,
-  session: CoreUserSession | undefined,
-  onMessage: any
-) => {
-  const auth =
-    typeof onMessage === 'function'
-      ? requiresSession
-      : onMessage.auth === undefined
-        ? requiresSession
-        : onMessage.auth
-
-  if (auth && !session) {
-    return false
-  }
-  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,
-  channelConfig: CoreAPIChannel<any, any>,
-  channelHandler: PikkuChannelHandler
-) => {
-  const logger = services.logger
-  const requiresSession = channelConfig.auth !== false
-
-  const processMessage = async (
-    data: JSONValue,
-    onMessage: any,
-    session: CoreUserSession | undefined,
-    routingProperty?: string,
-    routerValue?: string
-  ): Promise<unknown> => {
-    if (!validateAuth(requiresSession, channelHandler, onMessage)) {
-      const routeMessage = routingProperty
-        ? `route '${routingProperty}:${routerValue}'`
-        : 'the default message route'
-      logger.error(
-        `Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for ${routeMessage}`
-      )
-      // TODO: Send error message back breaks typescript, but should be implemented somehow
-      channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`)
-      return
-    }
-
-    const routeMeta = 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'}`
-      )
-    }
-
-    return await runFunction(
-      services,
-      channelHandler,
-      routeMeta,
-      session,
-      onMessage,
-      data
-    )
-  }
-
-  const onMessage = async (rawData): Promise<unknown> => {
-    let result: unknown
-    let processed = false
-
-    // Route-specific handling
-    if (typeof rawData === 'string' && channelConfig.onMessageRoute) {
-      try {
-        const messageData = JSON.parse(rawData)
-        const entries = Object.entries(channelConfig.onMessageRoute)
-        for (const [routingProperty, routes] of entries) {
-          const routerValue = messageData[routingProperty]
-          if (routerValue && routes[routerValue]) {
-            processed = true
-            result = await processMessage(
-              messageData,
-              routes[routerValue],
-              session,
-              routingProperty,
-              routerValue
-            )
-            break
-          }
-        }
-
-        // Default handler if no routes matched but json data was parsed
-        if (!processed && channelConfig.onMessage) {
-          processed = true
-          result = await processMessage(
-            messageData,
-            channelConfig.onMessage,
-            session
-          )
-        }
-      } catch (error) {
-        // Most likely a json error.. ignore
-      }
-    }
-
-    // Default handler if no routes matched and json data wasn't parsed
-    if (!processed && channelConfig.onMessage) {
-      processed = true
-      result = await processMessage(rawData, channelConfig.onMessage, session)
-    }
-
-    if (!processed) {
-      logger.error(
-        `No handler found for message in channel ${channelConfig.name} for ${rawData}`
-      )
-      logger.error(`Channel ${channelConfig}`)
-    }
-
-    return result
-  }
-
-  return onMessage
-}

package/src/channel/channel-runner.ts

@@ -1,98 +0,0 @@
-import { NotFoundError } from '../errors/errors.js'
-import { pikkuState } from '../pikku-state.js'
-import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js'
-import { UserSessionService } from '../services/user-session-service.js'
-import {
-  CoreAPIChannel,
-  RunChannelOptions,
-  RunChannelParams,
-} from './channel.types.js'
-import { match } from 'path-to-regexp'
-
-export const addChannel = <
-  In,
-  Channel extends string,
-  ChannelFunction,
-  ChannelFunctionSessionless,
-  APIPermission,
->(
-  channel: CoreAPIChannel<
-    In,
-    Channel,
-    ChannelFunction,
-    ChannelFunctionSessionless,
-    APIPermission
-  >
-) => {
-  pikkuState('channel', 'channels').push(channel as any)
-}
-
-export const getMatchingChannelConfig = (request: string) => {
-  const channels = pikkuState('channel', 'channels')
-  const channelsMeta = pikkuState('channel', 'meta')
-  for (const channelConfig of channels) {
-    const cleanedRoute = channelConfig.route.replace(/^\/\//, '/')
-    const cleanedRequest = request.replace(/^\/\//, '/')
-    const matchFunc = match(cleanedRoute, {
-      decode: decodeURIComponent,
-    })
-    const matchedPath = matchFunc(cleanedRequest)
-    if (matchedPath) {
-      const schemaName = channelsMeta.find(
-        (channelMeta) => channelMeta.route === channelConfig.route
-      )?.input
-      return {
-        matchedPath,
-        params: matchedPath.params,
-        channelConfig,
-        schemaName,
-      }
-    }
-  }
-
-  return null
-}
-
-export const openChannel = async ({
-  route,
-  singletonServices,
-  coerceDataFromSchema = true,
-  request,
-}: Pick<CoreAPIChannel<unknown, string>, 'route'> &
-  RunChannelParams<unknown> & {
-    userSession: UserSessionService<any>
-  } & RunChannelOptions): Promise<{
-  openingData: unknown
-  channelConfig: CoreAPIChannel<unknown, any>
-}> => {
-  const matchingChannel = getMatchingChannelConfig(route)
-  if (!matchingChannel) {
-    singletonServices.logger.info(`Channel not found: ${route}`)
-    throw new NotFoundError(`Channel not found: ${route}`)
-  }
-
-  const { params, channelConfig, schemaName } = matchingChannel
-
-  const requiresSession = channelConfig.auth !== false
-  request?.setParams(params)
-
-  singletonServices.logger.info(
-    `Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`
-  )
-
-  let openingData: any | undefined
-  if (request) {
-    openingData = await request.data()
-    if (coerceDataFromSchema && schemaName) {
-      coerceTopLevelDataFromSchema(schemaName, openingData)
-    }
-    await validateSchema(
-      singletonServices.logger,
-      singletonServices.schema,
-      schemaName,
-      openingData
-    )
-  }
-
-  return { openingData, channelConfig }
-}

package/src/channel/channel-store.ts

@@ -1,29 +0,0 @@
-import { CoreUserSession } from '../types/core.types.js'
-
-export type Channel<ChannelType = unknown, OpeningData = unknown> = {
-  channelId: string
-  channelName: string
-  channelObject?: ChannelType
-  openingData?: OpeningData
-}
-
-export abstract class ChannelStore<
-  ChannelType = unknown,
-  OpeningData = unknown,
-  UserSession extends CoreUserSession = CoreUserSession,
-  TypedChannel = Channel<ChannelType, OpeningData>,
-> {
-  public abstract addChannel(
-    channel: Channel<ChannelType, OpeningData>
-  ): Promise<void> | void
-  public abstract removeChannels(channelId: string[]): Promise<void> | void
-  public abstract setUserSession(
-    channelId: string,
-    userSession: UserSession | null
-  ): Promise<void> | void
-  public abstract getChannelAndSession(
-    channelId: string
-  ):
-    | Promise<TypedChannel & { session: UserSession }>
-    | (TypedChannel & { session: UserSession })
-}

package/src/channel/channel.types.ts

@@ -1,171 +0,0 @@
-import { PikkuError } from '../errors/error-handler.js'
-import {
-  HTTPFunctionMetaInputTypes,
-  PikkuHTTPRequest,
-  PikkuHTTPResponse,
-} from '../http/http-routes.types.js'
-import {
-  APIDocs,
-  CoreServices,
-  CoreSingletonServices,
-  CreateSessionServices,
-  PikkuMiddleware,
-} from '../types/core.types.js'
-import { CoreAPIFunction, CoreAPIPermission } from '../types/functions.types.js'
-
-export type RunChannelOptions = Partial<{
-  skipUserSession: boolean
-  respondWith404: boolean
-  coerceDataFromSchema: boolean
-  logWarningsForStatusCodes: number[]
-  bubbleErrors: boolean
-}>
-
-export type RunChannelParams<ChannelData> = {
-  channelId: string
-  singletonServices: CoreSingletonServices
-  request?: PikkuHTTPRequest<ChannelData>
-  response?: PikkuHTTPResponse
-  createSessionServices?: CreateSessionServices
-}
-
-export interface ChannelMessageMeta {
-  inputs: string[] | null
-  outputs: string[] | null
-  docs?: APIDocs
-  type: null | string
-}
-
-export interface ChannelMeta {
-  name: string
-  route: string
-  params?: string[]
-  query?: string[]
-  input: string | null
-  inputTypes?: HTTPFunctionMetaInputTypes
-  connect: boolean
-  disconnect: boolean
-  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 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>,
-  APIPermission = CoreAPIPermission<ChannelData>,
-> = {
-  name: string
-  route: Channel
-  onConnect?: ChannelFunctionConnection
-  onDisconnect?: ChannelFunctionDisconnection
-  onMessage?:
-    | {
-        func: ChannelFunctionDefaultMessage
-        permissions?: Record<string, APIPermission[] | APIPermission>
-        auth?: boolean
-      }
-    | ChannelFunctionDefaultMessage
-  onMessageRoute?: Record<
-    string,
-    Record<
-      string,
-      | ChannelFunctionMessageRoute
-      | {
-          func: ChannelFunctionMessageRoute
-          permissions?: Record<string, APIPermission[] | APIPermission>
-          auth?: boolean
-        }
-    >
-  >
-  middleware?: PikkuMiddleware[]
-  permissions?: Record<string, APIPermission[] | APIPermission>
-  auth?: boolean
-  docs?: Partial<{
-    description: string
-    response: string
-    errors: Array<typeof PikkuError>
-    tags: string[]
-  }>
-  tags?: string[]
-}
-
-export type CoreAPIChannels = CoreAPIChannel<any, string>[]
-
-export interface PikkuChannel<OpeningData, Out> {
-  // The channel identifier
-  channelId: string
-  // The data the channel was created with. This could be query parameters
-  // or parameters in the url.
-  openingData: OpeningData
-  // The data to send. This will fail is the stream has been closed.
-  send: (data: Out, isBinary?: boolean) => Promise<void> | void
-  // This will close the channel.
-  close: () => Promise<void> | void
-  // The current state of the channel
-  state: 'initial' | 'open' | 'closed'
-}
-
-export interface PikkuChannelHandler<OpeningData = unknown, Out = unknown> {
-  send(message: Out, isBinary?: boolean): Promise<void> | void
-  getChannel(): PikkuChannel<OpeningData, Out>
-}
-
-export type PikkuChannelHandlerFactory<OpeningData = unknown, Out = unknown> = (
-  channelId: string,
-  channelName: string,
-  openingData: OpeningData
-) => PikkuChannelHandler<OpeningData, Out>

package/src/channel/eventhub-service.ts

@@ -1,30 +0,0 @@
-/**
- * Interface defining the methods of a EventHub Service.
- */
-export interface EventHubService<Out = unknown> {
-  /**
-   * Subscribes a connection to a specific topic.
-   * @param topic - The topic to subscribe to.
-   * @param channelId - The unique ID of the connection to subscribe.
-   */
-  subscribe(topic: string, channelId: string): Promise<void> | void
-
-  /**
-   * Unsubscribes a connection from a specific topic.
-   * @param topic - The topic to unsubscribe from.
-   * @param channelId - The unique ID of the connection to unsubscribe.
-   */
-  unsubscribe(topic: string, channelId: string): Promise<void> | void
-
-  /**
-   * Sends data to all connections subscribed to a topic.
-   * @param topic - The topic to send data to.
-   * @param data - The data to send to the subscribers.
-   */
-  publish(
-    topic: string,
-    channelId: string | null,
-    data: Out,
-    isBinary?: boolean
-  ): Promise<void> | void
-}

package/src/channel/eventhub-store.ts

@@ -1,8 +0,0 @@
-export abstract class EventHubStore {
-  public abstract getChannelIdsForTopic(topic: string): Promise<string[]>
-  public abstract subscribe(topic: string, channelId: string): Promise<boolean>
-  public abstract unsubscribe(
-    topic: string,
-    channelId: string
-  ): Promise<boolean>
-}

package/src/channel/index.ts

@@ -1,8 +0,0 @@
-export * from './channel-runner.js'
-export * from './channel.types.js'
-export * from './log-channels.js'
-export * from './pikku-abstract-channel-handler.js'
-export * from './eventhub-service.js'
-export * from './eventhub-service.js'
-export * from './channel-store.js'
-export * from './eventhub-store.js'

package/src/channel/local/index.ts

@@ -1,3 +0,0 @@
-export * from './local-channel-handler.js'
-export * from './local-channel-runner.js'
-export * from './local-eventhub-service.js'

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

@@ -1,50 +0,0 @@
-import { PikkuAbstractChannelHandler } from '../pikku-abstract-channel-handler.js'
-
-export class PikkuLocalChannelHandler<
-  OpeningData = unknown,
-  Out = unknown,
-> extends PikkuAbstractChannelHandler<OpeningData, Out> {
-  private onMessageCallback?: (message: unknown) => void
-  private openCallBack?: () => void
-  private closeCallback?: () => void
-  private sendCallback?: (message: Out, isBinary?: boolean) => void
-
-  public registerOnOpen(callback: () => void): void {
-    this.openCallBack = callback
-  }
-
-  public open() {
-    this.getChannel().state = 'open'
-    if (this.openCallBack) {
-      this.openCallBack()
-    }
-  }
-
-  public registerOnMessage(callback: (data: any) => Promise<unknown>): void {
-    this.onMessageCallback = callback
-  }
-
-  public async message(data: unknown): Promise<unknown> {
-    return this.onMessageCallback?.(data)
-  }
-
-  public registerOnClose(callback: () => void): void {
-    this.closeCallback = callback
-  }
-
-  public close() {
-    super.close()
-    this.closeCallback?.()
-  }
-
-  public registerOnSend(send: (message: Out) => void) {
-    this.sendCallback = send
-  }
-
-  public send(message: Out, isBinary?: boolean): void {
-    if (!this.sendCallback) {
-      throw new Error('No send callback registered')
-    }
-    return this.sendCallback?.(message, isBinary)
-  }
-}