@fjell/lib-sequelize 4.4.4 → 4.4.5

package/dist/cjs/ops/update.cjs

@@ -9,8 +9,30 @@ const logger$1 = require('../logger.cjs');
 const RowProcessor = require('../RowProcessor.cjs');
 const general = require('../util/general.cjs');
 const Library = require('@fjell/lib');
+const sequelize = require('sequelize');
+const relationshipUtils = require('../util/relationshipUtils.cjs');
 
 const logger = 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)=>{
@@ -26,15 +48,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.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.default('Composite key query for update', {
+                queryOptions
             });
+            response = await model.findOne(queryOptions);
         }
         if (response) {
             // Remove the key and events
@@ -58,4 +114,4 @@ const getUpdateOperation = (models, definition, registry)=>{
 };
 
 exports.getUpdateOperation = getUpdateOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/util/relationshipUtils.cjs

@@ -25,8 +25,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
         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

package/dist/es/AggregationBuilder.js

@@ -1,27 +1,61 @@
 import { ikToLKA } from '@fjell/core';
+import { serializeKey, contextManager } from './OperationContext.js';
+import LibLogger from './logger.js';
 
-const buildAggregation = async (item, aggregationDefinition, registry)=>{
+const logger = LibLogger.get('sequelize', 'AggregationBuilder');
+const buildAggregation = async (item, aggregationDefinition, registry, context)=>{
     const location = 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;
+    // Create a cache key for this aggregation query
+    // This helps avoid running the same aggregation multiple times
+    const aggregationCacheKey = `${aggregationDefinition.kta.join('.')}_${aggregationDefinition.cardinality}_${serializeKey(item.key)}`;
+    if (context) {
+        // Check if this aggregation is already cached
+        if (context.cache.has(aggregationCacheKey)) {
+            const cachedResult = context.cache.get(aggregationCacheKey);
+            logger.default('Using cached aggregation result', {
+                aggregationCacheKey,
+                property: aggregationDefinition.property
+            });
+            item[aggregationDefinition.property] = cachedResult;
             return item;
-        });
-    } else {
-        // For one-to-many relationship, use the all operation
-        return libraryInstance.operations.all({}, location).then((results)=>{
-            item[aggregationDefinition.property] = results;
-            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 contextManager.withContext(context || 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;
+            });
+        }
+    });
 };
 
 export { buildAggregation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRpb25CdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRpb25CdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/KeyMaster.js

@@ -21,19 +21,41 @@ 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)=>{
@@ -121,4 +143,4 @@ const addKey = (model, item, keyTypes)=>{
 };
 
 export { addKey, removeKey };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/OperationContext.js

@@ -0,0 +1,155 @@
+import LibLogger from './logger.js';
+
+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 = LibLogger.get('sequelize', 'OperationContext');
+/**
+ * Serialize an ItemKey to a string for use in sets and maps
+ */ const 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 = serializeKey(key);
+            logger.default('Marking key as in progress', {
+                key,
+                serialized
+            });
+            inProgress.add(serialized);
+        },
+        markComplete (key) {
+            const serialized = serializeKey(key);
+            logger.default('Marking key as complete', {
+                key,
+                serialized
+            });
+            inProgress.delete(serialized);
+        },
+        isInProgress (key) {
+            const serialized = serializeKey(key);
+            const result = inProgress.has(serialized);
+            logger.default('Checking if key is in progress', {
+                key,
+                serialized,
+                result
+            });
+            return result;
+        },
+        getCached (key) {
+            const serialized = serializeKey(key);
+            const result = cache.get(serialized);
+            logger.default('Getting cached item', {
+                key,
+                serialized,
+                found: !!result
+            });
+            return result;
+        },
+        setCached (key, item) {
+            const serialized = serializeKey(key);
+            logger.default('Caching item', {
+                key,
+                serialized
+            });
+            cache.set(serialized, item);
+        },
+        isCached (key) {
+            const serialized = serializeKey(key);
+            const result = cache.has(serialized);
+            logger.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.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.default('Got current context', {
+                contextId: this.currentContextId,
+                found: !!context
+            });
+            return context;
+        }
+        return;
+    }
+    /**
+   * Clear the current context
+   */ clearCurrentContext() {
+        if (this.currentContextId) {
+            logger.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 contextManager = new ContextManager();
+
+export { contextManager, createOperationContext, serializeKey };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9uQ29udGV4dC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/ReferenceBuilder.js

@@ -1,4 +1,7 @@
-const buildReference = async (item, referenceDefinition, registry)=>{
+import LibLogger from './logger.js';
+
+const logger = LibLogger.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");
@@ -12,13 +15,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.default('Using cached reference', {
+                priKey,
+                property: referenceDefinition.property
+            });
+            referencedItem = context.getCached(priKey);
+        } else if (context.isInProgress(priKey)) {
+            logger.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
@@ -27,4 +69,4 @@ const buildReference = async (item, referenceDefinition, registry)=>{
 };
 
 export { buildReference };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/RowProcessor.js

@@ -4,34 +4,49 @@ import { buildReference } from './ReferenceBuilder.js';
 import { buildAggregation } from './AggregationBuilder.js';
 import { stringifyJSON } from './util/general.js';
 import { populateEvents } from './EventCoordinator.js';
+import { contextManager, createOperationContext } from './OperationContext.js';
 
 const logger = LibLogger.get('sequelize', 'RowProcessor');
-const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry)=>{
+const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context)=>{
     logger.default('Processing Row', {
         row
     });
-    let item = row.get({
-        plain: true
-    });
-    logger.default('Adding Key to Item with Key Types: %s', stringifyJSON(keyTypes));
-    item = addKey(row, item, keyTypes);
-    item = populateEvents(item);
-    logger.default('Key Added to Item: %s', stringifyJSON(item.key));
-    if (referenceDefinitions && referenceDefinitions.length > 0) {
-        for (const referenceDefinition of referenceDefinitions){
-            logger.default('Processing Reference for %s to %s', item.key.kt, stringifyJSON(referenceDefinition.kta));
-            item = await buildReference(item, referenceDefinition, registry);
-        }
-    }
-    if (aggregationDefinitions && aggregationDefinitions.length > 0) {
-        for (const aggregationDefinition of aggregationDefinitions){
-            logger.default('Processing Aggregation for %s from %s', item.key.kt, 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 contextManager.withContext(operationContext, async ()=>{
+        let item = row.get({
+            plain: true
+        });
+        logger.default('Adding Key to Item with Key Types: %s', stringifyJSON(keyTypes));
+        item = addKey(row, item, keyTypes);
+        item = populateEvents(item);
+        logger.default('Key Added to Item: %s', 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.default('Processing Reference for %s to %s', item.key.kt, stringifyJSON(referenceDefinition.kta));
+                    item = await buildReference(item, referenceDefinition, registry, operationContext);
+                }
+            }
+            if (aggregationDefinitions && aggregationDefinitions.length > 0) {
+                for (const aggregationDefinition of aggregationDefinitions){
+                    logger.default('Processing Aggregation for %s from %s', item.key.kt, 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.default('Processed Row: %j', stringifyJSON(item));
-    return item;
+        logger.default('Processed Row: %j', stringifyJSON(item));
+        return item;
+    });
 };
 
 export { processRow };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==