@pikku/core 0.11.2 → 0.12.1

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

@@ -1,5 +1,11 @@
 import type { CoreServices, CoreSingletonServices, CoreUserSession, CorePikkuMiddleware, PikkuWire, PickRequired } from '../types/core.types.js';
-import { Session } from 'inspector';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { CoreNodeConfig } from '../wirings/node/node.types.js';
+/**
+ * @deprecated Use StandardSchemaV1 from @standard-schema/spec instead.
+ * This alias exists only for backward compatibility with generated code.
+ */
+export type ZodLike<T = any> = StandardSchemaV1<T, T>;
 /**
  * Represents a core API function that performs an operation using core services and a user session.
  *
@@ -8,7 +14,7 @@ import { Session } from 'inspector';
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Wire - The wire type, defaults to `PikkuWire<In, Out>`.
  */
-export type CorePikkuFunction<In, Out, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, Out> = PikkuWire<In, Out, true, Session>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Out> : Promise<Out> | Promise<void>;
+export type CorePikkuFunction<In, Out, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession, Wire extends PikkuWire<In, Out> = PikkuWire<In, Out, true, Session>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Out> : Promise<Out> | Promise<void>;
 /**
  * Represents a core API function that can be used without a session.
  *
@@ -17,7 +23,7 @@ export type CorePikkuFunction<In, Out, Services extends CoreSingletonServices =
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Wire - The wire type, defaults to `PikkuWire<In, Out>`.
  */
-export type CorePikkuFunctionSessionless<In, Out, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, Out, false, CoreUserSession, any, any, any> = PikkuWire<In, Out, false, CoreUserSession, any, any, any>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Out> : Promise<Out> | Promise<void>;
+export type CorePikkuFunctionSessionless<In, Out, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession, Wire extends PikkuWire<In, Out, false, Session, any, any, any> = PikkuWire<In, Out, false, Session, any, any, any>> = (services: Services, data: In, wire: Wire) => Wire['channel'] extends null ? Promise<Out> : Promise<Out> | Promise<void>;
 /**
  * Represents a function that checks permissions for a given operation.
  *
@@ -36,8 +42,8 @@ export type CorePikkuPermission<In = any, Services extends CoreSingletonServices
 export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonServices = CoreServices, Wire extends PikkuWire<In, never, false, CoreUserSession> = PikkuWire<In, never, false, CoreUserSession>> = {
     /** The permission function */
     func: CorePikkuPermission<In, Services, Wire>;
-    /** Optional human-readable title for the permission */
-    title?: string;
+    /** Optional human-readable name for the permission */
+    name?: string;
     /** Optional description of what the permission checks */
     description?: string;
 };
@@ -49,18 +55,18 @@ export type CorePikkuPermissionConfig<In = any, Services extends CoreSingletonSe
  * ```typescript
  * // Direct function syntax
  * export const adminPermission = pikkuPermission(
- *   async ({ logger }, _data, { session }) => {
- *     const currentSession = await session.get()
+ *   async ({ logger }, _data, { getSession }) => {
+ *     const currentSession = await getSession()
  *     return currentSession?.role === 'admin'
  *   }
  * )
  *
  * // Configuration object syntax with metadata
  * export const adminPermission = pikkuPermission({
- *   title: 'Admin Permission',
+ *   name: 'Admin Permission',
  *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, _data, { session }) => {
- *     const currentSession = await session.get()
+ *   func: async ({ logger }, _data, { getSession }) => {
+ *     const currentSession = await getSession()
  *     return currentSession?.role === 'admin'
  *   }
  * })
@@ -85,8 +91,8 @@ export type CorePikkuPermissionFactory<In = any, Services extends CoreSingletonS
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, { session }) => {
- *      const currentSession = await session.get()
+ *   return pikkuPermission(async ({ logger }, data, { getSession }) => {
+ *      const currentSession = await getSession()
  *     if (!currentSession || currentSession.role !== role) {
  *       logger.warn(`Permission denied: required role '${role}'`)
  *       return false
@@ -97,93 +103,32 @@ export type CorePikkuPermissionFactory<In = any, Services extends CoreSingletonS
  * ```
  */
 export declare const pikkuPermissionFactory: <In = any>(factory: CorePikkuPermissionFactory<In>) => CorePikkuPermissionFactory<In>;
-export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
-/**
- * Zod schema type - matches z.ZodType shape for type inference
- * This avoids requiring zod as a dependency while allowing schema inference
- */
-export type ZodLike<T = any> = {
-    _input: T;
-    _output: T;
+export type CorePikkuAuth<Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, session: Session) => Promise<boolean> | boolean;
+export type CorePikkuAuthConfig<Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = {
+    func: CorePikkuAuth<Services, Session>;
+    name?: string;
+    description?: string;
 };
-export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>, InputSchema extends ZodLike | undefined = undefined, OutputSchema extends ZodLike | undefined = undefined> = {
+export declare const pikkuAuth: <Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession>(auth: CorePikkuAuth<Services, Session> | CorePikkuAuthConfig<Services, Session>) => CorePikkuPermission<any, Services, any>;
+export type CorePermissionGroup<PikkuPermission = CorePikkuPermission<any>> = Record<string, PikkuPermission | PikkuPermission[]> | undefined;
+export type CorePikkuFunctionConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>, InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = {
     /** Optional human-readable title for the function */
     title?: string;
     /** Optional description of what the function does */
     description?: string;
     override?: string;
+    version?: number;
     tags?: string[];
     expose?: boolean;
-    internal?: boolean;
+    remote?: boolean;
+    mcp?: boolean;
+    readonly?: boolean;
+    requiresApproval?: boolean;
     func: PikkuFunction;
     auth?: boolean;
     permissions?: CorePermissionGroup<PikkuPermission>;
     middleware?: PikkuMiddleware[];
     input?: InputSchema;
     output?: OutputSchema;
+    node?: CoreNodeConfig;
 };
-/**
- * A trigger function that sets up a subscription and returns a teardown function.
- * The trigger is fired via wire.trigger.trigger(data).
- *
- * @template TConfig - Configuration type (hardcoded when wired)
- * @template TOutput - Output type produced when trigger fires
- * @template Services - Services available to the trigger
- */
-export type CorePikkuTriggerFunction<TConfig = unknown, TOutput = unknown, Services extends CoreSingletonServices = CoreSingletonServices> = (services: Services, config: TConfig, wire: {
-    trigger: {
-        trigger: (data: TOutput) => void;
-    };
-}) => Promise<() => void | Promise<void>>;
-/**
- * Configuration object for creating a trigger function with metadata
- */
-export type CorePikkuTriggerFunctionConfig<TConfig = unknown, TOutput = unknown, Services extends CoreSingletonServices = CoreSingletonServices, ConfigSchema extends ZodLike | undefined = undefined, OutputSchema extends ZodLike | undefined = undefined> = {
-    /** Optional human-readable title for the trigger */
-    title?: string;
-    /** Optional description of what the trigger does */
-    description?: string;
-    /** Optional tags for categorization */
-    tags?: string[];
-    /** The trigger function */
-    func: CorePikkuTriggerFunction<TConfig, TOutput, Services>;
-    /** Optional Zod schema for config validation */
-    config?: ConfigSchema;
-    /** Optional Zod schema for output validation */
-    output?: OutputSchema;
-};
-/**
- * Factory function for creating trigger functions
- * Supports both direct function and configuration object syntax
- *
- * @example
- * ```typescript
- * // Direct function syntax
- * export const redisSubscribeTrigger = pikkuTriggerFunc<
- *   { channel: string },
- *   { message: string }
- * >(async ({ redis }, { channel }, { trigger }) => {
- *   const subscriber = redis.duplicate()
- *   await subscriber.subscribe(channel, (msg) => {
- *     trigger.trigger({ message: msg })
- *   })
- *   return () => subscriber.unsubscribe()
- * })
- *
- * // Configuration object syntax with metadata
- * export const redisSubscribeTrigger = pikkuTriggerFunc({
- *   title: 'Redis Subscribe Trigger',
- *   description: 'Listens to Redis pub/sub channel',
- *   config: z.object({ channel: z.string() }),
- *   output: z.object({ message: z.string() }),
- *   func: async ({ redis }, { channel }, { trigger }) => {
- *     const subscriber = redis.duplicate()
- *     await subscriber.subscribe(channel, (msg) => {
- *       trigger.trigger({ message: msg })
- *     })
- *     return () => subscriber.unsubscribe()
- *   }
- * })
- * ```
- */
-export declare const pikkuTriggerFunc: <TConfig = unknown, TOutput = unknown, Services extends CoreSingletonServices = CoreSingletonServices, ConfigSchema extends ZodLike | undefined = undefined, OutputSchema extends ZodLike | undefined = undefined>(triggerOrConfig: CorePikkuTriggerFunction<TConfig, TOutput, Services> | CorePikkuTriggerFunctionConfig<TConfig, TOutput, Services, ConfigSchema, OutputSchema>) => CorePikkuTriggerFunctionConfig<TConfig, TOutput, Services, ConfigSchema, OutputSchema>;

package/dist/function/functions.types.js

@@ -6,18 +6,18 @@
  * ```typescript
  * // Direct function syntax
  * export const adminPermission = pikkuPermission(
- *   async ({ logger }, _data, { session }) => {
- *     const currentSession = await session.get()
+ *   async ({ logger }, _data, { getSession }) => {
+ *     const currentSession = await getSession()
  *     return currentSession?.role === 'admin'
  *   }
  * )
  *
  * // Configuration object syntax with metadata
  * export const adminPermission = pikkuPermission({
- *   title: 'Admin Permission',
+ *   name: 'Admin Permission',
  *   description: 'Checks if user has admin role',
- *   func: async ({ logger }, _data, { session }) => {
- *     const currentSession = await session.get()
+ *   func: async ({ logger }, _data, { getSession }) => {
+ *     const currentSession = await getSession()
  *     return currentSession?.role === 'admin'
  *   }
  * })
@@ -35,8 +35,8 @@ export const pikkuPermission = (permission) => {
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, { session }) => {
- *      const currentSession = await session.get()
+ *   return pikkuPermission(async ({ logger }, data, { getSession }) => {
+ *      const currentSession = await getSession()
  *     if (!currentSession || currentSession.role !== role) {
  *       logger.warn(`Permission denied: required role '${role}'`)
  *       return false
@@ -49,43 +49,13 @@ export const pikkuPermission = (permission) => {
 export const pikkuPermissionFactory = (factory) => {
     return factory;
 };
-/**
- * Factory function for creating trigger functions
- * Supports both direct function and configuration object syntax
- *
- * @example
- * ```typescript
- * // Direct function syntax
- * export const redisSubscribeTrigger = pikkuTriggerFunc<
- *   { channel: string },
- *   { message: string }
- * >(async ({ redis }, { channel }, { trigger }) => {
- *   const subscriber = redis.duplicate()
- *   await subscriber.subscribe(channel, (msg) => {
- *     trigger.trigger({ message: msg })
- *   })
- *   return () => subscriber.unsubscribe()
- * })
- *
- * // Configuration object syntax with metadata
- * export const redisSubscribeTrigger = pikkuTriggerFunc({
- *   title: 'Redis Subscribe Trigger',
- *   description: 'Listens to Redis pub/sub channel',
- *   config: z.object({ channel: z.string() }),
- *   output: z.object({ message: z.string() }),
- *   func: async ({ redis }, { channel }, { trigger }) => {
- *     const subscriber = redis.duplicate()
- *     await subscriber.subscribe(channel, (msg) => {
- *       trigger.trigger({ message: msg })
- *     })
- *     return () => subscriber.unsubscribe()
- *   }
- * })
- * ```
- */
-export const pikkuTriggerFunc = (triggerOrConfig) => {
-    if (typeof triggerOrConfig === 'function') {
-        return { func: triggerOrConfig };
-    }
-    return triggerOrConfig;
+export const pikkuAuth = (auth) => {
+    const fn = typeof auth === 'function' ? auth : auth.func;
+    const wrapper = async (services, _data, wire) => {
+        const session = wire.session;
+        if (!session)
+            return false;
+        return fn(services, session);
+    };
+    return wrapper;
 };

package/dist/function/index.d.ts

@@ -1,2 +1,2 @@
-export * from './function-runner.js';
-export * from './functions.types.js';
+export { addFunction, getAllFunctionNames } from './function-runner.js';
+export type { CorePikkuFunction, CorePikkuFunctionSessionless, } from './functions.types.js';

package/dist/function/index.js

@@ -1,2 +1 @@
-export * from './function-runner.js';
-export * from './functions.types.js';
+export { addFunction, getAllFunctionNames } from './function-runner.js';

package/dist/handle-error.d.ts

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

package/dist/handle-error.js

@@ -31,29 +31,20 @@ export const handleHTTPError = (e, http, trackerId, logger, logWarningsForStatus
             if (trackerId) {
                 logger.warn(`Warning id: ${trackerId}`);
             }
-            logger.warn(e);
+            logger.warn(e instanceof Error ? e.message : e);
         }
     }
     else {
         // Handle unexpected errors
-        logger.error(e);
+        logger.error(e instanceof Error ? e.message : e);
         http?.response?.status(500);
         if (trackerId) {
             logger.warn(`Error id: ${trackerId}`);
             http?.response?.json({ errorId: trackerId });
         }
     }
-    // Handle 404 errors specifically
-    if (e instanceof NotFoundError) {
-        // TODO
-        // http?.response?.end()
-    }
-    // Either bubble up or end the response
     if (bubbleError) {
         throw e;
     }
-    else {
-        // TODO
-        // http?.response?.end()
-    }
+    http?.response?.close?.();
 };

package/dist/index.d.ts

@@ -1,32 +1,36 @@
 /**
  * @module @pikku/core
  */
-export * from './types/core.types.js';
-export * from './function/index.js';
-export * from './pikku-request.js';
-export * from './pikku-response.js';
-export * from './services/logger.js';
-export * from './services/schema-service.js';
-export * from './services/jwt-service.js';
-export * from './services/secret-service.js';
-export * from './services/user-session-service.js';
-export * from './services/scheduler-service.js';
-export * from './wirings/http/index.js';
-export * from './wirings/channel/index.js';
-export * from './wirings/scheduler/index.js';
-export * from './wirings/rpc/index.js';
-export * from './wirings/queue/index.js';
-export * from './wirings/workflow/index.js';
-export * from './wirings/workflow/graph/index.js';
-export * from './wirings/mcp/index.js';
-export * from './wirings/cli/index.js';
-export * from './wirings/forge-node/index.js';
-export * from './wirings/trigger/index.js';
-export * from './errors/index.js';
-export * from './middleware/index.js';
-export * from './utils.js';
-export * from './time-utils.js';
-export { pikkuState, initializePikkuState, resetPikkuState, addPackageServiceFactories, } from './pikku-state.js';
+export type { CommonWireMeta, CoreConfig, CorePikkuMiddleware, CorePikkuMiddlewareConfig, CorePikkuMiddlewareFactory, CorePikkuMiddlewareGroup, CoreServices, CoreSingletonServices, CoreUserSession, CreateConfig, FunctionMeta, FunctionRuntimeMeta, FunctionServicesMeta, FunctionWiresMeta, FunctionsMeta, FunctionsRuntimeMeta, JSONPrimitive, JSONValue, MakeRequired, MiddlewareMetadata, PermissionMetadata, PickOptional, PickRequired, PikkuAIMiddlewareHooks, PikkuWire, PikkuWiringTypes, RequireAtLeastOne, SerializedError, WireServices, } from './types/core.types.js';
+export { pikkuAIMiddleware, pikkuChannelMiddleware, pikkuChannelMiddlewareFactory, pikkuMiddleware, pikkuMiddlewareFactory, } from './types/core.types.js';
+export type { CorePikkuAuth, CorePikkuAuthConfig, CorePikkuFunction, CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuPermissionConfig, CorePikkuPermissionFactory, CorePermissionGroup, ZodLike, } from './function/functions.types.js';
+export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, } from './function/functions.types.js';
+export { addFunction, getAllFunctionNames } from './function/index.js';
+export { PikkuRequest } from './pikku-request.js';
+export { getRelativeTimeOffsetFromNow, parseDurationString, } from './time-utils.js';
+export type { RelativeTimeInput } from './time-utils.js';
+export { formatVersionedId, isVersionedId, parseVersionedId, } from './version.js';
+export { runPikkuFunc } from './function/function-runner.js';
+export { runCLICommand, pikkuCLIRender } from './wirings/cli/cli-runner.js';
+export { fetch } from './wirings/http/http-runner.js';
+export { runMCPTool, runMCPResource, runMCPPrompt, } from './wirings/mcp/mcp-runner.js';
+export type { MCPToolResponse, MCPResourceResponse, MCPPromptResponse, } from './wirings/mcp/mcp.types.js';
+export { runQueueJob } from './wirings/queue/queue-runner.js';
+export { runScheduledTask } from './wirings/scheduler/scheduler-runner.js';
+export { NotFoundError } from './errors/errors.js';
+export type { EventHubService } from './wirings/channel/eventhub-service.js';
+export type { QueueService } from './wirings/queue/queue.types.js';
+export type { JWTService } from './services/jwt-service.js';
+export type { HTTPMethod } from './wirings/http/http.types.js';
+export type { GraphNodeConfig } from './wirings/workflow/graph/workflow-graph.types.js';
+export { createGraph } from './wirings/workflow/graph/graph-node.js';
+export { workflow as wireWorkflow } from './wirings/workflow/workflow-helpers.js';
+export { wireAddon } from './wirings/rpc/wire-addon.js';
+export type { WireAddonConfig } from './wirings/rpc/wire-addon.js';
 export type { PikkuPackageState } from './types/state.types.js';
 export { runMiddleware, addMiddleware } from './middleware-runner.js';
 export { addPermission } from './permissions.js';
+export { isSerializable, stopSingletonServices } from './utils.js';
+export { getSingletonServices, getCreateWireServices } from './pikku-state.js';
+export { type ScheduledTaskInfo, type ScheduledTaskSummary, } from './services/scheduler-service.js';
+export { SchedulerService } from './services/scheduler-service.js';

package/dist/index.js

@@ -1,31 +1,21 @@
-/**
- * @module @pikku/core
- */
-export * from './types/core.types.js';
-export * from './function/index.js';
-export * from './pikku-request.js';
-export * from './pikku-response.js';
-export * from './services/logger.js';
-export * from './services/schema-service.js';
-export * from './services/jwt-service.js';
-export * from './services/secret-service.js';
-export * from './services/user-session-service.js';
-export * from './services/scheduler-service.js';
-export * from './wirings/http/index.js';
-export * from './wirings/channel/index.js';
-export * from './wirings/scheduler/index.js';
-export * from './wirings/rpc/index.js';
-export * from './wirings/queue/index.js';
-export * from './wirings/workflow/index.js';
-export * from './wirings/workflow/graph/index.js';
-export * from './wirings/mcp/index.js';
-export * from './wirings/cli/index.js';
-export * from './wirings/forge-node/index.js';
-export * from './wirings/trigger/index.js';
-export * from './errors/index.js';
-export * from './middleware/index.js';
-export * from './utils.js';
-export * from './time-utils.js';
-export { pikkuState, initializePikkuState, resetPikkuState, addPackageServiceFactories, } from './pikku-state.js';
+export { pikkuAIMiddleware, pikkuChannelMiddleware, pikkuChannelMiddlewareFactory, pikkuMiddleware, pikkuMiddlewareFactory, } from './types/core.types.js';
+export { pikkuAuth, pikkuPermission, pikkuPermissionFactory, } from './function/functions.types.js';
+export { addFunction, getAllFunctionNames } from './function/index.js';
+export { PikkuRequest } from './pikku-request.js';
+export { getRelativeTimeOffsetFromNow, parseDurationString, } from './time-utils.js';
+export { formatVersionedId, isVersionedId, parseVersionedId, } from './version.js';
+export { runPikkuFunc } from './function/function-runner.js';
+export { runCLICommand, pikkuCLIRender } from './wirings/cli/cli-runner.js';
+export { fetch } from './wirings/http/http-runner.js';
+export { runMCPTool, runMCPResource, runMCPPrompt, } from './wirings/mcp/mcp-runner.js';
+export { runQueueJob } from './wirings/queue/queue-runner.js';
+export { runScheduledTask } from './wirings/scheduler/scheduler-runner.js';
+export { NotFoundError } from './errors/errors.js';
+export { createGraph } from './wirings/workflow/graph/graph-node.js';
+export { workflow as wireWorkflow } from './wirings/workflow/workflow-helpers.js';
+export { wireAddon } from './wirings/rpc/wire-addon.js';
 export { runMiddleware, addMiddleware } from './middleware-runner.js';
 export { addPermission } from './permissions.js';
+export { isSerializable, stopSingletonServices } from './utils.js';
+export { getSingletonServices, getCreateWireServices } from './pikku-state.js';
+export { SchedulerService } from './services/scheduler-service.js';

package/dist/internal.d.ts

@@ -0,0 +1,3 @@
+export { pikkuState, resetPikkuState } from './pikku-state.js';
+export { httpRouter } from './wirings/http/routers/http-router.js';
+export type { CreateSingletonServices, CreateWireServices, } from './types/core.types.js';

package/dist/internal.js

@@ -0,0 +1,2 @@
+export { pikkuState, resetPikkuState } from './pikku-state.js';
+export { httpRouter } from './wirings/http/routers/http-router.js';

package/dist/middleware/auth-apikey.d.ts

@@ -18,7 +18,7 @@
 export declare const authAPIKey: import("../types/core.types.js").CorePikkuMiddlewareFactory<{
     source: "header" | "query" | "all";
 }, import("../types/core.types.js").CoreSingletonServices<{
-    logLevel?: import("../index.js").LogLevel;
+    logLevel?: import("../services/logger.js").LogLevel;
     secrets?: {};
-    workflow?: import("../index.js").WorkflowServiceConfig;
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware/auth-apikey.js

@@ -16,8 +16,8 @@ import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js'
  * ])
  * ```
  */
-export const authAPIKey = pikkuMiddlewareFactory(({ source }) => pikkuMiddleware(async ({ jwt: jwtService }, { http, session: SessionService }, next) => {
-    if (!http?.request || !SessionService || SessionService.get()) {
+export const authAPIKey = pikkuMiddlewareFactory(({ source }) => pikkuMiddleware(async ({ jwt: jwtService }, { http, setSession, session }, next) => {
+    if (!http?.request || !setSession || session) {
         return next();
     }
     let apiKey = null;
@@ -30,7 +30,7 @@ export const authAPIKey = pikkuMiddlewareFactory(({ source }) => pikkuMiddleware
     if (apiKey && jwtService) {
         const userSession = await jwtService.decode(apiKey);
         if (userSession) {
-            SessionService.setInitial(userSession);
+            setSession?.(userSession);
         }
     }
     return next();

package/dist/middleware/auth-bearer.d.ts

@@ -1,4 +1,4 @@
-import { CoreUserSession } from '../types/core.types.js';
+import type { CoreUserSession } from '../types/core.types.js';
 /**
  * Bearer token middleware that extracts and validates tokens from the Authorization header.
  *
@@ -34,7 +34,7 @@ export declare const authBearer: import("../types/core.types.js").CorePikkuMiddl
         userSession: CoreUserSession;
     };
 }, import("../types/core.types.js").CoreSingletonServices<{
-    logLevel?: import("../index.js").LogLevel;
+    logLevel?: import("../services/logger.js").LogLevel;
     secrets?: {};
-    workflow?: import("../index.js").WorkflowServiceConfig;
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
 }>, CoreUserSession>;

package/dist/middleware/auth-bearer.js

@@ -1,5 +1,5 @@
 import { InvalidSessionError } from '../errors/errors.js';
-import { pikkuMiddleware, pikkuMiddlewareFactory, } from '../types/core.types.js';
+import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js';
 /**
  * Bearer token middleware that extracts and validates tokens from the Authorization header.
  *
@@ -29,9 +29,8 @@ import { pikkuMiddleware, pikkuMiddlewareFactory, } from '../types/core.types.js
  * ])
  * ```
  */
-export const authBearer = pikkuMiddlewareFactory(({ token } = {}) => pikkuMiddleware(async ({ jwt: jwtService }, { http, session }, next) => {
-    // Skip if session already exists.
-    if (!http?.request || !session || session.get()) {
+export const authBearer = pikkuMiddlewareFactory(({ token } = {}) => pikkuMiddleware(async ({ jwt: jwtService }, { http, setSession, session }, next) => {
+    if (!http?.request || !setSession || session) {
         return next();
     }
     const authHeader = http.request.header('authorization') ||
@@ -42,16 +41,14 @@ export const authBearer = pikkuMiddlewareFactory(({ token } = {}) => pikkuMiddle
             throw new InvalidSessionError();
         }
         let userSession = null;
-        // If static token provided, validate against it
         if (token && bearerToken === token.value) {
             userSession = token.userSession;
         }
-        // Otherwise, default to JWT decoding
         else if (jwtService && !token) {
             userSession = await jwtService.decode(bearerToken);
         }
         if (userSession) {
-            session.setInitial(userSession);
+            setSession?.(userSession);
         }
     }
     return next();

package/dist/middleware/auth-cookie.d.ts

@@ -1,5 +1,5 @@
-import { SerializeOptions } from 'cookie';
-import { RelativeTimeInput } from '../time-utils.js';
+import type { SerializeOptions } from 'cookie';
+import type { RelativeTimeInput } from '../time-utils.js';
 /**
  * Cookie-based session middleware that uses JWT for encoding/decoding session data.
  *
@@ -33,7 +33,7 @@ export declare const authCookie: import("../types/core.types.js").CorePikkuMiddl
     options: SerializeOptions;
     expiresIn: RelativeTimeInput;
 }, import("../types/core.types.js").CoreSingletonServices<{
-    logLevel?: import("../index.js").LogLevel;
+    logLevel?: import("../services/logger.js").LogLevel;
     secrets?: {};
-    workflow?: import("../index.js").WorkflowServiceConfig;
+    workflow?: import("../wirings/workflow/workflow.types.js").WorkflowServiceConfig;
 }>, import("../types/core.types.js").CoreUserSession>;

package/dist/middleware/auth-cookie.js

@@ -1,5 +1,5 @@
 import { pikkuMiddleware, pikkuMiddlewareFactory } from '../types/core.types.js';
-import { getRelativeTimeOffsetFromNow, } from '../time-utils.js';
+import { getRelativeTimeOffsetFromNow } from '../time-utils.js';
 /**
  * Cookie-based session middleware that uses JWT for encoding/decoding session data.
  *
@@ -28,27 +28,25 @@ import { getRelativeTimeOffsetFromNow, } from '../time-utils.js';
  * ])
  * ```
  */
-export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn }) => pikkuMiddleware(async ({ jwt: jwtService, logger }, { http, session: SessionService }, next) => {
-    if (!http?.request || !SessionService || SessionService.get()) {
+export const authCookie = pikkuMiddlewareFactory(({ name, options, expiresIn }) => pikkuMiddleware(async ({ jwt: jwtService, logger }, { http, setSession, getSession, session, hasSessionChanged }, next) => {
+    if (!http?.request || !setSession || session) {
         return next();
     }
-    // Try to decode session from cookie
     const cookieValue = http.request.cookie(name);
     if (cookieValue && jwtService) {
         const userSession = await jwtService.decode(cookieValue);
         if (userSession) {
-            SessionService.setInitial(userSession);
+            setSession?.(userSession);
         }
     }
     await next();
-    // Set the cookie in the response if the session has changed
     if (!http?.response) {
         return;
     }
-    if (SessionService.sessionChanged) {
-        const session = SessionService.get();
+    if (hasSessionChanged?.()) {
+        const currentSession = await getSession?.();
         if (jwtService) {
-            http.response.cookie(name, await jwtService.encode(expiresIn, session), {
+            http.response.cookie(name, await jwtService.encode(expiresIn, currentSession), {
                 ...options,
                 expires: getRelativeTimeOffsetFromNow(expiresIn),
             });