@fjell/lib-sequelize 4.4.4 → 4.4.5

package/dist/cjs/AggregationBuilder.cjs

@@ -3,29 +3,63 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const core = require('@fjell/core');
+const OperationContext = require('./OperationContext.cjs');
+const logger$1 = require('./logger.cjs');
 
-const buildAggregation = async (item, aggregationDefinition, registry)=>{
+const logger = 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;
+    // 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.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 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;
+            });
+        }
+    });
 };
 
 exports.buildAggregation = buildAggregation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRpb25CdWlsZGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWdncmVnYXRpb25CdWlsZGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/KeyMaster.cjs

@@ -25,19 +25,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)=>{
@@ -126,4 +148,4 @@ const addKey = (model, item, keyTypes)=>{
 
 exports.addKey = addKey;
 exports.removeKey = removeKey;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/OperationContext.cjs

@@ -0,0 +1,161 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('./logger.cjs');
+
+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 = logger$1.default.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();
+
+exports.contextManager = contextManager;
+exports.createOperationContext = createOperationContext;
+exports.serializeKey = serializeKey;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9uQ29udGV4dC5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/ReferenceBuilder.cjs

@@ -2,7 +2,10 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const buildReference = async (item, referenceDefinition, registry)=>{
+const logger$1 = require('./logger.cjs');
+
+const logger = 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");
@@ -16,13 +19,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
@@ -31,4 +73,4 @@ const buildReference = async (item, referenceDefinition, registry)=>{
 };
 
 exports.buildReference = buildReference;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/RowProcessor.cjs

@@ -8,34 +8,49 @@ const ReferenceBuilder = require('./ReferenceBuilder.cjs');
 const AggregationBuilder = require('./AggregationBuilder.cjs');
 const general = require('./util/general.cjs');
 const EventCoordinator = require('./EventCoordinator.cjs');
+const OperationContext = require('./OperationContext.cjs');
 
 const logger = logger$1.default.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', general.stringifyJSON(keyTypes));
-    item = KeyMaster.addKey(row, item, keyTypes);
-    item = EventCoordinator.populateEvents(item);
-    logger.default('Key Added to Item: %s', general.stringifyJSON(item.key));
-    if (referenceDefinitions && referenceDefinitions.length > 0) {
-        for (const referenceDefinition of referenceDefinitions){
-            logger.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
-            item = await ReferenceBuilder.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, general.stringifyJSON(aggregationDefinition.kta));
-            item = await AggregationBuilder.buildAggregation(item, aggregationDefinition, registry);
+    // Use provided context or create new one
+    const operationContext = context || OperationContext.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.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
+        item = KeyMaster.addKey(row, item, keyTypes);
+        item = EventCoordinator.populateEvents(item);
+        logger.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.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
+                    item = await ReferenceBuilder.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, general.stringifyJSON(aggregationDefinition.kta));
+                    item = await AggregationBuilder.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', general.stringifyJSON(item));
-    return item;
+        logger.default('Processed Row: %j', general.stringifyJSON(item));
+        return item;
+    });
 };
 
 exports.processRow = processRow;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/ops/all.cjs

@@ -7,8 +7,30 @@ const QueryBuilder = require('../QueryBuilder.cjs');
 const logger$1 = require('../logger.cjs');
 const RowProcessor = require('../RowProcessor.cjs');
 const sequelize = require('sequelize');
+const relationshipUtils = require('../util/relationshipUtils.cjs');
+const OperationContext = require('../OperationContext.cjs');
 
 const logger = logger$1.default.get('sequelize', 'ops', 'all');
+// 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 getAllOperation = (models, definition, registry)=>{
     const { coordinate, options: { references, aggregations } } = definition;
     //#region Query
@@ -18,29 +40,64 @@ const 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 = QueryBuilder.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.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.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(existingIncludes, additionalIncludes);
             }
         }
         logger.default('Configured this Item Query', {
@@ -49,9 +106,11 @@ const 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 RowProcessor.processRow(row, coordinate.kta, references, aggregations, registry);
+            const processedRow = await RowProcessor.processRow(row, coordinate.kta, references, aggregations, registry, context);
             return core.validateKeys(processedRow, coordinate.kta);
         }));
     };
@@ -59,4 +118,4 @@ const getAllOperation = (models, definition, registry)=>{
 };
 
 exports.getAllOperation = getAllOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/ops/get.cjs

@@ -7,6 +7,7 @@ const logger$1 = require('../logger.cjs');
 const RowProcessor = require('../RowProcessor.cjs');
 const Library = require('@fjell/lib');
 const relationshipUtils = require('../util/relationshipUtils.cjs');
+const OperationContext = require('../OperationContext.cjs');
 
 const logger = logger$1.default.get('sequelize', 'ops', 'get');
 // Helper function to process composite key and build query options
@@ -75,11 +76,13 @@ const getGetOperation = (models, definition, registry)=>{
         if (!item) {
             throw new Library.NotFoundError('get', coordinate, key);
         } else {
-            return core.validateKeys(await RowProcessor.processRow(item, kta, references, aggregations, registry), kta);
+            // Get the current context from context manager
+            const context = OperationContext.contextManager.getCurrentContext();
+            return core.validateKeys(await RowProcessor.processRow(item, kta, references, aggregations, registry, context), kta);
         }
     };
     return get;
 };
 
 exports.getGetOperation = getGetOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=