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

package/lib/postgres/sql-expressions.js

@@ -0,0 +1,261 @@
+const cds = require('@sap/cds');
+const utils = require('../utils/change-tracking.js');
+const config = cds.env.requires['change-tracking'];
+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');
+
+const _cqn2sqlCache = new WeakMap();
+
+function toSQL(query, model) {
+	let cqn2sql = _cqn2sqlCache.get(model);
+	if (!cqn2sql) {
+		const Service = require('@cap-js/postgres');
+		const TriggerCQN2SQL = createTriggerCQN2SQL(Service.CQN2SQL);
+		cqn2sql = new TriggerCQN2SQL({ model });
+		_cqn2sqlCache.set(model, cqn2sql);
+	}
+	const sqlCQN = cqn4sql(query, model);
+	return cqn2sql.SELECT(sqlCQN);
+}
+
+function getSkipCheckCondition(entityName) {
+	const entitySkipVar = getEntitySkipVarName(entityName);
+	return `(COALESCE(current_setting('${CT_SKIP_VAR}', true), 'false') != 'true' AND COALESCE(current_setting('${entitySkipVar}', true), 'false') != 'true')`;
+}
+
+function getElementSkipCondition(entityName, elementName) {
+	const varName = getElementSkipVarName(entityName, elementName);
+	return `COALESCE(current_setting('${varName}', true), 'false') != 'true'`;
+}
+
+/**
+ * Truncates large strings: CASE WHEN LENGTH(val) > 5000 THEN LEFT(val, 4997) || '...' ELSE val END
+ */
+function wrapLargeString(val) {
+	return `CASE WHEN LENGTH(${val}) > 5000 THEN LEFT(${val}, 4997) || '...' ELSE ${val} END`;
+}
+
+function compositeKeyExpr(parts) {
+	if (parts.length <= 1) return `${parts[0]}::TEXT`;
+	return parts.map((p) => `LENGTH(${p}::TEXT) || ',' || ${p}::TEXT`).join(" || ';' || ");
+}
+
+/**
+ * Returns SQL expression for a column's raw value
+ */
+function getValueExpr(col, refRow) {
+	if (col.type === 'cds.Boolean') {
+		return `CASE WHEN ${refRow}.${col.name} IS TRUE THEN 'true' WHEN ${refRow}.${col.name} IS FALSE THEN 'false' ELSE NULL END`;
+	}
+	if (col.target && col.foreignKeys) {
+		if (col.foreignKeys.length > 1) {
+			return col.foreignKeys.map((fk) => `${refRow}.${col.name}_${fk}::TEXT`).join(" || ' ' || ");
+		}
+		return `${refRow}.${col.name}_${col.foreignKeys[0]}::TEXT`;
+	}
+	if (col.target && col.on) {
+		return col.on.map((m) => `${refRow}.${m.foreignKeyField}::TEXT`).join(" || ' ' || ");
+	}
+	// Apply truncation for String and LargeString types
+	if (col.type === 'cds.String' || col.type === 'cds.LargeString') {
+		return wrapLargeString(`${refRow}.${col.name}::TEXT`);
+	}
+	return `${refRow}.${col.name}::TEXT`;
+}
+
+/**
+ * Returns SQL WHERE condition for detecting column changes
+ */
+function getWhereCondition(col, modification) {
+	if (modification === 'update') {
+		const checkCols = col.foreignKeys ? col.foreignKeys.map((fk) => `${col.name}_${fk}`) : col.on ? col.on.map((m) => m.foreignKeyField) : [col.name];
+		return checkCols.map((c) => `NEW.${c} IS DISTINCT FROM OLD.${c}`).join(' OR ');
+	}
+	// CREATE or DELETE: check value is not null
+	const rowRef = modification === 'create' ? 'NEW' : 'OLD';
+	if (col.foreignKeys) {
+		return col.foreignKeys.map((fk) => `${rowRef}.${col.name}_${fk} IS NOT NULL`).join(' OR ');
+	}
+	if (col.on) {
+		return col.on.map((m) => `${rowRef}.${m.foreignKeyField} IS NOT NULL`).join(' OR ');
+	}
+	return `${rowRef}.${col.name} IS NOT NULL`;
+}
+
+/**
+ * Builds scalar subselect for association label lookup with locale support
+ */
+function buildAssocLookup(column, refRow, model) {
+	let where = {};
+	if (column.foreignKeys) {
+		where = column.foreignKeys.reduce((acc, k) => {
+			acc[k] = { val: `${refRow}.${column.name}_${k}` };
+			return acc;
+		}, {});
+	} else if (column.on) {
+		where = column.on.reduce((acc, mapping) => {
+			acc[mapping.targetKey] = { val: `${refRow}.${mapping.foreignKeyField}` };
+			return acc;
+		}, {});
+	}
+
+	const alt = column.alt.map((s) => s.split('.').slice(1).join('.'));
+	const columns = alt.length === 1 ? alt[0] : utils.buildConcatXpr(alt);
+
+	// Check for localization
+	const localizedInfo = utils.getLocalizedLookupInfo(column.target, column.alt, model);
+	if (localizedInfo) {
+		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, model)}), (${toSQL(baseQuery, model)})))`;
+	}
+
+	const query = SELECT.one.from(column.target).columns(columns).where(where);
+	return `(${toSQL(query, model)})`;
+}
+
+/**
+ * Returns SQL expression for a column's label (looked-up value for associations)
+ */
+function getLabelExpr(col, refRow, model) {
+	if (col.target && col.alt) {
+		return buildAssocLookup(col, refRow, model);
+	}
+	return 'NULL';
+}
+
+/**
+ * Builds PL/pgSQL statement for objectID assignment
+ */
+function buildObjectIDAssignment(objectIDs, entity, keys, recVar, targetVar, model) {
+	if (!objectIDs || objectIDs.length === 0) {
+		return `${targetVar} := entity_key;`;
+	}
+
+	const parts = [];
+	for (const oid of objectIDs) {
+		if (oid.included) {
+			parts.push(`${recVar}.${oid.name}::TEXT`);
+		} 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, model)})::TEXT, '')`);
+		}
+	}
+
+	return `
+    SELECT CONCAT_WS(', ', ${parts.join(', ')}) INTO ${targetVar};
+    IF ${targetVar} = '' OR ${targetVar} IS NULL THEN
+        ${targetVar} := entity_key;
+    END IF;
+    `;
+}
+
+function buildColumnSubquery(col, modification, entity, model) {
+	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') {
+		fullWhere += ` AND NOT EXISTS (
+			SELECT 1 FROM sap_changelog_changes
+			WHERE entity = '${entity.name}'
+			AND entitykey = entity_key
+			AND attribute = '${col.name}'
+			AND valuedatatype = 'cds.Composition'
+			AND transactionid = transaction_id
+		)`;
+	}
+
+	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 WHERE ${fullWhere}`;
+}
+
+/**
+ * Generates INSERT SQL for changelog entries from UNION query
+ */
+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
+            (ID, PARENT_ID, ATTRIBUTE, VALUECHANGEDFROM, VALUECHANGEDTO, VALUECHANGEDFROMLABEL, VALUECHANGEDTOLABEL, ENTITY, ENTITYKEY, OBJECTID, CREATEDAT, CREATEDBY, VALUEDATATYPE, MODIFICATION, TRANSACTIONID)
+            SELECT
+                gen_random_uuid(),
+                ${parentIdValue},
+                attribute,
+                valueChangedFrom,
+                valueChangedTo,
+                valueChangedFromLabel,
+                valueChangedToLabel,
+                entity_name,
+                entity_key,
+                object_id,
+                now(),
+                user_id,
+                valueDataType,
+                '${modification}',
+                transaction_id
+            FROM (
+            ${unionQuery}
+            ) AS changes;`;
+}
+
+/**
+ * Generates INSERT block for a modification type (with config check)
+ */
+function buildInsertBlock(columns, modification, entity, model, hasCompositionParent = false) {
+	if (!config || (modification === 'create' && config.disableCreateTracking) || (modification === 'update' && config.disableUpdateTracking) || (modification === 'delete' && config.disableDeleteTracking)) {
+		return '';
+	}
+
+	if (modification === 'delete' && !config?.preserveDeletes) {
+		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, model, hasCompositionParent)}`;
+	}
+
+	return buildChangelogInsertSQL(columns, modification, entity, model, hasCompositionParent);
+}
+
+/**
+ * Extracts database column names from tracked columns (for UPDATE OF clause)
+ */
+function extractTrackedDbColumns(columns) {
+	const dbCols = [];
+	for (const col of columns) {
+		if (col.foreignKeys && col.foreignKeys.length > 0) {
+			col.foreignKeys.forEach((fk) => dbCols.push(`${col.name}_${fk}`.toLowerCase()));
+		} else if (col.on && col.on.length > 0) {
+			col.on.forEach((m) => dbCols.push(m.foreignKeyField.toLowerCase()));
+		} else {
+			dbCols.push(col.name.toLowerCase());
+		}
+	}
+	return [...new Set(dbCols)];
+}
+
+module.exports = {
+	toSQL,
+	getSkipCheckCondition,
+	getElementSkipCondition,
+	compositeKeyExpr,
+	getValueExpr,
+	getWhereCondition,
+	getLabelExpr,
+	buildObjectIDAssignment,
+	buildInsertBlock,
+	extractTrackedDbColumns
+};

package/lib/postgres/triggers.js

@@ -0,0 +1,113 @@
+const utils = require('../utils/change-tracking.js');
+const { getCompositionParentInfo, getGrandParentCompositionInfo } = require('../utils/composition-helpers.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, 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', model);
+
+	const hasCompositionParent = compositionParentInfo !== null;
+	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', model, grandParentCompositionInfo) : '';
+	const updateParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'update', model, grandParentCompositionInfo) : '';
+	const deleteParentBlock = compositionParentInfo ? buildCompositionParentBlock(compositionParentInfo, rootObjectIDs, 'delete', model, grandParentCompositionInfo) : '';
+
+	return `
+        DECLARE
+            rec RECORD;
+        BEGIN
+            IF NOT ${getSkipCheckCondition(entity.name)} THEN
+                RETURN NULL;
+            END IF;
+
+            IF (TG_OP = 'DELETE') THEN
+                rec := OLD;
+            ELSE
+                rec := NEW;
+            END IF;
+
+            entity_key := ${entityKeyExpr};
+            ${objectIDAssignment}
+
+            IF (TG_OP = 'INSERT') THEN
+                ${createParentBlock}
+                ${createBlock}
+            ELSIF (TG_OP = 'UPDATE') THEN
+                ${updateParentBlock}
+                ${updateBlock}
+            ELSIF (TG_OP = 'DELETE') THEN
+                ${deleteParentBlock}
+                ${deleteBlock}
+            END IF;
+        END;`;
+}
+
+function generatePostgresTriggers(csn, entity, rootEntity, 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);
+
+	// Check if this entity is a tracked composition target (composition-of-many)
+	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);
+
+	// Generate triggers if we have tracked columns OR if this is a composition target
+	const shouldGenerateTriggers = trackedColumns.length > 0 || compositionParentInfo;
+	if (!shouldGenerateTriggers) return triggers;
+
+	const tableName = entity.name.replace(/\./g, '_').toLowerCase();
+	const triggerName = `${tableName}_tr_change`;
+	const functionName = `${tableName}_func_change`;
+
+	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;' : '';
+	const parentModificationDecl = compositionParentInfo?.parentKeyBinding?.type === 'compositionOfOne' ? 'comp_parent_modification TEXT;' : '';
+	const grandparentIdDecl = grandParentCompositionInfo ? 'comp_grandparent_id UUID := NULL;' : '';
+
+	const createFunction = `CREATE OR REPLACE FUNCTION ${functionName}() RETURNS TRIGGER AS $$
+    DECLARE
+        entity_name TEXT := '${entity.name}';
+        entity_key TEXT;
+        object_id TEXT;
+        user_id TEXT := coalesce(current_setting('cap.applicationuser', true), 'anonymous');
+        transaction_id BIGINT := txid_current();
+        ${parentIdDecl}
+        ${parentModificationDecl}
+        ${grandparentIdDecl}
+    BEGIN
+        ${funcBody}
+        RETURN NULL;
+    END;
+    $$ LANGUAGE plpgsql;`;
+
+	triggers.push(createFunction);
+
+	const trackedDbColumns = extractTrackedDbColumns(trackedColumns);
+	const updateOfClause = trackedDbColumns.length > 0 ? `UPDATE OF ${trackedDbColumns.join(', ')}` : 'UPDATE';
+	const createTrigger = `CREATE OR REPLACE TRIGGER ${triggerName}
+    AFTER INSERT OR ${updateOfClause} OR DELETE ON "${tableName}"
+    FOR EACH ROW EXECUTE FUNCTION ${functionName}();
+    `;
+
+	triggers.push(createTrigger);
+
+	return triggers;
+}
+
+module.exports = { generatePostgresTriggers };

package/lib/skipHandlers.js

@@ -0,0 +1,34 @@
+const cds = require('@sap/cds');
+
+const { isChangeTracked, collectEntities } = require('./utils/entity-collector.js');
+const { setSkipSessionVariables, resetSkipSessionVariables, resetAutoSkipForServiceEntity } = require('./utils/session-variables.js');
+
+/**
+ * Register db handlers for setting/resetting session variables on INSERT/UPDATE/DELETE.
+ */
+function registerSessionVariableHandlers() {
+	cds.db.before(['INSERT', 'UPDATE', 'DELETE'], async (req) => {
+		const model = cds.context?.model ?? cds.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;
+		setSkipSessionVariables(req, srv, collectedEntities);
+	});
+
+	cds.db.after(['INSERT', 'UPDATE', 'DELETE'], async (_, req) => {
+		if (!req.target || req.target.name.endsWith('.drafts')) return;
+
+		// Reset auto-skip variable if it was set
+		if (req._ctAutoSkipEntity) {
+			resetAutoSkipForServiceEntity(req, req._ctAutoSkipEntity);
+			delete req._ctAutoSkipEntity;
+			return;
+		}
+
+		if (!isChangeTracked(req.target)) return;
+		resetSkipSessionVariables(req);
+	});
+}
+
+module.exports = { registerSessionVariableHandlers };

package/lib/sqlite/composition.js

@@ -0,0 +1,234 @@
+const utils = require('../utils/change-tracking.js');
+const { toSQL, compositeKeyExpr } = require('./sql-expressions.js');
+
+/**
+ * Builds rootObjectID select for composition of many
+ */
+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 rootEntityKeyExpr;
+
+	const where = {};
+	for (let i = 0; i < rootKeys.length; i++) {
+		where[rootKeys[i]] = { val: `${refRow}.${binding[i]}` };
+	}
+
+	// Clone to avoid mutation
+	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, 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, model) {
+	const { parentEntityName, compositionFieldName, parentKeyBinding } = compositionParentInfo;
+	const { compositionName, childKeys } = parentKeyBinding;
+
+	const parentFKFields = childKeys.map((k) => `${compositionName}_${k}`);
+	const parentEntity = model.definitions[parentEntityName];
+	const parentKeys = utils.extractKeys(parentEntity.keys);
+	const parentWhereClause = parentFKFields.map((fk, i) => `${fk} = ${rowRef}.${childKeys[i]}`).join(' AND ');
+
+	// Build the parent key expression via subquery (reverse lookup)
+	const parentKeyExpr = compositeKeyExpr(parentKeys.map((pk) => `(SELECT ${pk} FROM ${utils.transformName(parentEntityName)} WHERE ${parentWhereClause})`));
+
+	// Build rootObjectID expression for the parent entity
+	let rootObjectIDExpr;
+	if (rootObjectIDs?.length > 0) {
+		const oidSelects = rootObjectIDs.map((oid) => `(SELECT ${oid.name} FROM ${utils.transformName(parentEntityName)} WHERE ${parentWhereClause})`);
+		rootObjectIDExpr = oidSelects.length > 1 ? oidSelects.join(" || ', ' || ") : oidSelects[0];
+	} else {
+		rootObjectIDExpr = parentKeyExpr;
+	}
+
+	const modificationExpr = `CASE WHEN EXISTS (
+			SELECT 1 FROM sap_changelog_Changes
+			WHERE entity = '${parentEntityName}'
+			AND entityKey = ${parentKeyExpr}
+			AND modification = 'create'
+			AND createdBy = session_context('$user.id')
+			AND createdAt = session_context('$now')
+		) THEN 'create' ELSE 'update' END`;
+
+	const insertSQL = `INSERT INTO sap_changelog_Changes (ID, parent_ID, attribute, entity, entityKey, objectID, createdAt, createdBy, valueDataType, modification, transactionID)
+		SELECT
+			hex(randomblob(16)),
+			NULL,
+			'${compositionFieldName}',
+			'${parentEntityName}',
+			${parentKeyExpr},
+			${rootObjectIDExpr},
+			session_context('$now'),
+			session_context('$user.id'),
+			'cds.Composition',
+			${modificationExpr},
+			session_context('$now')
+		WHERE EXISTS (
+			SELECT 1 FROM ${utils.transformName(parentEntityName)} WHERE ${parentWhereClause}
+		)
+		AND NOT EXISTS (
+			SELECT 1 FROM sap_changelog_Changes
+			WHERE entity = '${parentEntityName}'
+			AND entityKey = ${parentKeyExpr}
+			AND attribute = '${compositionFieldName}'
+			AND valueDataType = 'cds.Composition'
+			AND createdBy = session_context('$user.id')
+			AND createdAt = session_context('$now')
+		);`;
+
+	// SELECT SQL to get the parent_ID for child entries
+	const parentLookupExpr = `(SELECT ID FROM sap_changelog_Changes
+		WHERE entity = '${parentEntityName}'
+		AND entityKey = ${parentKeyExpr}
+		AND attribute = '${compositionFieldName}'
+		AND valueDataType = 'cds.Composition'
+		AND createdBy = session_context('$user.id')
+		ORDER BY createdAt DESC LIMIT 1)`;
+
+	return { insertSQL, parentEntityName, compositionFieldName, parentKeyExpr, parentLookupExpr };
+}
+
+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, 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, model);
+
+	let insertSQL;
+
+	if (grandParentCompositionInfo) {
+		const { grandParentEntityName, grandParentCompositionFieldName, grandParentKeyBinding } = grandParentCompositionInfo;
+		const parentEntity = model.definitions[parentEntityName];
+		const parentKeys = utils.extractKeys(parentEntity.keys);
+		const parentWhere = parentKeys.map((pk, i) => `${pk} = ${rowRef}.${parentKeyBinding[i]}`).join(' AND ');
+
+		// Build the grandparent key expression from the parent record
+		const grandParentKeyExpr = compositeKeyExpr(grandParentKeyBinding.map((k) => `(SELECT ${k} FROM ${utils.transformName(parentEntityName)} WHERE ${parentWhere})`));
+
+		// Build expression for grandparent lookup (for linking parent entry to it)
+		// Must filter by createdAt to get entry from current transaction
+		const grandParentLookupExpr = `(SELECT ID FROM sap_changelog_Changes
+			WHERE entity = '${grandParentEntityName}'
+			AND entityKey = ${grandParentKeyExpr}
+			AND attribute = '${grandParentCompositionFieldName}'
+			AND valueDataType = 'cds.Composition'
+			AND createdBy = session_context('$user.id')
+			AND createdAt = session_context('$now')
+			ORDER BY createdAt DESC LIMIT 1)`;
+
+		// First insert grandparent entry if not exists
+		const grandParentInsertSQL = `INSERT INTO sap_changelog_Changes (ID, parent_ID, attribute, entity, entityKey, objectID, createdAt, createdBy, valueDataType, modification, transactionID)
+			SELECT
+				hex(randomblob(16)),
+				NULL,
+				'${grandParentCompositionFieldName}',
+				'${grandParentEntityName}',
+				${grandParentKeyExpr},
+				${grandParentKeyExpr},
+				session_context('$now'),
+				session_context('$user.id'),
+				'cds.Composition',
+				'update',
+				session_context('$now')
+			WHERE NOT EXISTS (
+				SELECT 1 FROM sap_changelog_Changes
+				WHERE entity = '${grandParentEntityName}'
+				AND entityKey = ${grandParentKeyExpr}
+				AND attribute = '${grandParentCompositionFieldName}'
+				AND valueDataType = 'cds.Composition'
+				AND createdBy = session_context('$user.id')
+				AND createdAt = session_context('$now')
+			);`;
+
+		// Then insert parent entry linking to grandparent
+		const parentInsertSQL = `INSERT INTO sap_changelog_Changes (ID, parent_ID, attribute, entity, entityKey, objectID, createdAt, createdBy, valueDataType, modification, transactionID)
+			SELECT
+				hex(randomblob(16)),
+				${grandParentLookupExpr},
+				'${compositionFieldName}',
+				'${parentEntityName}',
+				${parentKeyExpr},
+				${rootObjectIDExpr},
+				session_context('$now'),
+				session_context('$user.id'),
+				'cds.Composition',
+				'${modification}',
+				session_context('$now')
+			WHERE NOT EXISTS (
+				SELECT 1 FROM sap_changelog_Changes
+				WHERE entity = '${parentEntityName}'
+				AND entityKey = ${parentKeyExpr}
+				AND attribute = '${compositionFieldName}'
+				AND valueDataType = 'cds.Composition'
+				AND createdBy = session_context('$user.id')
+				AND createdAt = session_context('$now')
+			);`;
+
+		insertSQL = `${grandParentInsertSQL}\n        ${parentInsertSQL}`;
+	} else {
+		const modificationExpr = `CASE WHEN EXISTS (
+				SELECT 1 FROM sap_changelog_Changes
+				WHERE entity = '${parentEntityName}'
+				AND entityKey = ${parentKeyExpr}
+				AND modification = 'create'
+				AND createdBy = session_context('$user.id')
+				AND createdAt = session_context('$now')
+			) THEN 'create' ELSE 'update' END`;
+
+		insertSQL = `INSERT INTO sap_changelog_Changes (ID, parent_ID, attribute, entity, entityKey, objectID, createdAt, createdBy, valueDataType, modification, transactionID)
+			SELECT
+				hex(randomblob(16)),
+				NULL,
+				'${compositionFieldName}',
+				'${parentEntityName}',
+				${parentKeyExpr},
+				${rootObjectIDExpr},
+				session_context('$now'),
+				session_context('$user.id'),
+				'cds.Composition',
+				${modificationExpr},
+				session_context('$now')
+			WHERE NOT EXISTS (
+				SELECT 1 FROM sap_changelog_Changes
+				WHERE entity = '${parentEntityName}'
+				AND entityKey = ${parentKeyExpr}
+				AND attribute = '${compositionFieldName}'
+				AND valueDataType = 'cds.Composition'
+				AND createdBy = session_context('$user.id')
+				AND createdAt = session_context('$now')
+			);`;
+	}
+
+	// SELECT SQL to get the parent_ID for child entries
+	const parentLookupExpr = `(SELECT ID FROM sap_changelog_Changes
+		WHERE entity = '${parentEntityName}'
+		AND entityKey = ${parentKeyExpr}
+		AND attribute = '${compositionFieldName}'
+		AND valueDataType = 'cds.Composition'
+		AND createdBy = session_context('$user.id')
+		ORDER BY createdAt DESC LIMIT 1)`;
+
+	return { insertSQL, parentEntityName, compositionFieldName, parentKeyExpr, parentLookupExpr };
+}
+
+module.exports = {
+	buildCompOfManyRootObjectIDSelect,
+	buildCompositionOfOneParentContext,
+	buildCompositionParentContext
+};

package/lib/sqlite/register.js

@@ -0,0 +1,28 @@
+const cds = require('@sap/cds');
+
+const { getEntitiesForTriggerGeneration, collectEntities } = require('../utils/entity-collector.js');
+const { getLabelTranslations } = require('../localization.js');
+const { generateTriggersForEntities } = require('../utils/trigger-utils.js');
+
+async function deploySQLiteTriggers() {
+	const db = cds.env.requires?.db;
+	if (db?.kind !== 'sqlite') return;
+
+	const model = cds.context?.model ?? cds.model;
+	const { collectedEntities, hierarchyMap } = collectEntities(model);
+	const { generateSQLiteTrigger } = require('./triggers.js');
+	const entities = getEntitiesForTriggerGeneration(model.definitions, collectedEntities);
+
+	const triggers = generateTriggersForEntities(model, hierarchyMap, entities, generateSQLiteTrigger);
+	let deleteTriggers = triggers.map((t) => t.match(/CREATE\s+TRIGGER\s+IF NOT EXISTS\s+(\w+)/i)).map((m) => `DROP TRIGGER IF EXISTS ${m[1]};`);
+
+	const labels = getLabelTranslations(entities, model);
+	const { i18nKeys } = cds.entities('sap.changelog');
+
+	// Delete existing triggers
+	await Promise.all(deleteTriggers.map((t) => cds.db.run(t)));
+
+	await Promise.all([...triggers.map((t) => cds.db.run(t)), cds.delete(i18nKeys), cds.insert(labels).into(i18nKeys)]);
+}
+
+module.exports = { deploySQLiteTriggers };