cloudly/ts/manager.domain/classes.domainmanager.ts

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

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

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

  public CDomain = plugins.smartdata.setDefaultManagerForDoc(this, Domain);

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

    // Get all domains
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.domain.IRequest_Any_Cloudly_GetDomains>(
        'getDomains',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const domains = await this.CDomain.getDomains();

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

    // Get domain by ID
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.domain.IRequest_Any_Cloudly_GetDomainById>(
        'getDomainById',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const domain = await this.CDomain.getDomainById(reqArg.domainId);
          if (!domain) {
            throw new Error(`Domain with id ${reqArg.domainId} not found`);
          }

          return {
            domain: await domain.createSavableObject(),
          };
        }
      )
    );

    // Create domain
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.domain.IRequest_Any_Cloudly_CreateDomain>(
        'createDomain',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          // Check if domain already exists
          const existingDomain = await this.CDomain.getDomainByName(reqArg.domainData.name);
          if (existingDomain) {
            throw new Error(`Domain ${reqArg.domainData.name} already exists`);
          }

          const domain = await this.CDomain.createDomain(reqArg.domainData);

          return {
            domain: await domain.createSavableObject(),
          };
        }
      )
    );

    // Update domain
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.domain.IRequest_Any_Cloudly_UpdateDomain>(
        'updateDomain',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const domain = await this.CDomain.updateDomain(
            reqArg.domainId,
            reqArg.domainData
          );

          return {
            domain: await domain.createSavableObject(),
          };
        }
      )
    );

    // Delete domain
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.domain.IRequest_Any_Cloudly_DeleteDomain>(
        'deleteDomain',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const success = await this.CDomain.deleteDomain(reqArg.domainId);

          return {
            success,
          };
        }
      )
    );

    // Verify domain
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.domain.IRequest_Any_Cloudly_VerifyDomain>(
        'verifyDomain',
        async (reqArg) => {
          await plugins.smartguard.passGuardsOrReject(reqArg, [
            this.cloudlyRef.authManager.validIdentityGuard,
          ]);

          const domain = await this.CDomain.getDomainById(reqArg.domainId);
          if (!domain) {
            throw new Error(`Domain with id ${reqArg.domainId} not found`);
          }

          const verificationResult = await domain.verifyDomain(reqArg.verificationMethod);

          return {
            domain: await domain.createSavableObject(),
            verificationResult,
          };
        }
      )
    );
  }

  /**
   * Initialize the domain manager
   */
  public async init() {
    console.log('Domain Manager initialized');
  }

  /**
   * Stop the domain manager
   */
  public async stop() {
    console.log('Domain Manager stopped');
  }

  /**
   * Get all active domains
   */
  public async getActiveDomains() {
    const domains = await this.CDomain.getInstances({
      'data.status': 'active',
    });
    return domains;
  }

  /**
   * Get domains that are expiring soon
   */
  public async getExpiringDomains(daysThreshold: number = 30) {
    const domains = await this.CDomain.getDomains();
    return domains.filter(domain => domain.isExpiringSoon(daysThreshold));
  }

  /**
   * Check if a domain name is available (not in our system)
   */
  public async isDomainAvailable(domainName: string): Promise<boolean> {
    const existingDomain = await this.CDomain.getDomainByName(domainName);
    return !existingDomain;
  }
}