@pikku/core 0.6.27 → 0.7.1

package/src/http/{http-routes.types.ts → http.types.ts}

@@ -1,6 +1,6 @@
-import { SerializeOptions } from 'cookie'
-import { PikkuError } from '../errors/error-handler.js'
-import {
+import type { SerializeOptions } from 'cookie'
+import type { PikkuError } from '../errors/error-handler.js'
+import type {
   APIDocs,
   CoreServices,
   CoreSingletonServices,
@@ -8,11 +8,12 @@ import {
   CreateSessionServices,
   PikkuMiddleware,
 } from '../types/core.types.js'
-import {
+import type {
   CoreAPIFunction,
   CoreAPIFunctionSessionless,
   CoreAPIPermission,
-} from '../types/functions.types.js'
+  CorePermissionGroup,
+} from '../function/functions.types.js'
 
 type ExtractRouteParams<S extends string> =
   S extends `${string}:${infer Param}/${infer Rest}`
@@ -32,6 +33,7 @@ export type RunRouteOptions = Partial<{
   logWarningsForStatusCodes: number[]
   coerceDataFromSchema: boolean
   bubbleErrors: boolean
+  generateRequestId: () => string
 }>
 
 export type RunRouteParams = {
@@ -117,10 +119,11 @@ export type CoreHTTPFunctionRoute<
       route: R
       method: HTTPMethod
       func: APIFunction
-      permissions?: Record<string, APIPermission[] | APIPermission>
+      permissions?: CorePermissionGroup<APIPermission>
       auth?: true
       tags?: string[]
       middleware?: APIMiddleware[]
+      sse?: undefined
     })
   | (CoreHTTPFunction & {
       route: R
@@ -130,16 +133,38 @@ export type CoreHTTPFunctionRoute<
       auth?: false
       tags?: string[]
       middleware?: APIMiddleware[]
+      sse?: undefined
+    })
+  | (CoreHTTPFunction & {
+      route: R
+      method: 'get'
+      func: APIFunction
+      permissions?: CorePermissionGroup<APIPermission>
+      auth?: true
+      sse?: boolean
+      tags?: string[]
+      middleware?: APIMiddleware[]
+    })
+  | (CoreHTTPFunction & {
+      route: R
+      method: 'get'
+      func: APIFunctionSessionless
+      permissions?: undefined
+      auth?: false
+      sse?: boolean
+      tags?: string[]
+      middleware?: APIMiddleware[]
     })
   | (CoreHTTPFunction & {
       route: R
       method: 'post'
       func: APIFunction
-      permissions?: Record<string, APIPermission[] | APIPermission>
+      permissions?: CorePermissionGroup<APIPermission>
       auth?: true
       query?: Array<keyof In>
       tags?: string[]
       middleware?: APIMiddleware[]
+      sse?: undefined
     })
   | (CoreHTTPFunction & {
       route: R
@@ -150,15 +175,9 @@ export type CoreHTTPFunctionRoute<
       query?: Array<keyof In>
       tags?: string[]
       middleware?: APIMiddleware[]
+      sse?: undefined
     })
 
-/**
- * Represents an array of core API routes.
- */
-export type CoreHTTPFunctionRoutes = Array<
-  CoreHTTPFunctionRoute<any, any, string>
->
-
 /**
  * Represents the input types for route metadata, including parameters, query, and body types.
  */
@@ -171,7 +190,8 @@ export type HTTPFunctionMetaInputTypes = {
 /**
  * Represents metadata for a set of routes, including route details, methods, input/output types, and documentation.
  */
-export type HTTPRoutesMeta = Array<{
+export type HTTPRouteMeta = {
+  pikkuFuncName: string
   route: string
   method: HTTPMethod
   params?: string[]
@@ -181,6 +201,14 @@ export type HTTPRoutesMeta = Array<{
   inputTypes?: HTTPFunctionMetaInputTypes
   docs?: APIDocs
   tags?: string[]
+  sse?: true
+}
+export type HTTPRoutesMeta = Array<HTTPRouteMeta>
+
+export type HTTPFunctionsMeta = Array<{
+  name: string
+  inputs: string[] | null
+  outputs: string[] | null
 }>
 
 export type HTTPRouteMiddleware = {
@@ -205,7 +233,18 @@ export interface PikkuHTTPResponse {
   status(code: number): this
   cookie(name: string, value: string | null, options: SerializeOptions): this
   header(name: string, value: string | string[]): this
-  arrayBuffer(data: XMLHttpRequestBodyInit): this
+  arrayBuffer(
+    data:
+      | ArrayBuffer
+      | ArrayBufferView
+      | Blob
+      | string
+      | FormData
+      | URLSearchParams
+      | ReadableStream
+  ): this
   json(data: unknown): this
   redirect(location: string, status?: number): this
+  close?: () => void
+  setMode?: (mode: 'stream') => void
 }

package/src/http/index.ts

@@ -3,6 +3,6 @@ export * from './pikku-fetch-http-response.js'
 export * from './incomingmessage-to-request-convertor.js'
 export * from './log-http-routes.js'
 
-export { fetch, fetchData, addRoute } from './http-route-runner.js'
+export { fetch, fetchData, addHTTPRoute } from './http-runner.js'
 
-export type * from './http-routes.types.js'
+export type * from './http.types.js'

package/src/http/log-http-routes.ts

@@ -6,15 +6,17 @@ import { Logger } from '../services/index.js'
  * @param logger - A logger for logging information.
  */
 export const logRoutes = (logger: Logger) => {
-  const routes = pikkuState('http', 'routes')
-  if (routes.length === 0) {
+  const routesByType = pikkuState('http', 'routes')
+  if (routesByType.size === 0) {
     logger.info('No routes added')
     return
   }
 
   let routesMessage = 'Routes loaded:'
-  for (const { method, route } of routes) {
-    routesMessage += `\n\t- ${method.toUpperCase()} -> ${route}`
-  }
+  routesByType.forEach((routes) => {
+    routes.forEach((route) => {
+      routesMessage += `\n\t- ${route.method.toUpperCase()} -> ${route.route}`
+    })
+  })
   logger.info(routesMessage)
 }

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

@@ -1,10 +1,6 @@
 import { parse as parseQuery } from 'picoquery'
 import { parse as parseCookie } from 'cookie'
-import {
-  HTTPMethod,
-  PikkuHTTPRequest,
-  PikkuQuery,
-} from './http-routes.types.js'
+import { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js'
 import { UnprocessableContentError } from '../errors/errors.js'
 
 /**

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

@@ -1,4 +1,4 @@
-import { PikkuHTTPResponse } from './http-routes.types.js'
+import { PikkuHTTPResponse } from './http.types.js'
 import {
   SerializeOptions as CookieSerializeOptions,
   serialize as serializeCookie,
@@ -10,6 +10,16 @@ export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
   #cookies = new Map<string, { value: string; flags: CookieSerializeOptions }>()
 
   #body: BodyInit | null = null
+  #responseMode: 'stream' | null = null
+  #send: ((data: string) => void) | null = null
+  #close: (() => void) | null = null
+
+  public setMode(mode: 'stream') {
+    this.#responseMode = 'stream'
+    if (mode === 'stream') {
+      this.#body = this.createStream()
+    }
+  }
 
   public status(code: number): this {
     this.#statusCode = code
@@ -36,33 +46,49 @@ export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
   }
 
   public arrayBuffer(data: XMLHttpRequestBodyInit): this {
-    this.#body = data
-    this.header('Content-Type', 'application/octet-stream')
+    if (this.#responseMode === 'stream') {
+      this.#send!(data as string)
+    } else {
+      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')
+    if (this.#responseMode === 'stream') {
+      this.#send!(JSON.stringify(data))
+    } else {
+      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')
+    if (this.#responseMode === 'stream') {
+      this.#send!(content)
+    } else {
+      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')
+    if (this.#responseMode === 'stream') {
+      this.#send!(content)
+    } else {
+      this.#body = content
+      this.header('Content-Type', 'text/html')
+    }
     return this
   }
 
-  public body(body: BodyInit): this {
-    this.#body = body
-    return this
-  }
+  // public body(body: BodyInit): this {
+  //   this.#body = body
+  //   return this
+  // }
 
   public redirect(location: string, status: number = 302): this {
     this.#statusCode = status
@@ -70,6 +96,13 @@ export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     return this
   }
 
+  public close(): this {
+    if (this.#close) {
+      this.#close()
+    }
+    return this
+  }
+
   public toResponse(args?: Record<string, any>): Response {
     const cookieHeader = Array.from(this.#cookies.entries()).map(
       ([name, { value, flags }]) => serializeCookie(name, value, flags)
@@ -81,4 +114,25 @@ export class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
       headers: this.#headers,
     })
   }
+
+  private createStream(): ReadableStream<Uint8Array> {
+    const encoder = new TextEncoder()
+    return new ReadableStream({
+      start: (controller) => {
+        const send = (data: string) => {
+          controller.enqueue(encoder.encode(`data: ${data}\n\n`))
+        }
+
+        const close = () => {
+          controller.close()
+        }
+
+        this.#send = send
+        this.#close = close
+
+        // Force initial flush
+        controller.enqueue(encoder.encode(':\n\n'))
+      },
+    })
+  }
 }

package/src/index.ts

@@ -2,7 +2,7 @@
  * @module @pikku/core
  */
 export * from './types/core.types.js'
-export * from './types/functions.types.js'
+export * from './function/index.js'
 export * from './pikku-request.js'
 export * from './pikku-response.js'
 export * from './services/index.js'
@@ -12,8 +12,9 @@ export * from './scheduler/index.js'
 export * from './errors/index.js'
 export * from './middleware/index.js'
 export * from './time-utils.js'
+export * from './utils.js'
 export { pikkuState } from './pikku-state.js'
 export { runMiddleware } from './middleware-runner.js'
-export { addRoute, addMiddleware } from './http/http-route-runner.js'
+export { addHTTPRoute, addMiddleware } from './http/http-runner.js'
 export { addChannel } from './channel/channel-runner.js'
 export { addScheduledTask } from './scheduler/scheduler-runner.js'

package/src/middleware/auth-apikey.ts

@@ -33,7 +33,8 @@ export const authAPIKey = <
     }
 )) => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
-    if (!http?.request || services.userSession.get()) {
+    const { userSession: userSessionService, jwt: jwtService } = services
+    if (!http?.request || userSessionService.get()) {
       return next()
     }
 
@@ -47,15 +48,15 @@ export const authAPIKey = <
     if (apiKey) {
       let userSession: UserSession | null = null
       if (jwt) {
-        if (!services.jwt) {
+        if (!jwtService) {
           throw new Error('JWT service is required for JWT decoding.')
         }
-        userSession = await services.jwt.decode(apiKey)
+        userSession = await jwtService.decode(apiKey)
       } else {
         userSession = await getSessionForAPIKey!(services as any, apiKey)
       }
       if (userSession) {
-        services.userSession.setInitial(userSession)
+        userSessionService.setInitial(userSession)
       }
     }
     return next()

package/src/middleware/auth-bearer.ts

@@ -28,8 +28,9 @@ export const authBearer = <
   ) => Promise<UserSession> | UserSession
 } = {}): PikkuMiddleware => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
+    const { userSession: userSessionService, jwt: jwtService } = services
     // Skip if session already exists.
-    if (!http?.request || services.userSession.get()) {
+    if (!http?.request || userSessionService.get()) {
       return next()
     }
 
@@ -43,10 +44,10 @@ export const authBearer = <
       }
       let userSession: UserSession | null = null
       if (jwt) {
-        if (!services.jwt) {
+        if (!jwtService) {
           throw new Error('JWT service is required for JWT decoding.')
         }
-        userSession = await services.jwt.decode(bearerToken)
+        userSession = await jwtService.decode(bearerToken)
       } else if (token) {
         if (bearerToken === token.value) {
           userSession = token.userSession
@@ -56,7 +57,7 @@ export const authBearer = <
       }
 
       if (userSession) {
-        services.userSession.setInitial(userSession)
+        userSessionService.setInitial(userSession)
       }
     }
     return next()

package/src/middleware/auth-cookie.ts

@@ -44,7 +44,12 @@ export const authCookie = <
     }
 )): PikkuMiddleware => {
   const middleware: PikkuMiddleware = async (services, { http }, next) => {
-    if (!http?.request || services.userSession.get()) {
+    const {
+      userSession: userSessionService,
+      jwt: jwtService,
+      logger,
+    } = services
+    if (!http?.request || userSessionService.get()) {
       return next()
     }
 
@@ -52,10 +57,10 @@ export const authCookie = <
     const cookieValue = http.request.cookie(name)
     if (cookieValue) {
       if (jwt) {
-        if (!services.jwt) {
+        if (!jwtService) {
           throw new Error('JWT service is required for JWT decoding.')
         }
-        userSession = await services.jwt.decode(cookieValue)
+        userSession = await jwtService.decode(cookieValue)
       } else if (getSessionForCookieValue) {
         userSession = await getSessionForCookieValue(
           services as any,
@@ -66,7 +71,7 @@ export const authCookie = <
     }
 
     if (userSession) {
-      services.userSession.setInitial(userSession)
+      userSessionService.setInitial(userSession)
     }
     await next()
 
@@ -75,22 +80,22 @@ export const authCookie = <
       return
     }
 
-    if (services.userSession.sessionChanged) {
-      const session = services.userSession.get()
+    if (userSessionService.sessionChanged) {
+      const session = userSessionService.get()
       if (jwt) {
-        if (!services.jwt) {
+        if (!jwtService) {
           throw new Error('JWT service is required for JWT encoding.')
         }
         http.response.cookie(
           name,
-          await services.jwt.encode(expiresIn, session),
+          await jwtService.encode(expiresIn, session),
           {
             ...options,
             expires: getRelativeTimeOffsetFromNow(expiresIn),
           }
         )
       } else {
-        services.logger.warn('No JWT service available, unable to set cookie')
+        logger.warn('No JWT service available, unable to set cookie')
       }
     }
   }

package/src/permissions.ts

@@ -1,5 +1,5 @@
 import { CoreServices, CoreUserSession } from './types/core.types.js'
-import { CoreAPIPermission } from './types/functions.types.js'
+import { CorePermissionGroup } from './function/functions.types.js'
 
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
@@ -9,9 +9,7 @@ import { CoreAPIPermission } from './types/functions.types.js'
  * @returns A promise that resolves to void.
  */
 export const verifyPermissions = async (
-  permissions:
-    | Record<string, CoreAPIPermission<any>[] | CoreAPIPermission<any>>
-    | undefined,
+  permissions: CorePermissionGroup,
   services: CoreServices,
   data: any,
   session?: CoreUserSession

package/src/pikku-function.ts

@@ -0,0 +1 @@
+export const callFunction = () => {}

package/src/pikku-state.ts

@@ -1,23 +1,35 @@
-import { ChannelsMeta, CoreAPIChannels } from './channel/channel.types.js'
+import { ChannelsMeta, CoreAPIChannel } from './channel/channel.types.js'
 import {
-  CoreHTTPFunctionRoutes,
+  CoreHTTPFunctionRoute,
+  HTTPMethod,
   HTTPRoutesMeta,
-} from './http/http-routes.types.js'
-import { PikkuMiddleware } from './types/core.types.js'
+} from './http/http.types.js'
+import { FunctionsMeta, PikkuMiddleware } from './types/core.types.js'
 import {
   CoreScheduledTask,
   ScheduledTasksMeta,
 } from './scheduler/scheduler.types.js'
 import { ErrorDetails, PikkuError } from './errors/error-handler.js'
+import {
+  CoreAPIFunction,
+  CoreAPIFunctionSessionless,
+} from './function/functions.types.js'
 
 interface PikkuState {
+  functions: {
+    meta: FunctionsMeta
+    nameToFunction: Map<
+      string,
+      CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>
+    >
+  }
   http: {
     middleware: Array<{ route: string; middleware: PikkuMiddleware[] }>
-    routes: CoreHTTPFunctionRoutes
+    routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionRoute<any, any, any>>>
     meta: HTTPRoutesMeta
   }
   channel: {
-    channels: CoreAPIChannels
+    channels: Map<string, CoreAPIChannel<any, any>>
     meta: ChannelsMeta
   }
   scheduler: {
@@ -32,14 +44,18 @@ interface PikkuState {
 
 export const resetPikkuState = () => {
   globalThis.pikkuState = {
+    functions: {
+      meta: {},
+      nameToFunction: new Map(),
+    },
     http: {
       middleware: [],
-      routes: [],
+      routes: new Map(),
       meta: [],
     },
     channel: {
-      channels: [],
-      meta: [],
+      channels: new Map(),
+      meta: {},
     },
     scheduler: {
       tasks: new Map(),

package/src/scheduler/scheduler-runner.ts

@@ -5,10 +5,11 @@ import type {
   CreateSessionServices,
 } from '../types/core.types.js'
 import type { CoreScheduledTask } from './scheduler.types.js'
-import type { CoreAPIFunctionSessionless } from '../types/functions.types.js'
+import type { CoreAPIFunctionSessionless } from '../function/functions.types.js'
 import { getErrorResponse } from '../errors/error-handler.js'
 import { closeSessionServices } from '../utils.js'
 import { pikkuState } from '../pikku-state.js'
+import { addFunction, runPikkuFunc } from '../function/function-runner.js'
 
 export type RunScheduledTasksParams = {
   name: string
@@ -26,6 +27,13 @@ export const addScheduledTask = <
 >(
   scheduledTask: CoreScheduledTask<APIFunction>
 ) => {
+  const meta = pikkuState('scheduler', 'meta')
+  const taskMeta = meta[scheduledTask.name]
+  if (!taskMeta) {
+    throw new Error('Task metadata not found')
+  }
+  addFunction(taskMeta.pikkuFuncName, scheduledTask.func)
+
   const tasks = pikkuState('scheduler', 'tasks')
   if (tasks.has(scheduledTask.name)) {
     throw new Error(`Scheduled task already exists: ${scheduledTask.name}`)
@@ -51,33 +59,43 @@ export async function runScheduledTask<
   let sessionServices: CoreServices | undefined
   try {
     const task = pikkuState('scheduler', 'tasks').get(name)
-
+    const meta = pikkuState('scheduler', 'meta')[name]
     if (!task) {
       throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`)
     }
+    if (!meta) {
+      throw new ScheduledTaskNotFoundError(
+        `Scheduled task meta not found: ${name}`
+      )
+    }
 
     singletonServices.logger.info(
       `Running schedule task: ${name} | schedule: ${task.schedule}`
     )
 
-    let allServices = singletonServices
-    if (createSessionServices) {
-      const sessionServices = await createSessionServices(
-        singletonServices,
-        {},
-        session
-      )
-      allServices = { ...singletonServices, ...sessionServices }
+    const getAllServices = async () => {
+      if (createSessionServices) {
+        const sessionServices = await createSessionServices(
+          singletonServices,
+          {},
+          session
+        )
+        return { ...singletonServices, ...sessionServices }
+      }
+      return singletonServices
     }
 
-    await task.func(allServices, undefined, session!)
+    return await runPikkuFunc(meta.pikkuFuncName, {
+      singletonServices,
+      getAllServices,
+      session,
+      data: undefined,
+    })
   } catch (e: any) {
     const errorResponse = getErrorResponse(e)
-
     if (errorResponse != null) {
       singletonServices.logger.error(e)
     }
-
     throw e
   } finally {
     if (sessionServices) {

package/src/scheduler/scheduler.types.ts

@@ -1,17 +1,21 @@
 import { APIDocs, CoreUserSession } from '../types/core.types.js'
-import { CoreAPIFunctionSessionless } from '../types/functions.types.js'
+import { CoreAPIFunctionSessionless } from '../function/functions.types.js'
 
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
  */
 export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> =
-  Array<{
-    name: string
-    schedule: string
-    session?: UserSession
-    docs?: APIDocs
-    tags?: string[]
-  }>
+  Record<
+    string,
+    {
+      pikkuFuncName: string
+      name: string
+      schedule: string
+      session?: UserSession
+      docs?: APIDocs
+      tags?: string[]
+    }
+  >
 
 /**
  * Represents a core scheduled task.