@sap/cds-dk 10.0.6 → 10.1.0

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

@@ -4,6 +4,8 @@ const cds = require('../../../cds')
 
 let counter = Math.round(Math.random() * 10000) // Default random seed // Non-deterministic behaviour
 const MAX_ASSOC_DEPTH = 5
+let compositionRecords = 2 // number of records generated per to-many composition
+let requestedRecords = 1 // number of records requested per entity, used to spread association keys
 
 /**
  * Creates JSON test data for the given entities
@@ -16,6 +18,8 @@ const MAX_ASSOC_DEPTH = 5
  */
 const asJson = module.exports = async (data, csn, numRecords=1, options={}) => {
   let { referenceData, contentType, artifact='entity' } = options
+  compositionRecords = Number(options.compositionRecords) > 0 ? Number(options.compositionRecords) : 2
+  requestedRecords = Number(numRecords) > 0 ? Number(numRecords) : 1
 
   // if no data is given, use all data
   if (!data) {
@@ -120,8 +124,11 @@ function dataForField(element, artifact, csn, record, data, parent, depth, refer
 
   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, artifact, csn, record, data, null, depth+1, referenceData) ]
+  else if (element.items?.type) { // `array of` / `many` with simple type
+    // `@assert.range` sits on the outer element, not on items, so carry it over
+    const items = element['@assert.range'] ? { ...element.items, '@assert.range': element['@assert.range'] } : element.items
+    return [ dataForField(items, artifact, csn, record, data, null, depth+1, referenceData) ]
+  }
 
   if (element.is_struct) {
     let struct = {}
@@ -134,11 +141,18 @@ function dataForField(element, artifact, csn, record, data, parent, depth, refer
 
   const type = element._type || element.type
   switch (type) {
-    case 'cds.Time':
-      return '22:59:53'
+    case 'cds.Time': {
+      // vary time across records instead of a fixed constant
+      const pad = n => String(n).padStart(2, '0')
+      const hh = pad(randomIntInRange({ from: 0, to: 23 }))
+      const mm = pad(randomIntInRange({ from: 0, to: 59 }))
+      const ss = pad(randomIntInRange({ from: 0, to: 59 }))
+      return `${hh}:${mm}:${ss}`
+    }
 
     case 'cds.Timestamp': {
       const range = {from: new Date('2000-01-01'), to: new Date('2024-01-01')}
+      annotatedDateRange(element, range) // honor @assert.range bounds
       return randomDateInRange(range).toISOString()
     }
     case 'cds.Date': {
@@ -228,18 +242,20 @@ function dataForField(element, artifact, csn, record, data, parent, depth, refer
     case 'cds.hana.REAL':
     case 'cds.Decimal': { // Decimal(9,5), Decimal(9), Decimal(precision:5), Decimal(2,2)
       const scale = element.scale ?? (element.precision ? 0 : 2) // scale is 0 if only precision is given
-      //10^x would allow one digit more than allowed, that's why -1
-      const prec  = element.precision ? Math.min(Math.pow(10, element.precision - scale) - 1, Number.MAX_SAFE_INTEGER) : 100
+      // largest value representable with the given precision/scale, e.g. Decimal(2,2) -> 0.99, Decimal(4,2) -> 99.99
+      const prec  = element.precision ? Math.min(Math.pow(10, element.precision - scale) - Math.pow(10, -scale), Number.MAX_SAFE_INTEGER) : 100
       const range = { from: 0, to: prec }
       annotatedIntRange(element, range)
       if (scale === 0) return randomIntInRange(range)
-      const intPart = randomIntInRange(range)
-      const frac = Math.floor(randomUnit() * Math.pow(10, scale))
-      return +(intPart + frac / Math.pow(10, scale)).toFixed(scale)
+      // draw uniformly across the range and round to scale, so annotated bounds are never exceeded
+      const val = +randomDecimalInRange(range).toFixed(scale)
+      return +Math.min(Math.max(val, range.from), range.to).toFixed(scale)
     }
     case 'cds.Double': {
       const range = {from: 0, to: 100}
-      return randomDecimalInRange(range)
+      annotatedIntRange(element, range) // honor @assert.range bounds
+      const val = randomDecimalInRange(range)
+      return Math.min(Math.max(val, range.from), range.to)
     }
     case 'cds.Composition': {
       const target = csn.definitions[element.target]
@@ -248,7 +264,7 @@ function dataForField(element, artifact, csn, record, data, parent, depth, refer
       let targetRecords = [] // in findKeysInOnCondition target records are linked to the entity, we don't want to overwrite any existing data
       if (data[target.name]) data[target.name].deleteReference = true // for json composites references are nested and will be deleted when writing to file
 
-      const targetRecordCount = element.is2many ? 2 : 1 // TODO: make this configurable
+      const targetRecordCount = element.is2many ? compositionRecords : 1
       const targetRecordID = randomNumber()
       for (let i = 0; i < targetRecordCount; i++) {
         const newRecord = fillRecord({}, targetRecordID+i, target, csn, data, artifact, depth+1, referenceData)
@@ -291,31 +307,52 @@ function dataForField(element, artifact, csn, record, data, parent, depth, refer
           return
 
         if (targetRecords.length > 0) { // use record generated by following association
-          targetRecord = targetRecords.at(-1)  // make sure the localized record references the newly generated texts
+          // spread across fully-built targets so composite association keys vary; fall back to the last (still-building) record for circular refs
+          const targetKeys = Object.keys(target.elements).filter(k => target.elements[k].key)
+          const ready = targetRecords.filter(r => targetKeys.every(k => r[k] !== undefined))
+          targetRecord = ready.length ? ready[pickIndex(record['$id'], element.name, ready.length)] : targetRecords.at(-1)
         } else {
-          targetRecord = fillRecord({}, randomNumber(), target, csn, data, artifact, depth+1, referenceData)
-          if (targetRecord) {
-            targetRecords.push(targetRecord)
-            uniqRecords(targetRecords, target)
+          // a key association needs distinct targets across rows, else the composite key collapses to one row;
+          // seed a pool up to the requested record count so later rows can spread across it
+          let poolSize = element.key && target.name !== artifact.name ? requestedRecords : 1
+          // a self-referential link (2+ key associations to the same target) needs at least 2 targets to pair distinct rows
+          const keyAssocsToTarget = Object.values(artifact.elements).filter(e => e.key && e.target === element.target).length
+          if (keyAssocsToTarget > 1) poolSize = Math.max(poolSize, keyAssocsToTarget)
+          for (let p = 0; p < poolSize; p++) {
+            const rec = fillRecord({}, randomNumber(), target, csn, data, artifact, depth+1, referenceData)
+            if (rec) targetRecords.push(rec)
           }
+          uniqRecords(targetRecords, target)
+          targetRecord = targetRecords.length ? targetRecords[pickIndex(record['$id'], element.name, targetRecords.length)] : undefined
           if (parent && (parent.name != artifact.name)) data[target.name].keepReference = true
         }
       }
 
-      // TODO: handle foreign keys correctly
+      // build the foreign key from all of the target's keys, recursing into keys that are themselves associations
       const assoc = {}
       Object.keys(target.elements)
         .filter(keyName => target.elements[keyName].key)
-        .forEach(keyName => assoc[keyName] = targetRecord[keyName])
+        .forEach(keyName => {
+          const keyEl = target.elements[keyName]
+          assoc[keyName] = keyEl.target
+            ? dataForField(keyEl, target, csn, targetRecord, data, artifact, depth+1, referenceData)
+            : 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
+    case 'cds.LargeBinary': {
+      const bytes = element.length ? Math.min(element.length, 16) : 8
+      const buf = Buffer.alloc(bytes)
+      for (let i = 0; i < bytes; i++) buf[i] = randomNumber() % 256
+      return buf.toString('base64')
+    }
+    case 'cds.Vector': {
+      const dim = element.dimension ?? element.length ?? 3
+      return JSON.stringify(Array.from({ length: dim }, () => +randomUnit().toFixed(6)))
+    }
     default: {
       console.error(`Unknown type ${element._type} (${element.type}) in '${artifact.name}:${element.name}'`)
       return
@@ -391,7 +428,8 @@ function findKeysInOnCondition(assocElement, target) {
         targetKey = ref[1]
       }
       else if (ref[0] === '$self') {
-        ownKey = Object.keys(assocElement.parent.keys)[0]  // TODO composite keys
+        // structured foreign key: carry over the parent's full (possibly composite) key set
+        ownKey = Object.keys(assocElement.parent.keys || {})[0]
         ownKeyStructured = true
       }
       else if (assocElement.parent.elements[ref[0]]) {
@@ -407,7 +445,8 @@ function uniqRecords(records, artifact) {
   if (keys.length === 0)  keys.push('$id') // no keys (e.g. in actions) -> use record's $id
   const keySet = new Set()
   for (let i = 0; i < records.length; i++) {
-    const key = keys.map(k => records[i][k]).join('|')
+    // JSON-serialize so association-typed keys (object foreign keys) compare by value, not '[object Object]'
+    const key = keys.map(k => JSON.stringify(records[i][k])).join('|')
     if (keySet.has(key)) {
       // console.debug('Removing', keys, key, 'from', artifact.name)
       records.splice(i, 1)
@@ -420,29 +459,60 @@ function uniqRecords(records, artifact) {
 
 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
+    let from = dateBound(el['@assert.range'][0], true)
+    let to = dateBound(el['@assert.range'][1], false)
+    const YEAR = 10 * 365 * 24 * 60 * 60 * 1000 // anchor window for open-ended bounds
+    if (from === Infinity || from === -Infinity) from = to instanceof Date ? new Date(to.valueOf() - YEAR) : dateRange.from
+    if (to === Infinity || to === -Infinity) to = from instanceof Date ? new Date(from.valueOf() + YEAR) : dateRange.to
+    // use annotated bounds directly, so ranges outside the default window don't invert
+    if (from instanceof Date && !isNaN(from)) dateRange.from = from
+    if (to instanceof Date && !isNaN(to)) dateRange.to = to
+  }
+}
+
+// resolve one date @assert.range bound: ISO string, open-interval xpr {xpr:[y,'-',m,'-',d]}, or infinity {'=':'_'}
+function dateBound(bound, isLower) {
+  if (bound && typeof bound === 'object') {
+    if (bound.val === '_' || bound['='] === '_') return isLower ? -Infinity : Infinity
+    if (Array.isArray(bound.xpr)) {
+      const nums = bound.xpr.filter(p => p && typeof p.val === 'number').map(p => p.val)
+      if (nums.length === 3) return new Date(Date.UTC(nums[0], nums[1] - 1, nums[2]))
     }
+    return undefined
   }
+  return new Date(bound)
 }
 
 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
-    }
+    let from = rangeBound(el['@assert.range'][0], true)
+    let to = rangeBound(el['@assert.range'][1], false)
+    // infinity on one side: anchor a finite window to the other bound so the span stays valid
+    if (from === Infinity || from === -Infinity) from = to !== undefined && isFinite(to) ? to - 100 : intRange.from
+    if (to === Infinity || to === -Infinity) to = from !== undefined && isFinite(from) ? from + 100 : intRange.to
+    // use annotated bounds directly, so ranges outside the default [0,100] don't invert
+    if (from !== undefined) intRange.from = from
+    if (to !== undefined) intRange.to = to
+  }
+}
+
+// pick a pool index that varies per association name, so multiple associations to the same
+// target on one record (e.g. a self-referential link a<->a) land on different rows
+function pickIndex(id, name, len) {
+  let h = 0
+  for (let i = 0; i < name.length; i++) h = (h * 31 + name.charCodeAt(i)) | 0
+  return (((id + Math.abs(h)) % len) + len) % len
+}
+
+// resolve one @assert.range bound: plain number, open bound {'=':true,val}, or infinity {'=':'_'}
+function rangeBound(bound, isLower) {
+  if (typeof bound === 'number') return bound
+  if (bound && typeof bound === 'object') {
+    if (bound.val === '_' || bound['='] === '_') return isLower ? -Infinity : Infinity
+    const n = typeof bound.val === 'string' ? Number(bound.val) : bound.val // decimal open bounds arrive as string literals
+    if (typeof n === 'number' && !isNaN(n)) return isLower ? n + 1e-9 : n - 1e-9 // open bound: nudge inward
   }
-   //TODO : decimalRange
+  return undefined
 }
 
 const langList = ['ar', 'cs', 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja', 'ko', 'ms', 'nl', 'pl', 'pt', 'ro', 'ru', 'sv', 'th', 'tr', 'zh']
@@ -539,9 +609,9 @@ function addSemantics(csn) {
 
 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 returnDate = new Date(Date.UTC(dateFrom.getUTCFullYear(), dateFrom.getUTCMonth(), dateFrom.getUTCDate())) // build in UTC to match the UTC mutation below, avoiding a timezone off-by-one-day
   const diffTime = dateRange.to.valueOf() - dateRange.from.valueOf();
-  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+  const diffDays = Math.max(1, Math.ceil(diffTime / (1000 * 60 * 60 * 24))); // at least 1 day so a single-day range never yields NaN
   const step = randomNumber() % diffDays
   returnDate.setUTCDate(returnDate.getUTCDate() + step);
   return returnDate
@@ -552,6 +622,8 @@ function randomDecimalInRange({ from: min, to: max }) {
 }
 
 function randomIntInRange({ from: min, to: max }) {
+  min = Math.ceil(min) // round fractional bounds inward so the result stays an integer within range
+  max = Math.floor(max)
   const span = Math.max(0, max - min + 1)
   return min + Math.floor(randomUnit() * span)
 }

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

@@ -32,11 +32,21 @@ module.exports = class DataTemplate extends require('../../plugin') {
         short: 'n',
         help: 'The number of records to be created for each entity.'
       },
+      'composition-records': {
+        type: 'number',
+        help: 'The number of records to be created per to-many composition (default 2).'
+      },
       'content-type': {
         type: 'string',
         short: 'c',
         help: 'The content type of the data. One of "json" or "csv".'
       },
+      'keys-only': {
+        type: 'boolean',
+        help: `Only fill key values into the generated CSV records, leaving all
+        other columns empty. Requires '--records'. Useful to generate placeholder
+        rows for an agent or human to fill in later.`
+      },
       'out': {
         type: 'string',
         short: 'o',
@@ -56,6 +66,8 @@ module.exports = class DataTemplate extends require('../../plugin') {
     } = cds.cli.options
     if (typeof records === 'string')  records = parseInt(records)
     if (Number.isNaN(records) || records < 1) records = 1
+    let compositionRecords = cds.cli.options['composition-records']
+    if (typeof compositionRecords === 'string')  compositionRecords = parseInt(compositionRecords)
 
     const [filterName, filterQueryStr] = (cds.cli.options['filter'] ?? cds.cli.options['data:for'] ?? '').split(':')
     const nameFilter = filterStringAsRegex(filterName)
@@ -78,12 +90,14 @@ module.exports = class DataTemplate extends require('../../plugin') {
       .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, {contentType})
+    await asJson(data, csn, records, {contentType, compositionRecords})
 
     if (contentType === 'csv') {
       const headerOnly = !cds.cli.options['records'] // compat to old behavior which only creates headers
       if (headerOnly) console.log(`${dim('adding headers only, use --records to create random entries')}`)
-      await asCsv(data, csn, Object.assign({ headerOnly }, dataForParams))
+      const keysOnly = !!cds.cli.options['keys-only']
+      if (keysOnly && headerOnly) console.log(`${dim('ignoring --keys-only, use --records to create entries')}`)
+      await asCsv(data, csn, Object.assign({ headerOnly, keysOnly }, dataForParams))
     }
 
     // write files

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

@@ -23,8 +23,8 @@ module.exports = class DestinationTemplate extends require('../../plugin') {
         await merge(__dirname, 'files', 'package.json.hbs').into(configFile, { with: project })
     }
 
-    async combine() {
-        const project = readProject()
+    async combine(facet) {
+        const project = readProject(facet)
         const { addApprouter, addMultitenancy, addKyma, addMta, hasMta, srv, isJava } = project
 
         if (addMta || (addApprouter || addMultitenancy) && hasMta) {

package/lib/init/template/dynatrace/files/package.json.hbs

@@ -1,8 +1,8 @@
 {
   "dependencies": {
-    "@cap-js/telemetry": ">=0",
-    "@opentelemetry/exporter-metrics-otlp-proto": "<0.200"{{#hasKyma}},
-    "@opentelemetry/host-metrics": "<0.200"
+    "@cap-js/telemetry": "^2",
+    "@opentelemetry/exporter-metrics-otlp-proto": ">=0.200"{{#hasKyma}},
+    "@opentelemetry/instrumentation-host-metrics": ">=0.2"
     {{/hasKyma}}
   },
   "cds": {

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

@@ -23,8 +23,8 @@ module.exports = class extends require('../../plugin') {
     }
   }
 
-  async combine() {
-    const project = readProject()
+  async combine(facet) {
+    const project = readProject(facet)
     const { appName, addMta, addKyma, isJava, addMultitenancy, srv } = project
 
     if (addMta || addMultitenancy) {

package/lib/init/template/enterprise-messaging/index.js

@@ -50,8 +50,8 @@ module.exports = class EnterpriseMessagingTemplate extends require('../../plugin
     }
   }
 
-  async combine() {
-    const project = readProject()
+  async combine(facet) {
+    const project = readProject(facet)
     const { addXsuaa, hasXsuaa, addKyma, addMta, srv, appName } = project
 
     if (addMta) {

package/lib/init/template/enterprise-messaging-shared/index.js

@@ -17,8 +17,8 @@ module.exports = class EnterpriseMessagingSharedTemplate extends require('../ent
     return 'messaging via shared SAP Event Mesh'
   }
 
-  async combine() {
-    const project = readProject()
+  async combine(facet) {
+    const project = readProject(facet)
     const { addMta, addKyma, srv } = project
 
     if (addMta) {

package/lib/init/template/extensibility/files/mta.yaml.hbs

@@ -0,0 +1,11 @@
+---
+resources:
+  - name: {{appName}}-auth
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: xsuaa
+      config:
+        role-collections:
+          - name: 'ExtensionDeveloper ({{appName}} ${org}-${space})'
+            description: 'generated'
+            role-template-references: ['$XSAPPNAME.ExtensionDeveloper']

package/lib/init/template/extensibility/files/xs-security.json.hbs

@@ -8,7 +8,7 @@
   "role-templates": [
     {
       "name": "ExtensionDeveloper",
-      "description": "Extension development including UIFlex extensibility",
+      "description": "Extend CAP applications via extension projects",
       "scope-references": [
         "$XSAPPNAME.cds.ExtensionDeveloper"
       ]

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

@@ -24,14 +24,14 @@ module.exports = class ExtensibilityTemplate extends require('../../plugin') {
     await merge(__dirname, 'files/package.json.hbs').into(configFile, { project })
   }
 
-  async combine() {
-    const project = readProject()
+  async combine(facet) {
+    const project = readProject(facet)
     const { addXsuaa } = project
     if (addXsuaa) {
       await merge(__dirname, 'files', 'xs-security.json.hbs').into('xs-security.json', {
         project,
         additions: [
-          { in: 'scopes', where: { name: '$XSAPPNAME.cds.ExtensionDeveloper' }},
+          { in: 'scopes',         where: { name: '$XSAPPNAME.cds.ExtensionDeveloper' }},
           { in: 'role-templates', where: { name: 'ExtensionDeveloper' }}
         ]
       })

package/lib/init/template/github-actions/index.js

@@ -49,8 +49,8 @@ module.exports = class GitHubActionTemplate extends require('../../plugin') {
     }
   }
 
-  async combine() {
-    const project = readProject()
+  async combine(facet) {
+    const project = readProject(facet)
     const { addMta, addKyma } = project, { force } = cds.cli.options
     project.sap = cds.cli.options.sap
     if (addMta) {

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

@@ -15,6 +15,7 @@ module.exports = class HanaTemplate extends require('../../plugin') {
 
     static hasInProduction(env) {
         const { dependencies, isJava } = readProject()
+        if (cds.cli.options?.add?.has('hana-serverless') || env.requires?.db?.kind === 'hana-serverless' || env.requires?.db?.serverless) return false
         return dependencies?.['@cap-js/hana'] || isJava && env.requires?.db?.kind === 'hana'
     }
 
@@ -38,8 +39,8 @@ module.exports = class HanaTemplate extends require('../../plugin') {
         await sort('package.json', 'dependencies')
     }
 
-    async combine() {
-        const project = readProject()
+    async combine(facet) {
+        const project = readProject(facet)
         const { addMta, hasMta, addMultitenancy, addKyma, isJava, hasKyma, hasMultitenancy, srv } = project
 
         if (addMta || addMultitenancy && hasMta) {

package/lib/init/template/hana-serverless/files/db/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "deploy",
+  "dependencies": {
+    "hdb": "^2.0.0",
+    "@sap/hdi-deploy": "^5"
+  },
+  "engines": {
+    "node": "^24.0.0"
+  },
+  "scripts": {
+    "start": "node node_modules/@sap/hdi-deploy/deploy.js --use-hdb --parameter com.sap.hana.di.table/try_fast_table_migration=true",
+    "build": "npm i && npx cds build .. --for hana --production"
+  }
+}

package/lib/init/template/hana-serverless/files/identity.values.yaml.hbs

@@ -0,0 +1,10 @@
+identity:
+  serviceOfferingName: identity
+  servicePlanName: application
+  parameters:
+    display-name: {{appName}}
+    consumed-services:
+      - service-instance-name: {{appName}}-db
+    {{#hasMultitenancy}}
+    multi-tenant: true
+    {{/hasMultitenancy}}

package/lib/init/template/hana-serverless/files/mta.yaml.hbs

@@ -0,0 +1,64 @@
+---
+modules:
+  - name: {{appName}}-srv
+    type: {{language}}
+    path: {{& srv.path}}
+    requires:
+      - name: {{appName}}-db
+      - name: {{appName}}-hana-auth
+        parameters:
+          config:
+            credential-type: X509_GENERATED
+            app-identifier: srv
+
+  - name: {{appName}}-db-deployer
+    type: hdb
+    path: {{& db.path}}
+    parameters:
+      buildpack: nodejs_buildpack
+{{#isJava}}
+    build-parameters:
+      builder: custom
+      commands:
+        - npm run build
+{{/isJava}}
+    requires:
+      - name: {{appName}}-db
+      - name: {{appName}}-hana-auth
+        parameters:
+          config:
+            credential-type: X509_GENERATED
+            app-identifier: db-deployer
+
+  - name: {{appName}}-mtx
+    type: nodejs
+    path: {{#isNodejs}}gen/{{/isNodejs}}mtx/sidecar
+    requires:
+      - name: {{appName}}-db
+      - name: {{appName}}-hana-auth
+        parameters:
+          config:
+            credential-type: X509_GENERATED
+            app-identifier: mtx
+
+resources:
+  - name: {{appName}}-db
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: hana-cloud
+      service-plan: serverless
+      config:
+        auto_subscription:
+          type: subscription-manager
+        subscribe_with_consuming_app: true
+
+  - name: {{appName}}-hana-auth
+    type: org.cloudfoundry.managed-service
+    processed-after:
+      - {{appName}}-db
+    parameters:
+      service: identity
+      service-plan: application
+      config:
+        consumed-services:
+          - service-instance-name: {{appName}}-db

package/lib/init/template/hana-serverless/files/package.json.hbs

@@ -0,0 +1,35 @@
+{
+  {{#isNodejs}}
+  "dependencies": {
+    "@cap-js/hana": "^3"
+  },
+  "cds": {
+    "requires": {
+      "[production]": {
+      {{#shortcut}}
+        "db": "hana-serverless"
+      {{/shortcut}}
+      {{^shortcut}}
+        "db": {
+          "kind": "hana-serverless"
+        }
+      {{/shortcut}}
+      }
+    }
+  }
+  {{/isNodejs}}
+  {{#isJava}}
+  "requires": {
+    "[production]": {
+    {{#shortcut}}
+      "db": "hana-serverless"
+    {{/shortcut}}
+    {{^shortcut}}
+      "db": {
+        "kind": "hana-serverless"
+      }
+    {{/shortcut}}
+    }
+  }
+  {{/isJava}}
+}