@fjell/lib-sequelize 4.4.1 → 4.4.2

package/dist/es/ops/create.js

@@ -1,19 +1,150 @@
+import { isPriKey, isComKey, validateKeys } from '@fjell/core';
 import LibLogger from '../logger.js';
+import { processRow } from '../RowProcessor.js';
+import { extractEvents, removeEvents } from '../EventCoordinator.js';
+import { buildRelationshipPath, buildRelationshipChain } from '../util/relationshipUtils.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'create');
-const getCreateOperation = (// eslint-disable-next-line @typescript-eslint/no-unused-vars
-models, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-definition, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-registry)=>{
+// 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);
+        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 or chain is invalid`);
+    }
+}
+const getCreateOperation = (models, definition, registry)=>{
     const create = async (item, options)=>{
         logger.default('Create', {
             item,
             options
         });
-        throw new Error('Not implemented');
+        const { coordinate, options: { references, aggregations } } = definition;
+        const { kta } = coordinate;
+        // Get the primary model (first model in array)
+        const model = models[0];
+        const modelAttributes = model.getAttributes();
+        // Validate that all item attributes exist on the model
+        let itemData = {
+            ...item
+        };
+        // TODO: We need the opposite of processRow, something to step down from fjell to database.
+        itemData = extractEvents(itemData);
+        itemData = removeEvents(itemData);
+        for (const key of Object.keys(itemData)){
+            if (!modelAttributes[key]) {
+                throw new Error(`Attribute '${key}' does not exist on model ${model.name}`);
+            }
+        }
+        // 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.
+        // If this is a CItem then the locations will be present.
+        if (options === null || options === void 0 ? void 0 : options.key) {
+            const key = options.key;
+            if (isPriKey(key)) {
+                // Set the primary key
+                itemData.id = key.pk;
+            } else if (isComKey(key)) {
+                // Set primary key
+                itemData.id = key.pk;
+                // Process location keys - only set direct foreign keys, validate hierarchical chains
+                const comKey = key;
+                const directLocations = [];
+                const hierarchicalLocations = [];
+                // Categorize location keys as direct or hierarchical
+                for (const locKey of comKey.loc){
+                    const relationshipInfo = 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.error(errorMessage, {
+                            key: comKey,
+                            kta
+                        });
+                        throw new Error(errorMessage);
+                    }
+                    if (relationshipInfo.isDirect) {
+                        directLocations.push(locKey);
+                    } else {
+                        hierarchicalLocations.push(locKey);
+                    }
+                }
+                // Set direct foreign keys
+                for (const locKey of directLocations){
+                    const foreignKeyField = locKey.kt + 'Id';
+                    itemData[foreignKeyField] = locKey.lk;
+                }
+                // Validate hierarchical chains exist
+                for (const locKey of hierarchicalLocations){
+                    await validateHierarchicalChain(models, locKey, kta);
+                }
+            }
+        }
+        // Handle locations options
+        // This is the most frequent way relationship ids will be set
+        if (options === null || options === void 0 ? void 0 : options.locations) {
+            const directLocations = [];
+            const hierarchicalLocations = [];
+            // Categorize location keys as direct or hierarchical
+            for (const locKey of options.locations){
+                const relationshipInfo = buildRelationshipPath(model, locKey.kt, kta, true);
+                if (!relationshipInfo.found) {
+                    const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
+                    logger.error(errorMessage, {
+                        locations: options.locations,
+                        kta
+                    });
+                    throw new Error(errorMessage);
+                }
+                if (relationshipInfo.isDirect) {
+                    directLocations.push(locKey);
+                } else {
+                    hierarchicalLocations.push(locKey);
+                }
+            }
+            // Set direct foreign keys
+            for (const locKey of directLocations){
+                const foreignKeyField = locKey.kt + 'Id';
+                itemData[foreignKeyField] = locKey.lk;
+            }
+            // Validate hierarchical chains exist
+            for (const locKey of hierarchicalLocations){
+                await validateHierarchicalChain(models, locKey, kta);
+            }
+        }
+        // Create the record
+        const createdRecord = await model.create(itemData);
+        // Add key and events
+        const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
+        return validateKeys(processedRecord, kta);
     };
     return create;
 };
 
 export { getCreateOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/ops/get.js

@@ -2,8 +2,45 @@ 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;
@@ -20,17 +57,16 @@ const getGetOperation = (models, definition, registry)=>{
         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)) {
-            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 = itemKey;
-            // TODO: This should probably interrogate the model?
-            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 NotFoundError('get', coordinate, key);
@@ -42,4 +78,4 @@ const getGetOperation = (models, definition, registry)=>{
 };
 
 export { getGetOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/es/ops/remove.js

@@ -2,8 +2,45 @@ import { isValidItemKey, abbrevIK, isPriKey, isComKey } from '@fjell/core';
 import { populateEvents } from '../EventCoordinator.js';
 import { addKey } from '../KeyMaster.js';
 import LibLogger from '../logger.js';
+import { buildRelationshipPath } from '../util/relationshipUtils.js';
 
 const logger = LibLogger.get('sequelize', 'ops', 'remove');
+// 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;
@@ -24,14 +61,16 @@ registry)=>{
         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;
@@ -47,14 +86,14 @@ registry)=>{
             returnItem = item === null || item === void 0 ? void 0 : item.get({
                 plain: true
             });
-            returnItem = addKey(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 = addKey(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');
@@ -65,4 +104,4 @@ registry)=>{
 };
 
 export { getRemoveOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/ops/update.js

@@ -1,5 +1,5 @@
 import { abbrevIK, isPriKey, isComKey, validateKeys } from '@fjell/core';
-import { removeEvents } from '../EventCoordinator.js';
+import { extractEvents, removeEvents } from '../EventCoordinator.js';
 import { removeKey } from '../KeyMaster.js';
 import LibLogger from '../logger.js';
 import { processRow } from '../RowProcessor.js';
@@ -35,7 +35,9 @@ const getUpdateOperation = (models, definition, registry)=>{
         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
@@ -52,4 +54,4 @@ const getUpdateOperation = (models, definition, registry)=>{
 };
 
 export { getUpdateOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

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