@raclettejs/core 0.0.1

package/services/backend/dist/src/core/backgroundTasks/taskManager.js

@@ -0,0 +1,135 @@
+import fastifyPlugin from "fastify-plugin";
+import { SimpleIntervalJob, AsyncTask } from "toad-scheduler";
+// Store metadata for jobs
+const taskMetadata = new Map();
+let activeConnections = 0;
+let isAppReady = false;
+let tasksToStartOnReady = [];
+const pauseNonEssentialTasks = (fastify) => {
+    const jobs = fastify.scheduler.getAllJobs();
+    jobs.forEach((job) => {
+        const metadata = taskMetadata.get(job.id || "");
+        if (metadata && !metadata.keepRunning) {
+            fastify.log.info(`Pausing non-essential task: ${job.id}`);
+            job.stop();
+        }
+    });
+};
+const resumeNonEssentialTasks = (fastify) => {
+    const jobs = fastify.scheduler.getAllJobs();
+    jobs.forEach((job) => {
+        const metadata = taskMetadata.get(job.id || "");
+        if (metadata && !metadata.keepRunning) {
+            fastify.log.info(`Resuming non-essential task: ${job.id}`);
+            job.start();
+        }
+    });
+};
+const stopAllTasks = (fastify) => {
+    const jobs = fastify.scheduler.getAllJobs();
+    fastify.log.info(`Stopping ${jobs.length} tasks...`);
+    jobs.forEach((job) => {
+        try {
+            job.stop();
+            fastify.log.debug(`Stopped task: ${job.id}`);
+        }
+        catch (error) {
+            fastify.log.error(`Error stopping task ${job.id}:`, error);
+        }
+    });
+    // Clear all jobs from scheduler
+    try {
+        fastify.scheduler.stop();
+        fastify.log.info("Task scheduler stopped");
+    }
+    catch (error) {
+        fastify.log.error("Error stopping scheduler:", error);
+    }
+    // Clear metadata
+    taskMetadata.clear();
+    tasksToStartOnReady = [];
+};
+const setupTaskManager = (fastify) => {
+    fastify.wss.on("connection", (socket) => {
+        activeConnections++;
+        if (activeConnections === 1) {
+            resumeNonEssentialTasks(fastify);
+        }
+        socket.on("disconnect", () => {
+            activeConnections--;
+            if (activeConnections === 0) {
+                pauseNonEssentialTasks(fastify);
+            }
+        });
+    });
+    return {
+        createIntervalTask: (name, handler, options) => {
+            const createTask = () => {
+                const task = new AsyncTask(name, handler, (error) => {
+                    if (options.errorHandler) {
+                        options.errorHandler(error);
+                    }
+                    fastify.log.error(`Task ${name} failed:`, error);
+                });
+                const job = new SimpleIntervalJob({
+                    seconds: options.seconds,
+                    runImmediately: options.runImmediately ?? false,
+                }, task, { id: name });
+                taskMetadata.set(name, {
+                    keepRunning: options.keepRunning ?? false,
+                });
+                fastify.scheduler.addSimpleIntervalJob(job);
+                fastify.log.info(`Registered interval task: ${name}`);
+            };
+            // If app is ready, create task immediately
+            // Otherwise, queue it for when the app becomes ready
+            if (isAppReady) {
+                createTask();
+            }
+            else {
+                tasksToStartOnReady.push(createTask);
+                fastify.log.info(`Queued task for app ready: ${name}`);
+            }
+        },
+        cancelTask: (name) => {
+            const removed = fastify.scheduler.removeById(name);
+            if (removed) {
+                taskMetadata.delete(name);
+                fastify.log.info(`Cancelled task: ${name}`);
+            }
+            else {
+                fastify.log.warn(`Task not found: ${name}`);
+            }
+        },
+        markAppReady: () => {
+            if (isAppReady)
+                return;
+            isAppReady = true;
+            fastify.log.info(`App ready, starting ${tasksToStartOnReady.length} queued tasks`);
+            // Start all queued tasks
+            tasksToStartOnReady.forEach((createTask) => {
+                try {
+                    createTask();
+                }
+                catch (error) {
+                    fastify.log.error("Error starting queued task:", error);
+                }
+            });
+            tasksToStartOnReady = [];
+        },
+        stopAllTasks: () => stopAllTasks(fastify),
+        getTaskCount: () => fastify.scheduler.getAllJobs().length,
+    };
+};
+export default fastifyPlugin(async (fastify) => {
+    const taskManager = setupTaskManager(fastify);
+    fastify.decorate("taskManager", taskManager);
+    // Add cleanup hook for server shutdown
+    fastify.addHook("onClose", async () => {
+        fastify.log.info("App is closing, stopping all tasks...");
+        stopAllTasks(fastify);
+    });
+}, {
+    name: "taskManager",
+});
+export { setupTaskManager };

package/services/backend/dist/src/core/backgroundTasks/taskManagerTypes.d.ts

@@ -0,0 +1,19 @@
+export interface TaskOptions {
+    errorHandler?: (error: Error) => void;
+}
+export interface IntervalTaskOptions extends TaskOptions {
+    seconds: number;
+    runImmediately?: boolean;
+    keepRunning?: boolean;
+}
+declare module "fastify" {
+    interface FastifyInstance {
+        taskManager: {
+            createIntervalTask: (name: string, handler: () => Promise<void>, options: IntervalTaskOptions) => void;
+            cancelTask: (name: string) => void;
+            markAppReady: () => void;
+            stopAllTasks: () => void;
+            getTaskCount: () => number;
+        };
+    }
+}

package/services/backend/dist/src/core/backgroundTasks/taskManagerTypes.js

@@ -0,0 +1,2 @@
+// taskManagerTypes.ts
+export {};

package/services/backend/dist/src/core/backgroundTasks/toadSchedulerTypes.d.ts

@@ -0,0 +1,7 @@
+import type { JobOptions } from "toad-scheduler/dist/lib/engines/simple-interval/SimpleIntervalJob";
+export interface ExtendedJobOptions extends JobOptions {
+    metadata?: {
+        pluginKey: string;
+        keepRunning: boolean;
+    };
+}

package/services/backend/dist/src/core/backgroundTasks/toadSchedulerTypes.js

@@ -0,0 +1 @@
+export {};

package/services/backend/dist/src/core/config/configService.d.ts

@@ -0,0 +1,38 @@
+import type { SocketConfig, CacheConfig } from "../../../types/index.js";
+type RacletteBackendConfig = {
+    sockets?: {
+        autoSend?: any;
+    };
+    cache?: {
+        persistence?: string;
+    };
+    onlyAllowLoginWithAdminTag?: true;
+    plugins?: string[];
+    global?: {
+        requireAuthentication?: boolean;
+    };
+    additionalPluginPaths?: string[];
+};
+type socketDefaultAutoSend = "compositions" | "interactionLinks" | "projectConfig";
+export declare class ConfigService {
+    private config;
+    constructor();
+    init(): Promise<this>;
+    refreshConfig(): Promise<void>;
+    getConfig(): RacletteBackendConfig | null;
+    getCacheConfig(): CacheConfig | {};
+    getCachePersistenceConfig(): CacheConfig["persistence"] | string;
+    getCacheRDBConfig(): CacheConfig["RDB_OPTIONS"];
+    getSocketConfig(): SocketConfig;
+    getSocketAutoSendConfig(): SocketConfig["autoSend"] | {};
+    getSocketSecurityConfig(): SocketConfig["security"];
+    getSocketOptionsConfig(): SocketConfig["options"];
+    isAutoSendEnabled(feature: socketDefaultAutoSend): boolean;
+    isAuthRequired(): boolean;
+    isAdminTagRequired(): boolean;
+    getCustomSocketData(): Record<string, any> | undefined;
+    getPlugins(): string[];
+    getAdditonalPluginPaths(): string[];
+}
+declare const configService: ConfigService;
+export default configService;

package/services/backend/dist/src/core/config/configService.js

@@ -0,0 +1,98 @@
+// Cache for configuration
+let cachedConfig = null;
+export class ConfigService {
+    config = null;
+    constructor() {
+        this.config = {};
+    }
+    async init() {
+        await this.refreshConfig();
+        return this;
+    }
+    // Refresh the config (useful for hot reloading)
+    async refreshConfig() {
+        try {
+            // Dynamic import for ESM - this allows for hot reloading
+            const configModule = await import("../../../raclette.config.js?t=" + Date.now());
+            this.config = configModule.racletteConfig;
+            cachedConfig = this.config;
+        }
+        catch (error) {
+            console.warn(`Error loading config: ${error instanceof Error ? error.message : String(error)}`);
+            // Keep using cached config if it exists
+            this.config = cachedConfig;
+        }
+    }
+    // Get the entire config
+    getConfig() {
+        if (!this.config) {
+            if (!cachedConfig) {
+                console.error("Failed to load Raclette configuration");
+            }
+            this.config = cachedConfig;
+        }
+        return this.config;
+    }
+    // Get cache configuration with defaults
+    getCacheConfig() {
+        const config = this.getConfig();
+        return config?.cache ?? {};
+    }
+    // Get cache persistence configuration
+    getCachePersistenceConfig() {
+        const cacheConfig = this.getCacheConfig();
+        return cacheConfig?.persistence ?? "none";
+    }
+    // Get cache rdb configuration
+    getCacheRDBConfig() {
+        const cacheConfig = this.getCacheConfig();
+        return cacheConfig?.RDB_OPTIONS ?? "3600 1 300 100 60 10000";
+    }
+    // Get socket configuration with defaults
+    getSocketConfig() {
+        const config = this.getConfig();
+        return config?.sockets ?? {};
+    }
+    // Get socket auto-send configuration
+    getSocketAutoSendConfig() {
+        const socketConfig = this.getSocketConfig();
+        return socketConfig?.autoSend ?? {};
+    }
+    // Get socket security configuration
+    getSocketSecurityConfig() {
+        const socketConfig = this.getSocketConfig();
+        return socketConfig.security || {};
+    }
+    // Get socket options configuration
+    getSocketOptionsConfig() {
+        const socketConfig = this.getSocketConfig();
+        return socketConfig.options || {};
+    }
+    // Helper to check if a specific auto-send feature is enabled
+    // Default to true unless explicitly set to false
+    isAutoSendEnabled(feature) {
+        const autoSend = this.getSocketAutoSendConfig();
+        return autoSend[feature] !== false;
+    }
+    // Helper to check if auth is required
+    // Default to true unless explicitly set to false
+    isAuthRequired() {
+        return this.config?.global?.requireAuthentication ?? true;
+    }
+    isAdminTagRequired() {
+        return this.config?.onlyAllowLoginWithAdminTag ?? false;
+    }
+    getCustomSocketData() {
+        const socketConfig = this.getSocketConfig();
+        return socketConfig?.autoSend?.customData;
+    }
+    getPlugins() {
+        return this.config?.plugins || [];
+    }
+    getAdditonalPluginPaths() {
+        return this.config?.additionalPluginPaths || [];
+    }
+}
+// Create singleton instance
+const configService = new ConfigService();
+export default configService;

package/services/backend/dist/src/core/config/configTypes.d.ts

@@ -0,0 +1,33 @@
+export interface ModuleConfig {
+    name: string;
+    enabled: boolean;
+    options?: Record<string, any>;
+}
+export interface AppHooks {
+    beforeStart?: () => Promise<void> | void;
+    afterStart?: () => Promise<void> | void;
+    beforeMount?: () => Promise<void> | void;
+    afterMount?: () => Promise<void> | void;
+}
+export interface AppConfig {
+    title: string;
+    baseColor: string;
+    languages: string[];
+    modules?: ModuleConfig[];
+    hooks?: AppHooks;
+    dev?: {
+        port?: number;
+        host?: string;
+        debug?: boolean;
+    };
+    build?: {
+        outDir?: string;
+        minify?: boolean;
+        sourcemap?: boolean;
+    };
+    runtimeConfig?: {
+        public?: Record<string, any>;
+        private?: Record<string, any>;
+    };
+}
+export declare const defaultConfig: Partial<AppConfig>;

package/services/backend/dist/src/core/config/configTypes.js

@@ -0,0 +1,5 @@
+export const defaultConfig = {
+    title: "App",
+    baseColor: "#000000",
+    languages: ["en"],
+};

package/services/backend/dist/src/core/contracting/contractRegistrar.d.ts

@@ -0,0 +1,13 @@
+import type { PluginContract, DataTypeContract, DiscoveryResult } from "./contractTypes.js";
+export declare const registerPluginContract: (pluginKey: string, contract: PluginContract) => void;
+export declare const getPluginContract: (pluginKey: string) => PluginContract | undefined;
+export declare const getDataTypeContract: (pluginKey: string, dataTypeName: string) => DataTypeContract | undefined;
+export declare const getAllPluginContracts: () => Record<string, PluginContract>;
+export declare const getAllPluginKeys: () => string[];
+export declare const getAvailableDataTypes: () => Record<string, string[]>;
+export declare const getDataTypeOperations: (pluginKey: string, dataTypeName: string) => string[];
+export declare const callDataTypeOperation: (pluginKey: string, dataTypeName: string, operation: string, ...args: any[]) => Promise<any>;
+export declare const findDataTypesByKeyword: (keyword: string) => DiscoveryResult[];
+export declare const findDataTypesWithOperation: (operation: string) => DiscoveryResult[];
+export declare const getAllKeywords: () => string[];
+export declare const hasOperation: (pluginKey: string, dataTypeName: string, operation: string) => boolean;

package/services/backend/dist/src/core/contracting/contractRegistrar.js

@@ -0,0 +1,83 @@
+// Store plugin contracts: pluginKey -> contract
+const contracts = {};
+export const registerPluginContract = (pluginKey, contract) => {
+    if (contracts[pluginKey]) {
+        throw new Error(`Plugin contract for "${pluginKey}" is already registered`);
+    }
+    contracts[pluginKey] = contract;
+};
+export const getPluginContract = (pluginKey) => contracts[pluginKey];
+export const getDataTypeContract = (pluginKey, dataTypeName) => contracts[pluginKey]?.[dataTypeName];
+export const getAllPluginContracts = () => contracts;
+export const getAllPluginKeys = () => Object.keys(contracts);
+export const getAvailableDataTypes = () => {
+    const result = {};
+    Object.entries(contracts).forEach(([pluginKey, contract]) => {
+        result[pluginKey] = Object.keys(contract);
+    });
+    return result;
+};
+export const getDataTypeOperations = (pluginKey, dataTypeName) => {
+    const dataType = getDataTypeContract(pluginKey, dataTypeName);
+    return dataType?.operations ? Object.keys(dataType.operations) : [];
+};
+export const callDataTypeOperation = async (pluginKey, dataTypeName, operation, ...args) => {
+    const dataType = getDataTypeContract(pluginKey, dataTypeName);
+    if (!dataType) {
+        throw new Error(`DataType "${dataTypeName}" not found in plugin "${pluginKey}"`);
+    }
+    const operationFn = dataType.operations?.[operation];
+    if (!operationFn) {
+        throw new Error(`Operation "${operation}" not provided by "${pluginKey}.${dataTypeName}"`);
+    }
+    return await operationFn(...args);
+};
+// Discovery functions
+export const findDataTypesByKeyword = (keyword) => {
+    const results = [];
+    Object.entries(contracts).forEach(([pluginKey, contract]) => {
+        Object.entries(contract).forEach(([dataTypeName, dataType]) => {
+            if (dataType.keywords?.includes(keyword)) {
+                results.push({
+                    pluginKey,
+                    dataTypeName,
+                    keywords: dataType.keywords || [],
+                    operations: dataType.operations
+                        ? Object.keys(dataType.operations)
+                        : [],
+                });
+            }
+        });
+    });
+    return results;
+};
+export const findDataTypesWithOperation = (operation) => {
+    const results = [];
+    Object.entries(contracts).forEach(([pluginKey, contract]) => {
+        Object.entries(contract).forEach(([dataTypeName, dataType]) => {
+            if (dataType.operations?.[operation]) {
+                results.push({
+                    pluginKey,
+                    dataTypeName,
+                    keywords: dataType.keywords || [],
+                    operations: Object.keys(dataType.operations),
+                });
+            }
+        });
+    });
+    return results;
+};
+export const getAllKeywords = () => {
+    const keywordSet = new Set();
+    Object.values(contracts).forEach((contract) => {
+        Object.values(contract).forEach((dataType) => {
+            dataType.keywords?.forEach((keyword) => keywordSet.add(keyword));
+        });
+    });
+    return Array.from(keywordSet);
+};
+// Utility function to check if operation exists
+export const hasOperation = (pluginKey, dataTypeName, operation) => {
+    const dataType = getDataTypeContract(pluginKey, dataTypeName);
+    return !!dataType?.operations?.[operation];
+};

package/services/backend/dist/src/core/contracting/contractTypes.d.ts

@@ -0,0 +1,18 @@
+export interface DataTypeContract {
+    schema?: any;
+    operations?: Record<string, Function>;
+    keywords?: string[];
+    metadata?: {
+        description?: string;
+        version?: string;
+    };
+}
+export interface PluginContract {
+    [dataTypeName: string]: DataTypeContract;
+}
+export interface DiscoveryResult {
+    pluginKey: string;
+    dataTypeName: string;
+    keywords: string[];
+    operations: string[];
+}

package/services/backend/dist/src/core/contracting/contractTypes.js

@@ -0,0 +1 @@
+export {};

package/services/backend/dist/src/core/crud/crudRegistrar.d.ts

@@ -0,0 +1,6 @@
+import type { CrudHandlers } from "../crud/crudTypes.js";
+export declare const registerCrudHandlers: <T>(type: string, crudHandlers: CrudHandlers<T>, scope?: string) => void;
+export declare const getCrudHandlers: <T>(type: string) => CrudHandlers<T> | undefined;
+export declare const getAllCrudHandlers: () => Record<string, CrudHandlers<any>>;
+export declare const getCrudHandlersByScope: (scope: string) => CrudHandlers<any>[];
+export declare const getAllTypes: () => string[];

package/services/backend/dist/src/core/crud/crudRegistrar.js

@@ -0,0 +1,16 @@
+// Store CRUD handlers in a simple object
+const handlers = {};
+const scopes = {};
+export const registerCrudHandlers = (type, crudHandlers, scope = "core") => {
+    if (handlers[type]) {
+        throw new Error(`CRUD handlers for type "${type}" are already registered`);
+    }
+    handlers[type] = crudHandlers;
+    // Register scope
+    scopes[scope] = scopes[scope] || new Set();
+    scopes[scope].add(type);
+};
+export const getCrudHandlers = (type) => handlers[type];
+export const getAllCrudHandlers = () => handlers;
+export const getCrudHandlersByScope = (scope) => Array.from(scopes[scope] || []).map((type) => handlers[type]);
+export const getAllTypes = () => Object.keys(handlers);

package/services/backend/dist/src/core/crud/crudTypes.d.ts

@@ -0,0 +1,8 @@
+import type { ClientPayloadRequestData } from "../payload/payloadTypes.js";
+import type { FastifyInstance } from "fastify";
+export interface CrudHandlers<T> {
+    create: (fastify: FastifyInstance, requestParams: ClientPayloadRequestData, data: Partial<T>, userId: string, broadcast?: boolean) => Promise<any>;
+    read: (fastify: FastifyInstance, requestParams: ClientPayloadRequestData, id: string) => Promise<any>;
+    update: (fastify: FastifyInstance, requestParams: ClientPayloadRequestData, id: string, data: Partial<T>, userId: string, broadcast?: boolean) => Promise<any>;
+    delete: (fastify: FastifyInstance, requestParams: ClientPayloadRequestData, id: string, userId: string, broadcast?: boolean) => Promise<any>;
+}

package/services/backend/dist/src/core/crud/crudTypes.js

@@ -0,0 +1 @@
+export {};

package/services/backend/dist/src/core/eventBus/eventBusEventMap.d.ts

@@ -0,0 +1,65 @@
+declare const _default: {
+    dataNew: {};
+    dataCreated: {};
+    dataUpdated: {};
+    dataDeleted: {};
+    dataMoved: {};
+    journalTicketCreated: {};
+    journalTicketUpdated: {};
+    journalTicketMoved: {};
+    journalTicketDeleted: {};
+    journalTicketFileUploaded: {};
+    journalTicketFileDeleted: {};
+    coreTagCreated: {};
+    coreTagUpdated: {};
+    coreTagDeleted: {};
+    coreTagHardDeleted: {};
+    coreTagArrayUpdated: {};
+    coreUserCreated: {};
+    coreUserUpdated: {};
+    coreUserDeleted: {};
+    coreUserHardDeleted: {};
+    coreAccountCreated: {};
+    coreAccountUpdated: {};
+    coreAccountDeleted: {};
+    coreAccountHardDeleted: {};
+    coreProjectCreated: {};
+    coreProjectUpdated: {};
+    coreProjectDeleted: {};
+    coreProjectHardDeleted: {};
+    coreCompositionCreated: {};
+    coreCompositionUpdated: {};
+    coreCompositionDeleted: {};
+    coreCompositionHardDeleted: {};
+    coreInteractionLinkCreated: {};
+    coreInteractionLinkUpdated: {};
+    coreInteractionLinkDeleted: {};
+    coreInteractionLinkHardDeleted: {};
+    coreContentCreated: {};
+    coreContentUpdated: {};
+    coreContentDeleted: {};
+    coreContentHardDeleted: {};
+    coreProjectConfigUpdated: {};
+    broadcastDataCreated: {};
+    broadcastDataUpdated: {};
+    broadcastDataDeleted: {};
+    broadcastDataUpdatedSystem: {};
+    broadcastTicketCreated: {};
+    broadcastTicketDeleted: {};
+    broadcastTicketFileUploaded: {};
+    broadcastTicketFileDeleted: {};
+    broadcastTagCreated: {};
+    broadcastTagDeleted: {};
+    broadcastUserCreated: {};
+    broadcastUserDeleted: {};
+    broadcastInteractionLinkCreated: {};
+    broadcastInteractionLinkDeleted: {};
+    broadcastCompositionCreated: {};
+    broadcastCompositionDeleted: {};
+    broadcastProjectCreated: {};
+    broadcastProjectUpdated: {};
+    broadcastProjectConfigUpdated: {};
+    appReady: {};
+    broadcastNewVersionAvailable: {};
+};
+export default _default;

package/services/backend/dist/src/core/eventBus/eventBusEventMap.js

@@ -0,0 +1,64 @@
+export default {
+    dataNew: {},
+    dataCreated: {},
+    dataUpdated: {},
+    dataDeleted: {},
+    dataMoved: {},
+    journalTicketCreated: {},
+    journalTicketUpdated: {},
+    journalTicketMoved: {},
+    journalTicketDeleted: {},
+    journalTicketFileUploaded: {},
+    journalTicketFileDeleted: {},
+    coreTagCreated: {},
+    coreTagUpdated: {},
+    coreTagDeleted: {},
+    coreTagHardDeleted: {}, // fully deleted from DB
+    coreTagArrayUpdated: {},
+    coreUserCreated: {},
+    coreUserUpdated: {},
+    coreUserDeleted: {},
+    coreUserHardDeleted: {},
+    coreAccountCreated: {},
+    coreAccountUpdated: {},
+    coreAccountDeleted: {},
+    coreAccountHardDeleted: {},
+    coreProjectCreated: {},
+    coreProjectUpdated: {},
+    coreProjectDeleted: {},
+    coreProjectHardDeleted: {},
+    coreCompositionCreated: {},
+    coreCompositionUpdated: {},
+    coreCompositionDeleted: {},
+    coreCompositionHardDeleted: {},
+    coreInteractionLinkCreated: {},
+    coreInteractionLinkUpdated: {},
+    coreInteractionLinkDeleted: {},
+    coreInteractionLinkHardDeleted: {},
+    coreContentCreated: {},
+    coreContentUpdated: {},
+    coreContentDeleted: {},
+    coreContentHardDeleted: {},
+    coreProjectConfigUpdated: {},
+    broadcastDataCreated: {},
+    broadcastDataUpdated: {},
+    broadcastDataDeleted: {},
+    broadcastDataUpdatedSystem: {},
+    broadcastTicketCreated: {},
+    broadcastTicketDeleted: {},
+    broadcastTicketFileUploaded: {},
+    broadcastTicketFileDeleted: {},
+    broadcastTagCreated: {},
+    broadcastTagDeleted: {},
+    broadcastUserCreated: {},
+    broadcastUserDeleted: {},
+    broadcastInteractionLinkCreated: {},
+    broadcastInteractionLinkDeleted: {},
+    broadcastCompositionCreated: {},
+    broadcastCompositionDeleted: {},
+    broadcastProjectCreated: {},
+    broadcastProjectUpdated: {},
+    broadcastProjectConfigUpdated: {},
+    appReady: {},
+    broadcastNewVersionAvailable: {},
+};

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

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

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

@@ -0,0 +1,7 @@
+import fastifyPlugin from "fastify-plugin";
+import eventMap from "./eventBusEventMap.js";
+import EventEmitter from "../events/eventEmitter.js";
+export default fastifyPlugin(async (fastify) => {
+    const eventbus = new EventEmitter(eventMap);
+    fastify.decorate("eventbus", eventbus);
+});

package/services/backend/dist/src/core/events/eventEmitter.d.ts

@@ -0,0 +1,13 @@
+type Listener = (...args: any[]) => void;
+declare class EventEmitter {
+    private events;
+    private eventMap?;
+    constructor(eventMap?: Record<string, any>);
+    on(event: string, listener: Listener): () => void;
+    removeListener(event: string, listener: Listener): void;
+    emit(event: string, ...args: any[]): boolean;
+    once(event: string, listener: Listener): void;
+    private isValid;
+}
+export default EventEmitter;
+export type { Listener };