@pikku/core 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## 0.7.0
 
+## 0.7.3
+
+### Patch Changes
+
+- 534fdef: feat: adding rpc (locally for now)
+
+## 0.7.2
+
+### Patch Changes
+
+- bb59874: fix: only try validating schemas if they exist in function runner
+
 ## 0.7.1
 
 ### Patch Changes

package/dist/channel/channel-handler.js

@@ -47,7 +47,6 @@ export const processMessageHandlers = (services, session, channelConfig, channel
         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(),

package/dist/channel/channel-runner.js

@@ -17,18 +17,24 @@ export const addChannel = (channel) => {
     pikkuState('channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
     if (channel.onConnect && channelMeta.connectPikkuFuncName) {
-        addFunction(channelMeta.connectPikkuFuncName, channel.onConnect);
+        addFunction(channelMeta.connectPikkuFuncName, {
+            func: channel.onConnect,
+        });
     }
     // Register onDisconnect function if provided
     if (channel.onDisconnect && channelMeta.disconnectPikkuFuncName) {
-        addFunction(channelMeta.disconnectPikkuFuncName, channel.onDisconnect);
+        addFunction(channelMeta.disconnectPikkuFuncName, {
+            func: 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);
+        addFunction(channelMeta.message.pikkuFuncName, {
+            func: messageFunc,
+        });
     }
     // Register functions in onMessageRoute
     if (channel.onMessageRoute && channelMeta.messageRoutes) {
@@ -43,7 +49,13 @@ export const addChannel = (channel) => {
                 if (!routeMeta)
                     return;
                 // Extract the function from the handler
-                const routeFunc = typeof handler === 'function' ? handler : handler.func;
+                const routeFunc = typeof handler === 'function'
+                    ? { func: handler }
+                    : {
+                        func: handler.func,
+                        auth: handler.auth,
+                        permissions: handler.permissions,
+                    };
                 // Register the function using the pikku name from metadata
                 addFunction(routeMeta.pikkuFuncName, routeFunc);
             });

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

@@ -7,6 +7,7 @@ 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';
+import { rpcService } from '../../rpc/rpc-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;
@@ -36,11 +37,11 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             if (createSessionServices) {
                 sessionServices = await createSessionServices(singletonServices, { http }, session);
             }
-            const allServices = {
+            const allServices = rpcService.injectRPCService({
                 ...singletonServices,
                 ...sessionServices,
                 userSession: userSession,
-            };
+            });
             channelHandler.registerOnOpen(() => {
                 if (channelConfig.onConnect && meta.connectPikkuFuncName) {
                     runPikkuFuncDirectly(meta.connectPikkuFuncName, { ...allServices, channel }, openingData);

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

@@ -1,9 +1,8 @@
-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;
+import { CoreServices, CoreUserSession } from '../types/core.types.js';
+import { CorePermissionGroup, CorePikkuFunctionConfig } from './functions.types.js';
+export declare const addFunction: (funcName: string, funcConfig: CorePikkuFunctionConfig<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;
+export declare const runPikkuFunc: <In = any, Out = any>(funcName: string, { getAllServices, data, session, permissions: transportPermissions, coerceDataFromSchema, }: {
     getAllServices: () => Promise<CoreServices> | CoreServices;
     data: In;
     session?: CoreUserSession;

package/dist/function/function-runner.js

@@ -2,37 +2,79 @@ 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);
+// Permission merging function
+function mergePermissions(logger, funcName, funcPermissions, transportPermissions) {
+    if (!funcPermissions && !transportPermissions) {
+        return undefined;
+    }
+    if (!funcPermissions) {
+        return transportPermissions;
+    }
+    if (!transportPermissions) {
+        return funcPermissions;
+    }
+    // Start with a copy of function permissions
+    const mergedPermissions = { ...funcPermissions };
+    // Merge in transport permissions
+    for (const [key, transportValue] of Object.entries(transportPermissions)) {
+        if (key in mergedPermissions) {
+            // For permission arrays, concatenate and deduplicate values
+            if (Array.isArray(mergedPermissions[key]) &&
+                Array.isArray(transportValue)) {
+                mergedPermissions[key] = [
+                    ...new Set([...mergedPermissions[key], ...transportValue]),
+                ];
+            }
+            // For other types, warn about conflict and use the more restrictive (transport-level) value
+            else {
+                logger.warn(`Permission conflict on key "${key}" for function "${funcName}". Using transport-level permission.`);
+                mergedPermissions[key] = transportValue;
+            }
+        }
+        else {
+            // If key doesn't exist in function permissions, add it
+            mergedPermissions[key] = transportValue;
+        }
+    }
+    return mergedPermissions;
+}
+export const addFunction = (funcName, funcConfig) => {
+    pikkuState('function', 'functions').set(funcName, funcConfig);
 };
 export const runPikkuFuncDirectly = async (funcName, allServices, data, session) => {
-    const func = pikkuState('functions', 'nameToFunction').get(funcName);
-    if (!func) {
+    const funcConfig = pikkuState('function', 'functions').get(funcName);
+    if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
     }
-    return (await func(allServices, data, session));
+    return (await funcConfig.func(allServices, data, session));
 };
-export const runPikkuFunc = async (funcName, { singletonServices, getAllServices, data, session, permissions, coerceDataFromSchema, }) => {
-    const func = pikkuState('functions', 'nameToFunction').get(funcName);
-    if (!func) {
+export const runPikkuFunc = async (funcName, { getAllServices, data, session, permissions: transportPermissions, coerceDataFromSchema, }) => {
+    const funcConfig = pikkuState('function', 'functions').get(funcName);
+    if (!funcConfig) {
         throw new Error(`Function not found: ${funcName}`);
     }
-    const funcMeta = pikkuState('functions', 'meta')[funcName];
+    const funcMeta = pikkuState('function', '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);
+    if (funcConfig.auth && !session) {
+        throw new ForbiddenError(`Function ${funcName} requires authentication even though transport does not`);
     }
     const allServices = await getAllServices();
+    const schemaName = funcMeta.schemaName;
+    if (schemaName) {
+        // Validate request data against the defined schema, if any
+        await validateSchema(allServices.logger, allServices.schema, schemaName, data);
+        // Coerce (top level) query string parameters or date objects if specified by the schema
+        if (coerceDataFromSchema) {
+            coerceTopLevelDataFromSchema(schemaName, data);
+        }
+    }
     // Execute permission checks
-    const permissioned = await verifyPermissions(permissions, allServices, data, session);
+    const mergedPermissions = mergePermissions(allServices.logger, funcName, funcConfig.permissions, transportPermissions);
+    const permissioned = await verifyPermissions(mergedPermissions, allServices, data, session);
     if (permissioned === false) {
         throw new ForbiddenError('Permission denied');
     }
-    return (await func(allServices, data, session));
+    return (await funcConfig.func(allServices, data, session));
 };

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

@@ -35,3 +35,8 @@ export type CoreAPIFunctionSessionless<In, Out, ChannelData extends unknown | nu
  */
 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;
+export type CorePikkuFunctionConfig<APIFunction extends CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>, APIPermission extends CoreAPIPermission<any> = CoreAPIPermission<any>> = {
+    func: APIFunction;
+    auth?: boolean;
+    permissions?: CorePermissionGroup<APIPermission>;
+};

package/dist/http/http-runner.js

@@ -8,6 +8,7 @@ import { pikkuState } from '../pikku-state.js';
 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';
 /**
  * Registers middleware either globally or for a specific route.
  *
@@ -54,7 +55,11 @@ export const addHTTPRoute = (httpRoute) => {
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
-    addFunction(routeMeta.pikkuFuncName, httpRoute.func);
+    addFunction(routeMeta.pikkuFuncName, {
+        func: httpRoute.func,
+        auth: httpRoute.auth,
+        permissions: httpRoute.permissions,
+    });
     const routes = pikkuState('http', 'routes');
     if (!routes.has(httpRoute.method)) {
         routes.set(httpRoute.method, new Map());
@@ -204,16 +209,15 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
             }
             // Create session-specific services for handling the request
             sessionServices = await createSessionServices({ ...singletonServices, userSession, channel }, { http }, session);
-            return {
+            return rpcService.injectRPCService({
                 ...singletonServices,
                 ...sessionServices,
                 http,
                 userSession,
                 channel,
-            };
+            });
         };
         const result = await runPikkuFunc(meta.pikkuFuncName, {
-            singletonServices,
             getAllServices,
             session,
             data,

package/dist/pikku-state.d.ts

@@ -3,11 +3,15 @@ import { CoreHTTPFunctionRoute, HTTPMethod, HTTPRoutesMeta } from './http/http.t
 import { FunctionsMeta, PikkuMiddleware } from './types/core.types.js';
 import { CoreScheduledTask, ScheduledTasksMeta } from './scheduler/scheduler.types.js';
 import { ErrorDetails, PikkuError } from './errors/error-handler.js';
-import { CoreAPIFunction, CoreAPIFunctionSessionless } from './function/functions.types.js';
+import { CorePikkuFunctionConfig } from './function/functions.types.js';
+import { RPCMeta } from './rpc/rpc-types.js';
 interface PikkuState {
-    functions: {
+    function: {
         meta: FunctionsMeta;
-        nameToFunction: Map<string, CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>>;
+        functions: Map<string, CorePikkuFunctionConfig<any, any>>;
+    };
+    rpc: {
+        meta: Record<string, RPCMeta>;
     };
     http: {
         middleware: Array<{

package/dist/pikku-state.js

@@ -1,8 +1,11 @@
 export const resetPikkuState = () => {
     globalThis.pikkuState = {
-        functions: {
+        function: {
+            meta: {},
+            functions: new Map(),
+        },
+        rpc: {
             meta: {},
-            nameToFunction: new Map(),
         },
         http: {
             middleware: [],

package/dist/rpc/index.d.ts

@@ -0,0 +1 @@
+export { initialize } from './rpc-runner.js';

package/dist/rpc/index.js

@@ -0,0 +1 @@
+export { initialize } from './rpc-runner.js';

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

@@ -0,0 +1,31 @@
+import { CoreSingletonServices, CoreServices, CreateSessionServices, CoreUserSession } from '../types/core.types.js';
+type RPCServiceConfig = {
+    singletonServices: CoreSingletonServices;
+    createSessionServices: CreateSessionServices;
+    coerceDataFromSchema: boolean;
+};
+export declare class PikkuRPCService {
+    private config?;
+    initialize(config: RPCServiceConfig): void;
+    injectRPCService(coreServices: CoreServices, depth?: number): {
+        jwt?: import("../index.js").JWTService;
+        schema?: import("../index.js").SchemaService;
+        config: {
+            logLevel?: import("../index.js").LogLevel;
+            secrets?: {};
+        };
+        logger: import("../index.js").Logger;
+        variables: import("../index.js").VariablesService;
+        eventHub?: import("../index.js").EventHubService<unknown>;
+        secrets?: import("../index.js").SecretService;
+        http?: import("../index.js").PikkuHTTP;
+        rpc?: import("./rpc-types.js").PikkuRPC;
+        userSession?: import("../services/user-session-service.js").UserSessionService<CoreUserSession> | undefined;
+        channel?: import("../index.js").PikkuChannel<unknown, unknown>;
+    };
+    rpc<In = any, Out = any>(funcName: string, data: In, session?: CoreUserSession): Promise<Out>;
+}
+export declare const rpcService: PikkuRPCService;
+export declare const initialize: (config: RPCServiceConfig) => void;
+export declare const pikkuRPC: <In = any, Out = any, session = CoreUserSession>(funcName: string, data: In, session?: CoreUserSession) => Promise<Out>;
+export {};

package/dist/rpc/rpc-runner.js

@@ -0,0 +1,101 @@
+import { runPikkuFunc } from '../function/function-runner.js';
+import { pikkuState } from '../pikku-state.js';
+import { PikkuUserSessionService } from '../services/user-session-service.js';
+const getRPCMeta = (rpcName) => {
+    const rpc = pikkuState('rpc', 'meta');
+    const rpcMeta = rpc[rpcName];
+    if (!rpcMeta) {
+        throw new Error(`RPC function not found: ${rpcName}`);
+    }
+    return rpcMeta;
+};
+// Context-aware RPC client for use within services
+class ServiceRPC {
+    services;
+    options;
+    constructor(services, options) {
+        this.services = services;
+        this.options = options;
+    }
+    async rpc(funcName, data) {
+        const session = await this.services.userSession?.get();
+        const rpcDepth = this.services.rpc?.depth || 0;
+        const rpcMeta = getRPCMeta(funcName);
+        return runPikkuFunc(rpcMeta.pikkuFuncName, {
+            getAllServices: () => {
+                this.services.rpc = this.services.rpc
+                    ? {
+                        ...this.services.rpc,
+                        depth: rpcDepth + 1,
+                        global: false,
+                    }
+                    : undefined;
+                return this.services;
+            },
+            data,
+            session,
+            coerceDataFromSchema: this.options.coerceDataFromSchema,
+        });
+    }
+}
+// RPC Service class for the global interface
+export class PikkuRPCService {
+    config;
+    // Initialize the RPC service with configuration
+    initialize(config) {
+        this.config = config;
+    }
+    // Convenience function for initializing
+    injectRPCService(coreServices, depth = 0) {
+        const serviceCopy = {
+            ...coreServices,
+        };
+        const serviceRPC = new ServiceRPC(serviceCopy, {
+            coerceDataFromSchema: this.config?.coerceDataFromSchema,
+        });
+        serviceCopy.rpc = {
+            depth,
+            global: false,
+            invoke: serviceRPC.rpc.bind(serviceRPC),
+        };
+        return serviceCopy;
+    }
+    //   Global RPC method to call functions by name
+    async rpc(funcName, data, session) {
+        if (!this.config) {
+            throw new Error('RPC service not initialized');
+        }
+        const rpcMeta = getRPCMeta(funcName);
+        const { singletonServices, createSessionServices, coerceDataFromSchema } = this.config;
+        // Define the getAllServices function for runPikkuFunc
+        const getAllServices = async () => {
+            const userSession = new PikkuUserSessionService();
+            if (session) {
+                userSession.set(session);
+            }
+            const sessionServices = await createSessionServices(singletonServices, {}, session);
+            return this.injectRPCService({
+                ...singletonServices,
+                ...sessionServices,
+                userSession,
+            }, 0);
+        };
+        // Call the function using runPikkuFunc - it will handle permission merging
+        return runPikkuFunc(rpcMeta.pikkuFuncName, {
+            getAllServices,
+            data,
+            session,
+            coerceDataFromSchema: coerceDataFromSchema ?? true,
+        });
+    }
+}
+// Create a singleton instance
+export const rpcService = new PikkuRPCService();
+// Convenience function for initializing
+export const initialize = (config) => {
+    rpcService.initialize(config);
+};
+// Convenience function for making standalone RPC calls
+export const pikkuRPC = (funcName, data, session) => {
+    return rpcService.rpc(funcName, data, session);
+};

package/dist/rpc/rpc-types.d.ts

@@ -0,0 +1,9 @@
+export type PikkuRPC = {
+    depth: number;
+    global: boolean;
+    invoke: any;
+};
+export type RPCMeta = {
+    pikkuFuncName: string;
+    exposed: boolean;
+};

package/dist/rpc/rpc-types.js

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

package/dist/scheduler/scheduler-runner.js

@@ -2,13 +2,16 @@ import { getErrorResponse } from '../errors/error-handler.js';
 import { closeSessionServices } from '../utils.js';
 import { pikkuState } from '../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../function/function-runner.js';
+import { rpcService } from '../rpc/rpc-runner.js';
 export const addScheduledTask = (scheduledTask) => {
     const meta = pikkuState('scheduler', 'meta');
     const taskMeta = meta[scheduledTask.name];
     if (!taskMeta) {
         throw new Error('Task metadata not found');
     }
-    addFunction(taskMeta.pikkuFuncName, scheduledTask.func);
+    addFunction(taskMeta.pikkuFuncName, {
+        func: scheduledTask.func,
+    });
     const tasks = pikkuState('scheduler', 'tasks');
     if (tasks.has(scheduledTask.name)) {
         throw new Error(`Scheduled task already exists: ${scheduledTask.name}`);
@@ -35,12 +38,14 @@ export async function runScheduledTask({ name, session, singletonServices, creat
         const getAllServices = async () => {
             if (createSessionServices) {
                 const sessionServices = await createSessionServices(singletonServices, {}, session);
-                return { ...singletonServices, ...sessionServices };
+                return rpcService.injectRPCService({
+                    ...singletonServices,
+                    ...sessionServices,
+                });
             }
             return singletonServices;
         };
         return await runPikkuFunc(meta.pikkuFuncName, {
-            singletonServices,
             getAllServices,
             session,
             data: undefined,

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

@@ -7,6 +7,7 @@ import { UserSessionService } from '../services/user-session-service.js';
 import { JWTService } from '../services/jwt-service.js';
 import { SecretService } from '../services/secret-service.js';
 import { PikkuChannel } from '../channel/channel.types.js';
+import { PikkuRPC } from '../rpc/rpc-types.js';
 export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];
@@ -93,6 +94,7 @@ export type PikkuMiddleware<SingletonServices extends CoreSingletonServices = Co
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.
  */
 export type CoreServices<SingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession, CoreServices extends Record<string, unknown> = {}> = SingletonServices & PikkuInteraction & {
+    rpc?: PikkuRPC;
     userSession?: UserSessionService<UserSession>;
     channel?: PikkuChannel<unknown, unknown>;
 } & CoreServices;