@mcp-abap-adt/adt-backup 0.1.0

package/dist/lib/restore/restoreTreeBackup.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreTreeBackup = restoreTreeBackup;
+const logVerbose_1 = require("../cli/logVerbose");
+const typeOrder_1 = require("../constants/typeOrder");
+const flattenTree_1 = require("../tree/flattenTree");
+const getNodeObjectId_1 = require("../tree/getNodeObjectId");
+const restoreTreeNode_1 = require("./restoreTreeNode");
+const sortTreeNodesByDependencies_1 = require("./sortTreeNodesByDependencies");
+async function restoreTreeBackup(client, root, mode, activate, transportRequest, restoreIds, restoreActions, activateOnCreate = true, softwareComponent) {
+    const allNodes = (0, flattenTree_1.flattenTree)(root).filter((node) => node.type && node.restoreStatus === 'ok');
+    const nodes = restoreIds
+        ? allNodes.filter((node) => {
+            const id = (0, getNodeObjectId_1.getNodeObjectId)(node);
+            return id ? restoreIds.has(id) : false;
+        })
+        : allNodes;
+    // Separate packages from non-packages
+    // Packages keep their tree order (parent before children)
+    const packageNodes = nodes.filter((node) => node.type === 'package');
+    const nonPackageNodes = nodes.filter((node) => node.type !== 'package');
+    // Sort non-packages by dependencies or typeOrder
+    const priority = new Map(typeOrder_1.typeOrder.map((type, index) => [type, index]));
+    const hasDependencies = nonPackageNodes.some((node) => Array.isArray(node.usedBy) && node.usedBy.length > 0);
+    const sortedNonPackages = hasDependencies
+        ? (0, sortTreeNodesByDependencies_1.sortTreeNodesByDependencies)(nonPackageNodes)
+        : nonPackageNodes.sort((a, b) => {
+            const aOrder = a.type ? (priority.get(a.type) ?? 999) : 999;
+            const bOrder = b.type ? (priority.get(b.type) ?? 999) : 999;
+            return aOrder - bOrder || a.name.localeCompare(b.name);
+        });
+    // Packages first (in tree order), then sorted non-packages
+    const orderedNodes = [...packageNodes, ...sortedNonPackages];
+    // Collect package names from backup tree for inheritance logic
+    const backupPackageNames = new Set(packageNodes.map((node) => node.name));
+    (0, logVerbose_1.logVerbose)(2, `Restoring ${orderedNodes.length} node(s) from tree (mode=${mode}, activate=${activate})`);
+    (0, logVerbose_1.logVerbose)(2, `  Packages: ${packageNodes.length}, Other objects: ${sortedNonPackages.length}`);
+    const activationList = [];
+    for (const node of orderedNodes) {
+        (0, logVerbose_1.logVerbose)(3, `Restore ${node.type}:${node.name}`);
+        const nodeId = (0, getNodeObjectId_1.getNodeObjectId)(node);
+        const nodeMode = mode === 'upsert' && nodeId && restoreActions?.has(nodeId)
+            ? restoreActions.get(nodeId)
+            : mode;
+        const shouldActivate = nodeMode === 'create' ? activateOnCreate : activate;
+        const isPackage = node.type === 'package';
+        // Defer activation for non-package objects if activation is requested
+        const effectiveActivate = isPackage ? shouldActivate : false;
+        if (nodeMode === 'upsert') {
+            try {
+                await (0, restoreTreeNode_1.restoreTreeNode)(client, node, 'create', effectiveActivate, transportRequest, softwareComponent, backupPackageNames);
+            }
+            catch (_error) {
+                await (0, restoreTreeNode_1.restoreTreeNode)(client, node, 'update', effectiveActivate, transportRequest, softwareComponent, backupPackageNames);
+            }
+        }
+        else {
+            await (0, restoreTreeNode_1.restoreTreeNode)(client, node, nodeMode || mode, effectiveActivate, transportRequest, softwareComponent, backupPackageNames);
+        }
+        if (!isPackage && shouldActivate && node.adtType) {
+            activationList.push({ name: node.name, type: node.adtType });
+        }
+    }
+    if (activationList.length > 0) {
+        (0, logVerbose_1.logVerbose)(2, `Activating ${activationList.length} object(s)...`);
+        // Pass true for preauditRequested to check before activating
+        await client.getUtils().activateObjectsGroup(activationList, true);
+    }
+}

package/dist/lib/restore/restoreTreeNode.d.ts

@@ -0,0 +1,4 @@
+import type { AdtClient } from '@mcp-abap-adt/adt-clients';
+import type { BackupTreeNode, RestoreMode } from '../types';
+export declare function restoreTreeNode(client: AdtClient, node: BackupTreeNode, mode: RestoreMode, activate: boolean, transportRequest?: string, softwareComponentOverride?: string, backupPackageNames?: Set<string>): Promise<void>;
+//# sourceMappingURL=restoreTreeNode.d.ts.map

package/dist/lib/restore/restoreTreeNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restoreTreeNode.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAkBV,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAK5D,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAiUf"}

package/dist/lib/restore/restoreTreeNode.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreTreeNode = restoreTreeNode;
+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 applyTransportRequest_1 = require("./applyTransportRequest");
+async function restoreTreeNode(client, node, mode, activate, transportRequest, softwareComponentOverride, backupPackageNames) {
+    if (!node.type || node.restoreStatus !== 'ok') {
+        return;
+    }
+    const config = (0, applyTransportRequest_1.applyTransportRequest)((0, ensureDescription_1.ensureDescription)(node.config || {}, node.name), transportRequest);
+    const payload = node.codeBase64 ? (0, decodeBase64_1.decodeBase64)(node.codeBase64) : undefined;
+    const options = {
+        activateOnCreate: activate,
+        activateOnUpdate: activate,
+    };
+    try {
+        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.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 (softwareComponentOverride) {
+                    pkgConfig.softwareComponent = softwareComponentOverride;
+                }
+                else if (!pkgConfig.softwareComponent) {
+                    pkgConfig.softwareComponent = 'ZLOCAL';
+                }
+                (0, logVerbose_1.logVerbose)(3, `Package ${node.name}: final softwareComponent=${pkgConfig.softwareComponent}`);
+                if (mode !== 'update') {
+                    await client.getPackage().create(pkgConfig, options);
+                }
+                if (mode !== 'create') {
+                    await client.getPackage().update(pkgConfig, options);
+                }
+                return;
+            }
+            case 'domain': {
+                if (mode !== 'update') {
+                    await client
+                        .getDomain()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (mode !== 'create') {
+                    await client
+                        .getDomain()
+                        .update((0, asConfig_1.asConfig)(config), options);
+                }
+                return;
+            }
+            case 'dataElement': {
+                if (mode !== 'update') {
+                    await client
+                        .getDataElement()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (mode !== 'create') {
+                    await client
+                        .getDataElement()
+                        .update((0, asConfig_1.asConfig)(config), options);
+                }
+                return;
+            }
+            case 'structure': {
+                if (mode !== 'update') {
+                    await client
+                        .getStructure()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getStructure().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        ddlCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'table': {
+                if (mode !== 'update') {
+                    await client
+                        .getTable()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client
+                        .getTable()
+                        .update((0, asConfig_1.asConfig)({ ...config, ddlCode: payload }), options);
+                }
+                return;
+            }
+            case 'view': {
+                if (mode !== 'update') {
+                    await client.getView().create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client
+                        .getView()
+                        .update((0, asConfig_1.asConfig)({ ...config, ddlSource: payload }), options);
+                }
+                return;
+            }
+            case 'class': {
+                if (mode !== 'update') {
+                    await client
+                        .getClass()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getClass().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'interface': {
+                if (mode !== 'update') {
+                    await client
+                        .getInterface()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getInterface().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'program': {
+                if (mode !== 'update') {
+                    await client
+                        .getProgram()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getProgram().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'functionGroup': {
+                if (mode !== 'update') {
+                    await client
+                        .getFunctionGroup()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (mode !== 'create') {
+                    await client
+                        .getFunctionGroup()
+                        .update((0, asConfig_1.asConfig)(config), options);
+                }
+                return;
+            }
+            case 'functionModule': {
+                if (mode !== 'update') {
+                    await client
+                        .getFunctionModule()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getFunctionModule().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'serviceDefinition': {
+                if (mode !== 'update') {
+                    await client
+                        .getServiceDefinition()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getServiceDefinition().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'metadataExtension': {
+                if (mode !== 'update') {
+                    await client
+                        .getMetadataExtension()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getMetadataExtension().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'behaviorDefinition': {
+                if (mode !== 'update') {
+                    await client
+                        .getBehaviorDefinition()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getBehaviorDefinition().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'behaviorImplementation': {
+                if (mode !== 'update') {
+                    await client
+                        .getBehaviorImplementation()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getBehaviorImplementation().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'enhancement': {
+                if (mode !== 'update') {
+                    await client
+                        .getEnhancement()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (payload) {
+                    await client.getEnhancement().update((0, asConfig_1.asConfig)({
+                        ...config,
+                        sourceCode: payload,
+                    }), options);
+                }
+                return;
+            }
+            case 'tableType': {
+                if (mode !== 'update') {
+                    await client
+                        .getTableType()
+                        .create((0, asConfig_1.asConfig)(config), options);
+                }
+                if (mode !== 'create') {
+                    await client
+                        .getTableType()
+                        .update((0, asConfig_1.asConfig)(config), options);
+                }
+                return;
+            }
+        }
+    }
+    catch (error) {
+        if (error.response?.data) {
+            console.error(`Error restoring ${node.type}:${node.name}:`, typeof error.response.data === 'string'
+                ? error.response.data
+                : JSON.stringify(error.response.data, null, 2));
+        }
+        throw error;
+    }
+}

package/dist/lib/restore/sortByDependencies.d.ts

@@ -0,0 +1,3 @@
+import type { BackupObject } from '../types';
+export declare function sortByDependencies(objects: BackupObject[]): BackupObject[];
+//# sourceMappingURL=sortByDependencies.d.ts.map

package/dist/lib/restore/sortByDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortByDependencies.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/sortByDependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAsE1E"}

package/dist/lib/restore/sortByDependencies.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByDependencies = sortByDependencies;
+const typeOrder_1 = require("../constants/typeOrder");
+function sortByDependencies(objects) {
+    const idToObject = new Map(objects.map((obj) => [obj.id, obj]));
+    const dependencies = new Map();
+    const indegree = new Map();
+    for (const obj of objects) {
+        const deps = new Set((obj.dependsOn || []).filter((dep) => idToObject.has(dep)));
+        dependencies.set(obj.id, deps);
+        indegree.set(obj.id, deps.size);
+    }
+    const priority = new Map(typeOrder_1.typeOrder.map((type, index) => [type, index]));
+    const queue = objects
+        .filter((obj) => (indegree.get(obj.id) || 0) === 0)
+        .sort((a, b) => {
+        const aOrder = priority.get(a.type) ?? 999;
+        const bOrder = priority.get(b.type) ?? 999;
+        return aOrder - bOrder || a.id.localeCompare(b.id);
+    })
+        .map((obj) => obj.id);
+    const result = [];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (!id) {
+            continue;
+        }
+        const obj = idToObject.get(id);
+        if (!obj || visited.has(id)) {
+            continue;
+        }
+        visited.add(id);
+        result.push(obj);
+        for (const [otherId, deps] of dependencies.entries()) {
+            if (!deps.has(id)) {
+                continue;
+            }
+            deps.delete(id);
+            const nextIndegree = (indegree.get(otherId) || 0) - 1;
+            indegree.set(otherId, nextIndegree);
+            if (nextIndegree === 0) {
+                queue.push(otherId);
+                queue.sort((aId, bId) => {
+                    const aObj = idToObject.get(aId);
+                    const bObj = idToObject.get(bId);
+                    const aOrder = aObj ? (priority.get(aObj.type) ?? 999) : 999;
+                    const bOrder = bObj ? (priority.get(bObj.type) ?? 999) : 999;
+                    return aOrder - bOrder || aId.localeCompare(bId);
+                });
+            }
+        }
+    }
+    if (result.length !== objects.length) {
+        const remaining = objects.filter((obj) => !visited.has(obj.id));
+        remaining.sort((a, b) => {
+            const aOrder = priority.get(a.type) ?? 999;
+            const bOrder = priority.get(b.type) ?? 999;
+            return aOrder - bOrder || a.id.localeCompare(b.id);
+        });
+        result.push(...remaining);
+    }
+    return result;
+}

package/dist/lib/restore/sortTreeNodesByDependencies.d.ts

@@ -0,0 +1,3 @@
+import type { BackupTreeNode } from '../types';
+export declare function sortTreeNodesByDependencies(nodes: BackupTreeNode[]): BackupTreeNode[];
+//# sourceMappingURL=sortTreeNodesByDependencies.d.ts.map

package/dist/lib/restore/sortTreeNodesByDependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortTreeNodesByDependencies.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/sortTreeNodesByDependencies.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAI/C,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,cAAc,EAAE,GACtB,cAAc,EAAE,CAqGlB"}

package/dist/lib/restore/sortTreeNodesByDependencies.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortTreeNodesByDependencies = sortTreeNodesByDependencies;
+const typeOrder_1 = require("../constants/typeOrder");
+const getNodeObjectId_1 = require("../tree/getNodeObjectId");
+const objectId_1 = require("../utils/objectId");
+const parseObjectSpec_1 = require("../utils/parseObjectSpec");
+function sortTreeNodesByDependencies(nodes) {
+    const idToNode = new Map();
+    for (const node of nodes) {
+        const id = (0, getNodeObjectId_1.getNodeObjectId)(node);
+        if (id) {
+            idToNode.set(id, node);
+        }
+    }
+    const dependencies = new Map();
+    for (const id of idToNode.keys()) {
+        dependencies.set(id, new Set());
+    }
+    for (const node of nodes) {
+        const currentId = (0, getNodeObjectId_1.getNodeObjectId)(node);
+        if (!currentId || !node.usedBy) {
+            continue;
+        }
+        for (const usedBySpec of node.usedBy) {
+            let usedById;
+            try {
+                const spec = (0, parseObjectSpec_1.parseObjectSpec)(usedBySpec);
+                usedById = (0, objectId_1.objectId)(spec);
+            }
+            catch {
+                continue;
+            }
+            if (!idToNode.has(usedById) || usedById === currentId) {
+                continue;
+            }
+            const deps = dependencies.get(usedById);
+            if (deps) {
+                deps.add(currentId);
+            }
+        }
+    }
+    const indegree = new Map();
+    for (const [id, deps] of dependencies.entries()) {
+        indegree.set(id, deps.size);
+    }
+    const priority = new Map(typeOrder_1.typeOrder.map((type, index) => [type, index]));
+    const queue = Array.from(idToNode.entries())
+        .filter(([id]) => (indegree.get(id) || 0) === 0)
+        .sort(([, a], [, b]) => {
+        const aOrder = a.type ? (priority.get(a.type) ?? 999) : 999;
+        const bOrder = b.type ? (priority.get(b.type) ?? 999) : 999;
+        return aOrder - bOrder || a.name.localeCompare(b.name);
+    })
+        .map(([id]) => id);
+    const result = [];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (!id) {
+            continue;
+        }
+        const node = idToNode.get(id);
+        if (!node || visited.has(id)) {
+            continue;
+        }
+        visited.add(id);
+        result.push(node);
+        for (const [otherId, deps] of dependencies.entries()) {
+            if (!deps.has(id)) {
+                continue;
+            }
+            deps.delete(id);
+            const nextIndegree = (indegree.get(otherId) || 0) - 1;
+            indegree.set(otherId, nextIndegree);
+            if (nextIndegree === 0) {
+                queue.push(otherId);
+                queue.sort((aId, bId) => {
+                    const aNode = idToNode.get(aId);
+                    const bNode = idToNode.get(bId);
+                    const aOrder = aNode?.type ? (priority.get(aNode.type) ?? 999) : 999;
+                    const bOrder = bNode?.type ? (priority.get(bNode.type) ?? 999) : 999;
+                    return aOrder - bOrder || aId.localeCompare(bId);
+                });
+            }
+        }
+    }
+    if (result.length !== nodes.length) {
+        const remaining = nodes.filter((node) => {
+            const id = (0, getNodeObjectId_1.getNodeObjectId)(node);
+            return id ? !visited.has(id) : true;
+        });
+        remaining.sort((a, b) => {
+            const aOrder = a.type ? (priority.get(a.type) ?? 999) : 999;
+            const bOrder = b.type ? (priority.get(b.type) ?? 999) : 999;
+            return aOrder - bOrder || a.name.localeCompare(b.name);
+        });
+        result.push(...remaining);
+    }
+    return result;
+}

package/dist/lib/run.d.ts

@@ -0,0 +1,2 @@
+export declare function run(): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

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

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