@pikku/core 0.6.18 → 0.6.20

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## 0.6
 
+## 0.6.20
+
+### Patch Changes
+
+- 1d43a9a: feat: adding context to allow middleware to set values (not typed)
+
+## 0.6.19
+
+### Patch Changes
+
+- 9fb2b99: refactor: moving schemas to pikku state
+
 ## 0.6.18
 
 ### Patch Changes

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

@@ -16,7 +16,6 @@ export interface ErrorDetails {
     status: number;
     message: string;
 }
-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

@@ -13,14 +13,13 @@ export class PikkuError extends Error {
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
-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 }) => {
-    pikkuState('errors', 'errors').set(error, { status, message });
+    pikkuState('misc', 'errors').set(error, { status, message });
 };
 /**
  * Adds multiple errors to the API errors map.
@@ -37,10 +36,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 errors = Array.from(pikkuState('errors', 'errors').entries());
+    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('errors', 'errors').get(error);
+    return pikkuState('misc', 'errors').get(error);
 };

package/dist/handle-error.d.ts

@@ -11,4 +11,4 @@ import { PikkuHTTP } from './http/http-routes.types.js';
  * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
  * @param {boolean} bubbleError - Whether to throw the error after handling
  */
-export declare const handleError: (e: any, http: PikkuHTTP | undefined, trackerId: string, logger: Logger, logWarningsForStatusCodes: number[], respondWith404: boolean, bubbleError: boolean) => void;
+export declare const handleError: (e: any, http: PikkuHTTP | undefined, trackerId: string | undefined, logger: Logger, logWarningsForStatusCodes: number[], respondWith404: boolean, bubbleError: boolean) => void;

package/dist/handle-error.js

@@ -28,16 +28,20 @@ export const handleError = (e, http, trackerId, logger, logWarningsForStatusCode
         });
         // Log certain status codes as warnings
         if (logWarningsForStatusCodes.includes(errorResponse.status)) {
-            logger.warn(`Warning id: ${trackerId}`);
+            if (trackerId) {
+                logger.warn(`Warning id: ${trackerId}`);
+            }
             logger.warn(e);
         }
     }
     else {
         // Handle unexpected errors
-        logger.warn(`Error id: ${trackerId}`);
         logger.error(e);
         http?.response?.setStatus(500);
-        http?.response?.setJson({ errorId: trackerId });
+        if (trackerId) {
+            logger.warn(`Error id: ${trackerId}`);
+            http?.response?.setJson({ errorId: trackerId });
+        }
     }
     // Handle 404 errors specifically
     if (e instanceof NotFoundError) {

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

@@ -3,7 +3,6 @@ import { match } from 'path-to-regexp';
 import { PikkuHTTPAbstractRequest } from './pikku-http-abstract-request.js';
 import { PikkuHTTPAbstractResponse } from './pikku-http-abstract-response.js';
 import { ForbiddenError, MissingSessionError, NotFoundError, } from '../errors/errors.js';
-import crypto from 'crypto';
 import { closeSessionServices } from '../utils.js';
 import { coerceQueryStringToArray, validateSchema } from '../schema.js';
 import { LocalUserSessionService } from '../services/user-session-service.js';
@@ -111,7 +110,7 @@ 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 { singletonServices, userSessionService, context, createSessionServices, skipUserSession, } = services;
     const requiresSession = route.auth !== false;
     let sessionServices;
     let result;
@@ -132,8 +131,8 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             throw new MissingSessionError();
         }
         // Create session services
-        sessionServices = await createSessionServices(singletonServices, { http }, session);
-        const allServices = { ...singletonServices, ...sessionServices, http };
+        sessionServices = await createSessionServices({ ...singletonServices, context }, { http }, session);
+        const allServices = { ...singletonServices, ...sessionServices, context };
         const data = await http?.request?.getData();
         // Validate schema
         validateSchema(singletonServices.logger, singletonServices.schemaService, schemaName, data);
@@ -158,7 +157,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         http?.response?.end();
         return result;
     };
-    await runMiddleware({ ...singletonServices, userSessionService }, { http }, middleware, runMain);
+    await runMiddleware({ ...singletonServices, context, userSessionService }, { http }, middleware, runMain);
     return sessionServices ? { result, sessionServices } : { result };
 };
 /**
@@ -169,7 +168,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
  * @ignore
  */
 export const runHTTPRoute = async ({ singletonServices, request, response, createSessionServices, route: apiRoute, method: apiType, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceToArray = false, bubbleErrors = false, }) => {
-    const trackerId = crypto.randomUUID().toString();
+    const context = new Map();
     const userSessionService = new LocalUserSessionService();
     let sessionServices;
     let result;
@@ -192,6 +191,7 @@ export const runHTTPRoute = async ({ singletonServices, request, response, creat
         ({ result, sessionServices } = await executeRouteWithMiddleware({
             singletonServices,
             userSessionService,
+            context,
             createSessionServices,
             skipUserSession,
         }, matchedRoute, http, { coerceToArray }));
@@ -199,7 +199,7 @@ export const runHTTPRoute = async ({ singletonServices, request, response, creat
     }
     catch (e) {
         // Handle and possibly bubble the error
-        handleError(e, http, trackerId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        handleError(e, http, context.get('trackingId'), singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {
         // Clean up session services

package/dist/pikku-state.d.ts

@@ -20,8 +20,9 @@ interface PikkuState {
         tasks: Map<string, CoreScheduledTask>;
         meta: ScheduledTasksMeta;
     };
-    errors: {
+    misc: {
         errors: Map<PikkuError, ErrorDetails>;
+        schemas: Map<string, any>;
     };
 }
 export declare const resetPikkuState: () => void;

package/dist/pikku-state.js

@@ -13,9 +13,9 @@ export const resetPikkuState = () => {
             tasks: new Map(),
             meta: [],
         },
-        errors: {
-            // We keep errors since they are registered globally
-            errors: globalThis.pikkuState?.errors?.errors || new Map(),
+        misc: {
+            errors: globalThis.pikkuState?.misc?.errors || new Map(),
+            schemas: globalThis.pikkuState?.misc?.schema || new Map(),
         },
     };
 };

package/dist/scheduler/scheduler-runner.js

@@ -1,4 +1,3 @@
-import crypto from 'crypto';
 import { getErrorResponse } from '../errors/error-handler.js';
 import { closeSessionServices } from '../utils.js';
 import { pikkuState } from '../pikku-state.js';
@@ -16,7 +15,6 @@ class ScheduledTaskNotFoundError extends Error {
 }
 export async function runScheduledTask({ name, session, singletonServices, createSessionServices, }) {
     let sessionServices;
-    const trackerId = crypto.randomUUID().toString();
     try {
         const task = pikkuState('scheduler', 'tasks').get(name);
         if (!task) {
@@ -33,7 +31,6 @@ export async function runScheduledTask({ name, session, singletonServices, creat
     catch (e) {
         const errorResponse = getErrorResponse(e);
         if (errorResponse != null) {
-            singletonServices.logger.warn(`Error id: ${trackerId}`);
             singletonServices.logger.error(e);
         }
         throw e;

package/dist/schema.d.ts

@@ -1,15 +1,5 @@
 import { Logger } from './services/logger.js';
 import { SchemaService } from './services/schema-service.js';
-/**
- * Retrieves the global schemas map.
- * @returns A map of schemas.
- */
-export declare const getSchemas: () => any;
-/**
- * Retrieves a schema from the schemas map.
- * @returns A schema.
- */
-export declare const getSchema: (schemaName: string) => any;
 /**
  * Adds a schema to the global schemas map.
  * @param name - The name of the schema.

package/dist/schema.js

@@ -1,27 +1,5 @@
 import { UnprocessableContentError } from './errors/errors.js';
 import { pikkuState } from './pikku-state.js';
-/**
- * Retrieves the global schemas map.
- * @returns A map of schemas.
- */
-export const getSchemas = () => {
-    if (!global.pikkuSchemas) {
-        global.pikkuSchemas = new Map();
-    }
-    return global.pikkuSchemas;
-};
-/**
- * Retrieves a schema from the schemas map.
- * @returns A schema.
- */
-export const getSchema = (schemaName) => {
-    const schemas = getSchemas();
-    const schema = schemas.get(schemaName);
-    if (!schema) {
-        throw new Error(`Schema not found: ${schemaName}`);
-    }
-    return schema;
-};
 /**
  * Adds a schema to the global schemas map.
  * @param name - The name of the schema.
@@ -29,7 +7,7 @@ export const getSchema = (schemaName) => {
  * @ignore
  */
 export const addSchema = (name, value) => {
-    getSchemas().set(name, value);
+    pikkuState('misc', 'schemas').set(name, value);
 };
 /**
  * Loads a schema and compiles it into a validator.
@@ -39,7 +17,8 @@ export const compileAllSchemas = (logger, schemaService) => {
     if (!schemaService) {
         throw new Error('SchemaService needs to be defined to load schemas');
     }
-    for (const [name, schema] of getSchemas()) {
+    const schemas = pikkuState('misc', 'schemas');
+    for (const [name, schema] of schemas) {
         schemaService.compileSchema(name, schema);
     }
     validateAllSchemasLoaded(logger, schemaService);
@@ -64,7 +43,7 @@ const validateAllSchemasLoaded = (logger, schemaService) => {
     }
 };
 export const coerceQueryStringToArray = (schemaName, data) => {
-    const schema = getSchema(schemaName);
+    const schema = pikkuState('misc', 'schemas').get(schemaName);
     for (const key in schema.properties) {
         const property = schema.properties[key];
         if (typeof property === 'boolean') {
@@ -90,7 +69,7 @@ export const validateSchema = async (logger, schemaService, schemaName, data) =>
                 return;
             }
         }
-        const schema = getSchema(schemaName);
+        const schema = pikkuState('misc', 'schemas').get(schemaName);
         await schemaService.compileSchema(schemaName, schema);
         await schemaService.validateSchema(schemaName, data);
     }