@sap-ux/adp-tooling 0.15.37 → 0.16.0

package/dist/cf/project/yaml.js

@@ -0,0 +1,436 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMtaProject = isMtaProject;
+exports.getSAPCloudService = getSAPCloudService;
+exports.getRouterType = getRouterType;
+exports.getAppParamsFromUI5Yaml = getAppParamsFromUI5Yaml;
+exports.adjustMtaYaml = adjustMtaYaml;
+const node_fs_1 = __importDefault(require("node:fs"));
+const path = __importStar(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const types_1 = require("../../types");
+const api_1 = require("../services/api");
+const yaml_loader_1 = require("./yaml-loader");
+const CF_MANAGED_SERVICE = 'org.cloudfoundry.managed-service';
+const HTML5_APPS_REPO = 'html5-apps-repo';
+const SAP_APPLICATION_CONTENT = 'com.sap.application.content';
+/**
+ * Checks if the selected path is a MTA project.
+ *
+ * @param {string} selectedPath - The selected path.
+ * @returns {boolean} True if the selected path is a MTA project, false otherwise.
+ */
+function isMtaProject(selectedPath) {
+    return node_fs_1.default.existsSync(path.join(selectedPath, 'mta.yaml'));
+}
+/**
+ * Gets the SAP Cloud Service.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @returns {string} The SAP Cloud Service.
+ */
+function getSAPCloudService(yamlContent) {
+    const modules = yamlContent?.modules?.filter((module) => module.name.includes('destination-content'));
+    const destinations = modules?.[0]?.parameters?.content?.instance?.destinations;
+    const mtaDestination = destinations?.find((destination) => destination.Name.includes('html_repo_host'));
+    const sapCloudService = mtaDestination?.['sap.cloud.service']?.replaceAll('_', '.') ?? '';
+    return sapCloudService;
+}
+/**
+ * Gets the router type.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @returns {AppRouterType} The router type.
+ */
+function getRouterType(yamlContent) {
+    const filtered = yamlContent?.modules?.filter((module) => module.name.includes('destination-content') || module.name.includes('approuter'));
+    const routerType = filtered?.pop();
+    if (routerType?.name.includes('approuter')) {
+        return types_1.AppRouterType.STANDALONE;
+    }
+    else {
+        return types_1.AppRouterType.MANAGED;
+    }
+}
+/**
+ * Gets the app params from the UI5 YAML file.
+ *
+ * @param {string} projectPath - The project path.
+ * @returns {AppParamsExtended} The app params.
+ */
+function getAppParamsFromUI5Yaml(projectPath) {
+    const ui5YamlPath = path.join(projectPath, 'ui5.yaml');
+    const parsedYaml = (0, yaml_loader_1.getYamlContent)(ui5YamlPath);
+    const appConfiguration = parsedYaml?.builder?.customTasks?.[0]?.configuration;
+    const appParams = {
+        appHostId: appConfiguration?.appHostId || '',
+        appName: appConfiguration?.appVersion || '',
+        appVersion: appConfiguration?.appVersion || '',
+        spaceGuid: appConfiguration?.space || ''
+    };
+    return appParams;
+}
+/**
+ * Adjusts the MTA YAML for a standalone approuter.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @param {string} projectName - The project name.
+ * @param {string} businessService - The business service.
+ */
+function adjustMtaYamlStandaloneApprouter(yamlContent, projectName, businessService) {
+    const appRouterName = `${projectName}-approuter`;
+    let appRouter = yamlContent.modules?.find((module) => module.name === appRouterName);
+    if (appRouter == null) {
+        appRouter = {
+            name: appRouterName,
+            type: 'approuter.nodejs',
+            path: appRouterName,
+            requires: [],
+            parameters: {
+                'disk-quota': '256M',
+                'memory': '256M'
+            }
+        };
+        yamlContent.modules?.push(appRouter);
+    }
+    const requires = [
+        `${projectName}_html_repo_runtime`,
+        `${projectName}_uaa`,
+        `portal_resources_${projectName}`
+    ].concat(businessService);
+    for (const name of requires) {
+        if (appRouter.requires?.every((existing) => existing.name !== name)) {
+            appRouter.requires?.push({ name });
+        }
+    }
+}
+/**
+ * Adjusts the MTA YAML for a managed approuter.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @param {string} projectName - The project name.
+ * @param {string} businessSolution - The business solution.
+ * @param {string} businessService - The business service.
+ * @param {string} timestamp - The timestamp.
+ */
+function adjustMtaYamlManagedApprouter(yamlContent, projectName, businessSolution, businessService, timestamp) {
+    const projectNameForXsSecurity = (0, yaml_loader_1.getProjectNameForXsSecurity)(yamlContent, timestamp);
+    const appRouterName = `${projectName}-destination-content`;
+    let appRouter = yamlContent.modules?.find((module) => module.name === appRouterName);
+    if (appRouter == null) {
+        businessSolution = businessSolution.split('.').join('_');
+        appRouter = {
+            name: appRouterName,
+            type: SAP_APPLICATION_CONTENT,
+            requires: [
+                {
+                    name: `${projectName}_uaa`,
+                    parameters: {
+                        'service-key': {
+                            name: `${projectName}-uaa-key`
+                        }
+                    }
+                },
+                {
+                    name: `${projectName}_html_repo_host`,
+                    parameters: {
+                        'service-key': {
+                            name: `${projectName}-html_repo_host-key`
+                        }
+                    }
+                },
+                {
+                    name: `${projectName}-destination`,
+                    parameters: {
+                        'content-target': true
+                    }
+                },
+                {
+                    name: `${businessService}`,
+                    parameters: {
+                        'service-key': {
+                            name: `${businessService}-key`
+                        }
+                    }
+                }
+            ],
+            'build-parameters': {
+                'no-source': true
+            },
+            parameters: {
+                content: {
+                    instance: {
+                        destinations: [
+                            {
+                                Name: `${businessSolution}-${projectName}-html_repo_host`,
+                                ServiceInstanceName: `${projectName}-html5_app_host`,
+                                ServiceKeyName: `${projectName}-html_repo_host-key`,
+                                'sap.cloud.service': businessSolution.replaceAll('_', '.')
+                            },
+                            {
+                                Name: `${businessSolution}-uaa-${projectName}`,
+                                ServiceInstanceName: `${projectNameForXsSecurity}-xsuaa`,
+                                ServiceKeyName: `${projectName}_uaa-key`,
+                                Authentication: 'OAuth2UserTokenExchange',
+                                'sap.cloud.service': businessSolution.replaceAll('_', '.')
+                            },
+                            {
+                                Name: `${businessService}-service_instance_name`,
+                                Authentication: 'OAuth2UserTokenExchange',
+                                ServiceInstanceName: `${businessService}`,
+                                ServiceKeyName: `${businessService}-key`
+                            }
+                        ],
+                        existing_destinations_policy: 'update'
+                    }
+                }
+            }
+        };
+        yamlContent.modules?.push(appRouter);
+    }
+}
+/**
+ * Adjusts the MTA YAML for a UI deployer.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @param {string} projectName - The project name.
+ * @param {string} moduleName - The module name.
+ */
+function adjustMtaYamlUDeployer(yamlContent, projectName, moduleName) {
+    const uiDeployerName = `${projectName}_ui_deployer`;
+    let uiDeployer = yamlContent.modules?.find((module) => module.name === uiDeployerName);
+    if (uiDeployer == null) {
+        uiDeployer = {
+            name: uiDeployerName,
+            type: SAP_APPLICATION_CONTENT,
+            path: '.',
+            requires: [],
+            'build-parameters': {
+                'build-result': 'resources',
+                requires: []
+            }
+        };
+        yamlContent.modules?.push(uiDeployer);
+    }
+    const htmlRepoHostName = `${projectName}_html_repo_host`;
+    if (uiDeployer.requires?.every((req) => req.name !== htmlRepoHostName)) {
+        uiDeployer.requires?.push({
+            name: htmlRepoHostName,
+            parameters: {
+                'content-target': true
+            }
+        });
+    }
+    if (uiDeployer['build-parameters']?.requires?.every((require) => require.name !== moduleName)) {
+        uiDeployer['build-parameters']?.requires?.push({
+            artifacts: [`${moduleName}.zip`],
+            name: moduleName,
+            'target-path': 'resources/'
+        });
+    }
+}
+/**
+ * Adjusts the MTA YAML for resources.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @param {string} projectName - The project name.
+ * @param {string} timestamp - The timestamp.
+ * @param {boolean} isManagedAppRouter - Whether the approuter is managed.
+ */
+function adjustMtaYamlResources(yamlContent, projectName, timestamp, isManagedAppRouter) {
+    const projectNameForXsSecurity = (0, yaml_loader_1.getProjectNameForXsSecurity)(yamlContent, timestamp);
+    const resources = [
+        {
+            name: `${projectName}_html_repo_host`,
+            type: CF_MANAGED_SERVICE,
+            parameters: {
+                service: HTML5_APPS_REPO,
+                'service-plan': 'app-host',
+                'service-name': `${projectName}-html5_app_host`
+            }
+        },
+        {
+            name: `${projectName}_uaa`,
+            type: CF_MANAGED_SERVICE,
+            parameters: {
+                service: 'xsuaa',
+                path: './xs-security.json',
+                'service-plan': 'application',
+                'service-name': `${projectNameForXsSecurity}-xsuaa`
+            }
+        }
+    ];
+    if (isManagedAppRouter) {
+        resources.push({
+            name: `${projectName}-destination`,
+            type: CF_MANAGED_SERVICE,
+            parameters: {
+                service: 'destination',
+                'service-name': `${projectName}-destination`,
+                'service-plan': 'lite',
+                config: {
+                    HTML5Runtime_enabled: true,
+                    version: '1.0.0'
+                }
+            }
+        });
+    }
+    else {
+        resources.push({
+            name: `portal_resources_${projectName}`,
+            type: CF_MANAGED_SERVICE,
+            parameters: {
+                service: 'portal',
+                'service-plan': 'standard'
+            }
+        }, {
+            name: `${projectName}_html_repo_runtime`,
+            type: CF_MANAGED_SERVICE,
+            parameters: {
+                service: HTML5_APPS_REPO,
+                'service-plan': 'app-runtime'
+            }
+        });
+    }
+    for (const resource of resources) {
+        if (yamlContent.resources?.every((existing) => existing.name !== resource.name)) {
+            yamlContent.resources?.push(resource);
+        }
+    }
+}
+/**
+ * Adjusts the MTA YAML for the own module.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @param {string} moduleName - The module name.
+ */
+function adjustMtaYamlOwnModule(yamlContent, moduleName) {
+    let module = yamlContent.modules?.find((module) => module.name === moduleName);
+    if (module == null) {
+        module = {
+            name: moduleName,
+            type: 'html5',
+            path: moduleName,
+            'build-parameters': {
+                builder: 'custom',
+                commands: ['npm install', 'npm run build'],
+                'supported-platforms': []
+            }
+        };
+        yamlContent.modules?.push(module);
+    }
+}
+/**
+ * Adds a module if it does not exist.
+ *
+ * @param {MtaRequire[]} requires - The requires.
+ * @param {string} name - The name.
+ */
+function addModuleIfNotExists(requires, name) {
+    if (requires.every((require) => require.name !== name)) {
+        requires.push({ name });
+    }
+}
+/**
+ * Adjusts the MTA YAML for the FLP module.
+ *
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @param {string} projectName - The project name.
+ * @param {string} businessService - The business service.
+ */
+function adjustMtaYamlFlpModule(yamlContent, projectName, businessService) {
+    for (const module of yamlContent.modules ?? []) {
+        const moduleIndex = yamlContent.modules?.indexOf(module);
+        if (moduleIndex !== undefined) {
+            if (module.type === SAP_APPLICATION_CONTENT && module.requires) {
+                const portalResources = module.requires.find((require) => require.name === `portal_resources_${projectName}`);
+                if (portalResources?.parameters?.['service-key']?.name === 'content-deploy-key') {
+                    addModuleIfNotExists(module.requires, `${projectName}_html_repo_host`);
+                    addModuleIfNotExists(module.requires, `${projectName}_ui_deployer`);
+                    addModuleIfNotExists(module.requires, businessService);
+                    // Move FLP module to last position
+                    yamlContent.modules?.push(yamlContent.modules.splice(moduleIndex, 1)[0]);
+                }
+            }
+        }
+    }
+}
+/**
+ * Adjusts the MTA YAML.
+ *
+ * @param {AdjustMtaYamlParams} params - The parameters.
+ * @param {Editor} memFs - The mem-fs editor instance.
+ * @param {ToolsLogger} logger - The logger.
+ * @returns {Promise<void>} The promise.
+ */
+async function adjustMtaYaml({ projectPath, moduleName, appRouterType, businessSolutionName, businessService, spaceGuid }, memFs, logger) {
+    const timestamp = Date.now().toString();
+    const mtaYamlPath = path.join(projectPath, 'mta.yaml');
+    const loadedYamlContent = (0, yaml_loader_1.getYamlContent)(mtaYamlPath);
+    const defaultYaml = {
+        ID: projectPath.split(path.sep).pop() ?? '',
+        version: '0.0.1',
+        modules: [],
+        resources: [],
+        '_schema-version': '3.2'
+    };
+    if (!appRouterType) {
+        appRouterType = getRouterType(loadedYamlContent);
+    }
+    const yamlContent = Object.assign(defaultYaml, loadedYamlContent);
+    const projectName = yamlContent.ID.toLowerCase();
+    const initialServices = yamlContent.resources?.map((resource) => resource.parameters.service ?? '') ?? [];
+    const isStandaloneApprouter = appRouterType === types_1.AppRouterType.STANDALONE;
+    if (isStandaloneApprouter) {
+        adjustMtaYamlStandaloneApprouter(yamlContent, projectName, businessService);
+    }
+    else {
+        adjustMtaYamlManagedApprouter(yamlContent, projectName, businessSolutionName, businessService, timestamp);
+    }
+    adjustMtaYamlUDeployer(yamlContent, projectName, moduleName);
+    adjustMtaYamlResources(yamlContent, projectName, timestamp, !isStandaloneApprouter);
+    adjustMtaYamlOwnModule(yamlContent, moduleName);
+    // should go last since it sorts the modules (workaround, should be removed after fixed in deployment module)
+    adjustMtaYamlFlpModule(yamlContent, projectName, businessService);
+    await (0, api_1.createServices)(projectPath, yamlContent, initialServices, timestamp, spaceGuid, logger);
+    const updatedYamlContent = js_yaml_1.default.dump(yamlContent);
+    memFs.write(mtaYamlPath, updatedYamlContent);
+    logger?.debug(`Adjusted MTA YAML for project ${projectPath}`);
+}
+//# sourceMappingURL=yaml.js.map

package/dist/cf/services/api.d.ts

@@ -0,0 +1,65 @@
+import type { ToolsLogger } from '@sap-ux/logger';
+import type { CfConfig, CFApp, RequestArguments, ServiceKeys, GetServiceInstanceParams, MtaYaml } from '../../types';
+/**
+ * Get the business service keys.
+ *
+ * @param {string} businessService - The business service.
+ * @param {CfConfig} config - The CF config.
+ * @param {ToolsLogger} logger - The logger.
+ * @returns {Promise<ServiceKeys | null>} The service keys.
+ */
+export declare function getBusinessServiceKeys(businessService: string, config: CfConfig, logger: ToolsLogger): Promise<ServiceKeys | null>;
+/**
+ * Get the FDC request arguments.
+ *
+ * @param {CfConfig} cfConfig - The CF config.
+ * @returns {RequestArguments} The request arguments.
+ */
+export declare function getFDCRequestArguments(cfConfig: CfConfig): RequestArguments;
+/**
+ * Get the FDC apps.
+ *
+ * @param {string[]} appHostIds - The app host ids.
+ * @param {CfConfig} cfConfig - The CF config.
+ * @param {ToolsLogger} logger - The logger.
+ * @returns {Promise<FDCResponse>} The FDC apps.
+ */
+export declare function getFDCApps(appHostIds: string[], cfConfig: CfConfig, logger: ToolsLogger): Promise<CFApp[]>;
+/**
+ * Creates a service.
+ *
+ * @param {string} spaceGuid - The space GUID.
+ * @param {string} plan - The plan.
+ * @param {string} serviceInstanceName - The service instance name.
+ * @param {string[]} tags - The tags.
+ * @param {string} [serviceName] - The service name.
+ * @param {object} [security] - Security configuration.
+ * @param {string | null} security.filePath - The security file path.
+ * @param {string} [security.xsappname] - The XS app name.
+ * @param {ToolsLogger} [logger] - The logger.
+ */
+export declare function createService(spaceGuid: string, plan: string, serviceInstanceName: string, tags: string[], serviceName: string | undefined, security?: {
+    filePath: string | null;
+    xsappname?: string;
+}, logger?: ToolsLogger): Promise<void>;
+/**
+ * Creates the services.
+ *
+ * @param {string} projectPath - The project path.
+ * @param {MtaYaml} yamlContent - The YAML content.
+ * @param {string[]} initialServices - The initial services.
+ * @param {string} timestamp - The timestamp.
+ * @param {string} spaceGuid - The space GUID.
+ * @param {ToolsLogger} logger - The logger.
+ * @returns {Promise<void>} The promise.
+ */
+export declare function createServices(projectPath: string, yamlContent: MtaYaml, initialServices: string[], timestamp: string, spaceGuid: string, logger?: ToolsLogger): Promise<void>;
+/**
+ * Gets the service instance keys.
+ *
+ * @param {GetServiceInstanceParams} serviceInstanceQuery - The service instance query.
+ * @param {ToolsLogger} logger - The logger.
+ * @returns {Promise<ServiceKeys | null>} The service instance keys.
+ */
+export declare function getServiceInstanceKeys(serviceInstanceQuery: GetServiceInstanceParams, logger: ToolsLogger): Promise<ServiceKeys | null>;
+//# sourceMappingURL=api.d.ts.map