@pikku/core 0.6.16 → 0.6.17

package/dist/middleware/auth-bearer.js

@@ -0,0 +1,40 @@
+import { InvalidSessionError } from '../errors/errors.js';
+/**
+ * Extracts the Bearer token from the Authorization header
+ */
+export const authBearer = ({ token, jwt, getSession, } = {}) => {
+    const middleware = async (services, { http }, next) => {
+        // Skip if session already exists.
+        if (!http?.request || services.userSession.get()) {
+            return next();
+        }
+        const authHeader = http.request.getHeader('authorization') ||
+            http.request.getHeader('Authorization');
+        if (authHeader) {
+            const [scheme, bearerToken] = authHeader.split(' ');
+            if (scheme !== 'Bearer' || !token || !bearerToken) {
+                throw new InvalidSessionError();
+            }
+            let userSession = null;
+            if (jwt) {
+                if (!services.jwt) {
+                    throw new Error('JWT service is required for JWT decoding.');
+                }
+                userSession = await services.jwt.decode(bearerToken);
+            }
+            else if (token) {
+                if (bearerToken === token.value) {
+                    userSession = token.userSession;
+                }
+            }
+            else if (getSession) {
+                userSession = await getSession(services, token);
+            }
+            if (userSession) {
+                await services.userSession.set(userSession);
+            }
+        }
+        return next();
+    };
+    return middleware;
+};

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

@@ -0,0 +1,16 @@
+import { CoreConfig, CoreSingletonServices, CoreUserSession, PikkuMiddleware } from '../types/core.types.js';
+/**
+ * Cookie middleware that extracts a session from cookies.
+ *
+ * @param options.cookieNames - List of cookie names to check.
+ * @param options.getSessionForCookieValue - Function to retrieve a session using a cookie value.
+ */
+export declare const authCookie: <SingletonServices extends CoreSingletonServices<CoreConfig>, UserSession extends CoreUserSession>({ cookieNames, getSessionForCookieValue, jwt, }: {
+    cookieNames: string[];
+} & ({
+    getSessionForCookieValue: (services: SingletonServices, cookieValue: string, cookieName: string) => Promise<UserSession>;
+    jwt?: false;
+} | {
+    getSessionForCookieValue?: undefined;
+    jwt: true;
+})) => PikkuMiddleware;

package/dist/middleware/auth-cookie.js

@@ -0,0 +1,43 @@
+/**
+ * Cookie middleware that extracts a session from cookies.
+ *
+ * @param options.cookieNames - List of cookie names to check.
+ * @param options.getSessionForCookieValue - Function to retrieve a session using a cookie value.
+ */
+export const authCookie = ({ cookieNames, getSessionForCookieValue, jwt, }) => {
+    const middleware = async (services, { http }, next) => {
+        if (!http?.request || services.userSession.get()) {
+            return next();
+        }
+        const cookies = http.request.getCookies();
+        if (cookies) {
+            let cookieName;
+            for (const name of cookieNames) {
+                if (cookies[name]) {
+                    cookieName = name;
+                    break;
+                }
+            }
+            if (cookieName) {
+                let userSession = 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, cookieValue, cookieName);
+                    }
+                    if (userSession) {
+                        await services.userSession.set(userSession);
+                    }
+                }
+            }
+        }
+        return next();
+    };
+    return middleware;
+};

package/dist/middleware/index.d.ts

@@ -1,4 +1,3 @@
-export * from './auth-api-key.js';
-export * from './auth-cookie-middleware.js';
-export * from './auth-jwt-middleware.js';
-export * from './auth-query-middleware.js';
+export * from './auth-apikey.js';
+export * from './auth-cookie.js';
+export * from './auth-bearer.js';

package/dist/middleware/index.js

@@ -1,4 +1,3 @@
-export * from './auth-api-key.js';
-export * from './auth-cookie-middleware.js';
-export * from './auth-jwt-middleware.js';
-export * from './auth-query-middleware.js';
+export * from './auth-apikey.js';
+export * from './auth-cookie.js';
+export * from './auth-bearer.js';

package/dist/middleware/timeout.d.ts

@@ -0,0 +1,2 @@
+import { PikkuMiddleware } from '../types/core.types.js';
+export declare const timeout: (timeout: number) => PikkuMiddleware;

package/dist/middleware/timeout.js

@@ -0,0 +1,10 @@
+import { RequestTimeoutError } from '../errors/errors.js';
+export const timeout = (timeout) => {
+    const middleware = async (_services, _interaction, next) => {
+        setTimeout(() => {
+            throw new RequestTimeoutError();
+        }, timeout);
+        await next();
+    };
+    return middleware;
+};

package/dist/middleware-runner.d.ts

@@ -18,5 +18,5 @@ import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './type
  * );
  */
 export declare const runMiddleware: (services: CoreSingletonServices & {
-    userSessionService: UserSessionService<any>;
+    userSession: UserSessionService<any>;
 }, interaction: PikkuInteraction, middlewares: PikkuMiddleware[], main?: () => Promise<void>) => Promise<void>;

package/dist/pikku-state.d.ts

@@ -0,0 +1,29 @@
+import { ChannelsMeta, CoreAPIChannels } from './channel/channel.types.js';
+import { CoreHTTPFunctionRoutes, HTTPRoutesMeta } from './http/http-routes.types.js';
+import { PikkuMiddleware } from './types/core.types.js';
+import { CoreScheduledTask, ScheduledTasksMeta } from './scheduler/scheduler.types.js';
+import { ErrorDetails, PikkuError } from './errors/error-handler.js';
+interface PikkuState {
+    http: {
+        middleware: Array<{
+            route: string;
+            middleware: PikkuMiddleware[];
+        }>;
+        routes: CoreHTTPFunctionRoutes;
+        meta: HTTPRoutesMeta;
+    };
+    channel: {
+        channels: CoreAPIChannels;
+        meta: ChannelsMeta;
+    };
+    scheduler: {
+        tasks: Map<string, CoreScheduledTask>;
+        meta: ScheduledTasksMeta;
+    };
+    errors: {
+        errors: Map<PikkuError, ErrorDetails>;
+    };
+}
+export declare const resetPikkuState: () => void;
+export declare const pikkuState: <Type extends keyof PikkuState, Content extends keyof PikkuState[Type]>(type: Type, content: Content, value?: PikkuState[Type][Content]) => PikkuState[Type][Content];
+export {};

package/dist/pikku-state.js

@@ -0,0 +1,30 @@
+export const resetPikkuState = () => {
+    globalThis.pikkuState = {
+        http: {
+            middleware: [],
+            routes: [],
+            meta: [],
+        },
+        channel: {
+            channels: [],
+            meta: [],
+        },
+        scheduler: {
+            tasks: new Map(),
+            meta: [],
+        },
+        errors: {
+            // We keep errors since they are registered globally
+            errors: globalThis.pikkuState?.errors?.errors || new Map(),
+        },
+    };
+};
+if (!globalThis.pikkuState) {
+    resetPikkuState();
+}
+export const pikkuState = (type, content, value) => {
+    if (value) {
+        globalThis.pikkuState[type][content] = value;
+    }
+    return globalThis.pikkuState[type][content];
+};

package/dist/scheduler/index.d.ts

@@ -1,3 +1,3 @@
 export * from './scheduler.types.js';
-export { runScheduledTask, getScheduledTasks, addScheduledTask, clearScheduledTasks, setScheduledTasksMeta, } from './scheduler-runner.js';
+export { runScheduledTask, addScheduledTask } from './scheduler-runner.js';
 export * from './log-schedulers.js';

package/dist/scheduler/index.js

@@ -1,3 +1,3 @@
 export * from './scheduler.types.js';
-export { runScheduledTask, getScheduledTasks, addScheduledTask, clearScheduledTasks, setScheduledTasksMeta, } from './scheduler-runner.js';
+export { runScheduledTask, addScheduledTask } from './scheduler-runner.js';
 export * from './log-schedulers.js';

package/dist/scheduler/log-schedulers.js

@@ -1,10 +1,10 @@
-import { getScheduledTasks } from './scheduler-runner.js';
+import { pikkuState } from '../pikku-state.js';
 /**
  * Logs all the loaded scheduled tasks.
  * @param logger - A logger for logging information.
  */
 export const logSchedulers = (logger) => {
-    const { scheduledTasks } = getScheduledTasks();
+    const scheduledTasks = pikkuState('scheduler', 'tasks');
     if (scheduledTasks.size === 0) {
         logger.info('No scheduled tasks added');
         return;

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

@@ -1,5 +1,5 @@
 import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../types/core.types.js';
-import type { CoreScheduledTask, ScheduledTasksMeta } from './scheduler.types.js';
+import type { CoreScheduledTask } from './scheduler.types.js';
 import type { CoreAPIFunctionSessionless } from '../types/functions.types.js';
 export type RunScheduledTasksParams = {
     name: string;
@@ -8,14 +8,4 @@ export type RunScheduledTasksParams = {
     createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export declare const addScheduledTask: <APIFunction extends CoreAPIFunctionSessionless<void, void>>(scheduledTask: CoreScheduledTask<APIFunction>) => void;
-export declare const clearScheduledTasks: () => void;
-export declare const setScheduledTasksMeta: (_scheduledTasksMeta: ScheduledTasksMeta) => void;
-/**
- * Returns all the cron jobs
- * @internal
- */
-export declare const getScheduledTasks: () => {
-    scheduledTasks: Map<string, CoreScheduledTask>;
-    scheduledTasksMeta: any;
-};
 export declare function runScheduledTask<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession, Services extends CoreServices<SingletonServices> = CoreServices<SingletonServices>>({ name, session, singletonServices, createSessionServices, }: RunScheduledTasksParams): Promise<void>;

package/dist/scheduler/scheduler-runner.js

@@ -1,41 +1,13 @@
 import crypto from 'crypto';
 import { getErrorResponse } from '../errors/error-handler.js';
 import { closeSessionServices } from '../utils.js';
-if (!global.pikku?.scheduledTasks) {
-    global.pikku = global.pikku || {};
-    global.pikku.scheduledTasks = new Map();
-    global.pikku.scheduledTasksMeta = [];
-}
-const scheduledTasks = () => {
-    return global.pikku.scheduledTasks;
-};
-const scheduledTasksMeta = (data) => {
-    if (data) {
-        global.pikku.scheduledTasksMeta = data;
-    }
-    return global.pikku.scheduledTasksMeta;
-};
+import { pikkuState } from '../pikku-state.js';
 export const addScheduledTask = (scheduledTask) => {
-    if (scheduledTasks().has(scheduledTask.name)) {
+    const tasks = pikkuState('scheduler', 'tasks');
+    if (tasks.has(scheduledTask.name)) {
         throw new Error(`Scheduled task already exists: ${scheduledTask.name}`);
     }
-    scheduledTasks().set(scheduledTask.name, scheduledTask);
-};
-export const clearScheduledTasks = () => {
-    scheduledTasks().clear();
-};
-export const setScheduledTasksMeta = (_scheduledTasksMeta) => {
-    scheduledTasksMeta(_scheduledTasksMeta);
-};
-/**
- * Returns all the cron jobs
- * @internal
- */
-export const getScheduledTasks = () => {
-    return {
-        scheduledTasks: scheduledTasks(),
-        scheduledTasksMeta: scheduledTasksMeta(),
-    };
+    tasks.set(scheduledTask.name, scheduledTask);
 };
 class ScheduledTaskNotFoundError extends Error {
     constructor(title) {
@@ -46,7 +18,7 @@ export async function runScheduledTask({ name, session, singletonServices, creat
     let sessionServices;
     const trackerId = crypto.randomUUID().toString();
     try {
-        const task = scheduledTasks().get(name);
+        const task = pikkuState('scheduler', 'tasks').get(name);
         if (!task) {
             throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`);
         }

package/dist/schema.js

@@ -1,5 +1,5 @@
-import { getRoutes } from './http/http-route-runner.js';
 import { UnprocessableContentError } from './errors/errors.js';
+import { pikkuState } from './pikku-state.js';
 /**
  * Retrieves the global schemas map.
  * @returns A map of schemas.
@@ -45,7 +45,7 @@ export const compileAllSchemas = (logger, schemaService) => {
     validateAllSchemasLoaded(logger, schemaService);
 };
 const validateAllSchemasLoaded = (logger, schemaService) => {
-    const { routesMeta } = getRoutes();
+    const routesMeta = pikkuState('http', 'meta');
     const validators = schemaService.getSchemaNames();
     const missingSchemas = [];
     for (const route of routesMeta) {

package/dist/services/jwt-service.d.ts

@@ -1,9 +1,7 @@
-import { CoreUserSession } from '../types/core.types.js';
 /**
  * Interface for handling JSON Web Tokens (JWT).
- * @template UserSession - The type of the user session.
  */
-export interface JWTService<UserSession = CoreUserSession> {
+export interface JWTService {
     /**
      * Encodes a payload into a JWT.
      * @param expiresIn - The expiration time of the token.
@@ -19,11 +17,4 @@ export interface JWTService<UserSession = CoreUserSession> {
      * @returns A promise that resolves to the decoded payload.
      */
     decode: <T>(hash: string, invalidHashError?: Error, debug?: boolean) => Promise<T>;
-    /**
-     * Decodes a user session from a JWT.
-     * @param jwtToken - The JWT representing the user session.
-     * @param debug - An optional flag for debugging.
-     * @returns A promise that resolves to the decoded user session.
-     */
-    decodeSession: (jwtToken: string, debug?: any) => Promise<UserSession>;
 }

package/dist/services/user-session-service.d.ts

@@ -17,7 +17,7 @@ export declare class RemoteUserSessionService<UserSession extends CoreUserSessio
     private channelId;
     session: UserSession | undefined;
     constructor(channelStore: ChannelStore<unknown, unknown, UserSession>, channelId: string, session?: UserSession | undefined);
-    set(session: UserSession): Promise<void>;
-    clear(): Promise<void>;
+    set(session: UserSession): void | Promise<void>;
+    clear(): void | Promise<void>;
     get(): Promise<UserSession | undefined>;
 }

package/dist/services/user-session-service.js

@@ -22,14 +22,14 @@ export class RemoteUserSessionService {
         this.channelId = channelId;
         this.session = session;
     }
-    async set(session) {
-        await this.channelStore.setUserSession(this.channelId, session);
+    set(session) {
+        return this.channelStore.setUserSession(this.channelId, session);
     }
-    async clear() {
-        await this.channelStore.setUserSession(this.channelId, undefined);
+    clear() {
+        return this.channelStore.setUserSession(this.channelId, null);
     }
     async get() {
-        const channel = await this.channelStore.getChannel(this.channelId);
-        return channel.userSession;
+        const { session } = await this.channelStore.getChannelAndSession(this.channelId);
+        return session;
     }
 }

package/dist/types/core.types.d.ts

@@ -48,9 +48,9 @@ export interface CoreUserSession {
 /**
  * Interface for core singleton services provided by Pikku.
  */
-export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig, UserSession extends CoreUserSession = CoreUserSession> {
+export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     /** JWT Service */
-    jwt?: JWTService<UserSession>;
+    jwt?: JWTService;
     /** The schema library used to validate data */
     schemaService?: SchemaService;
     /** The core configuration for the application. */
@@ -74,7 +74,7 @@ export interface PikkuInteraction {
  * A function that can wrap an interaction and be called before or after
  */
 export type PikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
-    userSessionService: UserSessionService<UserSession>;
+    userSession: UserSessionService<UserSession>;
 }, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
 /**
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.