@pikku/core 0.9.2 → 0.9.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## 0.9.0
 
+## 0.9.4
+
+### Patch Changes
+
+- c18800d: feat: adding queue and scheduledTask to interactions
+
+## 0.9.3
+
+### Patch Changes
+
+- 9691aba: fix: add-functions should support both functions only and objects
+- 2ab0278: refactor: no longer import ALL functions, only the ones used by rpcs
+- 81005ba: feat: creating a smaller meta file for functions to reduce size
+
 ## 0.9.2
 
 ### Patch Changes

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

@@ -1,12 +1,13 @@
 import { CoreServices, CoreUserSession, CorePikkuMiddleware } from '../types/core.types.js';
-import { CorePermissionGroup, CorePikkuFunctionConfig } from './functions.types.js';
-export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any>) => void;
+import { CorePermissionGroup, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from './functions.types.js';
+export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<any, any> | CorePikkuFunctionSessionless<any, any> | CorePikkuFunction<any, any>) => void;
 export declare const runPikkuFuncDirectly: <In, Out>(funcName: string, allServices: CoreServices, data: In, session?: CoreUserSession) => Promise<Out>;
-export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }: {
+export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, tags, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;
     permissions?: CorePermissionGroup;
     middleware?: CorePikkuMiddleware[];
     coerceDataFromSchema?: boolean;
+    tags?: string[];
 }) => Promise<Out>;

package/dist/function/function-runner.js

@@ -1,9 +1,12 @@
 import { ForbiddenError } from '../errors/errors.js';
 import { runMiddleware } from '../middleware-runner.js';
-import { verifyPermissions } from '../permissions.js';
+import { verifyPermissions, getPermissionsForTags } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 export const addFunction = (funcName, funcConfig) => {
+    if (funcConfig instanceof Function) {
+        funcConfig = { func: funcConfig };
+    }
     pikkuState('function', 'functions').set(funcName, funcConfig);
 };
 export const runPikkuFuncDirectly = async (funcName, allServices, data, session) => {
@@ -13,7 +16,7 @@ export const runPikkuFuncDirectly = async (funcName, allServices, data, session)
     }
     return (await funcConfig.func(allServices, data, session));
 };
-export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, }) => {
+export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, middleware: transportMiddleware, coerceDataFromSchema, tags = [], }) => {
     const funcConfig = pikkuState('function', 'functions').get(funcName);
     if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
@@ -26,17 +29,27 @@ export const runPikkuFunc = async (funcName, { getAllServices, data, session, pe
         throw new ForbiddenError(`Function ${funcName} requires authentication even though transport does not`);
     }
     const allServices = await getAllServices();
-    const schemaName = funcMeta.schemaName;
-    if (schemaName) {
+    const inputSchemaName = funcMeta.inputSchemaName;
+    if (inputSchemaName) {
         // Validate request data against the defined schema, if any
-        await validateSchema(allServices.logger, allServices.schema, schemaName, data);
+        await validateSchema(allServices.logger, allServices.schema, inputSchemaName, data);
         // Coerce (top level) query string parameters or date objects if specified by the schema
         if (coerceDataFromSchema) {
-            coerceTopLevelDataFromSchema(schemaName, data);
+            coerceTopLevelDataFromSchema(inputSchemaName, data);
         }
     }
     let permissioned = true;
-    if (funcConfig.permissions) {
+    // Check tagged permissions first - ALL must pass
+    const taggedPermissions = getPermissionsForTags([
+        ...tags,
+        ...(funcConfig.tags || []),
+    ]);
+    if (taggedPermissions.length > 0) {
+        const taggedResults = await Promise.all(taggedPermissions.map((permission) => permission(allServices, data, session)));
+        permissioned = taggedResults.every((result) => result);
+    }
+    // Only check function permissions if tagged permissions passed
+    if (permissioned && funcConfig.permissions) {
         permissioned = await verifyPermissions(funcConfig.permissions, allServices, data, session);
     }
     if (!permissioned && transportPermissions) {

package/dist/function/functions.types.d.ts

@@ -35,12 +35,13 @@ export type CorePikkuFunctionSessionless<In, Out, ChannelData extends unknown |
  */
 export type CorePikkuPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
 export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
-export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>> = {
+export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any> = CorePikkuMiddleware<any>> = {
     name?: string;
     expose?: boolean;
     func: PikkuFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;
-    middleware?: CorePikkuMiddleware[];
+    middleware?: PikkuMiddleware[];
+    tags?: string[];
     docs?: PikkuDocs;
 };

package/dist/index.d.ts

@@ -21,7 +21,8 @@ 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 { runMiddleware, addMiddleware, addMiddlewareForTags, } from './middleware-runner.js';
+export { addPermission, getPermissionsForTags } from './permissions.js';
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';

package/dist/index.js

@@ -21,7 +21,8 @@ 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 { runMiddleware, addMiddleware, addMiddlewareForTags, } from './middleware-runner.js';
+export { addPermission, getPermissionsForTags } from './permissions.js';
 export { wireHTTP, addHTTPMiddleware } from './wirings/http/http-runner.js';
 export { wireChannel } from './wirings/channel/channel-runner.js';
 export { wireScheduler } from './wirings/scheduler/scheduler-runner.js';

package/dist/middleware-runner.d.ts

@@ -20,3 +20,65 @@ import { CoreSingletonServices, PikkuInteraction, CorePikkuMiddleware } from './
 export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(services: CoreSingletonServices & {
     userSession?: UserSessionService<any>;
 }, interaction: PikkuInteraction, middlewares: Middleware[], main?: () => Promise<unknown>) => Promise<unknown>;
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @template PikkuMiddleware The middleware type.
+ * @param {string} tag - The tag that the middleware should apply to.
+ * @param {PikkuMiddleware[]} middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws {Error} If middleware for the tag already exists.
+ *
+ * @example
+ * ```typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * ```
+ */
+export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(tag: string, middleware: PikkuMiddleware[]) => void;
+/**
+ * Retrieves middleware for a given set of tags.
+ *
+ * This function looks up all middleware registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Array of middleware functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all middleware for tags 'api' and 'auth'
+ * const middleware = getMiddlewareForTags(['api', 'auth'])
+ * ```
+ */
+export declare const getMiddlewareForTags: (tags?: string[]) => CorePikkuMiddleware[];
+/**
+ * Combines tag-based middleware with wiring-specific middleware.
+ *
+ * This helper function gets middleware for tags and combines it with any
+ * wiring-specific middleware, avoiding the need for manual spreading.
+ *
+ * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
+ *
+ * @example
+ * ```typescript
+ * // Instead of:
+ * const taggedMiddleware = getMiddlewareForTags(tags)
+ * const combined = [...taggedMiddleware, ...(middleware || [])]
+ *
+ * // Use:
+ * const combined = addMiddlewareForTags(middleware, tags)
+ * ```
+ */
+export declare const addMiddlewareForTags: (wiringMiddleware?: CorePikkuMiddleware[], tags?: string[]) => CorePikkuMiddleware[];

package/dist/middleware-runner.js

@@ -1,3 +1,4 @@
+import { pikkuState } from './pikku-state.js';
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
  *
@@ -16,10 +17,12 @@
  * );
  */
 export const runMiddleware = async (services, interaction, middlewares, main) => {
+    // Deduplicate middleware using Set to avoid running the same middleware multiple times
+    const uniqueMiddleware = Array.from(new Set(middlewares));
     let result;
     const dispatch = async (index) => {
-        if (middlewares && index < middlewares.length) {
-            return await middlewares[index](services, interaction, () => dispatch(index + 1));
+        if (uniqueMiddleware && index < uniqueMiddleware.length) {
+            return await uniqueMiddleware[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
             result = await main();
@@ -28,3 +31,89 @@ export const runMiddleware = async (services, interaction, middlewares, main) =>
     await dispatch(0);
     return result;
 };
+/**
+ * Adds global middleware for a specific tag.
+ *
+ * This function allows you to register middleware that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @template PikkuMiddleware The middleware type.
+ * @param {string} tag - The tag that the middleware should apply to.
+ * @param {PikkuMiddleware[]} middleware - The middleware array to apply for the specified tag.
+ *
+ * @throws {Error} If middleware for the tag already exists.
+ *
+ * @example
+ * ```typescript
+ * // Add admin middleware for admin endpoints
+ * addMiddleware('admin', [adminMiddleware])
+ *
+ * // Add authentication middleware for auth endpoints
+ * addMiddleware('auth', [authMiddleware])
+ *
+ * // Add logging middleware for all API endpoints
+ * addMiddleware('api', [loggingMiddleware])
+ * ```
+ */
+export const addMiddleware = (tag, middleware) => {
+    const middlewareStore = pikkuState('misc', 'middleware');
+    // Check if tag already exists
+    if (middlewareStore[tag]) {
+        throw new Error(`Middleware for tag '${tag}' already exists. Use a different tag or remove the existing middleware first.`);
+    }
+    middlewareStore[tag] = middleware;
+};
+/**
+ * Retrieves middleware for a given set of tags.
+ *
+ * This function looks up all middleware registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Array of middleware functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all middleware for tags 'api' and 'auth'
+ * const middleware = getMiddlewareForTags(['api', 'auth'])
+ * ```
+ */
+export const getMiddlewareForTags = (tags) => {
+    if (!tags || tags.length === 0) {
+        return [];
+    }
+    const middlewareStore = pikkuState('misc', 'middleware');
+    const applicableMiddleware = [];
+    // Collect middleware for all matching tags
+    for (const tag of tags) {
+        const tagMiddleware = middlewareStore[tag];
+        if (tagMiddleware) {
+            applicableMiddleware.push(...tagMiddleware);
+        }
+    }
+    return applicableMiddleware;
+};
+/**
+ * Combines tag-based middleware with wiring-specific middleware.
+ *
+ * This helper function gets middleware for tags and combines it with any
+ * wiring-specific middleware, avoiding the need for manual spreading.
+ *
+ * @param {CorePikkuMiddleware[] | undefined} wiringMiddleware - Wiring-specific middleware.
+ * @param {string[] | undefined} tags - Array of tags to look up middleware for.
+ * @returns {CorePikkuMiddleware[]} Combined array of tag-based and wiring-specific middleware.
+ *
+ * @example
+ * ```typescript
+ * // Instead of:
+ * const taggedMiddleware = getMiddlewareForTags(tags)
+ * const combined = [...taggedMiddleware, ...(middleware || [])]
+ *
+ * // Use:
+ * const combined = addMiddlewareForTags(middleware, tags)
+ * ```
+ */
+export const addMiddlewareForTags = (wiringMiddleware, tags) => {
+    const taggedMiddleware = getMiddlewareForTags(tags);
+    return [...taggedMiddleware, ...(wiringMiddleware || [])];
+};

package/dist/permissions.d.ts

@@ -8,3 +8,43 @@ import { CorePermissionGroup } from './function/functions.types.js';
  * @returns A promise that resolves to void.
  */
 export declare const verifyPermissions: (permissions: CorePermissionGroup, services: CoreServices, data: any, session?: CoreUserSession) => Promise<boolean>;
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param {string} tag - The tag that the permissions should apply to.
+ * @param {any[]} permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws {Error} If permissions for the tag already exist.
+ *
+ * @example
+ * ```typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * ```
+ */
+export declare const addPermission: (tag: string, permissions: any[]) => void;
+/**
+ * Retrieves permissions for a given set of tags.
+ *
+ * This function looks up all permissions registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up permissions for.
+ * @returns {any[]} Array of permission functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all permissions for tags 'api' and 'auth'
+ * const permissions = getPermissionsForTags(['api', 'auth'])
+ * ```
+ */
+export declare const getPermissionsForTags: (tags?: string[]) => any[];

package/dist/permissions.js

@@ -1,3 +1,4 @@
+import { pikkuState } from './pikku-state.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.
  * @param services - The core services required for permission validation.
@@ -30,3 +31,64 @@ export const verifyPermissions = async (permissions, services, data, session) =>
     }
     return false;
 };
+/**
+ * Adds global permissions for a specific tag.
+ *
+ * This function allows you to register permissions that will be applied to
+ * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
+ *
+ * @param {string} tag - The tag that the permissions should apply to.
+ * @param {any[]} permissions - The permissions array to apply for the specified tag.
+ *
+ * @throws {Error} If permissions for the tag already exist.
+ *
+ * @example
+ * ```typescript
+ * // Add admin permissions for admin endpoints
+ * addPermission('admin', [adminPermission])
+ *
+ * // Add authentication permissions for auth endpoints
+ * addPermission('auth', [authPermission])
+ *
+ * // Add read permissions for all API endpoints
+ * addPermission('api', [readPermission])
+ * ```
+ */
+export const addPermission = (tag, permissions) => {
+    const permissionsStore = pikkuState('misc', 'permissions');
+    // Check if tag already exists
+    if (permissionsStore[tag]) {
+        throw new Error(`Permissions for tag '${tag}' already exist. Use a different tag or remove the existing permissions first.`);
+    }
+    permissionsStore[tag] = permissions;
+};
+/**
+ * Retrieves permissions for a given set of tags.
+ *
+ * This function looks up all permissions registered for any of the provided tags
+ * and returns them as a flattened array.
+ *
+ * @param {string[]} tags - Array of tags to look up permissions for.
+ * @returns {any[]} Array of permission functions that apply to the given tags.
+ *
+ * @example
+ * ```typescript
+ * // Get all permissions for tags 'api' and 'auth'
+ * const permissions = getPermissionsForTags(['api', 'auth'])
+ * ```
+ */
+export const getPermissionsForTags = (tags) => {
+    if (!tags || tags.length === 0) {
+        return [];
+    }
+    const permissionsStore = pikkuState('misc', 'permissions');
+    const applicablePermissions = [];
+    // Collect permissions for all matching tags
+    for (const tag of new Set(tags)) {
+        const tagPermissions = permissionsStore[tag];
+        if (tagPermissions) {
+            applicablePermissions.push(...tagPermissions);
+        }
+    }
+    return applicablePermissions;
+};

package/dist/pikku-state.d.ts

@@ -4,7 +4,6 @@ import { FunctionsMeta, CorePikkuMiddleware } from './types/core.types.js';
 import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
 import { CorePikkuFunctionConfig } from './function/functions.types.js';
-import { RPCMeta } from './wirings/rpc/rpc-types.js';
 import { queueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
 import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
 interface PikkuState {
@@ -13,7 +12,7 @@ interface PikkuState {
         functions: Map<string, CorePikkuFunctionConfig<any, any>>;
     };
     rpc: {
-        meta: Record<string, RPCMeta>;
+        meta: Record<string, string>;
         files: Map<string, {
             exportedName: string;
             path: string;
@@ -50,6 +49,8 @@ interface PikkuState {
     misc: {
         errors: Map<PikkuError, ErrorDetails>;
         schemas: Map<string, any>;
+        middleware: Record<string, CorePikkuMiddleware[]>;
+        permissions: Record<string, any[]>;
     };
 }
 export declare const resetPikkuState: () => void;

package/dist/pikku-state.js

@@ -36,6 +36,8 @@ export const resetPikkuState = () => {
         misc: {
             errors: globalThis.pikkuState?.misc?.errors || new Map(),
             schemas: globalThis.pikkuState?.misc?.schema || new Map(),
+            middleware: globalThis.pikkuState?.misc?.middleware || {},
+            permissions: globalThis.pikkuState?.misc?.permissions || {},
         },
     };
 };

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

@@ -6,6 +6,8 @@ import { UserSessionService } from '../services/user-session-service.js';
 import { PikkuChannel } from '../wirings/channel/channel.types.js';
 import { PikkuRPC } from '../wirings/rpc/rpc-types.js';
 import { PikkuMCP } from '../wirings/mcp/mcp.types.js';
+import { PikkuScheduledTask } from '../wirings/scheduler/scheduler.types.js';
+import { PikkuQueue } from '../wirings/queue/queue.types.js';
 export declare enum PikkuWiringTypes {
     http = "http",
     scheduler = "scheduler",
@@ -18,17 +20,23 @@ export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
 }
-export type FunctionsMeta = Record<string, {
+export type FunctionRuntimeMeta = {
     pikkuFuncName: string;
-    name?: string;
+    inputSchemaName: string | null;
+    outputSchemaName: string | null;
+    expose?: boolean;
+};
+export type FunctionMeta = FunctionRuntimeMeta & Partial<{
+    name: string;
     services: FunctionServicesMeta;
-    schemaName: string | null;
     inputs: string[] | null;
     outputs: string[] | null;
-    expose?: boolean;
-    tags?: string[];
-    docs?: PikkuDocs;
+    tags: string[];
+    docs: PikkuDocs;
+    isDirectFunction: boolean;
 }>;
+export type FunctionsRuntimeMeta = Record<string, FunctionRuntimeMeta>;
+export type FunctionsMeta = Record<string, FunctionMeta>;
 export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 /**
  * Represents a JSON primitive type which can be a string, number, boolean, null, or undefined.
@@ -84,11 +92,15 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 /**
  * Represents different forms of interaction within Pikku and the outside world.
  */
-export interface PikkuInteraction {
-    http?: PikkuHTTP;
-    mcp?: PikkuMCP;
-    rpc?: PikkuRPC;
-}
+export type PikkuInteraction = Partial<{
+    http: PikkuHTTP;
+    mcp: PikkuMCP;
+    rpc: PikkuRPC;
+    channel: PikkuChannel<unknown, unknown>;
+    scheduledTask: PikkuScheduledTask;
+    queue: PikkuQueue;
+    s: any;
+}>;
 /**
  * A function that can wrap an interaction and be called before or after
  */

package/dist/wirings/channel/channel-handler.js

@@ -56,6 +56,7 @@ export const processMessageHandlers = (services, session, channelConfig, channel
             session,
             permissions,
             middleware,
+            tags: channelConfig.tags,
         });
     };
     const onMessage = async (rawData) => {

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

@@ -4,7 +4,7 @@ import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleHTTPError } from '../../../handle-error.js';
-import { runMiddleware } from '../../../middleware-runner.js';
+import { addMiddlewareForTags, runMiddleware, } from '../../../middleware-runner.js';
 import { PikkuUserSessionService } from '../../../services/user-session-service.js';
 import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 import { rpcService } from '../../rpc/rpc-runner.js';
@@ -17,25 +17,33 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
         http = createHTTPInteraction(request, response);
         route = http?.request?.path();
     }
+    let openingData, channelConfig, meta;
+    try {
+        ;
+        ({ openingData, channelConfig, meta } = await openChannel({
+            channelId,
+            createSessionServices,
+            respondWith404,
+            request,
+            response,
+            route,
+            singletonServices,
+            skipUserSession,
+            coerceDataFromSchema,
+            userSession,
+        }));
+    }
+    catch (e) {
+        handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        return;
+    }
     const main = async () => {
         try {
-            const { openingData, channelConfig, meta } = await openChannel({
-                channelId,
-                createSessionServices,
-                respondWith404,
-                request,
-                response,
-                route,
-                singletonServices,
-                skipUserSession,
-                coerceDataFromSchema,
-                userSession,
-            });
             channelHandler = new PikkuLocalChannelHandler(channelId, channelConfig.name, openingData);
             const channel = channelHandler.getChannel();
             const session = await userSession.get();
             if (createSessionServices) {
-                sessionServices = await createSessionServices(singletonServices, { http }, session);
+                sessionServices = await createSessionServices(singletonServices, { http, channel }, session);
             }
             const allServices = rpcService.injectRPCService({
                 ...singletonServices,
@@ -69,6 +77,6 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, route.middleware || [], main);
+    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
     return channelHandler;
 };

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

@@ -4,7 +4,7 @@ import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.js';
 import { handleHTTPError } from '../../../handle-error.js';
 import { PikkuUserSessionService } from '../../../services/user-session-service.js';
-import { runMiddleware } from '../../../middleware-runner.js';
+import { addMiddlewareForTags, runMiddleware, } from '../../../middleware-runner.js';
 import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
 import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
@@ -76,7 +76,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
     await runMiddleware({
         ...singletonServices,
         userSession,
-    }, { http }, channelConfig.middleware || [], main);
+    }, { http }, addMiddlewareForTags(channelConfig.middleware, channelConfig.tags), main);
 };
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;