@raclettejs/core 0.1.0 → 0.1.1

package/services/backend/dist/src/core/pluginSystem/pluginLoader.js

@@ -1,317 +0,0 @@
-import { PluginType } from "../../types/index.js";
-import fs from "fs";
-import path from "path";
-import { createPluginFastifyInstance } from "./pluginFastifyInstance.js";
-import configService from "../config/configService.js";
-import { slugify } from "../../shared/helper/pluginHelper.js";
-import { fileURLToPath } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(path.join(__filename, ".."));
-const MAX_SCAN_DEPTH = 3;
-// Error handling flags
-const PLUGIN_ERROR_FLAGS = {
-    CORE: 1,
-    NPM: 2,
-    APP: 4,
-};
-const DEFAULT_ERROR_FLAGS = PLUGIN_ERROR_FLAGS.CORE | PLUGIN_ERROR_FLAGS.APP; // 5
-/**
- * Register plugins in three phases: core, npm, then app plugins
- */
-export const registerPlugins = async (fastify, errorFlags = DEFAULT_ERROR_FLAGS) => {
-    // Constants
-    const CORE_PLUGIN_PATHS = [path.join(__dirname, "..", "corePlugins")];
-    const APP_PLUGIN_PATHS = [
-        path.join(__dirname, "..", "raclette-plugins"),
-        ...configService.getAdditonalPluginPaths(),
-    ];
-    const allPlugins = [];
-    // Phase 1: Core plugins (always required, crash on error (default, PLUGIN_ERROR_FLAGS))
-    await collectCorePlugins(fastify, CORE_PLUGIN_PATHS, allPlugins, errorFlags);
-    // Phase 2: NPM plugins (standalone, continue on error unless flag set)
-    await collectNpmPlugins(fastify, allPlugins, errorFlags);
-    // Phase 3: App/User plugins (might depend on core/npm, crash on error (default, PLUGIN_ERROR_FLAGS))
-    await collectAppPlugins(fastify, APP_PLUGIN_PATHS, allPlugins, errorFlags);
-    // Register all collected plugins
-    await registerCollectedPlugins(fastify, allPlugins, errorFlags);
-};
-/**
- * Collect core plugins from hardcoded paths
- */
-const collectCorePlugins = async (fastify, paths, plugins, errorFlags) => {
-    fastify.log.info("Collecting core plugins...");
-    for (const pluginPath of paths) {
-        await collectLocalPluginsFromPath(fastify, plugins, pluginPath, PluginType.CORE, errorFlags);
-    }
-};
-/**
- * Collect app/user plugins from hardcoded paths
- */
-const collectAppPlugins = async (fastify, paths, plugins, errorFlags) => {
-    fastify.log.info("Collecting app plugins...");
-    for (const pluginPath of paths) {
-        await collectLocalPluginsFromPath(fastify, plugins, pluginPath, PluginType.APP, errorFlags);
-    }
-};
-/**
- * Collect local plugins from a specific path
- */
-const collectLocalPluginsFromPath = async (fastify, plugins, basePath, pluginType, errorFlags) => {
-    if (!fs.existsSync(basePath)) {
-        fastify.log.debug(`Plugin path does not exist: ${basePath}`);
-        return;
-    }
-    const pluginConfigs = await findPluginConfigs(basePath, 0);
-    fastify.log.debug(`Found ${pluginConfigs.length} ${pluginType} plugin config(s) in ${basePath}`);
-    for (const configPath of pluginConfigs) {
-        try {
-            const pluginPath = path.dirname(configPath);
-            const metadata = await loadPluginMetadata(configPath);
-            if (!validatePluginMetadata(metadata)) {
-                const error = `Invalid plugin metadata in ${configPath}: Missing required fields`;
-                handlePluginError(fastify, error, pluginType, errorFlags);
-                continue;
-            }
-            // Get server path from metadata or use default
-            const serverRelativePath = metadata.serverDir || "server";
-            const serverPath = path.join(pluginPath, serverRelativePath);
-            if (!fs.existsSync(serverPath) ||
-                !fs.statSync(serverPath).isDirectory() ||
-                !findPluginModule(serverPath)) {
-                if (metadata.serverDir) {
-                    const error = `Server directory not found for plugin: ${configPath}`;
-                    // we only cancel when the dir was explicitly set
-                    handlePluginError(fastify, error, pluginType, errorFlags);
-                }
-                continue;
-            }
-            // Find the main module file
-            const modulePath = findPluginModule(serverPath);
-            if (!modulePath) {
-                const error = `No plugin index file found in ${serverPath}`;
-                handlePluginError(fastify, error, pluginType, errorFlags);
-                continue;
-            }
-            const author = slugify(metadata.author);
-            const pluginName = slugify(metadata.name);
-            plugins.push({
-                author,
-                pluginName,
-                modulePath,
-                pluginPath,
-                type: pluginType,
-                metadata,
-            });
-            fastify.log.debug(`Located ${pluginType} plugin: ${author}/${pluginName}`);
-        }
-        catch (error) {
-            const errorString = `Error processing ${pluginType} plugin ${configPath}: ${error.message}`;
-            handlePluginError(fastify, errorString, pluginType, errorFlags);
-        }
-    }
-};
-/**
- * Collect npm-installable plugins
- */
-const collectNpmPlugins = async (fastify, plugins, errorFlags) => {
-    const installedPlugins = configService.getPlugins();
-    if (!installedPlugins.length) {
-        return;
-    }
-    fastify.log.info(`Collecting ${installedPlugins.length} npm plugin(s)...`);
-    for (const pluginPackage of installedPlugins) {
-        try {
-            // Extract the plugin name without scope
-            const pluginNameWithoutScope = pluginPackage.replace(/^@[^/]+\//, "");
-            // Try to find the plugin in several locations (keep fallback logic)
-            const possibleLocations = [
-                // Regular node_modules location
-                path.resolve(process.cwd(), "node_modules", pluginPackage),
-                // Development convention (mounted directory)
-                path.resolve("/app", pluginNameWithoutScope),
-            ];
-            let pluginPath = null;
-            let pluginMetadata = null;
-            // Find the plugin path and load its metadata
-            for (const location of possibleLocations) {
-                try {
-                    fastify.log.debug(`Checking for npm plugin at: ${location}`);
-                    // Check if this path exists and is a directory
-                    if (fs.existsSync(location) && fs.statSync(location).isDirectory()) {
-                        // Try to import the plugin config
-                        const pluginConfigPath = path.join(location, "raclette.plugin.js");
-                        if (fs.existsSync(pluginConfigPath)) {
-                            pluginMetadata = await loadPluginMetadata(pluginConfigPath);
-                            if (validatePluginMetadata(pluginMetadata)) {
-                                pluginPath = location;
-                                fastify.log.debug(`Found valid npm plugin at ${location}`);
-                                break;
-                            }
-                            else {
-                                fastify.log.debug(`Invalid plugin metadata at ${location}: Missing required fields`);
-                            }
-                        }
-                        else {
-                            fastify.log.debug(`Plugin config not found at ${pluginConfigPath}`);
-                        }
-                    }
-                }
-                catch (error) {
-                    fastify.log.debug(`Error checking npm plugin location ${location}: ${error.message}`);
-                }
-            }
-            if (!pluginPath || !pluginMetadata) {
-                const error = `Could not find valid npm plugin ${pluginPackage}`;
-                handlePluginError(fastify, error, PluginType.NPM, errorFlags);
-                continue;
-            }
-            // Get server path from metadata or use default
-            const serverRelativePath = pluginMetadata.serverDir || "src/server";
-            const serverPath = path.join(pluginPath, serverRelativePath);
-            if (!fs.existsSync(serverPath) ||
-                !fs.statSync(serverPath).isDirectory()) {
-                const error = `Server directory not found for npm plugin: ${pluginPackage}`;
-                handlePluginError(fastify, error, PluginType.NPM, errorFlags);
-                continue;
-            }
-            // Find the main module file
-            const modulePath = findPluginModule(serverPath);
-            if (!modulePath) {
-                const error = `No plugin module found in ${serverPath}`;
-                handlePluginError(fastify, error, PluginType.NPM, errorFlags);
-                continue;
-            }
-            const author = slugify(pluginMetadata.author);
-            const pluginName = slugify(pluginMetadata.name);
-            plugins.push({
-                author,
-                pluginName,
-                modulePath,
-                pluginPath,
-                type: PluginType.NPM,
-                metadata: pluginMetadata,
-            });
-            fastify.log.debug(`Located npm plugin: ${author}/${pluginName}`);
-        }
-        catch (error) {
-            const errorString = `Error processing npm plugin ${pluginPackage}: ${error.message}`;
-            handlePluginError(fastify, errorString, PluginType.NPM, errorFlags);
-        }
-    }
-};
-/**
- * Recursively find raclette.plugin.js files
- */
-const findPluginConfigs = async (dir, currentDepth) => {
-    const configs = [];
-    if (currentDepth >= MAX_SCAN_DEPTH) {
-        return configs;
-    }
-    try {
-        const items = fs.readdirSync(dir);
-        // First check if current directory has a plugin config
-        const configPath = path.join(dir, "raclette.plugin.js");
-        if (fs.existsSync(configPath)) {
-            configs.push(configPath);
-            return configs; // If we found a config here, don't scan subdirectories
-        }
-        // If no config found, scan subdirectories
-        for (const item of items) {
-            const itemPath = path.join(dir, item);
-            if (fs.statSync(itemPath).isDirectory()) {
-                const subConfigs = await findPluginConfigs(itemPath, currentDepth + 1);
-                configs.push(...subConfigs);
-            }
-        }
-    }
-    catch (error) {
-        // Ignore permission errors and continue
-    }
-    return configs;
-};
-/**
- * Load and validate plugin metadata from raclette.plugin.js
- */
-const loadPluginMetadata = async (configPath) => {
-    const importedConfig = await import(/* @vite-ignore */ `file://${configPath}`);
-    return importedConfig.default || importedConfig;
-};
-/**
- * Validate that plugin metadata has required fields
- */
-const validatePluginMetadata = (metadata) => {
-    return (metadata &&
-        typeof metadata.name === "string" &&
-        typeof metadata.author === "string");
-};
-/**
- * Handle plugin errors based on error flags
- */
-const handlePluginError = (fastify, error, pluginType, errorFlags) => {
-    const shouldCrash = (errorFlags &
-        PLUGIN_ERROR_FLAGS[pluginType.toUpperCase()]) !==
-        0;
-    if (shouldCrash) {
-        fastify.log.error(error);
-        throw new Error(error);
-    }
-    else {
-        fastify.log.warn(error);
-    }
-};
-/**
- * Register all collected plugins using a common registration process
- */
-const registerCollectedPlugins = async (fastify, plugins, errorFlags) => {
-    if (plugins.length === 0) {
-        fastify.log.info("No plugins to register");
-        return;
-    }
-    fastify.log.info(`Registering ${plugins.length} plugin(s)`);
-    for (const plugin of plugins) {
-        const { author, pluginName, modulePath } = plugin;
-        const key = `${author}__${pluginName}`;
-        try {
-            // Construct the prefixed collection name and route prefix
-            const collectionPrefix = `${author}__${pluginName}-`;
-            const routePrefix = `/${author}__${pluginName}`;
-            const pluginOptions = {
-                key,
-                author,
-                pluginName,
-                type: plugin.type,
-                collectionPrefix,
-                routePrefix,
-                absolutePath: plugin.pluginPath,
-            };
-            // Dynamically import the plugin module
-            const pluginModule = await import(/* @vite-ignore */ modulePath);
-            const pluginFunction = pluginModule.default;
-            if (!pluginModule || !pluginFunction) {
-                const error = `No plugin bootstrapping function found in ${modulePath}`;
-                handlePluginError(fastify, error, plugin.type, errorFlags);
-                continue;
-            }
-            // Create a restricted fastify instance for the plugins to use
-            const customFastify = createPluginFastifyInstance(fastify, pluginOptions);
-            // Register the plugin, passing the restricted instance and options
-            await fastify.register(() => {
-                return pluginFunction(customFastify, pluginOptions);
-            });
-            fastify.log.info(`[PluginRegistration] ${key}: successfully registered`);
-        }
-        catch (error) {
-            const errorMsg = `[PluginRegistration] ${key}: Error during registration: ${error.message}`;
-            handlePluginError(fastify, errorMsg, plugin.type, errorFlags);
-        }
-    }
-};
-/**
- * Helper function to find the plugin module file
- */
-const findPluginModule = (serverPath) => {
-    const extensions = ["ts", "js"];
-    return extensions
-        .map((ext) => path.join(serverPath, `index.${ext}`))
-        .find((fullPath) => fs.existsSync(fullPath));
-};

package/services/backend/dist/src/core/pluginSystem/pluginTypes.d.ts

@@ -1,51 +0,0 @@
-import type { FastifyInstance, preHandlerHookHandler } from "fastify";
-import type { Server as SocketServer } from "socket.io";
-import type { Schema, Model, Document } from "mongoose";
-import type { Listener } from "../events/eventEmitter.js";
-import type { PluginSchemaDefinition, HttpService, IntervalTaskOptions, CrudHandlers, ClientPayloadRequestData, ClientPayload, CacheService } from "../../types/index.js";
-import type { EventEmitter } from "stream";
-import type { PluginContract } from "../contracting/contractTypes.js";
-export declare enum PluginType {
-    CORE = "core",
-    NPM = "npm",
-    APP = "app"
-}
-export type PluginOptions = {
-    key: string;
-    pluginName: string;
-    author: string;
-    absolutePath: string;
-    type: PluginType;
-    collectionPrefix: string;
-    routePrefix: string;
-    socketIO?: {
-        registerEvents?: (io: SocketServer, eventbus: any) => void;
-        createRooms?: (io: SocketServer) => void;
-    };
-};
-export type PluginFastifyInstance = {
-    register: (routes: (instance: PluginFastifyInstance) => Promise<void> | void, opts?: PluginOptions) => FastifyInstance;
-    get: FastifyInstance["get"];
-    post: FastifyInstance["post"];
-    put: FastifyInstance["put"];
-    patch: FastifyInstance["patch"];
-    delete: FastifyInstance["delete"];
-    authenticate: preHandlerHookHandler;
-    log: ReturnType<FastifyInstance["log"]["child"]>;
-    createModel: <T extends Document>(modelName: string, schema: Schema) => Model<T>;
-    registerSchema: (schemaDefinition: PluginSchemaDefinition) => void;
-    registerCrudHandlers: <T>(name: string, handlers: CrudHandlers<T>) => void;
-    registerPayloadHandler: <T extends object>(name: string, registerData: any) => void;
-    createPayload: <T extends object>(name: string, item: T, requestData: ClientPayloadRequestData) => Promise<ClientPayload<T>>;
-    registerSocket: (eventName: string, handler: Listener) => void;
-    emit: (eventName: string, data: unknown) => void;
-    http: HttpService;
-    createIntervalTask: (name: string, handler: () => Promise<void>, options: IntervalTaskOptions) => void;
-    cancelTask: (name: string) => void;
-    cache: CacheService;
-    eventbus: EventEmitter;
-    registerPluginContract: (contractData: PluginContract) => void;
-    registerForFrontendGeneration: (options: any) => any;
-    fastify: FastifyInstance;
-    custom: Record<any, any>;
-};

package/services/backend/dist/src/core/pluginSystem/pluginTypes.js

@@ -1,6 +0,0 @@
-export var PluginType;
-(function (PluginType) {
-    PluginType["CORE"] = "core";
-    PluginType["NPM"] = "npm";
-    PluginType["APP"] = "app";
-})(PluginType || (PluginType = {}));

package/services/backend/dist/src/core/sockets/createSystemEventHandlers.d.ts

@@ -1,20 +0,0 @@
-import type { Project, Tag, Composition, InteractionLink } from "../../shared/types/index.js";
-import type { ClientPayload } from "../../types/index.js";
-import type { FastifyInstance } from "fastify";
-export declare const createSystemEventHandlers: (fastify: FastifyInstance) => {
-    broadcastDataUpdatedHandler: (payload: ClientPayload<unknown>) => void;
-    broadcastDataCreatedHandler: (payload: ClientPayload<unknown>) => void;
-    broadcastDataDeletedHandler: (payload: ClientPayload<unknown>) => void;
-    broadcastCompositionCreated: (payload: ClientPayload<Composition>) => void;
-    broadcastCompositionDeleted: (payload: ClientPayload<Composition>) => void;
-    broadcastInteractionLinkCreated: (payload: ClientPayload<InteractionLink>) => void;
-    broadcastInteractionLinkDeleted: (payload: ClientPayload<InteractionLink>) => void;
-    broadcastTagCreated: (payload: ClientPayload<Tag>) => void;
-    broadcastTagDeleted: (payload: ClientPayload<Tag>) => void;
-    broadcastUserCreated: (payload: ClientPayload<Tag>) => void;
-    broadcastUserDeleted: (payload: ClientPayload<Tag>) => void;
-    broadcastProjectCreated: (payload: ClientPayload<Project>) => void;
-    broadcastProjectUpdated: (payload: ClientPayload<Project>) => void;
-    broadcastProjectConfigUpdated: (payload: ClientPayload<Project>) => void;
-    broadcastNewVersionAvailable: () => void;
-};

package/services/backend/dist/src/core/sockets/createSystemEventHandlers.js

@@ -1,74 +0,0 @@
-export const createSystemEventHandlers = (fastify) => {
-    const { wss } = fastify;
-    const sendToChannel = (payload, key) => {
-        // TODO rework this to handle spaces instead of project and in the future document rooms -> y.js?
-        if (payload.project) {
-            wss.in(payload.project).emit(key, payload);
-        }
-        else {
-            wss.emit(key, payload);
-        }
-    };
-    return {
-        broadcastDataUpdatedHandler: (payload) => {
-            fastify.log.info(`[Socket] Push onData: ${payload.appSessionId}`);
-            sendToChannel(payload, "data");
-        },
-        broadcastDataCreatedHandler: (payload) => {
-            fastify.log.info(`[Socket] Push onCreate: ${payload.appSessionId}`);
-            sendToChannel(payload, "dataCreated");
-        },
-        broadcastDataDeletedHandler: (payload) => {
-            fastify.log.info(`[Socket] Push onDelete: ${payload.appSessionId}`);
-            sendToChannel(payload, "dataDeleted");
-        },
-        broadcastCompositionCreated: (payload) => {
-            fastify.log.info(`[Socket] Push CompositionCreated: ${payload.appSessionId}`);
-            sendToChannel(payload, "compositionCreated");
-        },
-        broadcastCompositionDeleted: (payload) => {
-            fastify.log.info(`[Socket] Push CompositionDeleted: ${payload.appSessionId}`);
-            sendToChannel(payload, "compositionDeleted");
-        },
-        broadcastInteractionLinkCreated: (payload) => {
-            fastify.log.info(`[Socket] Push InteractionLinkCreated: ${payload.appSessionId}`);
-            sendToChannel(payload, "interactionLinkCreated");
-        },
-        broadcastInteractionLinkDeleted: (payload) => {
-            fastify.log.info(`[Socket] Push InteractionLinkDeleted: ${payload.appSessionId}`);
-            sendToChannel(payload, "interactionLinkDeleted");
-        },
-        broadcastTagCreated: (payload) => {
-            fastify.log.info(`[Socket] Push tagCreated: ${payload.appSessionId}`);
-            sendToChannel(payload, "tagCreated");
-        },
-        broadcastTagDeleted: (payload) => {
-            fastify.log.info(`[Socket] Push tagDeleted: ${payload.appSessionId}`);
-            sendToChannel(payload, "tagDeleted");
-        },
-        broadcastUserCreated: (payload) => {
-            fastify.log.info(`[Socket] Push userCreated: ${payload.appSessionId}`);
-            sendToChannel(payload, "userCreated");
-        },
-        broadcastUserDeleted: (payload) => {
-            fastify.log.info(`[Socket] Push userDeleted: ${payload.appSessionId}`);
-            sendToChannel(payload, "userDeleted");
-        },
-        broadcastProjectCreated: (payload) => {
-            fastify.log.info(`[Socket] Push projectCreated: ${payload.appSessionId}`);
-            sendToChannel(payload, "projectCreated");
-        },
-        broadcastProjectUpdated: (payload) => {
-            fastify.log.info(`[Socket] Push projectUpdated: ${payload.appSessionId}`);
-            sendToChannel(payload, "projectUpdated");
-        },
-        broadcastProjectConfigUpdated: (payload) => {
-            fastify.log.info(`[Socket] Push projectDeleted: ${payload.appSessionId}`);
-            sendToChannel(payload, "projectDeleted");
-        },
-        broadcastNewVersionAvailable: () => {
-            wss.emit("newVersionAvailable");
-            fastify.log.info("[Socket] push new version available #all");
-        },
-    };
-};

package/services/backend/dist/src/core/sockets/index.d.ts

@@ -1,2 +0,0 @@
-declare const _default: (fastify: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>, opts: Record<never, never>, done: (err?: Error) => void) => void;
-export default _default;

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

@@ -1,65 +0,0 @@
-import fastifyPlugin from "fastify-plugin";
-import { Server } from "socket.io";
-import configService from "../config/configService.js";
-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: /localhost/, 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");
-            }
-            // Instead of socketio-jwt, use this custom middleware
-            socketServer.use((socket, next) => {
-                try {
-                    const token = socket.handshake.auth?.token ??
-                        socket.handshake.headers.authorization?.split(" ")[1];
-                    if (!token) {
-                        fastify.log.warn(`Socket connection without token: ${socket.id}`);
-                        return next(new Error("Authentication failed: No token provided"));
-                    }
-                    // Verify token using fastify-jwt
-                    const decoded = fastify.jwt.verify(token);
-                    // Log successful authentication
-                    fastify.log.debug(`Socket authenticated: ${socket.id}`);
-                    // Store decoded token on socket
-                    socket.decoded_token = decoded;
-                    next();
-                }
-                catch (error) {
-                    fastify.log.error(`Socket authentication error: ${error.message}`);
-                    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/src/core/sockets/socketManager.d.ts

@@ -1,3 +0,0 @@
-import type { FastifyInstance } from "fastify";
-declare const registerSocketEvents: (fastify: FastifyInstance) => void;
-export default registerSocketEvents;

package/services/backend/dist/src/core/sockets/socketManager.js

@@ -1,125 +0,0 @@
-import { createSystemEventHandlers } from "./createSystemEventHandlers.js";
-import configService from "../config/configService.js";
-import { callDataTypeOperation } from "../contracting/contractRegistrar.js";
-const registerSocketEvents = (fastify) => {
-    const { wss } = fastify;
-    const eventbusHandler = createSystemEventHandlers(fastify);
-    const requiresAuth = configService.isAuthRequired();
-    wss.on("connection", (socket) => {
-        const isAuthenticated = requiresAuth
-            ? socket.decoded_token !== undefined
-            : true;
-        fastify.log.warn(`[socket] connected ${socket.id}`);
-        socket.emit("socketEstablished", { id: socket.id });
-        if (!isAuthenticated && configService.isAuthRequired()) {
-            fastify.log.warn(`[socket] unauthenticated connection ${socket.id}`);
-            socket.emit("authenticationRequired", {
-                message: "Authentication required",
-            });
-            // Don't disconnect immediately to allow client to handle login flow
-        }
-        socket.on("join", async (payload) => {
-            // Check authentication if required
-            if (configService.isAuthRequired() && !isAuthenticated) {
-                socket.emit("authenticationFailed", {
-                    message: "Authentication required to join room",
-                });
-                return;
-            }
-            const { token: _token, roomId: spaceId } = payload;
-            // Find project either by roomId or default
-            let project;
-            if (spaceId) {
-                try {
-                    project = await callDataTypeOperation("raclette__core", "project", "read", fastify, spaceId);
-                }
-                catch (error) {
-                    socket.emit("error", {
-                        error: { msg: "Space not found or access denied" },
-                    });
-                    return;
-                }
-            }
-            else {
-                try {
-                    project = await callDataTypeOperation("raclette__core", "project", "readMain", fastify);
-                }
-                catch (error) {
-                    socket.emit("error", {
-                        error: {
-                            msg: "No suiting space found. Something seems wrongly configured!",
-                        },
-                    });
-                    return;
-                }
-            }
-            socket.join(project._id);
-            socket.data.project = project._id;
-            // Prepare response data with project always included
-            const responseData = { project };
-            // Add compositions based on config
-            if (configService.isAutoSendEnabled("compositions")) {
-                responseData.compositions = await callDataTypeOperation("raclette__core", "composition", "readAll", fastify);
-            }
-            // Add interaction links based on config
-            if (configService.isAutoSendEnabled("interactionLinks")) {
-                responseData.interactionLinks = await callDataTypeOperation("raclette__core", "interactionLink", "readAll", fastify);
-            }
-            // Add project config based on config
-            if (configService.isAutoSendEnabled("projectConfig")) {
-                try {
-                    responseData.projectConfig = {};
-                }
-                catch (error) {
-                    fastify.log.error(`Error loading project config: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            // Add any custom static data from the config
-            const customData = configService.getCustomSocketData();
-            if (customData && typeof customData === "object") {
-                Object.entries(customData).forEach(([key, value]) => {
-                    responseData[key] = value;
-                });
-            }
-            socket.emit("joinConfirmation", responseData);
-            fastify.log.info(`[Socket] socket ${socket.id} joined room ${project._id}`);
-        });
-        socket.on("disconnect", () => {
-            fastify.log.warn(`[Socket] disconnected ${socket.id}`);
-        });
-        socket.on("leave", (room) => {
-            socket.leave(room);
-            socket.emit("leaveConfirmation", room);
-            wss.in(room).emit("memberLeft", {
-                room,
-                msg: `member left ${socket.id}`,
-            });
-        });
-    });
-    wss.on("connection_error", (error) => {
-        fastify.log.error({ msg: "[Socket]", error });
-    });
-    // Register event handlers
-    const events = {
-        broadcastDataUpdated: eventbusHandler.broadcastDataUpdatedHandler,
-        broadcastDataCreated: eventbusHandler.broadcastDataCreatedHandler,
-        broadcastDataDeleted: eventbusHandler.broadcastDataDeletedHandler,
-        broadcastTagCreated: eventbusHandler.broadcastTagCreated,
-        broadcastTagDeleted: eventbusHandler.broadcastTagDeleted,
-        broadcastUserCreated: eventbusHandler.broadcastUserCreated,
-        broadcastUserDeleted: eventbusHandler.broadcastUserDeleted,
-        broadcastInteractionLinkCreated: eventbusHandler.broadcastInteractionLinkCreated,
-        broadcastInteractionLinkDeleted: eventbusHandler.broadcastInteractionLinkDeleted,
-        broadcastCompositionCreated: eventbusHandler.broadcastCompositionCreated,
-        broadcastCompositionDeleted: eventbusHandler.broadcastCompositionDeleted,
-        broadcastProjectCreated: eventbusHandler.broadcastProjectCreated,
-        broadcastProjectUpdated: eventbusHandler.broadcastProjectUpdated,
-        broadcastProjectConfigUpdated: eventbusHandler.broadcastProjectConfigUpdated,
-        broadcastNewVersionAvailable: eventbusHandler.broadcastNewVersionAvailable,
-    };
-    // Register standard event handlers
-    Object.entries(events).forEach(([event, handler]) => {
-        fastify.eventbus.on(event, handler);
-    });
-};
-export default registerSocketEvents;