@fjell/lib-sequelize 4.4.50 → 4.4.52

package/dist/index.js

@@ -376,6 +376,52 @@ var buildQuery = (itemQuery, model) => {
   return options;
 };
 
+// src/validation/LocationKeyValidator.ts
+var logger4 = logger_default.get("LocationKeyValidator");
+var validateLocations = (locations, coordinate, operation) => {
+  if (!locations || locations.length === 0) {
+    return;
+  }
+  const keyTypeArray = coordinate.kta;
+  const expectedLocationTypes = keyTypeArray.slice(1);
+  const actualLocationTypes = locations.map((loc) => loc.kt);
+  logger4.debug(`Validating locations for ${operation}`, {
+    expected: expectedLocationTypes,
+    actual: actualLocationTypes,
+    coordinate: keyTypeArray
+  });
+  if (actualLocationTypes.length > expectedLocationTypes.length) {
+    logger4.error("Location key array has too many elements", {
+      expected: expectedLocationTypes.length,
+      actual: actualLocationTypes.length,
+      expectedTypes: expectedLocationTypes,
+      actualTypes: actualLocationTypes,
+      coordinate,
+      operation
+    });
+    throw new Error(
+      `Invalid location key array for ${operation}: Expected at most ${expectedLocationTypes.length} location keys (hierarchy: [${expectedLocationTypes.join(", ")}]), but received ${actualLocationTypes.length} (types: [${actualLocationTypes.join(", ")}])`
+    );
+  }
+  for (let i = 0; i < actualLocationTypes.length; i++) {
+    if (expectedLocationTypes[i] !== actualLocationTypes[i]) {
+      logger4.error("Location key array order mismatch", {
+        position: i,
+        expected: expectedLocationTypes[i],
+        actual: actualLocationTypes[i],
+        expectedHierarchy: expectedLocationTypes,
+        actualOrder: actualLocationTypes,
+        coordinate,
+        operation
+      });
+      throw new Error(
+        `Invalid location key array order for ${operation}: At position ${i}, expected key type "${expectedLocationTypes[i]}" but received "${actualLocationTypes[i]}". Location keys must be ordered according to the hierarchy: [${expectedLocationTypes.join(", ")}]. Received order: [${actualLocationTypes.join(", ")}]`
+      );
+    }
+  }
+  logger4.debug(`Location key array validation passed for ${operation}`, { locations });
+};
+
 // src/util/relationshipUtils.ts
 var buildRelationshipChain = (targetModel, kta, currentIndex, targetIndex) => {
   const associationParts = [];
@@ -456,9 +502,9 @@ var buildRelationshipPath = (targetModel, locatorType, kta, includeIsDirect = fa
 };
 
 // src/KeyMaster.ts
-var logger4 = logger_default.get("sequelize", "KeyMaster");
+var logger5 = logger_default.get("sequelize", "KeyMaster");
 var extractLocationKeyValue = (model, item, locatorType, kta) => {
-  logger4.default("Extracting location key value", { locatorType, kta });
+  logger5.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. Key type array: [${kta.join(", ")}]. Available associations: [${Object.keys(model.associations || {}).join(", ")}]`);
@@ -502,12 +548,12 @@ var extractLocationKeyValue = (model, item, locatorType, kta) => {
   }
 };
 var removeKey = (item) => {
-  logger4.default("Removing Key", { item });
+  logger5.default("Removing Key", { item });
   delete item.key;
   return item;
 };
 var addKey = (model, item, keyTypes) => {
-  logger4.default("Adding Key", { item });
+  logger5.default("Adding Key", { item });
   const key = {};
   const modelClass = model.constructor;
   const primaryKeyAttr = modelClass.primaryKeyAttribute;
@@ -522,7 +568,7 @@ var addKey = (model, item, keyTypes) => {
         locationKeys.push({ kt: locatorType, lk });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger4.error(`Failed to extract location key for '${locatorType}'`, { error: errorMessage, item, keyTypes });
+        logger5.error(`Failed to extract location key for '${locatorType}'`, { error: errorMessage, item, keyTypes });
         throw error;
       }
     }
@@ -543,7 +589,7 @@ import {
 
 // src/EventCoordinator.ts
 import deepmerge from "deepmerge";
-var logger5 = logger_default.get("sequelize", "EventCoordinator");
+var logger6 = logger_default.get("sequelize", "EventCoordinator");
 var populateEvents = (item) => {
   const events = {
     created: { at: item.createdAt || null },
@@ -554,7 +600,7 @@ var populateEvents = (item) => {
   return item;
 };
 var extractEvents = (item) => {
-  logger5.default("Extracting Events to database fields", { item });
+  logger6.default("Extracting Events to database fields", { item });
   if (item.events) {
     if (item.events.created?.at) {
       item.createdAt = item.events.created.at;
@@ -569,7 +615,7 @@ var extractEvents = (item) => {
   return item;
 };
 var removeEvents = (item) => {
-  logger5.default("Removing Events", { item });
+  logger6.default("Removing Events", { item });
   delete item.events;
   return item;
 };
@@ -654,27 +700,27 @@ var stripSequelizeReferenceItems = (item, referenceDefinitions) => {
 };
 
 // src/RowProcessor.ts
-var logger6 = logger_default.get("sequelize", "RowProcessor");
+var logger7 = logger_default.get("sequelize", "RowProcessor");
 var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context) => {
-  logger6.default("Processing Row", { row });
+  logger7.default("Processing Row", { row });
   const operationContext = context || createOperationContext();
   return contextManager.withContext(operationContext, async () => {
     let item = row.get({ plain: true });
-    logger6.default("Adding Key to Item with Key Types: %s", stringifyJSON(keyTypes));
+    logger7.default("Adding Key to Item with Key Types: %s", stringifyJSON(keyTypes));
     item = addKey(row, item, keyTypes);
     item = populateEvents(item);
-    logger6.default("Key Added to Item: %s", stringifyJSON(item.key));
+    logger7.default("Key Added to Item: %s", stringifyJSON(item.key));
     operationContext.markInProgress(item.key);
     try {
       if (referenceDefinitions && referenceDefinitions.length > 0) {
         for (const referenceDefinition of referenceDefinitions) {
-          logger6.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
+          logger7.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
           item = await buildSequelizeReference(item, referenceDefinition, registry, operationContext);
         }
       }
       if (aggregationDefinitions && aggregationDefinitions.length > 0) {
         for (const aggregationDefinition of aggregationDefinitions) {
-          logger6.default("Processing Aggregation for %s from %s", item.key.kt, stringifyJSON(aggregationDefinition.kta));
+          logger7.default("Processing Aggregation for %s from %s", item.key.kt, stringifyJSON(aggregationDefinition.kta));
           item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
         }
       }
@@ -682,14 +728,14 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
     } finally {
       operationContext.markComplete(item.key);
     }
-    logger6.default("Processed Row: %j", stringifyJSON(item));
+    logger7.default("Processed Row: %j", stringifyJSON(item));
     return item;
   });
 };
 
 // src/ops/all.ts
 import { Op as Op2 } from "sequelize";
-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) {
@@ -712,7 +758,8 @@ var mergeIncludes = (existingIncludes, newIncludes) => {
 var getAllOperation = (models, definition, registry) => {
   const { coordinate, options: { references, aggregations } } = definition;
   const all = async (itemQuery, locations) => {
-    logger7.debug(`ALL operation called on ${models[0].name} with ${locations?.length || 0} location filters: ${locations?.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
+    logger8.debug(`ALL operation called on ${models[0].name} with ${locations?.length || 0} location filters: ${locations?.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
+    validateLocations(locations, coordinate, "all");
     const loc = locations || [];
     const model = models[0];
     const options = buildQuery(itemQuery, model);
@@ -725,7 +772,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) {
@@ -736,31 +783,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
           };
@@ -774,11 +821,11 @@ var getAllOperation = (models, definition, registry) => {
         options.include = mergeIncludes(existingIncludes, additionalIncludes);
       }
     }
-    logger7.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(", ") : "none"}, includes: ${options.include?.length || 0}`);
+    logger8.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(", ") : "none"}, includes: ${options.include?.length || 0}`);
     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)`);
     }
     const matchingItems = await model.findAll(options);
     const currentContext = contextManager.getCurrentContext();
@@ -786,7 +833,7 @@ var getAllOperation = (models, definition, registry) => {
       const processedRow = await processRow(row, coordinate.kta, references || [], aggregations || [], registry, currentContext);
       return validateKeys(processedRow, coordinate.kta);
     }));
-    logger7.debug(`[ALL] Returning ${results.length} ${model.name} records`);
+    logger8.debug(`[ALL] Returning ${results.length} ${model.name} records`);
     return results;
   };
   return all;
@@ -794,13 +841,13 @@ var getAllOperation = (models, definition, registry) => {
 
 // src/ops/create.ts
 import { isComKey as isComKey2, isPriKey as isPriKey2, validateKeys as validateKeys2 } from "@fjell/core";
-var logger8 = logger_default.get("sequelize", "ops", "create");
+var logger9 = logger_default.get("sequelize", "ops", "create");
 function translateDatabaseError(error, itemData, modelName) {
   const originalMessage = error.message || "";
   const errorCode = error.original?.code;
   const constraint = error.original?.constraint;
   const detail = error.original?.detail;
-  logger8.error("Database error during create operation", {
+  logger9.error("Database error during create operation", {
     errorCode,
     constraint,
     detail,
@@ -894,10 +941,16 @@ async function validateHierarchicalChain(models, locKey, kta) {
 var getCreateOperation = (models, definition, registry) => {
   const create = async (item, options) => {
     const constraints = options?.key ? `key: pk=${options.key.pk}, loc=[${isComKey2(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 { coordinate, options: { references, aggregations } } = definition;
     const { kta } = coordinate;
+    if (options?.locations) {
+      validateLocations(options.locations, coordinate, "create");
+    }
+    if (options?.key && isComKey2(options.key)) {
+      validateLocations(options.key.loc, coordinate, "create");
+    }
     const model = models[0];
     const modelAttributes = model.getAttributes();
     let itemData = { ...item };
@@ -929,7 +982,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) {
@@ -940,7 +993,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";
@@ -959,7 +1012,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) {
@@ -970,7 +1023,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";
@@ -981,11 +1034,11 @@ 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)}`);
       const createdRecord = await model.create(itemData);
       const processedRecord = await processRow(createdRecord, kta, references || [], aggregations || [], registry);
       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 translateDatabaseError(error, itemData, model.name);
@@ -996,37 +1049,38 @@ var getCreateOperation = (models, definition, registry) => {
 
 // src/ops/find.ts
 import { validateKeys as validateKeys3 } from "@fjell/core";
-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;
   const find = async (finder, finderParams, locations) => {
     const locationFilters = locations?.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none";
-    logger9.debug(
+    logger10.debug(
       `FIND operation called on ${models[0].name} with finder '${finder}' and ${locations?.length || 0} location filters: ${locationFilters}`
     );
-    logger9.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
+    logger10.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
+    validateLocations(locations, definition.coordinate, "find");
     if (finders && finders[finder]) {
       const finderMethod = finders[finder];
       if (finderMethod) {
-        logger9.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
+        logger10.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
         const results = await finderMethod(finderParams, locations);
         if (results && results.length > 0) {
           const processedResults = await Promise.all(results.map(async (row) => {
             const processedRow = await processRow(row, definition.coordinate.kta, references || [], aggregations || [], registry);
             return validateKeys3(processedRow, definition.coordinate.kta);
           }));
-          logger9.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
+          logger10.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
           return processedResults;
         } else {
-          logger9.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
+          logger10.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
           return [];
         }
       } else {
-        logger9.error(`Finder %s not found`, finder);
+        logger10.error(`Finder %s not found`, finder);
         throw new Error(`Finder ${finder} not found`);
       }
     } else {
-      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`);
     }
   };
@@ -1041,7 +1095,7 @@ import {
   validateKeys as validateKeys4
 } from "@fjell/core";
 import { NotFoundError } from "@fjell/lib";
-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 = [];
@@ -1049,7 +1103,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) {
@@ -1073,23 +1127,23 @@ var getGetOperation = (models, definition, registry) => {
   const { kta } = coordinate;
   const get = async (key) => {
     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 = isPriKey3(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 ${isPriKey3(key) ? "primary" : "composite"} key`);
+    logger11.debug(`GET operation called on ${models[0].name} with ${keyDescription}`);
+    logger11.default(`Get configured for ${models[0].name} with ${isPriKey3(key) ? "primary" : "composite"} key`);
     const itemKey = key;
     const model = models[0];
     let item;
     if (isPriKey3(itemKey)) {
-      logger10.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
+      logger11.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
       item = await model.findByPk(itemKey.pk);
     } else if (isComKey3(itemKey)) {
       const comKey = itemKey;
       const queryOptions = processCompositeKey(comKey, model, kta);
-      logger10.default("Composite key query", { queryOptions });
-      logger10.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+      logger11.default("Composite key query", { queryOptions });
+      logger11.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
       item = await model.findOne(queryOptions);
     }
     if (!item) {
@@ -1097,7 +1151,7 @@ var getGetOperation = (models, definition, registry) => {
     } else {
       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}`}`);
+      logger11.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
       return result;
     }
   };
@@ -1105,18 +1159,19 @@ var getGetOperation = (models, definition, registry) => {
 };
 
 // src/ops/one.ts
-var logger11 = logger_default.get("sequelize", "ops", "one");
+var logger12 = logger_default.get("sequelize", "ops", "one");
 var getOneOperation = (models, definition, registry) => {
   const one = async (itemQuery, locations = []) => {
-    logger11.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.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 ${locations.length} location filters: ${locations.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
+    logger12.default(`One configured for ${models[0].name} delegating to all operation`);
+    validateLocations(locations, definition.coordinate, "one");
     const items = await getAllOperation(models, definition, registry)(itemQuery, locations);
     if (items.length > 0) {
       const result = items[0];
-      logger11.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : "unknown"}`);
+      logger12.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : "unknown"}`);
       return result;
     } else {
-      logger11.debug(`[ONE] No ${models[0].name} record found`);
+      logger12.debug(`[ONE] No ${models[0].name} record found`);
       return null;
     }
   };
@@ -1127,7 +1182,7 @@ var getOneOperation = (models, definition, registry) => {
 import { isValidItemKey as isValidItemKey2 } from "@fjell/core";
 import { abbrevIK, isComKey as isComKey4, isPriKey as isPriKey4 } from "@fjell/core";
 import { NotFoundError as NotFoundError2 } from "@fjell/lib";
-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 = [];
@@ -1135,7 +1190,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) {
@@ -1159,24 +1214,24 @@ var getRemoveOperation = (models, definition, _registry) => {
   const { kta } = coordinate;
   const remove = async (key) => {
     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 = isPriKey4(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 ${isPriKey4(key) ? "primary" : "composite"} key`);
+    logger13.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
+    logger13.default(`Remove configured for ${models[0].name} with ${isPriKey4(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 (isPriKey4(key)) {
-      logger12.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
+      logger13.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
       item = await model.findByPk(key.pk);
     } else if (isComKey4(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)}`);
       item = await model.findOne(queryOptions);
     }
     if (!item) {
@@ -1191,13 +1246,13 @@ 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`);
       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`);
       await item?.destroy();
       returnItem = item?.get({ plain: true });
       returnItem = addKey(item, returnItem, kta);
@@ -1205,7 +1260,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}`}`);
     return returnItem;
   };
   return remove;
@@ -1216,7 +1271,7 @@ import { abbrevIK as abbrevIK2, isComKey as isComKey5, validateKeys as validateK
 import { isPriKey as isPriKey5 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/lib";
 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) {
@@ -1240,15 +1295,15 @@ var getUpdateOperation = (models, definition, registry) => {
   const { options: { references, aggregations } } = definition;
   const update = async (key, item) => {
     const keyDescription = isPriKey5(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}`);
+    logger14.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`);
     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 (isPriKey5(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}`);
       response = await model.findByPk(priKey.pk);
     } else if (isComKey5(key)) {
       const comKey = key;
@@ -1258,7 +1313,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) {
@@ -1277,21 +1332,21 @@ 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)}`);
       response = await model.findOne(queryOptions);
     }
     if (response) {
       let updateProps = removeKey(item);
       updateProps = extractEvents(updateProps);
       updateProps = removeEvents(updateProps);
-      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)}`);
       response = await response.update(updateProps);
       const processedItem = await processRow(response, kta, references || [], aggregations || [], registry);
       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;
     } else {
       throw new NotFoundError3("update", coordinate, key);
@@ -1302,25 +1357,25 @@ var getUpdateOperation = (models, definition, registry) => {
 
 // src/ops/upsert.ts
 import { isValidItemKey as isValidItemKey3 } 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);
   const create = getCreateOperation(models, definition, registry);
   const upsert = async (key, item) => {
     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)}`);
+    logger15.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`);
     try {
       const existingItem = await get(key);
       if (existingItem) {
-        logger14.debug(`[UPSERT] Item exists, updating with key: ${stringifyJSON(key)}`);
+        logger15.debug(`[UPSERT] Item exists, updating with key: ${stringifyJSON(key)}`);
         return await update(key, item);
       }
     } catch {
-      logger14.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}`);
+      logger15.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}`);
     }
     return await create(item, { key });
   };
@@ -1356,9 +1411,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 = Library2.wrapOperations(operations, options, coordinate, registry);
   const libLibrary = Library2.createLibrary(registry, coordinate, wrappedOperations, options);
@@ -1372,10 +1427,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),
@@ -1420,9 +1475,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);