@cap-js/change-tracking 2.0.0-beta.1 → 2.0.0-beta.3

package/lib/hana/sql-expressions.js

@@ -7,17 +7,8 @@ const { createTriggerCQN2SQL } = require('../TriggerCQN2SQL.js');
 
 const TriggerCQN2SQL = createTriggerCQN2SQL(HANAService.CQN2SQL);
 let HANACQN2SQL;
-let model;
 
-function setModel(m) {
-	model = m;
-}
-
-function getModel() {
-	return model;
-}
-
-function toSQL(query) {
+function toSQL(query, model) {
 	if (!HANACQN2SQL) {
 		HANACQN2SQL = new TriggerCQN2SQL();
 	}
@@ -111,7 +102,7 @@ function getWhereCondition(col, modification) {
 /**
  * Returns SQL expression for a column's label (looked-up value for associations)
  */
-function getLabelExpr(col, refRow) {
+function getLabelExpr(col, refRow, model) {
 	if (!(col.target && col.alt)) {
 		return `NULL`;
 	}
@@ -139,36 +130,36 @@ function getLabelExpr(col, refRow) {
 		const textsWhere = { ...where, locale: { func: 'SESSION_CONTEXT', args: [{ val: 'LOCALE' }] } };
 		const textsQuery = SELECT.one.from(localizedInfo.textsEntity).columns(columns).where(textsWhere);
 		const baseQuery = SELECT.one.from(col.target).columns(columns).where(where);
-		return `COALESCE((${toSQL(textsQuery)}), (${toSQL(baseQuery)}))`;
+		return `COALESCE((${toSQL(textsQuery, model)}), (${toSQL(baseQuery, model)}))`;
 	}
 
 	const query = SELECT.one.from(col.target).columns(columns).where(where);
-	return `(${toSQL(query)})`;
+	return `(${toSQL(query, model)})`;
 }
 
 /**
  * Builds SQL expression for objectID (entity display name)
  * Uses @changelog annotation fields, falling back to entity name
  */
-function buildObjectIDExpr(objectIDs, entity, rowRef) {
+function buildObjectIDExpr(objectIDs, entity, rowRef, model) {
 	const keys = utils.extractKeys(entity.keys);
 	const entityKeyExpr = compositeKeyExpr(keys.map((k) => `:${rowRef}.${k}`));
 
 	if (!objectIDs || objectIDs.length === 0) {
-		return `'${entity.name}'`;
+		return entityKeyExpr;
 	}
 
 	const parts = [];
 	for (const oid of objectIDs) {
 		if (oid.included) {
-			parts.push(`TO_NVARCHAR(:${rowRef}.${oid.name})`);
+			parts.push(`COALESCE(TO_NVARCHAR(:${rowRef}.${oid.name}), '<empty>')`);
 		} else {
 			const where = keys.reduce((acc, k) => {
 				acc[k] = { val: `:${rowRef}.${k}` };
 				return acc;
 			}, {});
 			const query = SELECT.one.from(entity.name).columns(oid.name).where(where);
-			parts.push(`COALESCE(TO_NVARCHAR((${toSQL(query)})), '')`);
+			parts.push(`COALESCE(TO_NVARCHAR((${toSQL(query, model)})), '')`);
 		}
 	}
 
@@ -180,7 +171,7 @@ function buildObjectIDExpr(objectIDs, entity, rowRef) {
  * Builds SQL expression for grandparent entity's objectID
  * Used when creating grandparent composition entries for deep linking
  */
-function buildGrandParentObjectIDExpr(grandParentObjectIDs, grandParentEntity, parentEntityName, parentKeyBinding, grandParentKeyBinding, rowRef) {
+function buildGrandParentObjectIDExpr(grandParentObjectIDs, grandParentEntity, parentEntityName, parentKeyBinding, grandParentKeyBinding, rowRef, model) {
 	// Build WHERE clause to find the parent entity record (e.g., OrderItem from OrderItemNote's FK)
 	const parentEntity = model.definitions[parentEntityName];
 	const parentKeys = utils.extractKeys(parentEntity.keys);
@@ -209,8 +200,6 @@ function buildGrandParentObjectIDExpr(grandParentObjectIDs, grandParentEntity, p
 }
 
 module.exports = {
-	setModel,
-	getModel,
 	toSQL,
 	getSkipCheckCondition,
 	getElementSkipCondition,

package/lib/hana/triggers.js

@@ -2,19 +2,19 @@ const cds = require('@sap/cds');
 const utils = require('../utils/change-tracking.js');
 const config = cds.env.requires['change-tracking'];
 const { getCompositionParentInfo, getGrandParentCompositionInfo } = require('../utils/composition-helpers.js');
-const { setModel, getSkipCheckCondition, getElementSkipCondition, compositeKeyExpr, getValueExpr, getWhereCondition, getLabelExpr, buildObjectIDExpr } = require('./sql-expressions.js');
+const { getSkipCheckCondition, getElementSkipCondition, compositeKeyExpr, getValueExpr, getWhereCondition, getLabelExpr, buildObjectIDExpr } = require('./sql-expressions.js');
 const { buildCompositionParentContext, buildParentLookupOrCreateSQL, buildCompositionOnlyBody } = require('./composition.js');
 
-function buildTriggerContext(entity, objectIDs, rowRef, compositionParentInfo = null) {
+function buildTriggerContext(entity, objectIDs, rowRef, model, compositionParentInfo = null) {
 	const keys = utils.extractKeys(entity.keys);
 	return {
 		entityKeyExpr: compositeKeyExpr(keys.map((k) => `:${rowRef}.${k}`)),
-		objectIDExpr: buildObjectIDExpr(objectIDs, entity, rowRef),
+		objectIDExpr: buildObjectIDExpr(objectIDs, entity, rowRef, model),
 		parentLookupExpr: compositionParentInfo !== null ? 'parent_id' : null
 	};
 }
 
-function buildInsertSQL(entity, columns, modification, ctx) {
+function buildInsertSQL(entity, columns, modification, ctx, model) {
 	// Generate single UNION ALL query for all changed columns
 	const unionQuery = columns
 		.map((col) => {
@@ -37,8 +37,8 @@ function buildInsertSQL(entity, columns, modification, ctx) {
 
 			const oldVal = modification === 'create' ? 'NULL' : getValueExpr(col, 'old');
 			const newVal = modification === 'delete' ? 'NULL' : getValueExpr(col, 'new');
-			const oldLabel = modification === 'create' ? 'NULL' : getLabelExpr(col, 'old');
-			const newLabel = modification === 'delete' ? 'NULL' : getLabelExpr(col, 'new');
+			const oldLabel = modification === 'create' ? 'NULL' : getLabelExpr(col, 'old', model);
+			const newLabel = modification === 'delete' ? 'NULL' : getLabelExpr(col, 'new', model);
 
 			return `SELECT '${col.name}' AS attribute, ${oldVal} AS valueChangedFrom, ${newVal} AS valueChangedTo, ${oldLabel} AS valueChangedFromLabel, ${newLabel} AS valueChangedToLabel, '${col.type}' AS valueDataType FROM SAP_CHANGELOG_CHANGE_TRACKING_DUMMY WHERE ${fullWhere}`;
 		})
@@ -81,18 +81,18 @@ function wrapInSkipCheck(entityName, insertSQL, compositionParentContext = null)
 	END IF;`;
 }
 
-function generateCreateTrigger(entity, columns, objectIDs, rootObjectIDs, compositionParentInfo = null, grandParentCompositionInfo = null) {
-	const ctx = buildTriggerContext(entity, objectIDs, 'new', compositionParentInfo);
+function generateCreateTrigger(entity, columns, objectIDs, rootObjectIDs, model, compositionParentInfo = null, grandParentCompositionInfo = null) {
+	const ctx = buildTriggerContext(entity, objectIDs, 'new', model, compositionParentInfo);
 
 	// Build context for composition parent entry if this is a tracked composition target
-	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'create', 'new', grandParentCompositionInfo) : null;
+	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'create', 'new', model, grandParentCompositionInfo) : null;
 
 	// Handle composition-only triggers (no tracked columns, only composition parent entry)
 	let body;
 	if (columns.length === 0 && compositionParentContext) {
 		body = buildCompositionOnlyBody(entity.name, compositionParentContext);
 	} else {
-		const insertSQL = buildInsertSQL(entity, columns, 'create', ctx);
+		const insertSQL = buildInsertSQL(entity, columns, 'create', ctx, model);
 		body = wrapInSkipCheck(entity.name, insertSQL, compositionParentContext);
 	}
 
@@ -108,18 +108,18 @@ END;`,
 	};
 }
 
-function generateUpdateTrigger(entity, columns, objectIDs, rootObjectIDs, compositionParentInfo = null, grandParentCompositionInfo = null) {
-	const ctx = buildTriggerContext(entity, objectIDs, 'new', compositionParentInfo);
+function generateUpdateTrigger(entity, columns, objectIDs, rootObjectIDs, model, compositionParentInfo = null, grandParentCompositionInfo = null) {
+	const ctx = buildTriggerContext(entity, objectIDs, 'new', model, compositionParentInfo);
 
 	// Build context for composition parent entry if this is a tracked composition target
-	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'update', 'new', grandParentCompositionInfo) : null;
+	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'update', 'new', model, grandParentCompositionInfo) : null;
 
 	// Handle composition-only triggers (no tracked columns, only composition parent entry)
 	let body;
 	if (columns.length === 0 && compositionParentContext) {
 		body = buildCompositionOnlyBody(entity.name, compositionParentContext);
 	} else {
-		const insertSQL = buildInsertSQL(entity, columns, 'update', ctx);
+		const insertSQL = buildInsertSQL(entity, columns, 'update', ctx, model);
 		body = wrapInSkipCheck(entity.name, insertSQL, compositionParentContext);
 	}
 
@@ -144,18 +144,18 @@ END;`,
 	};
 }
 
-function generateDeleteTriggerPreserve(entity, columns, objectIDs, rootObjectIDs, compositionParentInfo = null, grandParentCompositionInfo = null) {
-	const ctx = buildTriggerContext(entity, objectIDs, 'old', compositionParentInfo);
+function generateDeleteTriggerPreserve(entity, columns, objectIDs, rootObjectIDs, model, compositionParentInfo = null, grandParentCompositionInfo = null) {
+	const ctx = buildTriggerContext(entity, objectIDs, 'old', model, compositionParentInfo);
 
 	// Build context for composition parent entry if this is a tracked composition target
-	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'delete', 'old', grandParentCompositionInfo) : null;
+	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'delete', 'old', model, grandParentCompositionInfo) : null;
 
 	// Handle composition-only triggers (no tracked columns, only composition parent entry)
 	let body;
 	if (columns.length === 0 && compositionParentContext) {
 		body = buildCompositionOnlyBody(entity.name, compositionParentContext);
 	} else {
-		const insertSQL = buildInsertSQL(entity, columns, 'delete', ctx);
+		const insertSQL = buildInsertSQL(entity, columns, 'delete', ctx, model);
 		body = wrapInSkipCheck(entity.name, insertSQL, compositionParentContext);
 	}
 
@@ -171,16 +171,16 @@ END;`,
 	};
 }
 
-function generateDeleteTrigger(entity, columns, objectIDs, rootObjectIDs, compositionParentInfo = null, grandParentCompositionInfo = null) {
+function generateDeleteTrigger(entity, columns, objectIDs, rootObjectIDs, model, compositionParentInfo = null, grandParentCompositionInfo = null) {
 	const keys = utils.extractKeys(entity.keys);
 	const entityKey = compositeKeyExpr(keys.map((k) => `:old.${k}`));
 
-	const ctx = buildTriggerContext(entity, objectIDs, 'old', compositionParentInfo);
+	const ctx = buildTriggerContext(entity, objectIDs, 'old', model, compositionParentInfo);
 
 	const deleteSQL = `DELETE FROM SAP_CHANGELOG_CHANGES WHERE entity = '${entity.name}' AND entityKey = ${entityKey};`;
 
 	// Build context for composition parent entry if this is a tracked composition target
-	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'delete', 'old', grandParentCompositionInfo) : null;
+	const compositionParentContext = compositionParentInfo ? buildCompositionParentContext(compositionParentInfo, rootObjectIDs, 'delete', 'old', model, grandParentCompositionInfo) : null;
 
 	// Special wrapping for delete - need variable declared if using composition
 	let body;
@@ -189,7 +189,7 @@ function generateDeleteTrigger(entity, columns, objectIDs, rootObjectIDs, compos
 		body = buildCompositionOnlyBody(entity.name, compositionParentContext, deleteSQL);
 	} else if (compositionParentContext) {
 		// Mixed case: both composition parent entry and child column inserts
-		const insertSQL = buildInsertSQL(entity, columns, 'delete', ctx);
+		const insertSQL = buildInsertSQL(entity, columns, 'delete', ctx, model);
 		const { declares } = compositionParentContext;
 		body = `${declares}
 	IF ${getSkipCheckCondition(entity.name)} THEN
@@ -199,7 +199,7 @@ function generateDeleteTrigger(entity, columns, objectIDs, rootObjectIDs, compos
 	END IF;`;
 	} else {
 		// No composition: standard delete with column inserts
-		const insertSQL = buildInsertSQL(entity, columns, 'delete', ctx);
+		const insertSQL = buildInsertSQL(entity, columns, 'delete', ctx, model);
 		body = wrapInSkipCheck(entity.name, `${deleteSQL}\n\t\t${insertSQL}`);
 	}
 
@@ -216,7 +216,6 @@ END;`,
 }
 
 function generateHANATriggers(csn, entity, rootEntity = null, mergedAnnotations = null, rootMergedAnnotations = null, grandParentContext = {}) {
-	setModel(csn);
 	const triggers = [];
 	const { columns: trackedColumns } = utils.extractTrackedColumns(entity, csn, mergedAnnotations);
 
@@ -238,14 +237,14 @@ function generateHANATriggers(csn, entity, rootEntity = null, mergedAnnotations
 
 	// Generate triggers - either for tracked columns or for composition-only tracking
 	if (!config?.disableCreateTracking) {
-		triggers.push(generateCreateTrigger(entity, trackedColumns, objectIDs, rootObjectIDs, compositionParentInfo, grandParentCompositionInfo));
+		triggers.push(generateCreateTrigger(entity, trackedColumns, objectIDs, rootObjectIDs, csn, compositionParentInfo, grandParentCompositionInfo));
 	}
 	if (!config?.disableUpdateTracking) {
-		triggers.push(generateUpdateTrigger(entity, trackedColumns, objectIDs, rootObjectIDs, compositionParentInfo, grandParentCompositionInfo));
+		triggers.push(generateUpdateTrigger(entity, trackedColumns, objectIDs, rootObjectIDs, csn, compositionParentInfo, grandParentCompositionInfo));
 	}
 	if (!config?.disableDeleteTracking) {
 		const generateDeleteTriggerFunc = config?.preserveDeletes ? generateDeleteTriggerPreserve : generateDeleteTrigger;
-		triggers.push(generateDeleteTriggerFunc(entity, trackedColumns, objectIDs, rootObjectIDs, compositionParentInfo, grandParentCompositionInfo));
+		triggers.push(generateDeleteTriggerFunc(entity, trackedColumns, objectIDs, rootObjectIDs, csn, compositionParentInfo, grandParentCompositionInfo));
 	}
 
 	return triggers;

package/lib/model-enhancer.js

@@ -203,7 +203,7 @@ function enhanceModel(m) {
 										if (!cqn) {
 											return false;
 										}
-										// from.args is the case for joins
+										// from.args is the case for joins //REVISIT: only works in case it is one join, multiple joins and the ref is nested in further args
 										baseE = cqn.from?.ref?.[0] ?? cqn.from?.args?.[0]?.ref?.[0];
 									}
 									return false;

package/lib/postgres/composition.js

@@ -1,14 +1,16 @@
 const utils = require('../utils/change-tracking.js');
-const { getModel, toSQL, compositeKeyExpr } = require('./sql-expressions.js');
+const { toSQL, compositeKeyExpr } = require('./sql-expressions.js');
 
 /**
  * Builds rootObjectID select for composition of many
  */
-function buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, binding, refRow) {
-	if (!rootObjectIDs || rootObjectIDs.length === 0) return `'${rootEntity.name}'`;
+function buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, binding, refRow, model) {
+	const rootEntityKeyExpr = compositeKeyExpr(binding.map((k) => `${refRow}.${k}`));
+
+	if (!rootObjectIDs || rootObjectIDs.length === 0) return rootEntityKeyExpr;
 
 	const rootKeys = utils.extractKeys(rootEntity.keys);
-	if (rootKeys.length !== binding.length) return `'${rootEntity.name}'`;
+	if (rootKeys.length !== binding.length) return rootEntityKeyExpr;
 
 	const where = {};
 	for (let i = 0; i < rootKeys.length; i++) {
@@ -18,17 +20,15 @@ function buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, binding, r
 	const parts = [];
 	for (const oid of rootObjectIDs) {
 		const query = SELECT.one.from(rootEntity.name).columns(oid.name).where(where);
-		parts.push(`COALESCE((${toSQL(query)})::TEXT, '')`);
+		parts.push(`COALESCE((${toSQL(query, model)})::TEXT, '')`);
 	}
 
 	const concatLogic = `CONCAT_WS(', ', ${parts.join(', ')})`;
-	const rootEntityKeyExpr = compositeKeyExpr(binding.map((k) => `${refRow}.${k}`));
 
 	return `COALESCE(NULLIF(${concatLogic}, ''), ${rootEntityKeyExpr})`;
 }
 
-function buildCompositionOfOneParentBlock(compositionParentInfo, rootObjectIDs) {
-	const model = getModel();
+function buildCompositionOfOneParentBlock(compositionParentInfo, rootObjectIDs, model) {
 	const { parentEntityName, compositionFieldName, parentKeyBinding } = compositionParentInfo;
 	const { compositionName, childKeys } = parentKeyBinding;
 
@@ -84,20 +84,19 @@ function buildCompositionOfOneParentBlock(compositionParentInfo, rootObjectIDs)
             END IF;`;
 }
 
-function buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, modification, grandParentCompositionInfo = null) {
-	const model = getModel();
+function buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, modification, model, grandParentCompositionInfo = null) {
 	const { parentEntityName, compositionFieldName, parentKeyBinding } = compositionParentInfo;
 
 	// Handle composition of one (parent has FK to child - need reverse lookup)
 	if (parentKeyBinding.type === 'compositionOfOne') {
-		return buildCompositionOfOneParentBlock(compositionParentInfo, rootObjectIDs);
+		return buildCompositionOfOneParentBlock(compositionParentInfo, rootObjectIDs, model);
 	}
 
 	const parentKeyExpr = compositeKeyExpr(parentKeyBinding.map((k) => `rec.${k}`));
 
 	// Build rootObjectID expression for the parent entity
 	const rootEntity = model.definitions[parentEntityName];
-	const rootObjectIDExpr = buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, parentKeyBinding, 'rec');
+	const rootObjectIDExpr = buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, parentKeyBinding, 'rec', model);
 
 	let grandparentBlock = '';
 	let grandparentLookupExpr = 'NULL';

package/lib/postgres/sql-expressions.js

@@ -5,26 +5,18 @@ const cqn4sql = require('@cap-js/db-service/lib/cqn4sql');
 const { CT_SKIP_VAR, getEntitySkipVarName, getElementSkipVarName } = require('../utils/session-variables.js');
 const { createTriggerCQN2SQL } = require('../TriggerCQN2SQL.js');
 
-let PostgresCQN2SQL;
-let model;
+const _cqn2sqlCache = new WeakMap();
 
-function setModel(m) {
-	model = m;
-	PostgresCQN2SQL = null;
-}
-
-function getModel() {
-	return model;
-}
-
-function toSQL(query) {
-	if (!PostgresCQN2SQL) {
+function toSQL(query, model) {
+	let cqn2sql = _cqn2sqlCache.get(model);
+	if (!cqn2sql) {
 		const Service = require('@cap-js/postgres');
 		const TriggerCQN2SQL = createTriggerCQN2SQL(Service.CQN2SQL);
-		PostgresCQN2SQL = new TriggerCQN2SQL({ model });
+		cqn2sql = new TriggerCQN2SQL({ model });
+		_cqn2sqlCache.set(model, cqn2sql);
 	}
 	const sqlCQN = cqn4sql(query, model);
-	return PostgresCQN2SQL.SELECT(sqlCQN);
+	return cqn2sql.SELECT(sqlCQN);
 }
 
 function getSkipCheckCondition(entityName) {
@@ -94,7 +86,7 @@ function getWhereCondition(col, modification) {
 /**
  * Builds scalar subselect for association label lookup with locale support
  */
-function buildAssocLookup(column, refRow) {
+function buildAssocLookup(column, refRow, model) {
 	let where = {};
 	if (column.foreignKeys) {
 		where = column.foreignKeys.reduce((acc, k) => {
@@ -117,19 +109,19 @@ function buildAssocLookup(column, refRow) {
 		const textsWhere = { ...where, locale: { func: 'current_setting', args: [{ val: 'cap.locale' }, { val: true }] } };
 		const textsQuery = SELECT.one.from(localizedInfo.textsEntity).columns(columns).where(textsWhere);
 		const baseQuery = SELECT.one.from(column.target).columns(columns).where(where);
-		return `(SELECT COALESCE((${toSQL(textsQuery)}), (${toSQL(baseQuery)})))`;
+		return `(SELECT COALESCE((${toSQL(textsQuery, model)}), (${toSQL(baseQuery, model)})))`;
 	}
 
 	const query = SELECT.one.from(column.target).columns(columns).where(where);
-	return `(${toSQL(query)})`;
+	return `(${toSQL(query, model)})`;
 }
 
 /**
  * Returns SQL expression for a column's label (looked-up value for associations)
  */
-function getLabelExpr(col, refRow) {
+function getLabelExpr(col, refRow, model) {
 	if (col.target && col.alt) {
-		return buildAssocLookup(col, refRow);
+		return buildAssocLookup(col, refRow, model);
 	}
 	return 'NULL';
 }
@@ -137,22 +129,22 @@ function getLabelExpr(col, refRow) {
 /**
  * Builds PL/pgSQL statement for objectID assignment
  */
-function buildObjectIDAssignment(objectIDs, entity, keys, recVar, targetVar) {
+function buildObjectIDAssignment(objectIDs, entity, keys, recVar, targetVar, model) {
 	if (!objectIDs || objectIDs.length === 0) {
-		return `${targetVar} := '${entity.name}';`;
+		return `${targetVar} := entity_key;`;
 	}
 
 	const parts = [];
 	for (const oid of objectIDs) {
 		if (oid.included) {
-			parts.push(`${recVar}.${oid.name}::TEXT`);
+			parts.push(`COALESCE(${recVar}.${oid.name}::TEXT, '<empty>')`);
 		} else {
 			const where = keys.reduce((acc, k) => {
 				acc[k] = { val: `${recVar}.${k}` };
 				return acc;
 			}, {});
 			const query = SELECT.one.from(entity.name).columns(oid.name).where(where);
-			parts.push(`COALESCE((${toSQL(query)})::TEXT, '')`);
+			parts.push(`COALESCE((${toSQL(query, model)})::TEXT, '')`);
 		}
 	}
 
@@ -164,7 +156,7 @@ function buildObjectIDAssignment(objectIDs, entity, keys, recVar, targetVar) {
     `;
 }
 
-function buildColumnSubquery(col, modification, entity) {
+function buildColumnSubquery(col, modification, entity, model) {
 	const whereCondition = getWhereCondition(col, modification);
 	const elementSkipCondition = getElementSkipCondition(entity.name, col.name);
 	let fullWhere = `(${whereCondition}) AND ${elementSkipCondition}`;
@@ -184,8 +176,8 @@ function buildColumnSubquery(col, modification, entity) {
 
 	const oldVal = modification === 'create' ? 'NULL' : getValueExpr(col, 'OLD');
 	const newVal = modification === 'delete' ? 'NULL' : getValueExpr(col, 'NEW');
-	const oldLabel = modification === 'create' ? 'NULL' : getLabelExpr(col, 'OLD');
-	const newLabel = modification === 'delete' ? 'NULL' : getLabelExpr(col, 'NEW');
+	const oldLabel = modification === 'create' ? 'NULL' : getLabelExpr(col, 'OLD', model);
+	const newLabel = modification === 'delete' ? 'NULL' : getLabelExpr(col, 'NEW', model);
 
 	return `SELECT '${col.name}' AS attribute, ${oldVal} AS valueChangedFrom, ${newVal} AS valueChangedTo, ${oldLabel} AS valueChangedFromLabel, ${newLabel} AS valueChangedToLabel, '${col.type}' AS valueDataType WHERE ${fullWhere}`;
 }
@@ -193,8 +185,8 @@ function buildColumnSubquery(col, modification, entity) {
 /**
  * Generates INSERT SQL for changelog entries from UNION query
  */
-function buildChangelogInsertSQL(columns, modification, entity, hasCompositionParent = false) {
-	const unionQuery = columns.map((col) => buildColumnSubquery(col, modification, entity)).join('\n            UNION ALL\n            ');
+function buildChangelogInsertSQL(columns, modification, entity, model, hasCompositionParent = false) {
+	const unionQuery = columns.map((col) => buildColumnSubquery(col, modification, entity, model)).join('\n            UNION ALL\n            ');
 	const parentIdValue = hasCompositionParent ? 'comp_parent_id' : 'NULL';
 
 	return `INSERT INTO sap_changelog_changes
@@ -223,7 +215,7 @@ function buildChangelogInsertSQL(columns, modification, entity, hasCompositionPa
 /**
  * Generates INSERT block for a modification type (with config check)
  */
-function buildInsertBlock(columns, modification, entity, hasCompositionParent = false) {
+function buildInsertBlock(columns, modification, entity, model, hasCompositionParent = false) {
 	if (!config || (modification === 'create' && config.disableCreateTracking) || (modification === 'update' && config.disableUpdateTracking) || (modification === 'delete' && config.disableDeleteTracking)) {
 		return '';
 	}
@@ -232,10 +224,10 @@ function buildInsertBlock(columns, modification, entity, hasCompositionParent =
 		const keys = utils.extractKeys(entity.keys);
 		const entityKey = compositeKeyExpr(keys.map((k) => `OLD.${k}`));
 		const deleteSQL = `DELETE FROM sap_changelog_changes WHERE entity = '${entity.name}' AND entitykey = ${entityKey};`;
-		return `${deleteSQL}\n            ${buildChangelogInsertSQL(columns, modification, entity, hasCompositionParent)}`;
+		return `${deleteSQL}\n            ${buildChangelogInsertSQL(columns, modification, entity, model, hasCompositionParent)}`;
 	}
 
-	return buildChangelogInsertSQL(columns, modification, entity, hasCompositionParent);
+	return buildChangelogInsertSQL(columns, modification, entity, model, hasCompositionParent);
 }
 
 /**
@@ -256,8 +248,6 @@ function extractTrackedDbColumns(columns) {
 }
 
 module.exports = {
-	setModel,
-	getModel,
 	toSQL,
 	getSkipCheckCondition,
 	getElementSkipCondition,

package/lib/postgres/triggers.js

@@ -1,26 +1,26 @@
 const utils = require('../utils/change-tracking.js');
 const { getCompositionParentInfo, getGrandParentCompositionInfo } = require('../utils/composition-helpers.js');
-const { setModel, getSkipCheckCondition, compositeKeyExpr, buildObjectIDAssignment, buildInsertBlock, extractTrackedDbColumns } = require('./sql-expressions.js');
+const { getSkipCheckCondition, compositeKeyExpr, buildObjectIDAssignment, buildInsertBlock, extractTrackedDbColumns } = require('./sql-expressions.js');
 const { buildCompositionParentBlock } = require('./composition.js');
 
 /**
  * Generates the PL/pgSQL function body for the main change tracking trigger
  */
-function buildFunctionBody(entity, columns, objectIDs, rootEntity, rootObjectIDs, compositionParentInfo = null, grandParentCompositionInfo = null) {
+function buildFunctionBody(entity, columns, objectIDs, rootEntity, rootObjectIDs, model, compositionParentInfo = null, grandParentCompositionInfo = null) {
 	const keys = utils.extractKeys(entity.keys);
 	const entityKeyExpr = compositeKeyExpr(keys.map((k) => `rec.${k}`));
 
-	const objectIDAssignment = buildObjectIDAssignment(objectIDs, entity, keys, 'rec', 'object_id');
+	const objectIDAssignment = buildObjectIDAssignment(objectIDs, entity, keys, 'rec', 'object_id', model);
 
 	const hasCompositionParent = compositionParentInfo !== null;
-	const createBlock = columns.length > 0 ? buildInsertBlock(columns, 'create', entity, hasCompositionParent) : '';
-	const updateBlock = columns.length > 0 ? buildInsertBlock(columns, 'update', entity, hasCompositionParent) : '';
-	const deleteBlock = columns.length > 0 ? buildInsertBlock(columns, 'delete', entity, hasCompositionParent) : '';
+	const createBlock = columns.length > 0 ? buildInsertBlock(columns, 'create', entity, model, hasCompositionParent) : '';
+	const updateBlock = columns.length > 0 ? buildInsertBlock(columns, 'update', entity, model, hasCompositionParent) : '';
+	const deleteBlock = columns.length > 0 ? buildInsertBlock(columns, 'delete', entity, model, hasCompositionParent) : '';
 
 	// Build composition parent blocks if needed
-	const createParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'create', grandParentCompositionInfo) : '';
-	const updateParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'update', grandParentCompositionInfo) : '';
-	const deleteParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'delete', grandParentCompositionInfo) : '';
+	const createParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'create', model, grandParentCompositionInfo) : '';
+	const updateParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'update', model, grandParentCompositionInfo) : '';
+	const deleteParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'delete', model, grandParentCompositionInfo) : '';
 
 	return `
         DECLARE
@@ -53,8 +53,6 @@ function buildFunctionBody(entity, columns, objectIDs, rootEntity, rootObjectIDs
 }
 
 function generatePostgresTriggers(csn, entity, rootEntity, mergedAnnotations = null, rootMergedAnnotations = null, grandParentContext = {}) {
-	setModel(csn);
-
 	const triggers = [];
 	const { columns: trackedColumns } = utils.extractTrackedColumns(entity, csn, mergedAnnotations);
 	const objectIDs = utils.getObjectIDs(entity, csn, mergedAnnotations?.entityAnnotation);
@@ -75,7 +73,7 @@ function generatePostgresTriggers(csn, entity, rootEntity, mergedAnnotations = n
 	const triggerName = `${tableName}_tr_change`;
 	const functionName = `${tableName}_func_change`;
 
-	const funcBody = buildFunctionBody(entity, trackedColumns, objectIDs, rootEntity, rootObjectIDs, compositionParentInfo, grandParentCompositionInfo);
+	const funcBody = buildFunctionBody(entity, trackedColumns, objectIDs, rootEntity, rootObjectIDs, csn, compositionParentInfo, grandParentCompositionInfo);
 
 	// Include comp_parent_id, comp_parent_modification and comp_grandparent_id variable declarations if needed
 	const parentIdDecl = compositionParentInfo ? 'comp_parent_id UUID := NULL;' : '';

package/lib/skipHandlers.js

@@ -9,7 +9,7 @@ const { setSkipSessionVariables, resetSkipSessionVariables, resetAutoSkipForServ
 function registerSessionVariableHandlers() {
 	cds.db.before(['INSERT', 'UPDATE', 'DELETE'], async (req) => {
 		const model = cds.context?.model ?? cds.model;
-		const { collectedEntities } = collectEntities(model);
+		const collectedEntities = model.collectEntities || (model.collectEntities = collectEntities(model).collectedEntities);
 		if (!req.target || req.target.name.endsWith('.drafts')) return;
 		const srv = req.target._service;
 		if (!srv) return;

package/lib/sqlite/composition.js

@@ -1,14 +1,16 @@
 const utils = require('../utils/change-tracking.js');
-const { getModel, toSQL, compositeKeyExpr } = require('./sql-expressions.js');
+const { toSQL, compositeKeyExpr } = require('./sql-expressions.js');
 
 /**
  * Builds rootObjectID select for composition of many
  */
-function buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, binding, refRow) {
-	if (!rootObjectIDs || rootObjectIDs.length === 0) return `'${rootEntity.name}'`;
+function buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, binding, refRow, model) {
+	const rootEntityKeyExpr = compositeKeyExpr(binding.map((k) => `${refRow}.${k}`));
+
+	if (!rootObjectIDs || rootObjectIDs.length === 0) return rootEntityKeyExpr;
 
 	const rootKeys = utils.extractKeys(rootEntity.keys);
-	if (rootKeys.length !== binding.length) return `'${rootEntity.name}'`;
+	if (rootKeys.length !== binding.length) return rootEntityKeyExpr;
 
 	const where = {};
 	for (let i = 0; i < rootKeys.length; i++) {
@@ -19,15 +21,14 @@ function buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, binding, r
 	const oids = rootObjectIDs.map((o) => ({ ...o }));
 	for (const oid of oids) {
 		const q = SELECT.one.from(rootEntity.name).columns(oid.name).where(where);
-		oid.selectSQL = toSQL(q);
+		oid.selectSQL = toSQL(q, model);
 	}
 
 	const unions = oids.map((oid) => `SELECT (${oid.selectSQL}) AS value`).join('\nUNION ALL\n');
 	return `(SELECT GROUP_CONCAT(value, ', ') FROM (${unions}))`;
 }
 
-function buildCompositionOfOneParentContext(compositionParentInfo, rootObjectIDs, modification, rowRef) {
-	const model = getModel();
+function buildCompositionOfOneParentContext(compositionParentInfo, rootObjectIDs, modification, rowRef, model) {
 	const { parentEntityName, compositionFieldName, parentKeyBinding } = compositionParentInfo;
 	const { compositionName, childKeys } = parentKeyBinding;
 
@@ -95,23 +96,21 @@ function buildCompositionOfOneParentContext(compositionParentInfo, rootObjectIDs
 	return { insertSQL, parentEntityName, compositionFieldName, parentKeyExpr, parentLookupExpr };
 }
 
-function buildCompositionParentContext(compositionParentInfo, rootObjectIDs, modification, rowRef, grandParentCompositionInfo = null) {
-	const model = getModel();
+function buildCompositionParentContext(compositionParentInfo, rootObjectIDs, modification, rowRef, model, grandParentCompositionInfo = null) {
 	const { parentEntityName, compositionFieldName, parentKeyBinding } = compositionParentInfo;
 
 	// Handle composition of one (parent has FK to child - need reverse lookup)
 	if (parentKeyBinding.type === 'compositionOfOne') {
-		return buildCompositionOfOneParentContext(compositionParentInfo, rootObjectIDs, modification, rowRef);
+		return buildCompositionOfOneParentContext(compositionParentInfo, rootObjectIDs, modification, rowRef, model);
 	}
 
 	const parentKeyExpr = compositeKeyExpr(parentKeyBinding.map((k) => `${rowRef}.${k}`));
 
 	// Build rootObjectID expression for the parent entity
 	const rootEntity = model.definitions[parentEntityName];
-	const rootObjectIDExpr = buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, parentKeyBinding, rowRef);
+	const rootObjectIDExpr = buildCompOfManyRootObjectIDSelect(rootEntity, rootObjectIDs, parentKeyBinding, rowRef, model);
 
 	let insertSQL;
-	let grandParentLookupExpr = 'NULL';
 
 	if (grandParentCompositionInfo) {
 		const { grandParentEntityName, grandParentCompositionFieldName, grandParentKeyBinding } = grandParentCompositionInfo;
@@ -124,7 +123,7 @@ function buildCompositionParentContext(compositionParentInfo, rootObjectIDs, mod
 
 		// Build expression for grandparent lookup (for linking parent entry to it)
 		// Must filter by createdAt to get entry from current transaction
-		grandParentLookupExpr = `(SELECT ID FROM sap_changelog_Changes
+		const grandParentLookupExpr = `(SELECT ID FROM sap_changelog_Changes
 			WHERE entity = '${grandParentEntityName}'
 			AND entityKey = ${grandParentKeyExpr}
 			AND attribute = '${grandParentCompositionFieldName}'