@fjell/lib-sequelize 4.4.4 → 4.4.8

package/dist/index.cjs

@@ -93,9 +93,9 @@ const createOptions = (libOptions)=>{
 
 const logger$1.default = Logging.getLogger('@fjell/lib-sequelize');
 
-const logger$c = logger$1.default.get('lib-sequelize', 'Definition');
+const logger$f = logger$1.default.get('lib-sequelize', 'Definition');
 function createDefinition(kta, scopes, libOptions) {
-    logger$c.debug('createDefinition', {
+    logger$f.debug('createDefinition', {
         kta,
         scopes,
         libOptions
@@ -109,9 +109,9 @@ function createDefinition(kta, scopes, libOptions) {
     };
 }
 
-const logger$b = logger$1.default.get('sequelize', 'QueryBuilder');
+const logger$e = logger$1.default.get('sequelize', 'QueryBuilder');
 const addDeleteQuery = (options, model)=>{
-    logger$b.default('Adding Delete Query', {
+    logger$e.default('Adding Delete Query', {
         options
     });
     if (model.getAttributes().deletedAt) {
@@ -126,7 +126,7 @@ const addDeleteQuery = (options, model)=>{
     return options;
 };
 const addEventQueries = (options, events, model)=>{
-    logger$b.default('Adding Event Queries', {
+    logger$e.default('Adding Event Queries', {
         options,
         events
     });
@@ -163,12 +163,12 @@ const addEventQueries = (options, events, model)=>{
 };
 // Add the references to the query
 const addReferenceQueries = (options, references, model)=>{
-    logger$b.default('Adding Reference Queries', {
+    logger$e.default('Adding Reference Queries', {
         options,
         references
     });
     Object.keys(references).forEach((key)=>{
-        logger$b.default('Adding Reference Query', {
+        logger$e.default('Adding Reference Query', {
             key,
             references
         });
@@ -334,14 +334,14 @@ const addAssociationIncludes = (options, model)=>{
     return options;
 };
 const buildQuery = (itemQuery, model)=>{
-    logger$b.default('build', {
+    logger$e.default('build', {
         itemQuery
     });
     let options = {
         where: {}
     };
     if (itemQuery.compoundCondition) {
-        logger$b.default('Adding Conditions', {
+        logger$e.default('Adding Conditions', {
             compoundCondition: itemQuery.compoundCondition
         });
         options = addCompoundCondition(options, itemQuery.compoundCondition, model);
@@ -359,7 +359,7 @@ const buildQuery = (itemQuery, model)=>{
     // TODO: Once we start to support Aggs on the server-side, we'll need to parse agg queries
     // Apply a limit to the result set
     if (itemQuery.limit) {
-        logger$b.default('Limiting to', {
+        logger$e.default('Limiting to', {
             limit: itemQuery.limit
         });
         options.limit = itemQuery.limit;
@@ -410,8 +410,8 @@ const buildQuery = (itemQuery, model)=>{
         modelChain.push(currentModel);
     }
     // Build the full association path for the target field
-    const targetType = kta[targetIndex];
-    const associationPath = `$${associationParts.join('.')}.${targetType}Id$`;
+    const targetPrimaryKey = currentModel.primaryKeyAttribute || 'id';
+    const associationPath = `$${associationParts.join('.')}.${targetPrimaryKey}$`;
     // Build nested includes structure iteratively (clearer than recursion)
     let deepestInclude = null;
     // Build from the deepest level back to the root
@@ -497,10 +497,10 @@ const buildQuery = (itemQuery, model)=>{
     return result;
 };
 
-const logger$a = logger$1.default.get('sequelize', 'KeyMaster');
+const logger$d = logger$1.default.get('sequelize', 'KeyMaster');
 // Helper function to extract location key value from item
 const extractLocationKeyValue = (model, item, locatorType, kta)=>{
-    logger$a.default('Extracting location key value', {
+    logger$d.default('Extracting location key value', {
         locatorType,
         kta
     });
@@ -517,23 +517,45 @@ const extractLocationKeyValue = (model, item, locatorType, kta)=>{
         }
         return value;
     } else {
-        // Need to traverse relationship
-        // Try to get the value from the loaded relationship object
-        const relationshipObject = item[locatorType];
-        if (relationshipObject && typeof relationshipObject.id !== 'undefined') {
-            return relationshipObject.id;
+        // Need to traverse relationship hierarchy
+        // Find the path through the key type array
+        const locatorIndex = kta.indexOf(locatorType);
+        if (locatorIndex === -1) {
+            throw new Error(`Locator type '${locatorType}' not found in key type array`);
         }
-        // If the relationship object isn't loaded, we might need to look at the foreign key field
-        // This handles cases where we have the foreign key but not the full object
+        // Start from the current item (index 0 in kta)
+        let currentObject = item;
+        // Traverse through each intermediate relationship to reach the target
+        for(let i = 1; i < locatorIndex; i++){
+            const intermediateType = kta[i];
+            // Check if the intermediate relationship object is loaded
+            if (currentObject[intermediateType] && typeof currentObject[intermediateType] === 'object') {
+                currentObject = currentObject[intermediateType];
+            } else {
+                // Try the foreign key approach if the relationship object isn't loaded
+                const foreignKeyField = `${intermediateType}Id`;
+                if (typeof currentObject[foreignKeyField] !== 'undefined' && currentObject[foreignKeyField] !== null) {
+                    // We have the foreign key but not the loaded object, we can't traverse further
+                    throw new Error(`Intermediate relationship '${intermediateType}' is not loaded. Cannot traverse to '${locatorType}'. Either include the relationship in your query or ensure it's loaded.`);
+                }
+                throw new Error(`Intermediate relationship '${intermediateType}' is missing in the relationship chain. Expected path: ${kta.slice(0, locatorIndex + 1).join(' → ')}`);
+            }
+        }
+        // Now extract the target locator value from the current object
+        // First try to get it from the loaded relationship object
+        if (currentObject[locatorType] && typeof currentObject[locatorType] === 'object' && typeof currentObject[locatorType].id !== 'undefined') {
+            return currentObject[locatorType].id;
+        }
+        // If the relationship object isn't loaded, try the foreign key field
         const foreignKeyField = `${locatorType}Id`;
-        if (typeof item[foreignKeyField] !== 'undefined' && item[foreignKeyField] !== null) {
-            return item[foreignKeyField];
+        if (typeof currentObject[foreignKeyField] !== 'undefined' && currentObject[foreignKeyField] !== null) {
+            return currentObject[foreignKeyField];
         }
-        throw new Error(`Unable to extract location key for '${locatorType}'. Neither the relationship object nor direct foreign key is available.`);
+        throw new Error(`Unable to extract location key for '${locatorType}'. Neither the relationship object nor direct foreign key is available. Traversal path: ${kta.slice(0, locatorIndex + 1).join(' → ')}`);
     }
 };
 const removeKey = (item)=>{
-    logger$a.default('Removing Key', {
+    logger$d.default('Removing Key', {
         item
     });
     delete item.key;
@@ -567,7 +589,7 @@ const removeKey = (item)=>{
 //   return item;
 // }
 const addKey = (model, item, keyTypes)=>{
-    logger$a.default('Adding Key', {
+    logger$d.default('Adding Key', {
         item
     });
     const key = {};
@@ -593,7 +615,7 @@ const addKey = (model, item, keyTypes)=>{
                 });
             } catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                logger$a.error(`Failed to extract location key for '${locatorType}'`, {
+                logger$d.error(`Failed to extract location key for '${locatorType}'`, {
                     error: errorMessage,
                     item,
                     keyTypes
@@ -616,7 +638,8 @@ const addKey = (model, item, keyTypes)=>{
     return item;
 };
 
-const buildReference = async (item, referenceDefinition, registry)=>{
+const logger$c = logger$1.default.get('sequelize', 'ReferenceBuilder');
+const buildReference = async (item, referenceDefinition, registry, context)=>{
     // Check if there is more than one key type
     if (referenceDefinition.kta.length > 1) {
         throw new Error("The ReferenceBuilder doesn't work with more than one key type yet");
@@ -630,13 +653,52 @@ const buildReference = async (item, referenceDefinition, registry)=>{
     if (!library) {
         throw new Error("This model definition has a reference definition, but the dependency is not present");
     }
+    // Check if the column value is null - if so, skip the reference
+    const columnValue = item[referenceDefinition.column];
+    if (columnValue == null) {
+        item[referenceDefinition.property] = null;
+        return item;
+    }
     // Create a PriKey using the column value from item
     const priKey = {
         kt: referenceDefinition.kta[0],
-        pk: item[referenceDefinition.column]
+        pk: columnValue
     };
-    // Get the referenced item using the Library.Operations get method
-    const referencedItem = await library.operations.get(priKey);
+    let referencedItem;
+    if (context) {
+        // Check if we already have this item cached
+        if (context.isCached(priKey)) {
+            logger$c.default('Using cached reference', {
+                priKey,
+                property: referenceDefinition.property
+            });
+            referencedItem = context.getCached(priKey);
+        } else if (context.isInProgress(priKey)) {
+            logger$c.default('Circular dependency detected, creating reference placeholder', {
+                priKey,
+                property: referenceDefinition.property
+            });
+            // Create a minimal reference object with just the key to break the cycle
+            referencedItem = {
+                key: priKey
+            };
+        } else {
+            // Mark this key as in progress before loading
+            context.markInProgress(priKey);
+            try {
+                // Get the referenced item using the Library.Operations get method (context now managed internally)
+                referencedItem = await library.operations.get(priKey);
+                // Cache the result
+                context.setCached(priKey, referencedItem);
+            } finally{
+                // Always mark as complete, even if there was an error
+                context.markComplete(priKey);
+            }
+        }
+    } else {
+        // Fallback to original behavior if no context provided
+        referencedItem = await library.operations.get(priKey);
+    }
     // TODO: In a Fjell-compliant implementation, this value should be stored in the ref property
     // For now, we'll just populate the property directly
     // Store the result in the property on item
@@ -644,27 +706,210 @@ const buildReference = async (item, referenceDefinition, registry)=>{
     return item;
 };
 
-const buildAggregation = async (item, aggregationDefinition, registry)=>{
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+const logger$b = logger$1.default.get('sequelize', 'OperationContext');
+/**
+ * Serialize an ItemKey to a string for use in sets and maps
+ */ const OperationContext.serializeKey = (key)=>{
+    if ('pk' in key && 'kt' in key && !('loc' in key)) {
+        // PriKey
+        return `${key.kt}:${key.pk}`;
+    } else if ('pk' in key && 'kt' in key && 'loc' in key) {
+        // ComKey
+        const locStr = key.loc.map((l)=>`${l.kt}:${l.lk}`).join(',');
+        return `${key.kt}:${key.pk}|${locStr}`;
+    }
+    throw new Error(`Unsupported key type: ${JSON.stringify(key)}`);
+};
+/**
+ * Create a new OperationContext
+ */ const createOperationContext = ()=>{
+    const inProgress = new Set();
+    const cache = new Map();
+    return {
+        inProgress,
+        cache,
+        markInProgress (key) {
+            const serialized = OperationContext.serializeKey(key);
+            logger$b.default('Marking key as in progress', {
+                key,
+                serialized
+            });
+            inProgress.add(serialized);
+        },
+        markComplete (key) {
+            const serialized = OperationContext.serializeKey(key);
+            logger$b.default('Marking key as complete', {
+                key,
+                serialized
+            });
+            inProgress.delete(serialized);
+        },
+        isInProgress (key) {
+            const serialized = OperationContext.serializeKey(key);
+            const result = inProgress.has(serialized);
+            logger$b.default('Checking if key is in progress', {
+                key,
+                serialized,
+                result
+            });
+            return result;
+        },
+        getCached (key) {
+            const serialized = OperationContext.serializeKey(key);
+            const result = cache.get(serialized);
+            logger$b.default('Getting cached item', {
+                key,
+                serialized,
+                found: !!result
+            });
+            return result;
+        },
+        setCached (key, item) {
+            const serialized = OperationContext.serializeKey(key);
+            logger$b.default('Caching item', {
+                key,
+                serialized
+            });
+            cache.set(serialized, item);
+        },
+        isCached (key) {
+            const serialized = OperationContext.serializeKey(key);
+            const result = cache.has(serialized);
+            logger$b.default('Checking if key is cached', {
+                key,
+                serialized,
+                result
+            });
+            return result;
+        }
+    };
+};
+/**
+ * Context Manager for sharing context across operations without changing public interfaces
+ */ class ContextManager {
+    /**
+   * Set the current context for the current operation chain
+   */ setCurrentContext(context) {
+        const contextId = Math.random().toString(36).substring(7);
+        this.contexts.set(contextId, context);
+        this.currentContextId = contextId;
+        logger$b.default('Set current context', {
+            contextId
+        });
+        return contextId;
+    }
+    /**
+   * Get the current context if one is set
+   */ getCurrentContext() {
+        if (this.currentContextId) {
+            const context = this.contexts.get(this.currentContextId);
+            logger$b.default('Got current context', {
+                contextId: this.currentContextId,
+                found: !!context
+            });
+            return context;
+        }
+        return;
+    }
+    /**
+   * Clear the current context
+   */ clearCurrentContext() {
+        if (this.currentContextId) {
+            logger$b.default('Clearing current context', {
+                contextId: this.currentContextId
+            });
+            this.contexts.delete(this.currentContextId);
+            this.currentContextId = null;
+        }
+    }
+    /**
+   * Execute a function with a specific context set as current
+   */ async withContext(context, fn) {
+        const previousContextId = this.currentContextId;
+        this.setCurrentContext(context);
+        try {
+            return await fn();
+        } finally{
+            this.clearCurrentContext();
+            if (previousContextId) {
+                this.currentContextId = previousContextId;
+            }
+        }
+    }
+    constructor(){
+        _define_property(this, "contexts", new Map());
+        _define_property(this, "currentContextId", null);
+    }
+}
+// Global context manager instance
+const OperationContext.contextManager = new ContextManager();
+
+const logger$a = logger$1.default.get('sequelize', 'AggregationBuilder');
+const buildAggregation = async (item, aggregationDefinition, registry, context)=>{
     const location = core.ikToLKA(item.key);
     // Get the library instance from the registry using the key type array
     const libraryInstance = registry.get(aggregationDefinition.kta);
     if (!libraryInstance) {
         throw new Error(`Library instance not found for key type array: ${aggregationDefinition.kta.join(', ')}`);
     }
-    // Based on cardinality, use either one or all operation
-    if (aggregationDefinition.cardinality === 'one') {
-        // For one-to-one relationship, use the one operation
-        return libraryInstance.operations.one({}, location).then((result)=>{
-            item[aggregationDefinition.property] = result;
-            return item;
-        });
-    } else {
-        // For one-to-many relationship, use the all operation
-        return libraryInstance.operations.all({}, location).then((results)=>{
-            item[aggregationDefinition.property] = results;
+    // Create a cache key for this aggregation query
+    // This helps avoid running the same aggregation multiple times
+    const aggregationCacheKey = `${aggregationDefinition.kta.join('.')}_${aggregationDefinition.cardinality}_${OperationContext.serializeKey(item.key)}`;
+    if (context) {
+        // Check if this aggregation is already cached
+        if (context.cache.has(aggregationCacheKey)) {
+            const cachedResult = context.cache.get(aggregationCacheKey);
+            logger$a.default('Using cached aggregation result', {
+                aggregationCacheKey,
+                property: aggregationDefinition.property
+            });
+            item[aggregationDefinition.property] = cachedResult;
             return item;
-        });
+        }
+    // Note: We don't check for circular dependencies here because:
+    // 1. Aggregations are location-based queries, not key-based references
+    // 2. They should be allowed to run during normal item processing
+    // 3. The main circular dependency concern is with references, not aggregations
     }
+    // Execute aggregation within the current context to ensure context sharing
+    return OperationContext.contextManager.withContext(context || OperationContext.contextManager.getCurrentContext() || {
+        inProgress: new Set(),
+        cache: new Map()
+    }, async ()=>{
+        // Based on cardinality, use either one or all operation
+        if (aggregationDefinition.cardinality === 'one') {
+            // For one-to-one relationship, use the one operation
+            return libraryInstance.operations.one({}, location).then((result)=>{
+                if (context) {
+                    context.cache.set(aggregationCacheKey, result);
+                }
+                item[aggregationDefinition.property] = result;
+                return item;
+            });
+        } else {
+            // For one-to-many relationship, use the all operation
+            return libraryInstance.operations.all({}, location).then((results)=>{
+                if (context) {
+                    context.cache.set(aggregationCacheKey, results);
+                }
+                item[aggregationDefinition.property] = results;
+                return item;
+            });
+        }
+    });
 };
 
 const logger$9 = logger$1.default.get("sequelize", "EventCoordinator");
@@ -711,34 +956,68 @@ const removeEvents = (item)=>{
 };
 
 const logger$8 = logger$1.default.get('sequelize', 'RowProcessor');
-const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry)=>{
+const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context)=>{
     logger$8.default('Processing Row', {
         row
     });
-    let item = row.get({
-        plain: true
-    });
-    logger$8.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
-    item = addKey(row, item, keyTypes);
-    item = populateEvents(item);
-    logger$8.default('Key Added to Item: %s', general.stringifyJSON(item.key));
-    if (referenceDefinitions && referenceDefinitions.length > 0) {
-        for (const referenceDefinition of referenceDefinitions){
-            logger$8.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
-            item = await buildReference(item, referenceDefinition, registry);
-        }
-    }
-    if (aggregationDefinitions && aggregationDefinitions.length > 0) {
-        for (const aggregationDefinition of aggregationDefinitions){
-            logger$8.default('Processing Aggregation for %s from %s', item.key.kt, general.stringifyJSON(aggregationDefinition.kta));
-            item = await buildAggregation(item, aggregationDefinition, registry);
+    // Use provided context or create new one
+    const operationContext = context || createOperationContext();
+    // Process the row within the context to ensure all operations share the same context
+    return OperationContext.contextManager.withContext(operationContext, async ()=>{
+        let item = row.get({
+            plain: true
+        });
+        logger$8.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
+        item = addKey(row, item, keyTypes);
+        item = populateEvents(item);
+        logger$8.default('Key Added to Item: %s', general.stringifyJSON(item.key));
+        // Mark this item as in progress to detect circular references
+        operationContext.markInProgress(item.key);
+        try {
+            if (referenceDefinitions && referenceDefinitions.length > 0) {
+                for (const referenceDefinition of referenceDefinitions){
+                    logger$8.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
+                    item = await buildReference(item, referenceDefinition, registry, operationContext);
+                }
+            }
+            if (aggregationDefinitions && aggregationDefinitions.length > 0) {
+                for (const aggregationDefinition of aggregationDefinitions){
+                    logger$8.default('Processing Aggregation for %s from %s', item.key.kt, general.stringifyJSON(aggregationDefinition.kta));
+                    item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
+                }
+            }
+            // Cache the fully processed item
+            operationContext.setCached(item.key, item);
+        } finally{
+            // Mark this item as complete
+            operationContext.markComplete(item.key);
         }
-    }
-    logger$8.default('Processed Row: %j', general.stringifyJSON(item));
-    return item;
+        logger$8.default('Processed Row: %j', general.stringifyJSON(item));
+        return item;
+    });
 };
 
 const logger$7 = logger$1.default.get('sequelize', 'ops', 'all');
+// Helper function to merge includes avoiding duplicates
+const mergeIncludes$1 = (existingIncludes, newIncludes)=>{
+    const mergedIncludes = [
+        ...existingIncludes
+    ];
+    for (const newInclude of newIncludes){
+        const existingIndex = mergedIncludes.findIndex((existing)=>existing.as === newInclude.as && existing.model === newInclude.model);
+        if (existingIndex === -1) {
+            mergedIncludes.push(newInclude);
+        } else if (newInclude.include && mergedIncludes[existingIndex].include) {
+            mergedIncludes[existingIndex].include = [
+                ...mergedIncludes[existingIndex].include,
+                ...newInclude.include
+            ];
+        } else if (newInclude.include) {
+            mergedIncludes[existingIndex].include = newInclude.include;
+        }
+    }
+    return mergedIncludes;
+};
 const all.getAllOperation = (models, definition, registry)=>{
     const { coordinate, options: { references, aggregations } } = definition;
     //#region Query
@@ -748,29 +1027,64 @@ const all.getAllOperation = (models, definition, registry)=>{
             locations
         });
         const loc = locations || [];
-        // SQ Libs don't support locations
-        if (loc.length > 1) {
-            throw new Error('Not implemented for more than one location key');
-        }
-        // We have the model here?
         // @ts-ignore
         const model = models[0];
-        // We have the model here?
+        // Build base query from itemQuery
         const options = buildQuery(itemQuery, model);
-        // If this has a location array, we need to add a where clause
-        if (loc.length === 1) {
-            const locKeyType = loc[0].kt;
-            if (model.associations[locKeyType]) {
-                const association = model.associations[locKeyType];
+        // Handle location keys if present
+        if (loc.length > 0) {
+            const { kta } = coordinate;
+            const directLocations = [];
+            const hierarchicalLocations = [];
+            const additionalIncludes = [];
+            // Categorize location keys as direct or hierarchical
+            for (const locKey of loc){
+                const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta, true);
+                if (!relationshipInfo.found) {
+                    const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
+                    logger$7.error(errorMessage, {
+                        locations: loc,
+                        kta
+                    });
+                    throw new Error(errorMessage);
+                }
+                if (relationshipInfo.isDirect) {
+                    directLocations.push(locKey);
+                } else {
+                    hierarchicalLocations.push(locKey);
+                }
+            }
+            // Handle direct location keys (simple foreign key constraints)
+            for (const locKey of directLocations){
+                const foreignKeyField = locKey.kt + 'Id';
                 options.where = {
                     ...options.where,
-                    [association.foreignKey]: {
-                        [sequelize.Op.eq]: loc[0].lk
+                    [foreignKeyField]: {
+                        [sequelize.Op.eq]: locKey.lk
                     }
                 };
-            } else {
-                logger$7.error('Location key type not found in sequelize model association for: %s', locKeyType);
-                throw new Error('Location key type not found in model');
+            }
+            // Handle hierarchical location keys (requires relationship traversal)
+            for (const locKey of hierarchicalLocations){
+                const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta);
+                if (relationshipInfo.found && relationshipInfo.path) {
+                    // Add the relationship constraint using the path
+                    options.where = {
+                        ...options.where,
+                        [relationshipInfo.path]: {
+                            [sequelize.Op.eq]: locKey.lk
+                        }
+                    };
+                    // Add necessary includes for the relationship traversal
+                    if (relationshipInfo.includes) {
+                        additionalIncludes.push(...relationshipInfo.includes);
+                    }
+                }
+            }
+            // Merge additional includes with existing includes
+            if (additionalIncludes.length > 0) {
+                const existingIncludes = options.include || [];
+                options.include = mergeIncludes$1(existingIncludes, additionalIncludes);
             }
         }
         logger$7.default('Configured this Item Query', {
@@ -779,9 +1093,11 @@ const all.getAllOperation = (models, definition, registry)=>{
         });
         const matchingItems = await model.findAll(options);
         // this.logger.default('Matching Items', { matchingItems });
+        // Get the current context from context manager
+        const context = OperationContext.contextManager.getCurrentContext();
         // TODO: Move this Up!
         return await Promise.all(matchingItems.map(async (row)=>{
-            const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry);
+            const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry, context);
             return core.validateKeys(processedRow, coordinate.kta);
         }));
     };
@@ -1032,7 +1348,9 @@ const getGetOperation = (models, definition, registry)=>{
         if (!item) {
             throw new Library.NotFoundError('get', coordinate, key);
         } else {
-            return core.validateKeys(await processRow(item, kta, references, aggregations, registry), kta);
+            // Get the current context from context manager
+            const context = OperationContext.contextManager.getCurrentContext();
+            return core.validateKeys(await processRow(item, kta, references, aggregations, registry, context), kta);
         }
     };
     return get;
@@ -1155,6 +1473,26 @@ registry)=>{
 };
 
 const logger$1 = logger$1.default.get('sequelize', 'ops', 'update');
+// Helper function to merge includes avoiding duplicates
+const mergeIncludes = (existingIncludes, newIncludes)=>{
+    const mergedIncludes = [
+        ...existingIncludes
+    ];
+    for (const newInclude of newIncludes){
+        const existingIndex = mergedIncludes.findIndex((existing)=>existing.as === newInclude.as && existing.model === newInclude.model);
+        if (existingIndex === -1) {
+            mergedIncludes.push(newInclude);
+        } else if (newInclude.include && mergedIncludes[existingIndex].include) {
+            mergedIncludes[existingIndex].include = [
+                ...mergedIncludes[existingIndex].include,
+                ...newInclude.include
+            ];
+        } else if (newInclude.include) {
+            mergedIncludes[existingIndex].include = newInclude.include;
+        }
+    }
+    return mergedIncludes;
+};
 const getUpdateOperation = (models, definition, registry)=>{
     const { options: { references, aggregations } } = definition;
     const update = async (key, item)=>{
@@ -1170,15 +1508,49 @@ const getUpdateOperation = (models, definition, registry)=>{
             const priKey = key;
             response = await model.findByPk(priKey.pk);
         } else if (core.isComKey(key)) {
-            var _comKey_loc_, _comKey_loc_1;
             const comKey = key;
-            // Find the model by using both of the identifiers.
-            response = await model.findOne({
-                where: {
-                    [(comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_ = comKey.loc[0]) === null || _comKey_loc_ === void 0 ? void 0 : _comKey_loc_.kt) + 'Id']: comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_1 = comKey.loc[0]) === null || _comKey_loc_1 === void 0 ? void 0 : _comKey_loc_1.lk,
-                    id: comKey === null || comKey === void 0 ? void 0 : comKey.pk
+            // Build query options for composite key with multiple location keys
+            const where = {
+                id: comKey.pk
+            };
+            const additionalIncludes = [];
+            // Process all location keys in the composite key
+            for (const locator of comKey.loc){
+                const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta, true);
+                if (!relationshipInfo.found) {
+                    const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
+                    logger$1.error(errorMessage, {
+                        key: comKey,
+                        kta
+                    });
+                    throw new Error(errorMessage);
                 }
+                if (relationshipInfo.isDirect) {
+                    // Direct foreign key field
+                    const fieldName = `${locator.kt}Id`;
+                    where[fieldName] = locator.lk;
+                } else if (relationshipInfo.path) {
+                    // Hierarchical relationship requiring traversal
+                    where[relationshipInfo.path] = {
+                        [sequelize.Op.eq]: locator.lk
+                    };
+                    // Add necessary includes for relationship traversal
+                    if (relationshipInfo.includes) {
+                        additionalIncludes.push(...relationshipInfo.includes);
+                    }
+                }
+            }
+            // Build final query options
+            const queryOptions = {
+                where
+            };
+            if (additionalIncludes.length > 0) {
+                queryOptions.include = mergeIncludes([], additionalIncludes);
+            }
+            logger$1.default('Composite key query for update', {
+                queryOptions
             });
+            response = await model.findOne(queryOptions);
         }
         if (response) {
             // Remove the key and events