@pikku/core 0.6.26 → 0.7.0

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

@@ -4,6 +4,15 @@ export class PikkuFetchHTTPResponse {
     #headers = new Headers();
     #cookies = new Map();
     #body = null;
+    #responseMode = null;
+    #send = null;
+    #close = null;
+    setMode(mode) {
+        this.#responseMode = 'stream';
+        if (mode === 'stream') {
+            this.#body = this.createStream();
+        }
+    }
     status(code) {
         this.#statusCode = code;
         return this;
@@ -23,34 +32,60 @@ export class PikkuFetchHTTPResponse {
         return this;
     }
     arrayBuffer(data) {
-        this.#body = data;
-        this.header('Content-Type', 'application/octet-stream');
+        if (this.#responseMode === 'stream') {
+            this.#send(data);
+        }
+        else {
+            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');
+        if (this.#responseMode === 'stream') {
+            this.#send(JSON.stringify(data));
+        }
+        else {
+            this.#body = JSON.stringify(data);
+            this.header('Content-Type', 'application/json');
+        }
         return this;
     }
     text(content) {
-        this.#body = content;
-        this.header('Content-Type', 'text/plain');
+        if (this.#responseMode === 'stream') {
+            this.#send(content);
+        }
+        else {
+            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;
+        if (this.#responseMode === 'stream') {
+            this.#send(content);
+        }
+        else {
+            this.#body = content;
+            this.header('Content-Type', 'text/html');
+        }
         return this;
     }
+    // public body(body: BodyInit): this {
+    //   this.#body = body
+    //   return this
+    // }
     redirect(location, status = 302) {
         this.#statusCode = status;
         this.header('Location', location);
         return this;
     }
+    close() {
+        if (this.#close) {
+            this.#close();
+        }
+        return this;
+    }
     toResponse(args) {
         const cookieHeader = Array.from(this.#cookies.entries()).map(([name, { value, flags }]) => serializeCookie(name, value, flags));
         this.#headers.set('Set-Cookie', cookieHeader.join(', '));
@@ -60,4 +95,21 @@ export class PikkuFetchHTTPResponse {
             headers: this.#headers,
         });
     }
+    createStream() {
+        const encoder = new TextEncoder();
+        return new ReadableStream({
+            start: (controller) => {
+                const send = (data) => {
+                    controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                };
+                const close = () => {
+                    controller.close();
+                };
+                this.#send = send;
+                this.#close = close;
+                // Force initial flush
+                controller.enqueue(encoder.encode(':\n\n'));
+            },
+        });
+    }
 }

package/dist/http/pikku-http-request.d.ts

@@ -0,0 +1,56 @@
+import { PikkuRequest } from '../pikku-request.js';
+import { HTTPMethod, PikkuQuery } from './http-routes.types.js';
+/**
+ * Abstract class representing a pikku request.
+ * @template In - The type of the request body.
+ * @group RequestResponse
+ */
+export declare class PikkuHTTPRequest<In = unknown> extends PikkuRequest<In> {
+    private request;
+    private _params;
+    private url;
+    constructor(request: Request);
+    method(): HTTPMethod;
+    path(): string;
+    /**
+     * Retrieves the request body.
+     * @returns A promise that resolves to the request body.
+     */
+    json(): Promise<In>;
+    /**
+     * Retrieves the raw request body as a Buffer.
+     * @returns A promise that resolves to the raw request body.
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Retrieves the value of a specific header.
+     * @param headerName - The name of the header to retrieve.
+     * @returns The value of the header, or undefined if the header is not found.
+     */
+    header(headerName: string): string | null;
+    /**
+     * Retrieves the cookies from the request.
+     * @returns An object containing the cookies.
+     */
+    cookies(): Partial<Record<string, string>>;
+    /**
+     * Retrieves the request parameters.
+     * @returns An object containing the request parameters.
+     */
+    params(): Partial<Record<string, string | string[]>>;
+    /**
+     * Sets the request parameters.
+     * @param params - An object containing the request parameters to set.
+     */
+    setParams(params: Record<string, string | string[] | undefined>): void;
+    /**
+     * Retrieves the query parameters from the request.
+     * @returns An object containing the query parameters.
+     */
+    query(): PikkuQuery;
+    /**
+     * Retrieves the combined data from the request, including parameters, query, and body.
+     * @returns A promise that resolves to an object containing the combined data.
+     */
+    getData(): Promise<In>;
+}

package/dist/http/pikku-http-request.js

@@ -0,0 +1,95 @@
+import { parse as parseQuery } from 'picoquery';
+import { parse as parseCookie } from 'cookie';
+import { PikkuRequest } from '../pikku-request.js';
+/**
+ * Abstract class representing a pikku request.
+ * @template In - The type of the request body.
+ * @group RequestResponse
+ */
+export class PikkuHTTPRequest extends PikkuRequest {
+    request;
+    _params = {};
+    url;
+    constructor(request) {
+        super();
+        this.request = request;
+        this.url = new URL(request.url);
+    }
+    method() {
+        return this.request.method.toLowerCase();
+    }
+    path() {
+        return this.url.pathname;
+    }
+    /**
+     * Retrieves the request body.
+     * @returns A promise that resolves to the request body.
+     */
+    json() {
+        return this.request.json();
+    }
+    /**
+     * Retrieves the raw request body as a Buffer.
+     * @returns A promise that resolves to the raw request body.
+     */
+    arrayBuffer() {
+        return this.request.arrayBuffer();
+    }
+    /**
+     * Retrieves the value of a specific header.
+     * @param headerName - The name of the header to retrieve.
+     * @returns The value of the header, or undefined if the header is not found.
+     */
+    header(headerName) {
+        return this.request.headers.get(headerName.toLowerCase());
+    }
+    /**
+     * Retrieves the cookies from the request.
+     * @returns An object containing the cookies.
+     */
+    cookies() {
+        const cookieHeader = this.header('cookie');
+        if (cookieHeader) {
+            return parseCookie(cookieHeader);
+        }
+        return {};
+    }
+    /**
+     * Retrieves the request parameters.
+     * @returns An object containing the request parameters.
+     */
+    params() {
+        return this._params;
+    }
+    /**
+     * Sets the request parameters.
+     * @param params - An object containing the request parameters to set.
+     */
+    setParams(params) {
+        this._params = params;
+    }
+    /**
+     * Retrieves the query parameters from the request.
+     * @returns An object containing the query parameters.
+     */
+    query() {
+        return parseQuery(this.url.searchParams.toString());
+    }
+    /**
+     * Retrieves the combined data from the request, including parameters, query, and body.
+     * @returns A promise that resolves to an object containing the combined data.
+     */
+    async getData() {
+        let body = {};
+        try {
+            body = await this.json();
+        }
+        catch (e) { }
+        return {
+            ...this.params(),
+            ...this.query(),
+            // TODO: If body isn't an object, we should insert it as the word...
+            ...body,
+        };
+    }
+}

package/dist/http/pikku-http-response.d.ts

@@ -0,0 +1,13 @@
+export declare class PikkuHTTPResponse {
+    #private;
+    status(code: number): this;
+    cookie(name: string, value: string, flags: any): this;
+    header(name: string, value: string | string[]): this;
+    arrayBuffer(data: XMLHttpRequestBodyInit): this;
+    json(data: unknown): this;
+    text(content: string): this;
+    html(content: string): this;
+    body(body: BodyInit): this;
+    redirect(location: string, status?: number): this;
+    toResponse(args?: Record<string, any>): Response;
+}

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

@@ -0,0 +1,60 @@
+export class PikkuHTTPResponse {
+    #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);
+        this.html(`Redirecting to <a href="${location}">${location}</a>`);
+        return this;
+    }
+    toResponse(args) {
+        return new Response(this.#body, {
+            ...args,
+            status: this.#statusCode,
+            headers: this.#headers,
+        });
+    }
+}

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * @module @pikku/core
  */
 export * from './types/core.types.js';
-export * from './types/functions.types.js';
+export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
 export * from './services/index.js';
@@ -12,8 +12,9 @@ export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './time-utils.js';
+export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addRoute, addMiddleware } from './http/http-route-runner.js';
+export { addHTTPRoute, addMiddleware } from './http/http-runner.js';
 export { addChannel } from './channel/channel-runner.js';
 export { addScheduledTask } from './scheduler/scheduler-runner.js';

package/dist/index.js

@@ -2,7 +2,7 @@
  * @module @pikku/core
  */
 export * from './types/core.types.js';
-export * from './types/functions.types.js';
+export * from './function/index.js';
 export * from './pikku-request.js';
 export * from './pikku-response.js';
 export * from './services/index.js';
@@ -12,8 +12,9 @@ export * from './scheduler/index.js';
 export * from './errors/index.js';
 export * from './middleware/index.js';
 export * from './time-utils.js';
+export * from './utils.js';
 export { pikkuState } from './pikku-state.js';
 export { runMiddleware } from './middleware-runner.js';
-export { addRoute, addMiddleware } from './http/http-route-runner.js';
+export { addHTTPRoute, addMiddleware } from './http/http-runner.js';
 export { addChannel } from './channel/channel-runner.js';
 export { addScheduledTask } from './scheduler/scheduler-runner.js';

package/dist/middleware/auth-apikey.js

@@ -5,7 +5,8 @@
  */
 export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSession.get()) {
+        const { userSession: userSessionService, jwt: jwtService } = services;
+        if (!http?.request || userSessionService.get()) {
             return next();
         }
         let apiKey = null;
@@ -18,16 +19,16 @@ export const authAPIKey = ({ source, getSessionForAPIKey, jwt, }) => {
         if (apiKey) {
             let userSession = null;
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT decoding.');
                 }
-                userSession = await services.jwt.decode(apiKey);
+                userSession = await jwtService.decode(apiKey);
             }
             else {
                 userSession = await getSessionForAPIKey(services, apiKey);
             }
             if (userSession) {
-                services.userSession.setInitial(userSession);
+                userSessionService.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-bearer.js

@@ -4,8 +4,9 @@ import { InvalidSessionError } from '../errors/errors.js';
  */
 export const authBearer = ({ token, jwt, getSession, } = {}) => {
     const middleware = async (services, { http }, next) => {
+        const { userSession: userSessionService, jwt: jwtService } = services;
         // Skip if session already exists.
-        if (!http?.request || services.userSession.get()) {
+        if (!http?.request || userSessionService.get()) {
             return next();
         }
         const authHeader = http.request.header('authorization') ||
@@ -17,10 +18,10 @@ export const authBearer = ({ token, jwt, getSession, } = {}) => {
             }
             let userSession = null;
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT decoding.');
                 }
-                userSession = await services.jwt.decode(bearerToken);
+                userSession = await jwtService.decode(bearerToken);
             }
             else if (token) {
                 if (bearerToken === token.value) {
@@ -31,7 +32,7 @@ export const authBearer = ({ token, jwt, getSession, } = {}) => {
                 userSession = await getSession(services, token);
             }
             if (userSession) {
-                services.userSession.setInitial(userSession);
+                userSessionService.setInitial(userSession);
             }
         }
         return next();

package/dist/middleware/auth-cookie.js

@@ -7,43 +7,44 @@ import { getRelativeTimeOffsetFromNow, } from '../time-utils.js';
  */
 export const authCookie = ({ name, getSessionForCookieValue, jwt, options, expiresIn, }) => {
     const middleware = async (services, { http }, next) => {
-        if (!http?.request || services.userSession.get()) {
+        const { userSession: userSessionService, jwt: jwtService, logger, } = services;
+        if (!http?.request || userSessionService.get()) {
             return next();
         }
         let userSession = null;
         const cookieValue = http.request.cookie(name);
         if (cookieValue) {
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT decoding.');
                 }
-                userSession = await services.jwt.decode(cookieValue);
+                userSession = await jwtService.decode(cookieValue);
             }
             else if (getSessionForCookieValue) {
                 userSession = await getSessionForCookieValue(services, cookieValue, name);
             }
         }
         if (userSession) {
-            services.userSession.setInitial(userSession);
+            userSessionService.setInitial(userSession);
         }
         await next();
         // Set the cookie in the response if the session has changed
         if (!http?.response) {
             return;
         }
-        if (services.userSession.sessionChanged) {
-            const session = services.userSession.get();
+        if (userSessionService.sessionChanged) {
+            const session = userSessionService.get();
             if (jwt) {
-                if (!services.jwt) {
+                if (!jwtService) {
                     throw new Error('JWT service is required for JWT encoding.');
                 }
-                http.response.cookie(name, await services.jwt.encode(expiresIn, session), {
+                http.response.cookie(name, await jwtService.encode(expiresIn, session), {
                     ...options,
                     expires: getRelativeTimeOffsetFromNow(expiresIn),
                 });
             }
             else {
-                services.logger.warn('No JWT service available, unable to set cookie');
+                logger.warn('No JWT service available, unable to set cookie');
             }
         }
     };

package/dist/parse-relative-time-offset.d.ts

@@ -0,0 +1,12 @@
+type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'year';
+export interface RelativeTimeInput {
+    value: number;
+    unit: TimeUnit;
+}
+export declare const getRelativeTimeOffset: ({ value, unit }: RelativeTimeInput) => number;
+/**
+ * Returns a Unix timestamp (in seconds) offset from now by the given duration.
+ * e.g. value = -1 and unit = 'day' => 1 day ago => now - 86400 seconds
+ */
+export declare const getRelativeTimeOffsetFromNow: (relativeTime: RelativeTimeInput) => Date;
+export {};

package/dist/parse-relative-time-offset.js

@@ -0,0 +1,20 @@
+export const getRelativeTimeOffset = ({ value, unit }) => {
+    const multipliers = {
+        second: 1,
+        minute: 60,
+        hour: 60 * 60,
+        day: 60 * 60 * 24,
+        week: 60 * 60 * 24 * 7,
+        year: Math.round(365.25 * 60 * 60 * 24),
+    };
+    return Math.round(value * multipliers[unit]);
+};
+/**
+ * Returns a Unix timestamp (in seconds) offset from now by the given duration.
+ * e.g. value = -1 and unit = 'day' => 1 day ago => now - 86400 seconds
+ */
+export const getRelativeTimeOffsetFromNow = (relativeTime) => {
+    const now = Math.floor(Date.now() / 1000);
+    console.log(getRelativeTimeOffset(relativeTime), relativeTime, now);
+    return new Date(now + getRelativeTimeOffset(relativeTime));
+};

package/dist/permissions.d.ts

@@ -1,5 +1,5 @@
 import { CoreServices, CoreUserSession } from './types/core.types.js';
-import { CoreAPIPermission } from './types/functions.types.js';
+import { CorePermissionGroup } from './function/functions.types.js';
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
  * @param services - The core services required for permission validation.
@@ -7,4 +7,4 @@ import { CoreAPIPermission } from './types/functions.types.js';
  * @param session - An optional user session for permission validation.
  * @returns A promise that resolves to void.
  */
-export declare const verifyPermissions: (permissions: Record<string, CoreAPIPermission<any>[] | CoreAPIPermission<any>> | undefined, services: CoreServices, data: any, session?: CoreUserSession) => Promise<boolean>;
+export declare const verifyPermissions: (permissions: CorePermissionGroup, services: CoreServices, data: any, session?: CoreUserSession) => Promise<boolean>;

package/dist/pikku-func.d.ts

@@ -0,0 +1,12 @@
+import { CoreServices, CoreSingletonServices, CoreUserSession } from "./types/core.types.js";
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CorePermissionGroup } from "./types/functions.types.js";
+export declare const getFunctionName: (func: CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>) => string;
+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;
+    getAllServices: () => Promise<CoreServices> | CoreServices;
+    data: In;
+    session?: CoreUserSession;
+    permissions?: CorePermissionGroup;
+    coerceDataFromSchema?: boolean;
+}) => Promise<Out>;

package/dist/pikku-func.js

@@ -0,0 +1,39 @@
+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 getFunctionName = (func) => {
+    const funcName = pikkuState('functions', 'functionToName').get(func);
+    if (!funcName) {
+        throw new Error(`Function not found: ${funcName}`);
+    }
+    return funcName;
+};
+export const runPikkuFuncDirectly = async (funcName, allServices, data, session) => {
+    const func = pikkuState('functions', 'nameToFunction').get(funcName);
+    if (!func) {
+        throw new Error(`Function not found: ${funcName}`);
+    }
+    return await func(allServices, data, session);
+};
+export const runPikkuFunc = async (funcName, { singletonServices, getAllServices, data, session, permissions, coerceDataFromSchema }) => {
+    const func = pikkuState('functions', 'nameToFunction').get(funcName);
+    if (!func) {
+        throw new Error(`Function not found: ${funcName}`);
+    }
+    const funcMeta = pikkuState('functions', 'meta')[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);
+    }
+    const allServices = await getAllServices();
+    // Execute permission checks
+    const permissioned = await verifyPermissions(permissions, allServices, data, session);
+    if (permissioned === false) {
+        throw new ForbiddenError('Permission denied');
+    }
+    return await func(allServices, data, session);
+};

package/dist/pikku-function.d.ts

@@ -0,0 +1 @@
+export declare const callFunction: () => void;

package/dist/pikku-function.js

@@ -0,0 +1 @@
+export const callFunction = () => { };

package/dist/pikku-state.d.ts

@@ -1,19 +1,24 @@
-import { ChannelsMeta, CoreAPIChannels } from './channel/channel.types.js';
-import { CoreHTTPFunctionRoutes, HTTPRoutesMeta } from './http/http-routes.types.js';
-import { PikkuMiddleware } from './types/core.types.js';
+import { ChannelsMeta, CoreAPIChannel } from './channel/channel.types.js';
+import { CoreHTTPFunctionRoute, HTTPMethod, HTTPRoutesMeta } from './http/http.types.js';
+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';
 interface PikkuState {
+    functions: {
+        meta: FunctionsMeta;
+        nameToFunction: Map<string, CoreAPIFunction<any, any> | CoreAPIFunctionSessionless<any, any>>;
+    };
     http: {
         middleware: Array<{
             route: string;
             middleware: PikkuMiddleware[];
         }>;
-        routes: CoreHTTPFunctionRoutes;
+        routes: Map<HTTPMethod, Map<string, CoreHTTPFunctionRoute<any, any, any>>>;
         meta: HTTPRoutesMeta;
     };
     channel: {
-        channels: CoreAPIChannels;
+        channels: Map<string, CoreAPIChannel<any, any>>;
         meta: ChannelsMeta;
     };
     scheduler: {

package/dist/pikku-state.js

@@ -1,13 +1,17 @@
 export const resetPikkuState = () => {
     globalThis.pikkuState = {
+        functions: {
+            meta: {},
+            nameToFunction: new Map(),
+        },
         http: {
             middleware: [],
-            routes: [],
+            routes: new Map(),
             meta: [],
         },
         channel: {
-            channels: [],
-            meta: [],
+            channels: new Map(),
+            meta: {},
         },
         scheduler: {
             tasks: new Map(),

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

@@ -1,6 +1,6 @@
 import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../types/core.types.js';
 import type { CoreScheduledTask } from './scheduler.types.js';
-import type { CoreAPIFunctionSessionless } from '../types/functions.types.js';
+import type { CoreAPIFunctionSessionless } from '../function/functions.types.js';
 export type RunScheduledTasksParams = {
     name: string;
     session?: CoreUserSession;