@pikku/core 0.6.9

package/CHANGELOG.md

@@ -0,0 +1,339 @@
+## 0.6
+
+## 0.6.9
+
+### Patch Changes
+
+- f3550d8: feat: changing singleton constructor to accept a prtial map of existing services
+
+## 0.6.8
+
+### Patch Changes
+
+- b19aa86: refactor: switching aws to using @aws-sdk/cloudfront-signer
+
+## 0.6.7
+
+### Patch Changes
+
+- 0a92fa7: refactor: pulling schema into seperate package since ajv doesnt work on cloudflare (also keeps bundle size small!)
+
+## 0.6.6
+
+### Patch Changes
+
+- 4357bca: feat: fixing up nextjs apis
+
+## 0.6.5
+
+### Patch Changes
+
+- a40a508: fix: Fixing some generation bugs and other minors
+
+## 0.6.4
+
+### Patch Changes
+
+- f26880f: feat: extracting inspector and adding unique type references
+
+## 0.6.3
+
+### Patch Changes
+
+- 09fc52c: feat: adding cloudflare and lambda websockets
+  breaking change: moved subscription from channel to services and renamed to event hub
+- adecb52: feat: changes required to get cloudflare functions to work
+
+## 0.6.2
+
+### Patch Changes
+
+- ed45ca9: feat: adding lambda serverless
+- adeb392: feat: more channel improvements, and adding bubble option to runners to avoid all the empty try catches
+
+## 0.6.1
+
+### Patch Changes
+
+- dee2e9f: feat: adding a subscription service change handler
+
+Marking a major release to include channels and scheduled tasks
+
+## 0.5.29
+
+### Patch Changes
+
+- 662a6cf: feat: adding scheduled tasks names
+- c8578ea: fix: getting websocket auth to work on individual messages
+- d2f8edf: feat: adding channelId to channels for serverless compatability
+
+## 0.5.28
+
+### Patch Changes
+
+- a768bad: feat: adding channel permission service
+- 886a2fb: refactor: moving singletons (like routes and channels) to global to avoid nodemodule overrides
+- 886a2fb: fix: making core routes global to avoid state overrides
+
+## 0.5.27
+
+### Patch Changes
+
+- aa8435c: fix: fixing up channel apis and implementations
+
+## 0.5.26
+
+### Patch Changes
+
+- ab42f18: chore: upgrading to next15 and dropping pages support
+
+## 0.5.25
+
+### Patch Changes
+
+- 0f96787: refactor: dropping cjs support
+- 64e4a1e: refactor: seperating core into cleaner sub-packages
+- c23524a: refactor: bump to versions to ensure correct package usage
+
+## 0.5.24
+
+### Patch Changes
+
+- bba25cc: chore: updating all packages to reflect major changes
+- 9deb482: refactor: finalizing stream api
+- ee0c6ea: feat: adding ws server
+
+## 0.5.23
+
+### Patch Changes
+
+- 7fa64a0: feat: making schedule session services optional
+- 539937e: refactor: use a map instead for scheduled tasks
+- e9a9968: refactor: completing rename of stream to channel
+
+## 0.5.22
+
+### Patch Changes
+
+- 73973ec: fix: data type for methods is optional
+
+## 0.5.21
+
+### Patch Changes
+
+- 179b9c2: fix: fixing stream types
+
+## 0.5.20
+
+### Patch Changes
+
+- 5be6da1: feat: adding streams to uws (and associated refactors)
+
+## 0.5.19
+
+### Patch Changes
+
+- cbcc75b: feat: adding scheduler types to core
+- d58c440: refactor: making http requests explicit to support other types
+- 11c50d4: feat: adding streams to cli
+
+## 0.5.18
+
+### Patch Changes
+
+- bed9ab4: revert: reverting ajv array transformation
+- d4dd093: feat: coerce top level strings to arrays
+
+## 0.5.17
+
+### Patch Changes
+
+- 2f77f5f: feat: coerce array types if needed via ajv validation
+
+## 0.5.16
+
+### Patch Changes
+
+- 4046a85: feat: adding more error types
+
+## 0.5.15
+
+### Patch Changes
+
+- 816eaaa: fix: don't throw an error if auth isnt required for a route
+
+## 0.5.14
+
+### Patch Changes
+
+- 8531c5e: fix: export log routes in index since bundler can't find it
+
+## 0.5.13
+
+### Patch Changes
+
+- 30b46aa: fix: looks like using patch lowercase breaks the node fetch client sometimes
+
+## 0.5.12
+
+### Patch Changes
+
+- ff8a563: feat: only log warning errors for status codes we care about
+
+## 0.5.11
+
+### Patch Changes
+
+- be68efb: fix: allow error handler to use errors other than EError
+- 5295380: refactor: changing config object a getConfig function
+- f24a653: feat: coerce types in ajv for correct validation / usage later on
+
+## 0.5.10
+
+### Patch Changes
+
+- effbb4c: doc: adding readme to all packages
+
+## 0.5.9
+
+### Patch Changes
+
+- 3541ab7: refactor: rename nextDeclarationFile to nextJSFile
+- 725723d: docs: adding typedocs
+
+## 0.5.8
+
+### Patch Changes
+
+- 1876d7a: feat: add error return codes to doc generation
+- 8d85f7e: feat: load all schemas on start optionally instead of validating they were loaded
+
+## 0.5.7
+
+### Patch Changes
+
+- df62faf: fix: bumping up routes meta
+
+## 0.5.6
+
+### Patch Changes
+
+- 0883f00: fix: schema generation error
+
+## 0.5.5
+
+### Patch Changes
+
+- 93b80a3: feat: adding a beta openapi standard
+
+## 0.5.4
+
+### Patch Changes
+
+- 6cac8ab: feat: adding a do not edit to cli generated files
+
+## 0.5.3
+
+### Patch Changes
+
+- 8065e48: refactor: large cli refactor for a better dev experience
+
+## 0.5.2
+
+### Patch Changes
+
+- 5e0f033: feat: adding a routes map output file to support frontend sdks in the future
+
+## 0.5.1
+
+### Patch Changes
+
+- 97900d2: fix: exporting plugins from default barrel files
+- d939d46: refactor: extracting nextjs and fastify to plugins
+- 45e07de: refactor: renaming packages and pikku structure
+
+## 0.4.7
+
+### Patch Changes
+
+- ddaf58f: feat: adding hostname to servers
+
+## 0.4.6
+
+### Patch Changes
+
+- 2a2402b: republish since something went wrong
+
+## 0.4.5
+
+### Patch Changes
+
+- c73afd6: this should have been published..
+
+## 0.4.4
+
+### Patch Changes
+
+- 0650348: fix: export schemas using \*
+- 1a708a7: refactor: renaming PikkuCLIConfig back to PikkuConfig
+  feat: adding .end() to pikku response for servers that need it
+- 642d370: fix: adding schema error logs on fail
+
+## 0.4.3
+
+### Patch Changes
+
+- 94f8a74: fix: finalizing cjs and esm packages
+
+## 0.4.2
+
+### Patch Changes
+
+- 28f62ea: refactor: using cjs and esm builds!
+- 14783ee: fix: including all types as dependencies to avoid users needing to install them
+
+## 0.0.18 - 05.09.2022
+
+feat: adding a maximum compute time for better error handling on lambda timeouts
+
+## 0.0.17 - 24.08.2022
+
+fix: use error name instead of constructor for better management of instanceof
+
+## 0.0.10 - 21.07.2022
+
+feat: add a transform session call incase jwt provided belongs to a third-party like aws cognito
+
+## 0.0.9 - 26.06.2022
+
+chore: Upgrading dependencies
+
+## 0.0.6 - 13.04.2022
+
+chore: Upgrading dependencies
+
+## 0.0.5 - 19.02.2022
+
+chore: Upgrading dependencies
+
+## 0.0.4 - 26.09.2021
+
+feat: Adding writeFile, readFile and deleteFile APIs
+
+## 0.0.3 - 02.09.2021
+
+chore: Updating dependencies
+
+## 0.0.2 - 02.08.2021
+
+Fix: deleting files with correct path in local files
+
+## 0.0.1 - 27.07.2021
+
+Fix: Using global space for schemas as it appears to not always return the same file
+
+## 23.07.2021
+
+### Initial Release
+
+A package that contains pikku types

package/README.md

@@ -0,0 +1,5 @@
+# @pikku/core
+
+This package is part of @pikku/mono and is responsible for the runtime in pikku.
+
+It is used by most other packages, contains all the core types and minimal requirements.

package/dist/channel/channel-handler.d.ts

@@ -0,0 +1,3 @@
+import { CoreServices, CoreUserSession } from '../types/core.types.js';
+import { CoreAPIChannel, PikkuChannelHandler } from './channel.types.js';
+export declare const processMessageHandlers: (services: CoreServices, channelConfig: CoreAPIChannel<any, any>, channelHandler: PikkuChannelHandler<CoreUserSession, unknown>) => (rawData: any) => Promise<unknown>;

package/dist/channel/channel-handler.js

@@ -0,0 +1,97 @@
+import { verifyPermissions } from '../permissions.js';
+import { getChannels } from './channel-runner.js';
+const validateSchema = (logger, data, channelName, routingProperty, routerValue) => {
+    const { channelsMeta } = getChannels();
+    for (const channelMeta of channelsMeta) {
+        if (routingProperty && routerValue) {
+            const channelRoute = channelMeta.messageRoutes[routingProperty]?.[routerValue];
+            if (channelRoute) {
+                const schemaNames = channelRoute.inputs;
+                if (schemaNames) {
+                    // TODO
+                    // loadSchema(schemaNames, logger)
+                    // validateJson(schemaNames, data)
+                }
+                return;
+            }
+        }
+    }
+};
+const validateAuth = (requiresSession, channelHandler, onMessage) => {
+    const auth = typeof onMessage === 'function'
+        ? requiresSession
+        : onMessage.auth === undefined
+            ? requiresSession
+            : onMessage.auth;
+    if (auth && !channelHandler.getChannel().userSession) {
+        return false;
+    }
+    return true;
+};
+const validatePermissions = async (services, channelHandler, onMessage, data) => {
+    const permissions = typeof onMessage === 'function' ? {} : onMessage.permissions;
+    return await verifyPermissions(permissions, services, data, channelHandler.getChannel().userSession);
+};
+const runFunction = async (services, channelHandler, onMessage, data) => {
+    const func = typeof onMessage === 'function' ? onMessage : onMessage.func;
+    return await func(services, channelHandler.getChannel(), data);
+};
+export const processMessageHandlers = (services, channelConfig, channelHandler) => {
+    const logger = services.logger;
+    const requiresSession = channelConfig.auth !== false;
+    const processMessage = async (data, onMessage, routingProperty, routerValue) => {
+        if (!validateAuth(requiresSession, channelHandler, onMessage)) {
+            const routeMessage = routingProperty
+                ? `route '${routingProperty}:${routerValue}'`
+                : 'the default message route';
+            logger.error(`Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for ${routeMessage}`);
+            // TODO: Send error message back breaks typescript, but should be implemented somehow
+            channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`);
+            return;
+        }
+        validateSchema(services.logger, data, channelConfig.name, routingProperty, routerValue);
+        const hasPermission = await validatePermissions(services, channelHandler, onMessage, data);
+        if (!hasPermission) {
+            logger.error(`Channel ${channelConfig.name} requires permissions for ${routingProperty || 'default message route'}`);
+        }
+        return await runFunction(services, channelHandler, onMessage, data);
+    };
+    const onMessage = async (rawData) => {
+        let result;
+        let processed = false;
+        // Route-specific handling
+        if (typeof rawData === 'string' && channelConfig.onMessageRoute) {
+            try {
+                const messageData = JSON.parse(rawData);
+                const entries = Object.entries(channelConfig.onMessageRoute);
+                for (const [routingProperty, routes] of entries) {
+                    const routerValue = messageData[routingProperty];
+                    if (routerValue && routes[routerValue]) {
+                        processed = true;
+                        result = await processMessage(messageData, routes[routerValue], routingProperty, routerValue);
+                        break;
+                    }
+                }
+                // Default handler if no routes matched but json data was parsed
+                if (!processed && channelConfig.onMessage) {
+                    processed = true;
+                    result = await processMessage(messageData, channelConfig.onMessage);
+                }
+            }
+            catch (error) {
+                // Most likely a json error.. ignore
+            }
+        }
+        // Default handler if no routes matched and json data wasn't parsed
+        if (!processed && channelConfig.onMessage) {
+            processed = true;
+            result = await processMessage(rawData, channelConfig.onMessage);
+        }
+        if (!processed) {
+            logger.error(`No handler found for message in channel ${channelConfig.name} for ${rawData}`);
+            logger.error(`Channel ${channelConfig}`);
+        }
+        return result;
+    };
+    return onMessage;
+};

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

@@ -0,0 +1,26 @@
+import { CoreUserSession } from '../types/core.types.js';
+import { CoreAPIChannel, ChannelsMeta, CoreAPIChannels, RunChannelOptions, RunChannelParams } from './channel.types.js';
+/**
+ * Returns all the registered routes and associated metadata.
+ * @internal
+ */
+export declare const getChannels: () => {
+    channels: CoreAPIChannels;
+    channelsMeta: ChannelsMeta;
+};
+export declare const addChannel: <In, Channel extends string, ChannelFunction, ChannelFunctionSessionless, APIPermission>(channel: CoreAPIChannel<In, Channel, ChannelFunction, ChannelFunctionSessionless, APIPermission>) => void;
+/**
+ * @ignore
+ */
+export declare const setChannelsMeta: (_channelsMeta: ChannelsMeta) => void;
+export declare const getMatchingChannelConfig: (request: string) => {
+    matchedPath: import("path-to-regexp").MatchResult<Partial<Record<string, string | string[]>>>;
+    params: Partial<Record<string, string | string[]>>;
+    channelConfig: CoreAPIChannel<any, string, import("./channel.types.js").CoreChannelConnection<any, unknown, import("../types/core.types.js").CoreServices, unknown>, import("./channel.types.js").CoreChannelConnection<any, unknown, import("../types/core.types.js").CoreServices, unknown>, import("./channel.types.js").CoreChannelMessage<unknown, unknown, unknown, import("../types/core.types.js").CoreServices, unknown>, import("./channel.types.js").CoreChannelMessage<unknown, unknown, unknown, import("../types/core.types.js").CoreServices, unknown>, import("../index.js").CoreAPIPermission<any>>;
+    schemaName: string | null | undefined;
+} | null;
+export declare const openChannel: ({ route, singletonServices, skipUserSession, coerceToArray, http, }: Pick<CoreAPIChannel<unknown, string>, "route"> & Omit<RunChannelParams<unknown>, "response" | "request"> & RunChannelOptions) => Promise<{
+    userSession?: CoreUserSession;
+    openingData: unknown;
+    channelConfig: CoreAPIChannel<unknown, any>;
+}>;

package/dist/channel/channel-runner.js

@@ -0,0 +1,86 @@
+import { NotFoundError } from '../errors/errors.js';
+import { loadUserSession } from '../http/http-route-runner.js';
+import { validateAndCoerce } from '../schema.js';
+import { match } from 'path-to-regexp';
+if (!globalThis.pikku?.channels) {
+    globalThis.pikku = globalThis.pikku || {};
+    globalThis.pikku.channels = [];
+    globalThis.pikku.channelsMeta = [];
+}
+const channels = (data) => {
+    if (data) {
+        globalThis.pikku.channels = data;
+    }
+    return globalThis.pikku.channels;
+};
+const channelsMeta = (data) => {
+    if (data) {
+        globalThis.pikku.channelsMeta = data;
+    }
+    return globalThis.pikku.channelsMeta;
+};
+/**
+ * Returns all the registered routes and associated metadata.
+ * @internal
+ */
+export const getChannels = () => {
+    return {
+        channels: channels(),
+        channelsMeta: channelsMeta(),
+    };
+};
+export const addChannel = (channel) => {
+    channels().push(channel);
+};
+/**
+ * @ignore
+ */
+export const setChannelsMeta = (_channelsMeta) => {
+    channelsMeta(_channelsMeta);
+};
+export const getMatchingChannelConfig = (request) => {
+    const { channels, channelsMeta } = getChannels();
+    for (const channelConfig of channels) {
+        const cleanedRoute = channelConfig.route.replace(/^\/\//, '/');
+        const cleanedRequest = request.replace(/^\/\//, '/');
+        const matchFunc = match(cleanedRoute, {
+            decode: decodeURIComponent,
+        });
+        const matchedPath = matchFunc(cleanedRequest);
+        if (matchedPath) {
+            const schemaName = channelsMeta.find((channelMeta) => channelMeta.route === channelConfig.route)?.input;
+            return {
+                matchedPath,
+                params: matchedPath.params,
+                channelConfig,
+                schemaName,
+            };
+        }
+    }
+    return null;
+};
+export const openChannel = async ({ route, singletonServices, skipUserSession = false, coerceToArray = false, http, }) => {
+    const matchingChannel = getMatchingChannelConfig(route);
+    if (!matchingChannel) {
+        singletonServices.logger.info(`Channel not found: ${route}`);
+        throw new NotFoundError(`Channel not found: ${route}`);
+    }
+    const { matchedPath, params, channelConfig, schemaName } = matchingChannel;
+    const requiresSession = channelConfig.auth !== false;
+    http?.request?.setParams(params);
+    singletonServices.logger.info(`Matched channel: ${channelConfig.name} | route: ${channelConfig.route} | auth: ${requiresSession.toString()}`);
+    const userSession = await loadUserSession(skipUserSession, 
+    // We may require a session, but we don't actually need it
+    // on connect since channels can authenticate later given
+    // how websocket sessions work (cookie or queryParam based)
+    false, http, matchedPath, channelConfig, singletonServices.logger, singletonServices.httpSessionService);
+    if (singletonServices.enforceChannelAccess) {
+        await singletonServices.enforceChannelAccess(matchingChannel.channelConfig, userSession);
+    }
+    let openingData;
+    if (http?.request) {
+        openingData = await http.request.getData();
+        validateAndCoerce(singletonServices.logger, singletonServices.schemaService, schemaName, openingData, coerceToArray);
+    }
+    return { userSession, openingData, channelConfig };
+};

package/dist/channel/channel-store.d.ts

@@ -0,0 +1,14 @@
+import { CoreUserSession } from '../types/core.types.js';
+export type Channel<ChannelType = unknown, OpeningData = unknown, UserSession extends CoreUserSession = CoreUserSession> = {
+    channelId: string;
+    channelName: string;
+    channelObject?: ChannelType;
+    openingData?: OpeningData;
+    userSession?: UserSession;
+};
+export declare abstract class ChannelStore<ChannelType = unknown, OpeningData = unknown, UserSession extends CoreUserSession = CoreUserSession, TypedChannel = Channel<ChannelType, OpeningData, UserSession>> {
+    abstract addChannel(channel: Channel<ChannelType, OpeningData, UserSession>): Promise<void> | void;
+    abstract removeChannels(channelId: string[]): Promise<void> | void;
+    abstract setUserSession(channelId: string, userSession: any): Promise<void> | void;
+    abstract getChannel(channelId: string): Promise<TypedChannel> | TypedChannel;
+}

package/dist/channel/channel-store.js

@@ -0,0 +1,2 @@
+export class ChannelStore {
+}

package/dist/channel/channel.types.d.ts

@@ -0,0 +1,106 @@
+import { EError } from '../errors/error-handler.js';
+import { HTTPFunctionMetaInputTypes, PikkuHTTP } from '../http/http-routes.types.js';
+import { PikkuHTTPAbstractRequest } from '../http/pikku-http-abstract-request.js';
+import { PikkuHTTPAbstractResponse } from '../http/pikku-http-abstract-response.js';
+import { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, MakeRequired } from '../types/core.types.js';
+import { CoreAPIPermission } from '../types/functions.types.js';
+import { PikkuRequest } from '../pikku-request.js';
+import { PikkuResponse } from '../pikku-response.js';
+export type RunChannelOptions = Partial<{
+    skipUserSession: boolean;
+    respondWith404: boolean;
+    coerceToArray: boolean;
+    logWarningsForStatusCodes: number[];
+    bubbleErrors: boolean;
+}>;
+export type RunChannelParams<ChannelData> = {
+    channelId: string;
+    singletonServices: MakeRequired<CoreSingletonServices, 'eventHub'>;
+    request?: PikkuRequest<ChannelData> | PikkuHTTPAbstractRequest<ChannelData>;
+    response?: PikkuResponse | PikkuHTTPAbstractResponse;
+    http?: PikkuHTTP;
+    createSessionServices?: CreateSessionServices;
+};
+export interface HandlerMeta {
+}
+export interface ChannelMeta {
+    name: string;
+    route: string;
+    params?: string[];
+    query?: string[];
+    input: string | null;
+    inputTypes?: HTTPFunctionMetaInputTypes;
+    connect: boolean;
+    disconnect: boolean;
+    message: {
+        inputs: string[] | null;
+        outputs: string[] | null;
+    } | null;
+    messageRoutes: Record<string, Record<string, {
+        inputs: string[] | null;
+        outputs: string[] | null;
+    }>>;
+    docs?: APIDocs;
+}
+export type ChannelsMeta = ChannelMeta[];
+export type CoreChannelConnection<ChannelData, Out = unknown, Services extends CoreServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<Session, ChannelData, Out>) => Promise<void>;
+export type CoreChannelDisconnection<ChannelData, Services extends CoreServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<Session, ChannelData, never>) => Promise<void>;
+/**
+ * Represents a core channel function that performs an operation using core services and a user session.
+ *
+ * @template In - The input type.
+ * @template Services - The services type, defaults to `CoreServices`.
+ * @template Session - The session type, defaults to `CoreUserSession`.
+ */
+export type CoreChannelMessage<In, Out, ChannelData, Services extends CoreServices = CoreServices, Session extends CoreUserSession = CoreUserSession> = (services: MakeRequired<Services, 'eventHub'>, channel: PikkuChannel<Session, ChannelData, Out>, data: In) => Promise<void | Out>;
+export type CoreAPIChannelMessage<ChannelFunctionMessage = CoreChannelMessage<unknown, unknown, unknown>> = {
+    func: ChannelFunctionMessage;
+    route: string;
+};
+export type CoreAPIChannel<ChannelData, Channel extends string, ChannelFunctionConnection = CoreChannelConnection<ChannelData>, ChannelFunctionDisconnection = CoreChannelConnection<ChannelData>, ChannelFunctionDefaultMessage = CoreChannelMessage<unknown, unknown, unknown>, ChannelFunctionMessageRoute = CoreChannelMessage<unknown, unknown, unknown>, APIPermission = CoreAPIPermission<ChannelData>> = {
+    name: string;
+    route: Channel;
+    onConnect?: ChannelFunctionConnection;
+    onDisconnect?: ChannelFunctionDisconnection;
+    onMessage?: {
+        func: ChannelFunctionDefaultMessage;
+        permissions?: Record<string, APIPermission[] | APIPermission>;
+        auth?: boolean;
+    } | ChannelFunctionDefaultMessage;
+    onMessageRoute?: Record<string, Record<string, ChannelFunctionMessageRoute | {
+        func: ChannelFunctionMessageRoute;
+        permissions?: Record<string, APIPermission[] | APIPermission>;
+        auth?: boolean;
+    }>>;
+    permissions?: Record<string, APIPermission[] | APIPermission>;
+    auth?: boolean;
+    docs?: Partial<{
+        description: string;
+        response: string;
+        errors: Array<typeof EError>;
+        tags: string[];
+    }>;
+};
+export type CoreAPIChannels = CoreAPIChannel<any, string>[];
+export interface PikkuChannel<UserSession, OpeningData, Out> {
+    channelId: string;
+    userSession?: UserSession;
+    setUserSession: (userSession: UserSession) => Promise<void> | void;
+    openingData: OpeningData;
+    send: (data: Out, isBinary?: boolean) => Promise<void> | void;
+    close: () => Promise<void> | void;
+    state: 'initial' | 'open' | 'closed';
+}
+export interface PikkuChannelHandler<UserSession extends CoreUserSession = CoreUserSession, OpeningData = unknown, Out = unknown> {
+    setUserSession(session: UserSession): Promise<void> | void;
+    send(message: Out, isBinary?: boolean): Promise<void> | void;
+    getChannel(): PikkuChannel<UserSession, OpeningData, Out>;
+}
+export type PikkuChannelHandlerFactory<OpeningData = unknown, UserSession extends CoreUserSession = CoreUserSession, Out = unknown> = (channelId: string, channelName: string, openingData: OpeningData, userSession: UserSession | undefined) => PikkuChannelHandler<UserSession, OpeningData, Out>;
+/**
+ * Enfore access to a channel.
+ * @param route - The channel to verify access for.
+ * @param session - The user session.
+ * @returns A promise that resolves if access is granted.
+ */
+export type enforceChannelAccess = (channel: CoreAPIChannel<unknown, any>, session?: CoreUserSession) => Promise<void> | void;

package/dist/channel/channel.types.js

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