BACKEND DONE FOR ALL APPS

CEO/src/network/operations_base/operation_base.ts

@@ -0,0 +1,43 @@
+import { ParsedMessage } from '../message_handler';
+import { OperationHandler } from './operation_handler';
+import { OperationPlugin } from './operation_plugin';
+
+export abstract class OperationBase implements OperationPlugin {
+    // Shared operation codes
+    public static readonly operationCodes = {
+        OK: 'OK',
+        ERR: 'ERR',
+        END: 'END',
+    };
+
+    // Default handler for OK operation
+    public static handleOk(parsedMessage: ParsedMessage): ParsedMessage {
+        console.log('OK operation received');
+        return parsedMessage;  // Typically, you would just acknowledge with OK, returning as-is
+    }
+
+    // Default handler for ERR operation
+    public static handleErr(parsedMessage: ParsedMessage): ParsedMessage {
+        console.log('ERR operation received: ', parsedMessage.metaInfo?.message || 'No error details provided');
+        return parsedMessage;  // Typically, you would log the error and return
+    }
+
+    // Default handler for END operation
+    public static handleEnd(parsedMessage: ParsedMessage): ParsedMessage {
+        console.log('END operation received');
+        return {
+            operationCode: OperationBase.operationCodes.END,
+            metaInfo: { message: 'Connection ended.' },
+        };
+    }
+
+    // Register the common OK, ERR, and END handlers
+    public static registerCommonOperations(operationHandler: OperationHandler): void {
+        operationHandler.registerHandler(OperationBase.operationCodes.OK, OperationBase.handleOk);
+        operationHandler.registerHandler(OperationBase.operationCodes.ERR, OperationBase.handleErr);
+        operationHandler.registerHandler(OperationBase.operationCodes.END, OperationBase.handleEnd);
+    }
+
+    // Abstract register method that will be implemented by subclasses
+    public abstract register(operationHandler: OperationHandler): void;
+}

CEO/src/network/operations_base/operation_handler.ts

@@ -0,0 +1,58 @@
+// operation_handler.ts
+import { ParsedMessage, MessageHandler } from '../message_handler';
+import { OperationPlugin } from './operation_plugin';
+
+type OperationHandlerFunction = (parsedMessage: ParsedMessage) => ParsedMessage;
+
+export class OperationHandler {
+    private static instance: OperationHandler;
+    private handlers: { [operationCode: string]: OperationHandlerFunction } = {};
+
+    private constructor() {
+        // Register only the unknown command handler on initialization
+        this.registerHandler('UNKNOWN_COMMAND', this.handleUnknownCommand);
+    }
+
+    // Singleton instance
+    public static getInstance(): OperationHandler {
+        if (!OperationHandler.instance) {
+            OperationHandler.instance = new OperationHandler();
+        }
+        return OperationHandler.instance;
+    }
+
+    // Register a handler for a specific operation code
+    public registerHandler(operationCode: string, handler: OperationHandlerFunction): void {
+        this.handlers[operationCode] = handler;
+    }
+
+    // Handle operation request
+    public handleOperation(rawMessage: string): ParsedMessage {
+        // Parse and validate the message
+        const parsedMessage = MessageHandler.parseMessage(rawMessage);
+        if (!parsedMessage || !MessageHandler.validateMessage(parsedMessage)) {
+            return this.handleUnknownCommand(parsedMessage);
+        }
+
+        // Dispatch the handler for the given operation code
+        const handler = this.handlers[parsedMessage.operationCode];
+        if (handler) {
+            return handler(parsedMessage);
+        } else {
+            return this.handleUnknownCommand(parsedMessage);
+        }
+    }
+
+    // Default handler for unknown commands
+    private handleUnknownCommand(parsedMessage: ParsedMessage): ParsedMessage {
+        return {
+            operationCode: 'UNKNOWN_COMMAND',
+            metaInfo: { message: 'Unknown command received.' },
+        };
+    }
+
+    // Plugin system: Load plugins to register handlers
+    public loadPlugin(plugin: OperationPlugin): void {
+        plugin.register(this);
+    }
+}

CEO/src/network/operations_base/operation_plugin.ts

@@ -0,0 +1,6 @@
+// operation_plugin.ts
+import { OperationHandler } from './operation_handler';
+
+export interface OperationPlugin {
+    register(operationHandler: OperationHandler): void;
+}