@sap/cds-dk 7.5.1 → 7.6.1

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

@@ -1,15 +1,14 @@
-const cp = require('child_process');
 const path = require('path');
-const util = require('util');
 
 const fs = require('fs').promises;
 
 const cds = require('../../../lib/cds');
+const { exists, read } = cds.utils;
 
 const { build } = require('../../build');
 const buildConstants = require('../../build/constants');
 
-const hdiDeployUtil = require('./hdiDeployUtil');
+const hdi = require('./hdiDeployUtil');
 const cfUtil = require('../../util/cf');
 const gitUtil = require('../../util/git');
 const mtaUtil = require('./mtaUtil');
@@ -18,15 +17,9 @@ const { bold, info } = require('../../util/term');
 
 const { bind } = require('../../bind');
 
-const UTF_8 = 'utf-8';
+const DEBUG = cds.debug('deploy');
 
-
-class HanaDeployer {
-
-  constructor() {
-    this.execAsync = util.promisify(cp.exec);
-    this.spawnSync = cp.spawnSync;
-  }
+module.exports = new class HanaDeployer {
 
   getFromEnv(...varNames) {
     const result = {}
@@ -42,11 +35,8 @@ class HanaDeployer {
     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, dry } = options;
-
+  async deploy(options = {}) {
+    let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry, storeCredentials } = options;
     if (model) {
       throw `Specifying a CDS model for HANA deployment is not supported.
 'cds deploy --to hana' performs 'cds build --for hana' which in turn uses the configured HANA build task.
@@ -65,15 +55,16 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
     const buildResults = await this._build();
 
-    let globalVcapEnv = vcapFile ? await this._loadEnvFile(vcapFile) : {};
-    globalVcapEnv = { ...globalVcapEnv, ...this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS') };
+    const fromFile = vcapFile && exists(vcapFile) ? await read(vcapFile) : {};
+    const fromEnv = this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS');
+    let vcapEnv = { ...fromFile, ...fromEnv };
     if (process.env.TARGET_CONTAINER) {
-      globalVcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
+      vcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
     }
 
     if (dry) {
-      for (const buildResult of buildResults) {
-        const model = await cds.load(buildResult.task.src);
+      for (const { task } of buildResults) {
+        const model = await cds.load(task.src);
         const data = cds.compile.to.hdbtable(model);
         for (const [src, { file }] of data) {
           console.log(`-- ${file}`);
@@ -82,49 +73,47 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
         }
       }
     } else {
-      for (const buildResult of buildResults) {
-        let vcapEnv = globalVcapEnv;
-        let serviceKeyName;
-        const currentModelFolder = buildResult.task.dest;
+      for (const { task } of buildResults) {
+        const dest = task.dest;
 
         if (undeployWhitelist) {
           console.log('Writing undeploy.json');
-          await fs.write(path.join(currentModelFolder, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
+          await fs.write(path.join(dest, '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;
+          await fs.mkdir(dest, { recursive: true });
+        }
+        const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
+            await this._getOrCreateCFService(projectPath, dest, serviceName, tunnelAddress);
 
-          vcapEnv = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+        serviceName ??= cfServiceInstanceName;
+        if (!vcapEnv.VCAP_SERVICES || serviceName) {
+          vcapEnv.VCAP_SERVICES = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+        }
 
-          if (options.storeCredentials) {
-            await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey);
-          }
+        if (storeCredentials) {
+          await this._addInstanceToDefaultEnvJson([dest, projectPath], cfServiceInstanceName, serviceKey);
         }
 
         console.log(`${bold('Starting deployment to SAP HANA ...')}`);
 
-        hdiOptions = hdiOptions || {}
-        await hdiDeployUtil.deploy(currentModelFolder, vcapEnv, hdiOptions);
+        DEBUG?.({ dest, vcapEnv, hdiOptions })
+        await hdi.deploy(dest, vcapEnv, hdiOptions);
 
         if (!hasVCAPEnv) {
           const bindOptions = {
             ...options,
-            to: `${serviceName}:${serviceKeyName}`,
+            to: `${serviceName}:${cfServiceInstanceKeyName}`,
             for: options.for,
-            kind: buildResult.task.for
+            kind: task.for
           }
           await bind(bindOptions);
         }
       }
 
-      if (options.storeCredentials) {
+      if (storeCredentials) {
         await gitUtil.ensureFileIsGitignored('default-env.json', projectPath);
       }
 
@@ -155,11 +144,11 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     this._validateServiceInstanceName(cfServiceInstanceName);
     console.log(`Using container ${bold(cfServiceInstanceName)}`);
 
-    let cfConfig = cfServiceInstanceMta && cfServiceInstanceMta.parameters && cfServiceInstanceMta.parameters.config;
+    const cfConfig = cfServiceInstanceMta?.parameters?.config;
     const serviceInstance = await this.createHanaService(cfServiceInstanceName, cfConfig);
 
     const cfServiceInstanceKeyName = `${cfServiceInstanceName}-key`;
-    let serviceKey = await cfUtil.getOrCreateServiceKey(serviceInstance, cfServiceInstanceKeyName);
+    let serviceKey = await cfUtil.getOrCreateServiceKey(serviceInstance, cfServiceInstanceKeyName, { permissions: 'development' });
     this._validateServiceKey(serviceKey, cfServiceInstanceKeyName);
 
     if (tunnelAddress) {
@@ -191,13 +180,17 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
   _validateServiceKey(serviceKey, cfServiceInstanceKey) {
     if (!serviceKey) {
-      throw new Error(`Could not create service key ${bold(cfServiceInstanceKey)}.`);
+      throw `Could not create service key ${bold(cfServiceInstanceKey)}.`;
+    }
+
+    if (serviceKey['sm_url']) {
+      throw `Service key credentials are matching to a Service Manager instance of a multitenant environment. Make sure there is no conflict with ${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.`);
+        throw `Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`;
       }
     }
   }
@@ -209,40 +202,21 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     }
 
     console.log(`Running build`);
-    const buildResults = await build(buildTaskOptions);
-    return buildResults;
+    return build(buildTaskOptions);
   }
 
-  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');
+      const defaultEnvJson = exists(defaultEnvJsonPath) ? await read(defaultEnvJsonPath) : {};
 
-      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);
-        });
+      defaultEnvJson.VCAP_SERVICES ??= {};
+      for (const [serviceKey, services] of Object.entries(defaultEnvJson.VCAP_SERVICES)) {
+        defaultEnvJson.VCAP_SERVICES[serviceKey] = services.filter(service => service.name !== serviceInstanceName);
       }
 
       const hanaEntry = this._getVCAPServicesEntry(serviceInstanceName, serviceKey)
-      Object.assign(defaultEnvJson, hanaEntry);
+      Object.assign(defaultEnvJson.VCAP_SERVICES, hanaEntry);
 
       console.log(`Writing ${defaultEnvJsonPath}`);
       await fs.mkdir(path.dirname(defaultEnvJsonPath), { recursive: true })
@@ -253,15 +227,13 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
   _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
     return {
-      VCAP_SERVICES: {
         hana: [
           {
             name: serviceInstanceName,
             tags: ['hana'],
             credentials: serviceKey
           }
-        ]
-      }
+      ]
     };
   }
 
@@ -269,14 +241,14 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
   _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.`);
+      throw `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'`)
+      throw `Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`;
     }
     const [tunnelHost, tunnelPort] = tunnelAddress.split(':')
     const { host, port } = serviceKey
@@ -288,5 +260,3 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     return serviceKey
   }
 }
-
-module.exports = new HanaDeployer();

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

@@ -1,22 +1,21 @@
 const path = require('path');
 const util = require('util');
+const { bold } = require('../../util/term');
 
 const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
 
-class HdiDeployUtil {
+module.exports = new class HdiDeployUtil {
 
-    async deploy(dbDir, vcapEnv = {}, options = {}) {
+    async deploy(dbDir, vcapEnv = {}, { autoUndeploy } = {}) {
         console.log(`Deploying to HANA from ${dbDir}`);
 
-        const hdiDeployLib = await this._loadHdiDeployLib(dbDir);
+        const { clean_env, deploy } = this._loadHdiDeployLib(dbDir);
 
-        let deployerEnv = JSON.parse(JSON.stringify(process.env));
+        const 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);
-        }
+        clean_env?.(deployerEnv);
 
         if (vcapEnv.VCAP_SERVICES) {
             deployerEnv.VCAP_SERVICES = JSON.stringify(vcapEnv.VCAP_SERVICES);
@@ -28,8 +27,8 @@ class HdiDeployUtil {
             deployerEnv.TARGET_CONTAINER = vcapEnv.TARGET_CONTAINER;
         }
 
-        if (options.autoUndeploy) {
-            console.log(`Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);
+        if (autoUndeploy) {
+            console.log(`HDI deployer automatically undeploys deleted resources using --auto-undeploy.`);
             hdiDeployOptions.auto_undeploy = true;
         }
 
@@ -37,12 +36,12 @@ class HdiDeployUtil {
             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}`;
+        const asyncDeploy = util.promisify(deploy);
+        const { exitCode, signal } = await asyncDeploy(dbDir, deployerEnv);
+        if (exitCode) {
+            let message = `HDI deployment failed with exit code ${exitCode}`;
+            if (signal) {
+                message += `. ${signal}`;
             }
             throw new Error(message);
         }
@@ -55,7 +54,7 @@ class HdiDeployUtil {
         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}'.`);
+    Add it either to ${bold('devDependencies')} 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}`)
@@ -64,5 +63,3 @@ Add it either as a devDependency using 'npm install -D ${HDI_DEPLOY_LIB}' or ins
         return require(libPath);
     }
 }
-
-module.exports = new HdiDeployUtil();

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

@@ -98,7 +98,7 @@ async function _getProjectInfo(projectPath, mta) {
 }
 
 async function _getMta(projectPath) {
-    // yaml.parse  oesn't like null
+    // yaml.parse doesn't like null
     const mtaFilePath = path.join(projectPath, MTA_YAML)
 
     const existsMtaYaml = existsSync(mtaFilePath)

package/lib/env/schema.js

@@ -1,35 +1,175 @@
-const { merge } = require('../init/merge')
-const { readJSON } = require('../util/fs')
 
-module.exports = async function overlay4(schemaName, cwd = process.cwd()) {
+function _local(id) {
+    return require.resolve(id, {
+        paths: [
+            process.cwd(), // project-local module is preferred
+            __dirname      // otherwise from our own dependencies
+        ]
+    })
+}
+
+function _robustRequire(file) {
+    const fs = require('fs')
+    const path = require('path')
+
+    file = path.normalize(file)
+    let content
+    try {
+        content = fs.readFileSync(file, 'utf8')
+    } catch (e) {
+        // file is not readable -> nothing to do
+        return
+    }
+
+    try {
+        return JSON.parse(content)
+    } catch (e) {
+        // invalid json -> ignore and try regex
+    }
+
+    const result = {}
+    try {
+        const deps = JSON.parse(content.match(/"dependencies"\s*:\s*({[^}]*})/)[1])
+        result.dependencies = deps
+    } catch (e) { /* ignore */ }
+
+    try {
+        const devDeps = JSON.parse(content.match(/"devDependencies"\s*:\s*({[^}]*})/)[1])
+        result.devDependencies = devDeps
+    } catch (e) { /* ignore */ }
+
+    return result
+}
+
+_robustRequire.resolve = function (id, options = {}) {
+    const fs = require('fs')
+    const path = require('path')
+
+    try {
+        return require.resolve(id, options)
+    } catch (err) {
+        // ignore
+    }
+
+    const [, mod, file] = /(.+)\/([^/]+)$/.exec(id)
+    let modPath = path.join(process.cwd(), 'node_modules', mod, file)
+    const ext = path.extname(modPath)
+    if (!ext) {
+        modPath = modPath + '.js'
+    }
+    if (fs.existsSync(modPath)) {
+        return modPath
+    }
+
+    throw new Error('not found')
+}
+
+function mergePluginSchema(pluginSchema) {
+    return {
+        into: async (targetSchema) => {
+            if (pluginSchema.buildTaskType) {
+                targetSchema.$defs?.buildTaskType?.enum?.push(pluginSchema.buildTaskType.name);
+                targetSchema.$defs?.buildTaskType?.enumDescriptions?.push(pluginSchema.buildTaskType.description);
+                targetSchema._cds_schema_overlays.push('buildTaskType')
+            }
+
+            if (pluginSchema.databaseType) {
+                targetSchema.$defs?.databaseType?.enum?.push(pluginSchema.databaseType.name);
+                targetSchema.$defs?.databaseType?.enumDescriptions?.push(pluginSchema.databaseType.description);
+                targetSchema._cds_schema_overlays.push('databaseType')
+            }
+
+            if (pluginSchema.cds) {
+                if (targetSchema.$defs?.cdsRoot?.properties) {
+                    Object.assign(targetSchema.$defs.cdsRoot.properties, pluginSchema.cds)
+                    targetSchema._cds_schema_overlays.push('cdsRoot')
+                }
+
+                // backwards compatibility
+                if (targetSchema.properties) {
+                    Object.assign(targetSchema.properties, pluginSchema.cds)
+                    targetSchema._cds_schema_overlays.push('root')
+                }
+            }
+        }
+    }
+}
+
+module.exports = async function overlay4(schemaName) {
+    const path = require('path')
+    const { merge } = require('../init/merge')
 
-    // need to load @sap/cds from current cwd which might
-    // differ from initial cwd to get project specific cds version
-    const cds = require(require.resolve('@sap/cds', {
-        paths: [cwd, __dirname]
-    }))
+    const cds = require('../cds')
+    cds.root = process.cwd()
 
-    // force cds.root to be project root
-    cds.root = cwd
+    const { readJSON } = require('../util/fs')
 
-    // load defaults, throw err if schema not found
     let result;
     if (typeof cds.schema?.default4 === 'function') {
         result = await cds.schema.default4(schemaName)
     } else if (cds.env?.schemas?.[schemaName]) {
-        // backwards compatibility
+        // backwards compatibility, fails for invalid json files
         result = await readJSON(cds.env.schemas[schemaName])
     } else {
-        throw new Error(`cds ${cds.version} in ${cwd} does not support schema retrieval.`)
+        throw new Error(`cds ${cds.version} in ${cds.root} does not support schema retrieval.`)
+    }
+
+    if (schemaName !== 'cds-rc.json') {
+        return result
+    }
+
+    const oldTitle = result.title
+    const oldDescription = result.description
+    result._cds_schema_overlays = []
+
+    try {
+        const scheamFile = path.join(__dirname, 'schemas', schemaName.replace(/\.json$/, '.js'))
+        const schema = require(scheamFile)
+
+        await merge(schema).into(result)
+        result._cds_schema_overlays.push('cdsRoot')
+
+        if (result.properties) {
+            // backwards compatibility
+            await merge(schema.$defs.cdsRoot.properties).into(result.properties)
+            result._cds_schema_overlays.push('root')
+        }
+    } catch (err) {
+        console.error(err.message)
     }
 
-    // optional, don't throw if file not found
     try {
-        await merge(__dirname, 'schemas', schemaName).into(result)
-        result.description = result.description + ' - overlaid'
+        const pluginsLib = require(_local('@sap/cds/lib/plugins.js'))
+        if (pluginsLib) {
+            const oldRequire = pluginsLib.require
+            try {
+                pluginsLib.require = _robustRequire
+                const plugins = pluginsLib.fetch?.()
+                if (plugins) {
+                    for (const [key, { impl, packageJson }] of Object.entries(plugins)) {
+                        const pluginPackageJsonFile = packageJson || path.join(path.dirname(impl), 'package.json')
+                        try {
+                            const pluginPackageJson = require(pluginPackageJsonFile)
+                            if (pluginPackageJson.cds?.schema) {
+                                await mergePluginSchema(pluginPackageJson.cds.schema).into(result);
+                            }
+                        } catch (err) {
+                            if (err.code !== 'ENOENT') {
+                                console.error(`Error loading schema from plugin ${key}: ${err.message}`)
+                            }
+                        }
+                    }
+                }
+            } finally {
+                pluginsLib.require = oldRequire
+            }
+        }
     } catch (err) {
-        if (err.code !== 'ENOENT') throw err
+        console.error(err.message)
     }
 
+
+    result.title = oldTitle
+    result.description = oldDescription
     return result
 }

package/lib/env/schemas/cds-rc.js

@@ -0,0 +1,118 @@
+module.exports = {
+    title: "JSON schema for CDS-DK configuration",
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    description: "Build overlay",
+    $defs: {
+        cdsRoot: {
+            properties: {
+                // build specific schema
+                build: {
+                    type: "object",
+                    description: "Customize CDS build settings.",
+                    additionalProperties: true,
+                    properties: {
+                        target: {
+                            type: "string",
+                            description: "Specify the folder which contains generated build results. Defaults to './gen'.",
+                            format: "uri-reference"
+                        },
+                        tasks: {
+                            type: "array",
+                            description: "Control which tasks 'cds build' will execute on your project modules. This is a typical task configuration: '\"tasks\": [{ \"for\": \"hana\"}];",
+                            uniqueItems: true,
+                            default: [
+                                {}
+                            ],
+                            items: {
+                                type: "object",
+                                additionalProperties: true,
+                                properties: {
+                                    dest: {
+                                        type: "string",
+                                        description: "Optional: Define the destination folder for this build task, relative to build target folder. \nFor example: Destination defined as 'custom' results in an output written to 'gen/custom'.",
+                                        format: "uri-reference"
+                                    },
+                                    src: {
+                                        type: "string",
+                                        description: "Optional: Prefer defining 'cds.folders'. Use 'src' if you want it only to be valid for this specific build task, which excludes, for example, 'cds watch'.",
+                                        format: "uri-reference"
+                                    },
+                                    for: {
+                                        type: "string",
+                                        description: "Define the target technology for this build task.",
+                                        minLength: 1,
+                                        $ref: "#/$defs/buildTaskType"
+                                    },
+                                    options: {
+                                        type: "object",
+                                        description: "Optional: Set target technology specific options for this build task.",
+                                        additionalProperties: true,
+                                        properties: {
+                                            model: {
+                                                $ref: "#/$defs/foldersStringArray"
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+
+                // deploy specific schema
+                deploy: {
+                    type: "object",
+                    description: "Customize 'cds deploy' settings.",
+                    additionalProperties: true,
+                    properties: {
+                        no_save: {
+                            type: "boolean",
+                            description: "Do / don't update configuration in package.json.",
+                            default: true
+                        }
+                    }
+                }
+            }
+        },
+
+        buildTaskType: {
+            enum: [
+                "nodejs",
+                "java",
+                "hana",
+                "mtx-sidecar",
+                "mtx-extension",
+                "mtx",
+                "node-cf",
+                "java-cf"
+            ],
+            enumDescriptions: [
+                "Node.js build plugin",
+                "Java build plugin",
+                "SAP HANA build plugin",
+                "MTX sidecar build plugin",
+                "MTX extension build plugin",
+                "MTX build plugin",
+                "Node.js Cloud Foundry build plugin",
+                "Java Cloud Foundry build plugin"
+            ]
+        },
+
+        foldersStringArray: {
+            oneOf: [
+                {
+                    type: "string",
+                    format: "uri-reference"
+                },
+                {
+                    type: "array",
+                    uniqueItems: true,
+                    items: {
+                        type: "string",
+                        format: "uri-reference"
+                    }
+                }
+            ]
+        }
+    }
+}