@sap/cds-dk 10.0.7 → 10.1.1

package/lib/init/template/app-frontend/files/containerize.yaml.hbs

@@ -7,7 +7,7 @@ modules:
         builder: proxy-unified-runtime-dmz.int.repositories.cloud.sap/builder/noble
         {{/hasKymaUnifiedRuntime}}
         {{^hasKymaUnifiedRuntime}}
-        type: sapse/application-content-deployer-buildpack:1.4.0
+        type: sapse/application-content-deployer-buildpack:1.5.0
         builder: builder-jammy-base
         {{/hasKymaUnifiedRuntime}}
-        path: app/html5-deployer
+        path: {{& html5DeployerPath}}

package/lib/init/template/app-frontend/index.js

@@ -1,7 +1,7 @@
 const { readProject } = require('../../projectReader')
 const { merge } = require('../../merge')
 const { srv4, appDeployer, appFront, xsuaa } = require('../../registries/mta')
-const { odataApi } = require('../../registries/xs-app')
+const { srvApi } = require('../../registries/xs-app')
 const { renderAndCopy } = require('../../template')
 const { sh:$, path:{join}, fs:{promises:{rename}}, write, read, exists } = require('../../../cds').utils
 
@@ -50,8 +50,8 @@ module.exports = class extends require('../../plugin') {
 
     }
 
-    async combine() {
-        const project = readProject()
+    async combine(facet) {
+        const project = readProject(facet)
         const {
             srv, appPath, apps,
             hasMta, addMta, hasXsuaa, addSample, addApprouter, addWorkzoneStandard, addXsuaa, addIas,
@@ -61,7 +61,7 @@ module.exports = class extends require('../../plugin') {
         await Promise.all(apps.map(async ({ app }) => {
             project.app = app
             project.hasIndexHtml = exists(join(appPath, app, 'webapp/index.html'))
-            const additions = [odataApi]
+            const additions = [srvApi]
             await merge(__dirname, 'files/xs-app.json.hbs').into(join(appPath, app, 'xs-app.json'), { with: project, additions })
         }))
 

package/lib/init/template/application-logging/index.js

@@ -26,8 +26,8 @@ module.exports = class ApplicationLoggingTemplate extends require('../../plugin'
         if (isJava) await mvn.add('APPLICATION_LOGGING')
     }
 
-    async combine() {
-        const project = readProject()
+    async combine(facet) {
+        const project = readProject(facet)
         const { addMta, hasMta, hasApprouter, isJava, addMultitenancy, hasMultitenancy, srv } = project
 
         if (addMta || (addMultitenancy && hasMta)) {

package/lib/init/template/approuter/files/package.json

@@ -1,7 +1,7 @@
 {
   "name": "approuter",
   "dependencies": {
-    "@sap/approuter": "^22.0.0"
+    "@sap/approuter": "^23.0.0"
   },
   "scripts": {
     "start": "node node_modules/@sap/approuter/approuter.js"

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

@@ -31,8 +31,8 @@ module.exports = class ApprouterTemplate extends require('../../plugin') {
         await merge(__dirname, 'files/default-env.json').into(approuterPath + '/default-env.json')
     }
 
-    async combine() {
-        const project = readProject()
+    async combine(facet) {
+        const project = readProject(facet)
         const {
             isNodejs, isJava,
             addIas, addXsuaa, hasXsuaa, hasIas, addMultitenancy, hasMTXRoute, hasMTXRouteJava,
@@ -51,6 +51,7 @@ module.exports = class ApprouterTemplate extends require('../../plugin') {
             if (hasMultitenancy) modules.push(mtxSidecar)
             const additions = [...modules, ...apis]
             const relationships = []
+            const deletions = []
             if (hasXsuaa) {
                 relationships.push({
                     insert: [xsuaa, 'name'],
@@ -62,9 +63,13 @@ module.exports = class ApprouterTemplate extends require('../../plugin') {
                     insert: [ias, 'name'],
                     into: [approuter, 'requires', 'name']
                 })
+                deletions.push({
+                    item: { in: [approuter, 'requires'], where: { 'name': 'srv-api' } },
+                    key: 'properties.name'
+                })
             }
             await merge(__dirname, 'files/mta.yaml.hbs').into('mta.yaml', {
-                with: project, additions, relationships,
+                with: project, additions, relationships, deletions,
             })
         }
 

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

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "@cap-js/attachments": "^3"
+    "@cap-js/attachments": "^4"
   }
 }

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

@@ -25,8 +25,8 @@ module.exports = class AttachmentsTemplate extends require('../../plugin') {
         if (isJava) await mvn.add('attachments')
     }
 
-    async combine() {
-        const project = readProject()
+    async combine(facet) {
+        const project = readProject(facet)
         const { addMta, addKyma, srv } = project
 
         if (addMta) {

package/lib/init/template/audit-logging/index.js

@@ -32,8 +32,8 @@ module.exports = class AuditLoggingTemplate extends require('../../plugin') {
     if (isJava) await mvn.add('audit_logging')
   }
 
-  async combine() {
-    const project = readProject()
+  async combine(facet) {
+    const project = readProject(facet)
     const { addMta, addKyma, addMultitenancy, srv } = project
     const { plan = 'premium' } = cds.cli.options
     project.servicePlan = plan

package/lib/init/template/cloud-logging/files/package.json.hbs

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

package/lib/init/template/cloud-logging/index.js

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

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

@@ -16,26 +16,33 @@ const SUPPORTED_SHELLS = [...SUPPORTED_LINUX_SHELLS, ...SUPPORTED_WINDOWS_SHELLS
 module.exports = new class CompletionSetup {
     supportedShells = SUPPORTED_SHELLS
 
-    async setup(addEntry, options) {
-        const shell = options.shell
+    resolveShell(options) {
+        return options?.shell
             || (process.env.MSYSTEM?.includes('MINGW64') ? 'gitbash' : process.env.SHELL?.match(/(bash|fish|zsh)/)?.[0])
             || (process.env.PSModulePath ? 'ps' : null);
+    }
+
+    async setup(addEntry, options) {
+        const shell = this.resolveShell(options);
 
         switch (shell) {
             case 'bash':
             case 'fish':
             case 'gitbash':
             case 'zsh':
-                return this.setupLinuxLike(addEntry, shell);
+                await this.setupLinuxLike(addEntry, shell);
+                return shell;
             case 'ps':
-                return this.setupPs(addEntry);
+                await this.setupPs(addEntry);
+                return shell;
             case null:
                 try {
                     const shellType = this.determineShellLinux();
                     if (!shellType) {
                         throw `Unsupported shell.\nSupported shells are: ${SUPPORTED_SHELLS.join(', ')}.`;
                     }
-                    return this.setupLinuxLike(addEntry, shellType);
+                    await this.setupLinuxLike(addEntry, shellType);
+                    return shellType;
                 } catch (err) {
                     throw `Error during completion setup: ${err}`;
                 }
@@ -95,7 +102,7 @@ module.exports = new class CompletionSetup {
 
         profileFile = path.join(os.homedir(), profileFile);
 
-        await this.changeProfile(profileFile, shell, addEntry);
+        await this.changeProfile(profileFile, shell, addEntry, this.resolveScriptPath(shell));
 
         const relProfilePath = path.relative(os.homedir(), profileFile);
         console.log(`\nSource your shell using\n${bold(`source ~/${relProfilePath}`)}\nto activate the changes.\n`);
@@ -113,55 +120,45 @@ module.exports = new class CompletionSetup {
             throw err;
         }
 
-        await this.changeProfile(profilePath, 'ps', addEntry);
+        await this.changeProfile(profilePath, 'ps', addEntry, this.resolveScriptPath('ps'));
         console.log(`\nSource your shell using\n${bold('. $PROFILE')}\nto activate the changes.`);
     }
 
-    getScript(shell) {
+    // Returns the absolute path to the pre-generated cache file bundled with this package.
+    resolveScriptPath(shell) {
+        const cacheFiles = { bash: 'cds.sh', gitbash: 'cds.sh', fish: 'cds.fish', ps: 'cds.ps1', zsh: 'cds.zsh' };
+        return path.join(__dirname, '../../../../bin/completion/scripts', cacheFiles[shell]);
+    }
+
+    // Generates the snippet written to the user's shell profile. The script path is hardcoded at
+    // install time to avoid spawning a subprocess on every shell startup.
+    getScript(shell, scriptPath) {
         switch (shell) {
             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
-`
+                return `# cds shell completion script (path resolved at install time)
+_p="${scriptPath}" && [ -r "$_p" ] && . "$_p"`
             case 'fish':
-                return `
+                return `# cds shell completion script (path resolved at install time)
 if type "cds" >/dev/null 2>&1
-    set -l CDS_PROFILE (cds completion --shell fish --profile 2> /dev/null)
-    if test -e "$CDS_PROFILE"
-        source "$CDS_PROFILE"
-    end
-end
-`
+    set -l _p "${scriptPath}"
+    test -r "$_p" && source "$_p"
+end`
             case 'ps':
-                return `
-try {
-    $CDS_PROFILE = cds completion --shell ps --profile 2> $null
-    if (Test-Path -Path "$CDS_PROFILE" -PathType Leaf) {
-        . "$CDS_PROFILE"
-    }
-} catch {}
-`
-
+                return `# cds shell completion script (path resolved at install time)
+$_p = "${scriptPath}"; if (Test-Path -Path "$_p" -PathType Leaf) { . "$_p" }`
             case 'zsh':
-                return `
-# compinit can be removed here if loaded elsewhere in the script
+                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
-`
+# cds shell completion script (path resolved at install time)
+_p="${scriptPath}" && [ -r "$_p" ] && \\. "$_p"`
             default:
                 throw `Unsupported shell: ${shell}`;
         }
     }
 
-    async changeProfile(profileFile, shell, addEntry) {
+    async changeProfile(profileFile, shell, addEntry, scriptPath) {
         let profile = '';
         let profileFileExists = true;
         try {
@@ -181,7 +178,7 @@ fi
             profile = profile + `
 
 # cds completion start
-${this.getScript(shell)}
+${this.getScript(shell, scriptPath)}
 # cds completion end`;
             changed = true;
         }

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

@@ -18,8 +18,8 @@ module.exports = class ConnectivityTemplate 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 { srv, addKyma, addMta } = project
 
         if (addMta) {

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

@@ -4,10 +4,10 @@ const { elementsSorter } = require('./as-json')
  * 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
+ * @param {{ headerOnly: boolean, keysOnly: boolean, separator: boolean }} options
  * @returns {Promise<string>} CSV string
  */
-module.exports = async (data={}, csn, { headerOnly=false, separator=',' }={}) => {
+module.exports = async (data={}, csn, { headerOnly=false, keysOnly=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.
@@ -32,6 +32,15 @@ module.exports = async (data={}, csn, { headerOnly=false, separator=',' }={}) =>
             if (data[t] === undefined) {
               data[t] = value // Add object for a new entity. Next pass will process it.
             }
+            // managed to-one composition: emit the foreign-key column(s) on the parent, like an association
+            if (!element.on && element.keys) {
+              const targetRecord = Array.isArray(value) ? value[0] : value
+              const fk = {}
+              if (targetRecord) for (const k of element.keys) fk[k.ref[k.ref.length - 1]] = targetRecord[k.ref[k.ref.length - 1]]
+              const {headers: fkHeaders, records: fkRecords} = resolveStruct(fk, name)
+              if (i === 0) header.push(...fkHeaders)
+              record.push(...(keysOnly && !element.key ? fkRecords.map(() => '') : fkRecords))
+            }
           }
           else if (element._type === 'cds.Association') {
             if (element.on) {
@@ -42,18 +51,19 @@ module.exports = async (data={}, csn, { headerOnly=false, separator=',' }={}) =>
             if (i === 0) {
               header.push(...fkHeaders)
             }
-            record.push(...fkRecords)
+            // foreign keys of key associations are part of the primary key and must be kept
+            record.push(...(keysOnly && !element.key ? fkRecords.map(() => '') : fkRecords))
           }
           else if (element.is_struct && element.type !== 'cds.Map') {
             const {headers: structHeaders, records: structRecords} = resolveStruct(value, name);
             if (i === 0) {
               header.push(...structHeaders)
             }
-            record.push(...structRecords)
+            record.push(...(keysOnly && !element.key ? structRecords.map(() => '') : structRecords))
           }
           else {
             if (i === 0)  header.push(name)
-            record.push(processValue(value))
+            record.push(keysOnly && !element.key ? '' : processValue(value))
           }
         }
         records.push(record.join(separator))

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,23 @@ 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)
+      const factor = Math.pow(10, scale)
+      range.from = Math.ceil(range.from * factor) / factor
+      range.to = Math.floor(range.to * factor) / factor
+      // 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 +267,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 +310,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 +431,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 +448,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 +462,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 +612,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 +625,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)
 }