@contiva/sap-integration-suite-client
Version:
SAP Cloud Platform Integration API Client
367 lines (366 loc) • 17.7 kB
JavaScript
;
/**
* 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
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.IntegrationContentAdvancedClientFactory = exports.IntegrationContentAdvancedClient = void 0;
const base_custom_client_1 = require("./base-custom-client");
/**
* Erweiterter SAP Integration Content Client
*
* Diese Klasse stellt erweiterte, zusammengesetzte Operationen für die Interaktion
* mit den SAP Integration Content APIs bereit.
*/
class IntegrationContentAdvancedClient extends base_custom_client_1.BaseCustomClient {
/**
* Erstellt einen neuen IntegrationContentAdvancedClient
*
* @param {IntegrationContentClient} client - Die zugrundeliegende Client-Instanz
*/
constructor(client) {
super(client);
}
/**
* 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
*
* @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)
* @returns {Promise<PackageWithArtifacts[]>} Liste von Paketen mit ihren Artefakten
*
* @example
* // Alle Pakete mit ihren Artefakten abrufen
* 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 (schneller)
* const packagesWithArtifacts = await client.getPackagesWithArtifacts({ parallel: true });
*/
async getPackagesWithArtifacts(options = {}) {
// Hole alle Integrationspakete
const packages = await this.client.getIntegrationPackages({
top: options.top,
skip: options.skip
});
// Wenn keine Pakete gefunden wurden, direkt leeres Array zurückgeben
if (packages.length === 0) {
return [];
}
// Map von PackageId -> Package erstellen für einfacheren Zugriff
const packageMap = new Map();
for (const pkg of packages) {
if (pkg.Id) {
packageMap.set(pkg.Id, pkg);
}
}
// Array für das Ergebnis mit erweiterter Struktur
const result = packages.map(pkg => ({
package: {
...pkg,
IntegrationDesigntimeArtifacts: [],
MessageMappingDesigntimeArtifacts: [],
ValueMappingDesigntimeArtifacts: [],
ScriptCollectionDesigntimeArtifacts: []
}
}));
// Direktes Mapping von PackageId zu Result-Index
const packageIndexMap = new Map();
packages.forEach((pkg, index) => {
if (pkg.Id) {
packageIndexMap.set(pkg.Id, index);
}
});
try {
if (options.parallel) {
// Hole alle Artefakte parallel für alle Pakete
// Dies ist schneller, kann aber API-Limits überschreiten
const [allFlows, allMessageMappings, allValueMappings, allScriptCollections] = await Promise.all([
this.getAllIntegrationFlows({ packages }),
this.getAllMessageMappings({ packages }),
this.getAllValueMappings({ packages }),
this.getAllScriptCollections({ packages })
]);
// Sortiere Flows nach PackageId
for (const flow of allFlows) {
if (flow.PackageId && packageIndexMap.has(flow.PackageId)) {
const index = packageIndexMap.get(flow.PackageId);
result[index].package.IntegrationDesigntimeArtifacts.push(flow);
}
}
// Sortiere Message Mappings nach PackageId
for (const mapping of allMessageMappings) {
if (mapping.PackageId && packageIndexMap.has(mapping.PackageId)) {
const index = packageIndexMap.get(mapping.PackageId);
result[index].package.MessageMappingDesigntimeArtifacts.push(mapping);
}
}
// Sortiere Value Mappings nach PackageId
for (const mapping of allValueMappings) {
if (mapping.PackageId && packageIndexMap.has(mapping.PackageId)) {
const index = packageIndexMap.get(mapping.PackageId);
result[index].package.ValueMappingDesigntimeArtifacts.push(mapping);
}
}
// Sortiere Script Collections nach PackageId
for (const script of allScriptCollections) {
if (script.PackageId && packageIndexMap.has(script.PackageId)) {
const index = packageIndexMap.get(script.PackageId);
result[index].package.ScriptCollectionDesigntimeArtifacts.push(script);
}
}
}
else {
// Sequentieller Ansatz wie bisher, aber optimiert mit Try-Catch
for (const [i, pkg] of packages.entries()) {
const packageId = pkg.Id;
try {
// Hole alle Artefakte für dieses Paket
result[i].package.IntegrationDesigntimeArtifacts = await this.client.getIntegrationFlows(packageId).catch(() => []);
}
catch (error) {
console.error(`Fehler beim Abrufen der Integrationsflows für Paket ${packageId}:`, error);
result[i].package.IntegrationDesigntimeArtifacts = [];
}
try {
result[i].package.MessageMappingDesigntimeArtifacts = await this.client.getMessageMappings(packageId).catch(() => []);
}
catch (error) {
console.error(`Fehler beim Abrufen der Message Mappings für Paket ${packageId}:`, error);
result[i].package.MessageMappingDesigntimeArtifacts = [];
}
try {
result[i].package.ValueMappingDesigntimeArtifacts = await this.client.getValueMappings(packageId).catch(() => []);
}
catch (error) {
console.error(`Fehler beim Abrufen der Value Mappings für Paket ${packageId}:`, error);
result[i].package.ValueMappingDesigntimeArtifacts = [];
}
try {
result[i].package.ScriptCollectionDesigntimeArtifacts = await this.client.getScriptCollections(packageId).catch(() => []);
}
catch (error) {
console.error(`Fehler beim Abrufen der Script Collections für Paket ${packageId}:`, error);
result[i].package.ScriptCollectionDesigntimeArtifacts = [];
}
}
}
// Entferne leere Pakete, wenn includeEmpty=false
if (!options.includeEmpty) {
return result.filter(item => item.package.IntegrationDesigntimeArtifacts.length > 0 ||
item.package.MessageMappingDesigntimeArtifacts.length > 0 ||
item.package.ValueMappingDesigntimeArtifacts.length > 0 ||
item.package.ScriptCollectionDesigntimeArtifacts.length > 0);
}
return result;
}
catch (error) {
console.error(`Fehler beim Abrufen der Artefakte:`, error);
throw error;
}
}
/**
* 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 });
*/
async getAllIntegrationFlows(options = {}) {
// Verwende übergebene Pakete oder hole sie, wenn nicht vorhanden
const packages = options.packages || await this.client.getIntegrationPackages({ top: options.top });
// Sammel alle Flows
const allFlows = [];
// Arrays von Promises für Promise.all
const promises = packages.map(pkg => this.client.getIntegrationFlows(pkg.Id)
.then(flows => allFlows.push(...flows))
.catch(error => {
console.error(`Fehler beim Abrufen der Flows für Paket ${pkg.Id}:`, error);
return []; // Fehler ignorieren
}));
// Warte auf alle Promises
await Promise.all(promises);
return allFlows;
}
/**
* 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 });
*/
async getAllScriptCollections(options = {}) {
// Verwende übergebene Pakete oder hole sie, wenn nicht vorhanden
const packages = options.packages || await this.client.getIntegrationPackages({ top: options.top });
// Sammel alle Script Collections
const allScripts = [];
// Arrays von Promises für Promise.all
const promises = packages.map(pkg => this.client.getScriptCollections(pkg.Id)
.then(scripts => allScripts.push(...scripts))
.catch(error => {
console.error(`Fehler beim Abrufen der Script Collections für Paket ${pkg.Id}:`, error);
return []; // Fehler ignorieren
}));
// Warte auf alle Promises
await Promise.all(promises);
return allScripts;
}
/**
* 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 });
*/
async getAllMessageMappings(options = {}) {
// Wenn Pakete vorhanden sind, hole Mappings paketweise, ansonsten über die zentrale API
if (options.packages && options.packages.length > 0) {
const allMappings = [];
// Arrays von Promises für Promise.all
const promises = options.packages.map(pkg => this.client.getMessageMappings(pkg.Id)
.then(mappings => allMappings.push(...mappings))
.catch(error => {
console.error(`Fehler beim Abrufen der Message Mappings für Paket ${pkg.Id}:`, error);
return []; // Fehler ignorieren
}));
// Warte auf alle Promises
await Promise.all(promises);
return allMappings;
}
else {
// Über die zentrale API mit den ursprünglichen Parametern
return this.client.getAllMessageMappings(options);
}
}
/**
* 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 });
*/
async getAllValueMappings(options = {}) {
// Wenn Pakete vorhanden sind, hole Mappings paketweise, ansonsten über die zentrale API
if (options.packages && options.packages.length > 0) {
const allMappings = [];
// Arrays von Promises für Promise.all
const promises = options.packages.map(pkg => this.client.getValueMappings(pkg.Id)
.then(mappings => allMappings.push(...mappings))
.catch(error => {
console.error(`Fehler beim Abrufen der Value Mappings für Paket ${pkg.Id}:`, error);
return []; // Fehler ignorieren
}));
// Warte auf alle Promises
await Promise.all(promises);
return allMappings;
}
else {
// Über die zentrale API mit den ursprünglichen Parametern
return this.client.getAllValueMappings(options);
}
}
/**
* 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]}`);
* }
* }
* }
*/
async getDetailedArtifactErrorInformation(artifactId) {
return this.client.getDetailedArtifactErrorInformation(artifactId);
}
/**
* 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) {
return this.client.parseErrorDetails(errorInfo);
}
}
exports.IntegrationContentAdvancedClient = IntegrationContentAdvancedClient;
/**
* Factory für die Erstellung von IntegrationContentAdvancedClient-Instanzen
*/
class IntegrationContentAdvancedClientFactory {
/**
* Erstellt eine neue IntegrationContentAdvancedClient-Instanz
*
* @param baseClient - Der zugrundeliegende Standard-Client
* @returns Ein IntegrationContentAdvancedClient
*/
create(baseClient) {
return new IntegrationContentAdvancedClient(baseClient);
}
}
exports.IntegrationContentAdvancedClientFactory = IntegrationContentAdvancedClientFactory;