@cap-js/change-tracking 1.1.4 → 2.0.0-beta.2

package/lib/hana/triggers.js

@@ -0,0 +1,253 @@
+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 { getSkipCheckCondition, getElementSkipCondition, compositeKeyExpr, getValueExpr, getWhereCondition, getLabelExpr, buildObjectIDExpr } = require('./sql-expressions.js');
+const { buildCompositionParentContext, buildParentLookupOrCreateSQL, buildCompositionOnlyBody } = require('./composition.js');
+
+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, model),
+		parentLookupExpr: compositionParentInfo !== null ? 'parent_id' : null
+	};
+}
+
+function buildInsertSQL(entity, columns, modification, ctx, model) {
+	// Generate single UNION ALL query for all changed columns
+	const unionQuery = columns
+		.map((col) => {
+			const whereCondition = getWhereCondition(col, modification);
+			const elementSkipCondition = getElementSkipCondition(entity.name, col.name);
+			let fullWhere = `(${whereCondition}) AND ${elementSkipCondition}`;
+
+			// For composition-of-one columns, add deduplication check to prevent duplicate entries
+			// when child trigger has already created a composition entry for this transaction
+			if (col.type === 'cds.Composition' && ctx.entityKeyExpr) {
+				fullWhere += ` AND NOT EXISTS (
+			SELECT 1 FROM SAP_CHANGELOG_CHANGES
+			WHERE entity = '${entity.name}'
+			AND entityKey = ${ctx.entityKeyExpr}
+			AND attribute = '${col.name}'
+			AND valueDataType = 'cds.Composition'
+			AND transactionID = CURRENT_UPDATE_TRANSACTION()
+		)`;
+			}
+
+			const oldVal = modification === 'create' ? 'NULL' : getValueExpr(col, 'old');
+			const newVal = modification === 'delete' ? 'NULL' : getValueExpr(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}`;
+		})
+		.join('\nUNION ALL\n');
+
+	return `INSERT INTO SAP_CHANGELOG_CHANGES
+		(ID, parent_ID, attribute, valueChangedFrom, valueChangedTo, valueChangedFromLabel, valueChangedToLabel, entity, entityKey, objectID, createdAt, createdBy, valueDataType, modification, transactionID)
+		SELECT
+			SYSUUID,
+			${ctx.parentLookupExpr},
+			attribute,
+			valueChangedFrom,
+			valueChangedTo,
+			valueChangedFromLabel,
+			valueChangedToLabel,
+			'${entity.name}',
+			${ctx.entityKeyExpr},
+			${ctx.objectIDExpr},
+			CURRENT_TIMESTAMP,
+			SESSION_CONTEXT('APPLICATIONUSER'),
+			valueDataType,
+			'${modification}',
+			CURRENT_UPDATE_TRANSACTION()
+		FROM (
+			${unionQuery}
+		);`;
+}
+
+function wrapInSkipCheck(entityName, insertSQL, compositionParentContext = null) {
+	if (compositionParentContext) {
+		const { declares } = compositionParentContext;
+		return `${declares}
+	IF ${getSkipCheckCondition(entityName)} THEN
+		${buildParentLookupOrCreateSQL(compositionParentContext)}
+		${insertSQL}
+	END IF;`;
+	}
+	return `IF ${getSkipCheckCondition(entityName)} THEN
+		${insertSQL}
+	END IF;`;
+}
+
+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', 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, model);
+		body = wrapInSkipCheck(entity.name, insertSQL, compositionParentContext);
+	}
+
+	return {
+		name: entity.name + '_CT_CREATE',
+		sql: `TRIGGER ${utils.transformName(entity.name)}_CT_CREATE AFTER INSERT
+ON ${utils.transformName(entity.name)}
+REFERENCING NEW ROW new
+BEGIN
+	${body}
+END;`,
+		suffix: '.hdbtrigger'
+	};
+}
+
+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', 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, model);
+		body = wrapInSkipCheck(entity.name, insertSQL, compositionParentContext);
+	}
+
+	// Build OF clause for targeted update trigger
+	const ofColumns = columns.flatMap((c) => {
+		if (!c.target) return [c.name];
+		if (c.foreignKeys) return c.foreignKeys.map((k) => `${c.name}_${k.replaceAll(/\./g, '_')}`);
+		if (c.on) return c.on.map((m) => m.foreignKeyField);
+		return [];
+	});
+	const ofClause = columns.length > 0 ? `OF ${ofColumns.join(', ')} ` : '';
+
+	return {
+		name: entity.name + '_CT_UPDATE',
+		sql: `TRIGGER ${utils.transformName(entity.name)}_CT_UPDATE AFTER UPDATE ${ofClause}
+ON ${utils.transformName(entity.name)}
+REFERENCING NEW ROW new, OLD ROW old
+BEGIN
+	${body}
+END;`,
+		suffix: '.hdbtrigger'
+	};
+}
+
+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', 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, model);
+		body = wrapInSkipCheck(entity.name, insertSQL, compositionParentContext);
+	}
+
+	return {
+		name: entity.name + '_CT_DELETE',
+		sql: `TRIGGER ${utils.transformName(entity.name)}_CT_DELETE AFTER DELETE
+ON ${utils.transformName(entity.name)}
+REFERENCING OLD ROW old
+BEGIN
+	${body}
+END;`,
+		suffix: '.hdbtrigger'
+	};
+}
+
+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', 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', model, grandParentCompositionInfo) : null;
+
+	// Special wrapping for delete - need variable declared if using composition
+	let body;
+	if (columns.length === 0 && compositionParentContext) {
+		// Composition-only case: only insert composition parent entry, no child column inserts
+		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, model);
+		const { declares } = compositionParentContext;
+		body = `${declares}
+	IF ${getSkipCheckCondition(entity.name)} THEN
+		${deleteSQL}
+		${buildParentLookupOrCreateSQL(compositionParentContext)}
+		${insertSQL}
+	END IF;`;
+	} else {
+		// No composition: standard delete with column inserts
+		const insertSQL = buildInsertSQL(entity, columns, 'delete', ctx, model);
+		body = wrapInSkipCheck(entity.name, `${deleteSQL}\n\t\t${insertSQL}`);
+	}
+
+	return {
+		name: entity.name + '_CT_DELETE',
+		sql: `TRIGGER ${utils.transformName(entity.name)}_CT_DELETE AFTER DELETE
+ON ${utils.transformName(entity.name)}
+REFERENCING OLD ROW old
+BEGIN
+	${body}
+END;`,
+		suffix: '.hdbtrigger'
+	};
+}
+
+function generateHANATriggers(csn, entity, rootEntity = null, mergedAnnotations = null, rootMergedAnnotations = null, grandParentContext = {}) {
+	const triggers = [];
+	const { columns: trackedColumns } = utils.extractTrackedColumns(entity, csn, mergedAnnotations);
+
+	const objectIDs = utils.getObjectIDs(entity, csn, mergedAnnotations?.entityAnnotation);
+	const rootObjectIDs = utils.getObjectIDs(rootEntity, csn, rootMergedAnnotations?.entityAnnotation);
+
+	const keys = utils.extractKeys(entity.keys);
+	if (keys.length === 0 && trackedColumns.length > 0) return triggers;
+
+	// Check if this entity is a composition target with @changelog on the composition field
+	const compositionParentInfo = getCompositionParentInfo(entity, rootEntity, rootMergedAnnotations);
+
+	// Get grandparent info for deep linking (e.g., OrderItemNote -> OrderItem.notes -> Order.orderItems)
+	const { grandParentEntity, grandParentMergedAnnotations, grandParentCompositionField } = grandParentContext;
+	const grandParentCompositionInfo = getGrandParentCompositionInfo(rootEntity, grandParentEntity, grandParentMergedAnnotations, grandParentCompositionField);
+
+	// Skip if no tracked columns and not a composition target with tracked composition
+	if (trackedColumns.length === 0 && !compositionParentInfo) return triggers;
+
+	// Generate triggers - either for tracked columns or for composition-only tracking
+	if (!config?.disableCreateTracking) {
+		triggers.push(generateCreateTrigger(entity, trackedColumns, objectIDs, rootObjectIDs, csn, compositionParentInfo, grandParentCompositionInfo));
+	}
+	if (!config?.disableUpdateTracking) {
+		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, csn, compositionParentInfo, grandParentCompositionInfo));
+	}
+
+	return triggers;
+}
+
+module.exports = { generateHANATriggers };

package/lib/localization.js

@@ -1,135 +1,71 @@
 const cds = require('@sap/cds/lib');
-const LOG = cds.log('change-log');
-const { formatOptions } = require('./format-options');
-const { getNameFromPathVal, getDBEntity, splitPath } = require('./entity-helper');
 
-const MODIF_I18N_MAP = {
-	create: 'ChangeLog.modification.create',
-	update: 'ChangeLog.modification.update',
-	delete: 'ChangeLog.modification.delete'
-};
+/**
+ * Generate i18n label translations for change tracking triggers
+ * Used by trigger generators to populate the sap.changelog.i18nKeys table
+ */
+function getLabelTranslations(entities, model) {
+	// Create bundle from the passed model
+	const labelBundle = cds.i18n.bundle4(model);
+	const allLabels = labelBundle.translations4('all');
 
-const _localizeModification = function (change) {
-	if (change.modification && MODIF_I18N_MAP[change.modification]) {
-		change.modification = cds.i18n.labels.for(MODIF_I18N_MAP[change.modification]);
-	}
-};
+	// Get translations for modification texts
+	const bundle = cds.i18n.bundle4({ folders: [cds.utils.path.join(__dirname, '..', '_i18n')] });
+	const modificationLabels = bundle.translations4('all');
 
-const _localizeDefaultObjectID = function (change) {
-	if (!change.objectID) {
-		change.objectID = change.entity ? change.entity : '';
-	}
-	if (change.objectID && change.serviceEntityPath && !change.parentObjectID && change.parentKey) {
-		const path = splitPath(change.serviceEntityPath);
-		const parentNodePathVal = path[path.length - 2];
-		const parentEntityName = getNameFromPathVal(parentNodePathVal);
-		const dbEntity = getDBEntity(parentEntityName);
-		try {
-			const labelI18nKey = getTranslationKey(dbEntity['@Common.Label'] || dbEntity['@title']);
-			change.parentObjectID = cds.i18n.labels.for(labelI18nKey) || labelI18nKey || dbEntity.name;
-		} catch (e) {
-			LOG.error('Failed to localize parent object id', e);
-			throw new Error('Failed to localize parent object id', e);
-		}
-	}
-};
+	const rows = new Map();
+	const addRow = (ID, locale, text) => {
+		const compositeKey = `${ID}::${locale}`;
+		rows.set(compositeKey, { ID, locale, text });
+	};
 
-const _localizeEntityType = function (change) {
-	if (change.entity) {
-		try {
-			const labelI18nKey = _getLabelI18nKeyOnEntity(change.serviceEntity);
-			change.entity = labelI18nKey || change.entity;
-		} catch (e) {
-			LOG.error('Failed to localize entity type', e);
-			throw new Error('Failed to localize entity type', e);
-		}
-	}
-	if (change.serviceEntity) {
-		try {
-			const labelI18nKey = _getLabelI18nKeyOnEntity(change.serviceEntity);
-			change.serviceEntity = labelI18nKey || change.serviceEntity;
-		} catch (e) {
-			LOG.error('Failed to localize service entity', e);
-			throw new Error('Failed to localize service entity', e);
-		}
-	}
-};
+	for (const { dbEntityName, mergedAnnotations } of entities) {
+		const entity = model.definitions[dbEntityName];
 
-const getTranslationKey = (value) => {
-	if (typeof value != 'string') return value;
-	const result = value.match(/(?<=\{@?(i18n>)).*(?=\})/g);
-	return result ? result[0] : value;
-};
-
-const _localizeAttribute = function (change) {
-	if (change.attribute && change.serviceEntity) {
-		const model = cds.context?.model ?? cds.model;
-		try {
-			const serviceEntity = model.definitions[change.serviceEntity];
-			if (!serviceEntity) {
-				LOG.warn(`Cannot localize the attribute ${change.attribute} of ${change.serviceEntity}, because the service entity is not defined in "cds.model.definitions".`);
-				return;
+		// Entity labels
+		const entityLabelKey = labelBundle.key4(entity);
+		if (entityLabelKey && entityLabelKey !== entity.name) {
+			for (const [locale, localeTranslations] of Object.entries(allLabels)) {
+				if (!locale) continue;
+				const text = localeTranslations[entityLabelKey] || entityLabelKey;
+				addRow(entity.name, locale, text);
 			}
-			let labelI18nKey = _getLabelI18nKeyOnEntity(change.serviceEntity, change.attribute);
-			if (!labelI18nKey) {
-				const element = serviceEntity.elements[change.attribute];
-				if (!element) {
-					LOG.warn(`Cannot localize the attribute ${change.attribute} of ${change.serviceEntity}, because the attribute does not exist on the entity.`);
-					return;
+		}
+
+		// Attribute labels
+		for (const element of entity.elements) {
+			// Use merged annotation if available, otherwise use element's own annotation
+			const annotations = mergedAnnotations?.elementAnnotations?.[element.name] ?? element['@changelog'];
+			if (!annotations || element._foreignKey4) continue; // REVISIT: skip foreign keys
+			const attrKey = labelBundle.key4(element);
+			if (attrKey && attrKey !== element.name) {
+				for (const [locale, localeTranslations] of Object.entries(allLabels)) {
+					if (!locale) continue;
+					const text = localeTranslations[attrKey] || attrKey;
+					addRow(element.name, locale, text);
 				}
-				if (element.isAssociation) labelI18nKey = _getLabelI18nKeyOnEntity(element.target);
 			}
-			change.attribute = labelI18nKey || change.attribute;
-		} catch (e) {
-			LOG.error('Failed to localize change attribute', e);
-			throw new Error('Failed to localize change attribute', e);
 		}
 	}
-};
-
-const _getLabelI18nKeyOnEntity = function (entityName, /** optinal */ attribute) {
-	const model = cds.context?.model ?? cds.model;
-	let def = model.definitions[entityName];
-	if (attribute) def = def?.elements[attribute];
-	if (!def) return '';
-	const i18nKey = getTranslationKey(def['@Common.Label'] || def['@title'] || def['@UI.HeaderInfo.TypeName']);
-	return cds.i18n.labels.for(i18nKey) || i18nKey;
-};
 
-const parseTime = (time, locale, options) => {
-	const timeParts = time.split(':');
-	const date = new Date();
-	date.setHours(parseInt(timeParts[0], 10), parseInt(timeParts[1], 10), parseInt(timeParts[2], 10));
-	return date.toLocaleTimeString(locale, options);
-};
+	// Modification labels (create, update, delete)
+	const MODIF_I18N_MAP = {
+		create: 'Changes.modification.create',
+		update: 'Changes.modification.update',
+		delete: 'Changes.modification.delete'
+	};
 
-const _localizeValue = (change, locale) => {
-	if (change.valueDataType !== 'cds.Date' && change.valueDataType !== 'cds.DateTime' && change.valueDataType !== 'cds.Timestamp' && change.valueDataType !== 'cds.Time') {
-		return;
+	for (const [locale, localeTranslations] of Object.entries(modificationLabels)) {
+		if (!locale) continue;
+		for (const [key, i18nKey] of Object.entries(MODIF_I18N_MAP)) {
+			const text = localeTranslations[i18nKey] || key;
+			addRow(key, locale, text);
+		}
 	}
-	const normalizedLocale = locale.replaceAll('_', '-');
-	const options = formatOptions[change.valueDataType]?.[normalizedLocale] ?? formatOptions[change.valueDataType]?.['en'];
 
-	if (change.valueDataType === 'cds.Time') {
-		if (change.valueChangedFrom) change.valueChangedFrom = parseTime(change.valueChangedFrom, normalizedLocale, options);
-		if (change.valueChangedTo) change.valueChangedTo = parseTime(change.valueChangedTo, normalizedLocale, options);
-	} else {
-		const formatter = change.valueDataType === 'cds.Date' ? 'toLocaleDateString' : 'toLocaleString';
-		if (change.valueChangedFrom) change.valueChangedFrom = new Date(change.valueChangedFrom)[formatter](normalizedLocale, options);
-		if (change.valueChangedTo) change.valueChangedTo = new Date(change.valueChangedTo)[formatter](normalizedLocale, options);
-	}
-};
+	return Array.from(rows.values());
+}
 
-const localizeLogFields = function (data, locale) {
-	if (!locale) return;
-	for (const change of data) {
-		_localizeModification(change);
-		_localizeAttribute(change);
-		_localizeEntityType(change);
-		_localizeDefaultObjectID(change);
-		_localizeValue(change, locale);
-	}
-};
 module.exports = {
-	localizeLogFields
+	getLabelTranslations
 };