@fjell/lib-sequelize 4.4.74 → 4.4.76

package/dist/index.js

@@ -173,7 +173,7 @@ var addReferenceQueries = (options, references, model) => {
   });
   return options;
 };
-var addCompoundCondition = (options, compoundCondition, model) => {
+var addCompoundCondition = (options, compoundCondition, model, references, allReferences, registry) => {
   options.where = options.where || {};
   let compoundOp;
   const compoundType = compoundCondition.compoundType;
@@ -186,7 +186,7 @@ var addCompoundCondition = (options, compoundCondition, model) => {
   let conditions = {};
   compoundCondition.conditions.forEach((condition) => {
     if (isCondition(condition)) {
-      conditions = addCondition(conditions, condition, model);
+      conditions = addCondition(conditions, condition, model, options, references, allReferences, registry);
     } else {
       throw new Error(`Nested Compound conditions not supported. Model: '${model.name}', Compound condition: ${stringifyJSON(compoundCondition)}, Nested condition: ${stringifyJSON(condition)}`);
     }
@@ -216,12 +216,267 @@ var getSequelizeOperator = (operator) => {
     return Op.gte;
   } else if (operator === "in") {
     return Op.in;
+  } else if (operator === "!=") {
+    return Op.ne;
   } else {
     throw new Error(`Operator ${operator} not supported`);
   }
 };
-var addAssociationCondition = (conditions, condition, model) => {
-  const [associationName, attributeName] = condition.column.split(".", 2);
+var findReferenceByProperty = (propertyName, references) => {
+  if (!references || references.length === 0) {
+    return null;
+  }
+  return references.find((ref) => ref.property === propertyName) || null;
+};
+var getReferencesFromRegistry = (model, registry) => {
+  if (!registry) {
+    return;
+  }
+  const modelName = model.name.toLowerCase();
+  try {
+    const library = registry.get([modelName]);
+    if (library && library.options && library.options.references) {
+      return library.options.references;
+    }
+  } catch {
+  }
+  return;
+};
+var buildNestedInclude = (pathSegments, currentModel, references, allReferences, registry, isFirstSegment = true) => {
+  if (pathSegments.length === 0) {
+    return null;
+  }
+  const [firstSegment, ...remainingSegments] = pathSegments;
+  if (isFirstSegment) {
+    const refDef = findReferenceByProperty(firstSegment, references);
+    if (!refDef) {
+      logger3.debug(`[buildNestedInclude] No reference definition found for property '${firstSegment}'`, {
+        model: currentModel.name,
+        property: firstSegment,
+        availableReferences: references?.map((r) => r.property) || [],
+        referencesCount: references?.length || 0
+      });
+      return null;
+    }
+    logger3.debug(`[buildNestedInclude] Found reference definition for property '${firstSegment}'`, {
+      model: currentModel.name,
+      property: firstSegment,
+      refDef: { property: refDef.property, column: refDef.column, kta: refDef.kta }
+    });
+  }
+  const association = currentModel.associations?.[firstSegment];
+  if (!association) {
+    if (isFirstSegment) {
+      logger3.debug(`[buildNestedInclude] Reference property '${firstSegment}' found but no Sequelize association exists`, {
+        model: currentModel.name,
+        property: firstSegment,
+        availableAssociations: Object.keys(currentModel.associations || {}),
+        associationsObject: currentModel.associations ? Object.keys(currentModel.associations) : "undefined"
+      });
+    }
+    return null;
+  }
+  logger3.debug(`[buildNestedInclude] Found Sequelize association for '${firstSegment}'`, {
+    model: currentModel.name,
+    property: firstSegment,
+    associationType: association.associationType,
+    targetModel: association.target?.name
+  });
+  const targetModel = association.target;
+  const includeConfig = {
+    model: targetModel,
+    as: firstSegment,
+    required: true
+    // Use INNER JOIN for filtering conditions
+  };
+  if (remainingSegments.length === 0) {
+    return { include: includeConfig, associationName: firstSegment };
+  }
+  let nestedReferences = getReferencesFromRegistry(targetModel, registry);
+  if (!nestedReferences) {
+    nestedReferences = allReferences?.get(targetModel.name);
+  }
+  const nestedInclude = buildNestedInclude(
+    remainingSegments,
+    targetModel,
+    nestedReferences,
+    allReferences,
+    registry,
+    false
+    // Subsequent segments don't require reference definition match
+  );
+  if (nestedInclude) {
+    includeConfig.include = [nestedInclude.include];
+    return { include: includeConfig, associationName: firstSegment };
+  }
+  const [nextSegment, ...restSegments] = remainingSegments;
+  const nextAssociation = targetModel.associations?.[nextSegment];
+  if (!nextAssociation) {
+    return null;
+  }
+  if (restSegments.length === 0) {
+    includeConfig.include = [{
+      model: nextAssociation.target,
+      as: nextSegment,
+      required: true
+    }];
+    return { include: includeConfig, associationName: firstSegment };
+  }
+  const deeperInclude = buildNestedInclude(
+    remainingSegments,
+    targetModel,
+    nestedReferences,
+    allReferences,
+    registry,
+    false
+  );
+  if (!deeperInclude) {
+    return null;
+  }
+  includeConfig.include = [deeperInclude.include];
+  return { include: includeConfig, associationName: firstSegment };
+};
+var detectReferenceJoin = (fieldPath, model, references, allReferences, registry) => {
+  const pathSegments = fieldPath.split(".");
+  if (pathSegments.length < 2) {
+    return null;
+  }
+  for (let i = pathSegments.length - 1; i >= 1; i--) {
+    const referencePath = pathSegments.slice(0, i);
+    const attributePath = pathSegments.slice(i).join(".");
+    const includeResult = buildNestedInclude(referencePath, model, references, allReferences, registry);
+    if (!includeResult) {
+      continue;
+    }
+    let finalModel = model;
+    for (const segment of referencePath) {
+      const assoc = finalModel.associations?.[segment];
+      if (!assoc) {
+        break;
+      }
+      finalModel = assoc.target;
+    }
+    const attributeSegments = attributePath.split(".");
+    if (attributeSegments.length !== 1 || !finalModel.getAttributes()[attributePath]) {
+      continue;
+    }
+    logger3.debug(`Auto-detected reference join for condition '${fieldPath}'`, {
+      model: model.name,
+      referencePath: referencePath.join("."),
+      attributePath,
+      associationName: includeResult.associationName
+    });
+    return {
+      include: includeResult.include,
+      attributePath,
+      associationName: includeResult.associationName
+    };
+  }
+  return null;
+};
+var addIncludeIfNotExists = (options, newInclude) => {
+  options.include = options.include || [];
+  const exists = options.include.some((inc) => {
+    if (typeof inc === "string") {
+      return inc === newInclude.as;
+    }
+    if (inc.model === newInclude.model && inc.as === newInclude.as) {
+      if (newInclude.include && inc.include) {
+        newInclude.include.forEach((nested) => {
+          const nestedExists = inc.include.some(
+            (existingNested) => existingNested.model === nested.model && existingNested.as === nested.as
+          );
+          if (!nestedExists) {
+            inc.include.push(nested);
+          }
+        });
+      } else if (newInclude.include) {
+        inc.include = newInclude.include;
+      }
+      return true;
+    }
+    return false;
+  });
+  if (!exists) {
+    options.include.push(newInclude);
+  }
+};
+var addAssociationCondition = (conditions, condition, model, options, references, allReferences, registry) => {
+  const fieldPath = condition.column;
+  const pathSegments = fieldPath.split(".");
+  logger3.debug(`[addAssociationCondition] Processing condition '${fieldPath}'`, {
+    model: model.name,
+    hasReferences: !!references,
+    referencesCount: references?.length || 0,
+    pathSegmentsLength: pathSegments.length,
+    pathSegments,
+    willAttemptDetection: !!(references && pathSegments.length >= 2)
+  });
+  if (references && pathSegments.length >= 2) {
+    logger3.debug(`[addAssociationCondition] Attempting reference join detection for '${fieldPath}'`, {
+      model: model.name,
+      referencesCount: references.length,
+      references: references.map((r) => ({ property: r.property, column: r.column })),
+      pathSegments,
+      hasOptions: !!options
+    });
+    const referenceJoin = detectReferenceJoin(fieldPath, model, references, allReferences, registry);
+    if (!referenceJoin) {
+      logger3.debug(`[addAssociationCondition] Reference join detection returned null for '${fieldPath}'`, {
+        model: model.name,
+        fieldPath
+      });
+    }
+    if (referenceJoin && options) {
+      logger3.debug(`[addAssociationCondition] Reference join detected successfully for '${fieldPath}'`, {
+        model: model.name,
+        associationName: referenceJoin.associationName,
+        attributePath: referenceJoin.attributePath
+      });
+      addIncludeIfNotExists(options, referenceJoin.include);
+      const attributeName2 = referenceJoin.attributePath;
+      const associationPath = fieldPath.substring(0, fieldPath.length - attributeName2.length - 1);
+      const sequelizeAssociationColumn2 = `$${associationPath}.${attributeName2}$`;
+      const finalPathSegments = associationPath.split(".");
+      let currentModel = model;
+      let targetModel = model;
+      for (const segment of finalPathSegments) {
+        const assoc = currentModel.associations?.[segment];
+        if (!assoc) {
+          throw new Error(`Association ${segment} not found on model ${currentModel.name}`);
+        }
+        targetModel = assoc.target;
+        currentModel = targetModel;
+      }
+      if (!targetModel.getAttributes()[attributeName2]) {
+        throw new Error(`Attribute ${attributeName2} not found on associated model ${targetModel.name} for path ${associationPath}`);
+      }
+      if (condition.value === null) {
+        if (condition.operator === "==" || !condition.operator) {
+          logger3.trace(`[QueryBuilder] Setting reference condition: ${sequelizeAssociationColumn2} IS NULL`);
+          conditions[sequelizeAssociationColumn2] = {
+            [Op.is]: null
+          };
+        } else if (condition.operator === "!=") {
+          logger3.trace(`[QueryBuilder] Setting reference condition: ${sequelizeAssociationColumn2} IS NOT NULL`);
+          conditions[sequelizeAssociationColumn2] = {
+            [Op.not]: null
+          };
+        } else {
+          logger3.error(`Operator ${condition.operator} cannot be used with null value on reference`, { condition });
+          throw new Error(`Operator ${condition.operator} cannot be used with null value. Use '==' for IS NULL or '!=' for IS NOT NULL.`);
+        }
+        return conditions;
+      }
+      const conditionOp2 = getSequelizeOperator(condition.operator);
+      logger3.trace(`[QueryBuilder] Setting reference condition: ${sequelizeAssociationColumn2} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
+      conditions[sequelizeAssociationColumn2] = {
+        [conditionOp2]: condition.value
+      };
+      return conditions;
+    }
+  }
+  const [associationName, attributeName] = fieldPath.split(".", 2);
   if (!model.associations || !model.associations[associationName]) {
     throw new Error(`Association ${associationName} not found on model ${model.name}`);
   }
@@ -284,10 +539,10 @@ var addAttributeCondition = (conditions, condition, model) => {
   };
   return conditions;
 };
-var addCondition = (conditions, condition, model) => {
+var addCondition = (conditions, condition, model, options, references, allReferences, registry) => {
   const conditionColumn = condition.column;
   if (conditionColumn.includes(".")) {
-    return addAssociationCondition(conditions, condition, model);
+    return addAssociationCondition(conditions, condition, model, options, references, allReferences, registry);
   }
   return addAttributeCondition(conditions, condition, model);
 };
@@ -341,14 +596,105 @@ var addAssociationIncludes = (options, model) => {
   }
   return options;
 };
-var buildQuery = (itemQuery, model) => {
+var addReferenceIncludes = (options, model, referenceDefinitions) => {
+  if (!referenceDefinitions || referenceDefinitions.length === 0) {
+    return { options, includedReferences: [] };
+  }
+  const includedReferences = [];
+  options.include = options.include || [];
+  for (const refDef of referenceDefinitions) {
+    const association = model.associations && model.associations[refDef.property];
+    if (association) {
+      const alreadyIncluded = options.include.some(
+        (inc) => typeof inc === "string" && inc === refDef.property || typeof inc === "object" && inc.as === refDef.property
+      );
+      if (!alreadyIncluded) {
+        logger3.default(`Auto-detected association for reference '${refDef.property}' - using INCLUDE to prevent N+1`, {
+          property: refDef.property,
+          associationType: association.associationType,
+          targetModel: association.target.name
+        });
+        options.include.push({
+          model: association.target,
+          as: refDef.property,
+          required: false
+          // Use LEFT JOIN to preserve items without references
+        });
+        includedReferences.push(refDef.property);
+      } else {
+        logger3.debug(`Association '${refDef.property}' already included in query`, {
+          property: refDef.property
+        });
+        includedReferences.push(refDef.property);
+      }
+    } else {
+      logger3.debug(`No association found for reference '${refDef.property}' - will use separate query`, {
+        property: refDef.property,
+        availableAssociations: Object.keys(model.associations || {})
+      });
+    }
+  }
+  return { options, includedReferences };
+};
+var addAggregationIncludes = (options, model, aggregationDefinitions) => {
+  if (!aggregationDefinitions || aggregationDefinitions.length === 0) {
+    return { options, includedAggregations: [] };
+  }
+  const includedAggregations = [];
+  options.include = options.include || [];
+  for (const aggDef of aggregationDefinitions) {
+    const association = model.associations && model.associations[aggDef.property];
+    if (association) {
+      const alreadyIncluded = options.include.some(
+        (inc) => typeof inc === "string" && inc === aggDef.property || typeof inc === "object" && inc.as === aggDef.property
+      );
+      if (!alreadyIncluded) {
+        logger3.default(`Auto-detected association for aggregation '${aggDef.property}' - using INCLUDE to prevent N+1`, {
+          property: aggDef.property,
+          associationType: association.associationType,
+          targetModel: association.target.name
+        });
+        options.include.push({
+          model: association.target,
+          as: aggDef.property,
+          required: false
+          // Use LEFT JOIN to preserve items without aggregations
+        });
+        includedAggregations.push(aggDef.property);
+      } else {
+        logger3.debug(`Association '${aggDef.property}' already included in query`, {
+          property: aggDef.property
+        });
+        includedAggregations.push(aggDef.property);
+      }
+    } else {
+      logger3.debug(`No association found for aggregation '${aggDef.property}' - will use separate query`, {
+        property: aggDef.property,
+        availableAssociations: Object.keys(model.associations || {})
+      });
+    }
+  }
+  return { options, includedAggregations };
+};
+var buildQuery = (itemQuery, model, references, registry) => {
   logger3.default(`QueryBuilder build called with itemQuery: ${stringifyJSON(itemQuery)}`);
+  logger3.debug(`[buildQuery] Parameters:`, {
+    modelName: model.name,
+    referencesCount: references?.length || 0,
+    references: references?.map((r) => ({ property: r.property, column: r.column })) || [],
+    hasRegistry: !!registry,
+    hasCompoundCondition: !!itemQuery.compoundCondition
+  });
   let options = {
     where: {}
   };
+  const allReferences = /* @__PURE__ */ new Map();
+  if (references) {
+    allReferences.set(model.name, references);
+  }
   if (itemQuery.compoundCondition) {
     logger3.default(`QueryBuilder adding conditions: ${stringifyJSON(itemQuery.compoundCondition)}`);
-    options = addCompoundCondition(options, itemQuery.compoundCondition, model);
+    options = addCompoundCondition(options, itemQuery.compoundCondition, model, references, allReferences, registry);
   }
   if (model.getAttributes().deletedAt || model.getAttributes().isDeleted) {
     options = addDeleteQuery(options, model);
@@ -659,12 +1005,12 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
       pk: columnValue,
       loc: []
     };
-    libLogger3.debug("Using empty loc array for composite item reference", {
+    libLogger3.default("Using empty loc array for composite item reference", {
       kta: referenceDefinition.kta,
       property: referenceDefinition.property
     });
   }
-  libLogger3.debug("Created reference key", {
+  libLogger3.default("Created reference key", {
     itemKey,
     isCompositeItem,
     hasLocationColumns: !!referenceDefinition.locationColumns,
@@ -676,7 +1022,7 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
       libLogger3.debug("Using cached reference", { itemKey, property: referenceDefinition.property });
       referencedItem = context.getCached(itemKey);
     } else if (context.isInProgress(itemKey)) {
-      libLogger3.debug("Circular dependency detected, creating reference placeholder", {
+      libLogger3.default("Circular dependency detected, creating reference placeholder", {
         itemKey,
         property: referenceDefinition.property
       });
@@ -839,7 +1185,7 @@ function addAggsToItem(item, aggregationDefinitions) {
     if (typeof aggregationValue !== "undefined") {
       aggs[aggDef.property] = aggregationValue;
       delete result[aggDef.property];
-      libLogger2.debug(`Moved aggregation '${aggDef.property}' to aggs structure`, {
+      libLogger2.default(`Moved aggregation '${aggDef.property}' to aggs structure`, {
         property: aggDef.property,
         hasValue: typeof aggregationValue !== "undefined",
         valueType: Array.isArray(aggregationValue) ? "array" : typeof aggregationValue
@@ -879,7 +1225,7 @@ function removeAggsFromItem(item, aggregationDefinitions) {
 
 // src/RowProcessor.ts
 var logger6 = logger_default.get("sequelize", "RowProcessor");
-var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context) => {
+var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context, includedAggregations, includedReferences) => {
   logger6.default("Processing Row", { row });
   const operationContext = context || createOperationContext();
   return contextManager.withContext(operationContext, async () => {
@@ -892,9 +1238,22 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
     try {
       if (referenceDefinitions && referenceDefinitions.length > 0) {
         const referenceStartTime = typeof performance !== "undefined" ? performance.now() : Date.now();
-        const referencePromises = referenceDefinitions.map((referenceDefinition) => {
-          logger6.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
-          return buildSequelizeReference(item, referenceDefinition, registry, operationContext);
+        const referencePromises = referenceDefinitions.map(async (referenceDefinition) => {
+          const alreadyLoaded = includedReferences && includedReferences.includes(referenceDefinition.property) && typeof item[referenceDefinition.property] !== "undefined";
+          if (alreadyLoaded) {
+            logger6.default(
+              `Skipping buildSequelizeReference for '${referenceDefinition.property}' - already loaded via INCLUDE (N+1 prevention)`,
+              {
+                property: referenceDefinition.property,
+                itemType: item.key.kt,
+                hasData: item[referenceDefinition.property] ? "loaded" : "undefined"
+              }
+            );
+            return item;
+          } else {
+            logger6.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
+            return buildSequelizeReference(item, referenceDefinition, registry, operationContext);
+          }
         });
         await Promise.all(referencePromises);
         const referenceDuration = (typeof performance !== "undefined" ? performance.now() : Date.now()) - referenceStartTime;
@@ -904,8 +1263,20 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
       }
       if (aggregationDefinitions && aggregationDefinitions.length > 0) {
         for (const aggregationDefinition of aggregationDefinitions) {
-          logger6.default("Processing Aggregation for %s from %s", item.key.kt, stringifyJSON(aggregationDefinition.kta));
-          item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
+          const alreadyLoaded = includedAggregations && includedAggregations.includes(aggregationDefinition.property) && typeof item[aggregationDefinition.property] !== "undefined";
+          if (alreadyLoaded) {
+            logger6.default(
+              `Skipping buildAggregation for '${aggregationDefinition.property}' - already loaded via INCLUDE (N+1 prevention)`,
+              {
+                property: aggregationDefinition.property,
+                itemType: item.key.kt,
+                hasData: Array.isArray(item[aggregationDefinition.property]) ? `${item[aggregationDefinition.property].length} items` : "single item"
+              }
+            );
+          } else {
+            logger6.default("Processing Aggregation for %s from %s", item.key.kt, stringifyJSON(aggregationDefinition.kta));
+            item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
+          }
         }
       }
       operationContext.setCached(item.key, item);
@@ -914,11 +1285,11 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
     }
     if (referenceDefinitions && referenceDefinitions.length > 0) {
       item = addRefsToSequelizeItem(item, referenceDefinitions);
-      logger6.debug("Added refs structure to item (transparent wrapper)", { key: item.key });
+      logger6.default("Added refs structure to item (transparent wrapper)", { key: item.key });
     }
     if (aggregationDefinitions && aggregationDefinitions.length > 0) {
       item = addAggsToItem(item, aggregationDefinitions);
-      logger6.debug("Added aggs structure to item (transparent wrapper)", { key: item.key });
+      logger6.default("Added aggs structure to item (transparent wrapper)", { key: item.key });
     }
     logger6.default("Processed Row: %j", stringifyJSON(item));
     return item;
@@ -1117,8 +1488,57 @@ function transformSequelizeError(error, itemType, key, modelName, itemData) {
   return error;
 }
 
+// src/metrics/QueryMetrics.ts
+var logger7 = logger_default.get("sequelize", "metrics", "QueryMetrics");
+var QueryMetrics = class {
+  totalQueryCount = 0;
+  queriesByModel = /* @__PURE__ */ new Map();
+  LOG_INTERVAL = 10;
+  /**
+   * Records a query execution for a given model
+   * @param modelName - The name of the Sequelize model the query was executed against
+   */
+  recordQuery(modelName) {
+    this.totalQueryCount++;
+    const currentCount = this.queriesByModel.get(modelName) || 0;
+    this.queriesByModel.set(modelName, currentCount + 1);
+    if (this.totalQueryCount % this.LOG_INTERVAL === 0) {
+      const modelBreakdown = Array.from(this.queriesByModel.entries()).map(([model, count]) => `${model}: ${count}`).join(", ");
+      logger7.debug(
+        `Query execution count: ${this.totalQueryCount} total queries. Breakdown by model: ${modelBreakdown || "none"}`
+      );
+    }
+  }
+  /**
+   * Gets the total number of queries executed
+   */
+  getTotalQueryCount() {
+    return this.totalQueryCount;
+  }
+  /**
+   * Gets the number of queries executed for a specific model
+   */
+  getQueryCountForModel(modelName) {
+    return this.queriesByModel.get(modelName) || 0;
+  }
+  /**
+   * Gets a map of all model query counts
+   */
+  getQueriesByModel() {
+    return new Map(this.queriesByModel);
+  }
+  /**
+   * Resets all metrics (useful for testing)
+   */
+  reset() {
+    this.totalQueryCount = 0;
+    this.queriesByModel.clear();
+  }
+};
+var queryMetrics = new QueryMetrics();
+
 // src/ops/all.ts
-var logger7 = logger_default.get("sequelize", "ops", "all");
+var logger8 = logger_default.get("sequelize", "ops", "all");
 var mergeIncludes = (existingIncludes, newIncludes) => {
   const mergedIncludes = [...existingIncludes];
   for (const newInclude of newIncludes) {
@@ -1145,10 +1565,22 @@ var getAllOperation = (models, definition, registry) => {
     async (itemQuery, locations, allOptions) => {
       try {
         const locs = locations ?? [];
-        logger7.debug(`ALL operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
+        logger8.debug(`ALL operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
         const loc = locs;
         const model = models[0];
-        const options = buildQuery(itemQuery ?? {}, model);
+        let options = buildQuery(itemQuery ?? {}, model, references, registry);
+        const { options: optionsWithRefs, includedReferences } = addReferenceIncludes(
+          options,
+          model,
+          references || []
+        );
+        options = optionsWithRefs;
+        const { options: optionsWithAggs, includedAggregations } = addAggregationIncludes(
+          options,
+          model,
+          aggregations || []
+        );
+        options = optionsWithAggs;
         if (loc.length > 0) {
           const { kta } = coordinate;
           const directLocations = [];
@@ -1158,7 +1590,7 @@ var getAllOperation = (models, definition, registry) => {
             const relationshipInfo = 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.`;
-              logger7.error(errorMessage, { locations: loc, kta });
+              logger8.error(errorMessage, { locations: loc, kta });
               throw new Error(errorMessage);
             }
             if (relationshipInfo.isDirect) {
@@ -1169,31 +1601,31 @@ var getAllOperation = (models, definition, registry) => {
           }
           for (const locKey of directLocations) {
             if (locKey.lk === void 0 || locKey.lk == null || locKey.lk === "" || typeof locKey.lk === "object" && Object.keys(locKey.lk).length === 0) {
-              logger7.error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
+              logger8.error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
               throw new Error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
             }
             const foreignKeyField = locKey.kt + "Id";
             if (options.where[foreignKeyField]) {
-              logger7.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
+              logger8.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
               continue;
             }
-            logger7.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+            logger8.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
             options.where[foreignKeyField] = {
               [Op2.eq]: locKey.lk
             };
           }
           for (const locKey of hierarchicalLocations) {
             if (locKey.lk === void 0 || locKey.lk == null || locKey.lk === "" || typeof locKey.lk === "object" && Object.keys(locKey.lk).length === 0) {
-              logger7.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
+              logger8.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
               throw new Error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
             }
             const relationshipInfo = buildRelationshipPath(model, locKey.kt, kta);
             if (relationshipInfo.found && relationshipInfo.path) {
               if (options.where[relationshipInfo.path]) {
-                logger7.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
+                logger8.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
                 continue;
               }
-              logger7.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+              logger8.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
               options.where[relationshipInfo.path] = {
                 [Op2.eq]: locKey.lk
               };
@@ -1211,7 +1643,7 @@ var getAllOperation = (models, definition, registry) => {
         const effectiveOffset = allOptions?.offset ?? itemQuery?.offset ?? 0;
         const whereFields = options.where ? Object.keys(options.where).join(", ") : "none";
         const includeCount = options.include?.length || 0;
-        logger7.default(
+        logger8.default(
           `All query configured for ${model.name} with where fields: ${whereFields}, includes: ${includeCount}, limit: ${effectiveLimit}, offset: ${effectiveOffset}`
         );
         const countOptions = {
@@ -1221,9 +1653,10 @@ var getAllOperation = (models, definition, registry) => {
         if (options.include) {
           countOptions.include = options.include;
         }
+        queryMetrics.recordQuery(model.name);
         const countResult = await model.count(countOptions);
         const total = Array.isArray(countResult) ? countResult.length : countResult;
-        logger7.debug(`[ALL] Total count for ${model.name}: ${total}`);
+        logger8.debug(`[ALL] Total count for ${model.name}: ${total}`);
         delete options.limit;
         delete options.offset;
         if (effectiveLimit !== void 0) {
@@ -1233,17 +1666,27 @@ var getAllOperation = (models, definition, registry) => {
           options.offset = effectiveOffset;
         }
         try {
-          logger7.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
+          logger8.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
         } catch {
-          logger7.trace(`[ALL] Executing ${model.name}.findAll() with options containing non-serializable operators (${Object.keys(options.where || {}).length} where conditions)`);
+          logger8.trace(`[ALL] Executing ${model.name}.findAll() with options containing non-serializable operators (${Object.keys(options.where || {}).length} where conditions)`);
         }
+        queryMetrics.recordQuery(model.name);
         const matchingItems = await model.findAll(options);
         const currentContext = contextManager.getCurrentContext();
         const items = await Promise.all(matchingItems.map(async (row) => {
-          const processedRow = await processRow(row, coordinate.kta, references || [], aggregations || [], registry, currentContext);
+          const processedRow = await processRow(
+            row,
+            coordinate.kta,
+            references || [],
+            aggregations || [],
+            registry,
+            currentContext,
+            includedAggregations,
+            includedReferences
+          );
           return validateKeys(processedRow, coordinate.kta);
         }));
-        logger7.debug(`[ALL] Returning ${items.length} of ${total} ${model.name} records`);
+        logger8.debug(`[ALL] Returning ${items.length} of ${total} ${model.name} records`);
         return {
           items,
           metadata: {
@@ -1264,7 +1707,7 @@ var getAllOperation = (models, definition, registry) => {
 // src/ops/create.ts
 import { createCreateWrapper, isComKey as isComKey3, isPriKey as isPriKey3 } from "@fjell/core";
 import { validateKeys as validateKeys2 } from "@fjell/core/validation";
-var logger8 = logger_default.get("sequelize", "ops", "create");
+var logger9 = logger_default.get("sequelize", "ops", "create");
 async function validateHierarchicalChain(models, locKey, kta) {
   const locatorIndex = kta.indexOf(locKey.kt);
   if (locatorIndex === -1) {
@@ -1274,6 +1717,7 @@ async function validateHierarchicalChain(models, locKey, kta) {
   try {
     const chainResult = buildRelationshipChain(locatorModel, kta, locatorIndex, kta.length - 1);
     if (!chainResult.success) {
+      queryMetrics.recordQuery(locatorModel.name);
       const record2 = await locatorModel.findByPk(locKey.lk);
       if (!record2) {
         throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist`);
@@ -1286,6 +1730,7 @@ async function validateHierarchicalChain(models, locKey, kta) {
     if (chainResult.includes && chainResult.includes.length > 0) {
       queryOptions.include = chainResult.includes;
     }
+    queryMetrics.recordQuery(locatorModel.name);
     const record = await locatorModel.findOne(queryOptions);
     if (!record) {
       throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist or chain is invalid`);
@@ -1304,8 +1749,8 @@ var getCreateOperation = (models, definition, registry) => {
     coordinate,
     async (item, options) => {
       const constraints = options?.key ? `key: pk=${options.key.pk}, loc=[${isComKey3(options.key) ? options.key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ") : ""}]` : options?.locations ? `locations: ${options.locations.map((loc) => `${loc.kt}=${loc.lk}`).join(", ")}` : "no constraints";
-      logger8.debug(`CREATE operation called on ${models[0].name} with ${constraints}`);
-      logger8.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
+      logger9.debug(`CREATE operation called on ${models[0].name} with ${constraints}`);
+      logger9.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
       const model = models[0];
       const modelAttributes = model.getAttributes();
       let itemData = { ...item };
@@ -1343,7 +1788,7 @@ var getCreateOperation = (models, definition, registry) => {
             if (!relationshipInfo.found) {
               const associations = model.associations ? Object.keys(model.associations) : [];
               const errorMessage = `Composite key locator '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships. Available associations: [${associations.join(", ")}]. KTA: [${kta.join(", ")}]. Composite key: ${JSON.stringify(comKey, null, 2)}`;
-              logger8.error(errorMessage, { key: comKey, kta, associations });
+              logger9.error(errorMessage, { key: comKey, kta, associations });
               throw new Error(errorMessage);
             }
             if (relationshipInfo.isDirect) {
@@ -1354,7 +1799,7 @@ var getCreateOperation = (models, definition, registry) => {
           }
           for (const locKey of directLocations) {
             if (locKey.lk == null || locKey.lk === "") {
-              logger8.error(`Composite key location '${locKey.kt}' has undefined/null lk value`, { locKey, key: comKey });
+              logger9.error(`Composite key location '${locKey.kt}' has undefined/null lk value`, { locKey, key: comKey });
               throw new Error(`Composite key location '${locKey.kt}' has undefined/null lk value`);
             }
             const foreignKeyField = locKey.kt + "Id";
@@ -1373,7 +1818,7 @@ var getCreateOperation = (models, definition, registry) => {
           if (!relationshipInfo.found) {
             const associations = model.associations ? Object.keys(model.associations) : [];
             const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships. Available associations: [${associations.join(", ")}]. KTA: [${kta.join(", ")}]. Locations: ${JSON.stringify(options.locations, null, 2)}`;
-            logger8.error(errorMessage, { locations: options.locations, kta, associations });
+            logger9.error(errorMessage, { locations: options.locations, kta, associations });
             throw new Error(errorMessage);
           }
           if (relationshipInfo.isDirect) {
@@ -1384,7 +1829,7 @@ var getCreateOperation = (models, definition, registry) => {
         }
         for (const locKey of directLocations) {
           if (locKey.lk == null || locKey.lk === "") {
-            logger8.error(`Location option '${locKey.kt}' has undefined/null lk value`, { locKey, locations: options.locations });
+            logger9.error(`Location option '${locKey.kt}' has undefined/null lk value`, { locKey, locations: options.locations });
             throw new Error(`Location option '${locKey.kt}' has undefined/null lk value`);
           }
           const foreignKeyField = locKey.kt + "Id";
@@ -1395,11 +1840,12 @@ var getCreateOperation = (models, definition, registry) => {
         }
       }
       try {
-        logger8.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
+        logger9.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
+        queryMetrics.recordQuery(model.name);
         const createdRecord = await model.create(itemData);
-        const processedRecord = await processRow(createdRecord, kta, references || [], aggregations || [], registry);
+        const processedRecord = await processRow(createdRecord, kta, references || [], aggregations || [], registry, void 0, void 0);
         const result = validateKeys2(processedRecord, kta);
-        logger8.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
+        logger9.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
         return result;
       } catch (error) {
         throw transformSequelizeError(error, kta[0], options?.key, model.name, itemData);
@@ -1411,7 +1857,7 @@ var getCreateOperation = (models, definition, registry) => {
 // src/ops/find.ts
 import { createFindWrapper } from "@fjell/core";
 import { validateKeys as validateKeys3 } from "@fjell/core/validation";
-var logger9 = logger_default.get("sequelize", "ops", "find");
+var logger10 = logger_default.get("sequelize", "ops", "find");
 var getFindOperation = (models, definition, registry) => {
   const { options: { finders, references, aggregations } } = definition;
   return createFindWrapper(
@@ -1421,24 +1867,24 @@ var getFindOperation = (models, definition, registry) => {
         const locs = locations ?? [];
         const params = finderParams ?? {};
         const locationFilters = locs.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none";
-        logger9.debug(
+        logger10.debug(
           `FIND operation called on ${models[0].name} with finder '${finder}' and ${locs.length} location filters: ${locationFilters}`
         );
-        logger9.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(params).length} params`);
+        logger10.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(params).length} params`);
         if (!finders || !finders[finder]) {
-          logger9.error(`No finders have been defined for this lib`);
+          logger10.error(`No finders have been defined for this lib`);
           throw new Error(`No finders found`);
         }
         const finderMethod = finders[finder];
         if (!finderMethod) {
-          logger9.error(`Finder %s not found`, finder);
+          logger10.error(`Finder %s not found`, finder);
           throw new Error(`Finder ${finder} not found`);
         }
-        logger9.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(params)}, locations: ${stringifyJSON(locs)}, options: ${stringifyJSON(findOptions)}`);
+        logger10.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(params)}, locations: ${stringifyJSON(locs)}, options: ${stringifyJSON(findOptions)}`);
         const finderResult = await finderMethod(params, locs, findOptions);
         const processItems = async (items) => {
           return await Promise.all(items.map(async (row) => {
-            const processedRow = await processRow(row, definition.coordinate.kta, references || [], aggregations || [], registry);
+            const processedRow = await processRow(row, definition.coordinate.kta, references || [], aggregations || [], registry, void 0, void 0);
             return validateKeys3(processedRow, definition.coordinate.kta);
           }));
         };
@@ -1446,7 +1892,7 @@ var getFindOperation = (models, definition, registry) => {
         if (isOptInResult) {
           const optInResult = finderResult;
           const processedResults2 = optInResult.items && optInResult.items.length > 0 ? await processItems(optInResult.items) : [];
-          logger9.debug(`[FIND] Finder opted-in, found ${processedResults2.length} ${models[0].name} records using finder '${finder}' (total: ${optInResult.metadata.total})`);
+          logger10.debug(`[FIND] Finder opted-in, found ${processedResults2.length} ${models[0].name} records using finder '${finder}' (total: ${optInResult.metadata.total})`);
           return {
             items: processedResults2,
             metadata: optInResult.metadata
@@ -1454,7 +1900,7 @@ var getFindOperation = (models, definition, registry) => {
         }
         const results = finderResult;
         const processedResults = results && results.length > 0 ? await processItems(results) : [];
-        logger9.debug(`[FIND] Legacy finder, found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
+        logger10.debug(`[FIND] Legacy finder, found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
         return {
           items: processedResults,
           metadata: {
@@ -1465,7 +1911,7 @@ var getFindOperation = (models, definition, registry) => {
           }
         };
       } catch (error) {
-        logger9.error("Error in find operation", {
+        logger10.error("Error in find operation", {
           finder,
           finderParams,
           locations,
@@ -1497,7 +1943,7 @@ import {
   validateKeys as validateKeys4
 } from "@fjell/core";
 import { NotFoundError } from "@fjell/core";
-var logger10 = logger_default.get("sequelize", "ops", "get");
+var logger11 = logger_default.get("sequelize", "ops", "get");
 var processCompositeKey = (comKey, model, kta) => {
   const where = { id: comKey.pk };
   const includes = [];
@@ -1505,7 +1951,7 @@ var processCompositeKey = (comKey, model, kta) => {
     const relationshipInfo = 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. Key type array: [${kta.join(", ")}], Composite key: ${stringifyJSON(comKey)}, Available associations: [${Object.keys(model.associations || {}).join(", ")}]`;
-      logger10.error(errorMessage, { key: comKey, kta });
+      logger11.error(errorMessage, { key: comKey, kta });
       throw new Error(errorMessage);
     }
     if (relationshipInfo.path) {
@@ -1532,28 +1978,53 @@ var getGetOperation = (models, definition, registry) => {
     async (key) => {
       try {
         if (!isValidItemKey(key)) {
-          logger10.error("Key for Get is not a valid ItemKey: %j", key);
+          logger11.error("Key for Get is not a valid ItemKey: %j", key);
           throw new Error("Key for Get is not a valid ItemKey");
         }
         const keyDescription = isPriKey4(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
-        logger10.debug(`GET operation called on ${models[0].name} with ${keyDescription}`);
-        logger10.default(`Get configured for ${models[0].name} with ${isPriKey4(key) ? "primary" : "composite"} key`);
+        logger11.debug(`GET operation called on ${models[0].name} with ${keyDescription}`);
+        logger11.default(`Get configured for ${models[0].name} with ${isPriKey4(key) ? "primary" : "composite"} key`);
         const itemKey = key;
         const model = models[0];
         let item;
+        let includedAggregations = [];
+        let includedReferences = [];
         if (isPriKey4(itemKey)) {
-          logger10.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
-          item = await model.findByPk(itemKey.pk);
+          let options = {};
+          const refResult = addReferenceIncludes(options, model, references || []);
+          includedReferences = refResult.includedReferences;
+          options = refResult.options;
+          const aggResult = addAggregationIncludes(options, model, aggregations || []);
+          includedAggregations = aggResult.includedAggregations;
+          options = aggResult.options;
+          logger11.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}, ${includedReferences.length} reference includes, and ${includedAggregations.length} aggregation includes`);
+          queryMetrics.recordQuery(model.name);
+          item = options.include && options.include.length > 0 ? await model.findByPk(itemKey.pk, { include: options.include }) : await model.findByPk(itemKey.pk);
         } else if (isComKey4(itemKey)) {
           const comKey = itemKey;
           if (comKey.loc.length === 0) {
-            logger10.debug(`[GET] Empty loc array detected - finding by primary key across all locations: ${comKey.pk}`);
-            logger10.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${comKey.pk}`);
-            item = await model.findByPk(comKey.pk);
+            let options = {};
+            const refResult = addReferenceIncludes(options, model, references || []);
+            includedReferences = refResult.includedReferences;
+            options = refResult.options;
+            const aggResult = addAggregationIncludes(options, model, aggregations || []);
+            includedAggregations = aggResult.includedAggregations;
+            options = aggResult.options;
+            logger11.debug(`[GET] Empty loc array detected - finding by primary key across all locations: ${comKey.pk}`);
+            logger11.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${comKey.pk}, ${includedReferences.length} reference includes, and ${includedAggregations.length} aggregation includes`);
+            queryMetrics.recordQuery(model.name);
+            item = options.include && options.include.length > 0 ? await model.findByPk(comKey.pk, { include: options.include }) : await model.findByPk(comKey.pk);
           } else {
-            const queryOptions = processCompositeKey(comKey, model, kta);
-            logger10.default("Composite key query", { queryOptions });
-            logger10.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+            let queryOptions = processCompositeKey(comKey, model, kta);
+            const refResult = addReferenceIncludes(queryOptions, model, references || []);
+            includedReferences = refResult.includedReferences;
+            queryOptions = refResult.options;
+            const aggResult = addAggregationIncludes(queryOptions, model, aggregations || []);
+            includedAggregations = aggResult.includedAggregations;
+            queryOptions = aggResult.options;
+            logger11.default("Composite key query", { queryOptions });
+            logger11.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}, ${includedReferences.length} reference includes, and ${includedAggregations.length} aggregation includes`);
+            queryMetrics.recordQuery(model.name);
             item = await model.findOne(queryOptions);
           }
         }
@@ -1565,8 +2036,8 @@ var getGetOperation = (models, definition, registry) => {
           );
         }
         const currentContext = contextManager.getCurrentContext();
-        const result = validateKeys4(await processRow(item, kta, references || [], aggregations || [], registry, currentContext), kta);
-        logger10.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
+        const result = validateKeys4(await processRow(item, kta, references || [], aggregations || [], registry, currentContext, includedAggregations, includedReferences), kta);
+        logger11.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
         return result;
       } catch (error) {
         if (error instanceof NotFoundError) throw error;
@@ -1578,21 +2049,21 @@ var getGetOperation = (models, definition, registry) => {
 
 // src/ops/one.ts
 import { createOneWrapper } from "@fjell/core";
-var logger11 = logger_default.get("sequelize", "ops", "one");
+var logger12 = logger_default.get("sequelize", "ops", "one");
 var getOneOperation = (models, definition, registry) => {
   return createOneWrapper(
     definition.coordinate,
     async (itemQuery, locations) => {
       const locs = locations ?? [];
-      logger11.debug(`ONE operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
-      logger11.default(`One configured for ${models[0].name} delegating to all operation`);
+      logger12.debug(`ONE operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
+      logger12.default(`One configured for ${models[0].name} delegating to all operation`);
       const result = await getAllOperation(models, definition, registry)(itemQuery ?? {}, locs, { limit: 1 });
       if (result.items.length > 0) {
         const item = result.items[0];
-        logger11.debug(`[ONE] Found ${models[0].name} record with key: ${item.key ? JSON.stringify(item.key) : "unknown"}`);
+        logger12.debug(`[ONE] Found ${models[0].name} record with key: ${item.key ? JSON.stringify(item.key) : "unknown"}`);
         return item;
       } else {
-        logger11.debug(`[ONE] No ${models[0].name} record found`);
+        logger12.debug(`[ONE] No ${models[0].name} record found`);
         return null;
       }
     }
@@ -1602,7 +2073,7 @@ var getOneOperation = (models, definition, registry) => {
 // src/ops/remove.ts
 import { abbrevIK, isComKey as isComKey5, isPriKey as isPriKey5, isValidItemKey as isValidItemKey2, createRemoveWrapper } from "@fjell/core";
 import { NotFoundError as NotFoundError2 } from "@fjell/core";
-var logger12 = logger_default.get("sequelize", "ops", "remove");
+var logger13 = logger_default.get("sequelize", "ops", "remove");
 var processCompositeKey2 = (comKey, model, kta) => {
   const where = { id: comKey.pk };
   const includes = [];
@@ -1610,7 +2081,7 @@ var processCompositeKey2 = (comKey, model, kta) => {
     const relationshipInfo = 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.`;
-      logger12.error(errorMessage, { key: comKey, kta });
+      logger13.error(errorMessage, { key: comKey, kta });
       throw new Error(errorMessage);
     }
     if (relationshipInfo.path) {
@@ -1637,24 +2108,26 @@ var getRemoveOperation = (models, definition, _registry) => {
     async (key) => {
       try {
         if (!isValidItemKey2(key)) {
-          logger12.error("Key for Remove is not a valid ItemKey: %j", key);
+          logger13.error("Key for Remove is not a valid ItemKey: %j", key);
           throw new Error("Key for Remove is not a valid ItemKey");
         }
         const keyDescription = isPriKey5(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
-        logger12.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
-        logger12.default(`Remove configured for ${models[0].name} with ${isPriKey5(key) ? "primary" : "composite"} key`);
+        logger13.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
+        logger13.default(`Remove configured for ${models[0].name} with ${isPriKey5(key) ? "primary" : "composite"} key`);
         const model = models[0];
         let item;
         let returnItem;
-        logger12.debug("remove: %s", abbrevIK(key));
+        logger13.debug("remove: %s", abbrevIK(key));
         if (isPriKey5(key)) {
-          logger12.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
+          logger13.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
+          queryMetrics.recordQuery(model.name);
           item = await model.findByPk(key.pk);
         } else if (isComKey5(key)) {
           const comKey = key;
           const queryOptions = processCompositeKey2(comKey, model, kta);
-          logger12.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-          logger12.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+          logger13.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
+          logger13.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+          queryMetrics.recordQuery(model.name);
           item = await model.findOne(queryOptions);
         }
         if (!item) {
@@ -1673,13 +2146,15 @@ var getRemoveOperation = (models, definition, _registry) => {
           if (model.getAttributes().deletedAt) {
             item.deletedAt = /* @__PURE__ */ new Date();
           }
-          logger12.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
+          logger13.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
+          queryMetrics.recordQuery(model.name);
           await item?.save();
           returnItem = item?.get({ plain: true });
           returnItem = addKey(item, returnItem, kta);
           returnItem = populateEvents(returnItem);
         } else if (options.deleteOnRemove) {
-          logger12.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
+          logger13.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
+          queryMetrics.recordQuery(model.name);
           await item?.destroy();
           returnItem = item?.get({ plain: true });
           returnItem = addKey(item, returnItem, kta);
@@ -1687,7 +2162,7 @@ var getRemoveOperation = (models, definition, _registry) => {
         } else {
           throw new Error("No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set");
         }
-        logger12.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
+        logger13.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
         const { references } = options;
         if (references && references.length > 0) {
           returnItem = addRefsToSequelizeItem(returnItem, references);
@@ -1711,7 +2186,7 @@ import {
 import { validateKeys as validateKeys5 } from "@fjell/core/validation";
 import { NotFoundError as NotFoundError3 } from "@fjell/core";
 import { Op as Op3 } from "sequelize";
-var logger13 = logger_default.get("sequelize", "ops", "update");
+var logger14 = logger_default.get("sequelize", "ops", "update");
 var mergeIncludes2 = (existingIncludes, newIncludes) => {
   const mergedIncludes = [...existingIncludes];
   for (const newInclude of newIncludes) {
@@ -1743,15 +2218,16 @@ var getUpdateOperation = (models, definition, registry) => {
           );
         }
         const keyDescription = isPriKey6(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
-        logger13.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`, { options });
+        logger14.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`, { options });
         const { coordinate } = definition;
         const { kta } = coordinate;
-        logger13.debug("update: %s, %j", abbrevIK2(key), item);
+        logger14.debug("update: %s, %j", abbrevIK2(key), item);
         const model = models[0];
         let response;
         if (isPriKey6(key)) {
           const priKey = key;
-          logger13.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
+          logger14.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
+          queryMetrics.recordQuery(model.name);
           response = await model.findByPk(priKey.pk);
         } else if (isComKey6(key)) {
           const comKey = key;
@@ -1761,7 +2237,7 @@ var getUpdateOperation = (models, definition, registry) => {
             const relationshipInfo = 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.`;
-              logger13.error(errorMessage, { key: comKey, kta });
+              logger14.error(errorMessage, { key: comKey, kta });
               throw new Error(errorMessage);
             }
             if (relationshipInfo.isDirect) {
@@ -1780,8 +2256,9 @@ var getUpdateOperation = (models, definition, registry) => {
           if (additionalIncludes.length > 0) {
             queryOptions.include = mergeIncludes2([], additionalIncludes);
           }
-          logger13.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-          logger13.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+          logger14.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
+          logger14.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+          queryMetrics.recordQuery(model.name);
           response = await model.findOne(queryOptions);
         }
         if (!response) {
@@ -1800,13 +2277,14 @@ var getUpdateOperation = (models, definition, registry) => {
         if (aggregations && aggregations.length > 0) {
           updateProps = removeAggsFromItem(updateProps, aggregations);
         }
-        logger13.default(`Update found ${model.name} record to modify`);
-        logger13.default(`Update properties configured: ${Object.keys(updateProps).join(", ")}`);
-        logger13.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
+        logger14.default(`Update found ${model.name} record to modify`);
+        logger14.default(`Update properties configured: ${Object.keys(updateProps).join(", ")}`);
+        logger14.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
+        queryMetrics.recordQuery(model.name);
         response = await response.update(updateProps);
-        const processedItem = await processRow(response, kta, references || [], aggregations || [], registry);
+        const processedItem = await processRow(response, kta, references || [], aggregations || [], registry, void 0, void 0);
         const returnItem = validateKeys5(processedItem, kta);
-        logger13.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
+        logger14.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
         return returnItem;
       } catch (error) {
         if (error instanceof NotFoundError3) throw error;
@@ -1818,7 +2296,7 @@ var getUpdateOperation = (models, definition, registry) => {
 
 // src/ops/upsert.ts
 import { createUpsertWrapper, isValidItemKey as isValidItemKey3, NotFoundError as NotFoundError4 } from "@fjell/core";
-var logger14 = logger_default.get("sequelize", "ops", "upsert");
+var logger15 = logger_default.get("sequelize", "ops", "upsert");
 var getUpsertOperation = (models, definition, registry) => {
   const get = getGetOperation(models, definition, registry);
   const update = getUpdateOperation(models, definition, registry);
@@ -1827,31 +2305,31 @@ var getUpsertOperation = (models, definition, registry) => {
     definition.coordinate,
     async (key, item, locations, options) => {
       if (!isValidItemKey3(key)) {
-        logger14.error("Key for Upsert is not a valid ItemKey: %j", key);
+        logger15.error("Key for Upsert is not a valid ItemKey: %j", key);
         throw new Error(`Key for Upsert is not a valid ItemKey: ${stringifyJSON(key)}`);
       }
-      logger14.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`, { options });
+      logger15.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`, { options });
       let resultItem = null;
       try {
-        logger14.debug(`[UPSERT] Retrieving item by key: ${stringifyJSON(key)}`);
+        logger15.debug(`[UPSERT] Retrieving item by key: ${stringifyJSON(key)}`);
         resultItem = await get(key);
       } catch (error) {
         const isNotFound = error instanceof NotFoundError4 || error?.name === "NotFoundError" || error?.errorInfo?.code === "NOT_FOUND";
         if (isNotFound) {
-          logger14.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}, errorType: ${error?.name}, errorCode: ${error?.errorInfo?.code}`);
+          logger15.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}, errorType: ${error?.name}, errorCode: ${error?.errorInfo?.code}`);
           const createOptions3 = locations ? { locations } : { key };
           resultItem = await create(item, createOptions3);
         } else {
-          logger14.error(`[UPSERT] Unexpected error during get operation`, { error: error?.message, name: error?.name, code: error?.errorInfo?.code });
+          logger15.error(`[UPSERT] Unexpected error during get operation`, { error: error?.message, name: error?.name, code: error?.errorInfo?.code });
           throw error;
         }
       }
       if (!resultItem) {
         throw new Error(`Failed to retrieve or create item for key: ${stringifyJSON(key)}`);
       }
-      logger14.debug(`[UPSERT] Updating item with properties, key: ${stringifyJSON(key)}`, { options });
+      logger15.debug(`[UPSERT] Updating item with properties, key: ${stringifyJSON(key)}`, { options });
       resultItem = await update(resultItem.key, item, options);
-      logger14.debug(`[UPSERT] Item upserted successfully: ${stringifyJSON(resultItem)}`);
+      logger15.debug(`[UPSERT] Item upserted successfully: ${stringifyJSON(resultItem)}`);
       return resultItem;
     }
   );
@@ -1880,9 +2358,9 @@ var createOperations = (models, coordinate, registry, options) => {
 };
 
 // src/SequelizeLibrary.ts
-var logger15 = logger_default.get("SequelizeLibrary");
+var logger16 = logger_default.get("SequelizeLibrary");
 var createSequelizeLibrary = (registry, coordinate, models, options) => {
-  logger15.debug("createSequelizeLibrary", { coordinate, models, registry, options });
+  logger16.debug("createSequelizeLibrary", { coordinate, models, registry, options });
   const operations = createOperations(models, coordinate, registry, options);
   const wrappedOperations = Library3.wrapOperations(operations, options, coordinate, registry);
   const libLibrary = Library3.createLibrary(registry, coordinate, wrappedOperations, options);
@@ -1896,10 +2374,10 @@ var isSequelizeLibrary = (library) => {
 };
 
 // src/SequelizeLibraryFactory.ts
-var logger16 = logger_default.get("InstanceFactory");
+var logger17 = logger_default.get("InstanceFactory");
 var createSequelizeLibraryFactory = (models, options) => {
   return (coordinate, context) => {
-    logger16.debug("Creating Sequelize instance", {
+    logger17.debug("Creating Sequelize instance", {
       coordinate,
       registry: context.registry,
       models: models.map((m) => m.name),
@@ -1944,9 +2422,9 @@ __export(primary_exports, {
 
 // src/primary/SequelizeLibrary.ts
 import { Primary } from "@fjell/lib";
-var logger17 = logger_default.get("lib-sequelize", "primary", "library");
+var logger18 = logger_default.get("lib-sequelize", "primary", "library");
 function createSequelizeLibrary3(keyType, models, libOptions = {}, scopes = [], registry) {
-  logger17.debug("createSequelizeLibrary", { keyType, models, libOptions, scopes });
+  logger18.debug("createSequelizeLibrary", { keyType, models, libOptions, scopes });
   const coordinate = createCoordinate([keyType], scopes);
   const options = createOptions2(libOptions);
   const operations = createOperations(models, coordinate, registry, options);