@raclettejs/core 0.0.1

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

@@ -0,0 +1,342 @@
+import fs from "fs-extra";
+import path from "path";
+import eventMap from "../../eventBus/eventBusEventMap.js";
+// ========================================
+// 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,
+            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 } = routeInfo;
+    if (!registration)
+        return null;
+    const config = {
+        target: generateTargetFunction(url, pathParams),
+        method: method.toLowerCase(),
+    };
+    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.pluginPath, "client", "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/src/core/pluginSystem/pluginFastifyInstance.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+import type { PluginFastifyInstance, PluginOptions } from "./pluginTypes.js";
+export declare const createPluginFastifyInstance: (fastify: FastifyInstance, pluginOptions: PluginOptions) => PluginFastifyInstance;

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

@@ -0,0 +1,161 @@
+import mongoose from "mongoose";
+import { createCacheService } from "../../modules/cache/cacheManager.js";
+import { createPayload } from "../payload/payloadRegistrar.js";
+import { registerCrudHandlers } from "../crud/crudRegistrar.js";
+import { registerPayloadHandler } from "../payload/payloadRegistrar.js";
+import { registerPluginForFrontendGeneration } from "../pluginSystem/configGenerator/index.js";
+import { registerSchemaDefinition } from "../validation/schemaGenerator.js";
+import { registerPluginContract } from "../contracting/contractRegistrar.js";
+const EVENT_WHITELIST = [
+    "broadcastDataUpdated",
+    "broadcastDataCreated",
+    "broadcastDataDeleted",
+];
+export const createPluginFastifyInstance = (fastify, pluginOptions) => {
+    // here we add everything that we want to pass from fastify to the plugins
+    // + some additionally encapsulated functions
+    // encapsulate the plugin log to it's own child logger
+    const pluginLogger = fastify.log.child({
+        plugin: pluginOptions.key,
+        name: pluginOptions.key,
+    });
+    const pluginCacheService = createCacheService(fastify.redis, {
+        prefix: pluginOptions.key,
+        defaultTtl: 3600, // Default 60 minutes TTL for plugins -> TODO: should be a raclette.config option
+    });
+    const instance = {
+        register: (() => { }),
+        get: fastify.get,
+        post: fastify.post,
+        put: fastify.put,
+        patch: fastify.patch,
+        delete: fastify.delete,
+        authenticate: fastify.authenticate,
+        // Plugin-scoped logger with plugin-specific prefix
+        log: pluginLogger,
+        // Enforce prefixed model and collection naming
+        createModel: (modelName, schema) => {
+            const prefixedModelName = `${pluginOptions.collectionPrefix}${modelName}`;
+            const collectionName = `${pluginOptions.collectionPrefix}${modelName.toLowerCase()}`;
+            return mongoose.model(prefixedModelName, schema, collectionName);
+        },
+        registerSocket: (eventName, handler) => {
+            const prefixedEventName = `${pluginOptions.key}--${eventName}`;
+            // Defer socket and eventbus registration until app is ready
+            fastify.ready().then(() => {
+                if (!fastify.eventbus) {
+                    throw new Error("Eventbus is not available. Ensure it is registered before plugins.");
+                }
+                // Register with the eventbus
+                fastify.eventbus.on(prefixedEventName, handler);
+                fastify.log.info(`[registerSocket] Eventbus listener registered for: ${prefixedEventName}`);
+                // Register corresponding socket listener
+                fastify.wss.on("connection", (socket) => {
+                    socket.on(prefixedEventName, (payload) => {
+                        fastify.log.info(`[Socket] Event '${prefixedEventName}' received from socket.`);
+                        handler(payload); // Execute the event handler
+                    });
+                });
+            });
+        },
+        emit: (eventName, data) => {
+            // Whitelisted events will go to the main channel and need no prefix
+            if (EVENT_WHITELIST.includes(eventName)) {
+                fastify.log.info("[Eventbus] Emit Event " + eventName);
+                fastify.eventbus.emit(eventName, data);
+            }
+            else {
+                const prefixedEventName = `${pluginOptions.key}--${eventName}`;
+                fastify.log.info("[Eventbus] Emit Event " + prefixedEventName);
+                fastify.eventbus.emit(prefixedEventName, data);
+                fastify.wss.emit(prefixedEventName, data);
+            }
+        },
+        registerSchema: (schemaDefinition) => {
+            registerSchemaDefinition({
+                ...schemaDefinition,
+                pluginKey: pluginOptions.key,
+                isCore: pluginOptions.type === "core",
+            });
+        },
+        http: {
+            get: fastify.http.get,
+            post: fastify.http.post,
+            put: fastify.http.put,
+            delete: fastify.http.delete,
+        },
+        createIntervalTask: (name, handler, options) => {
+            const prefixedName = `${pluginOptions.key}--${name}`;
+            const pluginLogger = fastify.log.child({ plugin: pluginOptions.key });
+            fastify.taskManager.createIntervalTask(prefixedName, handler, {
+                ...options,
+                errorHandler: (error) => {
+                    if (options.errorHandler) {
+                        options.errorHandler(error);
+                    }
+                    pluginLogger.error(`Task ${prefixedName} failed:`, error);
+                },
+            });
+        },
+        cancelTask: (name) => {
+            const prefixedName = `${pluginOptions.key}--${name}`;
+            fastify.taskManager.cancelTask(prefixedName);
+        },
+        registerCrudHandlers: (name, handlers) => {
+            const prefixedName = `${pluginOptions.key}--${name}`;
+            registerCrudHandlers(prefixedName, handlers, "plugin");
+        },
+        registerPayloadHandler: (name, registerData) => {
+            const prefixedName = `${pluginOptions.key}--${name}`;
+            registerPayloadHandler(prefixedName, registerData, pluginOptions.key);
+        },
+        createPayload: (name, item, requestData, scope) => {
+            const prefixedName = `${pluginOptions.key}--${name}`;
+            return createPayload(prefixedName, item, requestData, scope || pluginOptions.key);
+        },
+        eventbus: {
+            emit: (eventName, data) => {
+                // TODO: add whitelist check where no prefix is applied
+                const prefixedName = `${pluginOptions.key}--${eventName}`;
+                return fastify.eventbus.emit(prefixedName, data);
+            },
+            // TODO: fiy types
+            on: (eventName, callback) => {
+                const prefixedName = `${pluginOptions.key}--${eventName}`;
+                return fastify.eventbus.on(prefixedName, callback);
+            },
+        },
+        registerPluginContract: (contractData) => {
+            registerPluginContract(pluginOptions.key, contractData);
+        },
+        registerForFrontendGeneration: (options) => {
+            registerPluginForFrontendGeneration(pluginOptions, options);
+        },
+        cache: pluginCacheService,
+    };
+    const register = (routes, options) => {
+        const opts = {
+            ...options,
+            prefix: pluginOptions.routePrefix,
+        };
+        return fastify.register((encapsulatedInstance) => {
+            const combined = new Proxy(instance, {
+                // Use instance directly instead of this
+                get: (target, prop) => {
+                    if (["get", "post", "put", "patch", "delete"].includes(prop)) {
+                        // @ts-ignore
+                        return encapsulatedInstance[prop].bind(encapsulatedInstance);
+                    }
+                    // @ts-ignore
+                    return target[prop];
+                },
+            });
+            // @ts-ignore
+            return routes(combined);
+        }, opts);
+    };
+    instance.register = register;
+    instance.fastify = fastify;
+    instance.custom = {};
+    return instance;
+};

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

@@ -0,0 +1,5 @@
+import type { FastifyInstance } from "fastify";
+/**
+ * Register plugins in three phases: core, npm, then app plugins
+ */
+export declare const registerPlugins: (fastify: FastifyInstance, errorFlags?: number) => Promise<void>;