cloudly/ts/manager.service/classes.servicemanager.ts

import type { Cloudly } from '../classes.cloudly.js';
import * as plugins from '../plugins.js';
import { Service } from './classes.service.js';

export class ServiceManager {
  public typedrouter = new plugins.typedrequest.TypedRouter();
  public cloudlyRef: Cloudly;

  get db() {
    return this.cloudlyRef.mongodbConnector.smartdataDb;
  }

  public CService = plugins.smartdata.setDefaultManagerForDoc(this, Service);

  constructor(cloudlyRef: Cloudly) {
    this.cloudlyRef = cloudlyRef;
    
    this.cloudlyRef.typedrouter.addTypedRouter(this.typedrouter);

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_GetServices>(
        'getServices',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const services = await this.CService.getInstances({});

          return {
            services: await Promise.all(
              services.map((service) => {
                return service.createSavableObject();
              })
            ),
          };
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_GetServiceById>(
        'getServiceById',
        async (dataArg) => {
          await plugins.smartguard.passGuardsOrReject(dataArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);
          const service = await Service.getInstance({
            id: dataArg.serviceId,
          });
          return {
            service: await service.createSavableObject(),
          };
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_GetServiceSecretBundlesAsFlatObject>(
        'getServiceSecretBundlesAsFlatObject',
        async (dataArg) => {
          const service = await Service.getInstance({
            id: dataArg.serviceId,
          });
          const flatKeyValueObject = await service.getSecretBundlesAsFlatObject(dataArg.environment);
          return {
            flatKeyValueObject: flatKeyValueObject,
          };
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_GetServiceRegistryTarget>(
        'getServiceRegistryTarget',
        async (dataArg) => {
          await plugins.smartguard.passGuardsOrReject(dataArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);
          const service = await Service.getInstance({
            id: dataArg.serviceId,
          });
          return {
            registryTarget: this.cloudlyRef.registryManager.getServiceRegistryTarget(
              service,
              dataArg.tag || service.data.imageVersion || 'latest',
            ),
          };
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_CreateService>(
        'createService',
        async (dataArg) => {
          await plugins.smartguard.passGuardsOrReject(dataArg, [
            this.cloudlyRef.authManager.adminIdentityGuard,
          ]);
          const service = await Service.createService(dataArg.serviceData);
          service.data.registryTarget = this.cloudlyRef.registryManager.getServiceRegistryTarget(
            service,
            service.data.imageVersion || 'latest',
          );
          await service.save();
          await this.cloudlyRef.coreflowManager.pushClusterConfigToConnectedCoreflows();
          return {
            service: await service.createSavableObject(),
          };
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_UpdateService>(
        'updateService',
        async (dataArg) => {
          await plugins.smartguard.passGuardsOrReject(dataArg, [
            this.cloudlyRef.authManager.adminIdentityGuard,
          ]);
          const service = await Service.getInstance({
            id: dataArg.serviceId,
          });
          service.data = {
            ...service.data,
            ...dataArg.serviceData,
          };
          service.data.registryTarget = this.cloudlyRef.registryManager.getServiceRegistryTarget(
            service,
            service.data.imageVersion || 'latest',
          );
          await service.save();
          await this.cloudlyRef.coreflowManager.pushClusterConfigToConnectedCoreflows();
          return {
            service: await service.createSavableObject(),
          };
        }
      )
    );

    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_DeleteServiceById>(
        'deleteServiceById',
        async (dataArg) => {
          await plugins.smartguard.passGuardsOrReject(dataArg, [
            this.cloudlyRef.authManager.adminIdentityGuard,
          ]);
          const service = await Service.getInstance({
            id: dataArg.serviceId,
          });
          
          // Remove DNS entries before deleting the service
          await service.removeDnsEntries();
          
          await service.delete();
          return {
            success: true,
          };
        }
      )
    );
  }

  public async start() {
    // ServiceManager is ready - handlers are already registered in constructor
    console.log('ServiceManager started');
  }

  public async stop() {
    // Cleanup if needed
    console.log('ServiceManager stopped');
  }
}