@fjell/lib-sequelize 4.4.5 → 4.4.10

package/dist/es/Instance.js

@@ -1,17 +1,32 @@
 import * as Library from '@fjell/lib';
-import { createDefinition } from './Definition.js';
 import { createOperations } from './Operations.js';
+import LibLogger from './logger.js';
 
-function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry) {
-    const definition = createDefinition(keyTypes, scopes, libOptions);
-    const operations = createOperations(models, definition, registry);
-    return {
-        definition,
-        operations: Library.wrapOperations(operations, definition, registry),
+const logger = LibLogger.get("Instance");
+/**
+ * Creates a new Sequelize instance that extends the fjell-lib instance
+ * with Sequelize-specific functionality
+ */ const createInstance = (registry, coordinate, models, options)=>{
+    logger.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.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);
+};
 
-export { createInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+export { createInstance, isInstance };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/InstanceFactory.js

@@ -0,0 +1,21 @@
+import { createInstance } from './Instance.js';
+import LibLogger from './logger.js';
+
+const logger = LibLogger.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.debug("Creating Sequelize instance", {
+            coordinate,
+            registry: context.registry,
+            models: models.map((m)=>m.name),
+            options
+        });
+        return createInstance(context.registry, coordinate, models, options);
+    };
+};
+
+export { createInstanceFactory };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2VGYWN0b3J5LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/Operations.js

@@ -6,8 +6,13 @@ import { getOneOperation } from './ops/one.js';
 import { getRemoveOperation } from './ops/remove.js';
 import { getUpdateOperation } from './ops/update.js';
 
-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 = getAllOperation(models, definition, registry);
     operations.one = getOneOperation(models, definition, registry);
     operations.create = getCreateOperation(models, definition, registry);
@@ -22,4 +27,4 @@ const createOperations = (models, definition, registry)=>{
 };
 
 export { createOperations };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/Options.js

@@ -1,16 +1,23 @@
 import * as Library from '@fjell/lib';
-import deepmerge from 'deepmerge';
-import { clean } from './util/general.js';
 
-const DEFAULT_OPTIONS = {
+const DEFAULT_SEQUELIZE_OPTIONS = {
     deleteOnRemove: false,
     references: [],
     aggregations: []
 };
-const createOptions = (libOptions)=>{
-    const options = Library.createOptions(libOptions);
-    return deepmerge(DEFAULT_OPTIONS, clean(options));
+const createOptions = (sequelizeOptions)=>{
+    // Create the base lib options
+    const baseOptions = Library.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;
 };
 
 export { createOptions };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/QueryBuilder.js

@@ -1,12 +1,11 @@
 import { isCondition, isPriKey, isComKey } from '@fjell/core';
 import { Op } from 'sequelize';
 import LibLogger from './logger.js';
+import { stringifyJSON } from './util/general.js';
 
 const logger = LibLogger.get('sequelize', 'QueryBuilder');
 const addDeleteQuery = (options, model)=>{
-    logger.default('Adding Delete Query', {
-        options
-    });
+    logger.default(`QueryBuilder adding delete query with options: ${stringifyJSON(options)}`);
     if (model.getAttributes().deletedAt) {
         options.where['deletedAt'] = {
             [Op.eq]: null
@@ -19,10 +18,7 @@ const addDeleteQuery = (options, model)=>{
     return options;
 };
 const addEventQueries = (options, events, model)=>{
-    logger.default('Adding Event Queries', {
-        options,
-        events
-    });
+    logger.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`);
@@ -56,20 +52,22 @@ const addEventQueries = (options, events, model)=>{
 };
 // Add the references to the query
 const addReferenceQueries = (options, references, model)=>{
-    logger.default('Adding Reference Queries', {
-        options,
-        references
-    });
+    logger.default(`QueryBuilder adding reference queries with options: ${stringifyJSON(options)}, references: ${stringifyJSON(references)}`);
     Object.keys(references).forEach((key)=>{
-        logger.default('Adding Reference Query', {
-            key,
-            references
-        });
+        logger.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 (isPriKey(references[key])) {
             const priKey = references[key];
+            if (priKey.pk == null || priKey.pk === '' || typeof priKey.pk === 'object' && Object.keys(priKey.pk).length === 0) {
+                logger.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.trace(`[QueryBuilder] Setting reference where clause: ${key}Id = ${stringifyJSON(priKey.pk)} (type: ${typeof priKey.pk})`);
             options.where[`${key}Id`] = {
                 [Op.eq]: priKey.pk
             };
@@ -146,6 +144,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.error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`, {
+            condition
+        });
+        throw new Error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`);
+    }
+    logger.trace(`[QueryBuilder] Setting association condition: ${sequelizeAssociationColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
     conditions[sequelizeAssociationColumn] = {
         [conditionOp]: condition.value
     };
@@ -157,6 +162,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.error(`Attribute condition for '${conditionColumn}' has undefined/null value`, {
+            condition
+        });
+        throw new Error(`Attribute condition for '${conditionColumn}' has undefined/null value`);
+    }
+    logger.trace(`[QueryBuilder] Setting attribute condition: ${conditionColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
     conditions[conditionColumn] = {
         [conditionOp]: condition.value
     };
@@ -227,16 +239,12 @@ const addAssociationIncludes = (options, model)=>{
     return options;
 };
 const buildQuery = (itemQuery, model)=>{
-    logger.default('build', {
-        itemQuery
-    });
+    logger.default(`QueryBuilder build called with itemQuery: ${stringifyJSON(itemQuery)}`);
     let options = {
         where: {}
     };
     if (itemQuery.compoundCondition) {
-        logger.default('Adding Conditions', {
-            compoundCondition: itemQuery.compoundCondition
-        });
+        logger.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
@@ -252,9 +260,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.default('Limiting to', {
-            limit: itemQuery.limit
-        });
+        logger.default(`QueryBuilder applying limit: ${itemQuery.limit}`);
         options.limit = itemQuery.limit;
     }
     // Apply an offset to the result set
@@ -281,4 +287,4 @@ const buildQuery = (itemQuery, model)=>{
 };
 
 export { addCompoundCondition, addCondition, buildQuery };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/contained/Instance.js

@@ -1,17 +1,24 @@
 import { Contained } from '@fjell/lib';
-import { createDefinition } from '../Definition.js';
 import { createOperations } from '../Operations.js';
+import { createOptions } from '../Options.js';
+import { createCoordinate } from '../Coordinate.js';
 
 function createInstance(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 = Contained.wrapOperations(operations, options, coordinate, registry);
     return {
-        definition,
-        operations: Contained.wrapOperations(operations, definition, registry),
-        models,
-        registry
+        coordinate,
+        registry,
+        operations: wrappedOperations,
+        options,
+        models
     };
 }
 
 export { createInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/index.js

@@ -1,10 +1,11 @@
-export { SCOPE_SEQUELIZE, createCoordinate } from './Coordinate.js';
 export { createDefinition } from './Definition.js';
-export { createInstance } from './Instance.js';
+export { createInstance, isInstance } from './Instance.js';
+export { createInstanceFactory } from './InstanceFactory.js';
 export { createOptions } from './Options.js';
 export { createOperations } from './Operations.js';
 import * as index from './contained/index.js';
 export { index as Contained };
 import * as index$1 from './primary/index.js';
 export { index$1 as Primary };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OzsifQ==
+export { SCOPE_SEQUELIZE, createCoordinate } from './Coordinate.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7In0=

package/dist/es/ops/all.js

@@ -5,6 +5,7 @@ import { processRow } from '../RowProcessor.js';
 import { Op } from 'sequelize';
 import { buildRelationshipPath } from '../util/relationshipUtils.js';
 import { contextManager } from '../OperationContext.js';
+import { stringifyJSON } from '../util/general.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'all');
 // Helper function to merge includes avoiding duplicates
@@ -31,10 +32,8 @@ const getAllOperation = (models, definition, registry)=>{
     const { coordinate, options: { references, aggregations } } = definition;
     //#region Query
     const all = async (itemQuery, locations)=>{
-        logger.default('All', {
-            itemQuery,
-            locations
-        });
+        var _options_include;
+        logger.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];
@@ -65,24 +64,44 @@ const 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.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]: {
-                        [Op.eq]: locKey.lk
-                    }
+                // Check if this field already has a condition from the itemQuery
+                if (options.where[foreignKeyField]) {
+                    logger.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
+                    continue; // Skip this location constraint to avoid conflicts
+                }
+                logger.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+                options.where[foreignKeyField] = {
+                    [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.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) {
+                    // Check if this field already has a condition from the itemQuery
+                    if (options.where[relationshipInfo.path]) {
+                        logger.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]: {
-                            [Op.eq]: locKey.lk
-                        }
+                    logger.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+                    options.where[relationshipInfo.path] = {
+                        [Op.eq]: locKey.lk
                     };
                     // Add necessary includes for the relationship traversal
                     if (relationshipInfo.includes) {
@@ -96,22 +115,27 @@ const getAllOperation = (models, definition, registry)=>{
                 options.include = mergeIncludes(existingIncludes, additionalIncludes);
             }
         }
-        logger.default('Configured this Item Query', {
-            itemQuery,
-            options
-        });
+        logger.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.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.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 = 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 validateKeys(processedRow, coordinate.kta);
         }));
+        logger.debug(`[ALL] Returning ${results.length} ${model.name} records`);
+        return results;
     };
     return all;
 };
 
 export { getAllOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9