wip(POC): @assert.constraint

db-service/lib/SQLService.js

@@ -5,6 +5,7 @@ const { pipeline } = require('stream/promises')
 const { resolveView, getDBTable, getTransition } = require('@sap/cds/libx/_runtime/common/utils/resolveView')
 const DatabaseService = require('./common/DatabaseService')
 const cqn4sql = require('./cqn4sql')
+const { attachConstraints, checkConstraints } = require('./assert-constraint')
 
 const BINARY_TYPES = {
   'cds.Binary': 1,
@@ -37,6 +38,7 @@ const _hasProps = (obj) => {
 class SQLService extends DatabaseService {
   init() {
     this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./fill-in-keys')) // REVISIT should be replaced by correct input processing eventually
+    this.after(['INSERT', 'UPSERT', 'UPDATE'], attachConstraints)
     this.on(['INSERT', 'UPSERT', 'UPDATE'], require('./deep-queries').onDeep)
     if (cds.env.features.db_strict) {
       this.before(['INSERT', 'UPSERT', 'UPDATE'], ({ query }) => {
@@ -67,6 +69,7 @@ class SQLService extends DatabaseService {
     this.on(['DELETE'], this.onDELETE)
     this.on(['CREATE ENTITY', 'DROP ENTITY'], this.onSIMPLE)
     this.on(['BEGIN', 'COMMIT', 'ROLLBACK'], this.onEVENT)
+    this.before(['COMMIT'], checkConstraints)
     this.on(['*'], this.onPlainSQL)
     return super.init()
   }

db-service/lib/assert-constraint/index.js

@@ -0,0 +1,124 @@
+'use strict'
+
+const { getValidationQuery, buildMessage, getWhereOfPatch, getConstraintsByTarget } = require('./utils')
+
+const constraintStorage = require('./storage')
+
+/**
+ *
+ * “Before-hook” that gathers every `@assert.constraint` touched by the current
+ * request, optionally augments them with an extra filter (the
+ * `where` of an UPDATE/UPSERT), and merges the result into
+ * {@link constraintStorage} so it can be validated once per transaction in
+ * {@link checkConstraints}.
+ *
+ * 1.  Skip CSV/multipart inserts.
+ * 2.  Call `getConstraintsByTarget()` to obtain a `Map`
+ *     `targetName → ConstraintDict`.
+ * 3.  If the root entity is an UPDATE/UPSERT, retrieve its filter via
+ *     `getWhereOfPatch(req)` and push it into the `where` array of every
+ *     constraint that belongs to that root entity.
+ * 4.  For each target entity, merge the (possibly augmented) constraints into
+ *     the per-transaction storage with `constraintStorage.merge(this.tx, …)`.
+ *
+ * Notes
+ * ─────────────────────────────────────────────────────────────────
+ * • No validation queries are built here; we only stash **metadata**.
+ * • The function is idempotent within the same transaction because
+ *   `constraintStorage.merge` deduplicates constraints and WHEREs.
+ *
+ * @this {import('@sap/cds').Service}  CAP service or transaction object
+ * @param {*}                        _res   (ignored — payload from previous hook)
+ * @param {import('@sap/cds').Request} req   Current request being processed
+ */
+function attachConstraints(_res, req) {
+  if (Array.isArray(req.data?.[0])) return // ignore CSV / multipart
+
+  const byTarget = getConstraintsByTarget(req.target, req.data)
+  if (!byTarget.size) return
+
+  const patchWhere = getWhereOfPatch(req) // null | array
+  const rootName = req.target.name
+
+  for (const [targetName, constraints] of byTarget) {
+    if (patchWhere && targetName === rootName) {
+      Object.values(constraints).forEach(c => {
+        c.where.push([{ xpr: patchWhere }])
+      })
+    }
+    constraintStorage.merge(this.tx, targetName, constraints)
+  }
+}
+
+/**
+ * Validate all pending constraints for the current transaction.
+ *
+ * 1. Collect constraints from `constraintStorage`.
+ * 2. Build **one** SQL query per target and run them in the current tx.
+ * 3. For each failed row:
+ *    - Lazily fetch the message params **only when** the constraint is violated.  
+ *    - Build a message, and register it with `req.error(...)`,
+ *      including all affected targets for the UI (`@Common.additionalTargets`).
+ * 4. Clear the constraint cache for this transaction.
+ *
+ * @param {import('@sap/cds').Request} req – CDS request that will hold any validation errors.
+ */
+async function checkConstraints(req) {
+  const constraintsPerTarget = constraintStorage.get(this.tx)
+  if (!constraintsPerTarget.size) return
+
+  // build exactly one query per bucket
+  const queries = []
+  for (const [targetName, constraints] of constraintsPerTarget) {
+    queries.push(getValidationQuery(targetName, constraints))
+  }
+
+  const results = await this.run(queries)
+
+  // key = message text        value = array of targets (order preserved)
+  // this way messages are deduplicated
+  const messages = new Map()
+
+  for (const [i, rows] of results.entries()) {
+    const constraints = queries[i].$constraints
+    const paramQuery = queries[i].$paramQuery
+    let params
+
+    for (const [name, meta] of Object.entries(constraints)) {
+      const col = `${name}_constraint`
+
+      // request params in separate query, because constraint has failed
+      if (paramQuery && rows.some(r => r[col] === false)) {
+        // use the same transaction as the query (or it would re-trigger the handler endlessly)
+        params = await this.tx().run(paramQuery)
+      }
+
+      for (const [j, r] of rows.entries()) {
+        if (r[col]) continue // row satisfied the constraint → no error
+
+        const row = params ? { ...r, ...params[j] } : r // merge only if needed
+
+        const text = buildMessage(name, meta, row)
+        const targets = meta.targets?.length ? meta.targets : [{ ref: [meta.element.name] }]
+
+        ;(messages.get(text) ?? []).push(...targets)
+        messages.set(text, targets)
+      }
+    }
+  }
+
+  for (const [text, targetList] of messages) {
+    req.error(400, {
+      message: text,
+      target: targetList[0]?.ref.join('/'),
+      '@Common.additionalTargets': targetList.map(t => t.ref.join('/')),
+    })
+  }
+
+  constraintStorage.clear(this.tx)
+}
+
+module.exports = {
+  attachConstraints,
+  checkConstraints,
+}

db-service/lib/assert-constraint/storage.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const _constraintStorage = new WeakMap() // tx → Map<targetName, ConstraintDict>
+
+function dedupWhere(arr) {
+  const seen = new Set()
+  return arr.filter(x => {
+    const key = JSON.stringify(x) // keep track of expressions already seen
+    return !seen.has(key) && seen.add(key)
+  })
+}
+
+function mergeConstraint(a, b) {
+  const merged = { ...a, ...b }
+
+  const where = [...(a.where ?? []), ...(b.where ?? [])]
+  merged.where = dedupWhere(where)
+
+  return merged
+}
+
+/**
+ * constraintStorage
+ *
+ * In-memory repository that collects assert-constraint metadata
+ * _per CDS transaction_ and _per target entity_.
+ * The data is stored in a `WeakMap`, so everything is garbage-collected
+ * automatically when the transaction object becomes unreachable at the end of
+ * the request.
+ *
+ * Storage structure
+ * ─────────────────
+ *   WeakMap
+ *     └─ key   : cds.Transaction
+ *     └─ value : Map<string, ConstraintDict>
+ *                        └─ key   : target entity name (e.g. 'bookshop.Books')
+ *                        └─ value : { [constraintName]: ConstraintMeta }
+ *
+ * `ConstraintMeta` is the object returned by `collectConstraints()` and may
+ * contain `condition`, `parameters`, `where`, … – see utils.js.
+ */
+module.exports = {
+  /**
+   * Merge a set of constraints into the bucket that belongs to this tx+entity.
+   * @param {import('@sap/cds').Transaction} tx
+   * @param {string} targetName
+   * @param {object} constraints   result of utils.getConstraintsByTarget().get(targetName)
+   */
+  merge(tx, targetName, constraints) {
+    const txMap = _constraintStorage.get(tx) ?? new Map()
+    const existingConstraintsForTarget = txMap.get(targetName) ?? {}
+
+    for (const [name, c] of Object.entries(constraints)) {
+      existingConstraintsForTarget[name] = existingConstraintsForTarget[name]
+        ? mergeConstraint(existingConstraintsForTarget[name], c)
+        : { ...c }
+    }
+
+    txMap.set(targetName, existingConstraintsForTarget)
+    _constraintStorage.set(tx, txMap)
+  },
+
+  /** @returns Map<string,object> */
+  get: tx => _constraintStorage.get(tx) ?? new Map(),
+  clear: tx => _constraintStorage.delete(tx),
+}