@raclettejs/core 0.0.1

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

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

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

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

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

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

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

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

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

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

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