@fjell/lib-sequelize 4.4.5 → 4.4.10

package/dist/cjs/ops/create.cjs

@@ -7,47 +7,114 @@ const logger$1 = require('../logger.cjs');
 const RowProcessor = require('../RowProcessor.cjs');
 const EventCoordinator = require('../EventCoordinator.cjs');
 const relationshipUtils = require('../util/relationshipUtils.cjs');
+const general = require('../util/general.cjs');
 
 const logger = 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.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 = relationshipUtils.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 = relationshipUtils.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.default('Create', {
-            item,
-            options
-        });
+        logger.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.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)
@@ -60,11 +127,17 @@ const getCreateOperation = (models, definition, registry)=>{
         // TODO: We need the opposite of processRow, something to step down from fjell to database.
         itemData = EventCoordinator.extractEvents(itemData);
         itemData = EventCoordinator.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.
@@ -85,10 +158,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.`;
+                        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.error(errorMessage, {
                             key: comKey,
-                            kta
+                            kta,
+                            associations
                         });
                         throw new Error(errorMessage);
                     }
@@ -100,6 +175,13 @@ const getCreateOperation = (models, definition, registry)=>{
                 }
                 // Set direct foreign keys
                 for (const locKey of directLocations){
+                    if (locKey.lk == null || locKey.lk === '') {
+                        logger.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;
                 }
@@ -118,10 +200,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.`;
+                    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.error(errorMessage, {
                         locations: options.locations,
-                        kta
+                        kta,
+                        associations
                     });
                     throw new Error(errorMessage);
                 }
@@ -133,6 +217,13 @@ const getCreateOperation = (models, definition, registry)=>{
             }
             // Set direct foreign keys
             for (const locKey of directLocations){
+                if (locKey.lk == null || locKey.lk === '') {
+                    logger.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;
             }
@@ -142,13 +233,20 @@ const getCreateOperation = (models, definition, registry)=>{
             }
         }
         // Create the record
-        const createdRecord = await model.create(itemData);
-        // Add key and events
-        const processedRecord = await RowProcessor.processRow(createdRecord, kta, references, aggregations, registry);
-        return core.validateKeys(processedRecord, kta);
+        try {
+            logger.trace(`[CREATE] Executing ${model.name}.create() with data: ${general.stringifyJSON(itemData)}`);
+            const createdRecord = await model.create(itemData);
+            // Add key and events
+            const processedRecord = await RowProcessor.processRow(createdRecord, kta, references, aggregations, registry);
+            const result = core.validateKeys(processedRecord, kta);
+            logger.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;
 };
 
 exports.getCreateOperation = getCreateOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/ops/find.cjs

@@ -5,28 +5,30 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const core = require('@fjell/core');
 const logger$1 = require('../logger.cjs');
 const RowProcessor = require('../RowProcessor.cjs');
+const general = require('../util/general.cjs');
 
 const logger = 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.default('Find', {
-            finder,
-            finderParams,
-            locations
-        });
+        logger.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.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.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${general.stringifyJSON(finderParams)}, locations: ${general.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 RowProcessor.processRow(row, definition.coordinate.kta, references, aggregations, registry);
                         return core.validateKeys(processedRow, definition.coordinate.kta);
                     }));
+                    logger.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
+                    return processedResults;
                 } else {
+                    logger.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
                     return [];
                 }
             } else {
@@ -42,4 +44,4 @@ const getFindOperation = (models, definition, registry)=>{
 };
 
 exports.getFindOperation = getFindOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/ops/get.cjs

@@ -8,6 +8,7 @@ const RowProcessor = require('../RowProcessor.cjs');
 const Library = require('@fjell/lib');
 const relationshipUtils = require('../util/relationshipUtils.cjs');
 const OperationContext = require('../OperationContext.cjs');
+const general = require('../util/general.cjs');
 
 const logger = logger$1.default.get('sequelize', 'ops', 'get');
 // Helper function to process composite key and build query options
@@ -50,19 +51,19 @@ const getGetOperation = (models, definition, registry)=>{
     const { coordinate, options: { references, aggregations } } = definition;
     const { kta } = coordinate;
     const get = async (key)=>{
-        logger.default('Get', {
-            key
-        });
         if (!core.isValidItemKey(key)) {
             logger.error('Key for Get is not a valid ItemKey: %j', key);
             throw new Error('Key for Get is not a valid ItemKey');
         }
+        logger.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.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.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
@@ -71,6 +72,7 @@ const getGetOperation = (models, definition, registry)=>{
             logger.default('Composite key query', {
                 queryOptions
             });
+            logger.trace(`[GET] Executing ${model.name}.findOne() with options: ${general.stringifyJSON(queryOptions)}`);
             item = await model.findOne(queryOptions);
         }
         if (!item) {
@@ -78,11 +80,13 @@ const getGetOperation = (models, definition, registry)=>{
         } else {
             // Get the current context from context manager
             const context = OperationContext.contextManager.getCurrentContext();
-            return core.validateKeys(await RowProcessor.processRow(item, kta, references, aggregations, registry, context), kta);
+            const result = core.validateKeys(await RowProcessor.processRow(item, kta, references, aggregations, registry, context), kta);
+            logger.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
+            return result;
         }
     };
     return get;
 };
 
 exports.getGetOperation = getGetOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/cjs/ops/one.cjs

@@ -8,14 +8,15 @@ const all = require('./all.cjs');
 const logger = logger$1.default.get('sequelize', 'ops', 'one');
 const getOneOperation = (models, definition, registry)=>{
     const one = async (itemQuery, locations = [])=>{
-        logger.default('One', {
-            itemQuery,
-            locations
-        });
+        logger.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.map((loc)=>`${loc.kt}=${loc.lk}`).join(', ') || 'none'}`);
+        logger.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.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : 'unknown'}`);
+            return result;
         } else {
+            logger.debug(`[ONE] No ${models[0].name} record found`);
             return null;
         }
     };
@@ -23,4 +24,4 @@ const getOneOperation = (models, definition, registry)=>{
 };
 
 exports.getOneOperation = getOneOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib25lLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/ops/remove.cjs

@@ -7,6 +7,7 @@ const EventCoordinator = require('../EventCoordinator.cjs');
 const KeyMaster = require('../KeyMaster.cjs');
 const logger$1 = require('../logger.cjs');
 const relationshipUtils = require('../util/relationshipUtils.cjs');
+const general = require('../util/general.cjs');
 
 const logger = logger$1.default.get('sequelize', 'ops', 'remove');
 // Helper function to process composite key and build query options
@@ -50,27 +51,26 @@ registry)=>{
     const { coordinate, options } = definition;
     const { kta } = coordinate;
     const remove = async (key)=>{
-        logger.default('Remove', {
-            key
-        });
         if (!core.isValidItemKey(key)) {
             logger.error('Key for Remove is not a valid ItemKey: %j', key);
             throw new Error('Key for Remove is not a valid ItemKey');
         }
+        logger.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.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.debug('remove: %s', core.abbrevIK(key));
         if (core.isPriKey(key)) {
+            logger.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.default('Composite key query', {
-                queryOptions
-            });
+            logger.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
+            logger.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${general.stringifyJSON(queryOptions)}`);
             item = await model.findOne(queryOptions);
         }
         if (!item) {
@@ -86,6 +86,7 @@ registry)=>{
                 item.deletedAt = new Date();
             }
             // Save the object
+            logger.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
@@ -93,6 +94,7 @@ registry)=>{
             returnItem = KeyMaster.addKey(item, returnItem, kta);
             returnItem = EventCoordinator.populateEvents(returnItem);
         } else if (options.deleteOnRemove) {
+            logger.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
@@ -102,10 +104,11 @@ registry)=>{
         } else {
             throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
         }
+        logger.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
         return returnItem;
     };
     return remove;
 };
 
 exports.getRemoveOperation = getRemoveOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/ops/update.cjs

@@ -7,10 +7,10 @@ const EventCoordinator = require('../EventCoordinator.cjs');
 const KeyMaster = require('../KeyMaster.cjs');
 const logger$1 = require('../logger.cjs');
 const RowProcessor = require('../RowProcessor.cjs');
-const general = require('../util/general.cjs');
 const Library = require('@fjell/lib');
 const sequelize = require('sequelize');
 const relationshipUtils = require('../util/relationshipUtils.cjs');
+const general = require('../util/general.cjs');
 
 const logger = logger$1.default.get('sequelize', 'ops', 'update');
 // Helper function to merge includes avoiding duplicates
@@ -36,6 +36,7 @@ const mergeIncludes = (existingIncludes, newIncludes)=>{
 const getUpdateOperation = (models, definition, registry)=>{
     const { options: { references, aggregations } } = definition;
     const update = async (key, item)=>{
+        logger.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.debug('update: %s, %j', core.abbrevIK(key), item);
@@ -46,6 +47,7 @@ const getUpdateOperation = (models, definition, registry)=>{
         if (core.isPriKey(key)) {
             // Find the model by using the PK
             const priKey = key;
+            logger.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
             response = await model.findByPk(priKey.pk);
         } else if (core.isComKey(key)) {
             const comKey = key;
@@ -87,9 +89,8 @@ const getUpdateOperation = (models, definition, registry)=>{
             if (additionalIncludes.length > 0) {
                 queryOptions.include = mergeIncludes([], additionalIncludes);
             }
-            logger.default('Composite key query for update', {
-                queryOptions
-            });
+            logger.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(', ') : 'none'}`);
+            logger.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${general.stringifyJSON(queryOptions)}`);
             response = await model.findOne(queryOptions);
         }
         if (response) {
@@ -98,13 +99,15 @@ const getUpdateOperation = (models, definition, registry)=>{
             // TODO: We need the opposite of processRow, something to step down from fjell to database.
             updateProps = EventCoordinator.extractEvents(updateProps);
             updateProps = EventCoordinator.removeEvents(updateProps);
-            logger.default('Response: %s', general.stringifyJSON(response));
-            logger.default('Update Properties: %s', general.stringifyJSON(updateProps));
+            logger.default(`Update found ${model.name} record to modify`);
+            logger.default(`Update properties configured: ${Object.keys(updateProps).join(', ')}`);
             // Update the object
+            logger.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${general.stringifyJSON(updateProps)}`);
             response = await response.update(updateProps);
             // Populate the key and events
             const processedItem = await RowProcessor.processRow(response, kta, references, aggregations, registry);
             const returnItem = core.validateKeys(processedItem, kta);
+            logger.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);
@@ -114,4 +117,4 @@ const getUpdateOperation = (models, definition, registry)=>{
 };
 
 exports.getUpdateOperation = getUpdateOperation;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmNqcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/cjs/primary/Instance.cjs

@@ -3,8 +3,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const Library = require('@fjell/lib');
-const Definition = require('../Definition.cjs');
 const Operations = require('../Operations.cjs');
+const Options = require('../Options.cjs');
+const Coordinate = require('../Coordinate.cjs');
 const logger$1 = require('../logger.cjs');
 
 const logger = logger$1.default.get('lib-sequelize', 'primary', 'instance');
@@ -15,17 +16,23 @@ function createInstance(keyType, models, libOptions = {}, scopes = [], registry)
         libOptions,
         scopes
     });
-    const definition = Definition.createDefinition([
+    // Create coordinate and options separately following new pattern
+    const coordinate = Coordinate.createCoordinate([
         keyType
-    ], scopes, libOptions);
-    const operations = Operations.createOperations(models, definition, registry);
+    ], scopes);
+    const options = Options.createOptions(libOptions);
+    // Create operations with the new signature
+    const operations = 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
     };
 }
 
 exports.createInstance = createInstance;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/cjs/util/general.cjs

@@ -2,9 +2,6 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-/* eslint-disable @typescript-eslint/no-unused-vars */ /* eslint-disable no-undefined */ const clean = (obj)=>{
-    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
-};
 //Recursive implementation of jSON.stringify;
 const stringifyJSON = function(obj, visited = new Set()) {
     const arrOfKeyVals = [];
@@ -47,6 +44,5 @@ const stringifyJSON = function(obj, visited = new Set()) {
     return '';
 };
 
-exports.clean = clean;
 exports.stringifyJSON = stringifyJSON;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhbC5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhbC5janMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/Coordinate.js

@@ -1,8 +1,14 @@
-import * as Library from '@fjell/lib';
+import { createCoordinate as createCoordinate$1 } from '@fjell/registry';
+import LibLogger from './logger.js';
 
+const logger = LibLogger.get('Coordinate');
 const SCOPE_SEQUELIZE = 'sequelize';
 const createCoordinate = (kta, scopes)=>{
-    const coordinate = Library.createCoordinate(kta, [
+    logger.debug('createCoordinate', {
+        kta,
+        scopes
+    });
+    const coordinate = createCoordinate$1(kta, [
         SCOPE_SEQUELIZE,
         ...scopes || []
     ]);
@@ -10,4 +16,4 @@ const createCoordinate = (kta, scopes)=>{
 };
 
 export { SCOPE_SEQUELIZE, createCoordinate };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29vcmRpbmF0ZS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ29vcmRpbmF0ZS5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/Definition.js

@@ -1,10 +1,9 @@
-import * as Library from '@fjell/lib';
-import { createCoordinate } from './Coordinate.js';
 import { createOptions } from './Options.js';
 import LibLogger from './logger.js';
+import { createCoordinate } from './Coordinate.js';
 
 const logger = LibLogger.get('lib-sequelize', 'Definition');
-function createDefinition(kta, scopes, libOptions) {
+const createDefinition = (kta, scopes, libOptions)=>{
     logger.debug('createDefinition', {
         kta,
         scopes,
@@ -12,12 +11,11 @@ function createDefinition(kta, scopes, libOptions) {
     });
     const coordinate = createCoordinate(kta, scopes);
     const options = createOptions(libOptions);
-    const definition = Library.createDefinition(coordinate, options);
     return {
-        ...definition,
+        coordinate,
         options
     };
-}
+};
 
 export { createDefinition };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVmaW5pdGlvbi5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVmaW5pdGlvbi5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==