@pikku/core 0.7.6 → 0.7.8

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## 0.7.0
 
+## 0.7.8
+
+### Patch Changes
+
+- 8b4f52e: fix: nextjs compatability with 0.7
+- 8b4f52e: refactor: moving schemas in channels to functions
+- 1d70184: feat: adding multiple bootstrap files for different transports
+
+## 0.7.7
+
+### Patch Changes
+
+- 6af8a19: fix: always write functions meta data
+
 ## 0.7.6
 
 ### Patch Changes

package/dist/channel/channel-runner.js

@@ -16,14 +16,14 @@ export const addChannel = (channel) => {
     }
     pikkuState('channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
-    if (channel.onConnect && channelMeta.connectPikkuFuncName) {
-        addFunction(channelMeta.connectPikkuFuncName, {
+    if (channel.onConnect && channelMeta.connect) {
+        addFunction(channelMeta.connect.pikkuFuncName, {
             func: channel.onConnect,
         });
     }
     // Register onDisconnect function if provided
-    if (channel.onDisconnect && channelMeta.disconnectPikkuFuncName) {
-        addFunction(channelMeta.disconnectPikkuFuncName, {
+    if (channel.onDisconnect && channelMeta.disconnect) {
+        addFunction(channelMeta.disconnect.pikkuFuncName, {
             func: channel.onDisconnect,
         });
     }

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

@@ -18,8 +18,6 @@ export type RunChannelParams<ChannelData> = {
 };
 export interface ChannelMessageMeta {
     pikkuFuncName: string;
-    inputs: string[] | null;
-    outputs: string[] | null;
     docs?: APIDocs;
 }
 export interface ChannelMeta {
@@ -29,10 +27,8 @@ export interface ChannelMeta {
     query?: string[];
     input: string | null;
     inputTypes?: HTTPFunctionMetaInputTypes;
-    connect: boolean;
-    connectPikkuFuncName: string | null;
-    disconnect: boolean;
-    disconnectPikkuFuncName: string | null;
+    connect: ChannelMessageMeta | null;
+    disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
     messageRoutes: Record<string, Record<string, ChannelMessageMeta>>;
     docs?: APIDocs;

package/dist/channel/local/local-channel-runner.js

@@ -43,13 +43,13 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                 userSession: userSession,
             });
             channelHandler.registerOnOpen(() => {
-                if (channelConfig.onConnect && meta.connectPikkuFuncName) {
-                    runPikkuFuncDirectly(meta.connectPikkuFuncName, { ...allServices, channel }, openingData);
+                if (channelConfig.onConnect && meta.connect) {
+                    runPikkuFuncDirectly(meta.connect.pikkuFuncName, { ...allServices, channel }, openingData);
                 }
             });
             channelHandler.registerOnClose(async () => {
-                if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
-                    runPikkuFuncDirectly(meta.disconnectPikkuFuncName, { ...allServices, channel }, openingData);
+                if (channelConfig.onDisconnect && meta.disconnect) {
+                    runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...allServices, channel }, openingData);
                 }
                 if (sessionServices) {
                     await closeSessionServices(singletonServices.logger, sessionServices);

package/dist/channel/serverless/serverless-channel-runner.js

@@ -59,8 +59,8 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
             if (createSessionServices) {
                 sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
             }
-            if (channelConfig.onConnect && meta.connectPikkuFuncName) {
-                await runPikkuFuncDirectly(meta.connectPikkuFuncName, { ...singletonServices, ...sessionServices, channel }, openingData);
+            if (channelConfig.onConnect && meta.connect) {
+                await runPikkuFuncDirectly(meta.connect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, openingData);
             }
             http?.response?.status(101);
         }
@@ -89,8 +89,8 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
     if (!sessionServices && params.createSessionServices) {
         sessionServices = await params.createSessionServices(singletonServices, {}, session);
     }
-    if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
-        await runPikkuFuncDirectly(meta.disconnectPikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
+    if (channelConfig.onDisconnect && meta.disconnect) {
+        await runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
     }
     await params.channelStore.removeChannels([channel.channelId]);
     if (sessionServices) {

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

@@ -87,4 +87,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, ignoreMiddleware, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;

package/dist/http/http-runner.js

@@ -21,14 +21,23 @@ import { rpcService } from '../rpc/rpc-runner.js';
  * @param {APIMiddleware[]} [middleware] - The middleware array to apply when a route pattern is specified.
  */
 export const addMiddleware = (routeOrMiddleware, middleware) => {
+    const middlewareStore = pikkuState('http', 'middleware');
     if (typeof routeOrMiddleware === 'string' && middleware) {
-        pikkuState('http', 'middleware').push({
-            route: routeOrMiddleware,
-            middleware,
-        });
+        const route = routeOrMiddleware;
+        // Remove existing entry for this route if it exists
+        const existingIndex = middlewareStore.findIndex((item) => item.route === route);
+        if (existingIndex !== -1) {
+            middlewareStore.splice(existingIndex, 1);
+        }
+        middlewareStore.push({ route, middleware });
     }
     else {
-        pikkuState('http', 'middleware').push({
+        // Handle global middleware
+        const existingIndex = middlewareStore.findIndex((item) => item.route === '*');
+        if (existingIndex !== -1) {
+            middlewareStore.splice(existingIndex, 1);
+        }
+        middlewareStore.push({
             route: '*',
             middleware: routeOrMiddleware,
         });
@@ -57,8 +66,6 @@ export const addHTTPRoute = (httpRoute) => {
     }
     addFunction(routeMeta.pikkuFuncName, {
         func: httpRoute.func,
-        auth: httpRoute.auth,
-        permissions: httpRoute.permissions,
     });
     const routes = pikkuState('http', 'routes');
     if (!routes.has(httpRoute.method)) {
@@ -217,7 +224,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
                 channel,
             });
         };
-        const result = await runPikkuFunc(meta.pikkuFuncName, {
+        result = await runPikkuFunc(meta.pikkuFuncName, {
             getAllServices,
             session,
             data,
@@ -234,7 +241,6 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         http?.response?.status(200);
         // TODO: Evaluate if the response stream should be explicitly ended.
         // http?.response?.end()
-        return result;
     };
     // Execute middleware, then run the main logic
     await runMiddleware({ ...singletonServices, userSession }, { http }, middleware, runMain);
@@ -295,7 +301,7 @@ export const pikkuFetch = async (request, params) => {
  * @param {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
+export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, ignoreMiddleware = false, }) => {
     const requestId = request.getHeader?.('x-request-id') ||
         generateRequestId?.() ||
         createWeakUID();
@@ -326,7 +332,12 @@ export const fetchData = async (request, response, { singletonServices, createSe
             createSessionServices,
             skipUserSession,
             requestId,
-        }, matchedRoute, http, { coerceDataFromSchema }));
+        }, ignoreMiddleware
+            ? {
+                ...matchedRoute,
+                middleware: [],
+            }
+            : matchedRoute, http, { coerceDataFromSchema }));
         return result;
     }
     catch (e) {

package/dist/http/http.types.d.ts

@@ -11,6 +11,7 @@ export type RunRouteOptions = Partial<{
     coerceDataFromSchema: boolean;
     bubbleErrors: boolean;
     generateRequestId: () => string;
+    ignoreMiddleware: boolean;
 }>;
 export type RunRouteParams = {
     singletonServices: CoreSingletonServices;

package/dist/middleware-runner.js

@@ -18,10 +18,10 @@
 export const runMiddleware = async (services, interaction, middlewares, main) => {
     const dispatch = async (index) => {
         if (middlewares && index < middlewares.length) {
-            await middlewares[index](services, interaction, () => dispatch(index + 1));
+            return await middlewares[index](services, interaction, () => dispatch(index + 1));
         }
         else if (main) {
-            return await main();
+            await main();
         }
     };
     await dispatch(0);

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

@@ -8,6 +8,12 @@ import { JWTService } from '../services/jwt-service.js';
 import { SecretService } from '../services/secret-service.js';
 import { PikkuChannel } from '../channel/channel.types.js';
 import { PikkuRPC } from '../rpc/rpc-types.js';
+export declare enum PikkuEventTypes {
+    http = "http",
+    scheduled = "scheduled",
+    channel = "channel",
+    rpc = "rpc"
+}
 export interface FunctionServicesMeta {
     optimized: boolean;
     services: string[];

package/dist/types/core.types.js

@@ -1 +1,7 @@
-export {};
+export var PikkuEventTypes;
+(function (PikkuEventTypes) {
+    PikkuEventTypes["http"] = "http";
+    PikkuEventTypes["scheduled"] = "scheduled";
+    PikkuEventTypes["channel"] = "channel";
+    PikkuEventTypes["rpc"] = "rpc";
+})(PikkuEventTypes || (PikkuEventTypes = {}));