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

package/lib/utils/entity-collector.js

@@ -0,0 +1,297 @@
+const cds = require('@sap/cds');
+const LOG = cds.log('change-tracking');
+const DEBUG = cds.debug('change-tracking');
+
+function isChangeTracked(entity) {
+	if (entity['@changelog'] === false) return false;
+	if (entity['@changelog']) return true;
+	return Object.values(entity.elements).some((e) => e['@changelog']);
+}
+
+// Compares two @changelog annotation values for equality
+function _annotationsEqual(a, b) {
+	// Handle null/undefined/false cases
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+	// Deep equality via structuredClone + comparison (order-safe)
+	return JSON.stringify(structuredClone(a)) === JSON.stringify(structuredClone(b));
+}
+
+// Maps service element name to DB element name (handles renaming in projections)
+function _getDbElementName(serviceEntity, elementName) {
+	const columns = (serviceEntity.projection ?? serviceEntity.query?.SELECT)?.columns;
+	if (!columns) return elementName;
+
+	for (const col of columns) {
+		// Check for a renamed column: { ref: ['title'], as: 'adminTitle' }
+		if (typeof col === 'object' && col.as === elementName && col.ref?.length > 0) {
+			return col.ref[0];
+		}
+	}
+	return elementName;
+}
+
+function _mergeChangelogAnnotations(dbEntity, serviceEntities) {
+	// Track merged annotations for conflict detection
+	let mergedEntityAnnotation = dbEntity['@changelog'];
+	let mergedEntityAnnotationSource = mergedEntityAnnotation ? dbEntity.name : null;
+	const mergedElementAnnotations = new Map(); // Map<dbElementName, { annotation, sourceName }>
+
+	// Initialize with DB entity element annotations
+	for (const element of dbEntity.elements) {
+		if (element['@changelog'] !== undefined) {
+			mergedElementAnnotations.set(element.name, {
+				annotation: element['@changelog'],
+				sourceName: dbEntity.name
+			});
+		}
+	}
+
+	// Merge annotations from each service entity
+	for (const { entity: srvEntity, entityAnnotation, elementAnnotations } of serviceEntities) {
+		// Merge entity-level @changelog (ObjectID definition)
+		if (entityAnnotation !== undefined) {
+			if (mergedEntityAnnotation !== undefined && !_annotationsEqual(mergedEntityAnnotation, entityAnnotation)) {
+				throw new Error(
+					`Conflicting @changelog annotations on entity '${dbEntity.name}': ` + `'${mergedEntityAnnotationSource}' has ${JSON.stringify(mergedEntityAnnotation)} but ` + `'${srvEntity.name}' has ${JSON.stringify(entityAnnotation)}`
+				);
+			}
+			if (mergedEntityAnnotation === undefined) {
+				mergedEntityAnnotation = entityAnnotation;
+				mergedEntityAnnotationSource = srvEntity.name;
+			}
+		}
+
+		// Merge element-level @changelog annotations
+		for (const [srvElemName, annotation] of Object.entries(elementAnnotations)) {
+			// Map service element name to DB element name (handles renaming)
+			const dbElemName = _getDbElementName(srvEntity, srvElemName);
+
+			// Skip if annotation is false/null (explicit opt-out)
+			if (annotation === false || annotation === null) continue;
+
+			const existing = mergedElementAnnotations.get(dbElemName);
+			if (existing && !_annotationsEqual(existing.annotation, annotation)) {
+				throw new Error(
+					`Conflicting @changelog annotations on element '${dbElemName}' of entity '${dbEntity.name}': ` + `'${existing.sourceName}' has ${JSON.stringify(existing.annotation)} but ` + `'${srvEntity.name}' has ${JSON.stringify(annotation)}`
+				);
+			}
+			if (!existing) {
+				mergedElementAnnotations.set(dbElemName, {
+					annotation,
+					sourceName: srvEntity.name
+				});
+			}
+		}
+	}
+
+	// Convert Map to plain object for elementAnnotations
+	const elementAnnotationsObj = {};
+	for (const [elemName, { annotation }] of mergedElementAnnotations) {
+		elementAnnotationsObj[elemName] = annotation;
+	}
+
+	return {
+		entityAnnotation: mergedEntityAnnotation,
+		elementAnnotations: elementAnnotationsObj
+	};
+}
+
+function getEntitiesForTriggerGeneration(model, collected) {
+	const result = [];
+	const processedDbEntities = new Set();
+
+	// Process collected service entities - resolve entities and annotations from names
+	for (const [dbEntityName, serviceEntityNames] of collected) {
+		processedDbEntities.add(dbEntityName);
+		const dbEntity = model[dbEntityName];
+		if (!dbEntity) {
+			DEBUG?.(`DB entity ${dbEntityName} not found in model, skipping`);
+			continue;
+		}
+
+		// Resolve service entities and extract their annotations
+		const serviceEntities = [];
+		for (const name of serviceEntityNames) {
+			const serviceEntity = model[name];
+			if (!serviceEntity) {
+				DEBUG?.(`Service entity ${name} not found in model, skipping`);
+				continue;
+			}
+
+			// Extract @changelog annotations from the service entity
+			const entityAnnotation = serviceEntity['@changelog'];
+			const elementAnnotations = {};
+			for (const element of serviceEntity.elements) {
+				if (element['@changelog'] !== undefined) {
+					elementAnnotations[element.name] = element['@changelog'];
+				}
+			}
+
+			serviceEntities.push({
+				entity: serviceEntity,
+				entityAnnotation,
+				elementAnnotations
+			});
+		}
+
+		try {
+			const mergedAnnotations = _mergeChangelogAnnotations(dbEntity, serviceEntities);
+			result.push({ dbEntityName, mergedAnnotations });
+			DEBUG?.(`Merged annotations for ${dbEntityName} from ${serviceEntities.length} service entities`);
+		} catch (error) {
+			LOG.error(error.message);
+			throw error;
+		}
+	}
+
+	// Add table entities that have @changelog but weren't collected
+	for (const def of model) {
+		const isTableEntity = def.kind === 'entity' && !def.query && !def.projection;
+		if (!isTableEntity || processedDbEntities.has(def.name)) continue;
+
+		if (isChangeTracked(def)) {
+			// No service entities collected, use null for mergedAnnotations (use entity's own annotations)
+			result.push({ dbEntityName: def.name, mergedAnnotations: null });
+			processedDbEntities.add(def.name);
+			DEBUG?.(`Including DB entity ${def.name} directly (no service entities collected)`);
+		}
+	}
+
+	// Add composition-of-many target entities that have @changelog on the composition field
+	for (const { dbEntityName, mergedAnnotations } of [...result]) {
+		const dbEntity = model[dbEntityName];
+
+		for (const element of Object.values(dbEntity.elements)) {
+			if (element.type !== 'cds.Composition' || !element.is2many || !element.target) continue;
+
+			const changelogAnnotation = mergedAnnotations?.elementAnnotations?.[element.name] ?? element['@changelog'];
+			if (!changelogAnnotation) continue;
+
+			// Skip if target entity is already processed
+			if (processedDbEntities.has(element.target)) continue;
+
+			const targetEntity = model[element.target];
+			if (!targetEntity) continue;
+
+			// Add target entity with null mergedAnnotations (it uses its own annotations, if any)
+			result.push({ dbEntityName: element.target, mergedAnnotations: null });
+			processedDbEntities.add(element.target);
+			DEBUG?.(`Including composition target ${element.target} for tracked composition ${element.name} on ${dbEntityName}`);
+		}
+	}
+
+	return result;
+}
+
+// Recursively find the base entity of a projection (needed for loaded lifecycle hook)
+function getBaseEntity(entity, model) {
+	const cqn = entity.projection ?? entity.query?.SELECT;
+	if (!cqn) return null;
+
+	const baseRef = cqn.from?.ref?.[0];
+	if (!baseRef || !model) return null;
+
+	const baseEntity = model.definitions[baseRef];
+	if (!baseEntity) return null;
+	const baseCQN = baseEntity.projection ?? baseEntity.query?.SELECT ?? baseEntity.query?.SET;
+	// If base entity is also a projection, recurse
+	if (baseCQN) {
+		return getBaseEntity(baseEntity, model);
+	} else {
+		return { baseRef, baseEntity };
+	}
+}
+
+// Analyze composition hierarchy in CSN
+function analyzeCompositions(csn) {
+	// First pass: build child -> { parent, compositionField } map
+	const childParentMap = new Map();
+
+	for (const [name, def] of Object.entries(csn.definitions)) {
+		if (def.kind !== 'entity') continue;
+
+		if (def.elements) {
+			for (const [elemName, element] of Object.entries(def.elements)) {
+				if (element.type === 'cds.Composition' && element.target) {
+					childParentMap.set(element.target, {
+						parent: name,
+						compositionField: elemName
+					});
+				}
+			}
+		}
+	}
+
+	// Second pass: build hierarchy with grandparent info
+	const hierarchy = new Map();
+	for (const [childName, parentInfo] of childParentMap) {
+		const { parent: parentName, compositionField } = parentInfo;
+
+		// Check if the parent itself has a parent (grandparent)
+		const grandParentInfo = childParentMap.get(parentName);
+
+		hierarchy.set(childName, {
+			parent: parentName,
+			compositionField,
+			grandParent: grandParentInfo?.parent ?? null,
+			grandParentCompositionField: grandParentInfo?.compositionField ?? null
+		});
+	}
+
+	return hierarchy;
+}
+
+function getService(name, model) {
+	const nameSegments = name.split('.');
+	let service;
+	let serviceName = '';
+
+	// Goining in reverse to ensure that in scenarios where one service includes another service name
+	// in its namespace the correct service is chosen
+	while (!service && nameSegments.length) {
+		nameSegments.pop();
+		serviceName = nameSegments.join('.');
+		service = model.definitions[serviceName];
+		if (service?.kind !== 'service') {
+			service = null;
+		}
+	}
+	if (!service) {
+		serviceName = '';
+	}
+	return serviceName;
+}
+
+/**
+ * REVISIT!
+ * Collect change-tracked service entities from a model, grouped by their underlying DB entity
+ */
+function collectEntities(model) {
+	const collectedEntities = new Map();
+	const hierarchyMap = analyzeCompositions(model);
+
+	for (const name in model.definitions) {
+		const entity = model.definitions[name];
+		const isServiceEntity = entity.kind === 'entity' && !!(entity.query || entity.projection);
+		if (isServiceEntity && isChangeTracked(entity)) {
+			const baseInfo = getBaseEntity(entity, model);
+			if (!baseInfo) continue;
+			const { baseRef: dbEntityName } = baseInfo;
+
+			if (!collectedEntities.has(dbEntityName)) collectedEntities.set(dbEntityName, []);
+			collectedEntities.get(dbEntityName).push(name);
+		}
+	}
+
+	return { collectedEntities, hierarchyMap };
+}
+
+module.exports = {
+	isChangeTracked,
+	getEntitiesForTriggerGeneration,
+	getBaseEntity,
+	analyzeCompositions,
+	getService,
+	collectEntities
+};

package/lib/utils/session-variables.js

@@ -0,0 +1,276 @@
+const cds = require('@sap/cds');
+const DEBUG = cds.debug('change-tracking');
+
+const { isChangeTracked } = require('./entity-collector.js');
+
+// Session context variable names for skipping change tracking
+// Using 'ct.' prefix for all session variables to be PostgreSQL compatible
+const CT_SKIP_VAR = 'ct.skip';
+const CT_SKIP_ENTITY_PREFIX = 'ct.skip_entity.';
+const CT_SKIP_ELEMENT_PREFIX = 'ct.skip_element.';
+
+function _resolveView(entity) {
+	const model = cds.context?.model ?? cds.model;
+	const baseRef = entity.query?._target;
+	if (!baseRef || !model) return null;
+
+	const baseEntity = model.definitions[baseRef.name];
+	if (!baseEntity) return null;
+
+	// If base entity is also a projection, recurse
+	if (baseEntity.query?._target) {
+		return _resolveView(baseEntity);
+	}
+
+	return baseEntity;
+}
+
+function getEntitySkipVarName(entityName) {
+	return `${CT_SKIP_ENTITY_PREFIX}${entityName.replace(/\./g, '_')}`;
+}
+
+function getElementSkipVarName(entityName, elementName) {
+	return `${CT_SKIP_ELEMENT_PREFIX}${entityName.replace(/\./g, '_')}.${elementName.replace(/\./g, '_')}`;
+}
+
+function _findServiceEntity(service, dbEntity) {
+	if (!service || !dbEntity) return null;
+	for (const def of service.entities) {
+		const projectionTarget = _resolveView(def)?.name;
+		if (projectionTarget === dbEntity.name) return def;
+	}
+	return null;
+}
+
+function _collectDeepEntities(entity, data, service, toSkip) {
+	if (!entity.compositions) return;
+	for (const comp of entity.compositions) {
+		const compData = data[comp.name];
+		if (compData === undefined) continue;
+
+		const targetEntity = comp._target || (cds.context?.model ?? cds.model).definitions[comp.target];
+		if (!targetEntity) continue;
+
+		// Check annotations of target entity (on service level)
+		const serviceEntity = _findServiceEntity(service, targetEntity);
+		if (serviceEntity && (serviceEntity['@changelog'] === false || serviceEntity['@changelog'] === null)) {
+			toSkip.add(targetEntity.name);
+		}
+
+		// Recurse for nested compositions
+		_collectDeepEntities(targetEntity, compData, service, toSkip);
+	}
+}
+
+function _collectSkipEntities(rootTarget, query, service) {
+	const toSkip = new Set();
+	const dbEntity = _resolveView(rootTarget);
+
+	// Check root entity annotation
+	if (rootTarget['@changelog'] === false || rootTarget['@changelog'] === null) {
+		toSkip.add(dbEntity.name);
+	}
+
+	// For deep operations, extract data from query and traverse compositions
+	const data = query?.INSERT?.entries || query?.UPDATE?.data || query?.UPDATE?.with;
+	if (!data || !dbEntity?.compositions) return toSkip;
+
+	// Filter all compositions inside data and map on composition target
+	const dataArray = Array.isArray(data) ? data : [data];
+	for (const row of dataArray) {
+		_collectDeepEntities(dbEntity, row, service, toSkip);
+	}
+
+	return Array.from(toSkip);
+}
+
+// Maps service element name to corresponding column name (considers renaming in projections)
+function _getDbElementName(serviceEntity, elementName) {
+	const columns = (serviceEntity.projection ?? serviceEntity.query?.SELECT)?.columns;
+	if (!columns) return elementName;
+
+	for (const col of columns) {
+		// Check for a renamed column: { ref: ['title'], as: 'adminTitle' }
+		if (typeof col === 'object' && col.as === elementName && col.ref?.length > 0) {
+			return col.ref[0];
+		}
+	}
+
+	return elementName;
+}
+
+function _collectSkipElements(serviceEntity, query, service) {
+	const toSkip = [];
+	if (!serviceEntity?.elements) return toSkip;
+
+	const dbEntity = _resolveView(serviceEntity);
+	if (!dbEntity) return toSkip;
+
+	for (const [elementName, element] of Object.entries(serviceEntity.elements)) {
+		if (element['@changelog'] === false || element['@changelog'] === null) {
+			// Get the actual column name (handles renaming in projections)
+			const dbElementName = _getDbElementName(serviceEntity, elementName);
+
+			toSkip.push({
+				dbEntityName: dbEntity.name,
+				dbElementName: dbElementName
+			});
+
+			DEBUG?.(`Found element to skip: ${dbEntity.name}.${dbElementName} (service element: ${elementName})`);
+		}
+	}
+
+	// Handle nested compositions for deep skip elements
+	const data = query?.INSERT?.entries || query?.UPDATE?.data || query?.UPDATE?.with;
+	if (!data || !dbEntity?.compositions) return toSkip;
+
+	// Filter all compositions inside data and map on composition target
+	const dataArray = Array.isArray(data) ? data : [data];
+	for (const row of dataArray) {
+		_collectDeepSkipElements(dbEntity, row, service, toSkip);
+	}
+
+	return toSkip;
+}
+
+function _collectDeepSkipElements(entity, data, service, toSkip) {
+	if (!entity.compositions) return;
+
+	for (const comp of entity.compositions) {
+		const compData = data[comp.name];
+		if (compData === undefined) continue;
+
+		const targetEntity = comp._target || (cds.context?.model ?? cds.model).definitions[comp.target];
+		if (!targetEntity) continue;
+
+		// Find the service entity for this composition target
+		const serviceEntity = _findServiceEntity(service, targetEntity);
+		if (serviceEntity) {
+			// Collect skip elements from this service entity
+			const skipElements = _collectSkipElements(serviceEntity);
+			for (const el of skipElements) {
+				toSkip.push(el);
+			}
+		}
+
+		// Recurse for nested compositions
+		const compDataArray = Array.isArray(compData) ? compData : [compData];
+		for (const row of compDataArray) {
+			_collectDeepSkipElements(targetEntity, row, service, toSkip);
+		}
+	}
+}
+
+/**
+ * Sets session variables to skip change tracking for a service/entities/elements.
+ * Called in the before handler for INSERT/UPDATE/DELETE.
+ */
+function setSkipSessionVariables(req, srv, collectedEntities) {
+	// Check if this service entity should be skipped automatically
+	const srvEntityIsChangeTracked = isChangeTracked(req.target);
+	if (!srvEntityIsChangeTracked && _shouldSkipServiceEntity(req.target, collectedEntities)) {
+		req._ctAutoSkipEntity = _setAutoSkipForServiceEntity(req);
+		return;
+	}
+	// Only proceed with explicit skip handling if service entity is change-tracked
+	if (!srvEntityIsChangeTracked) return;
+
+	// Check if request is for a service to skip
+	if (srv['@changelog'] === false || srv['@changelog'] === null) {
+		DEBUG?.(`Set skip session variable for service ${srv.name} to true!`);
+		req._tx.set({ [CT_SKIP_VAR]: 'true' });
+		req._ctSkipWasSet = true;
+	}
+
+	const entitiesToSkip = _collectSkipEntities(req.target, req.query, srv);
+	if (entitiesToSkip.length > 0) {
+		const skipVars = {};
+		for (const name of entitiesToSkip) {
+			const varName = getEntitySkipVarName(name);
+			skipVars[varName] = 'true';
+			DEBUG?.(`Set skip session variable for entity ${name} to true!`);
+		}
+		req._tx.set(skipVars);
+		req._ctSkipEntities = entitiesToSkip;
+	}
+
+	// Collect elements to skip from the root service entity
+	const elementsToSkip = _collectSkipElements(req.target, req.query, srv);
+	if (elementsToSkip.length > 0) {
+		const skipVars = {};
+		for (const { dbEntityName, dbElementName } of elementsToSkip) {
+			const varName = getElementSkipVarName(dbEntityName, dbElementName);
+			skipVars[varName] = 'true';
+			DEBUG?.(`Set skip session variable for element ${dbEntityName}.${dbElementName} to true!`);
+		}
+		req._tx.set(skipVars);
+		req._ctSkipElements = elementsToSkip;
+	}
+}
+
+/**
+ * Resets session variables after change tracking operations.
+ * Called in the after handler for INSERT/UPDATE/DELETE.
+ */
+function resetSkipSessionVariables(req) {
+	if (req._ctSkipWasSet) {
+		req._tx.set({ [CT_SKIP_VAR]: 'false' });
+		delete req._ctSkipWasSet;
+	}
+
+	if (req._ctSkipEntities) {
+		const resetVars = {};
+		for (const name of req._ctSkipEntities) {
+			resetVars[getEntitySkipVarName(name)] = 'false';
+		}
+		req._tx.set(resetVars);
+		delete req._ctSkipEntities;
+	}
+
+	if (req._ctSkipElements) {
+		const resetVars = {};
+		for (const { dbEntityName, dbElementName } of req._ctSkipElements) {
+			resetVars[getElementSkipVarName(dbEntityName, dbElementName)] = 'false';
+		}
+		req._tx.set(resetVars);
+		delete req._ctSkipElements;
+	}
+}
+
+// --- Auto-skip for non-opted-in service entities ---
+function _shouldSkipServiceEntity(serviceEntity, collectedEntities) {
+	const dbEntityName = _resolveView(serviceEntity)?.name;
+	if (!dbEntityName) return false;
+
+	const srvEntities = collectedEntities.get(dbEntityName);
+	if (!srvEntities) return false; // No triggers for this DB entity, nothing to skip
+
+	// If this service entity is NOT collected (didn't opt-in), skip it
+	return !srvEntities.includes(serviceEntity.name);
+}
+
+function _setAutoSkipForServiceEntity(req) {
+	const dbEntity = _resolveView(req.target);
+	if (!dbEntity) return null;
+
+	const varName = getEntitySkipVarName(dbEntity.name);
+	DEBUG?.(`Auto-skip: Service entity ${req.target.name} didn't opt-in, skipping DB entity ${dbEntity.name}`);
+	req._tx.set({ [varName]: 'true' });
+	return dbEntity.name;
+}
+
+function resetAutoSkipForServiceEntity(req, autoSkipEntityName) {
+	if (!autoSkipEntityName) return;
+	req._tx.set({ [getEntitySkipVarName(autoSkipEntityName)]: 'false' });
+}
+
+// Export what's needed by trigger modules and cds-plugin.js
+module.exports = {
+	CT_SKIP_VAR,
+	getEntitySkipVarName,
+	getElementSkipVarName,
+	setSkipSessionVariables,
+	resetSkipSessionVariables,
+	// Auto-skip functions for service entity handling
+	resetAutoSkipForServiceEntity
+};

package/lib/utils/trigger-utils.js

@@ -0,0 +1,94 @@
+const cds = require('@sap/cds');
+const LOG = cds.log('change-tracking');
+
+const { fs } = cds.utils;
+
+const { getEntitiesForTriggerGeneration, analyzeCompositions, collectEntities } = require('./entity-collector.js');
+const { getLabelTranslations } = require('../localization.js');
+
+/**
+ * Prepare CSN for trigger generation by cloning, compiling for Node.js,
+ * and analyzing compositions.
+ */
+function prepareCSNForTriggers(csn, preserveSources = false) {
+	const clonedCSN = structuredClone(csn);
+	if (preserveSources) clonedCSN.$sources = csn.$sources;
+	const runtimeCSN = cds.compile.for.nodejs(clonedCSN);
+	if (preserveSources) runtimeCSN.$sources = csn.$sources;
+	const { collectedEntities } = collectEntities(runtimeCSN);
+	const hierarchy = analyzeCompositions(runtimeCSN);
+	const entities = getEntitiesForTriggerGeneration(runtimeCSN.definitions, collectedEntities);
+	return { runtimeCSN, hierarchy, entities };
+}
+
+/**
+ * Generate triggers for all collected entities using the provided generator function.
+ */
+function generateTriggersForEntities(runtimeCSN, hierarchy, entities, generator) {
+	const triggers = [];
+	for (const { dbEntityName, mergedAnnotations } of entities) {
+		const entity = runtimeCSN.definitions[dbEntityName];
+		if (!entity) continue;
+
+		const hierarchyInfo = hierarchy.get(dbEntityName);
+		const rootEntityName = hierarchyInfo?.parent ?? null;
+		const rootEntity = rootEntityName ? runtimeCSN.definitions[rootEntityName] : null;
+		const rootMergedAnnotations = rootEntityName ? entities.find((d) => d.dbEntityName === rootEntityName)?.mergedAnnotations : null;
+
+		// Get grandparent info for deep linking
+		const grandParentEntityName = hierarchyInfo?.grandParent ?? null;
+		const grandParentEntity = grandParentEntityName ? runtimeCSN.definitions[grandParentEntityName] : null;
+		const grandParentMergedAnnotations = grandParentEntityName ? entities.find((d) => d.dbEntityName === grandParentEntityName)?.mergedAnnotations : null;
+		const grandParentCompositionField = hierarchyInfo?.grandParentCompositionField ?? null;
+
+		const result = generator(runtimeCSN, entity, rootEntity, mergedAnnotations, rootMergedAnnotations, {
+			grandParentEntity,
+			grandParentMergedAnnotations,
+			grandParentCompositionField
+		});
+		if (result) triggers.push(...(Array.isArray(result) ? result : [result]));
+	}
+	return triggers;
+}
+
+/**
+ * Write i18n labels CSV file for H2/HDI deployments.
+ */
+function writeLabelsCSV(entities, model) {
+	const labels = getLabelTranslations(entities, model);
+	const header = 'ID;locale;text';
+	const rows = labels.map((row) => `${row.ID};${row.locale};${row.text}`);
+	const content = [header, ...rows].join('\n') + '\n';
+	const dir = 'db/src/gen/data/';
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+	fs.writeFileSync(`${dir}/sap.changelog-i18nKeys.csv`, content);
+}
+
+/**
+ * Ensures the undeploy.json file contains the hdbtrigger pattern.
+ */
+function ensureUndeployJsonHasTriggerPattern() {
+	const undeployPath = 'db/undeploy.json';
+	const triggerPattern = 'src/gen/**/*.hdbtrigger';
+
+	let undeploy = [];
+	if (fs.existsSync(undeployPath)) {
+		undeploy = JSON.parse(fs.readFileSync(undeployPath, 'utf8'));
+	}
+	if (!Array.isArray(undeploy)) return;
+
+	if (!undeploy.includes(triggerPattern)) {
+		undeploy.push(triggerPattern);
+		fs.writeFileSync(undeployPath, JSON.stringify(undeploy, null, 4) + '\n');
+		LOG.info(`Added '${triggerPattern}' to ${undeployPath}`);
+	}
+}
+
+module.exports = {
+	prepareCSNForTriggers,
+	generateTriggersForEntities,
+	writeLabelsCSV,
+	ensureUndeployJsonHasTriggerPattern
+};