@sap/cds-dk 7.8.2 → 7.9.1

package/lib/init/template/completion/completionSetup.js

@@ -0,0 +1,184 @@
+
+const cp = require('node:child_process');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+
+const { bold } = require('../../../util/term');
+
+const ENTRY_REGEX = /\n{0,2}# cds completion start(.+)# cds completion end/is;
+
+
+module.exports = new class CompletionSetup {
+    async setup(addEntry, options) {
+        const shell = options.shell
+            || (process.env.MSYSTEM?.includes('MINGW64') ? 'gitbash' : process.env.SHELL?.match(/(bash|zsh)/)?.[0])
+            || (process.env.PSModulePath ? 'ps' : null);
+
+        switch (shell) {
+            case 'bash':
+            case 'gitbash':
+            case 'zsh':
+                return this.setupBashZsh(addEntry, shell);
+            case 'ps':
+                return this.setupPs(addEntry);
+            case null:
+                try {
+                    const shellType = this.determineShellLinux();
+                    if (!shellType) {
+                        throw `Unsupported shell.\nSupported shells are: bash, zsh, gitbash, ps.`;
+                    }
+                    return this.setupBashZsh(addEntry, shellType);
+                } catch (err) {
+                    throw `Error during completion setup: ${err}`;
+                }
+            default:
+                throw `Unsupported shell: ${shell}.\nSupported shells are: bash, zsh, gitbash, ps.`;
+        }
+    }
+
+    getProfilePathWindows() {
+        const supportedShells = ['pwsh.exe', 'powershell.exe'];
+        try {
+            const parentPID = process.ppid;
+            const parentProcessDetails = cp.spawnSync('tasklist', ['/fi', `PID eq ${parentPID}`, '/nh', '/fo', 'csv'], { encoding: 'utf8' }).stdout.trim();
+            const parentProcess = parentProcessDetails.split(',')[0].replace(/"/g, '').trim();
+            if (!supportedShells.includes(parentProcess)) {
+                throw `Shell '${parentProcess}' is not supported. Make sure you are using PowerShell.`;
+            }
+
+            return cp.spawnSync(parentProcess, ['-NoProfile', '-c', 'echo $PROFILE'], { encoding: 'utf8' }).stdout.trim();
+        } catch (err) {
+            throw `Error during getting Windows shell profile path:\n${err}`;
+        }
+    }
+
+    determineShellLinux() {
+        try {
+            const parentPID = process.ppid;
+            return cp.spawnSync('ps', ['--pid', parentPID, '-ocomm='], { encoding: 'utf8' }).stdout.trim();
+        }
+        catch (err) {
+            throw `Error during getting Linux parent shell: ${err}`;
+        }
+    }
+
+    async createBackup(fileName) {
+        await fsp.copyFile(fileName, fileName + '.cds.bak');
+    }
+
+    async setupBashZsh(addEntry, shell) {
+        const isBash = shell.includes('bash'); // also for gitbash
+        const isZsh = shell.includes('zsh');
+        const isGitBash = shell.includes('gitbash');
+
+        if (!isBash && !isZsh) {
+            throw 'Completion is only supported for bash, zsh or Git Bash shell.';
+        }
+
+        const profileFile = path.join(
+            os.homedir(),
+            isZsh
+                ? '.zshrc'
+                : os.platform() === 'darwin' || isGitBash
+                    ? '.bash_profile'
+                    : '.bashrc'
+        );
+
+        await this.changeProfile(profileFile, shell, addEntry);
+
+        const relProfilePath = path.relative(os.homedir(), profileFile);
+        console.log(`\nSource your shell using\n${bold(`source ~/${relProfilePath}`)}\nto activate the changes.\n`);
+    }
+
+    async setupPs(addEntry) {
+        const profilePath = this.getProfilePathWindows();
+
+        try {
+            await fsp.access(profilePath);
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                throw `Profile file ${bold(profilePath)} does not exist.\nMake sure you are using PowerShell. CMD shell is not supported.`
+            }
+            throw err;
+        }
+
+        await this.changeProfile(profilePath, 'ps', addEntry);
+        console.log(`\nSource your shell using\n${bold('. $PROFILE')}\nto activate the changes.`);
+    }
+
+    getScript(shell) {
+        switch (shell) {
+            case 'ps':
+                return `
+try {
+    $CDS_PROFILE = cds completion --shell ps --profile 2> $null
+    if (Test-Path -Path "$CDS_PROFILE" -PathType Leaf) {
+        . $CDS_PROFILE
+    }
+} catch {}
+`
+            case 'bash':
+            case 'gitbash':
+                return `
+CDS_PROFILE=$(cds completion --shell ${shell} --profile 2> /dev/null) || CDS_PROFILE=""
+if [ -r "$CDS_PROFILE" ]; then
+    . "$CDS_PROFILE"
+fi
+`
+            case 'zsh':
+                return `
+# compinit can be removed here if loaded elsewhere in the script
+autoload -Uz compinit && compinit
+
+CDS_PROFILE=$(cds completion --shell zsh --profile 2> /dev/null) || CDS_PROFILE=""
+if [ -r "$CDS_PROFILE" ]; then
+    . "$CDS_PROFILE"
+fi
+`
+            default: throw `Unsupported shell: ${shell}`;
+        }
+    }
+
+    async changeProfile(profileFile, shell, addEntry) {
+        let profile = '';
+        let profileFileExists = true;
+        try {
+            profile = await fsp.readFile(profileFile, 'utf8');
+        } catch (err) {
+            profileFileExists = false;
+            await fsp.mkdir(path.dirname(profileFile), { recursive: true });
+        }
+
+        let changed;
+        if (profile.match(ENTRY_REGEX)) {
+            profile = profile.replace(ENTRY_REGEX, '');
+            changed = true;
+        }
+
+        if (addEntry) {
+            profile = profile + `
+
+# cds completion start
+${this.getScript(shell)}
+# cds completion end`;
+            changed = true;
+        }
+
+        console.log();
+
+        if (changed) {
+            const relProfilePath = path.relative(os.homedir(), profileFile);
+            if (profileFileExists) {
+                await this.createBackup(profileFile);
+                console.log(`Created backup ${bold(`~/${relProfilePath}.cds.bak`)}.`);
+            }
+            await fsp.writeFile(profileFile, profile);
+            if (addEntry) {
+                console.log(`Added entry to ${bold(`~/${relProfilePath}`)}.`);
+            } else {
+                console.log(`Removed entry from ${bold(`~/${relProfilePath}`)}.`);
+            }
+        }
+    }
+}

package/lib/init/template/completion/index.js

@@ -0,0 +1,22 @@
+const cds = require('../../../cds');
+
+
+module.exports = class CompletionTemplate extends require('../../plugin') {
+    options() {
+        return {
+            'shell': {
+                type: 'string',
+                short: 's',
+                help: `<optional> Forces completion setup for a given shell and disables auto detection.
+        Usually the shell is determined automatically and this is only for cases where the automatic
+        detection fails. Valid values: bash, gitbash, zsh, ps`
+            }
+        }
+    }
+
+    async run() {
+        const completionSetup = require('./completionSetup');
+        await completionSetup.setup(true, cds.cli.options);
+        process.exit(0);
+    }
+}

package/lib/init/template/data/as-csv.js

@@ -1,12 +1,13 @@
-// const cds = require('../../../cds')
+const { elementsSorter } = require('./as-json')
 
-module.exports = async (data={}, csn, { headerOnly=false, queries=false, separator=',' }={}) => {
-  if (!queries) { // remove all projection-like entities
-    Object.keys(data)
-      .map(name => csn.definitions[name])
-      .filter (entity => entity.query)
-      .forEach(entity => { delete data[entity.name] })
-  }
+/**
+ * Serializes the given JSON data to CSV format
+ * @param {object} data JSON data to serialize
+ * @param {object} csn the model
+ * @param {{ headerOnly: boolean, separator: boolean }} options
+ * @returns {Promise<string>} CSV string
+ */
+module.exports = async (data={}, csn, { headerOnly=false, separator=',' }={}) => {
 
   // We might need multiple passes if data for associations/compositions is created on the fly.
   // So loop as long as there is some non-string data left.
@@ -20,7 +21,8 @@ module.exports = async (data={}, csn, { headerOnly=false, queries=false, separat
       const records = []
       for (let i = 0; i < entityData.length; i++) {
         let record = []
-        for (const element of Object.values(entity.elements).sort(keyFirstSorter)) {
+        const elements = Object.values(entity.elements).sort(elementsSorter(csn))
+        for (const element of elements) {
           const name = element.name
           let value = entityData[i][name]
           if (value === undefined)
@@ -29,6 +31,9 @@ module.exports = async (data={}, csn, { headerOnly=false, queries=false, separat
             data[element.target] = value // Add object for a new entity. Next pass will process it.
           }
           else if (element._type === 'cds.Association') {
+            if (element.on) {
+              continue // skip unmanaged associations with explicit on condition
+            }
             if (i === 0) {
               header.push(...Object.keys(value).map(foreignKey => name + '_' + foreignKey))
             }
@@ -36,8 +41,10 @@ module.exports = async (data={}, csn, { headerOnly=false, queries=false, separat
           }
           else {
             if (i === 0)  header.push(name)
-            if (typeof value === 'string' && (value.includes('"') || value.includes(separator)))
-              value = `"${value.replace(/"/g, '""')}"` // escape double quotes, then quote the value
+            if (Array.isArray(value)) { // `array of` / `many`
+              value = JSON.stringify(value)
+            }
+            value = escape(value)
             record.push(value)
           }
         }
@@ -48,13 +55,14 @@ module.exports = async (data={}, csn, { headerOnly=false, queries=false, separat
         res += '\n' + records.join('\n')
 
       data[entity.name] = res
+
+      function escape(value) {
+        if (typeof value === 'string' && (value.includes('"') || value.includes(separator))) {
+          return `"${value.replace(/"/g, '""')}"` // escape double quotes, then quote the value
+        }
+        return value
+      }
     })
   }
   return data
 }
-
-function keyFirstSorter(e1, e2) {
-  if (e1.key && !e2.key) return -1
-  if (!e1.key && e2.key) return 1
-  return 0 // preserve original order otherwise
-}

package/lib/init/template/data/as-json.js

@@ -5,14 +5,23 @@ const cds = require('../../../cds')
 let counter = Math.round(Math.random() * 10000) // Default random seed // Non-deterministic behaviour
 const MAX_ASSOC_DEPTH = 1
 
-module.exports = async (data, csn, numRecords=1, existingData) => {
+/**
+ * Creates JSON test data for the given entities
+ *
+ * @param {Record<string, object[]>|undefined} data the data with entities and their records to be created
+ * @param {object} csn the model
+ * @param {Number} numRecords the number of records to be created for each entity
+ * @param {{referenceData? : Record<string, string}} options misc. options
+ * @returns {Record<string, object[]>} the filled data
+ */
+const asJson = module.exports = async (data, csn, numRecords=1, options={}) => {
+  let { referenceData } = options
+
   // if no entity restrictions are given, use all entities
   if (!data)  data = csn.all('entity').reduce((all, e) => { all[e.name] = []; return all }, {})
 
-  if (!existingData)
-    existingData = await cds.deploy.resources(csn)
-
-  addSemantics(csn)
+  // if no reference data is given, scan for it using cds.deploy.resources
+  if (!referenceData)  referenceData = await cds.deploy.resources(csn)
 
   // sort all entities first that are referenced by others, so that dependant entities can be created after them
   const { definitions: defs } = csn
@@ -24,6 +33,11 @@ module.exports = async (data, csn, numRecords=1, existingData) => {
     return 0
   })
 
+  // requested entities shall always be created, so remove it from reference data
+  Object.entries(referenceData).filter(([, name]) => entityNames.includes(name)).forEach(([file]) => delete referenceData[file])
+
+  addSemantics(csn)
+
   for (const name of entityNames) {
     if (!data[name] // removed on purpose because records are created inline through compositions
       || data[name].length >= numRecords) { // already created by following associations
@@ -35,33 +49,63 @@ module.exports = async (data, csn, numRecords=1, existingData) => {
 
     const idNum = randomNumber()
     for (let i = 0; i < numRecords; i++) {
-      fillRecord(records[i], idNum+i, entity, csn, data, null, 0, existingData)
+      fillRecord(records[i], idNum+i, entity, csn, data, null, 0, referenceData)
     }
+    // Remove records w/ duplicate keys. This can happen if the key is an enum (and we have less enum values than requested records).
+    data[name] = uniqRecords(records, entity)
   }
   return data
 }
 
-function fillRecord(record, recordID, entity, csn, data, parentEntity, depth, existingData) {
+function fillRecord(record, recordID, entity, csn, data, parentEntity, depth, referenceData) {
   Object.defineProperty(record, '$id', {value: recordID, enumerable: false})
 
   const { elements } = entity
-
-  // fill in the keys first, to have them ready for foreign key refs
-  const keys = Object.keys(entity.keys||{})
-  for (const key of keys) {
-    record[key] = dataForField(elements[key], entity, csn, record, data, parentEntity, depth, existingData)
-  }
-  // non-key elements
-  Object.keys(elements).filter(name => !keys.includes(name)).forEach(name => {
-    record[name] = dataForField(elements[name], entity, csn, record, data, parentEntity, depth, existingData)
+  Object.values(elements).sort(asJson.elementsSorter(csn)).forEach(el => {
+    record[el.name] = dataForField(el, entity, csn, record, data, parentEntity, depth, referenceData)
   })
   return record
 }
 
-function dataForField(element, entity, csn, record, data, parentEntity, depth, existingData) {
-  if (element.virtual || element['@Core.Computed'])
+asJson.elementsSorter = function (csn) {
+  return (el1, el2) => {
+    // keys first, need to have them ready first for foreign key resolution anyway
+    if ( el1.key  && !el2.key) return -1
+    if (!el1.key  &&  el2.key) return 1
+    // own elements first
+    if ( isOwnElement(el1, el1.parent) && !isOwnElement(el2, el2.parent)) return -1
+    if (!isOwnElement(el1, el1.parent) &&  isOwnElement(el2, el2.parent)) return 1
+    return 0
+  }
+  function isOwnElement(el, entity) {
+    if (entity && entity === el.parent && (!entity.includes || entity.includes.length === 0)) {
+      // shortcut if element's entity has no includes
+      return true
+    }
+    // look for elements in entity includes/parents
+    for (const inc of entity?.includes||[]) {
+      if (csn.definitions[inc]?.elements?.[el.name])  return false
+      if (!isOwnElement(el, csn.definitions[inc]))  return false
+    }
+    return true
+  }
+}
+
+
+function dataForField(element, entity, csn, record, data, parentEntity, depth, referenceData) {
+  if (element.virtual || (element['@Core.Computed'] && element.value))
     return
-  switch (element._type) {
+  if (record[element.name] !== undefined)
+    return record[element.name] // value is already set by previous run, e.g. CodeList.code sets .name and .descr
+
+  if (element.items?.elements)  // `array of` / `many` with complex type
+    return [ fillRecord({}, record['$id'], element.items, csn, data, null, depth+1, referenceData) ]
+  else if (element.items?.type) // `array of` / `many` with simple type
+    return [ dataForField(element.items, entity, csn, record, data, null, depth+1, referenceData) ]
+
+  const type = element._type || element.type
+  switch (type) {
+    case undefined: return
     case 'cds.Time':
       return '22:59:53'
 
@@ -84,14 +128,22 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
       return generatedDate.toISOString()
     }
 
+    case 'cds.hana.CHAR':
+    case 'cds.hana.CLOB':
+    case 'cds.hana.NCHAR':
+    case 'cds.hana.VARCHAR':
     case 'cds.LargeString':
     case 'cds.String': {
       if (element['@data.gen']?.startsWith('faker.')) {
         return fakerValue(element['@data.gen'], csn)
       }
       if (element.enum) {
-        const enums = Object.entries(element.enum).map(([name, val]) => val.value ?? name)
-        return randomFromList(enums)
+        const enumName = randomFromList(Object.keys(element.enum))
+        const value = element.enum[enumName].val ?? element.enum[enumName].value ?? enumName
+        // key of common.CodeList, also fill name and descr with enum name
+        if (element.key && entity.elements.name && entity.elements.descr)
+          record.name = record.descr = enumName
+        return value
       }
       if (entity['@Communication.Contact.email']?.some(mail => mail.address?.['='] === element.name)
         || element['@Communication.IsEmailAddress']
@@ -105,7 +157,7 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
       if (element.key) {
         str = `${entity.name.split('.').pop()}-${record['$id']}`
         if (element.name === 'locale' && entity.name.endsWith('texts')) {
-          const record = randomFromExistingData(entity, csn, existingData)
+          const record = randomFromReferenceData(entity, csn, referenceData)
           if (record)  return record.locale
           return randomLanguage()
         }
@@ -129,19 +181,26 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
     case 'cds.Boolean':
       return (record['$id'].toString(2).at(-1)) < 0.5
 
+    case 'cds.hana.SMALLINT':
+    case 'cds.hana.TINYINT':
+    case 'cds.UInt8':
     case 'cds.Int16':
+    case 'cds.Int32':
+    case 'cds.Int64':
     case 'cds.Integer64':
     case 'cds.Integer': {
       if (element.key)
         return record['$id']
       if (element.enum) {
-        const enums = Object.values(element.enum).map((value) => value.val)
-        return parseInt(randomFromList(enums))
+        const enumName = randomFromList(Object.keys(element.enum))
+        const value = element.enum[enumName].val ?? element.enum[enumName].value ?? enumName
+        return parseInt(value)
       }
       const range = {from: 0, to: 100}
       annotatedIntRange(element, range)
       return randomIntInRange(range)
     }
+    case 'cds.hana.REAL':
     case 'cds.Decimal': {
       const range = {from: 0, to: 100}
       annotatedIntRange(element, range)
@@ -163,7 +222,7 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
       const targetRecordCount = element.is2many ? 2 : 1 // TODO: make this configurable
       const targetRecordID = randomNumber()
       for (let i = 0; i < targetRecordCount; i++) {
-        targetRecords.push(fillRecord({}, targetRecordID+i, target, csn, data, entity, depth+1, existingData))
+        targetRecords.push(fillRecord({}, targetRecordID+i, target, csn, data, entity, depth+1, referenceData))
       }
 
       const [ownKey, ownKeyStructured, targetKey] = findKeysInOnCondition(element, target)
@@ -174,6 +233,7 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
           Object.defineProperty(targetRecord, targetKey, { value, enumerable: false })
         })
       }
+      uniqRecords(targetRecords, target)
 
       // set the entire target record inline
       return element.is2many ? targetRecords : targetRecords[0]
@@ -185,7 +245,7 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
       if (!target || target === parentEntity || depth > MAX_ASSOC_DEPTH)
         return
 
-      let targetRecord = randomFromExistingData(target, csn, existingData)
+      let targetRecord = randomFromReferenceData(target, csn, referenceData)
       if (targetRecord) {
         delete data[target.name] // indicate that existing data is used and no new data shall be created
         delete data[target.name + '.texts'] // also delete associated texts entity
@@ -197,8 +257,9 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
         else if (!targetRecords) // target entity is not in the list of entities to be created
           return
 
-        targetRecord = fillRecord({}, randomNumber(), target, csn, data, entity, depth, existingData)
+        targetRecord = fillRecord({}, randomNumber(), target, csn, data, entity, depth, referenceData)
         targetRecords.push(targetRecord)
+        uniqRecords(targetRecords, target)
       }
 
       // TODO: handle foreign keys correctly
@@ -208,14 +269,22 @@ function dataForField(element, entity, csn, record, data, parentEntity, depth, e
         .forEach(keyName => assoc[keyName] = targetRecord[keyName])
       return assoc
     }
+
+    case 'cds.hana.BINARY':
+    case 'cds.Binary':
+    case 'cds.LargeBinary': // TODO add binary
+      return
+    case 'cds.Vector': // TODO add Vector
+      return
     default: {
-      throw new Error(`Unknown type '${element.type}' in '${entity.name}:${element.name}'`)
+      console.error(`Unknown type ${element._type} (${element.type}) in '${entity.name}:${element.name}'`)
+      return
     }
   }
 }
 
-function randomFromExistingData (entity, csn, existingData) {
-  const files = Object.entries(existingData)
+function randomFromReferenceData (entity, csn, referenceData) {
+  const files = Object.entries(referenceData)
     .filter(([, name]) => matchesEntityOrProjection(name, entity, csn))
     .map(([file]) => file)
   if (files.length === 0)  return
@@ -281,6 +350,22 @@ function findKeysInOnCondition(assocElement, target) {
   return [ownKey, ownKeyStructured, targetKey]
 }
 
+function uniqRecords(records, entity) {
+  const keys = Object.keys(entity.keys||{})
+  if (keys.length === 0)  return records
+  const keySet = new Set()
+  for (let i = 0; i < records.length; i++) {
+    const key = keys.map(k => records[i][k]).join('|')
+    if (keySet.has(key)) {
+      // console.debug('Removing', keys, key, 'from', entity.name)
+      records.splice(i, 1)
+      i--
+    }
+    keySet.add(key)
+  }
+  return records
+}
+
 function annotatedDateRange(el, dateRange) {
   if (el['@assert.range']?.length === 2) {
     const dateFrom = new Date(el['@assert.range'][0])

package/lib/init/template/data/index.js

@@ -1,5 +1,6 @@
 const cds = require('../../../cds')
 const { exists, fs } = cds.utils
+const { dim } = require('../../../util/term')
 const { resolve, join, relative }  = require('path')
 const { URLSearchParams } = require('url')
 const { env4 } = require('../../projectReader')
@@ -14,8 +15,8 @@ module.exports = class DataTemplate extends require('../../plugin') {
         type: 'string',
         short: 'f',
         help: `Filter for entities matching the given pattern. If it contains meta
-        characters like '^' or '*', it is treated like a regular expression,
-        otherwise as a prefix.`
+        characters like '^' or '*', it is treated as a regular expression,
+        otherwise as an include pattern, i.e /.*pattern.*/i`
       },
       'data:for': {
         type: 'string',
@@ -52,8 +53,9 @@ module.exports = class DataTemplate extends require('../../plugin') {
     if (Number.isNaN(records) || records < 1) records = 1
 
     const [filterName, filterQueryStr] = (cds.cli.options['filter'] ?? cds.cli.options['data:for'] ?? '').split(':')
-    const nameFilter = asRegex(filterName)
+    const nameFilter = filterStringAsRegex(filterName)
     const dataForParams = parseQueryStr(filterQueryStr)
+    const { queries } = dataForParams
 
     const env = env4('production')
     let dest = (typeof out === 'string') // target folder
@@ -68,33 +70,43 @@ module.exports = class DataTemplate extends require('../../plugin') {
 
     const data = csn.all('entity')
       .filter (e => e.name.match(nameFilter)) // --for prefix|regex
+      .filter (e => queries || !e.query) // remove all projection-like entities unless specified differently
       .reduce((all, e) => { all[e.name] = []; return all }, {})
 
     await asJson(data, csn, records)
 
     if (contentType === 'csv') {
       const headerOnly = !cds.cli.options['records'] // compat to old behavior which only creates headers
-      const queries = false // old behavior excluded queries
-      await asCsv(data, csn, Object.assign({ headerOnly, queries }, dataForParams))
+      await asCsv(data, csn, Object.assign({ headerOnly }, dataForParams))
     }
 
     // write files
-    for (const name of Object.keys(data)) {
+    for (const name of Object.keys(data).sort()) {
       writeFileFor(csn.definitions[name], data[name], csn, dest, force)
     }
   }
 }
 module.exports.asJson = asJson
 module.exports.asCsv = asCsv
-
-function asRegex(spec) {
+module.exports.filterStringAsRegex = filterStringAsRegex
+
+/**
+ * Turns a filter string with optional meta characters into a regular expression.
+ * If no meta characters are found, the string is treated as an include pattern.
+ *
+ * @param {string} spec the filter string
+ * @returns {RegExp} the regular expression
+ */
+function filterStringAsRegex(spec) {
   if (typeof spec === 'string') {
     try {
-      if (spec.match(/[\^$|*]/))
-        return new RegExp(spec)
-      else { // no meta chars -> prefix semantics
-        spec = spec.replace(/\./g, '\\.') // escape dot
-        return new RegExp('^'+spec+'.*')
+      if (spec.match(/[\^$|*]/)) {
+        spec = spec.replace(/^\*/, '.*')  // * at start would be invalid, so make it a .*
+        return new RegExp(spec, 'i')
+      }
+      else { // no meta chars -> include semantics
+        spec = spec.replace(/\./g, '\\.') // escape literal dot
+        return new RegExp(spec, 'i')
       }
     } catch (err) {
       throw err.message // user error, so cut off stack trace
@@ -149,7 +161,7 @@ function writeFileFor (entity, data, csn, dest, force) {
 
   // continue only if file not already exists, or '--force' option provided
   if (fileExists && !force) {
-    console.log(`Skipping ${relFilePath}`)
+    console.log(`  ${dim('Skipping ' + relFilePath)}`)
     return
   }
 
@@ -158,7 +170,8 @@ function writeFileFor (entity, data, csn, dest, force) {
   if (data.length) {
     if (!exists(dest))  fs.mkdirSync(dest, {recursive: true})
     fs.writeFileSync(dataFilePath, data)
-    fileExists ? console.log(`Overwriting `+relFilePath) : console.log(`Creating `+relFilePath)
+    if (fileExists) console.log(`  ${dim('Overwriting ' + relFilePath)}`)
+    else console.log(`  ${dim('Creating ' + relFilePath)}`)
   }
 }
 

package/lib/init/template/hana/files/undeploy.json

@@ -2,5 +2,6 @@
     "src/gen/**/*.hdbview",
     "src/gen/**/*.hdbindex",
     "src/gen/**/*.hdbconstraint",
-    "src/gen/**/*_drafts.hdbtable"
+    "src/gen/**/*_drafts.hdbtable",
+    "src/gen/**/*.hdbcalculationview"
 ]

package/lib/init/template/helm/files/chart/values.schema.json

@@ -187,7 +187,7 @@
                             ],
                             "properties": {
                                 "fromSecret": {
-                                    "description": "Name of a Kubernetes Secret, with the binding content, compliant to the SAP Kubernetes Service Binding spec https://github.tools.sap/Kubernetes-Service-Bindings/doc/",
+                                    "description": "Name of a Kubernetes Secret, with the binding content, compliant to the SAP Kubernetes Service Binding spec",
                                     "$ref": "#/definitions/KubernetesName"
                                 }
                             }

package/lib/init/template/helm/files/content-deployment/Chart.yaml

@@ -1,7 +1,5 @@
 apiVersion: v2
 description: A Helm Chart for creating a Content Deployment job
 name: content-deployment
-sources:
-- https://github.tools.sap/unified-runtime/content-deployment
 type: application
 version: 1.6.0