@sap/cds-dk 6.8.2 → 7.0.0

package/lib/client/settings_manager.js

@@ -6,11 +6,11 @@ const axios = require('axios');
 const cds = require('../cds');
 const DEBUG = cds.debug('cli');
 const { requireGlobal } = require('./helper/dependency_helper');
-const { getAppFromSuggestions, getAppName, getSubdomain } = require('./helper/cf_helper');
+const { getAppFromSuggestions, getSubdomain } = require('./helper/cf_helper');
 const isBas = require('./helper/env_helper');
 const Question = require('./helper/question');
 const { CliError } = require('./helper/errors');
-const { httpSchema, httpsSchema, extractSubdomain, schemaRegex, localhostRegex } = require('./helper/url_helper');
+const { httpSchema, httpsSchema, schemaRegex, localhostRegex } = require('./helper/url_helper');
 const { capitalize } = require('./helper/string_helper');
 
 const { ParamCollection, Persistence } = require('./params');
@@ -64,10 +64,7 @@ function getProjectFolder(params) {
         const maybeExistentPath = path.resolve(params.get('projectFolder'));
         return maybeExistentPath;
     }
-    const existentPath = params.has('subdomain') && fs.existsSync(params.get('subdomain'))
-        ? params.get('subdomain')
-        : '.';
-    return fs.realpathSync(existentPath);
+    return fs.realpathSync('.');
 }
 
 async function getAppUrlAndSubdomainFromSuggestions(params) {
@@ -109,7 +106,7 @@ async function getTokenBaseUrl(params, renewUrl) {
     };
 
     let existingPath;
-    const oauthPaths = [OAUTH_PATH_STREAMLINED_MTX/*, OAUTH_PATH_OLD_MTX*/]; // The old MTX does not support HEAD requests
+    const oauthPaths = [OAUTH_PATH_STREAMLINED_MTX];
     for (const path of oauthPaths) {
         try {
             await axios.head(getBaseUrl(path).toString());
@@ -122,7 +119,7 @@ async function getTokenBaseUrl(params, renewUrl) {
             throw error;
         }
     }
-    existingPath = existingPath ?? OAUTH_PATH_OLD_MTX;
+    existingPath = existingPath ?? OAUTH_PATH_OLD_MTX; // REVISIT can this just be included in the array?
     return getBaseUrl(existingPath).toString();
 }
 
@@ -218,12 +215,7 @@ class SettingsManager {
     }
 
     static async updateUrls(params, logout, loadedAppUrl) {
-        async function addAppUrlAndSubdomain() {
-            function needsSubdomain() {
-                // Subdomain needed for token retrieval.
-                return params.has('appUrl') && !localhostRegex.test(params.get('appUrl')) && !params.get('skipToken');
-            }
-
+        async function addAppUrl() {
             // Prefix URL schema
             if (params.has('appUrl')) {
                 const appUrl = params.get('appUrl');
@@ -237,37 +229,16 @@ class SettingsManager {
                 }
             }
 
-            if (!logout) {
+            if (!logout && !params.has('appUrl')) {
                 // Get appUrl from CF
-                if (!params.has('appUrl')) {
-                    DEBUG?.('App URL not given');
-                    await getAppUrlAndSubdomainFromSuggestions(params);
-                }
-
-                // Get subdomain from CF
-                if (!params.has('subdomain') && needsSubdomain()) {
-                    DEBUG?.('Subdomain not given');
-                    const appName = await getAppName(params.get('appUrl'));
-                    if (appName) {
-                        params.set('subdomain', await getSubdomainFromCfAndNotify(appName));
-                    }
-                }
+                DEBUG?.('App URL not given');
+                await getAppUrlAndSubdomainFromSuggestions(params);
             }
 
             // Check required param: appUrl
             if (!params.has('appUrl')) {
                 throw new CliError('App URL not given. Please specify it or log in to Cloud Foundry and repeat this command.');
             }
-
-            // Check required param: subdomain
-            if (!params.has('subdomain') && needsSubdomain()) {
-                const subdomain = extractSubdomain(params.get('appUrl'));
-                if (!subdomain) {
-                    throw new CliError('Subdomain not given');
-                }
-                params.set('subdomain', subdomain);
-                console.log('Subdomain determined from app URL:', subdomain);
-            }
         }
         async function renewTokenUrl() {
             const renewUrl = params.get('appUrl') !== loadedAppUrl;
@@ -276,7 +247,7 @@ class SettingsManager {
             }
         }
 
-        await addAppUrlAndSubdomain();
+        await addAppUrl();
 
         if (!logout && !params.get('skipToken')) {
             await renewTokenUrl();

package/lib/deploy/to-hana/hana.js

@@ -0,0 +1,273 @@
+const cp = require('child_process');
+const path = require('path');
+const util = require('util');
+
+const fs = require('fs').promises;
+
+const cds = require('../../../lib/cds');
+
+const { build } = require('../../build');
+const buildConstants = require('../../build/constants');
+
+const hdiDeployUtil = require('./hdiDeployUtil');
+const cfUtil = require('../../util/cfUtil');
+const gitUtil = require('../../util/gitUtil');
+const mtaUtil = require('./mtaUtil');
+
+const { bold, info } = require('../../util/term');
+const { CliError } = require('../../client/helper/errors');
+
+const { bind } = require('../../bind');
+
+const UTF_8 = 'utf-8';
+
+
+class HanaDeployer {
+
+  constructor() {
+    this.execAsync = util.promisify(cp.exec);
+    this.spawnSync = cp.spawnSync;
+  }
+
+  getFromEnv(...varNames) {
+    const result = {}
+    for (const varName of varNames) {
+      if (process.env[varName]) {
+        try {
+          result[varName] = JSON.parse(process.env[varName]);
+        } catch (err) {
+          throw new Error(`Error parsing environment variable ${varName}`);
+        }
+      }
+    }
+    return result;
+  }
+
+  // arg object
+  // async deploy(model, serviceName, tunnelAddress, buildTaskOptions, vcapFile, undeployWhitelist, hdiOptions, bindCallback) { // NOSONAR
+  async deploy(options = {}) { // NOSONAR
+    let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions } = options;
+
+    if (model) {
+      throw new CliError('Specifying a model for hana deployment is not supported.');
+    }
+
+    console.log(`${bold('Starting deploy to SAP HANA ...')}`);
+    if (vcapFile) {
+      console.log(`Using VCAP_SERVICES from file ${vcapFile} (beta feature).`);
+    }
+
+    const projectPath = cds.root;
+
+    const buildResults = await this._build();
+
+    let globalVcapEnv = vcapFile ? await this._loadEnvFile(vcapFile) : {};
+    globalVcapEnv = { ...globalVcapEnv, ...this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS') };
+    if (process.env.TARGET_CONTAINER) {
+      globalVcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
+    }
+
+    for (const buildResult of buildResults) {
+      let vcapEnv = globalVcapEnv;
+      let serviceKeyName;
+      const currentModelFolder = buildResult.task.dest;
+
+      if (undeployWhitelist) {
+        console.log('Writing undeploy.json');
+        await fs.write(path.join(currentModelFolder, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
+      }
+
+      const hasVCAPEnv = Object.keys(vcapEnv).length > 0;
+      if (!serviceName && hasVCAPEnv) {
+        await fs.mkdir(currentModelFolder, { recursive: true });
+      } else {
+        const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
+          await this._getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress);
+        serviceKeyName = cfServiceInstanceKeyName;
+        serviceName = serviceName || cfServiceInstanceName;
+
+        vcapEnv = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+
+        if (options.storeCredentials) {
+          await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey);
+        }
+      }
+
+      hdiOptions = hdiOptions || {}
+      await hdiDeployUtil.deploy(currentModelFolder, vcapEnv, hdiOptions);
+
+      if (!hasVCAPEnv) {
+        const bindOptions = {
+          ...options,
+          to: `${serviceName}:${serviceKeyName}`,
+          for: options.for,
+          kind: buildResult.task.for
+        }
+        await bind(bindOptions);
+      }
+    }
+
+    if (options.storeCredentials) {
+      await gitUtil.ensureFileIsGitignored('default-env.json', projectPath);
+    }
+
+    console.log(`If not already done, use ${info('cds add hana')} to configure the project for SAP HANA.\n`);
+    console.log(`Done.`);
+
+    return { buildResults };
+  }
+
+
+  async _getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress) {
+    const modelName = path.basename(currentModelFolder);
+
+    // get from param
+    let cfServiceInstanceMta;
+    let cfServiceInstanceName;
+    if (serviceName) {
+      cfServiceInstanceName = serviceName;
+    } else {
+      const cfServiceDescriptor = await mtaUtil.getHanaDbModuleDescriptor(projectPath, modelName);
+      cfServiceInstanceName = cfServiceDescriptor.hdiServiceName;
+      cfServiceInstanceMta = cfServiceDescriptor.hdiService
+    }
+
+    console.log();
+    this._validateServiceInstanceName(cfServiceInstanceName);
+    console.log(`Using container ${bold(cfServiceInstanceName)}`);
+
+    let cfConfig = cfServiceInstanceMta && cfServiceInstanceMta.parameters && cfServiceInstanceMta.parameters.config;
+    const serviceInstance = await this.createHanaService(cfServiceInstanceName, cfConfig);
+
+    const cfServiceInstanceKeyName = `${cfServiceInstanceName}-key`;
+    let serviceKey = await cfUtil.getOrCreateServiceKey(serviceInstance, cfServiceInstanceKeyName);
+    this._validateServiceKey(serviceKey, cfServiceInstanceKeyName);
+
+    if (tunnelAddress) {
+      console.log(`Using tunnel address ${bold(tunnelAddress)} (beta feature)`);
+      serviceKey = this._injectTunnelAddress(serviceKey, tunnelAddress)
+    }
+
+    return { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey, serviceInstance }
+  }
+
+
+  async createHanaService(instanceName, cfConfig) {
+    // hana or hanatrial, error if neither found
+    try {
+      return await cfUtil.getOrCreateService('hana', 'hdi-shared', instanceName, cfConfig);
+    } catch (error) {
+      if (error.command && /offering .* not found/i.test(error.command.stderr)) {
+        console.log(`Falling back to 'hanatrial'`);
+        return await cfUtil.getOrCreateService('hanatrial', 'hdi-shared', instanceName, cfConfig);
+      }
+      else if (error.command && /no database/i.test(error.command.stderr)) {
+        console.log(`No database connected to 'hana' service. Falling back to 'hanatrial'`);
+        return await cfUtil.getOrCreateService('hanatrial', 'hdi-shared', instanceName, cfConfig);
+      }
+      throw error;
+    }
+  }
+
+
+  _validateServiceKey(serviceKey, cfServiceInstanceKey) {
+    if (!serviceKey) {
+      throw new Error(`Could not create service key ${bold(cfServiceInstanceKey)}.`);
+    }
+
+    const fields = ['schema', 'user', 'password', 'url'];
+    for (const field of fields) {
+      if (!serviceKey[field]) {
+        throw new Error(`Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`);
+      }
+    }
+  }
+
+
+  async _build() {
+    const buildTaskOptions = {
+      for: buildConstants.BUILD_TASK_HANA
+    }
+
+    console.log(`Running build`);
+    const buildResults = await build(buildTaskOptions);
+    return buildResults;
+  }
+
+  async _loadEnvFile(defaultEnvFile) {
+    try {
+      const content = await fs.readFile(defaultEnvFile);
+      return JSON.parse(content);
+    } catch (err) {
+      throw new Error(`Error reading default env file: ${err.message}`);
+    }
+  }
+
+
+  async _addInstanceToDefaultEnvJson(currentFolders, serviceInstanceName, serviceKey) {
+    for (const currentFolder of currentFolders) {
+      let defaultEnvJson = {};
+      const defaultEnvJsonPath = path.join(currentFolder, 'default-env.json');
+
+      try {
+        defaultEnvJson = JSON.parse(await fs.readFile(defaultEnvJsonPath, UTF_8));
+      } catch (err) {
+        // ignore any errors
+      }
+
+      defaultEnvJson.VCAP_SERVICES = defaultEnvJson.VCAP_SERVICES || {};
+      for (const serviceKey of Object.keys(defaultEnvJson.VCAP_SERVICES)) {
+        defaultEnvJson.VCAP_SERVICES[serviceKey] = defaultEnvJson.VCAP_SERVICES[serviceKey].filter((service) => {
+          return (service.name !== serviceInstanceName);
+        });
+      }
+
+      const hanaEntry = this._getVCAPServicesEntry(serviceInstanceName, serviceKey)
+      Object.assign(defaultEnvJson, hanaEntry);
+
+      console.log(`Writing ${defaultEnvJsonPath}`);
+      await fs.mkdir(path.dirname(defaultEnvJsonPath), { recursive: true })
+      await fs.writeFile(defaultEnvJsonPath, JSON.stringify(defaultEnvJson, null, 2));
+    }
+  }
+
+
+  _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
+    return {
+      VCAP_SERVICES: {
+        hana: [
+          {
+            name: serviceInstanceName,
+            tags: ['hana'],
+            credentials: serviceKey
+          }
+        ]
+      }
+    };
+  }
+
+
+  _validateServiceInstanceName(serviceInstanceName) {
+    // valid service name chars: alpha-numeric, hyphens, and underscores
+    if (/[^\w-_]+/g.exec(serviceInstanceName)) {
+      throw new Error(`Service name ${serviceInstanceName} must only contain alpha-numeric, hyphens, and underscores.`);
+    }
+  }
+
+
+  _injectTunnelAddress(serviceKey, tunnelAddress) {
+    if (!/\w+:\d+/.test(tunnelAddress)) {
+      throw new Error(`Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`)
+    }
+    const [tunnelHost, tunnelPort] = tunnelAddress.split(':')
+    const { host, port } = serviceKey
+    serviceKey.host = tunnelHost
+    serviceKey.port = tunnelPort
+    serviceKey.url = serviceKey.url.replace(`${host}:${port}`, tunnelAddress)
+    serviceKey.hostname_in_certificate = host  // make cert. verification happy, see xs2/hdideploy.js#527
+    serviceKey.url = serviceKey.url + (serviceKey.url.includes('?') ? '&' : '?') + 'hostNameInCertificate=' + host
+    return serviceKey
+  }
+}
+
+module.exports = new HanaDeployer();

package/lib/deploy/to-hana/hdiDeployUtil.js

@@ -0,0 +1,68 @@
+const path = require('path');
+const util = require('util');
+
+const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
+
+class HdiDeployUtil {
+
+    async deploy(dbDir, vcapEnv = {}, options = {}) {
+        console.log(`Deploying to HANA from ${dbDir}`);
+
+        const hdiDeployLib = await this._loadHdiDeployLib(dbDir);
+
+        let deployerEnv = JSON.parse(JSON.stringify(process.env));
+        const hdiDeployOptions = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : {};
+        delete hdiDeployOptions.root;
+
+        if (typeof hdiDeployLib.clean_env === 'function') {
+            deployerEnv = hdiDeployLib.clean_env(deployerEnv);
+        }
+
+        if (vcapEnv.VCAP_SERVICES) {
+            deployerEnv.VCAP_SERVICES = JSON.stringify(vcapEnv.VCAP_SERVICES);
+        }
+        if (vcapEnv.SERVICE_REPLACEMENTS) {
+            deployerEnv.SERVICE_REPLACEMENTS = JSON.stringify(vcapEnv.SERVICE_REPLACEMENTS);
+        }
+        if (vcapEnv.TARGET_CONTAINER) {
+            deployerEnv.TARGET_CONTAINER = vcapEnv.TARGET_CONTAINER;
+        }
+
+        if (options.autoUndeploy) {
+            console.log(`Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);
+            hdiDeployOptions.auto_undeploy = true;
+        }
+
+        if (Object.entries(hdiDeployOptions).length > 0) {
+            deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(hdiDeployOptions);
+        }
+
+        const asyncDeploy = util.promisify(hdiDeployLib.deploy);
+        const response = await asyncDeploy(dbDir, deployerEnv);
+        if (response?.exitCode) {
+            let message = `HDI deployment failed with exit code ${response.exitCode}`;
+            if (response.signal) {
+                message += `. ${response.signal}`;
+            }
+            throw new Error(message);
+        }
+    }
+
+
+    _loadHdiDeployLib(cwd) {
+        const searchPaths = [cwd, __dirname];
+        const libPath = require.resolve(path.join(HDI_DEPLOY_LIB, 'library'), { paths: searchPaths });
+        if (!libPath) {
+            throw new Error(`Required library '${HDI_DEPLOY_LIB}' not found in
+    ${searchPaths.join('\n    ')}
+Add it either as a devDependency using 'npm install -D ${HDI_DEPLOY_LIB}' or install it globally using 'npm install -g ${HDI_DEPLOY_LIB}'.`);
+        }
+
+        console.log(`Using HDI deployer from ${libPath}`)
+
+        // let any error go through and abort deploy
+        return require(libPath);
+    }
+}
+
+module.exports = new HdiDeployUtil();

package/lib/deploy/to-hana/mtaUtil.js

@@ -0,0 +1,171 @@
+const cds = require('../../cds')
+
+const fs = require('fs').promises
+const {existsSync} = require('fs')
+const path = require('path')
+
+const HDI_CONTAINER_TYPES = ['com.sap.xs.hdi-container']
+const UTF_8 = 'utf-8'
+const MTA_YAML = 'mta.yaml'
+const DEBUG = cds.debug('cli');
+
+async function getHanaDbModuleDescriptor(projectPath, moduleName) {
+    // mta might be null if mta.yaml does not exist
+    const mta = await _getMta(projectPath)
+    const projectInfo = await _getProjectInfo(projectPath, mta)
+    const hdiService = _findHdiResource(mta, moduleName)
+    const appName = _getApplicationName(mta, moduleName, 'hdb')
+
+    return {
+        project: projectInfo,
+        appName: appName ? appName : `${projectInfo.name}-${moduleName}-deployer`,
+        hdiServiceName: hdiService ? hdiService.name : `${projectInfo.name}-${moduleName}`,
+        hdiService: hdiService
+    }
+}
+
+async function getServiceModuleDescriptor(projectPath, moduleName, moduleType) {
+    // mta might be null if mta.yaml does not exist
+    const mta = await _getMta(projectPath)
+    const projectInfo = await _getProjectInfo(projectPath, mta)
+    const appName = _getApplicationName(mta, moduleName, moduleType)
+
+    return {
+        project: projectInfo,
+        appName: appName ? appName : `${projectInfo.name}-${moduleName}`
+    }
+}
+
+async function _getProjectInfo(projectPath, mta) {
+    const details = {
+    }
+    // 1. use mta data
+    if (mta) {
+        details.id = mta.ID
+        details.description = mta.description
+        details.version = mta.version
+        if (mta.ID) {
+            details.name = mta.ID.replace(/\./g, '-')
+        }
+    }
+    // 2. use package.json data
+    const packageJsonPath = path.join(projectPath, 'package.json')
+    if (existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse((await fs.readFile(packageJsonPath, 'utf-8')).toString())
+            if (!details.description && packageJson.description) {
+                details.description = packageJson.description
+            }
+            if (!details.version && packageJson.version) {
+                details.version = packageJson.version
+            }
+            if (packageJson.name) {
+                let segments = packageJson.name.trim().split('/')
+                // scope as namespace
+                if (segments[0].startsWith('@')) {
+                    segments[0] = segments[0].replace('@', '')
+                }
+                segments = segments.map(segment => segment.startsWith('@') ? encodeURIComponent(segment.replace('@', '')) : encodeURIComponent(segment))
+                if (!details.name) {
+                    details.name = segments[segments.length - 1]
+                }
+                if (!details.id) {
+                    details.id = segments.join('.')
+                }
+                if (!details.description) {
+                    details.description = segments[segments.length - 1]
+                }
+            }
+        } catch (e) {
+            console.error(`Failed to load ${packageJsonPath} - skip application data`, e)
+        }
+    }
+    // 3. use project name and static default values
+    const projectName = path.basename(projectPath)
+    if (!details.name) {
+        details.name = projectName
+    }
+    if (!details.description) {
+        details.description = projectName
+    }
+    if (!details.id) {
+        details.id = projectName
+    }
+    if (!details.version) {
+        details.version = '1.0.0'
+    }
+    return details
+}
+
+async function _getMta(projectPath) {
+    // yaml.parse  oesn't like null
+    const mtaFilePath = path.join(projectPath, MTA_YAML)
+
+    const existsMtaYaml = existsSync(mtaFilePath)
+    if (!existsMtaYaml) {
+        DEBUG?.('mta.yaml not existing')
+        return null
+    }
+
+    const yamlStr = await fs.readFile(mtaFilePath, UTF_8)
+
+    // yaml returns null if string couldn't be parsed, e.g. empty string
+    return cds.parse.yaml(yamlStr)
+}
+
+function _getApplicationName(mta, moduleName, moduleType) {
+    const module = _findModule(mta, moduleName, moduleType)
+    if (module) {
+        const appName = module.parameters && module.parameters['app-name']
+        return appName ? appName : module.name
+    }
+    return null
+}
+
+function _findModules(mta, moduleType) {
+    let modules = []
+    if (mta && Array.isArray(mta.modules)) {
+        modules = mta.modules.filter(module => module.type === moduleType)
+    }
+    return modules
+}
+
+function _findModule(mta, moduleName, moduleType) {
+    const modules = _findModules(mta, moduleType)
+    if (modules.length === 1) {
+        return modules[0]
+    } else if (modules.length > 1) {
+        return modules.find(module => typeof module.path === 'string' && module.path.includes(moduleName))
+    }
+    return null
+}
+
+function _findHdiResource(mta, moduleName) {
+    if (mta && Array.isArray(mta.resources)) {
+        const hdiResources = mta.resources.filter(resource => HDI_CONTAINER_TYPES.includes(resource.type))
+
+        if (hdiResources.length > 0) {
+            if (Array.isArray(mta.modules)) {
+                const module = _findModule(mta, moduleName, 'hdb')
+                if (module && Array.isArray(module.requires)) {
+                    return hdiResources.find(hdiResource =>
+                        module.requires.find(req =>
+                            hdiResource.name === req.name
+                        )
+                    )
+                }
+            }
+
+            console.warn(`No matching hdi resource found for ${moduleName}. Using ${hdiResources[0].name}.`)
+            return hdiResources[0]
+        }
+    }
+
+    return null
+}
+
+module.exports = {
+    getHanaDbModuleDescriptor,
+    getServiceModuleDescriptor,
+    MTA_YAML
+}

package/lib/import/asyncapi/importAsyncAPI.js

@@ -1,4 +1,3 @@
-
 const ParserContext = require("./parserContext");
 const cdsDkVersion = require("../../../package.json").version;
 
@@ -29,4 +28,6 @@ function convertToCSN(context) {
      return csn;
 }
 
-module.exports = { importAsyncAPI }
+module.exports = {
+     importAsyncAPI
+}

package/lib/import/asyncapi/index.js

@@ -1,9 +1,12 @@
 const { importAsyncAPI } = require("./importAsyncAPI");
 const { validateAsyncAPI } = require('./utils');
 
-/* The starting function for conversion of AsyncAPI document to csn*/
+/**
+ * The starting function for conversion of AsyncAPI document to csn
+ * @returns AsyncAPI document
+ */ 
 function asyncapi2csn(source) {
-    //validate asyncapi document
+    // validate asyncapi document
     const content = JSON.parse(source);
     validateAsyncAPI(content);