@raclettejs/core 0.1.31 → 0.1.32-nightly-1

package/services/backend/dist/core/pluginSystem/configGenerator/index.js

@@ -0,0 +1,346 @@
+import fs from "fs-extra";
+import path from "path";
+import eventMap from "@c/eventBus/eventBusEventMap";
+// ========================================
+// Registry Class (State Management)
+// ========================================
+class FrontendConfigRegistry {
+    static instance;
+    registrations = new Map();
+    trackedRoutes = [];
+    isGenerationPending = false;
+    fastifyInstance = null;
+    isTrackingSetup = false;
+    static getInstance = () => {
+        if (!FrontendConfigRegistry.instance) {
+            FrontendConfigRegistry.instance = new FrontendConfigRegistry();
+        }
+        return FrontendConfigRegistry.instance;
+    };
+    registerPlugin = (pluginData, options) => {
+        const registration = {
+            pluginName: pluginData.pluginName,
+            author: pluginData.author,
+            pluginKey: pluginData.key,
+            pluginPath: pluginData.absolutePath,
+            frontendPath: pluginData.frontendAbsolutePath,
+            routePrefix: pluginData.routePrefix,
+            entityMapping: options?.entityMapping || {},
+            customConfig: options?.customConfig,
+            registeredAt: Date.now(),
+        };
+        this.registrations.set(registration.pluginKey, registration);
+        this.isGenerationPending = true;
+    };
+    setFastifyInstance = (fastify) => {
+        this.fastifyInstance = fastify;
+        if (!this.isTrackingSetup) {
+            this.setupRouteTracking(fastify);
+            this.isTrackingSetup = true;
+        }
+        if (fastify.log) {
+            fastify.log.info("Fastify instance registered for frontend generation with route tracking");
+        }
+    };
+    setupRouteTracking = (fastify) => {
+        if (fastify.log) {
+            fastify.log.info("Setting up route tracking for frontend generation");
+        }
+        fastify.addHook("onRoute", (routeOptions) => {
+            if (routeOptions.url &&
+                routeOptions.url !== "" &&
+                routeOptions.url !== "/*" &&
+                !Array.isArray(routeOptions.method) &&
+                routeOptions.method.toUpperCase() !== "HEAD") {
+                const trackedRoute = {
+                    method: Array.isArray(routeOptions.method)
+                        ? routeOptions.method[0]
+                        : routeOptions.method,
+                    url: routeOptions.url,
+                    routePath: routeOptions.url,
+                    config: routeOptions.config,
+                    schema: routeOptions.schema,
+                    handler: routeOptions.handler,
+                    routePrefix: routeOptions.prefix,
+                };
+                this.trackedRoutes.push(trackedRoute);
+            }
+        });
+        fastify.addHook("onReady", async () => {
+            if (fastify.log) {
+                fastify.log.debug(`Route tracking complete. Tracked ${this.trackedRoutes.length} routes`);
+            }
+        });
+    };
+    // Getters
+    isReadyForGeneration = () => this.fastifyInstance !== null &&
+        this.isGenerationPending &&
+        this.registrations.size > 0;
+    getRegistrations = () => Array.from(this.registrations.values());
+    getTrackedRoutes = () => this.trackedRoutes;
+    getFastifyInstance = () => this.fastifyInstance;
+    // State management
+    markGenerationCompleted = () => {
+        this.isGenerationPending = false;
+    };
+    reset = () => {
+        this.registrations.clear();
+        this.trackedRoutes = [];
+        this.fastifyInstance = null;
+        this.isGenerationPending = false;
+        this.isTrackingSetup = false;
+    };
+}
+// ========================================
+// Plugin Registration Functions (Called by Plugins)
+// ========================================
+export const registerPluginForFrontendGeneration = (pluginOptions, options) => {
+    const registry = FrontendConfigRegistry.getInstance();
+    registry.registerPlugin(pluginOptions, options);
+};
+export const setFastifyInstanceForGeneration = (fastify) => {
+    const registry = FrontendConfigRegistry.getInstance();
+    registry.setFastifyInstance(fastify);
+};
+// ========================================
+// Generation Functions (Called by Core)
+// ========================================
+export const generateAllFrontendConfigs = async () => {
+    const registry = FrontendConfigRegistry.getInstance();
+    if (!registry.isReadyForGeneration()) {
+        const fastify = registry.getFastifyInstance();
+        if (fastify?.log) {
+            fastify.log.warn("Frontend generation not ready - missing Fastify instance or no plugins registered");
+        }
+        return;
+    }
+    const fastify = registry.getFastifyInstance();
+    const registrations = registry.getRegistrations();
+    if (fastify.log) {
+        fastify.log.info(`Generating frontend configurations for ${registrations.length} registered plugins`);
+    }
+    try {
+        for (const registration of registrations) {
+            await generatePluginFrontendConfig(fastify, registration);
+        }
+        registry.markGenerationCompleted();
+        if (fastify.log) {
+            fastify.log.info(`Frontend configurations generated successfully for ${registrations.length} plugins`);
+        }
+    }
+    catch (error) {
+        if (fastify.log) {
+            fastify.log.error("Error generating frontend configurations:", error);
+        }
+        throw error;
+    }
+};
+export const triggerGenerationIfReady = async () => {
+    const registry = FrontendConfigRegistry.getInstance();
+    if (registry.isReadyForGeneration()) {
+        await generateAllFrontendConfigs();
+    }
+};
+// ========================================
+// Internal Generation Logic
+// ========================================
+const generatePluginFrontendConfig = async (fastify, registration) => {
+    const registry = FrontendConfigRegistry.getInstance();
+    const allRoutes = registry.getTrackedRoutes();
+    const pluginRoutes = allRoutes.filter((route) => {
+        const routePrefix = registration.routePrefix || registration.pluginKey;
+        return (route.url.startsWith(`${routePrefix}`) || route.url === `${routePrefix}`);
+    });
+    if (pluginRoutes.length === 0) {
+        if (fastify.log) {
+            fastify.log.warn(`No routes found for plugin ${registration.pluginKey}`);
+        }
+        return;
+    }
+    if (fastify.log) {
+        fastify.log.info(`Processing ${pluginRoutes.length} routes for plugin ${registration.pluginKey}`);
+    }
+    const dataTypes = new Map();
+    for (const route of pluginRoutes) {
+        const routeInfo = parseRouteInfo(route, registration);
+        if (!routeInfo)
+            continue;
+        const { entityName, operationName } = routeInfo;
+        if (!dataTypes.has(entityName)) {
+            dataTypes.set(entityName, {
+                type: entityName,
+                operations: {},
+            });
+        }
+        const dataType = dataTypes.get(entityName);
+        const operationConfig = generateOperationConfig(routeInfo);
+        if (operationConfig) {
+            dataType.operations[operationName] = operationConfig;
+            if (fastify.log) {
+                fastify.log.debug(`Generated operation config: ${entityName}.${operationName} -> ${routeInfo.method} ${routeInfo.url}`);
+            }
+        }
+    }
+    await writePluginConfigFile(dataTypes, registration, fastify);
+};
+// ========================================
+// Route Parsing Utilities
+// ========================================
+const parseRouteInfo = (route, registration) => {
+    const method = route.method || "GET";
+    const url = route.url || route.routePath || "";
+    const routePrefix = registration.routePrefix || registration.pluginKey;
+    const prefixPattern = new RegExp(`^/?${routePrefix}/?`);
+    const routeAfterPrefix = url.replace(prefixPattern, "");
+    if (!routeAfterPrefix)
+        return null;
+    const segments = routeAfterPrefix
+        .split("/")
+        .filter((segment) => segment !== "");
+    if (segments.length === 0)
+        return null;
+    const routeKey = segments[0];
+    const entityName = registration.entityMapping?.[routeKey] || routeKey;
+    const operationSegments = segments.slice(1);
+    const pathParams = segments
+        .filter((segment) => segment.startsWith(":"))
+        .map((param) => param.substring(1));
+    const operationName = getOperationName(method, operationSegments);
+    return {
+        method,
+        url,
+        entityName,
+        operationName,
+        pathParams,
+        registration,
+        config: route.config || {},
+        schema: route.schema || {},
+    };
+};
+const getOperationName = (method, urlSegments) => {
+    const httpMethod = method.toLowerCase();
+    const baseMethod = getMethodMapping(httpMethod);
+    const nonParamSegments = urlSegments.filter((segment) => !segment.startsWith(":"));
+    if (nonParamSegments.length === 0) {
+        return baseMethod;
+    }
+    const operationParts = nonParamSegments
+        .map((segment) => segment
+        .split("-")
+        .map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1))
+        .join(""))
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+    return baseMethod + operationParts;
+};
+const getMethodMapping = (httpMethod) => {
+    const methodMapping = {
+        get: "get",
+        post: "create",
+        patch: "update",
+        put: "update",
+        delete: "delete",
+    };
+    return methodMapping[httpMethod] || httpMethod;
+};
+// ========================================
+// Operation Configuration Generation
+// ========================================
+const generateOperationConfig = (routeInfo) => {
+    const { method, url, pathParams, registration, config: routeConfig, } = routeInfo;
+    if (!registration)
+        return null;
+    const config = {
+        target: generateTargetFunction(url, pathParams),
+        method: method.toLowerCase(),
+    };
+    if (routeConfig?.type) {
+        config.storeActionType = routeConfig.type;
+    }
+    if (routeInfo.config.broadcastChannels?.length) {
+        config.channels = routeInfo.config.broadcastChannels.map((channelName) => {
+            const coreChannel = getCoreChannel(channelName);
+            const channel = coreChannel || registration.pluginKey + "--" + channelName;
+            return {
+                channel,
+                channelKey: channelName,
+                prefix: coreChannel ? "" : registration.pluginKey,
+            };
+        });
+    }
+    return config;
+};
+const getCoreChannel = (channelName) => {
+    if (Object.keys(eventMap).includes(channelName)) {
+        if (channelName.startsWith("broadcast")) {
+            const result = channelName.replace("broadcast", "");
+            return result.charAt(0).toLowerCase() + result.slice(1);
+        }
+        return channelName;
+    }
+    return undefined;
+};
+const generateTargetFunction = (url, pathParams) => {
+    if (pathParams.length > 0) {
+        let targetFunction = `(payload) => \`${url}\``;
+        for (const param of pathParams) {
+            const paramPattern = new RegExp(`:${param}`, "g");
+            targetFunction = targetFunction.replace(paramPattern, `\${payload.${param}}`);
+        }
+        return targetFunction;
+    }
+    return url;
+};
+// ========================================
+// File Generation Utilities
+// ========================================
+const writePluginConfigFile = async (dataTypes, registration, fastify) => {
+    if (dataTypes.size === 0) {
+        if (fastify.log) {
+            fastify.log.warn(`No data types generated for plugin ${registration.pluginKey}`);
+        }
+        return;
+    }
+    const configContent = generatePluginConfigFile(dataTypes, registration);
+    const outputPath = path.join(registration.frontendPath, "generated-config.ts");
+    try {
+        await fs.ensureDir(path.dirname(outputPath));
+        await fs.writeFile(outputPath, configContent);
+        if (fastify.log) {
+            fastify.log.info(`Generated config for plugin ${registration.pluginKey}: ${outputPath}`);
+        }
+    }
+    catch (error) {
+        if (fastify.log) {
+            fastify.log.error(`Error writing config for plugin ${registration.pluginKey}:`, error);
+        }
+    }
+};
+const generatePluginConfigFile = (dataTypes, registration) => {
+    const dataObject = {};
+    for (const [entityName, dataType] of dataTypes.entries()) {
+        const routeKey = Object.keys(registration.entityMapping || {}).find((key) => registration.entityMapping[key] === entityName) || entityName;
+        dataObject[routeKey] = {
+            type: dataType.type,
+            operations: dataType.operations,
+        };
+    }
+    return `// Auto-generated frontend configuration for plugin: ${registration.pluginKey}
+// This file is generated from backend routes - do not edit manually
+// Entity mapping: ${JSON.stringify(registration.entityMapping || {})}
+
+export default {
+  pluginName: "${registration.pluginName}",
+  author: "${registration.author}",
+  pluginKey: "${registration.pluginKey}",
+  routePrefix: "${registration.routePrefix}",
+  pluginPath: "${registration.pluginPath}",
+  data: ${JSON.stringify(dataObject, null, 2)
+        .replace(/"(\([^)]+\) => [^"]+)"/g, "$1")
+        .replace(/"([a-zA-Z_$][a-zA-Z0-9_$]*)"\s*:/g, "$1:")
+        .split("\n")
+        .map((line, index) => (index === 0 ? line : "  " + line))
+        .join("\n")}
+}
+`;
+};

package/services/backend/dist/core/sockets/index.js

@@ -0,0 +1,95 @@
+import fastifyPlugin from "fastify-plugin";
+import { Server } from "socket.io";
+import configService from "@c/config/configService";
+import { getAllowedOrigins } from "@/helpers";
+import { validate } from "uuid";
+import { validateWorkSession } from "./socketManager";
+export default fastifyPlugin((fastify, opts, done) => {
+    // Get socket configuration using the wrfastifyer
+    const { options: socketOptions, security } = configService.getSocketConfig();
+    // Configure default options with overrides from config
+    const defaults = {
+        cors: { origin: getAllowedOrigins(), credentials: true },
+        connectionTimeout: socketOptions?.connectionTimeout || 3000,
+        pingInterval: socketOptions?.pingInterval || 1500,
+        pingTimeout: socketOptions?.pingTimeout || 1000,
+    };
+    /*
+     * create and configure the websocket server
+     */
+    const socketServer = new Server(fastify.server, { ...defaults, ...opts });
+    // Configure authentication based on security settings
+    if (configService.isAuthRequired() ?? true) {
+        // Default to JWT authentication
+        if (security?.tokenValidation === "jwt") {
+            if (!process.env.SERVER_TOKEN_SECRET) {
+                fastify.log.warn("SERVER_TOKEN_SECRET not set, socket authentication may fail");
+            }
+            // Dual authentication middleware: JWT or workSession
+            socketServer.use(async (socket, next) => {
+                fastify.log.debug(`[Socket Auth] Starting authentication for socket: ${socket.id}`);
+                try {
+                    const token = socket.handshake.auth?.token ??
+                        socket.handshake.headers.authorization?.split(" ")[1];
+                    // Try JWT authentication first
+                    if (token) {
+                        try {
+                            // Verify token using fastify-jwt
+                            const decoded = fastify.jwt.verify(token);
+                            // Store decoded token on socket
+                            socket.decoded_token = decoded;
+                            socket.isWorkSession = false;
+                            return next();
+                        }
+                        catch (jwtError) {
+                            // JWT verification failed, continue to workSession check
+                            fastify.log.debug(`[Socket Auth] JWT verification failed for ${socket.id}: ${jwtError.message}, checking workSession`);
+                        }
+                    }
+                    // Check for workSession authentication (same validation as socketManager.validateWorkSession)
+                    const sessionId = socket.handshake.auth?.sessionId;
+                    if (sessionId) {
+                        fastify.log.info(`[Socket Auth] Attempting workSession authentication for socket: ${socket.id}, sessionId: ${sessionId}`);
+                        if (!validate(sessionId)) {
+                            fastify.log.warn(`[Socket Auth] Invalid sessionId format for socket: ${socket.id}`);
+                            return next(new Error("Authentication failed: Invalid session ID format"));
+                        }
+                        try {
+                            const workSession = await validateWorkSession(fastify, sessionId);
+                            socket.workSession = workSession;
+                            socket.isWorkSession = true;
+                            return next();
+                        }
+                        catch (err) {
+                            fastify.log.warn(`[Socket Auth] WorkSession validation failed for socket: ${socket.id}, error: ${err.message}`);
+                            return next(new Error("Invalid or expired session"));
+                        }
+                    }
+                    // No valid authentication method found
+                    fastify.log.warn(`[Socket Auth] Socket connection without valid authentication: ${socket.id}, hasToken: ${!!token}, hasSessionId: ${!!sessionId}`);
+                    return next(new Error("Authentication failed: No valid token or session provided"));
+                }
+                catch (error) {
+                    fastify.log.error(`[Socket Auth] Socket authentication error for ${socket.id}: ${error.message}, stack: ${error.stack}`);
+                    next(new Error("Authentication failed: Invalid token"));
+                }
+            });
+        }
+        else if (security?.customValidator) {
+            // Custom validator would be implemented here
+            fastify.log.warn("Custom socket validator specified but not implemented - yet ;)");
+        }
+    }
+    else {
+        fastify.log.warn("Socket authentication is disabled - this is not recommended for production");
+    }
+    // make the websocket server available in the whole fastify
+    fastify.decorate("wss", socketServer);
+    // close the websocket server when the http server is closing
+    fastify.addHook("onClose", (fastify, done) => {
+        fastify.log.warn("App is closing, socket connection is also closed");
+        fastify.wss.close();
+        done();
+    });
+    done();
+});

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/account/events/index.js

@@ -0,0 +1,31 @@
+const registerEvents = (fastify) => {
+    /**
+     * Account created
+     */
+    const created = (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.eventbus.emit("broadcastAccountCreated", payload);
+        fastify.log.info(`[eventbus] account broadcast created ${payload.appSessionId}`);
+    };
+    /**
+     * Account updated
+     */
+    const updated = (payload) => {
+        fastify.eventbus.emit("broadcastDataUpdated", payload);
+        fastify.log.info(`[eventbus] account broadcast updated ${payload.appSessionId}`);
+    };
+    /**
+     * Account deleted
+     */
+    const deleted = (payload) => {
+        fastify.eventbus.emit("broadcastAccountDeleted", payload);
+        fastify.log.info(`[eventbus] account broadcast deleted ${payload.appSessionId}`);
+    };
+    /**
+     * Register event handlers
+     */
+    fastify.eventbus.on("coreAccountCreated", created);
+    fastify.eventbus.on("coreAccountUpdated", updated);
+    fastify.eventbus.on("coreAccountDeleted", deleted);
+};
+export default registerEvents;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/account/index.js

@@ -0,0 +1,48 @@
+import registerRoutes from "./routes";
+import { createModels } from "./account.model";
+import { createAccountService } from "./account.service";
+import { registerPayload } from "./helpers/payload";
+import { registerCrud } from "./helpers/crud";
+import { registerSchemas } from "./account.schema";
+const registerAccount = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const accountModel = createModels(fastify);
+    // create and pass in the model to your service
+    const accountService = createAccountService(accountModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.accountService = accountService;
+    /*
+     * ---------------------------------------------------------------------
+     * REGISTER ALL YOUR ROUTES
+     * ---------------------------------------------------------------------
+     */
+    try {
+        await fastify.register((instance) => registerRoutes(instance));
+    }
+    catch (error) {
+        fastify.log.error(`Failed to register routes.`, error);
+        throw error; // Let the application handle the error
+    }
+    registerPayload(fastify);
+    registerCrud(fastify);
+    registerSchemas(fastify);
+    return {
+        account: {
+            operations: {
+                readAll: accountService._readAccounts.bind(accountService),
+                read: accountService._readAccount.bind(accountService),
+                create: accountService._createAccount.bind(accountService),
+                update: accountService._updateAccount.bind(accountService),
+            },
+            keywords: ["account"],
+            metadata: {
+                description: "An account handles users and projects",
+            },
+        },
+    };
+};
+export default registerAccount;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/account/routes/index.js

@@ -0,0 +1,15 @@
+import get from "./route.account.get";
+import getAll from "./route.account.getAll";
+import hardDelete from "./route.account.hardDelete";
+import patch from "./route.account.patch";
+import post from "./route.account.post";
+import remove from "./route.account.remove";
+const registerRoutes = async (fastify) => {
+    await fastify.get("/account/all", getAll(fastify));
+    await fastify.get("/account/:_id", get(fastify));
+    await fastify.patch("/account/:_id", patch(fastify));
+    await fastify.post("/account", post(fastify));
+    await fastify.delete("/account/:_id", remove(fastify));
+    await fastify.delete("/account/:_id/hard", hardDelete(fastify));
+};
+export default registerRoutes;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/composition/events/index.js

@@ -0,0 +1,22 @@
+export const registerEvents = (fastify) => {
+    /*
+     * composition created and created
+     */
+    const created = async (payload) => {
+        fastify.eventbus.emit("broadcastCompositionCreated", payload);
+        fastify.log.info(`[eventbus] composition broadcast created ${payload.body.items}`);
+    };
+    /*
+     * composition deleted
+     */
+    const deleted = async (payload) => {
+        fastify.eventbus.emit("broadcastCompositionDeleted", payload);
+        fastify.log.info(`[eventbus] composition broadcast deleted ${payload.body.items}`);
+    };
+    /**
+     * Register those functions for eventbus events
+     */
+    fastify.eventbus.on("coreCompositionCreated", created);
+    fastify.eventbus.on("coreCompositionDeleted", deleted);
+};
+export default registerEvents;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/composition/index.js

@@ -0,0 +1,51 @@
+import registerRoutes from "./routes";
+import { createModels } from "./composition.model";
+import { createCompositionService } from "./composition.service";
+import { registerPayload } from "./helpers/payload";
+import { registerCrud } from "./helpers/crud";
+import { compositionSchema, registerSchemas } from "./composition.schema";
+const registerComposition = async (fastify) => {
+    /*
+     * ---------------------------------------------------------------------
+     * CREATE AND REGISTER ALL YOUR MODELS
+     * ---------------------------------------------------------------------
+     */
+    const compositionModel = createModels(fastify);
+    // create and pass in the model to your service
+    const compositionService = await createCompositionService(compositionModel);
+    // decorate the service to the instance, so we can easily call it everywhere
+    fastify.custom.compositionService = compositionService;
+    /*
+     * ---------------------------------------------------------------------
+     * REGISTER ALL YOUR ROUTES
+     * ---------------------------------------------------------------------
+     */
+    try {
+        await fastify.register((instance) => registerRoutes(instance));
+    }
+    catch (error) {
+        fastify.log.error(`Failed to register routes.`, error);
+        throw error; // Let the application handle the error
+    }
+    registerSchemas(fastify);
+    registerPayload(fastify);
+    registerCrud(fastify);
+    return {
+        composition: {
+            schema: compositionSchema,
+            operations: {
+                readAll: compositionService._readAllCompositions.bind(compositionService),
+                read: compositionService._readComposition.bind(compositionService),
+                create: compositionService._createComposition.bind(compositionService),
+                update: compositionService._updateComposition.bind(compositionService),
+                delete: compositionService._removeComposition.bind(compositionService),
+            },
+            keywords: ["composition", "content", "layout", "structure"],
+            metadata: {
+                description: "Core composition management",
+                version: "1.0.0",
+            },
+        },
+    };
+};
+export default registerComposition;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/composition/routes/index.js

@@ -0,0 +1,19 @@
+import get from "./route.composition.get";
+import getAll from "./route.composition.getAll";
+import hardDelete from "./route.composition.hardDelete";
+import patch from "./route.composition.patch";
+import post from "./route.composition.post";
+import postBulk from "./route.composition.post.bulk";
+import remove from "./route.composition.remove";
+import restore from "./route.composition.restore";
+const registerRoutes = async (fastify) => {
+    await fastify.get("/composition/all", getAll(fastify));
+    await fastify.get("/composition/:_id", get(fastify));
+    await fastify.patch("/composition/:_id", patch(fastify));
+    await fastify.patch("/composition/:_id/restore", restore(fastify));
+    await fastify.post("/composition", post(fastify));
+    await fastify.post("/composition/bulk", postBulk(fastify));
+    await fastify.delete("/composition/:_id", remove(fastify));
+    await fastify.delete("/composition/:_id/hard", hardDelete(fastify));
+};
+export default registerRoutes;

package/services/backend/dist/corePlugins/raclette__core/backend/datatypes/interactionLink/events/index.js

@@ -0,0 +1,22 @@
+export const registerEvents = (fastify) => {
+    /*
+     * interactionLink created and created
+     */
+    const created = async (payload) => {
+        fastify.eventbus.emit("broadcastInteractionLinkCreated", payload);
+        fastify.log.info(`[eventbus] interactionLink broadcast created ${payload.body.items}`);
+    };
+    /*
+     * interactionLink deleted
+     */
+    const deleted = async (payload) => {
+        fastify.eventbus.emit("broadcastInteractionLinkDeleted", payload);
+        fastify.log.info(`[eventbus] interactionLink broadcast deleted ${payload.body.items}`);
+    };
+    /**
+     * Register those functions for eventbus events
+     */
+    fastify.eventbus.on("coreInteractionLinkCreated", created);
+    fastify.eventbus.on("coreInteractionLinkDeleted", deleted);
+};
+export default registerEvents;