@pikku/core 0.6.21 → 0.6.22

package/src/http/index.ts

@@ -1,9 +1,8 @@
-export * from './pikku-http-abstract-request.js'
-
-export * from './pikku-http-abstract-response.js'
-
+export * from './pikku-fetch-http-request.js'
+export * from './pikku-fetch-http-response.js'
+export * from './incomingmessage-to-request-convertor.js'
 export * from './log-http-routes.js'
 
-export { runHTTPRoute, addRoute } from './http-route-runner.js'
+export { fetch, fetchData, addRoute } from './http-route-runner.js'
 
 export type * from './http-routes.types.js'

package/src/http/{pikku-http-abstract-request.ts → pikku-fetch-http-request.ts}

@@ -1,36 +1,49 @@
+import { parse as parseQuery } from 'picoquery'
 import { parse as parseCookie } from 'cookie'
-import { PikkuRequest } from '../pikku-request.js'
-import { HTTPMethod, PikkuQuery } from './http-routes.types.js'
+import {
+  HTTPMethod,
+  PikkuHTTPRequest,
+  PikkuQuery,
+} from './http-routes.types.js'
 
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.
  * @group RequestResponse
  */
-export abstract class PikkuHTTPAbstractRequest<
-  In = unknown,
-> extends PikkuRequest<In> {
-  private params: Partial<Record<string, string | string[]>> = {}
+export class PikkuFetchHTTPRequest<In = unknown>
+  implements PikkuHTTPRequest<In>
+{
+  #cookies: Partial<Record<string, string>> | undefined
+  #params: Partial<Record<string, string | string[]>> = {}
+  #url: URL
 
-  constructor(
-    public path: string,
-    public method: HTTPMethod
-  ) {
-    super()
+  constructor(private request: Request) {
+    this.#url = new URL(request.url)
+  }
+
+  public method(): HTTPMethod {
+    return this.request.method.toLowerCase() as HTTPMethod
+  }
+
+  public path(): string {
+    return this.#url.pathname
   }
 
   /**
    * Retrieves the request body.
    * @returns A promise that resolves to the request body.
    */
-  public abstract getBody(): Promise<In>
+  public json(): Promise<In> {
+    return this.request.json()
+  }
 
   /**
    * Retrieves the raw request body as a Buffer.
    * @returns A promise that resolves to the raw request body.
    */
-  public getRawBody(): Promise<Buffer> {
-    throw new Error('Method not implemented.')
+  public arrayBuffer(): Promise<ArrayBuffer> {
+    return this.request.arrayBuffer()
   }
 
   /**
@@ -38,26 +51,26 @@ export abstract class PikkuHTTPAbstractRequest<
    * @param headerName - The name of the header to retrieve.
    * @returns The value of the header, or undefined if the header is not found.
    */
-  public abstract getHeader(headerName: string): string | undefined
+  public header(headerName: string): string | null {
+    return this.request.headers.get(headerName.toLowerCase())
+  }
 
   /**
    * Retrieves the cookies from the request.
    * @returns An object containing the cookies.
    */
-  public getCookies(): Partial<Record<string, string>> {
-    const cookieHeader = this.getHeader('cookie')
-    if (cookieHeader) {
-      return parseCookie(cookieHeader)
-    }
-    return {}
+  public cookie(cookieName: string): string | null {
+    const cookieHeader = this.header('cookie')
+    this.#cookies = cookieHeader ? parseCookie(cookieHeader) : {}
+    return this.#cookies[cookieName] || null
   }
 
   /**
    * Retrieves the request parameters.
    * @returns An object containing the request parameters.
    */
-  public getParams(): Partial<Record<string, string | string[]>> {
-    return this.params
+  public params(): Partial<Record<string, string | string[]>> {
+    return this.#params
   }
 
   /**
@@ -67,36 +80,32 @@ export abstract class PikkuHTTPAbstractRequest<
   public setParams(
     params: Record<string, string | string[] | undefined>
   ): void {
-    this.params = params
+    this.#params = params
   }
 
   /**
    * Retrieves the query parameters from the request.
    * @returns An object containing the query parameters.
    */
-  public getQuery(): PikkuQuery {
-    return {}
-  }
-
-  /**
-   * Retrieves the IP address of the client making the request.
-   * @returns The IP address of the client.
-   * @throws {Error} This method is not implemented and should be overridden by subclasses.
-   */
-  public getIP(): string {
-    throw new Error('Method not implemented.')
+  public query(): PikkuQuery {
+    return parseQuery(this.#url.searchParams.toString()) as PikkuQuery
   }
 
   /**
    * Retrieves the combined data from the request, including parameters, query, and body.
    * @returns A promise that resolves to an object containing the combined data.
    */
-  public async getData(): Promise<In> {
+  public async data(): Promise<In> {
+    let body: any = {}
+    try {
+      body = await this.json()
+    } catch (e) {}
+
     return {
-      ...this.getParams(),
-      ...this.getQuery(),
+      ...this.params(),
+      ...this.query(),
       // TODO: If body isn't an object, we should insert it as the word...
-      ...(await this.getBody()),
+      ...body,
     }
   }
 }

package/src/http/pikku-fetch-http-response.ts

@@ -0,0 +1,70 @@
+import { PikkuHTTPResponse } from './http-routes.types.js'
+
+export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
+  #statusCode: number = 200
+  #headers = new Headers()
+  #body: BodyInit | null = null
+
+  public status(code: number): this {
+    this.#statusCode = code
+    return this
+  }
+
+  public cookie(name: string, value: string, flags: any): this {
+    // TODO
+    return this
+  }
+
+  public header(name: string, value: string | string[]): this {
+    this.#headers.delete(name)
+    if (Array.isArray(value)) {
+      value.forEach((v) => this.#headers.append(name, v))
+    } else {
+      this.#headers.set(name, value)
+    }
+    return this
+  }
+
+  public arrayBuffer(data: XMLHttpRequestBodyInit): this {
+    this.#body = data
+    this.header('Content-Type', 'application/octet-stream')
+    return this
+  }
+
+  public json(data: unknown): this {
+    this.#body = JSON.stringify(data)
+    this.header('Content-Type', 'application/json')
+    return this
+  }
+
+  public text(content: string): this {
+    this.#body = content
+    this.header('Content-Type', 'text/plain')
+    return this
+  }
+
+  public html(content: string): this {
+    this.#body = content
+    this.header('Content-Type', 'text/html')
+    return this
+  }
+
+  public body(body: BodyInit): this {
+    this.#body = body
+    return this
+  }
+
+  public redirect(location: string, status: number = 302): this {
+    this.#statusCode = status
+    this.header('Location', location)
+    return this
+  }
+
+  public toResponse(args?: Record<string, any>): Response {
+    return new Response(this.#body, {
+      ...args,
+      status: this.#statusCode,
+      headers: this.#headers,
+    })
+  }
+}

package/src/middleware/auth-apikey.ts

@@ -33,16 +33,16 @@ export const authAPIKey = <
     }
 )) => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
-    if (!http?.request || services.userSession.get()) {
+    if (!http?.request || services.userSessionService.get()) {
       return next()
     }
 
     let apiKey: string | null = null
     if (source === 'header' || source === 'all') {
-      apiKey = http.request.getHeader('x-api-key') as string | null
+      apiKey = http.request.header('x-api-key') as string | null
     }
     if (!apiKey && (source === 'query' || source === 'all')) {
-      apiKey = http.request.getQuery().apiKey as string | null
+      apiKey = http.request.query().apiKey as string | null
     }
     if (apiKey) {
       let userSession: UserSession | null = null
@@ -55,7 +55,7 @@ export const authAPIKey = <
         userSession = await getSessionForAPIKey!(services as any, apiKey)
       }
       if (userSession) {
-        await services.userSession.set(userSession)
+        services.userSessionService.setInitial(userSession)
       }
     }
     return next()

package/src/middleware/auth-bearer.ts

@@ -29,13 +29,13 @@ export const authBearer = <
 } = {}): PikkuMiddleware => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
     // Skip if session already exists.
-    if (!http?.request || services.userSession.get()) {
+    if (!http?.request || services.userSessionService.get()) {
       return next()
     }
 
     const authHeader =
-      http.request.getHeader('authorization') ||
-      http.request.getHeader('Authorization')
+      http.request.header('authorization') ||
+      http.request.header('Authorization')
     if (authHeader) {
       const [scheme, bearerToken] = authHeader.split(' ')
       if (scheme !== 'Bearer' || !token || !bearerToken) {
@@ -56,7 +56,7 @@ export const authBearer = <
       }
 
       if (userSession) {
-        await services.userSession.set(userSession)
+        services.userSessionService.setInitial(userSession)
       }
     }
     return next()

package/src/middleware/auth-cookie.ts

@@ -35,41 +35,33 @@ export const authCookie = <
     }
 )): PikkuMiddleware => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
-    if (!http?.request || services.userSession.get()) {
+    if (!http?.request || services.userSessionService.get()) {
       return next()
     }
 
-    const cookies = http.request.getCookies()
-    if (cookies) {
-      let cookieName: string | undefined
-      for (const name of cookieNames) {
-        if (cookies[name]) {
-          cookieName = name
-          break
-        }
-      }
-      if (cookieName) {
-        let userSession: UserSession | null = null
-        const cookieValue = cookies[cookieName]
-        if (cookieValue) {
-          if (jwt) {
-            if (!services.jwt) {
-              throw new Error('JWT service is required for JWT decoding.')
-            }
-            userSession = await services.jwt.decode(cookieValue)
-          } else if (getSessionForCookieValue) {
-            userSession = await getSessionForCookieValue(
-              services as any,
-              cookieValue,
-              cookieName
-            )
-          }
-          if (userSession) {
-            await services.userSession.set(userSession)
+    let userSession: UserSession | null = null
+    for (const cookieName of cookieNames) {
+      const cookieValue = http.request.cookie(cookieName)
+      if (cookieValue) {
+        if (jwt) {
+          if (!services.jwt) {
+            throw new Error('JWT service is required for JWT decoding.')
           }
+          userSession = await services.jwt.decode(cookieValue)
+        } else if (getSessionForCookieValue) {
+          userSession = await getSessionForCookieValue(
+            services as any,
+            cookieValue,
+            cookieName
+          )
         }
+        break
       }
     }
+
+    if (userSession) {
+      services.userSessionService.setInitial(userSession)
+    }
     return next()
   }
   return middleware

package/src/middleware-runner.ts

@@ -24,7 +24,7 @@ import {
  */
 export const runMiddleware = async (
   services: CoreSingletonServices & {
-    userSession: UserSessionService<any>
+    userSessionService: UserSessionService<any>
   },
   interaction: PikkuInteraction,
   middlewares: PikkuMiddleware[],

package/src/pikku-request.ts

@@ -4,16 +4,20 @@
  * @group RequestResponse
  */
 export abstract class PikkuRequest<In = any> {
-  constructor(private data?: In) {}
+  #data: In | undefined
+
+  constructor(data: In) {
+    this.#data = data
+  }
 
   /**
    * Retrieves the data
    * @returns A promise that resolves to an object containing the combined data.
    */
-  public async getData(): Promise<In> {
-    if (!this.data) {
+  public async data(): Promise<In> {
+    if (!this.#data) {
       throw new Error('Data not found')
     }
-    return this.data
+    return this.#data
   }
 }

package/src/scheduler/scheduler-runner.ts

@@ -42,8 +42,6 @@ class ScheduledTaskNotFoundError extends Error {
 export async function runScheduledTask<
   SingletonServices extends CoreSingletonServices = CoreSingletonServices,
   UserSession extends CoreUserSession = CoreUserSession,
-  Services extends
-    CoreServices<SingletonServices> = CoreServices<SingletonServices>,
 >({
   name,
   session,

package/src/services/user-session-service.ts

@@ -2,50 +2,48 @@ import { ChannelStore } from '../channel/channel-store.js'
 import { CoreUserSession } from '../types/core.types.js'
 
 export interface UserSessionService<UserSession extends CoreUserSession> {
+  setInitial(session: UserSession): void
   set(session: UserSession): Promise<void> | void
   clear(): Promise<void> | void
   get(): Promise<UserSession | undefined> | UserSession | undefined
 }
 
-export class LocalUserSessionService<UserSession extends CoreUserSession>
+export class PikkuUserSessionService<UserSession extends CoreUserSession>
   implements UserSessionService<UserSession>
 {
-  constructor(private session: UserSession | undefined = undefined) {}
-
-  public set(session: UserSession) {
-    this.session = session
-  }
-
-  public clear() {
-    this.session = undefined
+  private session: UserSession | undefined
+  constructor(
+    private channelStore?: ChannelStore<unknown, unknown, UserSession>,
+    private channelId?: string
+  ) {
+    if (channelStore && !channelId) {
+      throw new Error('Channel ID is required when using channel store')
+    }
   }
 
-  public get(): UserSession | undefined {
-    return this.session
+  public setInitial(session: UserSession) {
+    this.session = session
   }
-}
-
-export class RemoteUserSessionService<UserSession extends CoreUserSession>
-  implements UserSessionService<UserSession>
-{
-  constructor(
-    private channelStore: ChannelStore<unknown, unknown, UserSession>,
-    private channelId: string,
-    public session: UserSession | undefined = undefined
-  ) {}
 
   public set(session: UserSession) {
-    return this.channelStore.setUserSession(this.channelId, session)
+    this.session = session
+    return this.channelStore?.setUserSession(this.channelId!, session)
   }
 
   public clear() {
-    return this.channelStore.setUserSession(this.channelId, null)
+    this.session = undefined
+    return this.channelStore?.setUserSession(this.channelId!, null)
   }
 
-  public async get(): Promise<UserSession | undefined> {
-    const { session } = await this.channelStore.getChannelAndSession(
-      this.channelId
-    )
-    return session
+  public get(): Promise<UserSession> | UserSession | undefined {
+    if (this.channelStore) {
+      const channel = this.channelStore.getChannelAndSession(this.channelId!)
+      if (channel instanceof Promise) {
+        return channel.then(({ session }) => session)
+      } else {
+        return channel.session
+      }
+    }
+    return this.session
   }
 }

package/src/types/core.types.ts

@@ -93,7 +93,7 @@ export type PikkuMiddleware<
   UserSession extends CoreUserSession = CoreUserSession,
 > = (
   services: SingletonServices & {
-    userSession: UserSessionService<UserSession>
+    userSessionService: UserSessionService<UserSession>
   },
   interactions: PikkuInteraction,
   next: () => Promise<void>

package/src/types/functions.types.ts

@@ -1,3 +1,4 @@
+import { PikkuChannel } from '../channel/channel.types.js'
 import type {
   CoreServices,
   CoreSingletonServices,
@@ -15,9 +16,16 @@ import type {
 export type CoreAPIFunction<
   In,
   Out,
-  Services extends CoreSingletonServices = CoreServices,
+  Services extends CoreSingletonServices = CoreServices & {
+    channel?: PikkuChannel<unknown, Out>
+  },
   Session extends CoreUserSession = CoreUserSession,
-> = (services: Services, data: In, session: Session) => Promise<Out>
+  Channel extends boolean = false,
+> = (
+  services: Services,
+  data: In,
+  session: Session
+) => Channel extends true ? Promise<Out> | Promise<void> : Promise<Out>
 
 /**
  * Represents a core API function that can be used without a session.
@@ -30,9 +38,16 @@ export type CoreAPIFunction<
 export type CoreAPIFunctionSessionless<
   In,
   Out,
-  Services extends CoreSingletonServices = CoreServices,
+  Services extends CoreSingletonServices = CoreServices & {
+    channel?: PikkuChannel<unknown, Out>
+  },
   Session extends CoreUserSession = CoreUserSession,
-> = (services: Services, data: In, session?: Session) => Promise<Out>
+  Channel extends boolean = false,
+> = (
+  services: Services,
+  data: In,
+  session: Session
+) => Channel extends true ? Promise<Out> | Promise<void> : Promise<Out>
 
 /**
  * Represents a function that checks permissions for a given API operation.