@raclettejs/core 0.1.27 → 0.1.29

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

@@ -1,346 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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;