update

ts/platformservice.ts

@@ -4,6 +4,9 @@ import { PlatformServiceDb } from './classes.platformservicedb.js'
 import { EmailService } from './mail/services/classes.emailservice.js';
 import { SmsService } from './sms/classes.smsservice.js';
 import { MtaService } from './mail/delivery/classes.mta.js';
+import { logger } from './logger.js';
+import { type IPlatformConfig } from './config/index.js';
+import { ConfigurationError } from './errors/base.errors.js';
 
 export class SzPlatformService {
   public projectinfo: plugins.projectinfo.ProjectInfo;
@@ -17,29 +20,169 @@ export class SzPlatformService {
   public emailService: EmailService;
   public mtaService: MtaService;
   public smsService: SmsService;
+  
+  // Platform configuration
+  public config: IPlatformConfig;
 
-  public async start() {
-    this.platformserviceDb = new PlatformServiceDb(this);
+  /**
+   * Create a new platform service instance
+   * 
+   * @param config Optional platform configuration
+   */
+  constructor(config: IPlatformConfig) {
+    // Store configuration
+    this.config = config;
+    
+    // Initialize typed router
+    this.typedrouter = new plugins.typedrequest.TypedRouter();
+  }
+
+  /**
+   * Initialize the platform service
+   * Applies configuration provided in constructor
+   */
+  public async initialize(): Promise<void> {
+    // Simple validation of config - must be provided
+    if (!this.config) {
+      throw new ConfigurationError(
+        'Platform configuration must be provided in constructor',
+        'PLATFORM_CONFIG_MISSING',
+        {}
+      );
+    }
+    
+    // Apply configuration to logger
+    if (this.config.logging) {
+      logger.setContext({
+        environment: this.config.environment,
+        component: 'PlatformService'
+      });
+    }
+    
+    // Create project info
     this.projectinfo = new plugins.projectinfo.ProjectInfo(paths.packageDir);
     
-    // lets start the sub services
-    this.emailService = new EmailService(this);
-    this.mtaService = new MtaService(this);
-    this.smsService = new SmsService(this, {
-      apiGatewayApiToken: await this.serviceQenv.getEnvVarOnDemand('SMS_API_TOKEN'),
-    });
+    // Initialize database
+    this.platformserviceDb = new PlatformServiceDb(this);
     
-    // lets start the server finally
-    this.typedserver = new plugins.typedserver.TypedServer({
-      cors: true,
-    });
-    await this.typedserver.start();
+    logger.info('Platform service initialized successfully');
+  }
+
+  /**
+   * Start the platform service
+   */
+  public async start(): Promise<void> {
+    // Initialize first if needed
+    if (!this.config) {
+      await this.initialize();
+    }
+    
+    // Check if service is enabled
+    if (this.config.enabled === false) {
+      logger.warn('Platform service is disabled in configuration, not starting services');
+      return;
+    }
+    
+    logger.info('Starting platform service...');
+    
+    // Initialize sub-services
+    await this.initializeServices();
+    
+    // Start the HTTP server
+    await this.startServer();
+    
+    logger.info('Platform service started successfully');
   }
   
-  public async stop() {
+  /**
+   * Initialize and start sub-services
+   */
+  private async initializeServices(): Promise<void> {
+    // Initialize email service
+    if (this.config.email?.enabled !== false) {
+      this.emailService = new EmailService(this, this.config.email);
+      await this.emailService.start();
+      logger.info('Email service started');
+      
+      // Initialize MTA service if needed
+      if (this.config.email?.useMta) {
+        this.mtaService = new MtaService(this, this.config.email.mtaConfig);
+        logger.info('MTA service initialized');
+      }
+    } else {
+      logger.info('Email service disabled in configuration');
+    }
+    
+    // Initialize SMS service
+    if (this.config.sms?.enabled !== false) {
+      // Get API token from config or env var
+      const apiToken = this.config.sms?.apiGatewayApiToken || 
+        await this.serviceQenv.getEnvVarOnDemand('SMS_API_TOKEN');
+      
+      if (!apiToken) {
+        logger.warn('No SMS API token provided, SMS service will not be started');
+      } else {
+        this.smsService = new SmsService(this, {
+          apiGatewayApiToken: apiToken,
+          ...this.config.sms
+        });
+        await this.smsService.start();
+        logger.info('SMS service started');
+      }
+    } else {
+      logger.info('SMS service disabled in configuration');
+    }
+  }
+  
+  /**
+   * Start the HTTP server
+   */
+  private async startServer(): Promise<void> {
+    // Check if server is enabled
+    if (this.config.server?.enabled === false) {
+      logger.info('HTTP server disabled in configuration');
+      return;
+    }
+    
+    // Create server with configuration
+    this.typedserver = new plugins.typedserver.TypedServer({
+      cors: this.config.server?.cors === false ? false : true,
+      port: this.config.server?.port || 3000,
+      // hostname is not supported directly, will be set during start
+    });
+    
+    // Add the router
+    // Note: Using any type to bypass TypeScript restriction
+    (this.typedserver as any).addRouter(this.typedrouter);
+    
+    // Start server
+    await this.typedserver.start();
+    logger.info(`HTTP server started on ${this.config.server?.host || '0.0.0.0'}:${this.config.server?.port || 3000}`);
+  }
+  
+  /**
+   * Stop the platform service
+   */
+  public async stop(): Promise<void> {
+    logger.info('Stopping platform service...');
+    
+    // Stop sub-services
+    if (this.emailService) {
+      await this.emailService.stop();
+      logger.info('Email service stopped');
+    }
+    
+    if (this.smsService) {
+      await this.smsService.stop();
+      logger.info('SMS service stopped');
+    }
+    
     // Stop the server if it's running
     if (this.typedserver) {
       await this.typedserver.stop();
+      logger.info('HTTP server stopped');
     }
+    
+    logger.info('Platform service stopped successfully');
   }
 }