@fjell/lib-sequelize 4.4.1 → 4.4.2

package/dist/cjs/ops/remove.cjs

@@ -6,8 +6,45 @@ const core = require('@fjell/core');
 const EventCoordinator = require('../EventCoordinator.cjs');
 const KeyMaster = require('../KeyMaster.cjs');
 const logger$1 = require('../logger.cjs');
+const relationshipUtils = require('../util/relationshipUtils.cjs');
 
 const logger = logger$1.default.get('sequelize', 'ops', 'remove');
+// Helper function to process composite key and build query options
+const processCompositeKey = (comKey, model, kta)=>{
+    const where = {
+        id: comKey.pk
+    };
+    const includes = [];
+    for (const locator of comKey.loc){
+        const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta);
+        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.path) {
+            // This requires a relationship traversal
+            where[relationshipInfo.path] = locator.lk;
+            if (relationshipInfo.includes) {
+                includes.push(...relationshipInfo.includes);
+            }
+        } else {
+            // This is a direct field
+            const fieldName = `${locator.kt}Id`;
+            where[fieldName] = locator.lk;
+        }
+    }
+    const result = {
+        where
+    };
+    if (includes.length > 0) {
+        result.include = includes;
+    }
+    return result;
+};
 const getRemoveOperation = (models, definition, // eslint-disable-next-line @typescript-eslint/no-unused-vars
 registry)=>{
     const { coordinate, options } = definition;
@@ -28,14 +65,16 @@ registry)=>{
         if (core.isPriKey(key)) {
             item = await model.findByPk(key.pk);
         } else if (core.isComKey(key)) {
-            var _comKey_loc_, _comKey_loc_1;
+            // This is a composite key, so we need to build a where clause based on the composite key's locators
             const comKey = key;
-            item = await model.findOne({
-                where: {
-                    id: comKey.pk,
-                    [(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
-                }
+            const queryOptions = processCompositeKey(comKey, model, kta);
+            logger.default('Composite key query', {
+                queryOptions
             });
+            item = await model.findOne(queryOptions);
+        }
+        if (!item) {
+            throw new Error(`Item not found for removal with key: ${core.abbrevIK(key)}`);
         }
         const isDeletedAttribute = model.getAttributes().isDeleted;
         const deletedAtAttribute = model.getAttributes().deletedAt;
@@ -51,14 +90,14 @@ registry)=>{
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
             });
-            returnItem = KeyMaster.addKey(returnItem, kta);
+            returnItem = KeyMaster.addKey(item, returnItem, kta);
             returnItem = EventCoordinator.populateEvents(returnItem);
         } else if (options.deleteOnRemove) {
             await (item === null || item === void 0 ? void 0 : item.destroy());
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
             });
-            returnItem = KeyMaster.addKey(returnItem, kta);
+            returnItem = KeyMaster.addKey(item, returnItem, kta);
             returnItem = EventCoordinator.populateEvents(returnItem);
         } else {
             throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
@@ -69,4 +108,4 @@ registry)=>{
 };
 
 exports.getRemoveOperation = getRemoveOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/ops/update.cjs

@@ -39,7 +39,9 @@ const getUpdateOperation = (models, definition, registry)=>{
         if (response) {
             // Remove the key and events
             let updateProps = KeyMaster.removeKey(item);
-            updateProps = EventCoordinator.removeEvents(item);
+            // TODO: We need the opposite of processRow, something to step down from fjell to database.
+            updateProps = EventCoordinator.extractEvents(updateProps);
+            updateProps = EventCoordinator.removeEvents(updateProps);
             logger.default('Response: %s', general.stringifyJSON(response));
             logger.default('Update Properties: %s', general.stringifyJSON(updateProps));
             // Update the object
@@ -56,4 +58,4 @@ const getUpdateOperation = (models, definition, registry)=>{
 };
 
 exports.getUpdateOperation = getUpdateOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/util/relationshipUtils.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+/* eslint-disable indent */ /**
+ * Helper function to build relationship chain includes
+ */ const buildRelationshipChain = (targetModel, kta, currentIndex, targetIndex)=>{
+    // Build the association path and validate relationships exist
+    const associationParts = [];
+    const modelChain = [
+        targetModel
+    ];
+    let currentModel = targetModel;
+    // Validate that all associations exist and build model chain
+    for(let i = currentIndex + 1; i <= targetIndex; i++){
+        const intermediateType = kta[i];
+        const associationName = intermediateType;
+        if (!currentModel.associations || !currentModel.associations[associationName]) {
+            return {
+                success: false
+            };
+        }
+        associationParts.push(associationName);
+        currentModel = currentModel.associations[associationName].target;
+        modelChain.push(currentModel);
+    }
+    // Build the full association path for the target field
+    const targetType = kta[targetIndex];
+    const associationPath = `$${associationParts.join('.')}.${targetType}Id$`;
+    // Build nested includes structure iteratively (clearer than recursion)
+    let deepestInclude = null;
+    // Build from the deepest level back to the root
+    for(let i = targetIndex; i > currentIndex; i--){
+        const currentType = kta[i];
+        const modelIndex = i - currentIndex;
+        const includeObj = {
+            model: modelChain[modelIndex],
+            as: currentType,
+            required: true
+        };
+        if (deepestInclude) {
+            includeObj.include = [
+                deepestInclude
+            ];
+        }
+        deepestInclude = includeObj;
+    }
+    const includes = deepestInclude ? [
+        deepestInclude
+    ] : [];
+    return {
+        success: true,
+        path: associationPath,
+        includes
+    };
+};
+/**
+ * Helper function to build relationship path for a locator
+ * @param includeIsDirect Whether to include the isDirect flag in the result
+ */ const buildRelationshipPath = (targetModel, locatorType, kta, includeIsDirect = false)=>{
+    // First check if the field exists directly
+    const directFieldName = `${locatorType}Id`;
+    const attributes = targetModel.getAttributes();
+    if (attributes && attributes[directFieldName]) {
+        const result = {
+            found: true
+        };
+        if (includeIsDirect) {
+            result.isDirect = true;
+        }
+        return result;
+    }
+    // If not direct, look for relationship path
+    const targetIndex = kta.indexOf(locatorType);
+    if (targetIndex === -1) {
+        const result = {
+            found: false
+        };
+        if (includeIsDirect) {
+            result.isDirect = false;
+        }
+        return result;
+    }
+    const currentIndex = 0; // We're always looking from the base model
+    if (targetIndex <= currentIndex) {
+        const result = {
+            found: false
+        };
+        if (includeIsDirect) {
+            result.isDirect = false;
+        }
+        return result;
+    }
+    const chainResult = buildRelationshipChain(targetModel, kta, currentIndex, targetIndex);
+    if (chainResult.success) {
+        const result = {
+            found: true,
+            path: chainResult.path,
+            includes: chainResult.includes
+        };
+        if (includeIsDirect) {
+            result.isDirect = false;
+        }
+        return result;
+    }
+    const result = {
+        found: false
+    };
+    if (includeIsDirect) {
+        result.isDirect = false;
+    }
+    return result;
+};
+
+exports.buildRelationshipChain = buildRelationshipChain;
+exports.buildRelationshipPath = buildRelationshipPath;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsYXRpb25zaGlwVXRpbHMuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/EventCoordinator.js

@@ -18,6 +18,24 @@ const populateEvents = (item)=>{
     item.events = events;
     return item;
 };
+const extractEvents = (item)=>{
+    logger.default('Extracting Events to database fields', {
+        item
+    });
+    if (item.events) {
+        var _item_events_created, _item_events_updated, _item_events_deleted;
+        if ((_item_events_created = item.events.created) === null || _item_events_created === void 0 ? void 0 : _item_events_created.at) {
+            item.createdAt = item.events.created.at;
+        }
+        if ((_item_events_updated = item.events.updated) === null || _item_events_updated === void 0 ? void 0 : _item_events_updated.at) {
+            item.updatedAt = item.events.updated.at;
+        }
+        if ((_item_events_deleted = item.events.deleted) === null || _item_events_deleted === void 0 ? void 0 : _item_events_deleted.at) {
+            item.deletedAt = item.events.deleted.at;
+        }
+    }
+    return item;
+};
 const removeEvents = (item)=>{
     logger.default('Removing Events', {
         item
@@ -26,5 +44,5 @@ const removeEvents = (item)=>{
     return item;
 };
 
-export { populateEvents, removeEvents };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXZlbnRDb29yZGluYXRvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+export { extractEvents, populateEvents, removeEvents };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRXZlbnRDb29yZGluYXRvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/KeyMaster.js

@@ -1,6 +1,41 @@
 import LibLogger from './logger.js';
+import { buildRelationshipPath } from './util/relationshipUtils.js';
 
 const logger = LibLogger.get('sequelize', 'KeyMaster');
+// Helper function to extract location key value from item
+const extractLocationKeyValue = (model, item, locatorType, kta)=>{
+    logger.default('Extracting location key value', {
+        locatorType,
+        kta
+    });
+    const relationshipInfo = buildRelationshipPath(model, locatorType, kta, true);
+    if (!relationshipInfo.found) {
+        throw new Error(`Location key '${locatorType}' cannot be resolved on model '${model.name}' or through its relationships.`);
+    }
+    if (relationshipInfo.isDirect) {
+        // Direct foreign key field
+        const foreignKeyField = `${locatorType}Id`;
+        const value = item[foreignKeyField];
+        if (typeof value === 'undefined' || value === null) {
+            throw new Error(`Direct foreign key field '${foreignKeyField}' is missing or null in item`);
+        }
+        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;
+        }
+        // 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
+        const foreignKeyField = `${locatorType}Id`;
+        if (typeof item[foreignKeyField] !== 'undefined' && item[foreignKeyField] !== null) {
+            return item[foreignKeyField];
+        }
+        throw new Error(`Unable to extract location key for '${locatorType}'. Neither the relationship object nor direct foreign key is available.`);
+    }
+};
 const removeKey = (item)=>{
     logger.default('Removing Key', {
         item
@@ -35,11 +70,13 @@ const removeKey = (item)=>{
 //   }
 //   return item;
 // }
-const addKey = (item, keyTypes)=>{
+const addKey = (model, item, keyTypes)=>{
     logger.default('Adding Key', {
         item
     });
     const key = {};
+    const modelClass = model.constructor;
+    const primaryKeyAttr = modelClass.primaryKeyAttribute;
     if (Array.isArray(keyTypes) && keyTypes.length > 1) {
         const type = [
             ...keyTypes
@@ -47,33 +84,34 @@ const addKey = (item, keyTypes)=>{
         const pkType = type.shift();
         Object.assign(key, {
             kt: pkType,
-            pk: item.id
+            pk: item[primaryKeyAttr]
         });
-        // TODO: This is really just for primary items
-        if (type.length === 1) {
-            // TODO: This should be looking at the model to get the primary key of the reference item or association
-            const locKeyTypeId = type[0] + 'Id';
-            Object.assign(key, {
-                loc: [
-                    {
-                        kt: type[0],
-                        lk: item[locKeyTypeId]
-                    }
-                ]
-            });
-        } else if (type.length === 2) {
-            throw new Error('Not implemented');
-        } else if (type.length === 3) {
-            throw new Error('Not implemented');
-        } else if (type.length === 4) {
-            throw new Error('Not implemented');
-        } else if (type.length === 5) {
-            throw new Error('Not implemented');
+        // Build location keys for composite key
+        const locationKeys = [];
+        for (const locatorType of type){
+            try {
+                const lk = extractLocationKeyValue(modelClass, item, locatorType, keyTypes);
+                locationKeys.push({
+                    kt: locatorType,
+                    lk
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.error(`Failed to extract location key for '${locatorType}'`, {
+                    error: errorMessage,
+                    item,
+                    keyTypes
+                });
+                throw error;
+            }
         }
+        Object.assign(key, {
+            loc: locationKeys
+        });
     } else {
         Object.assign(key, {
             kt: keyTypes[0],
-            pk: item.id
+            pk: item[primaryKeyAttr]
         });
     }
     Object.assign(item, {
@@ -83,4 +121,4 @@ const addKey = (item, keyTypes)=>{
 };
 
 export { addKey, removeKey };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/Operations.js

@@ -10,12 +10,12 @@ const createOperations = (models, definition, registry)=>{
     const operations = {};
     operations.all = getAllOperation(models, definition, registry);
     operations.one = getOneOperation(models, definition, registry);
-    operations.create = getCreateOperation();
+    operations.create = getCreateOperation(models, definition, registry);
     operations.update = getUpdateOperation(models, definition, registry);
     operations.get = getGetOperation(models, definition, registry);
     operations.remove = getRemoveOperation(models, definition);
     operations.find = getFindOperation(models, definition, registry);
-    operations.upsert = ()=>{
+    operations.upsert = async ()=>{
         throw new Error('Not implemented');
     };
     return operations;

package/dist/es/QueryBuilder.js

@@ -80,7 +80,8 @@ const addReferenceQueries = (options, references, model)=>{
     return options;
 };
 const addCompoundCondition = (options, compoundCondition, model)=>{
-    const where = {};
+    // Ensure options.where exists
+    options.where = options.where || {};
     let compoundOp;
     const compoundType = compoundCondition.compoundType;
     if (compoundType === "AND") {
@@ -96,36 +97,135 @@ const addCompoundCondition = (options, compoundCondition, model)=>{
             throw new Error('Nest Compound conditions not supported');
         }
     });
-    where[compoundOp] = conditions;
-    options.where = where;
+    // Merge with existing where conditions instead of replacing
+    if (Object.keys(options.where).length > 0) {
+        // If there are existing conditions, wrap everything in an AND
+        options.where = {
+            [Op.and]: [
+                options.where,
+                {
+                    [compoundOp]: conditions
+                }
+            ]
+        };
+    } else {
+        // If no existing conditions, just set the compound condition
+        options.where[compoundOp] = conditions;
+    }
     return options;
 };
-const addCondition = (conditions, condition, model)=>{
-    let conditionOp;
+const getSequelizeOperator = (operator)=>{
+    if (operator === '==') {
+        return Op.eq;
+    } else if (operator === '<') {
+        return Op.lt;
+    } else if (operator === '>') {
+        return Op.gt;
+    } else if (operator === '<=') {
+        return Op.lte;
+    } else if (operator === '>=') {
+        return Op.gte;
+    } else if (operator === 'in') {
+        return Op.in;
+    } else {
+        throw new Error(`Operator ${operator} not supported`);
+    }
+};
+const addAssociationCondition = (conditions, condition, model)=>{
+    const [associationName, attributeName] = condition.column.split('.', 2);
+    // Check if the association exists on the model
+    if (!model.associations || !model.associations[associationName]) {
+        throw new Error(`Association ${associationName} not found on model ${model.name}`);
+    }
+    const association = model.associations[associationName];
+    const associatedModel = association.target;
+    // Check if the attribute exists on the associated model
+    if (!associatedModel.getAttributes()[attributeName]) {
+        throw new Error(`Attribute ${attributeName} not found on associated model ${associatedModel.name} for association ${associationName}`);
+    }
+    // Use Sequelize's $association.attribute$ syntax for querying associated models
+    const sequelizeAssociationColumn = `$${associationName}.${attributeName}$`;
+    const conditionOp = getSequelizeOperator(condition.operator);
+    conditions[sequelizeAssociationColumn] = {
+        [conditionOp]: condition.value
+    };
+    return conditions;
+};
+const addAttributeCondition = (conditions, condition, model)=>{
     const conditionColumn = condition.column;
     if (!model.getAttributes()[conditionColumn]) {
         throw new Error(`Condition column ${conditionColumn} not found on model ${model.name}`);
     }
-    if (condition.operator === '==') {
-        conditionOp = Op.eq;
-    } else if (condition.operator === '<') {
-        conditionOp = Op.lt;
-    } else if (condition.operator === '>') {
-        conditionOp = Op.gt;
-    } else if (condition.operator === '<=') {
-        conditionOp = Op.lte;
-    } else if (condition.operator === '>=') {
-        conditionOp = Op.gte;
-    } else if (condition.operator === 'in') {
-        conditionOp = Op.in;
-    } else {
-        throw new Error(`Operator ${condition.operator} not supported`);
-    }
+    const conditionOp = getSequelizeOperator(condition.operator);
     conditions[conditionColumn] = {
         [conditionOp]: condition.value
     };
     return conditions;
 };
+const addCondition = (conditions, condition, model)=>{
+    const conditionColumn = condition.column;
+    // Check if this is an association query (contains a dot)
+    if (conditionColumn.includes('.')) {
+        return addAssociationCondition(conditions, condition, model);
+    }
+    // Handle regular column queries
+    return addAttributeCondition(conditions, condition, model);
+};
+const collectAssociationsFromConditions = (conditions)=>{
+    const associations = new Set();
+    const processObject = (obj)=>{
+        if (typeof obj === 'object' && obj !== null) {
+            // Check string keys
+            Object.keys(obj).forEach((key)=>{
+                // Check if this is an association reference ($association.attribute$)
+                if (typeof key === 'string' && key.startsWith('$') && key.endsWith('$') && key.includes('.')) {
+                    const associationName = key.substring(1, key.indexOf('.'));
+                    associations.add(associationName);
+                }
+                // Recursively process nested objects
+                if (typeof obj[key] === 'object') {
+                    processObject(obj[key]);
+                }
+            });
+            // Also check Symbol keys (for compound conditions like Op.and, Op.or)
+            Object.getOwnPropertySymbols(obj).forEach((symbol)=>{
+                if (typeof obj[symbol] === 'object') {
+                    processObject(obj[symbol]);
+                }
+            });
+        }
+        // Handle arrays (for compound conditions that might be arrays)
+        if (Array.isArray(obj)) {
+            obj.forEach((item)=>{
+                if (typeof item === 'object') {
+                    processObject(item);
+                }
+            });
+        }
+    };
+    processObject(conditions);
+    return associations;
+};
+const addAssociationIncludes = (options, model)=>{
+    // Collect all association names used in conditions
+    const referencedAssociations = collectAssociationsFromConditions(options.where);
+    if (referencedAssociations.size > 0) {
+        options.include = options.include || [];
+        // Add each referenced association to the include array
+        referencedAssociations.forEach((associationName)=>{
+            // Check if this association is already included
+            const alreadyIncluded = options.include.some((inc)=>typeof inc === 'string' && inc === associationName || typeof inc === 'object' && inc.association === associationName);
+            if (!alreadyIncluded && model.associations && model.associations[associationName]) {
+                options.include.push({
+                    model: model.associations[associationName].target,
+                    as: associationName,
+                    required: false // Use LEFT JOIN so records without associations are still returned
+                });
+            }
+        });
+    }
+    return options;
+};
 const buildQuery = (itemQuery, model)=>{
     logger.default('build', {
         itemQuery
@@ -175,8 +275,10 @@ const buildQuery = (itemQuery, model)=>{
             ];
         });
     }
+    // Add includes for any associations referenced in conditions
+    options = addAssociationIncludes(options, model);
     return options;
 };
 
 export { addCompoundCondition, addCondition, buildQuery };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/RowProcessor.js

@@ -14,7 +14,7 @@ const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefini
         plain: true
     });
     logger.default('Adding Key to Item with Key Types: %s', stringifyJSON(keyTypes));
-    item = addKey(item, keyTypes);
+    item = addKey(row, item, keyTypes);
     item = populateEvents(item);
     logger.default('Key Added to Item: %s', stringifyJSON(item.key));
     if (referenceDefinitions && referenceDefinitions.length > 0) {