Multi-Vendor-Architektur¶

// backend-js/src/common/interfaces/vendor-adapter.interface.ts

export interface VendorAdapter {
  /** Gibt Vendor-Metadaten zurück (Name, Version, unterstützte Features). */
  getInfo(): VendorInfo;

  /** Gibt die vom Adapter unterstützten Fähigkeiten zurück. */
  capabilities(): VendorCapabilities;

  /** Entdeckt verfügbare Ressourcentypen und Konfigurationen. */
  discover(tenant: VendorTenant): Promise<DiscoveryResult>;

  /** Erfasst einen Point-in-Time Snapshot aller (oder ausgewaehlter) Konfigurationen. */
  capture(tenant: VendorTenant, options?: CaptureOptions): Promise<CaptureResult>;

  /** Erkennt Drift zwischen zwei Snapshots oder zwischen Snapshot und Live-Konfiguration. */
  detectDrift(tenant: VendorTenant, baseline: Snapshot, current?: Snapshot): Promise<DriftResult>;

  /** Wendet eine Konfiguration auf den Ziel-Tenant an (Rollback oder Blueprint). */
  apply(tenant: VendorTenant, configuration: any, options?: ApplyOptions): Promise<ApplyResult>;

  /** Ruft Audit Logs vom Vendor für Change Attribution ab. */
  getAuditLogs(tenant: VendorTenant, timeRange: TimeRange): Promise<AuditLogEntry[]>;
}

interface VendorInfo {
  vendorId: string;         // 'microsoft' | 'zscaler' | 'atlassian'
  displayName: string;      // 'Microsoft 365' | 'Zscaler' | 'Atlassian Cloud'
  version: string;          // Adapter-Version
  documentationUrl: string; // Link zur Vendor-Dokumentation
}

interface VendorCapabilities {
  canCapture: boolean;      // Snapshot Capture unterstützt
  canDetectDrift: boolean;  // Drift Detection unterstützt
  canApply: boolean;        // Rollback/Apply unterstützt
  canAudit: boolean;        // Audit Log-Abruf unterstützt
  canDiscover: boolean;     // Resource Discovery unterstützt
  supportedResourceTypes: string[]; // Liste der Ressourcentyp-Identifier
}

interface CaptureResult {
  success: boolean;
  data: Record<string, any>; // Ressourcentyp -> Konfigurationsdaten
  resourceCount: number;
  errors?: CaptureError[];
  duration: number;
}

@Injectable()
export class VendorAdapterRegistry {
  private adapters = new Map<string, VendorAdapter>();

  /** Registriert einen Vendor-Adapter. Wird bei Modulinitialisierung aufgerufen. */
  register(vendorId: string, adapter: VendorAdapter): void {
    this.adapters.set(vendorId, adapter);
  }

  /** Sucht einen Adapter nach Vendor ID. Wirft Exception, wenn nicht registriert. */
  get(vendorId: string): VendorAdapter {
    const adapter = this.adapters.get(vendorId);
    if (!adapter) {
      throw new NotFoundException(`No adapter registered for vendor: ${vendorId}`);
    }
    return adapter;
  }

  /** Gibt alle registrierten Vendor IDs zurück. */
  getRegisteredVendors(): string[] {
    return Array.from(this.adapters.keys());
  }

  /** Prüft, ob ein Vendor-Adapter registriert ist. */
  has(vendorId: string): boolean {
    return this.adapters.has(vendorId);
  }
}

@Module({
  providers: [M365Adapter, VendorAdapterRegistry],
})
export class M365Module implements OnModuleInit {
  constructor(
    private readonly registry: VendorAdapterRegistry,
    private readonly m365Adapter: M365Adapter,
  ) {}

  onModuleInit() {
    this.registry.register('microsoft', this.m365Adapter);
  }
}

// backend-js/src/entities/aws-vendor-tenant.entity.ts
@ChildEntity('aws')
export class AwsVendorTenant extends VendorTenant {
  @Column({ name: 'aws_account_id', nullable: true })
  awsAccountId: string;

  @Column({ name: 'aws_access_key_id', nullable: true })
  awsAccessKeyId: string;

  @Column({ name: 'aws_secret_access_key', nullable: true })
  awsSecretAccessKey: string;
}

@Injectable()
export class AwsAdapter implements VendorAdapter {
  getInfo(): VendorInfo {
    return {
      vendorId: 'aws',
      displayName: 'Amazon Web Services',
      version: '1.0.0',
      documentationUrl: 'https://docs.aws.amazon.com',
    };
  }

  capabilities(): VendorCapabilities {
    return {
      canCapture: true, canDetectDrift: true, canApply: true,
      canAudit: true, canDiscover: true,
      supportedResourceTypes: ['aws.iam.policies', 'aws.iam.roles', /* ... */],
    };
  }

  async discover(tenant: VendorTenant): Promise<DiscoveryResult> { /* ... */ }
  async capture(tenant: VendorTenant, options?: CaptureOptions): Promise<CaptureResult> { /* ... */ }
  async detectDrift(tenant: VendorTenant, baseline: Snapshot, current?: Snapshot): Promise<DriftResult> { /* ... */ }
  async apply(tenant: VendorTenant, config: any, options?: ApplyOptions): Promise<ApplyResult> { /* ... */ }
  async getAuditLogs(tenant: VendorTenant, timeRange: TimeRange): Promise<AuditLogEntry[]> { /* ... */ }
}

@Module({
  imports: [VendorRegistryModule],
  providers: [AwsAdapter, AwsApiClient],
  exports: [AwsAdapter],
})
export class AwsModule implements OnModuleInit {
  constructor(
    private readonly registry: VendorAdapterRegistry,
    private readonly awsAdapter: AwsAdapter,
  ) {}

  onModuleInit() {
    this.registry.register('aws', this.awsAdapter);
  }
}