@mcp-abap-adt/adt-backup 0.1.2 → 1.0.0

package/dist/lib/restore/restoreTreeNode.js

@@ -5,13 +5,34 @@ const logVerbose_1 = require("../cli/logVerbose");
 const decodeBase64_1 = require("../crypto/decodeBase64");
 const asConfig_1 = require("../utils/asConfig");
 const ensureDescription_1 = require("../utils/ensureDescription");
+const parseBdefSource_1 = require("../utils/parseBdefSource");
+const parsePackageConfig_1 = require("../xml/parsePackageConfig");
 const applyTransportRequest_1 = require("./applyTransportRequest");
-async function restoreTreeNode(client, node, mode, activate, transportRequest, softwareComponentOverride, backupPackageNames) {
+async function restoreTreeNode(client, node, mode, activate, transportRequest, softwareComponentOverride, backupPackageNames, superPackageOverride, transportLayerOverride) {
+    if (mode === 'skip') {
+        (0, logVerbose_1.logVerbose)(2, `  [SKIP] ${node.type}:${node.name}`);
+        return;
+    }
     if (!node.type || node.restoreStatus !== 'ok') {
         return;
     }
-    const config = (0, applyTransportRequest_1.applyTransportRequest)((0, ensureDescription_1.ensureDescription)(node.config || {}, node.name), transportRequest);
+    // Use existing config or try to extract from XML if missing
+    let nodeConfig = node.config;
+    if (!nodeConfig &&
+        node.codeBase64 &&
+        node.codeFormat === 'xml' &&
+        node.type === 'package') {
+        try {
+            const xml = (0, decodeBase64_1.decodeBase64)(node.codeBase64);
+            nodeConfig = (0, parsePackageConfig_1.parsePackageConfig)(xml);
+        }
+        catch (_e) {
+            (0, logVerbose_1.logVerbose)(2, `  Could not parse XML config for package ${node.name}`);
+        }
+    }
+    const config = (0, applyTransportRequest_1.applyTransportRequest)((0, ensureDescription_1.ensureDescription)(nodeConfig || {}, node.name), transportRequest);
     const payload = node.codeBase64 ? (0, decodeBase64_1.decodeBase64)(node.codeBase64) : undefined;
+    // Standard options for most objects
     const options = {
         activateOnCreate: activate,
         activateOnUpdate: activate,
@@ -20,30 +41,48 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
         switch (node.type) {
             case 'package': {
                 const pkgConfig = (0, asConfig_1.asConfig)(config);
-                // Remove responsible field - let system use current user
-                // (backup might have user that doesn't exist in target system)
+                if (!pkgConfig.packageName) {
+                    pkgConfig.packageName = node.name;
+                }
                 if (pkgConfig.responsible) {
                     delete pkgConfig.responsible;
                 }
-                // Check if this package's superPackage is within our backup tree
                 const superPackageInBackup = pkgConfig.superPackage &&
                     backupPackageNames?.has(pkgConfig.superPackage);
-                (0, logVerbose_1.logVerbose)(3, `Package ${node.name}: superPackage=${pkgConfig.superPackage}, softwareComponent=${pkgConfig.softwareComponent}, superPackageInBackup=${superPackageInBackup}`);
-                // Set softwareComponent for all packages
-                // Priority: CLI override > config value > default 'ZLOCAL'
-                // For sub-packages, use CLI override to ensure consistency with parent
+                if (!superPackageInBackup && superPackageOverride) {
+                    pkgConfig.superPackage = superPackageOverride;
+                }
                 if (softwareComponentOverride) {
                     pkgConfig.softwareComponent = softwareComponentOverride;
                 }
                 else if (!pkgConfig.softwareComponent) {
                     pkgConfig.softwareComponent = 'ZLOCAL';
                 }
-                (0, logVerbose_1.logVerbose)(3, `Package ${node.name}: final softwareComponent=${pkgConfig.softwareComponent}`);
+                // Fix for the transport layer mapping issue in adt-clients
+                if (transportLayerOverride) {
+                    pkgConfig.transportLayer = transportLayerOverride;
+                    pkgConfig.transport_layer = transportLayerOverride;
+                }
+                pkgConfig.recordChanges = true;
                 if (mode !== 'update') {
+                    if (!pkgConfig.superPackage && node.type === 'package') {
+                        throw new Error(`Package ${node.name} cannot be created: superPackage is missing.`);
+                    }
+                    (0, logVerbose_1.logVerbose)(3, `  Creating package ${node.name} (Layer: ${pkgConfig.transportLayer}, SoftwareComp: ${pkgConfig.softwareComponent})`);
                     await client.getPackage().create(pkgConfig, options);
+                    // Wait for SAP to commit the package to the database
+                    // ADT has no event subscription for creation completion
+                    await delay(2000);
                 }
                 if (mode !== 'create') {
-                    await client.getPackage().update(pkgConfig, options);
+                    try {
+                        await client.getPackage().update(pkgConfig, options);
+                    }
+                    catch (error) {
+                        const msg = error instanceof Error ? error.message : String(error);
+                        (0, logVerbose_1.logVerbose)(1, `  [SKIP] Package ${node.name} update skipped`);
+                        (0, logVerbose_1.logVerbose)(3, `    Reason: ${msg.slice(0, 200)}`);
+                    }
                 }
                 return;
             }
@@ -53,11 +92,10 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
                         .getDomain()
                         .create((0, asConfig_1.asConfig)(config), options);
                 }
-                if (mode !== 'create') {
-                    await client
-                        .getDomain()
-                        .update((0, asConfig_1.asConfig)(config), options);
-                }
+                // Always update to set datatype/length/decimals (create only registers the name)
+                await client
+                    .getDomain()
+                    .update((0, asConfig_1.asConfig)(config), options);
                 return;
             }
             case 'dataElement': {
@@ -66,11 +104,10 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
                         .getDataElement()
                         .create((0, asConfig_1.asConfig)(config), options);
                 }
-                if (mode !== 'create') {
-                    await client
-                        .getDataElement()
-                        .update((0, asConfig_1.asConfig)(config), options);
-                }
+                // Always update to set typeKind/typeName/dataType (create only registers the name)
+                await client
+                    .getDataElement()
+                    .update((0, asConfig_1.asConfig)(config), options);
                 return;
             }
             case 'structure': {
@@ -159,11 +196,10 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
                         .getFunctionGroup()
                         .create((0, asConfig_1.asConfig)(config), options);
                 }
-                if (mode !== 'create') {
-                    await client
-                        .getFunctionGroup()
-                        .update((0, asConfig_1.asConfig)(config), options);
-                }
+                // Always update to set properties (create only registers the name)
+                await client
+                    .getFunctionGroup()
+                    .update((0, asConfig_1.asConfig)(config), options);
                 return;
             }
             case 'functionModule': {
@@ -200,11 +236,29 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
                         .getServiceBinding()
                         .create((0, asConfig_1.asConfig)(config), options);
                 }
-                if (mode !== 'create') {
+                // Always update to set properties (create only registers the name)
+                try {
                     await client
                         .getServiceBinding()
                         .update((0, asConfig_1.asConfig)(config));
                 }
+                catch (updateError) {
+                    const msg = updateError instanceof Error
+                        ? updateError.message
+                        : String(updateError);
+                    if (mode === 'update' && msg.includes('404')) {
+                        // Object missing despite verify — fallback to create + update
+                        await client
+                            .getServiceBinding()
+                            .create((0, asConfig_1.asConfig)(config), options);
+                        await client
+                            .getServiceBinding()
+                            .update((0, asConfig_1.asConfig)(config));
+                    }
+                    else {
+                        throw updateError;
+                    }
+                }
                 return;
             }
             case 'metadataExtension': {
@@ -223,9 +277,19 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
             }
             case 'behaviorDefinition': {
                 if (mode !== 'update') {
+                    // Fill rootEntity/implementationType from source if missing in config
+                    let bdefConfig = config;
+                    if (payload && (!config.rootEntity || !config.implementationType)) {
+                        const parsed = (0, parseBdefSource_1.parseBdefSource)(payload);
+                        bdefConfig = {
+                            ...config,
+                            rootEntity: config.rootEntity || parsed.rootEntity,
+                            implementationType: config.implementationType || parsed.implementationType,
+                        };
+                    }
                     await client
                         .getBehaviorDefinition()
-                        .create((0, asConfig_1.asConfig)(config), options);
+                        .create((0, asConfig_1.asConfig)(bdefConfig), options);
                 }
                 if (payload) {
                     await client.getBehaviorDefinition().update((0, asConfig_1.asConfig)({
@@ -263,28 +327,43 @@ async function restoreTreeNode(client, node, mode, activate, transportRequest, s
                 }
                 return;
             }
-            case 'tableType': {
+            case 'accessControl': {
                 if (mode !== 'update') {
                     await client
-                        .getTableType()
+                        .getAccessControl()
                         .create((0, asConfig_1.asConfig)(config), options);
                 }
-                if (mode !== 'create') {
+                if (payload) {
+                    await client.getAccessControl().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'tableType': {
+                if (mode !== 'update') {
                     await client
                         .getTableType()
-                        .update((0, asConfig_1.asConfig)(config), options);
+                        .create((0, asConfig_1.asConfig)(config), options);
                 }
+                // Always update to set properties (create only registers the name)
+                await client
+                    .getTableType()
+                    .update((0, asConfig_1.asConfig)(config), options);
                 return;
             }
         }
     }
     catch (error) {
-        const err = error;
-        if (err.response?.data) {
-            console.error(`Error restoring ${node.type}:${node.name}:`, typeof err.response.data === 'string'
-                ? err.response.data
-                : JSON.stringify(err.response.data, null, 2));
+        const data = error.response?.data;
+        if (data) {
+            const errorMsg = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+            console.error(`Error restoring ${node.type}:${node.name}:\n${errorMsg}`);
         }
         throw error;
     }
 }
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/lib/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/lib/run.ts"],"names":[],"mappings":"AAqDA,wBAAsB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CA4wBzC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/lib/run.ts"],"names":[],"mappings":"AAiDA,wBAAsB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAsoBzC"}