@fjell/lib-sequelize 4.4.5 → 4.4.10

package/dist/index.cjs

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const Library = require('@fjell/lib');
-const deepmerge = require('deepmerge');
 const Logging = require('@fjell/logging');
+const registry = require('@fjell/registry');
 const core = require('@fjell/core');
 const sequelize = require('sequelize');
+require('deepmerge');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
@@ -27,20 +28,58 @@ function _interopNamespaceDefault(e) {
 
 const Library__namespace = /*#__PURE__*/_interopNamespaceDefault(Library);
 
+const DEFAULT_SEQUELIZE_OPTIONS = {
+    deleteOnRemove: false,
+    references: [],
+    aggregations: []
+};
+const createOptions = (sequelizeOptions)=>{
+    // Create the base lib options
+    const baseOptions = Library__namespace.createOptions(sequelizeOptions);
+    var _sequelizeOptions_deleteOnRemove, _sequelizeOptions_references, _sequelizeOptions_aggregations;
+    // Add Sequelize-specific defaults
+    const result = {
+        ...baseOptions,
+        deleteOnRemove: (_sequelizeOptions_deleteOnRemove = sequelizeOptions === null || sequelizeOptions === void 0 ? void 0 : sequelizeOptions.deleteOnRemove) !== null && _sequelizeOptions_deleteOnRemove !== void 0 ? _sequelizeOptions_deleteOnRemove : DEFAULT_SEQUELIZE_OPTIONS.deleteOnRemove,
+        references: (_sequelizeOptions_references = sequelizeOptions === null || sequelizeOptions === void 0 ? void 0 : sequelizeOptions.references) !== null && _sequelizeOptions_references !== void 0 ? _sequelizeOptions_references : DEFAULT_SEQUELIZE_OPTIONS.references,
+        aggregations: (_sequelizeOptions_aggregations = sequelizeOptions === null || sequelizeOptions === void 0 ? void 0 : sequelizeOptions.aggregations) !== null && _sequelizeOptions_aggregations !== void 0 ? _sequelizeOptions_aggregations : DEFAULT_SEQUELIZE_OPTIONS.aggregations
+    };
+    return result;
+};
+
+const logger$1.default = Logging.getLogger('@fjell/lib-sequelize');
+
+const logger$i = logger$1.default.get('Coordinate');
 const SCOPE_SEQUELIZE = 'sequelize';
 const createCoordinate = (kta, scopes)=>{
-    const coordinate = Library__namespace.createCoordinate(kta, [
+    logger$i.debug('createCoordinate', {
+        kta,
+        scopes
+    });
+    const coordinate = registry.createCoordinate(kta, [
         SCOPE_SEQUELIZE,
         ...scopes || []
     ]);
     return coordinate;
 };
 
-/* eslint-disable @typescript-eslint/no-unused-vars */ /* eslint-disable no-undefined */ const clean = (obj)=>{
-    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
+const logger$h = logger$1.default.get('lib-sequelize', 'Definition');
+const createDefinition = (kta, scopes, libOptions)=>{
+    logger$h.debug('createDefinition', {
+        kta,
+        scopes,
+        libOptions
+    });
+    const coordinate = createCoordinate(kta, scopes);
+    const options = createOptions(libOptions);
+    return {
+        coordinate,
+        options
+    };
 };
+
 //Recursive implementation of jSON.stringify;
-const general.stringifyJSON = function(obj, visited = new Set()) {
+const stringifyJSON = function(obj, visited = new Set()) {
     const arrOfKeyVals = [];
     const arrVals = [];
     let objKeys = [];
@@ -55,7 +94,7 @@ const general.stringifyJSON = function(obj, visited = new Set()) {
             // Add array to visited before processing its elements
             visited.add(obj);
             obj.forEach(function(el) {
-                arrVals.push(general.stringifyJSON(el, visited));
+                arrVals.push(stringifyJSON(el, visited));
             });
             return '[' + arrVals + ']';
         }
@@ -73,7 +112,7 @@ const general.stringifyJSON = function(obj, visited = new Set()) {
             else if (typeof keyValOut === 'string') arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
             else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null) arrOfKeyVals.push(keyOut + keyValOut);
             else if (keyValOut instanceof Object) {
-                arrOfKeyVals.push(keyOut + general.stringifyJSON(keyValOut, visited));
+                arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));
             }
         });
         return '{' + arrOfKeyVals + '}';
@@ -81,39 +120,9 @@ const general.stringifyJSON = function(obj, visited = new Set()) {
     return '';
 };
 
-const DEFAULT_OPTIONS = {
-    deleteOnRemove: false,
-    references: [],
-    aggregations: []
-};
-const createOptions = (libOptions)=>{
-    const options = Library__namespace.createOptions(libOptions);
-    return deepmerge(DEFAULT_OPTIONS, clean(options));
-};
-
-const logger$1.default = Logging.getLogger('@fjell/lib-sequelize');
-
-const logger$f = logger$1.default.get('lib-sequelize', 'Definition');
-function createDefinition(kta, scopes, libOptions) {
-    logger$f.debug('createDefinition', {
-        kta,
-        scopes,
-        libOptions
-    });
-    const coordinate = createCoordinate(kta, scopes);
-    const options = createOptions(libOptions);
-    const definition = Library__namespace.createDefinition(coordinate, options);
-    return {
-        ...definition,
-        options
-    };
-}
-
-const logger$e = logger$1.default.get('sequelize', 'QueryBuilder');
+const logger$g = logger$1.default.get('sequelize', 'QueryBuilder');
 const addDeleteQuery = (options, model)=>{
-    logger$e.default('Adding Delete Query', {
-        options
-    });
+    logger$g.default(`QueryBuilder adding delete query with options: ${stringifyJSON(options)}`);
     if (model.getAttributes().deletedAt) {
         options.where['deletedAt'] = {
             [sequelize.Op.eq]: null
@@ -126,10 +135,7 @@ const addDeleteQuery = (options, model)=>{
     return options;
 };
 const addEventQueries = (options, events, model)=>{
-    logger$e.default('Adding Event Queries', {
-        options,
-        events
-    });
+    logger$g.default(`QueryBuilder adding event queries with options: ${stringifyJSON(options)}, events: ${stringifyJSON(events)}`);
     Object.keys(events).forEach((key)=>{
         if (!model.getAttributes()[`${key}At`]) {
             throw new Error(`Event ${key} is not supported on this model, column ${key}At not found`);
@@ -163,20 +169,22 @@ const addEventQueries = (options, events, model)=>{
 };
 // Add the references to the query
 const addReferenceQueries = (options, references, model)=>{
-    logger$e.default('Adding Reference Queries', {
-        options,
-        references
-    });
+    logger$g.default(`QueryBuilder adding reference queries with options: ${stringifyJSON(options)}, references: ${stringifyJSON(references)}`);
     Object.keys(references).forEach((key)=>{
-        logger$e.default('Adding Reference Query', {
-            key,
-            references
-        });
+        logger$g.default(`QueryBuilder adding reference query for key: ${key}, references: ${stringifyJSON(references)}`);
         if (!model.getAttributes()[`${key}Id`]) {
             throw new Error(`Reference ${key} is not supported on this model, column ${key}Id not found`);
         }
         if (core.isPriKey(references[key])) {
             const priKey = references[key];
+            if (priKey.pk == null || priKey.pk === '' || typeof priKey.pk === 'object' && Object.keys(priKey.pk).length === 0) {
+                logger$g.error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`, {
+                    priKey,
+                    references
+                });
+                throw new Error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`);
+            }
+            logger$g.trace(`[QueryBuilder] Setting reference where clause: ${key}Id = ${stringifyJSON(priKey.pk)} (type: ${typeof priKey.pk})`);
             options.where[`${key}Id`] = {
                 [sequelize.Op.eq]: priKey.pk
             };
@@ -253,6 +261,13 @@ const addAssociationCondition = (conditions, condition, model)=>{
     // Use Sequelize's $association.attribute$ syntax for querying associated models
     const sequelizeAssociationColumn = `$${associationName}.${attributeName}$`;
     const conditionOp = getSequelizeOperator(condition.operator);
+    if (condition.value == null && condition.operator !== '==' && condition.operator !== 'in') {
+        logger$g.error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`, {
+            condition
+        });
+        throw new Error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`);
+    }
+    logger$g.trace(`[QueryBuilder] Setting association condition: ${sequelizeAssociationColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
     conditions[sequelizeAssociationColumn] = {
         [conditionOp]: condition.value
     };
@@ -264,6 +279,13 @@ const addAttributeCondition = (conditions, condition, model)=>{
         throw new Error(`Condition column ${conditionColumn} not found on model ${model.name}`);
     }
     const conditionOp = getSequelizeOperator(condition.operator);
+    if (condition.value == null && condition.operator !== '==' && condition.operator !== 'in') {
+        logger$g.error(`Attribute condition for '${conditionColumn}' has undefined/null value`, {
+            condition
+        });
+        throw new Error(`Attribute condition for '${conditionColumn}' has undefined/null value`);
+    }
+    logger$g.trace(`[QueryBuilder] Setting attribute condition: ${conditionColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
     conditions[conditionColumn] = {
         [conditionOp]: condition.value
     };
@@ -334,16 +356,12 @@ const addAssociationIncludes = (options, model)=>{
     return options;
 };
 const buildQuery = (itemQuery, model)=>{
-    logger$e.default('build', {
-        itemQuery
-    });
+    logger$g.default(`QueryBuilder build called with itemQuery: ${stringifyJSON(itemQuery)}`);
     let options = {
         where: {}
     };
     if (itemQuery.compoundCondition) {
-        logger$e.default('Adding Conditions', {
-            compoundCondition: itemQuery.compoundCondition
-        });
+        logger$g.default(`QueryBuilder adding conditions: ${stringifyJSON(itemQuery.compoundCondition)}`);
         options = addCompoundCondition(options, itemQuery.compoundCondition, model);
     }
     // If the model has a deletedAt column, we need to add a delete query
@@ -359,9 +377,7 @@ const buildQuery = (itemQuery, model)=>{
     // TODO: Once we start to support Aggs on the server-side, we'll need to parse agg queries
     // Apply a limit to the result set
     if (itemQuery.limit) {
-        logger$e.default('Limiting to', {
-            limit: itemQuery.limit
-        });
+        logger$g.default(`QueryBuilder applying limit: ${itemQuery.limit}`);
         options.limit = itemQuery.limit;
     }
     // Apply an offset to the result set
@@ -497,10 +513,10 @@ const buildQuery = (itemQuery, model)=>{
     return result;
 };
 
-const logger$d = logger$1.default.get('sequelize', 'KeyMaster');
+const logger$f = logger$1.default.get('sequelize', 'KeyMaster');
 // Helper function to extract location key value from item
 const extractLocationKeyValue = (model, item, locatorType, kta)=>{
-    logger$d.default('Extracting location key value', {
+    logger$f.default('Extracting location key value', {
         locatorType,
         kta
     });
@@ -555,7 +571,7 @@ const extractLocationKeyValue = (model, item, locatorType, kta)=>{
     }
 };
 const removeKey = (item)=>{
-    logger$d.default('Removing Key', {
+    logger$f.default('Removing Key', {
         item
     });
     delete item.key;
@@ -589,7 +605,7 @@ const removeKey = (item)=>{
 //   return item;
 // }
 const addKey = (model, item, keyTypes)=>{
-    logger$d.default('Adding Key', {
+    logger$f.default('Adding Key', {
         item
     });
     const key = {};
@@ -615,7 +631,7 @@ const addKey = (model, item, keyTypes)=>{
                 });
             } catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                logger$d.error(`Failed to extract location key for '${locatorType}'`, {
+                logger$f.error(`Failed to extract location key for '${locatorType}'`, {
                     error: errorMessage,
                     item,
                     keyTypes
@@ -638,7 +654,7 @@ const addKey = (model, item, keyTypes)=>{
     return item;
 };
 
-const logger$c = logger$1.default.get('sequelize', 'ReferenceBuilder');
+const logger$e = logger$1.default.get('sequelize', 'ReferenceBuilder');
 const buildReference = async (item, referenceDefinition, registry, context)=>{
     // Check if there is more than one key type
     if (referenceDefinition.kta.length > 1) {
@@ -668,13 +684,13 @@ const buildReference = async (item, referenceDefinition, registry, context)=>{
     if (context) {
         // Check if we already have this item cached
         if (context.isCached(priKey)) {
-            logger$c.default('Using cached reference', {
+            logger$e.default('Using cached reference', {
                 priKey,
                 property: referenceDefinition.property
             });
             referencedItem = context.getCached(priKey);
         } else if (context.isInProgress(priKey)) {
-            logger$c.default('Circular dependency detected, creating reference placeholder', {
+            logger$e.default('Circular dependency detected, creating reference placeholder', {
                 priKey,
                 property: referenceDefinition.property
             });
@@ -719,7 +735,7 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-const logger$b = logger$1.default.get('sequelize', 'OperationContext');
+const logger$d = logger$1.default.get('sequelize', 'OperationContext');
 /**
  * Serialize an ItemKey to a string for use in sets and maps
  */ const OperationContext.serializeKey = (key)=>{
@@ -743,7 +759,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
         cache,
         markInProgress (key) {
             const serialized = OperationContext.serializeKey(key);
-            logger$b.default('Marking key as in progress', {
+            logger$d.default('Marking key as in progress', {
                 key,
                 serialized
             });
@@ -751,7 +767,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
         },
         markComplete (key) {
             const serialized = OperationContext.serializeKey(key);
-            logger$b.default('Marking key as complete', {
+            logger$d.default('Marking key as complete', {
                 key,
                 serialized
             });
@@ -760,7 +776,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
         isInProgress (key) {
             const serialized = OperationContext.serializeKey(key);
             const result = inProgress.has(serialized);
-            logger$b.default('Checking if key is in progress', {
+            logger$d.default('Checking if key is in progress', {
                 key,
                 serialized,
                 result
@@ -770,7 +786,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
         getCached (key) {
             const serialized = OperationContext.serializeKey(key);
             const result = cache.get(serialized);
-            logger$b.default('Getting cached item', {
+            logger$d.default('Getting cached item', {
                 key,
                 serialized,
                 found: !!result
@@ -779,7 +795,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
         },
         setCached (key, item) {
             const serialized = OperationContext.serializeKey(key);
-            logger$b.default('Caching item', {
+            logger$d.default('Caching item', {
                 key,
                 serialized
             });
@@ -788,7 +804,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
         isCached (key) {
             const serialized = OperationContext.serializeKey(key);
             const result = cache.has(serialized);
-            logger$b.default('Checking if key is cached', {
+            logger$d.default('Checking if key is cached', {
                 key,
                 serialized,
                 result
@@ -806,7 +822,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
         const contextId = Math.random().toString(36).substring(7);
         this.contexts.set(contextId, context);
         this.currentContextId = contextId;
-        logger$b.default('Set current context', {
+        logger$d.default('Set current context', {
             contextId
         });
         return contextId;
@@ -816,7 +832,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
    */ getCurrentContext() {
         if (this.currentContextId) {
             const context = this.contexts.get(this.currentContextId);
-            logger$b.default('Got current context', {
+            logger$d.default('Got current context', {
                 contextId: this.currentContextId,
                 found: !!context
             });
@@ -828,7 +844,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
    * Clear the current context
    */ clearCurrentContext() {
         if (this.currentContextId) {
-            logger$b.default('Clearing current context', {
+            logger$d.default('Clearing current context', {
                 contextId: this.currentContextId
             });
             this.contexts.delete(this.currentContextId);
@@ -857,7 +873,7 @@ const logger$b = logger$1.default.get('sequelize', 'OperationContext');
 // Global context manager instance
 const OperationContext.contextManager = new ContextManager();
 
-const logger$a = logger$1.default.get('sequelize', 'AggregationBuilder');
+const logger$c = logger$1.default.get('sequelize', 'AggregationBuilder');
 const buildAggregation = async (item, aggregationDefinition, registry, context)=>{
     const location = core.ikToLKA(item.key);
     // Get the library instance from the registry using the key type array
@@ -872,7 +888,7 @@ const buildAggregation = async (item, aggregationDefinition, registry, context)=
         // Check if this aggregation is already cached
         if (context.cache.has(aggregationCacheKey)) {
             const cachedResult = context.cache.get(aggregationCacheKey);
-            logger$a.default('Using cached aggregation result', {
+            logger$c.default('Using cached aggregation result', {
                 aggregationCacheKey,
                 property: aggregationDefinition.property
             });
@@ -912,7 +928,7 @@ const buildAggregation = async (item, aggregationDefinition, registry, context)=
     });
 };
 
-const logger$9 = logger$1.default.get("sequelize", "EventCoordinator");
+const logger$b = logger$1.default.get("sequelize", "EventCoordinator");
 //#endregion
 const populateEvents = (item)=>{
     const events = {
@@ -930,7 +946,7 @@ const populateEvents = (item)=>{
     return item;
 };
 const extractEvents = (item)=>{
-    logger$9.default('Extracting Events to database fields', {
+    logger$b.default('Extracting Events to database fields', {
         item
     });
     if (item.events) {
@@ -948,16 +964,16 @@ const extractEvents = (item)=>{
     return item;
 };
 const removeEvents = (item)=>{
-    logger$9.default('Removing Events', {
+    logger$b.default('Removing Events', {
         item
     });
     delete item.events;
     return item;
 };
 
-const logger$8 = logger$1.default.get('sequelize', 'RowProcessor');
+const logger$a = logger$1.default.get('sequelize', 'RowProcessor');
 const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context)=>{
-    logger$8.default('Processing Row', {
+    logger$a.default('Processing Row', {
         row
     });
     // Use provided context or create new one
@@ -967,22 +983,22 @@ const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefini
         let item = row.get({
             plain: true
         });
-        logger$8.default('Adding Key to Item with Key Types: %s', general.stringifyJSON(keyTypes));
+        logger$a.default('Adding Key to Item with Key Types: %s', stringifyJSON(keyTypes));
         item = addKey(row, item, keyTypes);
         item = populateEvents(item);
-        logger$8.default('Key Added to Item: %s', general.stringifyJSON(item.key));
+        logger$a.default('Key Added to Item: %s', stringifyJSON(item.key));
         // Mark this item as in progress to detect circular references
         operationContext.markInProgress(item.key);
         try {
             if (referenceDefinitions && referenceDefinitions.length > 0) {
                 for (const referenceDefinition of referenceDefinitions){
-                    logger$8.default('Processing Reference for %s to %s', item.key.kt, general.stringifyJSON(referenceDefinition.kta));
+                    logger$a.default('Processing Reference for %s to %s', item.key.kt, stringifyJSON(referenceDefinition.kta));
                     item = await buildReference(item, referenceDefinition, registry, operationContext);
                 }
             }
             if (aggregationDefinitions && aggregationDefinitions.length > 0) {
                 for (const aggregationDefinition of aggregationDefinitions){
-                    logger$8.default('Processing Aggregation for %s from %s', item.key.kt, general.stringifyJSON(aggregationDefinition.kta));
+                    logger$a.default('Processing Aggregation for %s from %s', item.key.kt, stringifyJSON(aggregationDefinition.kta));
                     item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
                 }
             }
@@ -992,12 +1008,12 @@ const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefini
             // Mark this item as complete
             operationContext.markComplete(item.key);
         }
-        logger$8.default('Processed Row: %j', general.stringifyJSON(item));
+        logger$a.default('Processed Row: %j', stringifyJSON(item));
         return item;
     });
 };
 
-const logger$7 = logger$1.default.get('sequelize', 'ops', 'all');
+const logger$9 = logger$1.default.get('sequelize', 'ops', 'all');
 // Helper function to merge includes avoiding duplicates
 const mergeIncludes$1 = (existingIncludes, newIncludes)=>{
     const mergedIncludes = [
@@ -1022,10 +1038,8 @@ const all.getAllOperation = (models, definition, registry)=>{
     const { coordinate, options: { references, aggregations } } = definition;
     //#region Query
     const all = async (itemQuery, locations)=>{
-        logger$7.default('All', {
-            itemQuery,
-            locations
-        });
+        var _options_include;
+        logger$9.debug(`ALL operation called on ${models[0].name} with ${(locations === null || locations === void 0 ? void 0 : locations.length) || 0} location filters: ${(locations === null || locations === void 0 ? void 0 : locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ')) || 'none'}`);
         const loc = locations || [];
         // @ts-ignore
         const model = models[0];
@@ -1042,7 +1056,7 @@ const all.getAllOperation = (models, definition, registry)=>{
                 const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta, true);
                 if (!relationshipInfo.found) {
                     const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-                    logger$7.error(errorMessage, {
+                    logger$9.error(errorMessage, {
                         locations: loc,
                         kta
                     });
@@ -1056,24 +1070,44 @@ const all.getAllOperation = (models, definition, registry)=>{
             }
             // Handle direct location keys (simple foreign key constraints)
             for (const locKey of directLocations){
+                if (locKey.lk === undefined || locKey.lk == null || locKey.lk === '' || typeof locKey.lk === 'object' && Object.keys(locKey.lk).length === 0) {
+                    logger$9.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';
-                options.where = {
-                    ...options.where,
-                    [foreignKeyField]: {
-                        [sequelize.Op.eq]: locKey.lk
-                    }
+                // Check if this field already has a condition from the itemQuery
+                if (options.where[foreignKeyField]) {
+                    logger$9.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
+                    continue; // Skip this location constraint to avoid conflicts
+                }
+                logger$9.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+                options.where[foreignKeyField] = {
+                    [sequelize.Op.eq]: locKey.lk
                 };
             }
             // Handle hierarchical location keys (requires relationship traversal)
             for (const locKey of hierarchicalLocations){
+                if (locKey.lk === undefined || locKey.lk == null || locKey.lk === '' || typeof locKey.lk === 'object' && Object.keys(locKey.lk).length === 0) {
+                    logger$9.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 = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta);
                 if (relationshipInfo.found && relationshipInfo.path) {
+                    // Check if this field already has a condition from the itemQuery
+                    if (options.where[relationshipInfo.path]) {
+                        logger$9.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
+                        continue; // Skip this location constraint to avoid conflicts
+                    }
                     // Add the relationship constraint using the path
-                    options.where = {
-                        ...options.where,
-                        [relationshipInfo.path]: {
-                            [sequelize.Op.eq]: locKey.lk
-                        }
+                    logger$9.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+                    options.where[relationshipInfo.path] = {
+                        [sequelize.Op.eq]: locKey.lk
                     };
                     // Add necessary includes for the relationship traversal
                     if (relationshipInfo.includes) {
@@ -1087,63 +1121,134 @@ const all.getAllOperation = (models, definition, registry)=>{
                 options.include = mergeIncludes$1(existingIncludes, additionalIncludes);
             }
         }
-        logger$7.default('Configured this Item Query', {
-            itemQuery,
-            options
-        });
+        logger$9.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(', ') : 'none'}, includes: ${((_options_include = options.include) === null || _options_include === void 0 ? void 0 : _options_include.length) || 0}`);
+        try {
+            logger$9.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
+        } catch  {
+            // Fallback for cases where JSON.stringify fails on Sequelize operators
+            logger$9.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);
         // this.logger.default('Matching Items', { matchingItems });
         // Get the current context from context manager
         const context = OperationContext.contextManager.getCurrentContext();
         // TODO: Move this Up!
-        return await Promise.all(matchingItems.map(async (row)=>{
+        const results = await Promise.all(matchingItems.map(async (row)=>{
             const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry, context);
             return core.validateKeys(processedRow, coordinate.kta);
         }));
+        logger$9.debug(`[ALL] Returning ${results.length} ${model.name} records`);
+        return results;
     };
     return all;
 };
 
-const logger$6 = logger$1.default.get('sequelize', 'ops', 'create');
+const logger$8 = logger$1.default.get('sequelize', 'ops', 'create');
+// Helper function to translate PostgreSQL errors to meaningful messages
+function translateDatabaseError(error, itemData, modelName) {
+    var _error_original, _error_original1, _error_original2;
+    const originalMessage = error.message || '';
+    const errorCode = (_error_original = error.original) === null || _error_original === void 0 ? void 0 : _error_original.code;
+    const constraint = (_error_original1 = error.original) === null || _error_original1 === void 0 ? void 0 : _error_original1.constraint;
+    const detail = (_error_original2 = error.original) === null || _error_original2 === void 0 ? void 0 : _error_original2.detail;
+    logger$8.error('Database error during create operation', {
+        errorCode,
+        constraint,
+        detail,
+        originalMessage,
+        modelName,
+        itemData: JSON.stringify(itemData, null, 2)
+    });
+    // Handle specific PostgreSQL error codes
+    switch(errorCode){
+        case '23505':
+            if (constraint) {
+                return new Error(`Duplicate value violates unique constraint '${constraint}'. ${detail || ''}`);
+            }
+            return new Error(`Duplicate value detected. This record already exists. ${detail || ''}`);
+        case '23503':
+            if (constraint) {
+                return new Error(`Foreign key constraint '${constraint}' violated. Referenced record does not exist. ${detail || ''}`);
+            }
+            return new Error(`Referenced record does not exist. Check that all related records are valid. ${detail || ''}`);
+        case '23502':
+            var _error_original3;
+            const column = (_error_original3 = error.original) === null || _error_original3 === void 0 ? void 0 : _error_original3.column;
+            if (column) {
+                return new Error(`Required field '${column}' cannot be null`);
+            }
+            return new Error(`Required field is missing or null`);
+        case '23514':
+            if (constraint) {
+                return new Error(`Check constraint '${constraint}' violated. ${detail || ''}`);
+            }
+            return new Error(`Data validation failed. Check constraint violated. ${detail || ''}`);
+        case '22001':
+            return new Error(`Data too long for field. Check string lengths. ${detail || ''}`);
+        case '22003':
+            return new Error(`Numeric value out of range. Check number values. ${detail || ''}`);
+        case '42703':
+            var _error_original4;
+            const undefinedColumn = (_error_original4 = error.original) === null || _error_original4 === void 0 ? void 0 : _error_original4.column;
+            if (undefinedColumn) {
+                return new Error(`Column '${undefinedColumn}' does not exist in table '${modelName}'`);
+            }
+            return new Error(`Referenced column does not exist`);
+        case '42P01':
+            return new Error(`Table '${modelName}' does not exist`);
+        default:
+            // For unknown errors, provide the original message with context
+            return new Error(`Database error in ${modelName}.create(): ${originalMessage}. Item data: ${JSON.stringify(itemData, null, 2)}`);
+    }
+}
 // Helper function to validate hierarchical chain exists
 async function validateHierarchicalChain(models, locKey, kta) {
-    // Find the direct parent model that contains this locator
-    const locatorIndex = kta.indexOf(locKey.kt);
-    if (locatorIndex === -1) {
-        throw new Error(`Locator type '${locKey.kt}' not found in kta array`);
-    }
-    // Get the model for this locator
-    const locatorModel = models[locatorIndex] || models[0]; // Fallback to primary model
-    // Build a query to validate the chain exists
-    const chainResult = buildRelationshipChain(locatorModel, kta, locatorIndex, kta.length - 1);
-    if (!chainResult.success) {
-        // If we can't build a chain, just validate the record exists
-        const record = await locatorModel.findByPk(locKey.lk);
+    try {
+        // Find the direct parent model that contains this locator
+        const locatorIndex = kta.indexOf(locKey.kt);
+        if (locatorIndex === -1) {
+            throw new Error(`Locator type '${locKey.kt}' not found in kta array`);
+        }
+        // Get the model for this locator
+        const locatorModel = models[locatorIndex] || models[0]; // Fallback to primary model
+        // Build a query to validate the chain exists
+        const chainResult = buildRelationshipChain(locatorModel, kta, locatorIndex, kta.length - 1);
+        if (!chainResult.success) {
+            // If we can't build a chain, just validate the record exists
+            const record = await locatorModel.findByPk(locKey.lk);
+            if (!record) {
+                throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist`);
+            }
+            return;
+        }
+        // Validate that the chain exists
+        const queryOptions = {
+            where: {
+                id: locKey.lk
+            }
+        };
+        if (chainResult.includes && chainResult.includes.length > 0) {
+            queryOptions.include = chainResult.includes;
+        }
+        const record = await locatorModel.findOne(queryOptions);
         if (!record) {
-            throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist`);
+            throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist or chain is invalid`);
         }
-        return;
-    }
-    // Validate that the chain exists
-    const queryOptions = {
-        where: {
-            id: locKey.lk
+    } catch (error) {
+        // Add context to validation errors
+        if (error.original) {
+            throw translateDatabaseError(error, {
+                locKey,
+                kta
+            }, locKey.kt);
         }
-    };
-    if (chainResult.includes && chainResult.includes.length > 0) {
-        queryOptions.include = chainResult.includes;
-    }
-    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`);
+        throw error;
     }
 }
 const getCreateOperation = (models, definition, registry)=>{
     const create = async (item, options)=>{
-        logger$6.default('Create', {
-            item,
-            options
-        });
+        logger$8.debug(`CREATE operation called on ${models[0].name} with ${(options === null || options === void 0 ? void 0 : options.key) ? `key: pk=${options.key.pk}, loc=[${core.isComKey(options.key) ? options.key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ') : ''}]` : (options === null || options === void 0 ? void 0 : options.locations) ? `locations: ${options.locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ')}` : 'no constraints'}`);
+        logger$8.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
         const { coordinate, options: { references, aggregations } } = definition;
         const { kta } = coordinate;
         // Get the primary model (first model in array)
@@ -1156,11 +1261,17 @@ const getCreateOperation = (models, definition, registry)=>{
         // TODO: We need the opposite of processRow, something to step down from fjell to database.
         itemData = extractEvents(itemData);
         itemData = removeEvents(itemData);
+        // Validate that all item attributes exist on the model
+        const invalidAttributes = [];
         for (const key of Object.keys(itemData)){
             if (!modelAttributes[key]) {
-                throw new Error(`Attribute '${key}' does not exist on model ${model.name}`);
+                invalidAttributes.push(key);
             }
         }
+        if (invalidAttributes.length > 0) {
+            const availableAttributes = Object.keys(modelAttributes).join(', ');
+            throw new Error(`Invalid attributes for model '${model.name}': [${invalidAttributes.join(', ')}]. ` + `Available attributes: [${availableAttributes}]. ` + `Item data: ${JSON.stringify(itemData, null, 2)}`);
+        }
         // Handle key options
         // If a key is supplied, assume its contents are to be assigned to the appropriate ids.
         // For most cases this will be null as key generation is often through autoIncrement.
@@ -1181,10 +1292,12 @@ const getCreateOperation = (models, definition, registry)=>{
                 for (const locKey of comKey.loc){
                     const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta, true);
                     if (!relationshipInfo.found) {
-                        const errorMessage = `Composite key locator '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-                        logger$6.error(errorMessage, {
+                        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)}`;
+                        logger$8.error(errorMessage, {
                             key: comKey,
-                            kta
+                            kta,
+                            associations
                         });
                         throw new Error(errorMessage);
                     }
@@ -1196,6 +1309,13 @@ const getCreateOperation = (models, definition, registry)=>{
                 }
                 // Set direct foreign keys
                 for (const locKey of directLocations){
+                    if (locKey.lk == null || locKey.lk === '') {
+                        logger$8.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';
                     itemData[foreignKeyField] = locKey.lk;
                 }
@@ -1214,10 +1334,12 @@ const getCreateOperation = (models, definition, registry)=>{
             for (const locKey of options.locations){
                 const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locKey.kt, kta, true);
                 if (!relationshipInfo.found) {
-                    const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-                    logger$6.error(errorMessage, {
+                    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)}`;
+                    logger$8.error(errorMessage, {
                         locations: options.locations,
-                        kta
+                        kta,
+                        associations
                     });
                     throw new Error(errorMessage);
                 }
@@ -1229,6 +1351,13 @@ const getCreateOperation = (models, definition, registry)=>{
             }
             // Set direct foreign keys
             for (const locKey of directLocations){
+                if (locKey.lk == null || locKey.lk === '') {
+                    logger$8.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';
                 itemData[foreignKeyField] = locKey.lk;
             }
@@ -1238,50 +1367,58 @@ const getCreateOperation = (models, definition, registry)=>{
             }
         }
         // Create the record
-        const createdRecord = await model.create(itemData);
-        // Add key and events
-        const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
-        return core.validateKeys(processedRecord, kta);
+        try {
+            logger$8.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
+            const createdRecord = await model.create(itemData);
+            // Add key and events
+            const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
+            const result = core.validateKeys(processedRecord, kta);
+            logger$8.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);
+        }
     };
     return create;
 };
 
-const logger$5 = logger$1.default.get('sequelize', 'ops', 'find');
+const logger$7 = logger$1.default.get('sequelize', 'ops', 'find');
 const getFindOperation = (models, definition, registry)=>{
     const { options: { finders, references, aggregations } } = definition;
     const find = async (finder, finderParams, locations)=>{
-        logger$5.default('Find', {
-            finder,
-            finderParams,
-            locations
-        });
+        logger$7.debug(`FIND operation called on ${models[0].name} with finder '${finder}' and ${(locations === null || locations === void 0 ? void 0 : locations.length) || 0} location filters: ${(locations === null || locations === void 0 ? void 0 : locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ')) || 'none'}`);
+        logger$7.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
         // Note that we execute the createFinders function here because we want to make sure we're always getting the
         // most up to date methods.
         if (finders && finders[finder]) {
             const finderMethod = finders[finder];
             if (finderMethod) {
+                logger$7.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) {
-                    return await Promise.all(results.map(async (row)=>{
+                    const processedResults = await Promise.all(results.map(async (row)=>{
                         const processedRow = await processRow(row, definition.coordinate.kta, references, aggregations, registry);
                         return core.validateKeys(processedRow, definition.coordinate.kta);
                     }));
+                    logger$7.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
+                    return processedResults;
                 } else {
+                    logger$7.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
                     return [];
                 }
             } else {
-                logger$5.error(`Finder %s not found`, finder);
+                logger$7.error(`Finder %s not found`, finder);
                 throw new Error(`Finder ${finder} not found`);
             }
         } else {
-            logger$5.error(`No finders have been defined for this lib`);
+            logger$7.error(`No finders have been defined for this lib`);
             throw new Error(`No finders found`);
         }
     };
     return find;
 };
 
-const logger$4 = logger$1.default.get('sequelize', 'ops', 'get');
+const logger$6 = logger$1.default.get('sequelize', 'ops', 'get');
 // Helper function to process composite key and build query options
 const processCompositeKey$1 = (comKey, model, kta)=>{
     const where = {
@@ -1292,7 +1429,7 @@ const processCompositeKey$1 = (comKey, model, kta)=>{
         const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta);
         if (!relationshipInfo.found) {
             const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-            logger$4.error(errorMessage, {
+            logger$6.error(errorMessage, {
                 key: comKey,
                 kta
             });
@@ -1322,27 +1459,28 @@ const getGetOperation = (models, definition, registry)=>{
     const { coordinate, options: { references, aggregations } } = definition;
     const { kta } = coordinate;
     const get = async (key)=>{
-        logger$4.default('Get', {
-            key
-        });
         if (!core.isValidItemKey(key)) {
-            logger$4.error('Key for Get is not a valid ItemKey: %j', key);
+            logger$6.error('Key for Get is not a valid ItemKey: %j', key);
             throw new Error('Key for Get is not a valid ItemKey');
         }
+        logger$6.debug(`GET operation called on ${models[0].name} with ${core.isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
+        logger$6.default(`Get configured for ${models[0].name} with ${core.isPriKey(key) ? 'primary' : 'composite'} key`);
         const itemKey = key;
         // @ts-ignore
         const model = models[0];
         let item;
         if (core.isPriKey(itemKey)) {
             // This is the easy case because we can just find the item by its primary key
+            logger$6.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
             item = await model.findByPk(itemKey.pk);
         } else if (core.isComKey(itemKey)) {
             // This is a composite key, so we need to build a where clause based on the composite key's locators
             const comKey = itemKey;
             const queryOptions = processCompositeKey$1(comKey, model, kta);
-            logger$4.default('Composite key query', {
+            logger$6.default('Composite key query', {
                 queryOptions
             });
+            logger$6.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
             item = await model.findOne(queryOptions);
         }
         if (!item) {
@@ -1350,30 +1488,33 @@ const getGetOperation = (models, definition, registry)=>{
         } else {
             // Get the current context from context manager
             const context = OperationContext.contextManager.getCurrentContext();
-            return core.validateKeys(await processRow(item, kta, references, aggregations, registry, context), kta);
+            const result = core.validateKeys(await processRow(item, kta, references, aggregations, registry, context), kta);
+            logger$6.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
+            return result;
         }
     };
     return get;
 };
 
-const logger$3 = logger$1.default.get('sequelize', 'ops', 'one');
+const logger$5 = logger$1.default.get('sequelize', 'ops', 'one');
 const getOneOperation = (models, definition, registry)=>{
     const one = async (itemQuery, locations = [])=>{
-        logger$3.default('One', {
-            itemQuery,
-            locations
-        });
+        logger$5.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ') || 'none'}`);
+        logger$5.default(`One configured for ${models[0].name} delegating to all operation`);
         const items = await all.getAllOperation(models, definition, registry)(itemQuery, locations);
         if (items.length > 0) {
-            return items[0];
+            const result = items[0];
+            logger$5.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : 'unknown'}`);
+            return result;
         } else {
+            logger$5.debug(`[ONE] No ${models[0].name} record found`);
             return null;
         }
     };
     return one;
 };
 
-const logger$2 = logger$1.default.get('sequelize', 'ops', 'remove');
+const logger$4 = logger$1.default.get('sequelize', 'ops', 'remove');
 // Helper function to process composite key and build query options
 const processCompositeKey = (comKey, model, kta)=>{
     const where = {
@@ -1384,7 +1525,7 @@ const processCompositeKey = (comKey, model, kta)=>{
         const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta);
         if (!relationshipInfo.found) {
             const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-            logger$2.error(errorMessage, {
+            logger$4.error(errorMessage, {
                 key: comKey,
                 kta
             });
@@ -1415,27 +1556,26 @@ registry)=>{
     const { coordinate, options } = definition;
     const { kta } = coordinate;
     const remove = async (key)=>{
-        logger$2.default('Remove', {
-            key
-        });
         if (!core.isValidItemKey(key)) {
-            logger$2.error('Key for Remove is not a valid ItemKey: %j', key);
+            logger$4.error('Key for Remove is not a valid ItemKey: %j', key);
             throw new Error('Key for Remove is not a valid ItemKey');
         }
+        logger$4.debug(`REMOVE operation called on ${models[0].name} with ${core.isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
+        logger$4.default(`Remove configured for ${models[0].name} with ${core.isPriKey(key) ? 'primary' : 'composite'} key`);
         // @ts-ignore
         const model = models[0];
         let item;
         let returnItem;
-        logger$2.debug('remove: %s', core.abbrevIK(key));
+        logger$4.debug('remove: %s', core.abbrevIK(key));
         if (core.isPriKey(key)) {
+            logger$4.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
             item = await model.findByPk(key.pk);
         } else if (core.isComKey(key)) {
             // This is a composite key, so we need to build a where clause based on the composite key's locators
             const comKey = key;
             const queryOptions = processCompositeKey(comKey, model, kta);
-            logger$2.default('Composite key query', {
-                queryOptions
-            });
+            logger$4.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
+            logger$4.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
             item = await model.findOne(queryOptions);
         }
         if (!item) {
@@ -1451,6 +1591,7 @@ registry)=>{
                 item.deletedAt = new Date();
             }
             // Save the object
+            logger$4.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
             await (item === null || item === void 0 ? void 0 : item.save());
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
@@ -1458,6 +1599,7 @@ registry)=>{
             returnItem = addKey(item, returnItem, kta);
             returnItem = populateEvents(returnItem);
         } else if (options.deleteOnRemove) {
+            logger$4.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
             await (item === null || item === void 0 ? void 0 : item.destroy());
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
@@ -1467,12 +1609,13 @@ registry)=>{
         } else {
             throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
         }
+        logger$4.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
         return returnItem;
     };
     return remove;
 };
 
-const logger$1 = logger$1.default.get('sequelize', 'ops', 'update');
+const logger$3 = logger$1.default.get('sequelize', 'ops', 'update');
 // Helper function to merge includes avoiding duplicates
 const mergeIncludes = (existingIncludes, newIncludes)=>{
     const mergedIncludes = [
@@ -1496,9 +1639,10 @@ const mergeIncludes = (existingIncludes, newIncludes)=>{
 const getUpdateOperation = (models, definition, registry)=>{
     const { options: { references, aggregations } } = definition;
     const update = async (key, item)=>{
+        logger$3.debug(`UPDATE operation called on ${models[0].name} with ${core.isPriKey(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l)=>`${l.kt}=${l.lk}`).join(', ')}]`}`);
         const { coordinate } = definition;
         const { kta } = coordinate;
-        logger$1.debug('update: %s, %j', core.abbrevIK(key), item);
+        logger$3.debug('update: %s, %j', core.abbrevIK(key), item);
         // Find the object we're updating
         // @ts-ignore
         const model = models[0];
@@ -1506,6 +1650,7 @@ const getUpdateOperation = (models, definition, registry)=>{
         if (core.isPriKey(key)) {
             // Find the model by using the PK
             const priKey = key;
+            logger$3.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
             response = await model.findByPk(priKey.pk);
         } else if (core.isComKey(key)) {
             const comKey = key;
@@ -1519,7 +1664,7 @@ const getUpdateOperation = (models, definition, registry)=>{
                 const relationshipInfo = relationshipUtils.buildRelationshipPath(model, locator.kt, kta, true);
                 if (!relationshipInfo.found) {
                     const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-                    logger$1.error(errorMessage, {
+                    logger$3.error(errorMessage, {
                         key: comKey,
                         kta
                     });
@@ -1547,9 +1692,8 @@ const getUpdateOperation = (models, definition, registry)=>{
             if (additionalIncludes.length > 0) {
                 queryOptions.include = mergeIncludes([], additionalIncludes);
             }
-            logger$1.default('Composite key query for update', {
-                queryOptions
-            });
+            logger$3.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
+            logger$3.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
             response = await model.findOne(queryOptions);
         }
         if (response) {
@@ -1558,13 +1702,15 @@ const getUpdateOperation = (models, definition, registry)=>{
             // TODO: We need the opposite of processRow, something to step down from fjell to database.
             updateProps = extractEvents(updateProps);
             updateProps = removeEvents(updateProps);
-            logger$1.default('Response: %s', general.stringifyJSON(response));
-            logger$1.default('Update Properties: %s', general.stringifyJSON(updateProps));
+            logger$3.default(`Update found ${model.name} record to modify`);
+            logger$3.default(`Update properties configured: ${Object.keys(updateProps).join(', ')}`);
             // Update the object
+            logger$3.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
             response = await response.update(updateProps);
             // Populate the key and events
             const processedItem = await processRow(response, kta, references, aggregations, registry);
             const returnItem = core.validateKeys(processedItem, kta);
+            logger$3.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
             return returnItem;
         } else {
             throw new Library.NotFoundError('update', coordinate, key);
@@ -1573,8 +1719,13 @@ const getUpdateOperation = (models, definition, registry)=>{
     return update;
 };
 
-const createOperations = (models, definition, registry)=>{
+const createOperations = (models, coordinate, registry, options)=>{
     const operations = {};
+    // Create a definition-like object for backward compatibility with existing operation functions
+    const definition = {
+        coordinate,
+        options
+    };
     operations.all = all.getAllOperation(models, definition, registry);
     operations.one = getOneOperation(models, definition, registry);
     operations.create = getCreateOperation(models, definition, registry);
@@ -1588,25 +1739,62 @@ const createOperations = (models, definition, registry)=>{
     return operations;
 };
 
-function createInstance$2(keyTypes, models, libOptions = {}, scopes = [], registry) {
-    const definition = createDefinition(keyTypes, scopes, libOptions);
-    const operations = createOperations(models, definition, registry);
-    return {
-        definition,
-        operations: Library__namespace.wrapOperations(operations, definition, registry),
+const logger$2 = logger$1.default.get("Instance");
+/**
+ * Creates a new Sequelize instance that extends the fjell-lib instance
+ * with Sequelize-specific functionality
+ */ const createInstance$2 = (registry, coordinate, models, options)=>{
+    logger$2.debug("createInstance", {
+        coordinate,
         models,
-        registry
+        registry,
+        options
+    });
+    // Create Sequelize-specific operations
+    const operations = createOperations(models, coordinate, registry, options);
+    // Create the base fjell-lib instance
+    const libInstance = Library__namespace.createInstance(registry, coordinate, operations, options);
+    return {
+        ...libInstance,
+        models
     };
-}
+};
+/**
+ * Type guard to check if an object is a Sequelize Instance
+ */ const isInstance = (instance)=>{
+    return instance != null && instance.coordinate != null && instance.operations != null && instance.options != null && instance.registry != null && instance.models != null && Array.isArray(instance.models);
+};
+
+const logger$1 = logger$1.default.get("InstanceFactory");
+/**
+ * Factory function for creating Sequelize instances
+ * This extends the fjell-lib pattern by adding Sequelize-specific models
+ */ const createInstanceFactory = (models, options)=>{
+    return (coordinate, context)=>{
+        logger$1.debug("Creating Sequelize instance", {
+            coordinate,
+            registry: context.registry,
+            models: models.map((m)=>m.name),
+            options
+        });
+        return createInstance$2(context.registry, coordinate, models, options);
+    };
+};
 
 function createInstance$1(keyTypes, models, libOptions = {}, scopes = [], registry) {
-    const definition = createDefinition(keyTypes, scopes, libOptions);
-    const operations = createOperations(models, definition, registry);
+    // Create coordinate and options separately following new pattern
+    const coordinate = createCoordinate(keyTypes, scopes);
+    const options = createOptions(libOptions);
+    // Create operations with the new signature
+    const operations = createOperations(models, coordinate, registry, options);
+    // Wrap operations for contained pattern
+    const wrappedOperations = Library.Contained.wrapOperations(operations, options, coordinate, registry);
     return {
-        definition,
-        operations: Library.Contained.wrapOperations(operations, definition, registry),
-        models,
-        registry
+        coordinate,
+        registry,
+        operations: wrappedOperations,
+        options,
+        models
     };
 }
 
@@ -1623,15 +1811,21 @@ function createInstance(keyType, models, libOptions = {}, scopes = [], registry)
         libOptions,
         scopes
     });
-    const definition = createDefinition([
+    // Create coordinate and options separately following new pattern
+    const coordinate = createCoordinate([
         keyType
-    ], scopes, libOptions);
-    const operations = createOperations(models, definition, registry);
+    ], scopes);
+    const options = createOptions(libOptions);
+    // Create operations with the new signature
+    const operations = createOperations(models, coordinate, registry, options);
+    // Wrap operations for primary pattern
+    const wrappedOperations = Library.Primary.wrapOperations(operations, options, coordinate, registry);
     return {
-        definition,
-        operations: Library.Primary.wrapOperations(operations, definition, registry),
-        models,
-        registry
+        coordinate,
+        registry,
+        operations: wrappedOperations,
+        options,
+        models
     };
 }
 
@@ -1646,6 +1840,8 @@ exports.SCOPE_SEQUELIZE = SCOPE_SEQUELIZE;
 exports.createCoordinate = createCoordinate;
 exports.createDefinition = createDefinition;
 exports.createInstance = createInstance$2;
+exports.createInstanceFactory = createInstanceFactory;
 exports.createOperations = createOperations;
 exports.createOptions = createOptions;
+exports.isInstance = isInstance;
 //# sourceMappingURL=index.cjs.map