@pikku/core 0.6.26 → 0.7.0

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

@@ -1,209 +0,0 @@
-import { SessionServices } from '../../types/core.types.js'
-import { closeSessionServices } from '../../utils.js'
-import { processMessageHandlers } from '../channel-handler.js'
-import { openChannel } from '../channel-runner.js'
-import type {
-  CoreAPIChannel,
-  RunChannelOptions,
-  RunChannelParams,
-  PikkuChannelHandlerFactory,
-} from '../channel.types.js'
-import { createHTTPInteraction } from '../../http/http-route-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'
-
-export interface RunServerlessChannelParams<ChannelData>
-  extends RunChannelParams<ChannelData> {
-  channelStore: ChannelStore
-  channelHandlerFactory: PikkuChannelHandlerFactory
-  channelObject?: unknown
-}
-
-const getVariablesForChannel = ({
-  channelId,
-  channelName,
-  channelHandlerFactory,
-  openingData,
-}: {
-  channelId: string
-  channelName: string
-  channelHandlerFactory: PikkuChannelHandlerFactory
-  openingData?: unknown
-}) => {
-  const channels = pikkuState('channel', 'channels')
-  const channelConfig = channels.find(
-    (channelConfig) => channelConfig.name === channelName
-  )
-  if (!channelConfig) {
-    throw new Error(`Channel not found: ${channelName}`)
-  }
-  const channelHandler = channelHandlerFactory(
-    channelId,
-    channelConfig.name,
-    openingData
-  )
-  return {
-    channelConfig,
-    channelHandler,
-    channel: channelHandler.getChannel(),
-  }
-}
-
-export const runChannelConnect = async ({
-  singletonServices,
-  channelId,
-  channelObject,
-  request,
-  response,
-  route,
-  createSessionServices,
-  channelStore,
-  channelHandlerFactory,
-  coerceDataFromSchema = true,
-  logWarningsForStatusCodes = [],
-  respondWith404 = true,
-  bubbleErrors = false,
-}: Pick<CoreAPIChannel<unknown, any>, 'route'> &
-  RunChannelOptions &
-  RunServerlessChannelParams<unknown>) => {
-  let sessionServices: SessionServices | undefined
-
-  let http: PikkuHTTP | undefined
-  if (request instanceof Request) {
-    http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response)
-  }
-
-  const userSession = new PikkuUserSessionService(channelStore, channelId)
-
-  const { channelConfig, openingData } = await openChannel({
-    channelId,
-    createSessionServices,
-    request,
-    route,
-    singletonServices,
-    coerceDataFromSchema,
-    userSession,
-  })
-
-  const main = async () => {
-    try {
-      await channelStore.addChannel({
-        channelId,
-        channelName: channelConfig.name,
-        openingData,
-        channelObject,
-      })
-      const { channel } = getVariablesForChannel({
-        channelId,
-        channelHandlerFactory,
-        channelName: channelConfig.name,
-      })
-      if (createSessionServices) {
-        sessionServices = await createSessionServices(
-          singletonServices,
-          { http },
-          await userSession.get()
-        )
-      }
-      await channelConfig.onConnect?.(
-        { ...singletonServices, ...sessionServices },
-        channel
-      )
-      http?.response?.status(101)
-    } catch (e: any) {
-      handleError(
-        e,
-        http,
-        channelId,
-        singletonServices.logger,
-        logWarningsForStatusCodes,
-        respondWith404,
-        bubbleErrors
-      )
-    } finally {
-      if (sessionServices) {
-        await closeSessionServices(singletonServices.logger, sessionServices)
-      }
-    }
-  }
-
-  await runMiddleware(
-    {
-      ...singletonServices,
-      userSession,
-    },
-    { http },
-    channelConfig.middleware || [],
-    main
-  )
-}
-
-export const runChannelDisconnect = async ({
-  singletonServices,
-  ...params
-}: RunServerlessChannelParams<unknown>): Promise<void> => {
-  let sessionServices: SessionServices | undefined
-  const { openingData, channelName, session } =
-    await params.channelStore.getChannelAndSession(params.channelId)
-  const { channel, channelConfig } = getVariablesForChannel({
-    ...params,
-    openingData,
-    channelName,
-  })
-  if (!sessionServices && params.createSessionServices) {
-    sessionServices = await params.createSessionServices(
-      singletonServices,
-      {},
-      session
-    )
-  }
-  await channelConfig.onDisconnect?.(
-    { ...singletonServices, ...sessionServices },
-    channel
-  )
-  await params.channelStore.removeChannels([channel.channelId])
-  if (sessionServices) {
-    await closeSessionServices(singletonServices.logger, sessionServices)
-  }
-}
-
-export const runChannelMessage = async (
-  { singletonServices, ...params }: RunServerlessChannelParams<unknown>,
-  data: unknown
-): Promise<unknown> => {
-  let sessionServices: SessionServices | undefined
-  const { openingData, channelName, session } =
-    await params.channelStore.getChannelAndSession(params.channelId)
-  const { channelHandler, channelConfig } = getVariablesForChannel({
-    ...params,
-    openingData,
-    channelName,
-  })
-  if (params.createSessionServices) {
-    sessionServices = await params.createSessionServices(
-      singletonServices,
-      {},
-      session
-    )
-  }
-  let response: unknown
-  try {
-    const onMessage = processMessageHandlers(
-      { ...singletonServices, ...sessionServices },
-      session,
-      channelConfig,
-      channelHandler
-    )
-    response = await onMessage(data)
-  } finally {
-    if (sessionServices) {
-      await closeSessionServices(singletonServices.logger, sessionServices)
-    }
-  }
-  return response
-}

package/src/errors/error-handler.ts

@@ -1,61 +0,0 @@
-import { pikkuState } from '../pikku-state.js'
-
-/**
- * Base class for custom errors.
- * @extends {Error}
- */
-export class PikkuError extends Error {
-  /**
-   * Creates an instance of PikkuError.
-   * @param message - The error message.
-   */
-  constructor(message: string = 'An error occurred') {
-    super(message)
-    Object.setPrototypeOf(this, new.target.prototype)
-  }
-}
-
-/**
- * Interface for error details.
- */
-export interface ErrorDetails {
-  status: number
-  message: string
-}
-
-/**
- * Adds an error to the API errors map.
- * @param error - The error to add.
- * @param details - The details of the error.
- */
-export const addError = (error: any, { status, message }: ErrorDetails) => {
-  pikkuState('misc', 'errors').set(error, { status, message })
-}
-
-/**
- * Adds multiple errors to the API errors map.
- * @param errors - An array of errors and their details.
- */
-export const addErrors = (
-  errors: Array<[error: any, details: ErrorDetails]>
-) => {
-  errors.forEach((error) => {
-    addError(error[0], error[1])
-  })
-}
-
-/**
- * Retrieves the error response for a given error.
- * @param error - The error to get the response for.
- * @returns An object containing the status and message, or undefined if the error is not found.
- */
-export const getErrorResponse = (
-  error: Error
-): { status: number; message: string } | undefined => {
-  const errors = Array.from(pikkuState('misc', 'errors').entries())
-  const foundError = errors.find(([e]) => e.name === error.constructor.name)
-  if (foundError) {
-    return foundError[1]
-  }
-  return pikkuState('misc', 'errors').get(error)
-}

package/src/errors/error.test.ts

@@ -1,54 +0,0 @@
-import { test, describe } from 'node:test'
-import assert from 'assert'
-import { getErrorResponse, addError } from './error-handler.js'
-import { ForbiddenError, BadRequestError, NotFoundError } from './errors.js'
-
-describe('getErrorResponse', () => {
-  test('should return the correct error response for BadRequestError', () => {
-    const error = new BadRequestError()
-    const response = getErrorResponse(error)
-    assert.deepStrictEqual(response, {
-      status: 400,
-      message:
-        'The server cannot or will not process the request due to client error (e.g., malformed request syntax).',
-    })
-  })
-
-  test('should return the correct error response for NotFoundError', () => {
-    const error = new NotFoundError()
-    const response = getErrorResponse(error)
-    assert.deepStrictEqual(response, {
-      status: 404,
-      message: 'The server cannot find the requested resource.',
-    })
-  })
-
-  test('should return the correct error response for ForbiddenError', () => {
-    const error = new ForbiddenError()
-    const response = getErrorResponse(error)
-    assert.deepStrictEqual(response, {
-      status: 403,
-      message:
-        'The client does not have permission to access the requested resource.',
-    })
-  })
-
-  test('should return undefined for an unknown error', () => {
-    class UnknownError extends Error {}
-    const error = new UnknownError()
-    const response = getErrorResponse(error)
-    assert.strictEqual(response, undefined)
-  })
-
-  test('should return the correct error response for a custom error added to apiErrors', () => {
-    class CustomError extends Error {}
-    const customError = new CustomError()
-    const customErrorDetails = { status: 400, message: 'Custom Error' }
-
-    // Add the custom error to the apiErrors map
-    addError(CustomError, customErrorDetails)
-
-    const response = getErrorResponse(customError)
-    assert.deepStrictEqual(response, customErrorDetails)
-  })
-})

package/src/errors/errors.ts

@@ -1,339 +0,0 @@
-/**
- * The server cannot or will not process the request due to client error (e.g., malformed request syntax).
- */
-import { addError, PikkuError } from './error-handler.js'
-
-/**
- * The server cannot or will not process the request due to client error (e.g., malformed request syntax).
- * @group Error
- */
-export class BadRequestError extends PikkuError {}
-addError(BadRequestError, {
-  status: 400,
-  message:
-    'The server cannot or will not process the request due to client error (e.g., malformed request syntax).',
-})
-
-/**
- * Authentication is required and has failed or has not yet been provided.
- * @group Error
- */
-export class UnauthorizedError extends PikkuError {}
-/**
- * More specific error to why it's unauthorized.
- * @group Error
- */
-export class MissingSessionError extends PikkuError {}
-/**
- * More specific error to why it's unauthorized.
- * @group Error
- */
-export class InvalidSessionError extends PikkuError {}
-
-addError(UnauthorizedError, {
-  status: 401,
-  message:
-    'Authentication is required and has failed or has not yet been provided.',
-})
-addError(MissingSessionError, { status: 401, message: 'Session missing.' })
-addError(InvalidSessionError, {
-  status: 401,
-  message: 'The session provided is not valid.',
-})
-
-/**
- * Reserved for future use, often related to digital payment or subscription services.
- * @group Error
- */
-export class PaymentRequiredError extends PikkuError {}
-addError(PaymentRequiredError, {
-  status: 402,
-  message:
-    'Reserved for future use, often related to digital payment or subscription services.',
-})
-
-/**
- * The client does not have permission to access the requested resource.
- * @group Error
- */
-export class ForbiddenError extends PikkuError {}
-addError(ForbiddenError, {
-  status: 403,
-  message:
-    'The client does not have permission to access the requested resource.',
-})
-
-/**
- * The request was made from an origin that is not permitted to access this resource.
- * @group Error
- */
-export class InvalidOriginError extends PikkuError {}
-addError(InvalidOriginError, {
-  status: 403,
-  message:
-    'The request was made from an origin that is not permitted to access this resource.',
-})
-
-/**
- * The server cannot find the requested resource.
- * @group Error
- */
-export class NotFoundError extends PikkuError {}
-/**
- * The server cannot find the requested route.
- * @group Error
- */
-addError(NotFoundError, {
-  status: 404,
-  message: 'The server cannot find the requested resource.',
-})
-
-/**
- * The request method is known by the server but is not supported by the resource.
- * @group Error
- */
-export class MethodNotAllowedError extends PikkuError {}
-addError(MethodNotAllowedError, {
-  status: 405,
-  message:
-    'The request method is known by the server but is not supported by the resource.',
-})
-
-/**
- * The requested resource cannot produce a response matching the list of acceptable values in the request's headers.
- * @group Error
- */
-export class NotAcceptableError extends PikkuError {}
-addError(NotAcceptableError, {
-  status: 406,
-  message:
-    "The requested resource cannot produce a response matching the list of acceptable values in the request's headers.",
-})
-
-/**
- * The client must authenticate itself to get the requested response.
- * @group Error
- */
-export class ProxyAuthenticationRequiredError extends PikkuError {}
-addError(ProxyAuthenticationRequiredError, {
-  status: 407,
-  message: 'The client must authenticate itself to get the requested response.',
-})
-
-/**
- * The server request expired
- * @group Error
- */
-export class RequestTimeoutError extends PikkuError {}
-addError(RequestTimeoutError, {
-  status: 408,
-  message: 'The request timeout has expired.',
-})
-
-/**
- * The request could not be completed due to a conflict with the current state of the target resource.
- * @group Error
- */
-export class ConflictError extends PikkuError {}
-addError(ConflictError, {
-  status: 409,
-  message:
-    'The request could not be completed due to a conflict with the current state of the target resource.',
-})
-
-/**
- * The resource that is being accessed is no longer available and will not be available again.
- * @group Error
- */
-export class GoneError extends PikkuError {}
-addError(GoneError, {
-  status: 410,
-  message:
-    'The resource that is being accessed is no longer available and will not be available again.',
-})
-
-/**
- * The request did not specify the length of its content, which is required by the requested resource.
- * @group Error
- */
-export class LengthRequiredError extends PikkuError {}
-addError(LengthRequiredError, {
-  status: 411,
-  message:
-    'The request did not specify the length of its content, which is required by the requested resource.',
-})
-
-/**
- * The server does not meet one of the preconditions that the requester put on the request.
- * @group Error
- */
-export class PreconditionFailedError extends PikkuError {}
-addError(PreconditionFailedError, {
-  status: 412,
-  message:
-    'The server does not meet one of the preconditions that the requester put on the request.',
-})
-
-/**
- * The request is larger than the server is willing or able to process.
- * @group Error
- */
-export class PayloadTooLargeError extends PikkuError {}
-addError(PayloadTooLargeError, {
-  status: 413,
-  message:
-    'The request is larger than the server is willing or able to process.',
-})
-
-/**
- * The URI requested by the client is longer than the server is willing to interpret.
- * @group Error
- */
-export class URITooLongError extends PikkuError {}
-addError(URITooLongError, {
-  status: 414,
-  message:
-    'The URI requested by the client is longer than the server is willing to interpret.',
-})
-
-/**
- * The server does not support the media format of the requested data.
- * @group Error
- */
-export class UnsupportedMediaTypeError extends PikkuError {}
-addError(UnsupportedMediaTypeError, {
-  status: 415,
-  message:
-    'The server does not support the media format of the requested data.',
-})
-
-/**
- * The client has asked for a portion of the file, but the server cannot supply that portion.
- * @group Error
- */
-export class RangeNotSatisfiableError extends PikkuError {}
-addError(RangeNotSatisfiableError, {
-  status: 416,
-  message:
-    'The client has asked for a portion of the file, but the server cannot supply that portion.',
-})
-
-/**
- * The server cannot meet the requirements of the Expect request-header field.
- * @group Error
- */
-export class ExpectationFailedError extends PikkuError {}
-addError(ExpectationFailedError, {
-  status: 417,
-  message:
-    'The server cannot meet the requirements of the Expect request-header field.',
-})
-
-/**
- * Indicates that the server understood the content type of the request content, and the syntax of the request content was correct, but it was unable to process the contained instructions.
- * @group Error
- */
-export class UnprocessableContentError extends PikkuError {}
-addError(UnprocessableContentError, {
-  status: 422,
-  message:
-    'The server understood the content type of the request content, and the syntax of the request content was correct, but it was unable to process the contained instructions..',
-})
-
-/**
- * Indicates that the server understood the content type of the request content, and the syntax of the request content was correct, but it was unable to process the contained instructions.
- * @group Error
- */
-export class LockedError extends PikkuError {}
-addError(LockedError, {
-  status: 423,
-  message:
-    "The resource is locked, meaning it can't be accessed. Its response body should contain information in WebDAV's XML format.",
-})
-
-/**
- * The user has sent too many requests in a given amount of time ("rate limiting").
- * @group Error
- */
-export class TooManyRequestsError extends PikkuError {}
-addError(TooManyRequestsError, {
-  status: 429,
-  message:
-    'The user has sent too many requests in a given amount of time ("rate limiting").',
-})
-
-/**
- * A generic error message, given when no more specific message is suitable.
- * @group Error
- */
-export class InternalServerError extends PikkuError {}
-addError(InternalServerError, {
-  status: 500,
-  message:
-    'A generic error message, given when no more specific message is suitable.',
-})
-
-/**
- * The server does not recognize the request method and cannot support it.
- * @group Error
- */
-export class NotImplementedError extends PikkuError {}
-addError(NotImplementedError, {
-  status: 501,
-  message:
-    'The server does not recognize the request method and cannot support it.',
-})
-
-/**
- * The server was acting as a gateway or proxy and received an invalid response from the upstream server.
- * @group Error
- */
-export class BadGatewayError extends PikkuError {}
-addError(BadGatewayError, {
-  status: 502,
-  message:
-    'The server was acting as a gateway or proxy and received an invalid response from the upstream server.',
-})
-
-/**
- * The server is currently unavailable (overloaded or down).
- * @group Error
- */
-export class ServiceUnavailableError extends PikkuError {}
-addError(ServiceUnavailableError, {
-  status: 503,
-  message: 'The server is currently unavailable (overloaded or down).',
-})
-
-/**
- * The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.
- * @group Error
- */
-export class GatewayTimeoutError extends PikkuError {}
-addError(GatewayTimeoutError, {
-  status: 504,
-  message:
-    'The server was acting as a gateway or proxy and did not receive a timely response from the upstream server.',
-})
-
-/**
- * The server does not support the HTTP protocol version used in the request.
- * @group Error
- */
-export class HTTPVersionNotSupportedError extends PikkuError {}
-addError(HTTPVersionNotSupportedError, {
-  status: 505,
-  message:
-    'The server does not support the HTTP protocol version used in the request.',
-})
-
-/**
- * The server took too long to complete the request, reaching the maximum compute time allowed.
- * @group Error
- */
-export class MaxComputeTimeReachedError extends PikkuError {}
-addError(MaxComputeTimeReachedError, {
-  status: 524,
-  message:
-    'The server took too long to complete the request, reaching the maximum compute time allowed.',
-})

package/src/errors/index.ts

@@ -1,2 +0,0 @@
-export * from './error-handler.js'
-export * from './errors.js'