@contiva/sap-integration-suite-client/dist/wrapper/custom/integration-content-advanced-client.d.ts

SAP Cloud Platform Integration API Client

/**
 * SAP Integration Content Advanced Client
 *
 * Diese Datei enthält erweiterte Methoden für die Integration Content APIs von SAP Cloud Integration.
 * Diese Methoden sind Erweiterungen der grundlegenden API-Funktionen und bieten zusammengesetzte Operationen.
 *
 * @module sap-integration-suite-client/integration-content-advanced
 */
import { ComSapHciApiIntegrationPackage, ComSapHciApiIntegrationDesigntimeArtifact, ComSapHciApiScriptCollectionDesigntimeArtifact, ComSapHciApiMessageMappingDesigntimeArtifact, ComSapHciApiValueMappingDesigntimeArtifact } from '../../types/sap.IntegrationContent';
import { PackageWithArtifacts, DetailedErrorInformation, ParsedErrorDetails } from '../../types/sap.ContentClient';
import { IntegrationContentClient } from '../integration-content-client';
import { BaseCustomClient, CustomClientFactory } from './base-custom-client';
/**
 * Progress-Event-Typen für getPackagesWithArtifacts
 */
export type ProgressEventType = 'packages:loaded' | 'step:start' | 'step:complete' | 'package:processing';
/**
 * Progress-Event-Daten
 */
export interface ProgressEvent {
    type: ProgressEventType;
    step?: 'messageMappings' | 'valueMappings' | 'flows' | 'scripts';
    totalPackages?: number;
    packages?: Array<{
        id: string;
        name: string;
    }>;
    currentPackage?: {
        id: string;
        name: string;
        index: number;
    };
    completedPackages?: number;
    progress?: number;
}
/**
 * Progress-Callback-Funktion
 */
export type OnProgressCallback = (event: ProgressEvent) => void;
/**
 * Erweiterter SAP Integration Content Client
 *
 * Diese Klasse stellt erweiterte, zusammengesetzte Operationen für die Interaktion
 * mit den SAP Integration Content APIs bereit.
 */
export declare class IntegrationContentAdvancedClient extends BaseCustomClient<IntegrationContentClient> {
    /** Counter für 429 Rate Limit Fehler */
    private rateLimitErrors;
    /**
     * Erstellt einen neuen IntegrationContentAdvancedClient
     *
     * @param {IntegrationContentClient} client - Die zugrundeliegende Client-Instanz
     */
    constructor(client: IntegrationContentClient);
    /**
     * Gibt die Anzahl der 429 Rate Limit Fehler zurück
     *
     * @returns {number} Anzahl der Rate Limit Fehler
     */
    getRateLimitErrorCount(): number;
    /**
     * Setzt den Rate Limit Error Counter zurück
     */
    resetRateLimitErrorCount(): void;
    /**
     * Ruft alle Integrationspakete mit ihren zugehörigen Artefakten ab
     *
     * Diese Methode holt alle Integrationspakete und sammelt für jedes Paket:
     * - Integrationsflows
     * - Message Mappings
     * - Value Mappings
     * - Script Collections
     *
     * **Optimierungen:**
     * - MessageMappings & ValueMappings werden über globale Endpunkte abgerufen (nur 2 API-Calls)
     * - IntegrationFlows & ScriptCollections werden mit Concurrency-Limit abgerufen
     * - Bis zu 50% weniger API-Aufrufe im Vergleich zur nicht-optimierten Variante
     *
     * **Best Practices:**
     * - Für kleine bis mittlere Systeme (bis 100 Packages): `concurrency: 7-10`
     * - Für größere Systeme: Starte mit `concurrency: 5` und erhöhe schrittweise
     * - 429 Rate Limit Fehler können mit `getRateLimitErrorCount()` überwacht werden
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete
     * @param {number} [options.skip] Anzahl der zu überspringenden Pakete
     * @param {boolean} [options.includeEmpty=false] Ob leere Pakete ohne Artefakte inkludiert werden sollen
     * @param {boolean} [options.parallel=false] Ob die Artefakte parallel abgerufen werden sollen (schneller, aber möglicherweise API-Limits)
     * @param {number} [options.concurrency=2] Maximale Anzahl paralleler Requests (nur bei parallel=true). Default: 7 (optimal für die meisten Systeme)
     * @returns {Promise<PackageWithArtifacts[]>} Liste von Paketen mit ihren Artefakten
     *
     * @example
     * // Alle Pakete mit ihren Artefakten abrufen (sequentiell)
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts();
     *
     * // Nur die ersten 5 Pakete mit Artefakten abrufen
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts({ top: 5 });
     *
     * // Alle Pakete mit parallelen API-Aufrufen abrufen (mit optimalem Concurrency Limit)
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts({ parallel: true, concurrency: 7 });
     *
     * // 429 Rate Limit Fehler überwachen
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts({ parallel: true });
     * const rateLimitErrors = client.getRateLimitErrorCount();
     * if (rateLimitErrors > 0) {
     *   console.warn(`${rateLimitErrors} Rate Limit Fehler aufgetreten - reduziere Concurrency`);
     * }
     *
     * // Mit Progress-Callback für Echtzeit-Fortschrittsmeldungen
     * const packagesWithArtifacts = await client.getPackagesWithArtifacts({
     *   parallel: true,
     *   onProgress: (event) => {
     *     if (event.type === 'packages:loaded') {
     *       console.log(`${event.totalPackages} Packages gefunden`);
     *     } else if (event.type === 'step:start') {
     *       console.log(`Lade ${event.step}...`);
     *     } else if (event.type === 'package:processing') {
     *       console.log(`Verarbeite ${event.currentPackage?.name} (${event.currentPackage?.index + 1}/${event.totalPackages})`);
     *     }
     *   }
     * });
     */
    getPackagesWithArtifacts(options?: {
        top?: number;
        skip?: number;
        includeEmpty?: boolean;
        parallel?: boolean;
        concurrency?: number;
        onProgress?: OnProgressCallback;
    }): Promise<PackageWithArtifacts[]>;
    /**
     * Hilfsmethode: Führt Promises mit Concurrency-Limit aus
     *
     * @private
     * @param tasks Array von Promise-Factories
     * @param concurrency Maximale Anzahl paralleler Promises
     * @returns Promise mit allen Ergebnissen
     */
    private executWithConcurrency;
    /**
     * Ruft alle Integrationsflows aller Pakete mit Concurrency-Limit ab
     *
     * @private
     * @param {Object} options Parameter für die Anfrage
     * @param {ComSapHciApiIntegrationPackage[]} options.packages Pakete
     * @param {number} options.concurrency Maximale Anzahl paralleler Requests
     * @returns {Promise<ComSapHciApiIntegrationDesigntimeArtifact[]>} Liste aller Integrationsflows
     */
    private getAllIntegrationFlowsWithConcurrency;
    /**
     * Ruft alle Script Collections aller Pakete mit Concurrency-Limit ab
     *
     * @private
     * @param {Object} options Parameter für die Anfrage
     * @param {ComSapHciApiIntegrationPackage[]} options.packages Pakete
     * @param {number} options.concurrency Maximale Anzahl paralleler Requests
     * @returns {Promise<ComSapHciApiScriptCollectionDesigntimeArtifact[]>} Liste aller Script Collections
     */
    private getAllScriptCollectionsWithConcurrency;
    /**
     * Ruft alle Integrationsflows aller Pakete ab
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete für die Abfrage
     * @param {ComSapHciApiIntegrationPackage[]} [options.packages] Bereits abgerufene Pakete, um redundante API-Aufrufe zu vermeiden
     * @returns {Promise<ComSapHciApiIntegrationDesigntimeArtifact[]>} Liste aller Integrationsflows
     *
     * @example
     * const allFlows = await client.getAllIntegrationFlows();
     *
     * // Mit bereits vorhandenen Paketen
     * const packages = await client.getIntegrationPackages();
     * const allFlows = await client.getAllIntegrationFlows({ packages });
     */
    getAllIntegrationFlows(options?: {
        top?: number;
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiIntegrationDesigntimeArtifact[]>;
    /**
     * Ruft alle Script Collections aller Pakete ab
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Pakete für die Abfrage
     * @param {ComSapHciApiIntegrationPackage[]} [options.packages] Bereits abgerufene Pakete, um redundante API-Aufrufe zu vermeiden
     * @returns {Promise<ComSapHciApiScriptCollectionDesigntimeArtifact[]>} Liste aller Script Collections
     *
     * @example
     * const allScriptCollections = await client.getAllScriptCollections();
     *
     * // Mit bereits vorhandenen Paketen
     * const packages = await client.getIntegrationPackages();
     * const allScripts = await client.getAllScriptCollections({ packages });
     */
    getAllScriptCollections(options?: {
        top?: number;
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiScriptCollectionDesigntimeArtifact[]>;
    /**
     * Gibt alle Message Mappings (tenant-weit) zurück.
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Mappings
     * @param {number} [options.skip] Anzahl der zu überspringenden Mappings
     * @param {string} [options.select] Zu selektierende Properties
     * @param {string} [options.orderby] Sortierreihenfolge
     * @returns {Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>} Promise mit einer Liste von Message Mappings
     *
     * @example
     * const allMappings = await client.getAllMessageMappings({ top: 50 });
     */
    getAllMessageMappings(options?: {
        top?: number;
        skip?: number;
        select?: ("Id" | "Version" | "PackageId" | "Name" | "Description" | "ArtifactContent")[];
        orderby?: ("Name" | "Name desc")[];
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiMessageMappingDesigntimeArtifact[]>;
    /**
     * Gibt alle Value Mappings (tenant-weit) zurück.
     *
     * @param {Object} options Optionale Parameter für die Anfrage
     * @param {number} [options.top] Maximale Anzahl der zurückzugebenden Mappings
     * @param {number} [options.skip] Anzahl der zu überspringenden Mappings
     * @param {string} [options.select] Zu selektierende Properties
     * @param {string} [options.orderby] Sortierreihenfolge
     * @returns {Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>} Promise mit einer Liste von Value Mappings
     *
     * @example
     * const allValueMappings = await client.getAllValueMappings({ top: 20 });
     */
    getAllValueMappings(options?: {
        top?: number;
        skip?: number;
        select?: ("Id" | "Version" | "PackageId" | "Name" | "Description" | "ArtifactContent")[];
        orderby?: ("Name" | "Name desc")[];
        packages?: ComSapHciApiIntegrationPackage[];
    }): Promise<ComSapHciApiValueMappingDesigntimeArtifact[]>;
    /**
     * Gibt detaillierte Fehlerinformationen für ein deployten Integrationsartefakt zurück
     * Diese Methode ruft den spezifischen $value-Endpunkt auf, der mehr Details enthält
     *
     * @param {string} artifactId ID des deployten Integrationsartefakts
     * @returns {Promise<DetailedErrorInformation | null>} Promise mit den detaillierten Fehlerinformationen oder null bei Fehlern
     *
     * @example
     * const detailedError = await client.getDetailedArtifactErrorInformation('MyFailedFlow');
     * if (detailedError && detailedError.message) {
     *   console.log(`Fehlertyp: ${detailedError.message.messageId}`);
     *   if (detailedError.parameter && detailedError.parameter.length > 0) {
     *     try {
     *       const paramJson = JSON.parse(detailedError.parameter[0]);
     *       console.log(`Fehlermeldung: ${paramJson.message}`);
     *     } catch (e) {
     *       console.log(`Parameter: ${detailedError.parameter[0]}`);
     *     }
     *   }
     * }
     */
    getDetailedArtifactErrorInformation(artifactId: string): Promise<DetailedErrorInformation | null>;
    /**
     * Parst die Fehlerdetails aus den Parametern einer DetailedErrorInformation
     *
     * @param {DetailedErrorInformation} errorInfo Die detaillierten Fehlerinformationen
     * @returns {ParsedErrorDetails | null} Die geparsten Fehlerdetails oder null, wenn keine Parameter vorhanden oder das Parsing fehlschlägt
     *
     * @example
     * const detailedError = await client.getDetailedArtifactErrorInformation('MyFailedFlow');
     * if (detailedError) {
     *   const errorDetails = client.parseErrorDetails(detailedError);
     *   if (errorDetails && errorDetails.message) {
     *     console.log(`Fehlermeldung: ${errorDetails.message}`);
     *
     *     if (errorDetails.childMessageInstances && errorDetails.childMessageInstances.length > 0) {
     *       console.log(`Hauptursache: ${errorDetails.childMessageInstances[0].message}`);
     *     }
     *   }
     * }
     */
    parseErrorDetails(errorInfo: DetailedErrorInformation): ParsedErrorDetails | null;
}
/**
 * Factory für die Erstellung von IntegrationContentAdvancedClient-Instanzen
 */
export declare class IntegrationContentAdvancedClientFactory implements CustomClientFactory<IntegrationContentClient, IntegrationContentAdvancedClient> {
    /**
     * Erstellt eine neue IntegrationContentAdvancedClient-Instanz
     *
     * @param baseClient - Der zugrundeliegende Standard-Client
     * @returns Ein IntegrationContentAdvancedClient
     */
    create(baseClient: IntegrationContentClient): IntegrationContentAdvancedClient;
}