@pikku/core 0.9.5 → 0.9.6

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

@@ -1,4 +1,4 @@
-import { match } from 'path-to-regexp';
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { MissingSessionError, NotFoundError } from '../../errors/errors.js';
 import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
 import { PikkuUserSessionService, } from '../../services/user-session-service.js';
@@ -9,6 +9,7 @@ import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
+import { httpRouter } from './routers/http-router.js';
 /**
  * Registers middleware either globally or for a specific route.
  *
@@ -22,25 +23,20 @@ import { rpcService } from '../rpc/rpc-runner.js';
  */
 export const addHTTPMiddleware = (routeOrMiddleware, middleware) => {
     const middlewareStore = pikkuState('http', 'middleware');
-    if (typeof routeOrMiddleware === 'string' && middleware) {
-        const route = routeOrMiddleware;
-        // Remove existing entry for this route if it exists
-        const existingIndex = middlewareStore.findIndex((item) => item.route === route);
-        if (existingIndex !== -1) {
-            middlewareStore.splice(existingIndex, 1);
-        }
-        middlewareStore.push({ route, middleware });
+    let route = '*';
+    if (typeof routeOrMiddleware === 'string') {
+        route = routeOrMiddleware;
+        middleware = middleware;
     }
     else {
-        // Handle global middleware
-        const existingIndex = middlewareStore.findIndex((item) => item.route === '*');
-        if (existingIndex !== -1) {
-            middlewareStore.splice(existingIndex, 1);
-        }
-        middlewareStore.push({
-            route: '*',
-            middleware: routeOrMiddleware,
-        });
+        middleware = routeOrMiddleware;
+    }
+    const currentMiddleware = middlewareStore.get(route);
+    if (currentMiddleware) {
+        middlewareStore.set(route, [...currentMiddleware, ...middleware]);
+    }
+    else {
+        middlewareStore.set(route, middleware);
     }
 };
 /**
@@ -60,7 +56,7 @@ export const addHTTPMiddleware = (routeOrMiddleware, middleware) => {
  */
 export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState('http', 'meta');
-    const routeMeta = httpMeta.find((meta) => meta.route === httpWiring.route && meta.method === httpWiring.method);
+    const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
@@ -85,37 +81,22 @@ export const wireHTTP = (httpWiring) => {
  * @returns {Object | undefined} An object with matched route details or undefined if no match.
  */
 const getMatchingRoute = (requestType, requestPath) => {
-    const allRoutes = pikkuState('http', 'routes');
-    const middleware = pikkuState('http', 'middleware');
-    const routes = allRoutes.get(requestType.toLowerCase());
-    if (!routes) {
-        return undefined;
-    }
-    for (const route of routes.values()) {
-        // Generate a matching function from the route pattern
-        const matchFunc = match(`/${route.route}`.replace(/^\/\//, '/'), {
-            decode: decodeURIComponent,
-        });
-        // Attempt to match the request path
-        const matchedPath = matchFunc(requestPath.replace(/^\/\//, '/'));
-        if (matchedPath) {
-            // Aggregate global and route-specific middleware
-            const globalMiddleware = middleware
-                .filter((m) => m.route === '*' || new RegExp(m.route).test(route.route))
-                .map((m) => m.middleware)
-                .flat();
-            const meta = pikkuState('http', 'meta').find((meta) => meta.route === route.route && meta.method === route.method);
-            return {
-                matchedPath,
-                params: matchedPath.params,
-                route,
-                permissions: route.permissions,
-                middleware: [...globalMiddleware, ...(route.middleware || [])],
-                meta: meta,
-            };
-        }
+    const matchedPath = httpRouter.match(requestType.toLowerCase(), requestPath);
+    if (matchedPath) {
+        const route = pikkuState('http', 'routes')
+            .get(requestType.toLowerCase())
+            .get(matchedPath.route);
+        const meta = pikkuState('http', 'meta')[requestType.toLowerCase()][route.route];
+        return {
+            matchedPath,
+            params: matchedPath.params,
+            route,
+            permissions: route.permissions,
+            httpMiddleware: matchedPath.middleware,
+            middleware: route.middleware,
+            meta: meta,
+        };
     }
-    return undefined;
 };
 /**
  * Combines the request and response objects into a single HTTP interaction object.
@@ -170,7 +151,7 @@ export const createHTTPInteraction = (request, response) => {
  * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRouteWithMiddleware = async (services, matchedRoute, http, options) => {
-    const { matchedPath, params, route, middleware, meta } = matchedRoute;
+    const { matchedPath, params, route, httpMiddleware, middleware, meta } = matchedRoute;
     const { singletonServices, userSession, createSessionServices, skipUserSession, requestId, } = services;
     const requiresSession = route.auth !== false;
     let sessionServices;
@@ -231,7 +212,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
                 channel,
             });
         };
-        result = await runPikkuFunc(meta.pikkuFuncName, {
+        result = await runPikkuFunc(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
             getAllServices,
             session,
             data,
@@ -253,7 +234,8 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
     // Get function config for middleware and tags
     const funcConfig = pikkuState('function', 'functions').get(meta.pikkuFuncName);
     // Execute middleware, then run the main logic
-    await runMiddleware({ ...singletonServices, userSession }, { http }, combineMiddleware({
+    await runMiddleware({ ...singletonServices, userSession }, { http }, combineMiddleware(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, {
+        httpMiddleware,
         wiringMiddleware: middleware,
         wiringTags: route.tags,
         funcMiddleware: funcConfig?.middleware,
@@ -350,7 +332,8 @@ export const fetchData = async (request, response, { singletonServices, createSe
         }, ignoreMiddleware
             ? {
                 ...matchedRoute,
-                middleware: [],
+                middleware: undefined,
+                httpMiddleware: undefined,
             }
             : matchedRoute, http, { coerceDataFromSchema }));
         return result;

package/dist/wirings/http/http.types.d.ts

@@ -147,7 +147,7 @@ export type HTTPWiringMeta = {
     tags?: string[];
     sse?: true;
 };
-export type HTTPWiringsMeta = Array<HTTPWiringMeta>;
+export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
 export type HTTPFunctionsMeta = Array<{
     name: string;
     inputs: string[] | null;

package/dist/wirings/http/pikku-fetch-http-request.js

@@ -48,6 +48,9 @@ export class PikkuFetchHTTPRequest {
      * @returns An object containing the cookies.
      */
     cookie(cookieName) {
+        if (this.#cookies?.[cookieName]) {
+            return this.#cookies[cookieName];
+        }
         const cookieHeader = this.header('cookie');
         this.#cookies = cookieHeader ? parseCookie(cookieHeader) : {};
         return this.#cookies[cookieName] || null;

package/dist/wirings/http/routers/http-router.d.ts

@@ -0,0 +1,12 @@
+import { CorePikkuMiddleware } from '../../../types/core.types.js';
+import { HTTPMethod } from '../http.types.js';
+import { PathToRegexRouter } from './path-to-regex.js';
+export type MatchResult = {
+    route: string;
+    params: Record<string, any>;
+    middleware?: CorePikkuMiddleware[];
+} | null;
+export interface Router {
+    match(method: HTTPMethod, path: string): MatchResult;
+}
+export declare const httpRouter: PathToRegexRouter;

package/dist/wirings/http/routers/http-router.js

@@ -0,0 +1,2 @@
+import { PathToRegexRouter } from './path-to-regex.js';
+export const httpRouter = new PathToRegexRouter();

package/dist/wirings/http/routers/path-to-regex.d.ts

@@ -0,0 +1,10 @@
+import { MatchResult, Router } from './http-router.js';
+import { HTTPMethod } from '../http.types.js';
+export declare class PathToRegexRouter implements Router {
+    private compiledRoutes;
+    private staticRoutes;
+    private precompiledMiddleware;
+    private isInitialized;
+    initialize(): void;
+    match(method: HTTPMethod, path: string): MatchResult;
+}

package/dist/wirings/http/routers/path-to-regex.js

@@ -0,0 +1,118 @@
+import { match } from 'path-to-regexp';
+import { pikkuState } from '../../../pikku-state.js';
+export class PathToRegexRouter {
+    compiledRoutes = new Map();
+    staticRoutes = new Map();
+    precompiledMiddleware = new Map();
+    isInitialized = false;
+    initialize() {
+        const routes = pikkuState('http', 'routes');
+        const channelRoutes = pikkuState('channel', 'channels');
+        const middlewareMap = pikkuState('http', 'middleware');
+        // Precompile middleware lookups
+        for (const [middlewareRoute, middlewareArray] of middlewareMap.entries()) {
+            this.precompiledMiddleware.set(middlewareRoute, middlewareArray);
+        }
+        // Helper function to compile routes for a given method
+        const compileRoutesForMethod = (method, routeEntries) => {
+            const methodCompiledRoutes = this.compiledRoutes.get(method) || new Map();
+            const methodStaticRoutes = this.staticRoutes.get(method) || new Map();
+            for (const [routePath] of routeEntries) {
+                // Normalize route path - ensure it starts with /
+                const normalizedRoutePath = routePath.startsWith('/')
+                    ? routePath
+                    : `/${routePath}`;
+                // Check if route is static (no parameters or wildcards)
+                const isStaticRoute = !/\*|:/.test(normalizedRoutePath);
+                // Precompute middleware for this route
+                const routeMiddleware = [];
+                // Add global middleware (*)
+                const globalMiddleware = this.precompiledMiddleware.get('*');
+                if (globalMiddleware) {
+                    routeMiddleware.push(...globalMiddleware);
+                }
+                // Add route-specific middleware
+                for (const [middlewareRoute, middlewareArray,] of this.precompiledMiddleware.entries()) {
+                    if (middlewareRoute !== '*') {
+                        // Use regex test for pattern matching
+                        try {
+                            if (new RegExp(middlewareRoute).test(normalizedRoutePath)) {
+                                routeMiddleware.push(...middlewareArray);
+                            }
+                        }
+                        catch {
+                            // If regex is invalid, do exact match
+                            if (middlewareRoute === normalizedRoutePath) {
+                                routeMiddleware.push(...middlewareArray);
+                            }
+                        }
+                    }
+                }
+                if (isStaticRoute) {
+                    // Store static routes for O(1) lookup
+                    methodStaticRoutes.set(normalizedRoutePath, {
+                        route: routePath, // Keep the original route path for lookup in pikkuState
+                        middleware: routeMiddleware,
+                    });
+                }
+                else {
+                    // Compile dynamic routes with path-to-regexp
+                    const matcher = match(normalizedRoutePath, {
+                        decode: decodeURIComponent,
+                    });
+                    methodCompiledRoutes.set(normalizedRoutePath, {
+                        matcher,
+                        route: routePath, // Keep the original route path for lookup in pikkuState
+                        middleware: routeMiddleware,
+                    });
+                }
+            }
+            this.compiledRoutes.set(method, methodCompiledRoutes);
+            this.staticRoutes.set(method, methodStaticRoutes);
+        };
+        // Precompile all HTTP route matchers
+        for (const [method, routeMap] of routes.entries()) {
+            compileRoutesForMethod(method, routeMap.entries());
+        }
+        // Precompile all channel route matchers (treating them as GET routes for WebSocket upgrades)
+        const channelRoutesArray = Array.from(channelRoutes.entries()).map(([, channel]) => [channel.route, channel]);
+        compileRoutesForMethod('get', channelRoutesArray);
+        this.isInitialized = true;
+    }
+    match(method, path) {
+        if (!this.isInitialized) {
+            this.initialize();
+        }
+        // Normalize path - ensure it starts with /
+        const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+        // First, try static routes for O(1) lookup
+        const methodStaticRoutes = this.staticRoutes.get(method);
+        if (methodStaticRoutes) {
+            const staticRoute = methodStaticRoutes.get(normalizedPath);
+            if (staticRoute) {
+                return {
+                    route: staticRoute.route,
+                    params: {},
+                    middleware: staticRoute.middleware,
+                };
+            }
+        }
+        // If no static route matched, try dynamic routes
+        const methodRoutes = this.compiledRoutes.get(method);
+        if (!methodRoutes) {
+            return null;
+        }
+        // Try each compiled route for this method
+        for (const [, compiledRoute] of methodRoutes.entries()) {
+            const result = compiledRoute.matcher(normalizedPath);
+            if (result) {
+                return {
+                    route: compiledRoute.route,
+                    params: result.params,
+                    middleware: compiledRoute.middleware,
+                };
+            }
+        }
+        return null;
+    }
+}

package/dist/wirings/mcp/mcp-runner.d.ts

@@ -1,4 +1,4 @@
-import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../../types/core.types.js';
+import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateSessionServices } from '../../types/core.types.js';
 import type { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
 import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export declare class MCPError extends Error {

package/dist/wirings/mcp/mcp-runner.js

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { getErrorResponse } from '../../errors/error-handler.js';
 import { closeSessionServices } from '../../utils.js';
 import { pikkuState } from '../../pikku-state.js';
@@ -132,7 +133,7 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { sessio
                     mcp: interaction,
                 });
             };
-            result = await runPikkuFunc(pikkuFuncName, {
+            result = await runPikkuFunc(PikkuWiringTypes.mcp, `${type}:${name}`, pikkuFuncName, {
                 getAllServices,
                 session,
                 data: request.params,
@@ -140,7 +141,7 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { sessio
             });
         };
         const funcConfig = pikkuState('function', 'functions').get(pikkuFuncName);
-        await runMiddleware(singletonServices, { mcp: interaction }, combineMiddleware({
+        await runMiddleware(singletonServices, { mcp: interaction }, combineMiddleware(PikkuWiringTypes.mcp, `${type}:${name}`, {
             wiringMiddleware: mcp.middleware,
             wiringTags: mcp.tags,
             funcMiddleware: funcConfig?.middleware,

package/dist/wirings/queue/queue-runner.js

@@ -1,6 +1,7 @@
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
 /**
  * Error class for queue processor not found
@@ -106,7 +107,7 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
                     : {}),
             });
             // Execute the pikku function with the job data
-            result = await runPikkuFunc(processorMeta.pikkuFuncName, {
+            result = await runPikkuFunc(PikkuWiringTypes.queue, job.queueName, processorMeta.pikkuFuncName, {
                 getAllServices,
                 data: job.data,
                 tags: queueWorker.tags,
@@ -116,7 +117,7 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
         // Get function config for middleware and tags
         const funcConfig = pikkuState('function', 'functions').get(processorMeta.pikkuFuncName);
         // Get middleware for tags and combine with queue-specific middleware
-        await runMiddleware(singletonServices, { queue }, combineMiddleware({
+        await runMiddleware(singletonServices, { queue }, combineMiddleware(PikkuWiringTypes.queue, `${job.queueName}:${job.id}`, {
             wiringMiddleware: queueWorker.middleware,
             wiringTags: queueWorker.tags,
             funcMiddleware: funcConfig?.middleware,

package/dist/wirings/rpc/rpc-runner.js

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes } from '../../types/core.types.js';
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { ForbiddenError } from '../../errors/errors.js';
@@ -31,7 +32,7 @@ class ContextAwareRPCService {
         const session = await this.services.userSession?.get();
         const rpcDepth = this.services.rpc?.depth || 0;
         const pikkuFuncName = getPikkuFunctionName(funcName);
-        return runPikkuFunc(pikkuFuncName, {
+        return runPikkuFunc(PikkuWiringTypes.rpc, pikkuFuncName, pikkuFuncName, {
             getAllServices: () => {
                 this.services.rpc = this.services.rpc
                     ? {

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

@@ -1,4 +1,4 @@
-import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../../types/core.types.js';
+import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateSessionServices } from '../../types/core.types.js';
 import type { CoreScheduledTask } from './scheduler.types.js';
 import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export type RunScheduledTasksParams = {

package/dist/wirings/scheduler/scheduler-runner.js

@@ -1,3 +1,4 @@
+import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js';
 import { closeSessionServices } from '../../utils.js';
 import { pikkuState } from '../../pikku-state.js';
@@ -63,7 +64,7 @@ export async function runScheduledTask({ name, session, singletonServices, creat
                 }
                 return singletonServices;
             };
-            result = await runPikkuFunc(meta.pikkuFuncName, {
+            result = await runPikkuFunc(PikkuWiringTypes.scheduler, meta.name, meta.pikkuFuncName, {
                 getAllServices,
                 session,
                 data: undefined,
@@ -71,7 +72,7 @@ export async function runScheduledTask({ name, session, singletonServices, creat
             });
         };
         const funcConfig = pikkuState('function', 'functions').get(meta.pikkuFuncName);
-        await runMiddleware(singletonServices, { scheduledTask }, combineMiddleware({
+        await runMiddleware(singletonServices, { scheduledTask }, combineMiddleware(PikkuWiringTypes.scheduler, meta.name, {
             wiringMiddleware: task.middleware,
             wiringTags: task.tags,
             funcMiddleware: funcConfig?.middleware,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",

package/src/factory-functions.test.ts

@@ -0,0 +1,37 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { pikkuPermission, pikkuMiddleware } from './index.js'
+
+test('pikkuPermission factory function', async () => {
+  const permission = pikkuPermission(async ({ logger }, data, session) => {
+    return true
+  })
+
+  assert.strictEqual(typeof permission, 'function')
+  assert.strictEqual(permission.length, 3) // services, data, session
+})
+
+test('pikkuMiddleware factory function', async () => {
+  const middleware = pikkuMiddleware(async ({ logger }, interactions, next) => {
+    await next()
+  })
+
+  assert.strictEqual(typeof middleware, 'function')
+  assert.strictEqual(middleware.length, 3) // services, interactions, next
+})
+
+test('pikkuPermission returns the same function', async () => {
+  const originalFn = async ({ logger }, data, session) => true
+  const wrappedFn = pikkuPermission(originalFn)
+
+  assert.strictEqual(wrappedFn, originalFn)
+})
+
+test('pikkuMiddleware returns the same function', async () => {
+  const originalFn = async ({ logger }, interactions, next) => {
+    await next()
+  }
+  const wrappedFn = pikkuMiddleware(originalFn)
+
+  assert.strictEqual(wrappedFn, originalFn)
+})