@fjell/lib-sequelize 4.4.0 → 4.4.2

package/dist/es/KeyMaster.js

@@ -0,0 +1,124 @@
+import LibLogger from './logger.js';
+import { buildRelationshipPath } from './util/relationshipUtils.js';
+
+const logger = LibLogger.get('sequelize', 'KeyMaster');
+// Helper function to extract location key value from item
+const extractLocationKeyValue = (model, item, locatorType, kta)=>{
+    logger.default('Extracting location key value', {
+        locatorType,
+        kta
+    });
+    const relationshipInfo = buildRelationshipPath(model, locatorType, kta, true);
+    if (!relationshipInfo.found) {
+        throw new Error(`Location key '${locatorType}' cannot be resolved on model '${model.name}' or through its relationships.`);
+    }
+    if (relationshipInfo.isDirect) {
+        // Direct foreign key field
+        const foreignKeyField = `${locatorType}Id`;
+        const value = item[foreignKeyField];
+        if (typeof value === 'undefined' || value === null) {
+            throw new Error(`Direct foreign key field '${foreignKeyField}' is missing or null in item`);
+        }
+        return value;
+    } else {
+        // Need to traverse relationship
+        // Try to get the value from the loaded relationship object
+        const relationshipObject = item[locatorType];
+        if (relationshipObject && typeof relationshipObject.id !== 'undefined') {
+            return relationshipObject.id;
+        }
+        // If the relationship object isn't loaded, we might need to look at the foreign key field
+        // This handles cases where we have the foreign key but not the full object
+        const foreignKeyField = `${locatorType}Id`;
+        if (typeof item[foreignKeyField] !== 'undefined' && item[foreignKeyField] !== null) {
+            return item[foreignKeyField];
+        }
+        throw new Error(`Unable to extract location key for '${locatorType}'. Neither the relationship object nor direct foreign key is available.`);
+    }
+};
+const removeKey = (item)=>{
+    logger.default('Removing Key', {
+        item
+    });
+    delete item.key;
+    return item;
+};
+// export const populateKey = <
+//   S extends string,
+//   L1 extends string = never,
+//   L2 extends string = never,
+//   L3 extends string = never,
+//   L4 extends string = never,
+//   L5 extends string = never
+// >(
+//   item: ItemProperties<S, L1, L2, L3, L4, L5>,
+//   keyTypes: AllItemTypeArrays<S, L1, L2, L3, L4, L5>
+// ): ItemProperties<S, L1, L2, L3, L4, L5> => {
+//   if (keyTypes.length === 1) {
+//     item.key = { kt: keyTypes[0], pk: item.id };
+//     delete item.id;
+//   } else if (keyTypes.length === 2) {
+//     item.key = {
+//       kt: keyTypes[0], pk: item.id,
+//       // TODO: Shouldn't this be inspecting the model to get the primary key type?
+//       loc: [{ kt: keyTypes[1], lk: item[keyTypes[1] + 'Id'] }],
+//     };
+//     delete item.id;
+//     delete item[keyTypes[1] + 'Id'];
+//   } else {
+//     throw new Error('Not implemented');
+//   }
+//   return item;
+// }
+const addKey = (model, item, keyTypes)=>{
+    logger.default('Adding Key', {
+        item
+    });
+    const key = {};
+    const modelClass = model.constructor;
+    const primaryKeyAttr = modelClass.primaryKeyAttribute;
+    if (Array.isArray(keyTypes) && keyTypes.length > 1) {
+        const type = [
+            ...keyTypes
+        ];
+        const pkType = type.shift();
+        Object.assign(key, {
+            kt: pkType,
+            pk: item[primaryKeyAttr]
+        });
+        // Build location keys for composite key
+        const locationKeys = [];
+        for (const locatorType of type){
+            try {
+                const lk = extractLocationKeyValue(modelClass, item, locatorType, keyTypes);
+                locationKeys.push({
+                    kt: locatorType,
+                    lk
+                });
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.error(`Failed to extract location key for '${locatorType}'`, {
+                    error: errorMessage,
+                    item,
+                    keyTypes
+                });
+                throw error;
+            }
+        }
+        Object.assign(key, {
+            loc: locationKeys
+        });
+    } else {
+        Object.assign(key, {
+            kt: keyTypes[0],
+            pk: item[primaryKeyAttr]
+        });
+    }
+    Object.assign(item, {
+        key
+    });
+    return item;
+};
+
+export { addKey, removeKey };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiS2V5TWFzdGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{Operations.js → es/Operations.js}

@@ -6,16 +6,16 @@ import { getOneOperation } from './ops/one.js';
 import { getRemoveOperation } from './ops/remove.js';
 import { getUpdateOperation } from './ops/update.js';
 
-const createOperations = (models, definition)=>{
+const createOperations = (models, definition, registry)=>{
     const operations = {};
-    operations.all = getAllOperation(models, definition);
-    operations.one = getOneOperation(models, definition);
-    operations.create = getCreateOperation();
-    operations.update = getUpdateOperation(models, definition);
-    operations.get = getGetOperation(models, definition);
+    operations.all = getAllOperation(models, definition, registry);
+    operations.one = getOneOperation(models, definition, registry);
+    operations.create = getCreateOperation(models, definition, registry);
+    operations.update = getUpdateOperation(models, definition, registry);
+    operations.get = getGetOperation(models, definition, registry);
     operations.remove = getRemoveOperation(models, definition);
-    operations.find = getFindOperation(models, definition);
-    operations.upsert = ()=>{
+    operations.find = getFindOperation(models, definition, registry);
+    operations.upsert = async ()=>{
         throw new Error('Not implemented');
     };
     return operations;

package/dist/{Options.js → es/Options.js}

@@ -1,19 +1,16 @@
 import * as Library from '@fjell/lib';
 import deepmerge from 'deepmerge';
+import { clean } from './util/general.js';
 
-const defaultOptions = {
-    deleteOnRemove: false
+const DEFAULT_OPTIONS = {
+    deleteOnRemove: false,
+    references: [],
+    aggregations: []
 };
 const createOptions = (libOptions)=>{
-    const defaultOptions = {
-        deleteOnRemove: false
-    };
     const options = Library.createOptions(libOptions);
-    const mergedOptions = deepmerge(defaultOptions, options);
-    return {
-        ...mergedOptions
-    };
+    return deepmerge(DEFAULT_OPTIONS, clean(options));
 };
 
-export { createOptions, defaultOptions };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+export { createOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3B0aW9ucy5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/{QueryBuilder.js → es/QueryBuilder.js}

@@ -80,7 +80,8 @@ const addReferenceQueries = (options, references, model)=>{
     return options;
 };
 const addCompoundCondition = (options, compoundCondition, model)=>{
-    const where = {};
+    // Ensure options.where exists
+    options.where = options.where || {};
     let compoundOp;
     const compoundType = compoundCondition.compoundType;
     if (compoundType === "AND") {
@@ -96,36 +97,135 @@ const addCompoundCondition = (options, compoundCondition, model)=>{
             throw new Error('Nest Compound conditions not supported');
         }
     });
-    where[compoundOp] = conditions;
-    options.where = where;
+    // Merge with existing where conditions instead of replacing
+    if (Object.keys(options.where).length > 0) {
+        // If there are existing conditions, wrap everything in an AND
+        options.where = {
+            [Op.and]: [
+                options.where,
+                {
+                    [compoundOp]: conditions
+                }
+            ]
+        };
+    } else {
+        // If no existing conditions, just set the compound condition
+        options.where[compoundOp] = conditions;
+    }
     return options;
 };
-const addCondition = (conditions, condition, model)=>{
-    let conditionOp;
+const getSequelizeOperator = (operator)=>{
+    if (operator === '==') {
+        return Op.eq;
+    } else if (operator === '<') {
+        return Op.lt;
+    } else if (operator === '>') {
+        return Op.gt;
+    } else if (operator === '<=') {
+        return Op.lte;
+    } else if (operator === '>=') {
+        return Op.gte;
+    } else if (operator === 'in') {
+        return Op.in;
+    } else {
+        throw new Error(`Operator ${operator} not supported`);
+    }
+};
+const addAssociationCondition = (conditions, condition, model)=>{
+    const [associationName, attributeName] = condition.column.split('.', 2);
+    // Check if the association exists on the model
+    if (!model.associations || !model.associations[associationName]) {
+        throw new Error(`Association ${associationName} not found on model ${model.name}`);
+    }
+    const association = model.associations[associationName];
+    const associatedModel = association.target;
+    // Check if the attribute exists on the associated model
+    if (!associatedModel.getAttributes()[attributeName]) {
+        throw new Error(`Attribute ${attributeName} not found on associated model ${associatedModel.name} for association ${associationName}`);
+    }
+    // Use Sequelize's $association.attribute$ syntax for querying associated models
+    const sequelizeAssociationColumn = `$${associationName}.${attributeName}$`;
+    const conditionOp = getSequelizeOperator(condition.operator);
+    conditions[sequelizeAssociationColumn] = {
+        [conditionOp]: condition.value
+    };
+    return conditions;
+};
+const addAttributeCondition = (conditions, condition, model)=>{
     const conditionColumn = condition.column;
     if (!model.getAttributes()[conditionColumn]) {
         throw new Error(`Condition column ${conditionColumn} not found on model ${model.name}`);
     }
-    if (condition.operator === '==') {
-        conditionOp = Op.eq;
-    } else if (condition.operator === '<') {
-        conditionOp = Op.lt;
-    } else if (condition.operator === '>') {
-        conditionOp = Op.gt;
-    } else if (condition.operator === '<=') {
-        conditionOp = Op.lte;
-    } else if (condition.operator === '>=') {
-        conditionOp = Op.gte;
-    } else if (condition.operator === 'in') {
-        conditionOp = Op.in;
-    } else {
-        throw new Error(`Operator ${condition.operator} not supported`);
-    }
+    const conditionOp = getSequelizeOperator(condition.operator);
     conditions[conditionColumn] = {
         [conditionOp]: condition.value
     };
     return conditions;
 };
+const addCondition = (conditions, condition, model)=>{
+    const conditionColumn = condition.column;
+    // Check if this is an association query (contains a dot)
+    if (conditionColumn.includes('.')) {
+        return addAssociationCondition(conditions, condition, model);
+    }
+    // Handle regular column queries
+    return addAttributeCondition(conditions, condition, model);
+};
+const collectAssociationsFromConditions = (conditions)=>{
+    const associations = new Set();
+    const processObject = (obj)=>{
+        if (typeof obj === 'object' && obj !== null) {
+            // Check string keys
+            Object.keys(obj).forEach((key)=>{
+                // Check if this is an association reference ($association.attribute$)
+                if (typeof key === 'string' && key.startsWith('$') && key.endsWith('$') && key.includes('.')) {
+                    const associationName = key.substring(1, key.indexOf('.'));
+                    associations.add(associationName);
+                }
+                // Recursively process nested objects
+                if (typeof obj[key] === 'object') {
+                    processObject(obj[key]);
+                }
+            });
+            // Also check Symbol keys (for compound conditions like Op.and, Op.or)
+            Object.getOwnPropertySymbols(obj).forEach((symbol)=>{
+                if (typeof obj[symbol] === 'object') {
+                    processObject(obj[symbol]);
+                }
+            });
+        }
+        // Handle arrays (for compound conditions that might be arrays)
+        if (Array.isArray(obj)) {
+            obj.forEach((item)=>{
+                if (typeof item === 'object') {
+                    processObject(item);
+                }
+            });
+        }
+    };
+    processObject(conditions);
+    return associations;
+};
+const addAssociationIncludes = (options, model)=>{
+    // Collect all association names used in conditions
+    const referencedAssociations = collectAssociationsFromConditions(options.where);
+    if (referencedAssociations.size > 0) {
+        options.include = options.include || [];
+        // Add each referenced association to the include array
+        referencedAssociations.forEach((associationName)=>{
+            // Check if this association is already included
+            const alreadyIncluded = options.include.some((inc)=>typeof inc === 'string' && inc === associationName || typeof inc === 'object' && inc.association === associationName);
+            if (!alreadyIncluded && model.associations && model.associations[associationName]) {
+                options.include.push({
+                    model: model.associations[associationName].target,
+                    as: associationName,
+                    required: false // Use LEFT JOIN so records without associations are still returned
+                });
+            }
+        });
+    }
+    return options;
+};
 const buildQuery = (itemQuery, model)=>{
     logger.default('build', {
         itemQuery
@@ -175,8 +275,10 @@ const buildQuery = (itemQuery, model)=>{
             ];
         });
     }
+    // Add includes for any associations referenced in conditions
+    options = addAssociationIncludes(options, model);
     return options;
 };
 
 export { addCompoundCondition, addCondition, buildQuery };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUXVlcnlCdWlsZGVyLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/es/ReferenceBuilder.js

@@ -0,0 +1,30 @@
+const buildReference = async (item, referenceDefinition, registry)=>{
+    // Check if there is more than one key type
+    if (referenceDefinition.kta.length > 1) {
+        throw new Error("The ReferenceBuilder doesn't work with more than one key type yet");
+    }
+    // Check if dependencies exist
+    if (!registry) {
+        throw new Error("This model definition has a reference definition, but the registry is not present");
+    }
+    // Find the Library.Instance for the key type
+    const library = registry.get(referenceDefinition.kta);
+    if (!library) {
+        throw new Error("This model definition has a reference definition, but the dependency is not present");
+    }
+    // Create a PriKey using the column value from item
+    const priKey = {
+        kt: referenceDefinition.kta[0],
+        pk: item[referenceDefinition.column]
+    };
+    // Get the referenced item using the Library.Operations get method
+    const referencedItem = await library.operations.get(priKey);
+    // TODO: In a Fjell-compliant implementation, this value should be stored in the ref property
+    // For now, we'll just populate the property directly
+    // Store the result in the property on item
+    item[referenceDefinition.property] = referencedItem;
+    return item;
+};
+
+export { buildReference };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVmZXJlbmNlQnVpbGRlci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/RowProcessor.js

@@ -0,0 +1,37 @@
+import LibLogger from './logger.js';
+import { addKey } from './KeyMaster.js';
+import { buildReference } from './ReferenceBuilder.js';
+import { buildAggregation } from './AggregationBuilder.js';
+import { stringifyJSON } from './util/general.js';
+import { populateEvents } from './EventCoordinator.js';
+
+const logger = LibLogger.get('sequelize', 'RowProcessor');
+const processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry)=>{
+    logger.default('Processing Row', {
+        row
+    });
+    let item = row.get({
+        plain: true
+    });
+    logger.default('Adding Key to Item with Key Types: %s', stringifyJSON(keyTypes));
+    item = addKey(row, item, keyTypes);
+    item = populateEvents(item);
+    logger.default('Key Added to Item: %s', stringifyJSON(item.key));
+    if (referenceDefinitions && referenceDefinitions.length > 0) {
+        for (const referenceDefinition of referenceDefinitions){
+            logger.default('Processing Reference for %s to %s', item.key.kt, stringifyJSON(referenceDefinition.kta));
+            item = await buildReference(item, referenceDefinition, registry);
+        }
+    }
+    if (aggregationDefinitions && aggregationDefinitions.length > 0) {
+        for (const aggregationDefinition of aggregationDefinitions){
+            logger.default('Processing Aggregation for %s from %s', item.key.kt, stringifyJSON(aggregationDefinition.kta));
+            item = await buildAggregation(item, aggregationDefinition, registry);
+        }
+    }
+    logger.default('Processed Row: %j', stringifyJSON(item));
+    return item;
+};
+
+export { processRow };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUm93UHJvY2Vzc29yLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

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

@@ -2,15 +2,16 @@ import { Contained } from '@fjell/lib';
 import { createDefinition } from '../Definition.js';
 import { createOperations } from '../Operations.js';
 
-function createInstance(keyTypes, models, libOptions = {}, scopes = []) {
+function createInstance(keyTypes, models, libOptions = {}, scopes = [], registry) {
     const definition = createDefinition(keyTypes, scopes, libOptions);
-    const operations = createOperations(models, definition);
+    const operations = createOperations(models, definition, registry);
     return {
         definition,
-        operations: Contained.wrapOperations(operations, definition),
-        models
+        operations: Contained.wrapOperations(operations, definition, registry),
+        models,
+        registry
     };
 }
 
 export { createInstance };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zdGFuY2UuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/{index.js → es/index.js}

@@ -1,7 +1,7 @@
 export { SCOPE_SEQUELIZE, createCoordinate } from './Coordinate.js';
 export { createDefinition } from './Definition.js';
 export { createInstance } from './Instance.js';
-export { createOptions, defaultOptions } from './Options.js';
+export { createOptions } from './Options.js';
 export { createOperations } from './Operations.js';
 import * as index from './contained/index.js';
 export { index as Contained };

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

@@ -5,8 +5,8 @@ import { processRow } from '../RowProcessor.js';
 import { Op } from 'sequelize';
 
 const logger = LibLogger.get('sequelize', 'ops', 'all');
-const getAllOperation = (models, definition)=>{
-    const { coordinate } = definition;
+const getAllOperation = (models, definition, registry)=>{
+    const { coordinate, options: { references, aggregations } } = definition;
     //#region Query
     const all = async (itemQuery, locations)=>{
         logger.default('All', {
@@ -46,10 +46,13 @@ const getAllOperation = (models, definition)=>{
         const matchingItems = await model.findAll(options);
         // this.logger.default('Matching Items', { matchingItems });
         // TODO: Move this Up!
-        return matchingItems.map((row)=>validateKeys(processRow(row, coordinate.kta), coordinate.kta));
+        return await Promise.all(matchingItems.map(async (row)=>{
+            const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry);
+            return validateKeys(processedRow, coordinate.kta);
+        }));
     };
     return all;
 };
 
 export { getAllOperation };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/es/ops/create.js

@@ -0,0 +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');
+// 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
+        });
+        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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9