@raclettejs/core 0.1.0 → 0.1.1

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

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

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

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

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