@fjell/lib-sequelize 4.4.0 → 4.4.2

package/dist/{ops → es/ops}/find.js

@@ -1,8 +1,10 @@
+import { validateKeys } from '@fjell/core';
 import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'find');
-const getFindOperation = (models, definition)=>{
-    const { options } = definition;
+const getFindOperation = (models, definition, registry)=>{
+    const { options: { finders, references, aggregations } } = definition;
     const find = async (finder, finderParams, locations)=>{
         logger.default('Find', {
             finder,
@@ -11,10 +13,18 @@ const getFindOperation = (models, definition)=>{
         });
         // 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 (options.finders && options.finders[finder]) {
-            const finderMethod = options.finders[finder];
+        if (finders && finders[finder]) {
+            const finderMethod = finders[finder];
             if (finderMethod) {
-                return finderMethod(finderParams, locations);
+                const results = await finderMethod(finderParams, locations);
+                if (results && results.length > 0) {
+                    return await Promise.all(results.map(async (row)=>{
+                        const processedRow = await processRow(row, definition.coordinate.kta, references, aggregations, registry);
+                        return validateKeys(processedRow, definition.coordinate.kta);
+                    }));
+                } else {
+                    return [];
+                }
             } else {
                 logger.error(`Finder %s not found`, finder);
                 throw new Error(`Finder ${finder} not found`);
@@ -28,4 +38,4 @@ const getFindOperation = (models, definition)=>{
 };
 
 export { getFindOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/ops/get.js

@@ -0,0 +1,81 @@
+import { isValidItemKey, isPriKey, isComKey, validateKeys } from '@fjell/core';
+import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
+import { NotFoundError } from '@fjell/lib';
+import { buildRelationshipPath } from '../util/relationshipUtils.js';
+
+const logger = LibLogger.get('sequelize', 'ops', 'get');
+// Helper function to process composite key and build query options
+const processCompositeKey = (comKey, model, kta)=>{
+    const where = {
+        id: comKey.pk
+    };
+    const includes = [];
+    for (const locator of comKey.loc){
+        const relationshipInfo = buildRelationshipPath(model, locator.kt, kta);
+        if (!relationshipInfo.found) {
+            const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
+            logger.error(errorMessage, {
+                key: comKey,
+                kta
+            });
+            throw new Error(errorMessage);
+        }
+        if (relationshipInfo.path) {
+            // This requires a relationship traversal
+            where[relationshipInfo.path] = locator.lk;
+            if (relationshipInfo.includes) {
+                includes.push(...relationshipInfo.includes);
+            }
+        } else {
+            // This is a direct field
+            const fieldName = `${locator.kt}Id`;
+            where[fieldName] = locator.lk;
+        }
+    }
+    const result = {
+        where
+    };
+    if (includes.length > 0) {
+        result.include = includes;
+    }
+    return result;
+};
+const getGetOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
+    const { kta } = coordinate;
+    const get = async (key)=>{
+        logger.default('Get', {
+            key
+        });
+        if (!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');
+        }
+        const itemKey = key;
+        // @ts-ignore
+        const model = models[0];
+        let item;
+        if (isPriKey(itemKey)) {
+            // This is the easy case because we can just find the item by its primary key
+            item = await model.findByPk(itemKey.pk);
+        } else if (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(comKey, model, kta);
+            logger.default('Composite key query', {
+                queryOptions
+            });
+            item = await model.findOne(queryOptions);
+        }
+        if (!item) {
+            throw new NotFoundError('get', coordinate, key);
+        } else {
+            return validateKeys(await processRow(item, kta, references, aggregations, registry), kta);
+        }
+    };
+    return get;
+};
+
+export { getGetOperation };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/{ops → es/ops}/one.js

@@ -2,13 +2,13 @@ import LibLogger from '../logger.js';
 import { getAllOperation } from './all.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'one');
-const getOneOperation = (models, definition)=>{
+const getOneOperation = (models, definition, registry)=>{
     const one = async (itemQuery, locations = [])=>{
         logger.default('One', {
             itemQuery,
             locations
         });
-        const items = await getAllOperation(models, definition)(itemQuery, locations);
+        const items = await getAllOperation(models, definition, registry)(itemQuery, locations);
         if (items.length > 0) {
             return items[0];
         } else {

package/dist/{ops → es/ops}/remove.js

@@ -1,10 +1,48 @@
 import { isValidItemKey, abbrevIK, isPriKey, isComKey } from '@fjell/core';
 import { populateEvents } from '../EventCoordinator.js';
-import { populateKey } from '../KeyMaster.js';
+import { addKey } from '../KeyMaster.js';
 import LibLogger from '../logger.js';
+import { buildRelationshipPath } from '../util/relationshipUtils.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'remove');
-const getRemoveOperation = (models, definition)=>{
+// Helper function to process composite key and build query options
+const processCompositeKey = (comKey, model, kta)=>{
+    const where = {
+        id: comKey.pk
+    };
+    const includes = [];
+    for (const locator of comKey.loc){
+        const relationshipInfo = buildRelationshipPath(model, locator.kt, kta);
+        if (!relationshipInfo.found) {
+            const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
+            logger.error(errorMessage, {
+                key: comKey,
+                kta
+            });
+            throw new Error(errorMessage);
+        }
+        if (relationshipInfo.path) {
+            // This requires a relationship traversal
+            where[relationshipInfo.path] = locator.lk;
+            if (relationshipInfo.includes) {
+                includes.push(...relationshipInfo.includes);
+            }
+        } else {
+            // This is a direct field
+            const fieldName = `${locator.kt}Id`;
+            where[fieldName] = locator.lk;
+        }
+    }
+    const result = {
+        where
+    };
+    if (includes.length > 0) {
+        result.include = includes;
+    }
+    return result;
+};
+const getRemoveOperation = (models, definition, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+registry)=>{
     const { coordinate, options } = definition;
     const { kta } = coordinate;
     const remove = async (key)=>{
@@ -23,14 +61,16 @@ const getRemoveOperation = (models, definition)=>{
         if (isPriKey(key)) {
             item = await model.findByPk(key.pk);
         } else if (isComKey(key)) {
-            var _comKey_loc_, _comKey_loc_1;
+            // This is a composite key, so we need to build a where clause based on the composite key's locators
             const comKey = key;
-            item = await model.findOne({
-                where: {
-                    id: comKey.pk,
-                    [(comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_ = comKey.loc[0]) === null || _comKey_loc_ === void 0 ? void 0 : _comKey_loc_.kt) + 'Id']: comKey === null || comKey === void 0 ? void 0 : (_comKey_loc_1 = comKey.loc[0]) === null || _comKey_loc_1 === void 0 ? void 0 : _comKey_loc_1.lk
-                }
+            const queryOptions = processCompositeKey(comKey, model, kta);
+            logger.default('Composite key query', {
+                queryOptions
             });
+            item = await model.findOne(queryOptions);
+        }
+        if (!item) {
+            throw new Error(`Item not found for removal with key: ${abbrevIK(key)}`);
         }
         const isDeletedAttribute = model.getAttributes().isDeleted;
         const deletedAtAttribute = model.getAttributes().deletedAt;
@@ -46,14 +86,14 @@ const getRemoveOperation = (models, definition)=>{
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
             });
-            returnItem = populateKey(returnItem, kta);
+            returnItem = addKey(item, returnItem, kta);
             returnItem = populateEvents(returnItem);
         } else if (options.deleteOnRemove) {
             await (item === null || item === void 0 ? void 0 : item.destroy());
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
             });
-            returnItem = populateKey(returnItem, kta);
+            returnItem = addKey(item, returnItem, kta);
             returnItem = populateEvents(returnItem);
         } else {
             throw new Error('No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set');
@@ -64,4 +104,4 @@ const getRemoveOperation = (models, definition)=>{
 };
 
 export { getRemoveOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{ops → es/ops}/update.js

@@ -1,11 +1,14 @@
-import { abbrevIK, isPriKey, isComKey } from '@fjell/core';
-import { removeEvents, populateEvents } from '../EventCoordinator.js';
-import { removeKey, populateKey } from '../KeyMaster.js';
+import { abbrevIK, isPriKey, isComKey, validateKeys } from '@fjell/core';
+import { extractEvents, removeEvents } from '../EventCoordinator.js';
+import { removeKey } from '../KeyMaster.js';
 import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
+import { stringifyJSON } from '../util/general.js';
 import { NotFoundError } from '@fjell/lib';
 
 const logger = LibLogger.get('sequelize', 'ops', 'update');
-const getUpdateOperation = (models, definition)=>{
+const getUpdateOperation = (models, definition, registry)=>{
+    const { options: { references, aggregations } } = definition;
     const update = async (key, item)=>{
         const { coordinate } = definition;
         const { kta } = coordinate;
@@ -32,19 +35,16 @@ const getUpdateOperation = (models, definition)=>{
         if (response) {
             // Remove the key and events
             let updateProps = removeKey(item);
-            updateProps = removeEvents(item);
+            // TODO: We need the opposite of processRow, something to step down from fjell to database.
+            updateProps = extractEvents(updateProps);
+            updateProps = removeEvents(updateProps);
+            logger.default('Response: %s', stringifyJSON(response));
+            logger.default('Update Properties: %s', stringifyJSON(updateProps));
             // Update the object
-            response = {
-                ...response,
-                ...updateProps
-            };
-            await (response === null || response === void 0 ? void 0 : response.save());
+            response = await response.update(updateProps);
             // Populate the key and events
-            let returnItem = response === null || response === void 0 ? void 0 : response.get({
-                plain: true
-            });
-            returnItem = populateKey(returnItem, kta);
-            returnItem = populateEvents(returnItem);
+            const processedItem = await processRow(response, kta, references, aggregations, registry);
+            const returnItem = validateKeys(processedItem, kta);
             return returnItem;
         } else {
             throw new NotFoundError('update', coordinate, key);

package/dist/{primary → es/primary}/Instance.js

@@ -4,7 +4,7 @@ import { createOperations } from '../Operations.js';
 import LibLogger from '../logger.js';
 
 const logger = LibLogger.get('lib-sequelize', 'primary', 'instance');
-function createInstance(keyType, models, libOptions = {}, scopes = []) {
+function createInstance(keyType, models, libOptions = {}, scopes = [], registry) {
     logger.debug('createInstance', {
         keyType,
         models,
@@ -14,13 +14,14 @@ function createInstance(keyType, models, libOptions = {}, scopes = []) {
     const definition = createDefinition([
         keyType
     ], scopes, libOptions);
-    const operations = createOperations(models, definition);
+    const operations = createOperations(models, definition, registry);
     return {
         definition,
-        operations: Primary.wrapOperations(operations, definition),
-        models
+        operations: Primary.wrapOperations(operations, definition, registry),
+        models,
+        registry
     };
 }
 
 export { createInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/util/general.js

@@ -0,0 +1,47 @@
+/* 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 = [];
+    const arrVals = [];
+    let objKeys = [];
+    /*********CHECK FOR PRIMITIVE TYPES**********/ if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null) return '' + obj;
+    else if (typeof obj === 'string') return '"' + obj + '"';
+    /*********DETECT CIRCULAR REFERENCES**********/ if (obj instanceof Object && visited.has(obj)) {
+        return '"(circular)"';
+    } else if (Array.isArray(obj)) {
+        //check for empty array
+        if (obj[0] === undefined) return '[]';
+        else {
+            // Add array to visited before processing its elements
+            visited.add(obj);
+            obj.forEach(function(el) {
+                arrVals.push(stringifyJSON(el, visited));
+            });
+            return '[' + arrVals + ']';
+        }
+    } else if (obj instanceof Object) {
+        // Add object to visited before processing its properties
+        visited.add(obj);
+        //get object keys
+        objKeys = Object.keys(obj);
+        //set key output;
+        objKeys.forEach(function(key) {
+            const keyOut = '"' + key + '":';
+            const keyValOut = obj[key];
+            //skip functions and undefined properties
+            if (keyValOut instanceof Function || keyValOut === undefined) return; // Skip this entry entirely instead of pushing an empty string
+            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 + stringifyJSON(keyValOut, visited));
+            }
+        });
+        return '{' + arrOfKeyVals + '}';
+    }
+    return '';
+};
+
+export { clean, stringifyJSON };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhbC5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/util/relationshipUtils.js

@@ -0,0 +1,112 @@
+/* eslint-disable indent */ /**
+ * Helper function to build relationship chain includes
+ */ const buildRelationshipChain = (targetModel, kta, currentIndex, targetIndex)=>{
+    // Build the association path and validate relationships exist
+    const associationParts = [];
+    const modelChain = [
+        targetModel
+    ];
+    let currentModel = targetModel;
+    // Validate that all associations exist and build model chain
+    for(let i = currentIndex + 1; i <= targetIndex; i++){
+        const intermediateType = kta[i];
+        const associationName = intermediateType;
+        if (!currentModel.associations || !currentModel.associations[associationName]) {
+            return {
+                success: false
+            };
+        }
+        associationParts.push(associationName);
+        currentModel = currentModel.associations[associationName].target;
+        modelChain.push(currentModel);
+    }
+    // Build the full association path for the target field
+    const targetType = kta[targetIndex];
+    const associationPath = `$${associationParts.join('.')}.${targetType}Id$`;
+    // Build nested includes structure iteratively (clearer than recursion)
+    let deepestInclude = null;
+    // Build from the deepest level back to the root
+    for(let i = targetIndex; i > currentIndex; i--){
+        const currentType = kta[i];
+        const modelIndex = i - currentIndex;
+        const includeObj = {
+            model: modelChain[modelIndex],
+            as: currentType,
+            required: true
+        };
+        if (deepestInclude) {
+            includeObj.include = [
+                deepestInclude
+            ];
+        }
+        deepestInclude = includeObj;
+    }
+    const includes = deepestInclude ? [
+        deepestInclude
+    ] : [];
+    return {
+        success: true,
+        path: associationPath,
+        includes
+    };
+};
+/**
+ * Helper function to build relationship path for a locator
+ * @param includeIsDirect Whether to include the isDirect flag in the result
+ */ const buildRelationshipPath = (targetModel, locatorType, kta, includeIsDirect = false)=>{
+    // First check if the field exists directly
+    const directFieldName = `${locatorType}Id`;
+    const attributes = targetModel.getAttributes();
+    if (attributes && attributes[directFieldName]) {
+        const result = {
+            found: true
+        };
+        if (includeIsDirect) {
+            result.isDirect = true;
+        }
+        return result;
+    }
+    // If not direct, look for relationship path
+    const targetIndex = kta.indexOf(locatorType);
+    if (targetIndex === -1) {
+        const result = {
+            found: false
+        };
+        if (includeIsDirect) {
+            result.isDirect = false;
+        }
+        return result;
+    }
+    const currentIndex = 0; // We're always looking from the base model
+    if (targetIndex <= currentIndex) {
+        const result = {
+            found: false
+        };
+        if (includeIsDirect) {
+            result.isDirect = false;
+        }
+        return result;
+    }
+    const chainResult = buildRelationshipChain(targetModel, kta, currentIndex, targetIndex);
+    if (chainResult.success) {
+        const result = {
+            found: true,
+            path: chainResult.path,
+            includes: chainResult.includes
+        };
+        if (includeIsDirect) {
+            result.isDirect = false;
+        }
+        return result;
+    }
+    const result = {
+        found: false
+    };
+    if (includeIsDirect) {
+        result.isDirect = false;
+    }
+    return result;
+};
+
+export { buildRelationshipChain, buildRelationshipPath };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsYXRpb25zaGlwVXRpbHMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9