@pikku/core 0.6.16 → 0.6.18

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## 0.6
 
+## 0.6.18
+
+### Patch Changes
+
+- 6be081b: fix: export addMiddleware correctly
+
+## 0.6.17
+
+### Patch Changes
+
+- ebc04eb: refactor: move all global state into pikku state
+- 8a14f3a: refactor: removing user session from channel object
+- 2c47386: refactor: improving middleware
+
 ## 0.6.16
 
 ### Patch Changes

package/dist/channel/channel-handler.js

@@ -1,7 +1,7 @@
 import { verifyPermissions } from '../permissions.js';
-import { getChannels } from './channel-runner.js';
+import { pikkuState } from '../pikku-state.js';
 const validateSchema = (logger, data, channelName, routingProperty, routerValue) => {
-    const { channelsMeta } = getChannels();
+    const channelsMeta = pikkuState('channel', 'meta');
     for (const channelMeta of channelsMeta) {
         if (routingProperty && routerValue) {
             const channelRoute = channelMeta.messageRoutes[routingProperty]?.[routerValue];

package/dist/channel/channel-runner.d.ts

@@ -1,25 +1,13 @@
 import { UserSessionService } from '../services/user-session-service.js';
-import { CoreAPIChannel, ChannelsMeta, CoreAPIChannels, RunChannelOptions, RunChannelParams } from './channel.types.js';
-/**
- * Returns all the registered routes and associated metadata.
- * @internal
- */
-export declare const getChannels: () => {
-    channels: CoreAPIChannels;
-    channelsMeta: ChannelsMeta;
-};
+import { CoreAPIChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 export declare const addChannel: <In, Channel extends string, ChannelFunction, ChannelFunctionSessionless, APIPermission>(channel: CoreAPIChannel<In, Channel, ChannelFunction, ChannelFunctionSessionless, APIPermission>) => void;
-/**
- * @ignore
- */
-export declare const setChannelsMeta: (_channelsMeta: ChannelsMeta) => void;
 export declare const getMatchingChannelConfig: (request: string) => {
     matchedPath: import("path-to-regexp").MatchResult<Partial<Record<string, string | string[]>>>;
     params: Partial<Record<string, string | string[]>>;
     channelConfig: CoreAPIChannel<any, string, import("./channel.types.js").CoreChannelConnection<any, unknown, import("../index.js").CoreServices>, import("./channel.types.js").CoreChannelDisconnection<any, import("../index.js").CoreServices>, import("./channel.types.js").CoreChannelMessage<unknown, unknown, unknown, import("../index.js").CoreServices>, import("./channel.types.js").CoreChannelMessage<unknown, unknown, unknown, import("../index.js").CoreServices>, import("../index.js").CoreAPIPermission<any>>;
     schemaName: string | null | undefined;
 } | null;
-export declare const openChannel: ({ route, singletonServices, coerceToArray, http, userSessionService, }: Pick<CoreAPIChannel<unknown, string>, "route"> & Omit<RunChannelParams<unknown>, "response" | "request"> & {
+export declare const openChannel: ({ route, singletonServices, coerceToArray, http, }: Pick<CoreAPIChannel<unknown, string>, "route"> & Omit<RunChannelParams<unknown>, "response" | "request"> & {
     userSessionService?: UserSessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;

package/dist/channel/channel-runner.js

@@ -1,44 +1,13 @@
 import { NotFoundError } from '../errors/errors.js';
+import { pikkuState } from '../pikku-state.js';
 import { coerceQueryStringToArray, validateSchema } from '../schema.js';
 import { match } from 'path-to-regexp';
-if (!globalThis.pikku?.channels) {
-    globalThis.pikku = globalThis.pikku || {};
-    globalThis.pikku.channels = [];
-    globalThis.pikku.channelsMeta = [];
-}
-const channels = (data) => {
-    if (data) {
-        globalThis.pikku.channels = data;
-    }
-    return globalThis.pikku.channels;
-};
-const channelsMeta = (data) => {
-    if (data) {
-        globalThis.pikku.channelsMeta = data;
-    }
-    return globalThis.pikku.channelsMeta;
-};
-/**
- * Returns all the registered routes and associated metadata.
- * @internal
- */
-export const getChannels = () => {
-    return {
-        channels: channels(),
-        channelsMeta: channelsMeta(),
-    };
-};
 export const addChannel = (channel) => {
-    channels().push(channel);
-};
-/**
- * @ignore
- */
-export const setChannelsMeta = (_channelsMeta) => {
-    channelsMeta(_channelsMeta);
+    pikkuState('channel', 'channels').push(channel);
 };
 export const getMatchingChannelConfig = (request) => {
-    const { channels, channelsMeta } = getChannels();
+    const channels = pikkuState('channel', 'channels');
+    const channelsMeta = pikkuState('channel', 'meta');
     for (const channelConfig of channels) {
         const cleanedRoute = channelConfig.route.replace(/^\/\//, '/');
         const cleanedRequest = request.replace(/^\/\//, '/');
@@ -58,7 +27,7 @@ export const getMatchingChannelConfig = (request) => {
     }
     return null;
 };
-export const openChannel = async ({ route, singletonServices, coerceToArray = false, http, userSessionService, }) => {
+export const openChannel = async ({ route, singletonServices, coerceToArray = false, http, }) => {
     const matchingChannel = getMatchingChannelConfig(route);
     if (!matchingChannel) {
         singletonServices.logger.info(`Channel not found: ${route}`);

package/dist/channel/channel-store.d.ts

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

package/dist/channel/index.d.ts

@@ -3,7 +3,6 @@ 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-forwarder.js';
 export * from './eventhub-service.js';
 export * from './channel-store.js';
 export * from './eventhub-store.js';

package/dist/channel/index.js

@@ -3,7 +3,6 @@ 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-forwarder.js';
 export * from './eventhub-service.js';
 export * from './channel-store.js';
 export * from './eventhub-store.js';

package/dist/channel/local/local-channel-runner.js

@@ -32,7 +32,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             const allServices = {
                 ...singletonServices,
                 ...sessionServices,
-                userSessionService,
+                userSession: userSessionService,
             };
             channelHandler.registerOnOpen(() => {
                 channelConfig.onConnect?.(allServices, channel);
@@ -56,7 +56,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     };
     await runMiddleware({
         ...singletonServices,
-        userSessionService,
+        userSession: userSessionService,
     }, { http }, route.middleware || [], main);
     return channelHandler;
 };

package/dist/channel/log-channels.js

@@ -1,10 +1,10 @@
-import { getChannels } from './channel-runner.js';
+import { pikkuState } from '../pikku-state.js';
 /**
  * Logs all the loaded channels.
  * @param logger - A logger for logging information.
  */
 export const logChannels = (logger) => {
-    const { channels } = getChannels();
+    const channels = pikkuState('channel', 'channels');
     if (channels.length === 0) {
         logger.info('No channels added');
         return;

package/dist/channel/serverless/serverless-channel-runner.js

@@ -1,12 +1,13 @@
 import { closeSessionServices } from '../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
-import { getChannels, openChannel } from '../channel-runner.js';
+import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-route-runner.js';
 import { handleError } from '../../handle-error.js';
 import { RemoteUserSessionService } from '../../services/user-session-service.js';
 import { runMiddleware } from '../../middleware-runner.js';
+import { pikkuState } from '../../pikku-state.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
-    const { channels } = getChannels();
+    const channels = pikkuState('channel', 'channels');
     const channelConfig = channels.find((channelConfig) => channelConfig.name === channelName);
     if (!channelConfig) {
         throw new Error(`Channel not found: ${channelName}`);
@@ -60,19 +61,19 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     };
     await runMiddleware({
         ...singletonServices,
-        userSessionService,
+        userSession: userSessionService,
     }, { http }, channelConfig.middleware || [], main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;
-    const { userSession, openingData, channelName } = await params.channelStore.getChannel(params.channelId);
+    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, {}, userSession);
+        sessionServices = await params.createSessionServices(singletonServices, {}, session);
     }
     await channelConfig.onDisconnect?.({ ...singletonServices, ...sessionServices }, channel);
     await params.channelStore.removeChannels([channel.channelId]);
@@ -82,14 +83,14 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
 };
 export const runChannelMessage = async ({ singletonServices, ...params }, data) => {
     let sessionServices;
-    const { userSession, openingData, channelName } = await params.channelStore.getChannel(params.channelId);
+    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, {}, userSession);
+        sessionServices = await params.createSessionServices(singletonServices, {}, session);
     }
     let response;
     try {

package/dist/errors/error-handler.d.ts

@@ -16,7 +16,7 @@ export interface ErrorDetails {
     status: number;
     message: string;
 }
-export declare const getErrors: () => Map<any, ErrorDetails>;
+export declare const getErrors: () => Map<PikkuError, ErrorDetails>;
 /**
  * Adds an error to the API errors map.
  * @param error - The error to add.

package/dist/errors/error-handler.js

@@ -1,3 +1,4 @@
+import { pikkuState } from '../pikku-state.js';
 /**
  * Base class for custom errors.
  * @extends {Error}
@@ -12,24 +13,14 @@ export class PikkuError extends Error {
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
-/**
- * Map of API errors to their details.
- */
-if (!globalThis.pikku?.apiErrors) {
-    globalThis.pikku = globalThis.pikku || {};
-    globalThis.pikku.apiErrors = new Map([]);
-}
-const apiErrors = () => {
-    return globalThis.pikku.apiErrors;
-};
-export const getErrors = () => apiErrors();
+export const getErrors = () => pikkuState('errors', 'errors');
 /**
  * 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, { status, message }) => {
-    apiErrors().set(error, { status, message });
+    pikkuState('errors', 'errors').set(error, { status, message });
 };
 /**
  * Adds multiple errors to the API errors map.
@@ -46,9 +37,10 @@ export const addErrors = (errors) => {
  * @returns An object containing the status and message, or undefined if the error is not found.
  */
 export const getErrorResponse = (error) => {
-    const foundError = Array.from(apiErrors().entries()).find(([e]) => e.name === error.constructor.name);
+    const errors = Array.from(pikkuState('errors', 'errors').entries());
+    const foundError = errors.find(([e]) => e.name === error.constructor.name);
     if (foundError) {
         return foundError[1];
     }
-    return apiErrors().get(error);
+    return pikkuState('errors', 'errors').get(error);
 };

package/dist/errors/errors.d.ts

@@ -69,7 +69,7 @@ export declare class NotAcceptableError extends PikkuError {
 export declare class ProxyAuthenticationRequiredError extends PikkuError {
 }
 /**
- * The server did not receive a timely response from an upstream server.
+ * The server request expired
  * @group Error
  */
 export declare class RequestTimeoutError extends PikkuError {

package/dist/errors/errors.js

@@ -114,14 +114,14 @@ addError(ProxyAuthenticationRequiredError, {
     message: 'The client must authenticate itself to get the requested response.',
 });
 /**
- * The server did not receive a timely response from an upstream server.
+ * The server request expired
  * @group Error
  */
 export class RequestTimeoutError extends PikkuError {
 }
 addError(RequestTimeoutError, {
     status: 408,
-    message: 'The server did not receive a timely response from an upstream server.',
+    message: 'The request timeout has expired.',
 });
 /**
  * The request could not be completed due to a conflict with the current state of the target resource.

package/dist/http/http-route-runner.d.ts

@@ -1,4 +1,5 @@
-import { CoreHTTPFunctionRoute, HTTPRoutesMeta, RunRouteOptions, RunRouteParams, PikkuHTTP } from './http-routes.types.js';
+import { CoreHTTPFunctionRoute, RunRouteOptions, RunRouteParams, PikkuHTTP } from './http-routes.types.js';
+import { PikkuMiddleware } from '../types/core.types.js';
 import { PikkuRequest } from '../pikku-request.js';
 import { PikkuResponse } from '../pikku-response.js';
 /**
@@ -7,34 +8,13 @@ import { PikkuResponse } from '../pikku-response.js';
  * @param {APIMiddleware[] | string} routeOrMiddleware - Route pattern to match or middleware array
  * @param {APIMiddleware} [middleware] - Middleware to add (required if first param is a string)
  */
-export declare const addMiddleware: <APIMiddleware>(routeOrMiddleware: APIMiddleware[] | string, middleware?: APIMiddleware) => void;
+export declare const addMiddleware: <APIMiddleware extends PikkuMiddleware>(routeOrMiddleware: APIMiddleware[] | string, middleware?: APIMiddleware[]) => void;
 /**
  * Add a route to the global routes registry
  *
  * @param {CoreHTTPFunctionRoute} route - Route configuration to add
  */
 export declare const addRoute: <In, Out, Route extends string, APIFunction, APIFunctionSessionless, APIPermission, APIMiddleware>(route: CoreHTTPFunctionRoute<In, Out, Route, APIFunction, APIFunctionSessionless, APIPermission, APIMiddleware>) => void;
-/**
- * Remove all routes from the global registry
- */
-export declare const clearRoutes: () => void;
-/**
- * Set the HTTP routes metadata
- *
- * @param {HTTPRoutesMeta} routeMeta - Metadata for routes
- * @ignore
- */
-export declare const setHTTPRoutesMeta: (routeMeta: HTTPRoutesMeta) => void;
-/**
- * Returns all the registered routes and associated metadata
- *
- * @returns {Object} Object containing routes and routesMeta
- * @internal
- */
-export declare const getRoutes: () => {
-    routes: CoreHTTPFunctionRoute<any, any, any>[];
-    routesMeta: HTTPRoutesMeta;
-};
 /**
  * Create an HTTP interaction object from request and response
  *

package/dist/http/http-route-runner.js

@@ -9,51 +9,7 @@ import { coerceQueryStringToArray, validateSchema } from '../schema.js';
 import { LocalUserSessionService } from '../services/user-session-service.js';
 import { runMiddleware } from '../middleware-runner.js';
 import { handleError } from '../handle-error.js';
-/**
- * Initialize global state for HTTP routes and middleware if not already available
- */
-if (!globalThis.pikku?.httpRoutes) {
-    globalThis.pikku = globalThis.pikku || {};
-    globalThis.pikku.httpMiddleware = [];
-    globalThis.pikku.httpRoutes = [];
-    globalThis.pikku.httpRoutesMeta = [];
-}
-/**
- * Get or set the global HTTP routes
- *
- * @param {CoreHTTPFunctionRoute<any, any, any>[]} [data] - Optional routes data to set
- * @returns {CoreHTTPFunctionRoute<any, any, any>[]} Current routes
- */
-const httpRoutes = (data) => {
-    if (data) {
-        globalThis.pikku.httpRoutes = data;
-    }
-    return globalThis.pikku.httpRoutes;
-};
-/**
- * Get or set the global HTTP route metadata
- *
- * @param {HTTPRoutesMeta} [data] - Optional route metadata to set
- * @returns {HTTPRoutesMeta} Current route metadata
- */
-const httpRoutesMeta = (data) => {
-    if (data) {
-        globalThis.pikku.httpRoutesMeta = data;
-    }
-    return globalThis.pikku.httpRoutesMeta;
-};
-/**
- * Get or set the global HTTP middleware
- *
- * @param {HTTPRouteMiddleware[]} [data] - Optional middleware to set
- * @returns {HTTPRouteMiddleware[]} Current middleware
- */
-const httpMiddleware = (data) => {
-    if (data) {
-        globalThis.pikku.httpMiddleware = data;
-    }
-    return globalThis.pikku.httpMiddleware;
-};
+import { pikkuState } from '../pikku-state.js';
 /**
  * Add middleware to a specific route or globally
  *
@@ -61,14 +17,14 @@ const httpMiddleware = (data) => {
  * @param {APIMiddleware} [middleware] - Middleware to add (required if first param is a string)
  */
 export const addMiddleware = (routeOrMiddleware, middleware) => {
-    if (typeof routeOrMiddleware === 'string') {
-        globalThis.pikku.httpMiddleware.push({
+    if (typeof routeOrMiddleware === 'string' && middleware) {
+        pikkuState('http', 'middleware').push({
             route: routeOrMiddleware,
-            middleware: middleware,
+            middleware,
         });
     }
     else {
-        globalThis.pikku.httpMiddleware.push({
+        pikkuState('http', 'middleware').push({
             route: '*',
             middleware: routeOrMiddleware,
         });
@@ -80,34 +36,7 @@ export const addMiddleware = (routeOrMiddleware, middleware) => {
  * @param {CoreHTTPFunctionRoute} route - Route configuration to add
  */
 export const addRoute = (route) => {
-    httpRoutes().push(route);
-};
-/**
- * Remove all routes from the global registry
- */
-export const clearRoutes = () => {
-    httpRoutes([]);
-};
-/**
- * Set the HTTP routes metadata
- *
- * @param {HTTPRoutesMeta} routeMeta - Metadata for routes
- * @ignore
- */
-export const setHTTPRoutesMeta = (routeMeta) => {
-    httpRoutesMeta(routeMeta);
-};
-/**
- * Returns all the registered routes and associated metadata
- *
- * @returns {Object} Object containing routes and routesMeta
- * @internal
- */
-export const getRoutes = () => {
-    return {
-        routes: httpRoutes(),
-        routesMeta: httpRoutesMeta(),
-    };
+    pikkuState('http', 'routes').push(route);
 };
 /**
  * Find a route that matches the given request type and path
@@ -117,7 +46,10 @@ export const getRoutes = () => {
  * @returns {Object | undefined} Matching route information or undefined if no match
  */
 const getMatchingRoute = (requestType, requestPath) => {
-    for (const route of httpRoutes()) {
+    const routes = pikkuState('http', 'routes');
+    const middleware = pikkuState('http', 'middleware');
+    const routesMeta = pikkuState('http', 'meta');
+    for (const route of routes) {
         // Skip routes that don't match the request method
         if (route.method !== requestType.toLowerCase()) {
             continue;
@@ -130,12 +62,12 @@ const getMatchingRoute = (requestType, requestPath) => {
         const matchedPath = matchFunc(requestPath.replace(/^\/\//, '/'));
         if (matchedPath) {
             // Get all middleware for this route
-            const globalMiddleware = httpMiddleware()
+            const globalMiddleware = middleware
                 .filter((m) => m.route === '*' || new RegExp(m.route).test(route.route))
                 .map((m) => m.middleware)
                 .flat();
             // Find schema for this route
-            const schemaName = httpRoutesMeta().find((routeMeta) => routeMeta.method === route.method && routeMeta.route === route.route)?.input;
+            const schemaName = routesMeta.find((routeMeta) => routeMeta.method === route.method && routeMeta.route === route.route)?.input;
             return {
                 matchedPath,
                 params: matchedPath.params,
@@ -180,7 +112,6 @@ export const createHTTPInteraction = (request, response) => {
 const executeRouteWithMiddleware = async (services, matchedRoute, http, options) => {
     const { matchedPath, params, route, middleware, schemaName } = matchedRoute;
     const { singletonServices, userSessionService, createSessionServices, skipUserSession, } = services;
-    const { coerceToArray } = options;
     const requiresSession = route.auth !== false;
     let sessionServices;
     let result;
@@ -206,7 +137,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         const data = await http?.request?.getData();
         // Validate schema
         validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, data);
-        if (coerceToArray && schemaName) {
+        if (options.coerceToArray && schemaName) {
             coerceQueryStringToArray(schemaName, data);
         }
         // Run permission checks

package/dist/http/index.d.ts

@@ -1,5 +1,5 @@
 export * from './pikku-http-abstract-request.js';
 export * from './pikku-http-abstract-response.js';
 export * from './log-http-routes.js';
-export { runHTTPRoute, getRoutes, setHTTPRoutesMeta, addRoute, } from './http-route-runner.js';
+export { runHTTPRoute, addRoute } from './http-route-runner.js';
 export type * from './http-routes.types.js';

package/dist/http/index.js

@@ -1,4 +1,4 @@
 export * from './pikku-http-abstract-request.js';
 export * from './pikku-http-abstract-response.js';
 export * from './log-http-routes.js';
-export { runHTTPRoute, getRoutes, setHTTPRoutesMeta, addRoute, } from './http-route-runner.js';
+export { runHTTPRoute, addRoute } from './http-route-runner.js';

package/dist/http/log-http-routes.js

@@ -1,10 +1,10 @@
-import { getRoutes } from './http-route-runner.js';
+import { pikkuState } from '../pikku-state.js';
 /**
  * Logs all the loaded routes.
  * @param logger - A logger for logging information.
  */
 export const logRoutes = (logger) => {
-    const { routes } = getRoutes();
+    const routes = pikkuState('http', 'routes');
     if (routes.length === 0) {
         logger.info('No routes added');
         return;

package/dist/index.d.ts

@@ -11,7 +11,8 @@ export * from './channel/index.js';
 export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
+export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addRoute } from './http/http-route-runner.js';
+export { addRoute, addMiddleware } from './http/http-route-runner.js';
 export { addChannel } from './channel/channel-runner.js';
 export { addScheduledTask } from './scheduler/scheduler-runner.js';

package/dist/index.js

@@ -11,7 +11,8 @@ export * from './channel/index.js';
 export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
+export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addRoute } from './http/http-route-runner.js';
+export { addRoute, addMiddleware } from './http/http-route-runner.js';
 export { addChannel } from './channel/channel-runner.js';
 export { addScheduledTask } from './scheduler/scheduler-runner.js';

package/dist/middleware/auth-apikey.d.ts

@@ -0,0 +1,15 @@
+import { CoreConfig, CoreSingletonServices, CoreUserSession, PikkuMiddleware } from '../types/core.types.js';
+/**
+ * API key middleware that retrieves a session from the 'x-api-key' header using a provided callback.
+ *
+ * @param options.getSessionForAPIKey - A function that returns a session when provided an API key.
+ */
+export declare const authAPIKey: <SingletonServices extends CoreSingletonServices<CoreConfig>, UserSession extends CoreUserSession>({ source, getSessionForAPIKey, jwt, }: {
+    source: "header" | "query" | "all";
+} & ({
+    getSessionForAPIKey?: undefined;
+    jwt?: true;
+} | {
+    getSessionForAPIKey: (services: SingletonServices, apiKey: string) => Promise<any>;
+    jwt?: false;
+})) => PikkuMiddleware;

package/dist/middleware/auth-apikey.js

@@ -0,0 +1,36 @@
+/**
+ * API key middleware that retrieves a session from the 'x-api-key' header using a provided callback.
+ *
+ * @param options.getSessionForAPIKey - A function that returns a session when provided an API key.
+ */
+export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
+    const middleware = async (services, { http }, next) => {
+        if (!http?.request || services.userSession.get()) {
+            return next();
+        }
+        let apiKey = null;
+        if (source === 'header' || source === 'all') {
+            apiKey = http.request.getHeader('x-api-key');
+        }
+        if (!apiKey && (source === 'query' || source === 'all')) {
+            apiKey = http.request.getQuery().apiKey;
+        }
+        if (apiKey) {
+            let userSession = null;
+            if (jwt) {
+                if (!services.jwt) {
+                    throw new Error('JWT service is required for JWT decoding.');
+                }
+                userSession = await services.jwt.decode(apiKey);
+            }
+            else {
+                userSession = await getSessionForAPIKey(services, apiKey);
+            }
+            if (userSession) {
+                await services.userSession.set(userSession);
+            }
+        }
+        return next();
+    };
+    return middleware;
+};

package/dist/middleware/auth-bearer.d.ts

@@ -0,0 +1,12 @@
+import { CoreConfig, CoreSingletonServices, CoreUserSession, PikkuMiddleware } from '../types/core.types.js';
+/**
+ * Extracts the Bearer token from the Authorization header
+ */
+export declare const authBearer: <SingletonServices extends CoreSingletonServices<CoreConfig>, UserSession extends CoreUserSession>({ token, jwt, getSession, }?: {
+    token?: {
+        value: string;
+        userSession: UserSession;
+    };
+    jwt?: boolean;
+    getSession?: (services: SingletonServices, token: string) => Promise<UserSession> | UserSession;
+}) => PikkuMiddleware;