@pikku/core 0.9.10 → 0.9.12-next.0

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

@@ -1,5 +1,5 @@
-import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
-import { CorePikkuMiddleware } from '../../types/core.types.js';
+import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import { CorePikkuMiddleware, MiddlewareMetadata } from '../../types/core.types.js';
 export type PikkuMCP<Tools extends string = any> = {
     uri?: string;
     sendResourceUpdated: (uri: string) => void;
@@ -10,23 +10,25 @@ export type PikkuMCP<Tools extends string = any> = {
 /**
  * Represents metadata for MCP resources, including name, description, and documentation.
  */
-export type MCPResourceMeta = Record<string, Omit<CoreMCPResource, 'func'> & {
+export type MCPResourceMeta = Record<string, Omit<CoreMCPResource, 'func' | 'middleware'> & {
     pikkuFuncName: string;
     inputSchema: string | null;
     outputSchema: string | null;
+    middleware?: MiddlewareMetadata[];
 }>;
 /**
  * Represents metadata for MCP tools, including name, description, and documentation.
  */
-export type MCPToolMeta = Record<string, Omit<CoreMCPTool, 'func'> & {
+export type MCPToolMeta = Record<string, Omit<CoreMCPTool, 'func' | 'middleware'> & {
     pikkuFuncName: string;
     inputSchema: string | null;
     outputSchema: string | null;
+    middleware?: MiddlewareMetadata[];
 }>;
 /**
  * Represents metadata for MCP prompts, including name, description, and arguments.
  */
-export type MCPPromptMeta = Record<string, Omit<CoreMCPPrompt, 'func'> & {
+export type MCPPromptMeta = Record<string, Omit<CoreMCPPrompt, 'func' | 'middleware'> & {
     pikkuFuncName: string;
     inputSchema: string | null;
     outputSchema: string | null;
@@ -35,11 +37,12 @@ export type MCPPromptMeta = Record<string, Omit<CoreMCPPrompt, 'func'> & {
         description: string;
         required: boolean;
     }>;
+    middleware?: MiddlewareMetadata[];
 }>;
 /**
  * Represents an MCP resource with specific properties.
  */
-export type CoreMCPResource<PikkuFunction = CorePikkuFunctionSessionless<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
+export type CoreMCPResource<PikkuFunction = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     uri: string;
     title: string;
     description?: string;
@@ -53,7 +56,7 @@ export type CoreMCPResource<PikkuFunction = CorePikkuFunctionSessionless<any, an
 /**
  * Represents an MCP tool with specific properties.
  */
-export type CoreMCPTool<PikkuFunction = CorePikkuFunctionSessionless<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
+export type CoreMCPTool<PikkuFunction = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     title?: string;
     description: string;
@@ -66,7 +69,7 @@ export type CoreMCPTool<PikkuFunction = CorePikkuFunctionSessionless<any, any>,
 /**
  * Represents an MCP prompt with specific properties.
  */
-export type CoreMCPPrompt<PikkuFunction = CorePikkuFunctionSessionless<any, MCPPromptResponse>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
+export type CoreMCPPrompt<PikkuFunction = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, MCPPromptResponse>>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     description?: string;
     func: PikkuFunction;

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

@@ -1,6 +1,6 @@
 import type { CoreServices } from '../../types/core.types.js';
 import type { CoreQueueWorker, QueueJob } from './queue.types.js';
-import type { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 import { PikkuError } from '../../errors/error-handler.js';
 import { CreateSessionServices } from '../../types/core.types.js';
 /**
@@ -18,7 +18,7 @@ export declare class QueueJobDiscardedError extends PikkuError {
 /**
  * Add a queue processor to the system
  */
-export declare const wireQueueWorker: <InputData = any, OutputData = any, PikkuFunction extends CorePikkuFunctionSessionless<InputData, OutputData> = CorePikkuFunctionSessionless<InputData, OutputData>>(queueWorker: CoreQueueWorker<PikkuFunction>) => void;
+export declare const wireQueueWorker: <InputData = any, OutputData = any, PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<InputData, OutputData>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<InputData, OutputData>>>(queueWorker: CoreQueueWorker<PikkuFunctionConfig>) => void;
 /**
  * Get all registered queue processors
  */

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

@@ -2,7 +2,6 @@ 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
  */
@@ -40,7 +39,14 @@ export const wireQueueWorker = (queueWorker) => {
         throw new Error(`Queue processor metadata not found for '${queueWorker.queueName}'. Make sure to run the CLI to generate metadata.`);
     }
     // Register the function with pikku
-    addFunction(processorMeta.pikkuFuncName, queueWorker.func);
+    addFunction(processorMeta.pikkuFuncName, {
+        func: queueWorker.func.func,
+        auth: queueWorker.func.auth,
+        permissions: queueWorker.func.permissions,
+        middleware: queueWorker.func.middleware,
+        tags: queueWorker.func.tags,
+        docs: queueWorker.func.docs,
+    });
     // Store processor definition in state - runtime adapters will pick this up
     const registrations = pikkuState('queue', 'registrations');
     registrations.set(queueWorker.queueName, queueWorker);
@@ -96,33 +102,25 @@ export async function runQueueJob({ singletonServices, createSessionServices, jo
     };
     try {
         logger.info(`Processing job ${job.id} in queue ${job.queueName}`);
-        let result;
-        // Main job execution logic wrapped for middleware handling
-        const runMain = async () => {
-            // Use provided singleton services
-            const getAllServices = () => ({
+        // Use provided singleton services
+        const getAllServices = async () => {
+            const sessionServices = await createSessionServices?.(singletonServices, { queue }, undefined);
+            return {
                 ...singletonServices,
-                ...(createSessionServices
-                    ? createSessionServices(singletonServices, { queue }, undefined)
-                    : {}),
-            });
-            // Execute the pikku function with the job data
-            result = await runPikkuFunc(PikkuWiringTypes.queue, job.queueName, processorMeta.pikkuFuncName, {
-                getAllServices,
-                data: job.data,
-                tags: queueWorker.tags,
-            });
-            logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
+                ...sessionServices,
+            };
         };
-        // 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(PikkuWiringTypes.queue, `${job.queueName}:${job.id}`, {
-            wiringMiddleware: queueWorker.middleware,
-            wiringTags: queueWorker.tags,
-            funcMiddleware: funcConfig?.middleware,
-            funcTags: funcConfig?.tags,
-        }), runMain);
+        // Execute the pikku function with the job data
+        const result = await runPikkuFunc(PikkuWiringTypes.queue, job.queueName, processorMeta.pikkuFuncName, {
+            singletonServices,
+            getAllServices,
+            data: () => job.data,
+            inheritedMiddleware: processorMeta.middleware,
+            wireMiddleware: queueWorker.middleware,
+            tags: queueWorker.tags,
+            interaction: { queue },
+        });
+        logger.debug(`Successfully processed job ${job.id} in queue ${job.queueName}`);
         return result;
     }
     catch (error) {

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

@@ -1,5 +1,5 @@
-import { PikkuDocs, CorePikkuMiddleware } from '../../types/core.types.js';
-import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import { PikkuDocs, MiddlewareMetadata } from '../../types/core.types.js';
+import { CorePikkuFunctionConfig } from '../../function/functions.types.js';
 import { QueueConfigMapping } from './validate-worker-config.js';
 /**
  * Configuration for queue workers - how jobs are processed
@@ -140,18 +140,19 @@ export type queueWorkersMeta = Record<string, {
     docs?: PikkuDocs;
     tags?: string[];
     config?: PikkuWorkerConfig;
+    middleware?: MiddlewareMetadata[];
 }>;
 /**
  * Core queue processor definition
  */
-export type CoreQueueWorker<PikkuFunction = CorePikkuFunctionSessionless<any, any>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
+export type CoreQueueWorker<PikkuFunctionConfig extends CorePikkuFunctionConfig<any, any, any> = CorePikkuFunctionConfig<any, any, any>> = {
     queueName: string;
-    func: PikkuFunction;
+    func: PikkuFunctionConfig;
     config?: PikkuWorkerConfig;
     docs?: PikkuDocs;
     session?: undefined;
     tags?: string[];
-    middleware?: PikkuMiddleware[];
+    middleware?: PikkuFunctionConfig['middleware'];
 };
 /**
  * Represents a queue interaction object for middleware

package/dist/wirings/rpc/index.d.ts

@@ -1,2 +1,2 @@
-export { initialize } from './rpc-runner.js';
+export { initialize, PikkuRPCService } from './rpc-runner.js';
 export type { PikkuRPC, RPCMeta } from './rpc-types.js';

package/dist/wirings/rpc/index.js

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

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

@@ -1,27 +1,15 @@
-import { CoreServices } from '../../types/core.types.js';
+import { CoreServices, PikkuInteraction } from '../../types/core.types.js';
+import { PikkuRPC } from './rpc-types.js';
 type RPCServiceConfig = {
     coerceDataFromSchema: boolean;
 };
-export declare class PikkuRPCService {
+export declare class PikkuRPCService<Services extends CoreServices, TypedRPC = PikkuRPC> {
     private config?;
     initialize(config: RPCServiceConfig): void;
-    injectRPCService(coreServices: CoreServices, depth?: number): {
-        schema?: import("../../index.js").SchemaService;
-        config: {
-            logLevel?: import("../../index.js").LogLevel;
-            secrets?: {};
-        };
-        logger: import("../../index.js").Logger;
-        variables: import("../../services/variables-service.js").VariablesService;
-        http?: import("../http/http.types.js").PikkuHTTP<unknown> | undefined;
-        mcp?: import("../mcp/mcp.types.js").PikkuMCP | undefined;
-        rpc?: import("./rpc-types.js").PikkuRPC | undefined;
-        channel?: import("../channel/channel.types.js").PikkuChannel<unknown, unknown> | undefined;
-        scheduledTask?: import("../scheduler/scheduler.types.js").PikkuScheduledTask | undefined;
-        queue?: import("../queue/queue.types.js").PikkuQueue | undefined;
-        userSession?: import("../../index.js").UserSessionService<import("../../types/core.types.js").CoreUserSession> | undefined;
+    injectRPCService(services: Services, interaction: PikkuInteraction, requiresAuth?: boolean | undefined, depth?: number): Services & {
+        rpc: TypedRPC;
     };
 }
-export declare const rpcService: PikkuRPCService;
+export declare const rpcService: PikkuRPCService<CoreServices, PikkuRPC>;
 export declare const initialize: (config: RPCServiceConfig) => void;
 export {};

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

@@ -1,4 +1,4 @@
-import { PikkuWiringTypes } from '../../types/core.types.js';
+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';
@@ -13,9 +13,11 @@ const getPikkuFunctionName = (rpcName) => {
 // Context-aware RPC client for use within services
 class ContextAwareRPCService {
     services;
+    interaction;
     options;
-    constructor(services, options) {
+    constructor(services, interaction, options) {
         this.services = services;
+        this.interaction = interaction;
         this.options = options;
     }
     async rpcExposed(funcName, data) {
@@ -29,10 +31,11 @@ class ContextAwareRPCService {
         return await this.rpc(funcName, data);
     }
     async rpc(funcName, data) {
-        const session = await this.services.userSession?.get();
         const rpcDepth = this.services.rpc?.depth || 0;
         const pikkuFuncName = getPikkuFunctionName(funcName);
         return runPikkuFunc(PikkuWiringTypes.rpc, pikkuFuncName, pikkuFuncName, {
+            auth: this.options.requiresAuth,
+            singletonServices: this.services,
             getAllServices: () => {
                 this.services.rpc = this.services.rpc
                     ? {
@@ -43,9 +46,10 @@ class ContextAwareRPCService {
                     : undefined;
                 return this.services;
             },
-            data,
-            session,
+            data: () => data,
+            userSession: this.services.userSession,
             coerceDataFromSchema: this.options.coerceDataFromSchema,
+            interaction: this.interaction,
         });
     }
 }
@@ -57,12 +61,13 @@ export class PikkuRPCService {
         this.config = config;
     }
     // Convenience function for initializing
-    injectRPCService(coreServices, depth = 0) {
+    injectRPCService(services, interaction, requiresAuth, depth = 0) {
         const serviceCopy = {
-            ...coreServices,
+            ...services,
         };
-        const serviceRPC = new ContextAwareRPCService(serviceCopy, {
+        const serviceRPC = new ContextAwareRPCService(serviceCopy, interaction, {
             coerceDataFromSchema: this.config?.coerceDataFromSchema,
+            requiresAuth,
         });
         serviceCopy.rpc = {
             depth,

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

@@ -1,12 +1,12 @@
 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';
+import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;
     singletonServices: CoreSingletonServices;
     createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
-export declare const wireScheduler: <PikkuFunction extends CorePikkuFunctionSessionless<void, void>>(scheduledTask: CoreScheduledTask<PikkuFunction>) => void;
+export declare const wireScheduler: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<void, void>>>(scheduledTask: CoreScheduledTask<PikkuFunctionConfig>) => void;
 export declare function runScheduledTask({ name, session, singletonServices, createSessionServices, }: RunScheduledTasksParams): Promise<void>;
 export declare const getScheduledTasks: () => Map<string, CoreScheduledTask>;

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

@@ -4,14 +4,21 @@ 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';
-import { combineMiddleware, runMiddleware } from '../../middleware-runner.js';
+import { PikkuUserSessionService } from '../../services/user-session-service.js';
 export const wireScheduler = (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.func,
+        auth: scheduledTask.func.auth,
+        permissions: scheduledTask.func.permissions,
+        middleware: scheduledTask.func.middleware,
+        tags: scheduledTask.func.tags,
+        docs: scheduledTask.func.docs,
+    });
     const tasks = pikkuState('scheduler', 'tasks');
     if (tasks.has(scheduledTask.name)) {
         throw new Error(`Scheduled task already exists: ${scheduledTask.name}`);
@@ -33,6 +40,10 @@ export async function runScheduledTask({ name, session, singletonServices, creat
     let sessionServices;
     const task = pikkuState('scheduler', 'tasks').get(name);
     const meta = pikkuState('scheduler', 'meta')[name];
+    const userSession = new PikkuUserSessionService();
+    if (session) {
+        userSession.set(session);
+    }
     if (!task) {
         throw new ScheduledTaskNotFoundError(`Scheduled task not found: ${name}`);
     }
@@ -40,44 +51,35 @@ export async function runScheduledTask({ name, session, singletonServices, creat
         throw new ScheduledTaskNotFoundError(`Scheduled task meta not found: ${name}`);
     }
     // Create the scheduled task interaction object
-    const scheduledTask = {
-        name,
-        schedule: task.schedule,
-        executionTime: new Date(),
-        skip: (reason) => {
-            throw new ScheduledTaskSkippedError(name, reason);
+    const interaction = {
+        scheduledTask: {
+            name,
+            schedule: task.schedule,
+            executionTime: new Date(),
+            skip: (reason) => {
+                throw new ScheduledTaskSkippedError(name, reason);
+            },
         },
     };
     try {
         singletonServices.logger.info(`Running schedule task: ${name} | schedule: ${task.schedule}`);
-        let result;
-        // Main scheduled task execution logic wrapped for middleware handling
-        const runMain = async () => {
-            const getAllServices = async () => {
-                if (createSessionServices) {
-                    const services = await createSessionServices(singletonServices, { scheduledTask }, session);
-                    sessionServices = services;
-                    return rpcService.injectRPCService({
-                        ...singletonServices,
-                        ...services,
-                    });
-                }
-                return singletonServices;
-            };
-            result = await runPikkuFunc(PikkuWiringTypes.scheduler, meta.name, meta.pikkuFuncName, {
-                getAllServices,
-                session,
-                data: undefined,
-                tags: task.tags,
-            });
+        const getAllServices = async () => {
+            sessionServices = await createSessionServices?.(singletonServices, interaction, session);
+            return rpcService.injectRPCService({
+                ...singletonServices,
+                ...sessionServices,
+            }, interaction);
         };
-        const funcConfig = pikkuState('function', 'functions').get(meta.pikkuFuncName);
-        await runMiddleware(singletonServices, { scheduledTask }, combineMiddleware(PikkuWiringTypes.scheduler, meta.name, {
-            wiringMiddleware: task.middleware,
-            wiringTags: task.tags,
-            funcMiddleware: funcConfig?.middleware,
-            funcTags: funcConfig?.tags,
-        }), runMain);
+        const result = await runPikkuFunc(PikkuWiringTypes.scheduler, meta.name, meta.pikkuFuncName, {
+            singletonServices,
+            getAllServices,
+            userSession,
+            data: () => undefined,
+            inheritedMiddleware: meta.middleware,
+            wireMiddleware: task.middleware,
+            tags: task.tags,
+            interaction,
+        });
         return result;
     }
     catch (e) {

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

@@ -1,5 +1,5 @@
-import { PikkuDocs, CoreUserSession, CorePikkuMiddleware } from '../../types/core.types.js';
-import { CorePikkuFunctionSessionless } from '../../function/functions.types.js';
+import { PikkuDocs, CoreUserSession, CorePikkuMiddleware, MiddlewareMetadata } from '../../types/core.types.js';
+import { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 /**
  * Represents metadata for scheduled tasks, including title, schedule, and documentation.
  */
@@ -10,11 +10,12 @@ export type ScheduledTasksMeta<UserSession extends CoreUserSession = any> = Reco
     session?: UserSession;
     docs?: PikkuDocs;
     tags?: string[];
+    middleware?: MiddlewareMetadata[];
 }>;
 /**
  * Represents a core scheduled task.
  */
-export type CoreScheduledTask<PikkuFunction = CorePikkuFunctionSessionless<void, void>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
+export type CoreScheduledTask<PikkuFunction = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<void, void>>, PikkuMiddleware = CorePikkuMiddleware<any>> = {
     name: string;
     schedule: string;
     func: PikkuFunction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.9.10",
+  "version": "0.9.12-next.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -8,8 +8,7 @@
   "type": "module",
   "scripts": {
     "tsc": "tsc",
-    "build:esm": "tsc -b",
-    "build": "yarn build:esm",
+    "build": "tsc -b",
     "ncu": "npx npm-check-updates",
     "release": "npm run build && npm test",
     "test": "bash run-tests.sh",
@@ -28,8 +27,10 @@
     "./scheduler": "./dist/wirings/scheduler/index.js",
     "./rpc": "./dist/wirings/rpc/index.js",
     "./mcp": "./dist/wirings/mcp/index.js",
+    "./cli/channel": "./dist/wirings/cli/channel/index.js",
     "./errors": "./dist/errors/index.js",
     "./services": "./dist/services/index.js",
+    "./services/local-content": "./dist/services/local-content.js",
     "./schema": "./dist/schema.js",
     "./types": "./dist/types/index.d.ts"
   },