@pikku/core 0.6.26 → 0.7.0

package/CHANGELOG.md

@@ -1,4 +1,20 @@
-## 0.6
+## 0.7.0
+
+We now use the function first approach internally, which means first all the functions register, and then events call call them.
+
+The main breaking changes for the end user are:
+
+- We now declare functions using `pikkuFunc<In, Out>(async () => {})
+- We renamed addRoute to addHTTPRoutes
+
+We also removed all the different types of functions. Everything is now either an APIFunction of APIFunctionSessionless. The channel (eventHub or any other transport specific service) is now injected in the service itself.
+
+## 0.6.27
+
+### Patch Changes
+
+- 8658745: refactor: changing content service to use streams for performance benefits
+- d0968d2: fix: fixing content uploads for s3
 
 ## 0.6.26
 

package/dist/channel/channel-handler.js

@@ -1,8 +1,7 @@
-import { verifyPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
+import { runPikkuFunc } from '../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
-    const channelsMeta = pikkuState('channel', 'meta');
-    const channelMeta = channelsMeta.find((channelMeta) => channelMeta.name === channelName);
+    const channelMeta = pikkuState('channel', 'meta')[channelName];
     if (!channelMeta) {
         throw new Error(`Channel ${channelName} not found`);
     }
@@ -21,14 +20,6 @@ const getRouteMeta = (channelName, routingProperty, routerValue) => {
     }
     return route;
 };
-const validateSchema = (logger, data, channelRoute) => {
-    const schemaNames = channelRoute.inputs;
-    if (schemaNames) {
-        // TODO
-        // loadSchema(schemaNames, logger)
-        // validateJson(schemaNames, data)
-    }
-};
 const validateAuth = (requiresSession, session, onMessage) => {
     const auth = typeof onMessage === 'function'
         ? requiresSession
@@ -40,22 +31,6 @@ const validateAuth = (requiresSession, session, onMessage) => {
     }
     return true;
 };
-const validatePermissions = async (services, session, onMessage, data) => {
-    const permissions = typeof onMessage === 'function' ? {} : onMessage.permissions;
-    return await verifyPermissions(permissions, services, data, session);
-};
-const runFunction = async (services, channelHandler, channelMessageMeta, session, onMessage, data) => {
-    const func = typeof onMessage === 'function' ? onMessage : onMessage.func;
-    if (channelMessageMeta.type?.toLowerCase().includes('function')) {
-        return await func({
-            ...services,
-            channel: channelHandler.getChannel(),
-        }, data, session);
-    }
-    else {
-        return await func(services, channelHandler.getChannel(), data);
-    }
-};
 export const processMessageHandlers = (services, session, channelConfig, channelHandler) => {
     const logger = services.logger;
     const requiresSession = channelConfig.auth !== false;
@@ -69,15 +44,18 @@ export const processMessageHandlers = (services, session, channelConfig, channel
             channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`);
             return;
         }
-        const routeMeta = getRouteMeta(channelConfig.name, routingProperty, routerValue);
-        if (routeMeta) {
-            await validateSchema(services.logger, data, routeMeta);
-        }
-        const hasPermission = await validatePermissions(services, channelHandler, onMessage, data);
-        if (!hasPermission) {
-            logger.error(`Channel ${channelConfig.name} requires permissions for ${routingProperty || 'default message route'}`);
-        }
-        return await runFunction(services, channelHandler, routeMeta, session, onMessage, data);
+        const { pikkuFuncName } = getRouteMeta(channelConfig.name, routingProperty, routerValue);
+        const permissions = typeof onMessage === 'function' ? {} : onMessage.permissions;
+        return await runPikkuFunc(pikkuFuncName, {
+            singletonServices: services,
+            getAllServices: () => ({
+                ...services,
+                channel: channelHandler.getChannel(),
+            }),
+            data,
+            session,
+            permissions,
+        });
     };
     const onMessage = async (rawData) => {
         let result;
@@ -111,8 +89,8 @@ export const processMessageHandlers = (services, session, channelConfig, channel
             result = await processMessage(rawData, channelConfig.onMessage, session);
         }
         if (!processed) {
-            logger.error(`No handler found for message in channel ${channelConfig.name} for ${rawData}`);
-            logger.error(`Channel ${channelConfig}`);
+            logger.error(`No handler found for message in channel ${channelConfig.name} for ${JSON.stringify(rawData)}`);
+            logger.error(`Channel ${JSON.stringify(channelConfig)}`);
         }
         return result;
     };

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

@@ -1,15 +1,14 @@
 import { UserSessionService } from '../services/user-session-service.js';
-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;
-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("../index.js").CoreAPIFunction<unknown, unknown>, import("./channel.types.js").CoreChannelMessage<unknown, unknown, unknown, import("../index.js").CoreServices> | import("../index.js").CoreAPIFunction<unknown, unknown>, import("../index.js").CoreAPIPermission<any>>;
-    schemaName: string | null | undefined;
-} | null;
+import { ChannelMeta, CoreAPIChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
+/**
+ * Adds a channel and registers all functions referenced in it using the
+ * function names already stored in the channel metadata
+ */
+export declare const addChannel: <In, Channel extends string, ChannelFunction, ChannelFunctionSessionless, APIPermission>(channel: CoreAPIChannel<In, Channel, ChannelFunction, APIPermission>) => void;
 export declare const openChannel: ({ route, singletonServices, coerceDataFromSchema, request, }: Pick<CoreAPIChannel<unknown, string>, "route"> & RunChannelParams<unknown> & {
     userSession: UserSessionService<any>;
 } & RunChannelOptions) => Promise<{
     openingData: unknown;
     channelConfig: CoreAPIChannel<unknown, any>;
+    meta: ChannelMeta;
 }>;

package/dist/channel/channel-runner.js

@@ -1,14 +1,61 @@
 import { NotFoundError } from '../errors/errors.js';
+import { addFunction } from '../function/function-runner.js';
 import { pikkuState } from '../pikku-state.js';
 import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
 import { match } from 'path-to-regexp';
+/**
+ * Adds a channel and registers all functions referenced in it using the
+ * function names already stored in the channel metadata
+ */
 export const addChannel = (channel) => {
-    pikkuState('channel', 'channels').push(channel);
+    // Get the channel metadata
+    const channelsMeta = pikkuState('channel', 'meta');
+    const channelMeta = channelsMeta[channel.name];
+    if (!channelMeta) {
+        throw new Error(`Channel metadata not found for channel: ${channel.name}`);
+    }
+    pikkuState('channel', 'channels').set(channel.name, channel);
+    // Register onConnect function if provided
+    if (channel.onConnect && channelMeta.connectPikkuFuncName) {
+        addFunction(channelMeta.connectPikkuFuncName, channel.onConnect);
+    }
+    // Register onDisconnect function if provided
+    if (channel.onDisconnect && channelMeta.disconnectPikkuFuncName) {
+        addFunction(channelMeta.disconnectPikkuFuncName, channel.onDisconnect);
+    }
+    // Register onMessage function if provided
+    if (channel.onMessage && channelMeta.message?.pikkuFuncName) {
+        const messageFunc = typeof channel.onMessage === 'function'
+            ? channel.onMessage
+            : channel.onMessage.func;
+        addFunction(channelMeta.message.pikkuFuncName, messageFunc);
+    }
+    // Register functions in onMessageRoute
+    if (channel.onMessageRoute && channelMeta.messageRoutes) {
+        // Iterate through each channel in onMessageRoute
+        Object.entries(channel.onMessageRoute).forEach(([channelKey, routes]) => {
+            const channelRoutes = channelMeta.messageRoutes[channelKey];
+            if (!channelRoutes)
+                return;
+            // Iterate through each route in the channel
+            Object.entries(routes).forEach(([routeKey, handler]) => {
+                const routeMeta = channelRoutes[routeKey];
+                if (!routeMeta)
+                    return;
+                // Extract the function from the handler
+                const routeFunc = typeof handler === 'function' ? handler : handler.func;
+                // Register the function using the pikku name from metadata
+                addFunction(routeMeta.pikkuFuncName, routeFunc);
+            });
+        });
+    }
+    // Store the channel configuration
+    pikkuState('channel', 'channels').set(channel.name, channel);
 };
-export const getMatchingChannelConfig = (request) => {
+const getMatchingChannelConfig = (request) => {
     const channels = pikkuState('channel', 'channels');
     const channelsMeta = pikkuState('channel', 'meta');
-    for (const channelConfig of channels) {
+    for (const channelConfig of channels.values()) {
         const cleanedRoute = channelConfig.route.replace(/^\/\//, '/');
         const cleanedRequest = request.replace(/^\/\//, '/');
         const matchFunc = match(cleanedRoute, {
@@ -16,12 +63,16 @@ export const getMatchingChannelConfig = (request) => {
         });
         const matchedPath = matchFunc(cleanedRequest);
         if (matchedPath) {
-            const schemaName = channelsMeta.find((channelMeta) => channelMeta.route === channelConfig.route)?.input;
+            const channelMeta = channelsMeta[channelConfig.name];
+            if (!channelMeta) {
+                throw new Error(`Channel ${channelConfig.name} not found in metadata`);
+            }
             return {
                 matchedPath,
                 params: matchedPath.params,
                 channelConfig,
-                schemaName,
+                schemaName: channelMeta.input,
+                meta: channelMeta
             };
         }
     }
@@ -33,7 +84,7 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         singletonServices.logger.info(`Channel not found: ${route}`);
         throw new NotFoundError(`Channel not found: ${route}`);
     }
-    const { params, channelConfig, schemaName } = matchingChannel;
+    const { params, channelConfig, schemaName, meta } = matchingChannel;
     const requiresSession = channelConfig.auth !== false;
     request?.setParams(params);
     singletonServices.logger.info(`Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`);
@@ -45,5 +96,5 @@ export const openChannel = async ({ route, singletonServices, coerceDataFromSche
         }
         await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, openingData);
     }
-    return { openingData, channelConfig };
+    return { openingData, channelConfig, meta };
 };

package/dist/channel/channel.types.d.ts

@@ -1,7 +1,7 @@
 import { PikkuError } from '../errors/error-handler.js';
-import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http-routes.types.js';
-import { APIDocs, CoreServices, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
-import { CoreAPIFunction, CoreAPIPermission } from '../types/functions.types.js';
+import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
+import { APIDocs, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
@@ -17,10 +17,10 @@ export type RunChannelParams<ChannelData> = {
     createSessionServices?: CreateSessionServices;
 };
 export interface ChannelMessageMeta {
+    pikkuFuncName: string;
     inputs: string[] | null;
     outputs: string[] | null;
     docs?: APIDocs;
-    type: null | string;
 }
 export interface ChannelMeta {
     name: string;
@@ -30,39 +30,27 @@ export interface ChannelMeta {
     input: string | null;
     inputTypes?: HTTPFunctionMetaInputTypes;
     connect: boolean;
+    connectPikkuFuncName: string | null;
     disconnect: boolean;
+    disconnectPikkuFuncName: string | null;
     message: ChannelMessageMeta | null;
     messageRoutes: Record<string, Record<string, ChannelMessageMeta>>;
     docs?: APIDocs;
     tags?: string[];
 }
-export type ChannelsMeta = ChannelMeta[];
-export type CoreChannelConnection<ChannelData, Out = unknown, Services extends CoreServices = CoreServices> = (services: Services, channel: PikkuChannel<ChannelData, Out>) => Promise<void>;
-export type CoreChannelDisconnection<ChannelData, Services extends CoreServices = CoreServices> = (services: Services, channel: PikkuChannel<ChannelData, never>) => Promise<void>;
-/**
- * Represents a core channel function that performs an operation using core services and a user session.
- *
- * @template In - The input type.
- * @template Services - The services type, defaults to `CoreServices`.
- * @template Session - The session type, defaults to `CoreUserSession`.
- */
-export type CoreChannelMessage<In, Out, ChannelData, Services extends CoreServices = CoreServices> = (services: Services, channel: PikkuChannel<ChannelData, Out>, data: In) => Promise<void | Out>;
-export type CoreAPIChannelMessage<ChannelFunctionMessage = CoreChannelMessage<unknown, unknown, unknown>> = {
-    func: ChannelFunctionMessage;
-    route: string;
-};
-export type CoreAPIChannel<ChannelData, Channel extends string, ChannelFunctionConnection = CoreChannelConnection<ChannelData>, ChannelFunctionDisconnection = CoreChannelDisconnection<ChannelData>, ChannelFunctionDefaultMessage = CoreChannelMessage<unknown, unknown, unknown> | CoreAPIFunction<unknown, unknown>, ChannelFunctionMessageRoute = CoreChannelMessage<unknown, unknown, unknown> | CoreAPIFunction<unknown, unknown>, APIPermission = CoreAPIPermission<ChannelData>> = {
+export type ChannelsMeta = Record<string, ChannelMeta>;
+export type CoreAPIChannel<ChannelData, Channel extends string, ChannelConnect = CoreAPIFunction<void, unknown, ChannelData> | CoreAPIFunctionSessionless<void, unknown, ChannelData>, ChannelDisconnect = CoreAPIFunction<void, void, ChannelData> | CoreAPIFunctionSessionless<void, void, ChannelData>, ChannelFunctionMessage = CoreAPIFunction<unknown, unknown, ChannelData> | CoreAPIFunctionSessionless<unknown, unknown, ChannelData>, APIPermission = CoreAPIPermission<ChannelData>> = {
     name: string;
     route: Channel;
-    onConnect?: ChannelFunctionConnection;
-    onDisconnect?: ChannelFunctionDisconnection;
+    onConnect?: ChannelConnect;
+    onDisconnect?: ChannelDisconnect;
     onMessage?: {
-        func: ChannelFunctionDefaultMessage;
+        func: ChannelFunctionMessage;
         permissions?: Record<string, APIPermission[] | APIPermission>;
         auth?: boolean;
-    } | ChannelFunctionDefaultMessage;
-    onMessageRoute?: Record<string, Record<string, ChannelFunctionMessageRoute | {
-        func: ChannelFunctionMessageRoute;
+    } | ChannelFunctionMessage;
+    onMessageRoute?: Record<string, Record<string, ChannelFunctionMessage | {
+        func: ChannelFunctionMessage;
         permissions?: Record<string, APIPermission[] | APIPermission>;
         auth?: boolean;
     }>>;
@@ -77,7 +65,6 @@ export type CoreAPIChannel<ChannelData, Channel extends string, ChannelFunctionC
     }>;
     tags?: string[];
 };
-export type CoreAPIChannels = CoreAPIChannel<any, string>[];
 export interface PikkuChannel<OpeningData, Out> {
     channelId: string;
     openingData: OpeningData;

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

@@ -1,11 +1,12 @@
 import { openChannel } from '../channel-runner.js';
-import { createHTTPInteraction } from '../../http/http-route-runner.js';
+import { createHTTPInteraction } from '../../http/http-runner.js';
 import { closeSessionServices } from '../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
 import { handleError } from '../../handle-error.js';
 import { runMiddleware } from '../../middleware-runner.js';
 import { PikkuUserSessionService } from '../../services/user-session-service.js';
+import { runPikkuFuncDirectly } from '../../function/function-runner.js';
 export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
     let sessionServices;
     let channelHandler;
@@ -17,7 +18,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
     }
     const main = async () => {
         try {
-            const { openingData, channelConfig } = await openChannel({
+            const { openingData, channelConfig, meta } = await openChannel({
                 channelId,
                 createSessionServices,
                 respondWith404,
@@ -41,10 +42,14 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                 userSession: userSession,
             };
             channelHandler.registerOnOpen(() => {
-                channelConfig.onConnect?.(allServices, channel);
+                if (channelConfig.onConnect && meta.connectPikkuFuncName) {
+                    runPikkuFuncDirectly(meta.connectPikkuFuncName, { ...allServices, channel }, openingData);
+                }
             });
             channelHandler.registerOnClose(async () => {
-                channelConfig.onDisconnect?.(allServices, channel);
+                if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
+                    runPikkuFuncDirectly(meta.disconnectPikkuFuncName, { ...allServices, channel }, openingData);
+                }
                 if (sessionServices) {
                     await closeSessionServices(singletonServices.logger, sessionServices);
                 }

package/dist/channel/log-channels.js

@@ -5,13 +5,13 @@ import { pikkuState } from '../pikku-state.js';
  */
 export const logChannels = (logger) => {
     const channels = pikkuState('channel', 'channels');
-    if (channels.length === 0) {
+    if (channels.size === 0) {
         logger.info('No channels added');
         return;
     }
     let scheduledChannels = 'Channels:';
-    for (const { name, route } of channels) {
-        scheduledChannels += `\n\t- ${name} at ${route}`;
-    }
+    channels.forEach((channel) => {
+        scheduledChannels += `\n\t- ${channel.name} at ${channel.route}`;
+    });
     logger.info(scheduledChannels);
 };

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

@@ -1,23 +1,30 @@
 import { closeSessionServices } from '../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { openChannel } from '../channel-runner.js';
-import { createHTTPInteraction } from '../../http/http-route-runner.js';
+import { createHTTPInteraction } from '../../http/http-runner.js';
 import { handleError } from '../../handle-error.js';
 import { PikkuUserSessionService } from '../../services/user-session-service.js';
 import { 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';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
     const channels = pikkuState('channel', 'channels');
-    const channelConfig = channels.find((channelConfig) => channelConfig.name === channelName);
+    const channelConfig = channels[channelName];
+    const channelsMeta = pikkuState('channel', 'meta');
+    const meta = channelsMeta[channelName];
     if (!channelConfig) {
         throw new Error(`Channel not found: ${channelName}`);
     }
+    if (!meta) {
+        throw new Error(`Channel meta not found: ${channelName}`);
+    }
     const channelHandler = channelHandlerFactory(channelId, channelConfig.name, openingData);
     return {
         channelConfig,
         channelHandler,
         channel: channelHandler.getChannel(),
+        meta
     };
 };
 export const runChannelConnect = async ({ singletonServices, channelId, channelObject, request, response, route, createSessionServices, channelStore, channelHandlerFactory, coerceDataFromSchema = true, logWarningsForStatusCodes = [], respondWith404 = true, bubbleErrors = false, }) => {
@@ -27,7 +34,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
         http = createHTTPInteraction(new PikkuFetchHTTPRequest(request), response);
     }
     const userSession = new PikkuUserSessionService(channelStore, channelId);
-    const { channelConfig, openingData } = await openChannel({
+    const { channelConfig, openingData, meta } = await openChannel({
         channelId,
         createSessionServices,
         request,
@@ -52,7 +59,9 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
             if (createSessionServices) {
                 sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
             }
-            await channelConfig.onConnect?.({ ...singletonServices, ...sessionServices }, channel);
+            if (channelConfig.onConnect && meta.connectPikkuFuncName) {
+                await runPikkuFuncDirectly(meta.connectPikkuFuncName, { ...singletonServices, ...sessionServices, channel }, openingData);
+            }
             http?.response?.status(101);
         }
         catch (e) {
@@ -72,7 +81,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
 export const runChannelDisconnect = async ({ singletonServices, ...params }) => {
     let sessionServices;
     const { openingData, channelName, session } = await params.channelStore.getChannelAndSession(params.channelId);
-    const { channel, channelConfig } = getVariablesForChannel({
+    const { channel, channelConfig, meta } = getVariablesForChannel({
         ...params,
         openingData,
         channelName,
@@ -80,7 +89,9 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
     if (!sessionServices && params.createSessionServices) {
         sessionServices = await params.createSessionServices(singletonServices, {}, session);
     }
-    await channelConfig.onDisconnect?.({ ...singletonServices, ...sessionServices }, channel);
+    if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
+        await runPikkuFuncDirectly(meta.disconnectPikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
+    }
     await params.channelStore.removeChannels([channel.channelId]);
     if (sessionServices) {
         await closeSessionServices(singletonServices.logger, sessionServices);

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

@@ -0,0 +1,12 @@
+import { CoreServices, CoreSingletonServices, CoreUserSession } from '../types/core.types.js';
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CorePermissionGroup } from './functions.types.js';
+export declare const addFunction: (funcName: string, func: CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<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, { singletonServices, getAllServices, data, session, permissions, coerceDataFromSchema, }: {
+    singletonServices: CoreSingletonServices;
+    getAllServices: () => Promise<CoreServices> | CoreServices;
+    data: In;
+    session?: CoreUserSession;
+    permissions?: CorePermissionGroup;
+    coerceDataFromSchema?: boolean;
+}) => Promise<Out>;

package/dist/function/function-runner.js

@@ -0,0 +1,38 @@
+import { ForbiddenError } from '../errors/errors.js';
+import { verifyPermissions } from '../permissions.js';
+import { pikkuState } from '../pikku-state.js';
+import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
+export const addFunction = (funcName, func) => {
+    pikkuState('functions', 'nameToFunction').set(funcName, func);
+};
+export const runPikkuFuncDirectly = async (funcName, allServices, data, session) => {
+    const func = pikkuState('functions', 'nameToFunction').get(funcName);
+    if (!func) {
+        throw new Error(`Function not found: ${funcName}`);
+    }
+    return (await func(allServices, data, session));
+};
+export const runPikkuFunc = async (funcName, { singletonServices, getAllServices, data, session, permissions, coerceDataFromSchema, }) => {
+    const func = pikkuState('functions', 'nameToFunction').get(funcName);
+    if (!func) {
+        throw new Error(`Function not found: ${funcName}`);
+    }
+    const funcMeta = pikkuState('functions', 'meta')[funcName];
+    if (!funcMeta) {
+        throw new Error(`Function meta not found: ${funcName}`);
+    }
+    const schemaName = funcMeta.schemaName;
+    // Validate request data against the defined schema, if any
+    await validateSchema(singletonServices.logger, singletonServices.schema, schemaName, data);
+    // Coerce (top level) query string parameters or date objects if specified by the schema
+    if (coerceDataFromSchema && schemaName) {
+        coerceTopLevelDataFromSchema(schemaName, data);
+    }
+    const allServices = await getAllServices();
+    // Execute permission checks
+    const permissioned = await verifyPermissions(permissions, allServices, data, session);
+    if (permissioned === false) {
+        throw new ForbiddenError('Permission denied');
+    }
+    return (await func(allServices, data, session));
+};

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

@@ -0,0 +1,37 @@
+import { PikkuChannel } from '../channel/channel.types.js';
+import type { CoreServices, CoreSingletonServices, CoreUserSession } from '../types/core.types.js';
+/**
+ * Represents a core API function that performs an operation using core services and a user session.
+ *
+ * @template In - The input type.
+ * @template Out - The output type.
+ * @template Services - The services type, defaults to `CoreServices`.
+ * @template Session - The session type, defaults to `CoreUserSession`.
+ */
+export type CoreAPIFunction<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
+    channel?: PikkuChannel<unknown, Out> | undefined;
+} : {
+    channel: PikkuChannel<ChannelData, Out>;
+}), Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session: Session) => ChannelData extends null ? Promise<Out> : Promise<Out> | Promise<void>;
+/**
+ * Represents a core API function that can be used without a session.
+ *
+ * @template In - The input type.
+ * @template Out - The output type.
+ * @template Services - The services type, defaults to `CoreServices`.
+ * @template Session - The session type, defaults to `CoreUserSession`.
+ */
+export type CoreAPIFunctionSessionless<In, Out, ChannelData extends unknown | null = null, Services extends CoreSingletonServices = CoreServices & (ChannelData extends null ? {
+    channel?: PikkuChannel<unknown, Out> | undefined;
+} : {
+    channel: PikkuChannel<ChannelData, Out>;
+}), Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => ChannelData extends null ? Promise<Out> : Promise<Out> | Promise<void>;
+/**
+ * Represents a function that checks permissions for a given API operation.
+ *
+ * @template In - The input type.
+ * @template Services - The services type, defaults to `CoreServices`.
+ * @template Session - The session type, defaults to `CoreUserSession`.
+ */
+export type CoreAPIPermission<In = any, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<boolean>;
+export type CorePermissionGroup<APIPermission = CoreAPIPermission<any>> = Record<string, APIPermission | APIPermission[]> | undefined;

package/dist/function/functions.types.js

@@ -0,0 +1 @@
+export {};

package/dist/function/index.d.ts

@@ -0,0 +1,2 @@
+export * from './function-runner.js';
+export * from './functions.types.js';

package/dist/function/index.js

@@ -0,0 +1,2 @@
+export * from './function-runner.js';
+export * from './functions.types.js';

package/dist/handle-error.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from './services/logger.js';
-import { PikkuHTTP } from './http/http-routes.types.js';
+import { PikkuHTTP } from './http/http.types.js';
 /**
  * Handle errors that occur during route processing
  *

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

@@ -24,11 +24,11 @@ export declare const addMiddleware: <APIMiddleware extends PikkuMiddleware>(rout
  * @template Route Route pattern as a string.
  * @template APIFunction Type for the route handler function.
  * @template APIFunctionSessionless Type for a sessionless handler.
- * @template APIPermission Type representing required permissions.
+ * @template APIPermissionGroup Type representing required permissions.
  * @template APIMiddleware Middleware type to be used with the route.
  * @param {CoreHTTPFunctionRoute<In, Out, Route, APIFunction, APIFunctionSessionless, APIPermission, APIMiddleware>} route - The route configuration object.
  */
-export declare const addRoute: <In, Out, Route extends string, APIFunction, APIFunctionSessionless, APIPermission, APIMiddleware>(route: CoreHTTPFunctionRoute<In, Out, Route, APIFunction, APIFunctionSessionless, APIPermission, APIMiddleware>) => void;
+export declare const addRoute: <In, Out, Route extends string, APIFunction, APIFunctionSessionless, APIPermissionGroup, APIMiddleware>(route: CoreHTTPFunctionRoute<In, Out, Route, APIFunction, APIFunctionSessionless, APIPermissionGroup, APIMiddleware>) => void;
 /**
  * Combines the request and response objects into a single HTTP interaction object.
  *
@@ -87,4 +87,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;