@pikku/core 0.11.0 → 0.11.2

package/dist/pikku-state.d.ts

@@ -1,106 +1,34 @@
-import { ChannelsMeta, CoreChannel } from './wirings/channel/channel.types.js';
-import { CoreHTTPFunctionWiring, HTTPMethod, HTTPWiringsMeta } from './wirings/http/http.types.js';
-import { FunctionsMeta, CorePikkuMiddleware, CorePikkuMiddlewareGroup, FunctionServicesMeta } from './types/core.types.js';
-import { CoreScheduledTask, ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js';
-import { ErrorDetails, PikkuError } from './errors/error-handler.js';
-import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuPermission } from './function/functions.types.js';
-import { QueueWorkersMeta, CoreQueueWorker } from './wirings/queue/queue.types.js';
-import { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from './wirings/mcp/mcp.types.js';
-import { CLIMeta, CLIProgramState } from './wirings/cli/cli.types.js';
-import { CoreWorkflow, WorkflowsMeta } from './wirings/workflow/workflow.types.js';
-interface PikkuState {
-    function: {
-        meta: FunctionsMeta;
-        functions: Map<string, CorePikkuFunctionConfig<any, any>>;
-    };
-    rpc: {
-        meta: Record<string, string>;
-        files: Map<string, {
-            exportedName: string;
-            path: string;
-        }>;
-    };
-    http: {
-        middleware: Map<string, CorePikkuMiddleware<any, any>[]>;
-        permissions: Map<string, CorePermissionGroup | CorePikkuPermission[]>;
-        routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionWiring<any, any, any>>>;
-        meta: HTTPWiringsMeta;
-    };
-    channel: {
-        channels: Map<string, CoreChannel<any, any>>;
-        meta: ChannelsMeta;
-    };
-    scheduler: {
-        tasks: Map<string, CoreScheduledTask>;
-        meta: ScheduledTasksMeta;
-    };
-    queue: {
-        registrations: Map<string, CoreQueueWorker>;
-        meta: QueueWorkersMeta;
-    };
-    workflows: {
-        registrations: Map<string, CoreWorkflow>;
-        meta: WorkflowsMeta;
-    };
-    mcp: {
-        resources: Map<string, CoreMCPResource>;
-        resourcesMeta: MCPResourceMeta;
-        tools: Map<string, CoreMCPTool>;
-        toolsMeta: MCPToolMeta;
-        prompts: Map<string, CoreMCPPrompt>;
-        promptsMeta: MCPPromptMeta;
-    };
-    cli: {
-        meta: CLIMeta | Record<string, any>;
-        programs: Record<string, CLIProgramState>;
-    };
-    middleware: {
-        tagGroup: Record<string, CorePikkuMiddlewareGroup>;
-        httpGroup: Record<string, CorePikkuMiddlewareGroup>;
-        tagGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            middlewareCount: number;
-            isFactory: boolean;
-        }>;
-        httpGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            middlewareCount: number;
-            isFactory: boolean;
-        }>;
-    };
-    permissions: {
-        tagGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
-        httpGroup: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
-        tagGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            permissionCount: number;
-            isFactory: boolean;
-        }>;
-        httpGroupMeta: Record<string, {
-            exportName: string | null;
-            sourceFile: string;
-            position: number;
-            services: FunctionServicesMeta;
-            permissionCount: number;
-            isFactory: boolean;
-        }>;
-    };
-    misc: {
-        errors: Map<PikkuError, ErrorDetails>;
-        schemas: Map<string, any>;
-        middleware: Record<string, CorePikkuMiddleware[]>;
-        permissions: Record<string, CorePermissionGroup | CorePikkuPermission[]>;
-    };
+import { PikkuPackageState } from './index.js';
+declare global {
+    var pikkuState: Map<string, PikkuPackageState> | undefined;
 }
+/**
+ * Get or set package-scoped pikku state
+ *
+ * @param packageName - Package name (null for main package, '@scope/package' for external packages)
+ * @param type - State category (function, rpc, http, etc.)
+ * @param content - Content key within the category
+ * @param value - Optional value to set
+ * @returns The current value of the state
+ *
+ * @example
+ * // Main package
+ * pikkuState(null, 'function', 'functions').get(funcName)
+ *
+ * // External package
+ * pikkuState('@acme/stripe-functions', 'rpc', 'meta')
+ */
+export declare const pikkuState: <Type extends keyof PikkuPackageState, Content extends keyof PikkuPackageState[Type]>(packageName: string | null, type: Type, content: Content, value?: PikkuPackageState[Type][Content]) => PikkuPackageState[Type][Content];
+/**
+ * Initialize state for a new package
+ */
+export declare const initializePikkuState: (packageName: string) => void;
 export declare const resetPikkuState: () => void;
-export declare const pikkuState: <Type extends keyof PikkuState, Content extends keyof PikkuState[Type]>(type: Type, content: Content, value?: PikkuState[Type][Content]) => PikkuState[Type][Content];
-export {};
+/**
+ * Register service factories for an external package.
+ * These factories are used to create services when the package's functions are invoked.
+ *
+ * @param packageName - The package name (e.g., '@pikku/templates-function-external')
+ * @param factories - The service factory functions
+ */
+export declare const addPackageServiceFactories: (packageName: string, factories: NonNullable<PikkuPackageState["package"]["factories"]>) => void;

package/dist/pikku-state.js

@@ -1,72 +1,146 @@
-export const resetPikkuState = () => {
-    globalThis.pikkuState = {
-        function: {
-            meta: {},
-            functions: new Map(),
-        },
-        rpc: {
-            meta: {},
-            files: new Map(),
-        },
-        http: {
-            permissions: new Map(),
-            routes: new Map(),
-            meta: {},
-        },
-        channel: {
-            channels: new Map(),
-            meta: {},
-        },
-        scheduler: {
-            tasks: new Map(),
-            meta: [],
-        },
-        queue: {
-            registrations: new Map(),
-            meta: {},
-        },
-        workflows: {
-            registrations: new Map(),
-            meta: {},
-        },
-        mcp: {
-            resources: new Map(),
-            resourcesMeta: {},
-            tools: new Map(),
-            toolsMeta: {},
-            prompts: new Map(),
-            promptsMeta: {},
-        },
-        cli: {
-            meta: { programs: {}, renderers: {} },
-            programs: {},
-        },
-        middleware: {
-            tagGroup: {},
-            httpGroup: {},
-            tagGroupMeta: {},
-            httpGroupMeta: {},
-        },
-        permissions: {
-            tagGroup: {},
-            httpGroup: {},
-            tagGroupMeta: {},
-            httpGroupMeta: {},
-        },
-        misc: {
-            errors: globalThis.pikkuState?.misc?.errors || new Map(),
-            schemas: new Map(),
-            middleware: {},
-            permissions: {},
+/**
+ * Get or set package-scoped pikku state
+ *
+ * @param packageName - Package name (null for main package, '@scope/package' for external packages)
+ * @param type - State category (function, rpc, http, etc.)
+ * @param content - Content key within the category
+ * @param value - Optional value to set
+ * @returns The current value of the state
+ *
+ * @example
+ * // Main package
+ * pikkuState(null, 'function', 'functions').get(funcName)
+ *
+ * // External package
+ * pikkuState('@acme/stripe-functions', 'rpc', 'meta')
+ */
+export const pikkuState = (packageName, type, content, value) => {
+    const resolvedPackageName = packageName ?? '__main__';
+    // Initialize package state if it doesn't exist
+    if (!globalThis.pikkuState ||
+        !globalThis.pikkuState.has(resolvedPackageName)) {
+        initializePikkuState(resolvedPackageName);
+    }
+    const packageState = globalThis.pikkuState.get(resolvedPackageName);
+    if (value !== undefined) {
+        packageState[type][content] = value;
+    }
+    return packageState[type][content];
+};
+const createEmptyPackageState = () => ({
+    function: {
+        meta: {},
+        functions: new Map(),
+    },
+    rpc: {
+        meta: {},
+        files: new Map(),
+        externalPackages: new Map(),
+    },
+    http: {
+        middleware: new Map(),
+        permissions: new Map(),
+        routes: new Map(),
+        meta: {
+            post: {},
+            get: {},
+            delete: {},
+            patch: {},
+            head: {},
+            put: {},
+            options: {},
         },
-    };
+    },
+    channel: {
+        channels: new Map(),
+        meta: {},
+    },
+    scheduler: {
+        tasks: new Map(),
+        meta: [],
+    },
+    queue: {
+        registrations: new Map(),
+        meta: {},
+    },
+    workflows: {
+        registrations: new Map(),
+        graphRegistrations: new Map(),
+        wirings: new Map(),
+        graphWirings: new Map(),
+        meta: {},
+    },
+    trigger: {
+        triggers: new Map(),
+        meta: {},
+    },
+    mcp: {
+        resources: new Map(),
+        resourcesMeta: {},
+        tools: new Map(),
+        toolsMeta: {},
+        prompts: new Map(),
+        promptsMeta: {},
+    },
+    cli: {
+        meta: { programs: {}, renderers: {} },
+        programs: {},
+    },
+    middleware: {
+        tagGroup: {},
+        httpGroup: {},
+        tagGroupMeta: {},
+        httpGroupMeta: {},
+    },
+    permissions: {
+        tagGroup: {},
+        httpGroup: {},
+        tagGroupMeta: {},
+        httpGroupMeta: {},
+    },
+    misc: {
+        errors: new Map(),
+        schemas: new Map(),
+        middleware: {},
+        permissions: {},
+    },
+    package: {
+        factories: null,
+        singletonServices: null,
+    },
+});
+/**
+ * Initialize state for a new package
+ */
+export const initializePikkuState = (packageName) => {
+    if (!globalThis.pikkuState) {
+        globalThis.pikkuState = new Map();
+    }
+    if (!globalThis.pikkuState.has(packageName)) {
+        globalThis.pikkuState.set(packageName, createEmptyPackageState());
+    }
+};
+export const resetPikkuState = () => {
+    // Preserve the errors map before resetting
+    const existingErrors = globalThis.pikkuState?.get('__main__')?.misc.errors;
+    globalThis.pikkuState = new Map();
+    initializePikkuState('__main__');
+    // Restore the errors map if it existed
+    if (existingErrors) {
+        const mainState = globalThis.pikkuState.get('__main__');
+        mainState.misc.errors = existingErrors;
+    }
 };
 if (!globalThis.pikkuState) {
     resetPikkuState();
 }
-export const pikkuState = (type, content, value) => {
-    if (value) {
-        globalThis.pikkuState[type][content] = value;
-    }
-    return globalThis.pikkuState[type][content];
+/**
+ * Register service factories for an external package.
+ * These factories are used to create services when the package's functions are invoked.
+ *
+ * @param packageName - The package name (e.g., '@pikku/templates-function-external')
+ * @param factories - The service factory functions
+ */
+export const addPackageServiceFactories = (packageName, factories) => {
+    pikkuState(packageName, 'package', 'factories', factories);
 };

package/dist/schema.d.ts

@@ -1,23 +1,25 @@
 import { Logger } from './services/logger.js';
 import { SchemaService } from './services/schema-service.js';
 /**
- * Adds a schema to the global schemas map.
+ * Adds a schema to the schemas map for a specific package.
  * @param name - The name of the schema.
  * @param value - The schema value.
+ * @param packageName - The package name (null for main package, '@scope/package' for external packages).
  * @ignore
  */
-export declare const addSchema: (name: string, value: any) => void;
+export declare const addSchema: (name: string, value: any, packageName?: string | null) => void;
 /**
- * Retrieves a schema from the global schemas map.
+ * Retrieves a schema from the schemas map for a specific package.
  * @param name - The name of the schema.
+ * @param packageName - The package name (null for main package, '@scope/package' for external packages).
  * @returns The schema value or undefined if not found.
  * @ignore
  */
-export declare const getSchema: (name: string) => Record<string, unknown> | undefined;
+export declare const getSchema: (name: string, packageName?: string | null) => Record<string, unknown> | undefined;
 /**
  * Loads a schema and compiles it into a validator.
  * @param logger - A logger for logging information.
  */
 export declare const compileAllSchemas: (logger: Logger, schemaService?: SchemaService) => void;
-export declare const coerceTopLevelDataFromSchema: (schemaName: string, data: any) => void;
-export declare const validateSchema: (logger: Logger, schemaService: SchemaService | undefined, schemaName: string | undefined | null, data: any) => Promise<void>;
+export declare const coerceTopLevelDataFromSchema: (schemaName: string, data: any, packageName?: string | null) => void;
+export declare const validateSchema: (logger: Logger, schemaService: SchemaService | undefined, schemaName: string | undefined | null, data: any, packageName?: string | null) => Promise<void>;

package/dist/schema.js

@@ -1,22 +1,24 @@
 import { UnprocessableContentError } from './errors/errors.js';
 import { pikkuState } from './pikku-state.js';
 /**
- * Adds a schema to the global schemas map.
+ * Adds a schema to the schemas map for a specific package.
  * @param name - The name of the schema.
  * @param value - The schema value.
+ * @param packageName - The package name (null for main package, '@scope/package' for external packages).
  * @ignore
  */
-export const addSchema = (name, value) => {
-    pikkuState('misc', 'schemas').set(name, value);
+export const addSchema = (name, value, packageName = null) => {
+    pikkuState(packageName, 'misc', 'schemas').set(name, value);
 };
 /**
- * Retrieves a schema from the global schemas map.
+ * Retrieves a schema from the schemas map for a specific package.
  * @param name - The name of the schema.
+ * @param packageName - The package name (null for main package, '@scope/package' for external packages).
  * @returns The schema value or undefined if not found.
  * @ignore
  */
-export const getSchema = (name) => {
-    return pikkuState('misc', 'schemas').get(name);
+export const getSchema = (name, packageName = null) => {
+    return pikkuState(packageName, 'misc', 'schemas').get(name);
 };
 /**
  * Loads a schema and compiles it into a validator.
@@ -26,19 +28,20 @@ export const compileAllSchemas = (logger, schemaService) => {
     if (!schemaService) {
         throw new Error('SchemaService needs to be defined to load schemas');
     }
-    const schemas = pikkuState('misc', 'schemas');
+    const schemas = pikkuState(null, 'misc', 'schemas');
     for (const [name, schema] of schemas) {
         schemaService.compileSchema(name, schema);
     }
     validateAllSchemasLoaded(logger, schemaService);
 };
 const validateAllSchemasLoaded = (logger, schemaService) => {
-    const routesMeta = pikkuState('http', 'meta');
+    const routesMeta = pikkuState(null, 'http', 'meta');
     const validators = schemaService.getSchemaNames();
     const missingSchemas = [];
     for (const routePaths of Object.values(routesMeta)) {
         for (const meta of Object.values(routePaths)) {
-            const inputs = pikkuState('function', 'meta')[meta.pikkuFuncName]?.inputs;
+            const inputs = pikkuState(null, 'function', 'meta')[meta.pikkuFuncName]
+                ?.inputs;
             const input = inputs?.[0];
             if (!input || validators.has(input)) {
                 continue;
@@ -55,8 +58,8 @@ const validateAllSchemasLoaded = (logger, schemaService) => {
         logger.info('All schemas loaded');
     }
 };
-export const coerceTopLevelDataFromSchema = (schemaName, data) => {
-    const schema = pikkuState('misc', 'schemas').get(schemaName);
+export const coerceTopLevelDataFromSchema = (schemaName, data, packageName = null) => {
+    const schema = pikkuState(packageName, 'misc', 'schemas').get(schemaName);
     for (const key in schema.properties) {
         const property = schema.properties[key];
         if (typeof property === 'boolean') {
@@ -74,7 +77,7 @@ export const coerceTopLevelDataFromSchema = (schemaName, data) => {
         }
     }
 };
-export const validateSchema = async (logger, schemaService, schemaName, data) => {
+export const validateSchema = async (logger, schemaService, schemaName, data, packageName = null) => {
     if (schemaService) {
         if (!schemaName) {
             if (data && (data.length > 0 || Object.keys(data).length > 0)) {
@@ -85,7 +88,16 @@ export const validateSchema = async (logger, schemaService, schemaName, data) =>
                 return;
             }
         }
-        const schema = pikkuState('misc', 'schemas').get(schemaName);
+        logger.debug(`[validateSchema] Validating schema '${schemaName}' for package '${packageName ?? 'main'}' with data:`, JSON.stringify(data));
+        const schemas = pikkuState(packageName, 'misc', 'schemas');
+        const schema = schemas.get(schemaName);
+        if (schema === undefined) {
+            const availableSchemas = Array.from(schemas.keys());
+            logger.error(`Schema '${schemaName}' not found for package '${packageName ?? 'main'}'. Available schemas: ${availableSchemas.join(', ') || '(none)'}`);
+        }
+        else {
+            logger.debug(`[validateSchema] Found schema '${schemaName}':`, JSON.stringify(schema));
+        }
         await schemaService.compileSchema(schemaName, schema);
         await schemaService.validateSchema(schemaName, data);
     }

package/dist/services/user-session-service.d.ts

@@ -1,19 +1,23 @@
 import { ChannelStore } from '../wirings/channel/channel-store.js';
 import { CoreUserSession } from '../types/core.types.js';
-export interface UserSessionService<UserSession extends CoreUserSession> {
+export interface SessionService<UserSession extends CoreUserSession> {
     sessionChanged: boolean;
+    initial: UserSession | undefined;
     setInitial(session: UserSession): void;
+    freezeInitial(): UserSession | undefined;
     set(session: UserSession): Promise<void> | void;
     clear(): Promise<void> | void;
-    get(): Promise<UserSession | undefined> | UserSession | undefined;
+    get(): Promise<UserSession> | UserSession | undefined;
 }
-export declare class PikkuUserSessionService<UserSession extends CoreUserSession> implements UserSessionService<UserSession> {
+export declare class PikkuSessionService<UserSession extends CoreUserSession> implements SessionService<UserSession> {
     private channelStore?;
     private channelId?;
     sessionChanged: boolean;
+    initial: UserSession | undefined;
     private session;
     constructor(channelStore?: ChannelStore<unknown, unknown, UserSession> | undefined, channelId?: string | undefined);
     setInitial(session: UserSession): void;
+    freezeInitial(): UserSession | undefined;
     set(session: UserSession): void | Promise<void> | undefined;
     clear(): void | Promise<void> | undefined;
     get(): Promise<UserSession> | UserSession | undefined;

package/dist/services/user-session-service.js

@@ -1,7 +1,8 @@
-export class PikkuUserSessionService {
+export class PikkuSessionService {
     channelStore;
     channelId;
     sessionChanged = false;
+    initial;
     session;
     constructor(channelStore, channelId) {
         this.channelStore = channelStore;
@@ -13,6 +14,12 @@ export class PikkuUserSessionService {
     setInitial(session) {
         this.session = session;
     }
+    freezeInitial() {
+        if (this.initial === undefined) {
+            this.initial = this.session;
+        }
+        return this.initial;
+    }
     set(session) {
         this.sessionChanged = true;
         this.session = session;

package/dist/services/workflow-service.d.ts

@@ -0,0 +1,38 @@
+import { SerializedError, CoreSingletonServices, CreateWireServices, CoreConfig } from '../types/core.types.js';
+import { WorkflowRun, StepState, WorkflowStatus } from '../wirings/workflow/workflow.types.js';
+/**
+ * Interface for workflow orchestration
+ * Handles workflow execution, replay, orchestration logic, and run-level state
+ */
+export interface WorkflowService {
+    createRun(workflowName: string, input: any, inline?: boolean): Promise<string>;
+    getRun(id: string): Promise<WorkflowRun | null>;
+    getRunHistory(runId: string): Promise<Array<StepState & {
+        stepName: string;
+    }>>;
+    updateRunStatus(id: string, status: WorkflowStatus, output?: any, error?: SerializedError): Promise<void>;
+    withRunLock<T>(id: string, fn: () => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+    resumeWorkflow(runId: string): Promise<void>;
+    setServices(singletonServices: CoreSingletonServices, createWireServices: CreateWireServices, config: CoreConfig): void;
+    startWorkflow<I>(name: string, input: I, rpcService: any, options?: {
+        inline?: boolean;
+        startNode?: string;
+    }): Promise<{
+        runId: string;
+    }>;
+    runWorkflowJob(runId: string, rpcService: any): Promise<void>;
+    orchestrateWorkflow(runId: string, rpcService: any): Promise<void>;
+    executeWorkflowSleepCompleted(runId: string, stepId: string): Promise<void>;
+    insertStepState(runId: string, stepName: string, rpcName: string, data: any, stepOptions?: {
+        retries?: number;
+        retryDelay?: string | number;
+    }): Promise<StepState>;
+    getStepState(runId: string, stepName: string): Promise<StepState>;
+    setStepRunning(stepId: string): Promise<void>;
+    setStepScheduled(stepId: string): Promise<void>;
+    setStepResult(stepId: string, result: any): Promise<void>;
+    setStepError(stepId: string, error: Error): Promise<void>;
+    createRetryAttempt(stepId: string, status: 'pending' | 'running'): Promise<StepState>;
+    executeWorkflowStep(runId: string, stepName: string, rpcName: string | null, data: any, rpcService: any): Promise<void>;
+}

package/dist/services/workflow-service.js

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