@sap/cds-dk 7.7.2 → 7.8.0

package/lib/index.js

@@ -46,9 +46,9 @@ class CdsDkAdd {
 class CdsDkBuild {
   get build() { return super.build = require('./build') }
 }
-if (process.argv[2] in { 'add':1, 'init':1 }) {
+if (process.argv[2] in { add:1, init:1, help:1 }) {
   cds.extend (cds.constructor) .with (CdsDkAdd)
-} else if (process.argv[2] in { 'build':1, 'deploy':1, 'push':1 }) {
+} else if (process.argv[2] in { build:1, deploy:1, push:1 }) {
   cds.extend (cds.constructor) .with (CdsDkBuild)
 }
 

package/lib/init/constants.js

@@ -4,7 +4,7 @@ module.exports = {
     COMMAND_INIT: 'init',
     COMMAND_ADD: 'add',
 
-    MAVEN_ARCHETYPE_VERSION: '2.7.0',
+    MAVEN_ARCHETYPE_VERSION: '2.7.1',
 
     OPTIONS: Object.freeze({
         JAVA: 'java',
@@ -35,6 +35,7 @@ module.exports = {
         ENTERPRISE_MESSAGING: 'enterprise-messaging',
         ENTERPRISE_MESSAGING_SHARED: 'enterprise-messaging-shared',
         REDIS_MESSAGING: 'redis-messaging',
+        KAFKA: 'kafka',
         APPROUTER: 'approuter',
         DESTINATION: 'destination',
         DATA: 'data',

package/lib/init/index.js

@@ -100,11 +100,11 @@ module.exports = class CDSGenerator {
     }
 
     /**
-     * @param {string} facets, comma separated list of templates, no blanks
+     * @param {string} facets, comma separated list of facets
      * @param {any} options, additional options
      */
-    async addCmd(facets) {
-        if (!facets) throw 'You must specify a facet to add to the project.'
+    async add(facets) {
+        if (!facets?.length) throw 'You must specify a facet to add to the project.'
 
         this._initialize(null);
         this._greetings();
@@ -113,7 +113,7 @@ module.exports = class CDSGenerator {
             throw `The current folder doesn't seem to contain a project. None of the following files found: ${PROJECT_FILES.join(', ')}.`
         }
 
-        await this._process();
+        await this._process(facets);
         await this.stepEnd();
     }
 
@@ -170,11 +170,11 @@ module.exports = class CDSGenerator {
         }
     }
 
-    async _process() {
+    async _process(facets) {
         DEBUG?.(`Project path: ${cds.root}`);
 
         await this._validateOptions();
-        await this._fillTemplateList();
+        await this._fillTemplateList(facets);
 
         for (const template of this.templateList) {
             console.log(`Adding feature '${template.name}'...`);
@@ -216,11 +216,11 @@ module.exports = class CDSGenerator {
         }
     }
 
-    async _fillTemplateList() {
+    async _fillTemplateList(facets) {
         const templates = new Map
-        const { command, options, argv } = cds.cli
+        const { command, options } = cds.cli
 
-        const plugins = command === COMMAND_INIT ? options.add : new Set(argv[0].split(','))
+        const plugins = command === COMMAND_INIT ? options.add : new Set(facets)
 
         for (let plugin of plugins) {
             // Compat
@@ -299,20 +299,6 @@ module.exports = class CDSGenerator {
         if (cds.cli.command === COMMAND_INIT && !options.add.has(JAVA)) {
             options.add.add(NODEJS);
         }
-
-        this._checkAdditionalOptions();
-    }
-
-    _checkAdditionalOptions() {
-        const { options } = cds.cli
-        for (const [key] of Object.entries(options)) {
-            const keySplit = key.split(/:/)
-            if (keySplit.length === 2) {
-                if (!options.add.has(keySplit[0])) {
-                    console.log(`ignoring option ${key} since ${keySplit[0]} is not part of specified feature list: ${Array.from(options.add).join(', ')}`)
-                }
-            }
-        }
     }
 
     async _validateOptions() {

package/lib/init/plugin.js

@@ -10,6 +10,14 @@ module.exports = class Plugin {
         this.name = this.constructor.name.replace(/template/i, '').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
     }
 
+    /**
+     * Provides command-line options for the plugin.
+     * @returns {Array.<{option: string, flag: string, shortcut?: string, help: string}>}
+     */
+    options() {
+        return []
+    }
+
     /**
      * Gets the required templates.
      * @returns {string[]} An array of strings representing required plugins.

package/lib/init/registries/mta.js

@@ -32,6 +32,11 @@ const enterpriseMessaging = {
     where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'enterprise-messaging' }
 }
 
+const kafkaMessaging = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'kafka' }
+}
+
 const applicationLogging = {
     in: 'resources',
     where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'application-logs' }
@@ -144,6 +149,7 @@ module.exports = {
     destination,
     connectivity,
     enterpriseMessaging,
+    kafkaMessaging,
     hdbDeployer,
     hdiContainer,
     notificationTypesDeployer,

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

@@ -0,0 +1,60 @@
+// const cds = require('../../../cds')
+
+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] })
+  }
+
+  // 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.
+  while (Object.values(data).some(d => typeof d === 'object')) {
+    Object.entries(data)
+    .filter(([_, value]) => typeof value === 'object')
+    .map(([name]) => csn.definitions[name])
+    .forEach(entity => {
+      const entityData = data[entity.name]
+      const header = []
+      const records = []
+      for (let i = 0; i < entityData.length; i++) {
+        let record = []
+        for (const element of Object.values(entity.elements).sort(keyFirstSorter)) {
+          const name = element.name
+          let value = entityData[i][name]
+          if (value === undefined)
+            continue
+          if (element._type === 'cds.Composition') {
+            data[element.target] = value // Add object for a new entity. Next pass will process it.
+          }
+          else if (element._type === 'cds.Association') {
+            if (i === 0) {
+              header.push(...Object.keys(value).map(foreignKey => name + '_' + foreignKey))
+            }
+            record.push(...Object.values(value))
+          }
+          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
+            record.push(value)
+          }
+        }
+        records.push(record.join(separator))
+      }
+      let res = header.join(separator)
+      if (!headerOnly)
+        res += '\n' + records.join('\n')
+
+      data[entity.name] = res
+    })
+  }
+  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

@@ -0,0 +1,441 @@
+const { randomUUID } = require('node:crypto')
+const { dirname } = require('node:path')
+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) => {
+  // 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)
+
+  // sort all entities first that are referenced by others, so that dependant entities can be created after them
+  const { definitions: defs } = csn
+  const entityNames = Object.keys(data).sort((n1, n2) => {
+    const n1HasComp = Object.values(defs[n1].elements).some(el => el.type === 'cds.Composition')
+    const n2HasComp = Object.values(defs[n2].elements).some(el => el.type === 'cds.Composition')
+    if (n1HasComp && !n2HasComp)  return -1
+    if (!n1HasComp && n2HasComp)  return 1
+    return 0
+  })
+
+  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
+      continue
+    }
+
+    const records = data[name] = Array(numRecords).fill({}).map(() => ({}))
+    const entity = defs[name]
+
+    const idNum = randomNumber()
+    for (let i = 0; i < numRecords; i++) {
+      fillRecord(records[i], idNum+i, entity, csn, data, null, 0, existingData)
+    }
+  }
+  return data
+}
+
+function fillRecord(record, recordID, entity, csn, data, parentEntity, depth, existingData) {
+  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)
+  })
+  return record
+}
+
+function dataForField(element, entity, csn, record, data, parentEntity, depth, existingData) {
+  if (element.virtual || element['@Core.Computed'])
+    return
+  switch (element._type) {
+    case 'cds.Time':
+      return '22:59:53'
+
+    case 'cds.Timestamp': {
+      const range = {from: new Date('2000-01-01'), to: new Date('2024-01-01')}
+      return randomDateInRange(range).toISOString()
+    }
+    case 'cds.Date': {
+      const range = {from: new Date('2000-01-01'), to: new Date('2024-01-01')}
+      annotatedDateRange(element, range)
+      const generatedDate = randomDateInRange(range)
+      const date = generatedDate.toISOString().split('T', 1)[0]
+      return date
+    }
+
+    case 'cds.DateTime': {
+      const range = {from: new Date('2000-01-01'), to: new Date('2024-01-01')}
+      annotatedDateRange(element, range)
+      const generatedDate = randomDateInRange(range)
+      return generatedDate.toISOString()
+    }
+
+    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)
+      }
+      if (entity['@Communication.Contact.email']?.some(mail => mail.address?.['='] === element.name)
+        || element['@Communication.IsEmailAddress']
+        || element['@cds.on.insert']?.['='] === '$user'
+        || element['@cds.on.update']?.['='] === '$user') {
+        return randomEmailAddress(element.name, record['$id'], csn)
+      }
+
+      let str = `${element.name}-${record['$id']}`
+
+      if (element.key) {
+        str = `${entity.name.split('.').pop()}-${record['$id']}`
+        if (element.name === 'locale' && entity.name.endsWith('texts')) {
+          const record = randomFromExistingData(entity, csn, existingData)
+          if (record)  return record.locale
+          return randomLanguage()
+        }
+      }
+      if (element['@assert.format']) {
+        str = randomStrForRegex(element['@assert.format'], csn)
+      }
+
+      if (element.length && str.length > element.length) {
+        str = str.slice(-element.length) // truncate to length
+      }
+      return str
+    }
+
+    case 'cds.UUID': {
+      // create a pseudo-random UUID based on the record ID
+      const idStr = '' + record['$id']
+      return idStr + randomUUID().slice(idStr.length)
+    }
+
+    case 'cds.Boolean':
+      return (record['$id'].toString(2).at(-1)) < 0.5
+
+    case 'cds.Int16':
+    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 range = {from: 0, to: 100}
+      annotatedIntRange(element, range)
+      return randomIntInRange(range)
+    }
+    case 'cds.Decimal': {
+      const range = {from: 0, to: 100}
+      annotatedIntRange(element, range)
+      return +(randomDecimalInRange(range).toFixed(element.scale ?? 2))
+    }
+    case 'cds.Double': {
+      const range = {from: 0, to: 100}
+      return randomDecimalInRange(range)
+    }
+    case 'cds.Composition': {
+      const target = csn.definitions[element.target]
+      if (!target)
+        return
+      delete data[target.name] // as data for the target is created inline below, no need to have it separately
+      if (target === parentEntity || depth > MAX_ASSOC_DEPTH)
+        return
+
+      const targetRecords = []
+      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))
+      }
+
+      const [ownKey, ownKeyStructured, targetKey] = findKeysInOnCondition(element, target)
+      if (ownKey && targetKey) {
+        const value = ownKeyStructured ? { [ownKey]: record[ownKey] } : record[ownKey]
+        targetRecords.forEach(targetRecord => {
+          // Set parent in target as non-enumerable. Json serialization doesn't need it, but csv does.
+          Object.defineProperty(targetRecord, targetKey, { value, enumerable: false })
+        })
+      }
+
+      // set the entire target record inline
+      return element.is2many ? targetRecords : targetRecords[0]
+    }
+    case 'cds.Association': {
+      if (element.is2many)
+        return
+      const target = csn.definitions[element.target]
+      if (!target || target === parentEntity || depth > MAX_ASSOC_DEPTH)
+        return
+
+      let targetRecord = randomFromExistingData(target, csn, existingData)
+      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
+      }
+      else {
+        let targetRecords = data[target.name]
+        if (!targetRecords && (element['@mandatory']) || element['@assert.target'])
+          targetRecords = data[target.name] = []
+        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)
+        targetRecords.push(targetRecord)
+      }
+
+      // TODO: handle foreign keys correctly
+      const assoc = {}
+      Object.keys(target.elements)
+        .filter(keyName => target.elements[keyName].key)
+        .forEach(keyName => assoc[keyName] = targetRecord[keyName])
+      return assoc
+    }
+    default: {
+      throw new Error(`Unknown type '${element.type}' in '${entity.name}:${element.name}'`)
+    }
+  }
+}
+
+function randomFromExistingData (entity, csn, existingData) {
+  const files = Object.entries(existingData)
+    .filter(([, name]) => matchesEntityOrProjection(name, entity, csn))
+    .map(([file]) => file)
+  if (files.length === 0)  return
+
+  if (files[0].endsWith('.csv')) {
+    const content = cds.utils.fs.readFileSync(files[0]).toString()
+    const records = cds.parse.csv(content)
+    if (records?.length > 1) {
+      const header = records[0] // 0 is header line
+      const randomRecord = records.length === 2 ? records[1] : records[randomIntInRange({from: 1, to: records.length-1} )]
+      let result = {}
+      for (let i = 0; i < records[0].length; i++) {
+        result[header[i]] = randomRecord[i]
+      }
+      return result
+    }
+  }
+  else {
+    let content
+    if (files[0].endsWith('.json')) {
+      content = cds.utils.fs.readFileSync(files[0]).toString()
+    } else {
+      content = files[0] // for tests, assuming the content is given inline
+    }
+    if (content) {
+      const records = JSON.parse(content)
+      if (records.length === 1)
+        return records[0]
+      else if (records.length > 1)
+        return records[randomIntInRange({from: 0, to: records.length-1} )]
+    }
+  }
+}
+
+/* whether the given name matches the entity or one of its projections */
+function matchesEntityOrProjection(name, entity, csn) {
+  if (name === entity?.name)  return true
+  // follow simle projections
+  const p = entity?.query?.SELECT || entity?.projection
+  if (p?.from?.ref?.length === 1) {
+    if (p.from.ref[0] === name)  return true
+    return matchesEntityOrProjection(name, csn.definitions[p.from.ref[0]], csn)
+  }
+}
+
+function findKeysInOnCondition(assocElement, target) {
+  const { on } = assocElement
+  let ownKey, targetKey, ownKeyStructured
+  if (on?.length === 3 && on[1] === '=') {
+    for (let { ref } of [on[0], on[2]]) {
+      if (ref.length > 1 && ref[0] === assocElement.name && target.elements[ref[1]]) {
+        targetKey = ref[1]
+      }
+      else if (ref[0] === '$self') {
+        ownKey = Object.keys(assocElement.parent.keys)[0]  // TODO composite keys
+        ownKeyStructured = true
+      }
+      else if (assocElement.parent.elements[ref[0]]) {
+        ownKey = ref[0]
+      }
+    }
+  }
+  return [ownKey, ownKeyStructured, targetKey]
+}
+
+function annotatedDateRange(el, dateRange) {
+  if (el['@assert.range']?.length === 2) {
+    const dateFrom = new Date(el['@assert.range'][0])
+    const dateTo = new Date(el['@assert.range'][1])
+    if (dateRange.from < dateFrom) {
+      dateRange.from = dateFrom
+    }
+    if (dateRange.to > dateTo) {
+      dateRange.to = dateTo
+    }
+  }
+}
+
+function annotatedIntRange(el, intRange) {
+  if (el['@assert.range']?.length === 2) {
+    const rangeFrom = el['@assert.range'][0]
+    const rangeTo = el['@assert.range'][1]
+    if (Number.isInteger(rangeFrom) && intRange.from < rangeFrom) {
+      intRange.from = rangeFrom
+    }
+    if (Number.isInteger(rangeTo) && intRange.to > rangeTo) {
+      intRange.to = rangeTo
+    }
+  }
+   //TODO : decimalRange
+}
+
+const langList = ['ar', 'cs', 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja', 'ko', 'ms', 'nl', 'pl', 'pt', 'ro', 'ru', 'sv', 'th', 'tr', 'zh']
+function randomLanguage() {
+  return randomFromList(langList)
+
+}
+function randomFromList(list) {
+  return list[randomNumber() % list.length]
+}
+
+function randomEmailAddress(firstName, num, csn) {
+  let addr = fakerValue('faker.internet.email', csn, false)
+  if (addr)  return addr
+  const provider = randomFromList(['example.com', 'example.org', 'example.net'])
+  return `${firstName}.${num.toString(36)}@${provider}`
+}
+
+function randomStrForRegex(regexStr, csn) {
+  // TODO make 'randexp' a hard dependency when this code is in a plugin
+  const randexp = requirePackage('randexp', csn, regexStr)
+  if (!randexp)  return `Install package 'randexp' to create data for regex ${regexStr}`
+  return randexp.randexp(regexStr)
+}
+
+function fakerValue(expr, csn, useFallback=true, ...args) {
+  // `en` bundle is way smaller than full faker. TODO use different Faker locales?
+  const Faker = requirePackage('@faker-js/faker/locale/en', csn)
+  if (!Faker && !useFallback)  return
+  if (!Faker)  return `Install package '@faker-js/faker' to create data for ${expr}`
+
+  let resultPart
+  let [, category, func] = expr.split('.')
+  const cat = Faker.faker[category]
+  if (typeof cat !== 'object')  return `Unknown faker category ${category} in ${expr}`
+  const funcParts = func.split('::')
+  if (funcParts.length === 2) {
+    resultPart = funcParts.pop()
+    func = funcParts.pop()
+  }
+  const fn = cat[func]
+  if (typeof fn !== 'function')  return `Unknown faker function ${func} in ${expr}`
+  if (category === 'internet' && func === 'email') {
+    // only allow domains that cannot be registered
+    const provider = randomFromList(['example.com', 'example.org', 'example.net'])
+    return fn({ provider })
+  }
+  let res = args ? fn(...args) : fn()
+  if (res && resultPart) {
+    return res[resultPart]
+  }
+  return res
+}
+
+const packages = {}
+function requirePackage(id, csn) {
+  try {
+    if (!packages[id]) {
+      const pkg = resolvePackage(id, csn)
+      if (pkg)
+        packages[id] = require(pkg)
+    }
+    return packages[id]
+  } catch (err) {
+    if (err.code !== 'MODULE_NOT_FOUND')  throw err
+  }
+}
+
+function resolvePackage(id, csn) {
+  try {
+    return require.resolve(id, { paths: [...csn.$sources.map(dirname), cds.root, __dirname] })
+  } catch (err) {
+    if (err.code !== 'MODULE_NOT_FOUND')  throw err
+
+  }
+}
+
+// add semantics to well-known entities
+function addSemantics(csn) {
+  if (resolvePackage('@faker-js/faker', csn)) { // only if faker is installed
+    csn.all('entity').forEach(entity => {
+      const { elements } = entity
+      if (entity.name === 'sap.common.Countries') {
+        elements.code['@data.gen'] = 'faker.location.countryCode'
+        elements.name['@data.gen'] = elements.descr['@data.gen'] = 'faker.location.country'
+      }
+      else if (entity.name === 'sap.common.Currencies') {
+        elements.code['@data.gen'] = 'faker.finance.currency::code'
+        elements.name['@data.gen'] = elements.descr['@data.gen'] = 'faker.finance.currency::name'
+        elements.symbol['@data.gen'] = 'faker.finance.currency::symbol'
+      }
+      else if (entity.name === 'sap.common.Timezones') {
+        elements.code['@data.gen'] = 'faker.location.timeZone'
+        elements.name['@data.gen'] = elements.descr['@data.gen'] = 'faker.location.timeZone'
+      }
+    })
+  }
+}
+
+function randomDateInRange(dateRange) {
+  const dateFrom = dateRange.from
+  const returnDate = new Date(dateFrom.getUTCFullYear(), dateFrom.getUTCMonth(), dateFrom.getUTCDate())//needed to avoid overwriting the original dateFrom when generating a random Date
+  const diffTime = dateRange.to.valueOf() - dateRange.from.valueOf();
+  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+  const step = randomNumber() % diffDays
+  returnDate.setUTCDate(returnDate.getUTCDate() + step);
+  return returnDate
+}
+
+function randomDecimalInRange(decimalRange) {
+  const max = decimalRange.to
+  const min = decimalRange.from
+  const num = min + (randomNumber() % (max - min))
+  let dec = randomNumber()
+  const divider = Math.pow(10, dec.toString().length)
+  dec = dec / divider
+  const returnValue = num + dec
+  return returnValue
+}
+
+function randomIntInRange(intRange) {
+  const max = intRange.to
+  const min = intRange.from
+  return min + (randomNumber() % max)
+}
+
+const p = 5651;
+const q = 5623;
+const M = p * q;
+function randomNumber() {
+  counter = (counter * counter) % M
+  return counter;
+}