@pikku/core 0.6.20 → 0.6.22

package/dist/http/pikku-fetch-http-response.js

@@ -0,0 +1,59 @@
+export class PikkuFetchHTTPResponse {
+    #statusCode = 200;
+    #headers = new Headers();
+    #body = null;
+    status(code) {
+        this.#statusCode = code;
+        return this;
+    }
+    cookie(name, value, flags) {
+        // TODO
+        return this;
+    }
+    header(name, value) {
+        this.#headers.delete(name);
+        if (Array.isArray(value)) {
+            value.forEach((v) => this.#headers.append(name, v));
+        }
+        else {
+            this.#headers.set(name, value);
+        }
+        return this;
+    }
+    arrayBuffer(data) {
+        this.#body = data;
+        this.header('Content-Type', 'application/octet-stream');
+        return this;
+    }
+    json(data) {
+        this.#body = JSON.stringify(data);
+        this.header('Content-Type', 'application/json');
+        return this;
+    }
+    text(content) {
+        this.#body = content;
+        this.header('Content-Type', 'text/plain');
+        return this;
+    }
+    html(content) {
+        this.#body = content;
+        this.header('Content-Type', 'text/html');
+        return this;
+    }
+    body(body) {
+        this.#body = body;
+        return this;
+    }
+    redirect(location, status = 302) {
+        this.#statusCode = status;
+        this.header('Location', location);
+        return this;
+    }
+    toResponse(args) {
+        return new Response(this.#body, {
+            ...args,
+            status: this.#statusCode,
+            headers: this.#headers,
+        });
+    }
+}

package/dist/middleware/auth-apikey.js

@@ -5,15 +5,15 @@
  */
 export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSession.get()) {
+        if (!http?.request || services.userSessionService.get()) {
             return next();
         }
         let apiKey = null;
         if (source === 'header' || source === 'all') {
-            apiKey = http.request.getHeader('x-api-key');
+            apiKey = http.request.header('x-api-key');
         }
         if (!apiKey && (source === 'query' || source === 'all')) {
-            apiKey = http.request.getQuery().apiKey;
+            apiKey = http.request.query().apiKey;
         }
         if (apiKey) {
             let userSession = null;
@@ -27,7 +27,7 @@ export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
                 userSession = await getSessionForAPIKey(services, apiKey);
             }
             if (userSession) {
-                await services.userSession.set(userSession);
+                services.userSessionService.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-bearer.js

@@ -5,11 +5,11 @@ import { InvalidSessionError } from '../errors/errors.js';
 export const authBearer = ({ token, jwt, getSession, } = {}) => {
     const middleware = async (services, { http }, next) => {
         // Skip if session already exists.
-        if (!http?.request || services.userSession.get()) {
+        if (!http?.request || services.userSessionService.get()) {
             return next();
         }
-        const authHeader = http.request.getHeader('authorization') ||
-            http.request.getHeader('Authorization');
+        const authHeader = http.request.header('authorization') ||
+            http.request.header('Authorization');
         if (authHeader) {
             const [scheme, bearerToken] = authHeader.split(' ');
             if (scheme !== 'Bearer' || !token || !bearerToken) {
@@ -31,7 +31,7 @@ export const authBearer = ({ token, jwt, getSession, } = {}) => {
                 userSession = await getSession(services, token);
             }
             if (userSession) {
-                await services.userSession.set(userSession);
+                services.userSessionService.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-cookie.js

@@ -6,37 +6,28 @@
  */
 export const authCookie = ({ cookieNames, getSessionForCookieValue, jwt, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSession.get()) {
+        if (!http?.request || services.userSessionService.get()) {
             return next();
         }
-        const cookies = http.request.getCookies();
-        if (cookies) {
-            let cookieName;
-            for (const name of cookieNames) {
-                if (cookies[name]) {
-                    cookieName = name;
-                    break;
-                }
-            }
-            if (cookieName) {
-                let userSession = null;
-                const cookieValue = cookies[cookieName];
-                if (cookieValue) {
-                    if (jwt) {
-                        if (!services.jwt) {
-                            throw new Error('JWT service is required for JWT decoding.');
-                        }
-                        userSession = await services.jwt.decode(cookieValue);
-                    }
-                    else if (getSessionForCookieValue) {
-                        userSession = await getSessionForCookieValue(services, cookieValue, cookieName);
-                    }
-                    if (userSession) {
-                        await services.userSession.set(userSession);
+        let userSession = null;
+        for (const cookieName of cookieNames) {
+            const cookieValue = http.request.cookie(cookieName);
+            if (cookieValue) {
+                if (jwt) {
+                    if (!services.jwt) {
+                        throw new Error('JWT service is required for JWT decoding.');
                     }
+                    userSession = await services.jwt.decode(cookieValue);
+                }
+                else if (getSessionForCookieValue) {
+                    userSession = await getSessionForCookieValue(services, cookieValue, cookieName);
                 }
+                break;
             }
         }
+        if (userSession) {
+            services.userSessionService.setInitial(userSession);
+        }
         return next();
     };
     return middleware;

package/dist/middleware-runner.d.ts

@@ -18,5 +18,5 @@ import { CoreSingletonServices, PikkuInteraction, PikkuMiddleware } from './type
  * );
  */
 export declare const runMiddleware: (services: CoreSingletonServices & {
-    userSession: UserSessionService<any>;
+    userSessionService: UserSessionService<any>;
 }, interaction: PikkuInteraction, middlewares: PikkuMiddleware[], main?: () => Promise<void>) => Promise<void>;

package/dist/pikku-request.d.ts

@@ -4,11 +4,11 @@
  * @group RequestResponse
  */
 export declare abstract class PikkuRequest<In = any> {
-    private data?;
-    constructor(data?: In | undefined);
+    #private;
+    constructor(data: In);
     /**
      * Retrieves the data
      * @returns A promise that resolves to an object containing the combined data.
      */
-    getData(): Promise<In>;
+    data(): Promise<In>;
 }

package/dist/pikku-request.js

@@ -4,18 +4,18 @@
  * @group RequestResponse
  */
 export class PikkuRequest {
-    data;
+    #data;
     constructor(data) {
-        this.data = data;
+        this.#data = data;
     }
     /**
      * Retrieves the data
      * @returns A promise that resolves to an object containing the combined data.
      */
-    async getData() {
-        if (!this.data) {
+    async data() {
+        if (!this.#data) {
             throw new Error('Data not found');
         }
-        return this.data;
+        return this.#data;
     }
 }

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

@@ -8,4 +8,4 @@ export type RunScheduledTasksParams = {
     createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export declare const addScheduledTask: <APIFunction extends CoreAPIFunctionSessionless<void, void>>(scheduledTask: CoreScheduledTask<APIFunction>) => void;
-export declare function runScheduledTask<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession, Services extends CoreServices<SingletonServices> = CoreServices<SingletonServices>>({ name, session, singletonServices, createSessionServices, }: RunScheduledTasksParams): Promise<void>;
+export declare function runScheduledTask<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession>({ name, session, singletonServices, createSessionServices, }: RunScheduledTasksParams): Promise<void>;

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

@@ -1,23 +1,18 @@
 import { ChannelStore } from '../channel/channel-store.js';
 import { CoreUserSession } from '../types/core.types.js';
 export interface UserSessionService<UserSession extends CoreUserSession> {
+    setInitial(session: UserSession): void;
     set(session: UserSession): Promise<void> | void;
     clear(): Promise<void> | void;
     get(): Promise<UserSession | undefined> | UserSession | undefined;
 }
-export declare class LocalUserSessionService<UserSession extends CoreUserSession> implements UserSessionService<UserSession> {
+export declare class PikkuUserSessionService<UserSession extends CoreUserSession> implements UserSessionService<UserSession> {
+    private channelStore?;
+    private channelId?;
     private session;
-    constructor(session?: UserSession | undefined);
-    set(session: UserSession): void;
-    clear(): void;
-    get(): UserSession | undefined;
-}
-export declare class RemoteUserSessionService<UserSession extends CoreUserSession> implements UserSessionService<UserSession> {
-    private channelStore;
-    private channelId;
-    session: UserSession | undefined;
-    constructor(channelStore: ChannelStore<unknown, unknown, UserSession>, channelId: string, session?: UserSession | undefined);
-    set(session: UserSession): void | Promise<void>;
-    clear(): void | Promise<void>;
-    get(): Promise<UserSession | undefined>;
+    constructor(channelStore?: ChannelStore<unknown, unknown, UserSession> | undefined, channelId?: string | undefined);
+    setInitial(session: UserSession): void;
+    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,35 +1,35 @@
-export class LocalUserSessionService {
-    session;
-    constructor(session = undefined) {
-        this.session = session;
-    }
-    set(session) {
-        this.session = session;
-    }
-    clear() {
-        this.session = undefined;
-    }
-    get() {
-        return this.session;
-    }
-}
-export class RemoteUserSessionService {
+export class PikkuUserSessionService {
     channelStore;
     channelId;
     session;
-    constructor(channelStore, channelId, session = undefined) {
+    constructor(channelStore, channelId) {
         this.channelStore = channelStore;
         this.channelId = channelId;
+        if (channelStore && !channelId) {
+            throw new Error('Channel ID is required when using channel store');
+        }
+    }
+    setInitial(session) {
         this.session = session;
     }
     set(session) {
-        return this.channelStore.setUserSession(this.channelId, session);
+        this.session = session;
+        return this.channelStore?.setUserSession(this.channelId, session);
     }
     clear() {
-        return this.channelStore.setUserSession(this.channelId, null);
+        this.session = undefined;
+        return this.channelStore?.setUserSession(this.channelId, null);
     }
-    async get() {
-        const { session } = await this.channelStore.getChannelAndSession(this.channelId);
-        return session;
+    get() {
+        if (this.channelStore) {
+            const channel = this.channelStore.getChannelAndSession(this.channelId);
+            if (channel instanceof Promise) {
+                return channel.then(({ session }) => session);
+            }
+            else {
+                return channel.session;
+            }
+        }
+        return this.session;
     }
 }

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

@@ -74,7 +74,7 @@ export interface PikkuInteraction {
  * A function that can wrap an interaction and be called before or after
  */
 export type PikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices & {
-    userSession: UserSessionService<UserSession>;
+    userSessionService: UserSessionService<UserSession>;
 }, interactions: PikkuInteraction, next: () => Promise<void>) => Promise<void>;
 /**
  * Represents the core services used by Pikku, including singleton services and the request/response interaction.

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

@@ -1,3 +1,4 @@
+import { PikkuChannel } from '../channel/channel.types.js';
 import type { CoreServices, CoreSingletonServices, CoreUserSession } from './core.types.js';
 /**
  * Represents a core API function that performs an operation using core services and a user session.
@@ -7,7 +8,9 @@ import type { CoreServices, CoreSingletonServices, CoreUserSession } from './cor
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CoreAPIFunction<In, Out, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session: Session) => Promise<Out>;
+export type CoreAPIFunction<In, Out, Services extends CoreSingletonServices = CoreServices & {
+    channel?: PikkuChannel<unknown, Out>;
+}, Session extends CoreUserSession = CoreUserSession, Channel extends boolean = false> = (services: Services, data: In, session: Session) => Channel extends true ? Promise<Out> | Promise<void> : Promise<Out>;
 /**
  * Represents a core API function that can be used without a session.
  *
@@ -16,7 +19,9 @@ export type CoreAPIFunction<In, Out, Services extends CoreSingletonServices = Co
  * @template Services - The services type, defaults to `CoreServices`.
  * @template Session - The session type, defaults to `CoreUserSession`.
  */
-export type CoreAPIFunctionSessionless<In, Out, Services extends CoreSingletonServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: Services, data: In, session?: Session) => Promise<Out>;
+export type CoreAPIFunctionSessionless<In, Out, Services extends CoreSingletonServices = CoreServices & {
+    channel?: PikkuChannel<unknown, Out>;
+}, Session extends CoreUserSession = CoreUserSession, Channel extends boolean = false> = (services: Services, data: In, session: Session) => Channel extends true ? Promise<Out> | Promise<void> : Promise<Out>;
 /**
  * Represents a function that checks permissions for a given API operation.
  *