@fjell/lib-sequelize 4.4.69 → 4.4.71

package/dist/RowProcessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RowProcessor.d.ts","sourceRoot":"","sources":["../src/RowProcessor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAIlC,OAAO,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAC;AAChF,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AACtC,OAAO,EAEL,cAAc,EACd,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAQpB,YAAY,EAAE,gBAAgB,EAAE,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,CAAC;AAElD,eAAO,MAAM,UAAU,GAAU,CAAC,SAAS,MAAM,EAC/C,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACvB,KAAK,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EACpB,UAAU,iBAAiB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAClD,sBAAsB,4BAA4B,EAAE,EACpD,wBAAwB,qBAAqB,EAAE,EAC/C,UAAU,OAAO,CAAC,QAAQ,EAC1B,UAAU,gBAAgB,KACzB,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAyCvC,CAAC"}
+{"version":3,"file":"RowProcessor.d.ts","sourceRoot":"","sources":["../src/RowProcessor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAIlC,OAAO,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,WAAW,CAAC;AAChF,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AACtC,OAAO,EAEL,cAAc,EACd,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAUpB,YAAY,EAAE,gBAAgB,EAAE,CAAC;AACjC,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,CAAC;AAElD,eAAO,MAAM,UAAU,GAAU,CAAC,SAAS,MAAM,EAC/C,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACzB,EAAE,SAAS,MAAM,GAAG,KAAK,EACvB,KAAK,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EACpB,UAAU,iBAAiB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAClD,sBAAsB,4BAA4B,EAAE,EACpD,wBAAwB,qBAAqB,EAAE,EAC/C,UAAU,OAAO,CAAC,QAAQ,EAC1B,UAAU,gBAAgB,KACzB,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAqEvC,CAAC"}

package/dist/index.js

@@ -580,11 +580,11 @@ var removeEvents = (item) => {
 
 // src/processing/ReferenceBuilder.ts
 var buildSequelizeReference = async (item, referenceDefinition, registry, context) => {
-  const libLogger = logger_default.get("processing", "ReferenceBuilder");
+  const libLogger3 = logger_default.get("processing", "ReferenceBuilder");
   const isCompositeItem = referenceDefinition.kta.length > 1;
   const primaryKeyType = referenceDefinition.kta[0];
   if (isCompositeItem) {
-    libLogger.debug(
+    libLogger3.debug(
       "Detected composite item reference - will use ComKey with empty loc array",
       {
         kta: referenceDefinition.kta,
@@ -619,18 +619,15 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
   } else if (referenceDefinition.locationColumns && referenceDefinition.locationColumns.length > 0) {
     const locationTypes = referenceDefinition.kta.slice(1);
     const loc = [];
+    let hasNullLocation = false;
     for (let i = 0; i < referenceDefinition.locationColumns.length; i++) {
       const columnName = referenceDefinition.locationColumns[i];
       const locValue = item[columnName];
       if (locValue == null) {
-        libLogger.warning(
+        libLogger3.warning(
           `Location column '${columnName}' is null/undefined for reference '${referenceDefinition.property}'. Falling back to empty loc array search.`
         );
-        itemKey = {
-          kt: primaryKeyType,
-          pk: columnValue,
-          loc: []
-        };
+        hasNullLocation = true;
         break;
       }
       loc.push({
@@ -638,13 +635,19 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
         lk: locValue
       });
     }
-    if (!itemKey) {
+    if (hasNullLocation) {
+      itemKey = {
+        kt: primaryKeyType,
+        pk: columnValue,
+        loc: []
+      };
+    } else {
       itemKey = {
         kt: primaryKeyType,
         pk: columnValue,
         loc
       };
-      libLogger.debug("Built full ComKey with location context", {
+      libLogger3.debug("Built full ComKey with location context", {
         itemKey,
         locationColumns: referenceDefinition.locationColumns,
         property: referenceDefinition.property
@@ -656,12 +659,12 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
       pk: columnValue,
       loc: []
     };
-    libLogger.debug("Using empty loc array for composite item reference", {
+    libLogger3.debug("Using empty loc array for composite item reference", {
       kta: referenceDefinition.kta,
       property: referenceDefinition.property
     });
   }
-  libLogger.debug("Created reference key", {
+  libLogger3.debug("Created reference key", {
     itemKey,
     isCompositeItem,
     hasLocationColumns: !!referenceDefinition.locationColumns,
@@ -670,10 +673,10 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
   let referencedItem;
   if (context) {
     if (context.isCached(itemKey)) {
-      libLogger.debug("Using cached reference", { itemKey, property: referenceDefinition.property });
+      libLogger3.debug("Using cached reference", { itemKey, property: referenceDefinition.property });
       referencedItem = context.getCached(itemKey);
     } else if (context.isInProgress(itemKey)) {
-      libLogger.debug("Circular dependency detected, creating reference placeholder", {
+      libLogger3.debug("Circular dependency detected, creating reference placeholder", {
         itemKey,
         property: referenceDefinition.property
       });
@@ -707,6 +710,173 @@ var stripSequelizeReferenceItems = (item, referenceDefinitions) => {
   return result;
 };
 
+// src/processing/RefsAdapter.ts
+import { isComKey as isComKey2, isPriKey as isPriKey2 } from "@fjell/core";
+var libLogger = logger_default.get("sequelize", "processing", "RefsAdapter");
+function buildKeyFromForeignKey(refDef, foreignKeyValue, item) {
+  const primaryKeyType = refDef.kta[0];
+  const isCompositeItem = refDef.kta.length > 1;
+  if (!isCompositeItem) {
+    return {
+      kt: primaryKeyType,
+      pk: foreignKeyValue
+    };
+  }
+  const loc = [];
+  if (refDef.locationColumns && refDef.locationColumns.length > 0) {
+    for (let i = 0; i < refDef.locationColumns.length; i++) {
+      const columnName = refDef.locationColumns[i];
+      const locValue = item[columnName];
+      if (locValue != null) {
+        const locationType = refDef.kta[i + 1];
+        loc.push({
+          kt: locationType,
+          lk: locValue
+        });
+      } else {
+        libLogger.debug(
+          `Location column '${columnName}' is null/undefined for reference '${refDef.property}'. Using empty loc array.`
+        );
+        break;
+      }
+    }
+  }
+  return {
+    kt: primaryKeyType,
+    pk: foreignKeyValue,
+    loc: loc.length > 0 ? loc : []
+  };
+}
+function addRefsToSequelizeItem(item, referenceDefinitions) {
+  const refs = {};
+  for (const refDef of referenceDefinitions) {
+    const foreignKeyValue = item[refDef.column];
+    const refName = refDef.property;
+    if (foreignKeyValue != null) {
+      const key = buildKeyFromForeignKey(refDef, foreignKeyValue, item);
+      const populatedItem = item[refDef.property];
+      if (populatedItem) {
+        const { key: _itemKey, ...itemProperties } = populatedItem;
+        refs[refName] = {
+          key,
+          ...itemProperties
+        };
+      } else {
+        refs[refName] = {
+          key
+        };
+      }
+    } else {
+      refs[refName] = {
+        key: {
+          kt: refDef.kta[0],
+          pk: null
+          // Will be handled as null reference
+        }
+      };
+    }
+  }
+  return {
+    ...item,
+    refs
+  };
+}
+function updateForeignKeysFromRefs(item, refs, referenceDefinitions) {
+  for (const refDef of referenceDefinitions) {
+    const refName = refDef.property;
+    const ref = refs[refName];
+    if (ref && ref.key) {
+      if (isPriKey2(ref.key)) {
+        item[refDef.column] = ref.key.pk;
+      } else if (isComKey2(ref.key)) {
+        const comKey = ref.key;
+        item[refDef.column] = comKey.pk;
+        if (refDef.locationColumns && comKey.loc) {
+          comKey.loc.forEach((locItem, index) => {
+            if (refDef.locationColumns && refDef.locationColumns[index]) {
+              item[refDef.locationColumns[index]] = locItem.lk;
+            }
+          });
+        }
+      }
+      const { key, ...itemProperties } = ref;
+      const hasItemProperties = Object.keys(itemProperties).length > 0;
+      if (hasItemProperties) {
+        item[refDef.property] = {
+          key,
+          ...itemProperties
+        };
+      } else {
+        delete item[refDef.property];
+      }
+    } else if (ref == null) {
+      if (refName in refs) {
+        item[refDef.column] = null;
+        delete item[refDef.property];
+      }
+    }
+  }
+}
+function removeRefsFromSequelizeItem(item, referenceDefinitions) {
+  const result = { ...item };
+  if (result.refs) {
+    updateForeignKeysFromRefs(result, result.refs, referenceDefinitions);
+    delete result.refs;
+  }
+  return result;
+}
+
+// src/processing/AggsAdapter.ts
+var libLogger2 = logger_default.get("sequelize", "processing", "AggsAdapter");
+function addAggsToItem(item, aggregationDefinitions) {
+  if (!aggregationDefinitions || aggregationDefinitions.length === 0) {
+    return item;
+  }
+  const aggs = {};
+  const result = { ...item };
+  for (const aggDef of aggregationDefinitions) {
+    const aggregationValue = item[aggDef.property];
+    if (typeof aggregationValue !== "undefined") {
+      aggs[aggDef.property] = aggregationValue;
+      delete result[aggDef.property];
+      libLogger2.debug(`Moved aggregation '${aggDef.property}' to aggs structure`, {
+        property: aggDef.property,
+        hasValue: typeof aggregationValue !== "undefined",
+        valueType: Array.isArray(aggregationValue) ? "array" : typeof aggregationValue
+      });
+    } else {
+      libLogger2.debug(`Aggregation '${aggDef.property}' is undefined, skipping`, {
+        property: aggDef.property
+      });
+    }
+  }
+  if (Object.keys(aggs).length > 0) {
+    return {
+      ...result,
+      aggs
+    };
+  }
+  return item;
+}
+function removeAggsFromItem(item, aggregationDefinitions) {
+  if (!aggregationDefinitions || aggregationDefinitions.length === 0) {
+    return item;
+  }
+  const result = { ...item };
+  if (result.aggs && typeof result.aggs === "object") {
+    for (const aggDef of aggregationDefinitions) {
+      if (typeof result.aggs[aggDef.property] !== "undefined") {
+        result[aggDef.property] = result.aggs[aggDef.property];
+        libLogger2.debug(`Moved aggregation '${aggDef.property}' from aggs to direct property`, {
+          property: aggDef.property
+        });
+      }
+    }
+    delete result.aggs;
+  }
+  return result;
+}
+
 // src/RowProcessor.ts
 var logger6 = logger_default.get("sequelize", "RowProcessor");
 var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context) => {
@@ -721,9 +891,15 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
     operationContext.markInProgress(item.key);
     try {
       if (referenceDefinitions && referenceDefinitions.length > 0) {
-        for (const referenceDefinition of referenceDefinitions) {
+        const referenceStartTime = typeof performance !== "undefined" ? performance.now() : Date.now();
+        const referencePromises = referenceDefinitions.map((referenceDefinition) => {
           logger6.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
-          item = await buildSequelizeReference(item, referenceDefinition, registry, operationContext);
+          return buildSequelizeReference(item, referenceDefinition, registry, operationContext);
+        });
+        await Promise.all(referencePromises);
+        const referenceDuration = (typeof performance !== "undefined" ? performance.now() : Date.now()) - referenceStartTime;
+        if (referenceDuration > 100) {
+          logger6.debug(`\u23F1\uFE0F REFERENCE_BUILDER_PERF: Loaded ${referenceDefinitions.length} references in parallel for ${item.key.kt} - ${referenceDuration.toFixed(2)}ms`);
         }
       }
       if (aggregationDefinitions && aggregationDefinitions.length > 0) {
@@ -736,6 +912,14 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
     } finally {
       operationContext.markComplete(item.key);
     }
+    if (referenceDefinitions && referenceDefinitions.length > 0) {
+      item = addRefsToSequelizeItem(item, referenceDefinitions);
+      logger6.debug("Added refs structure to item (transparent wrapper)", { key: item.key });
+    }
+    if (aggregationDefinitions && aggregationDefinitions.length > 0) {
+      item = addAggsToItem(item, aggregationDefinitions);
+      logger6.debug("Added aggs structure to item (transparent wrapper)", { key: item.key });
+    }
     logger6.default("Processed Row: %j", stringifyJSON(item));
     return item;
   });
@@ -958,7 +1142,7 @@ var getAllOperation = (models, definition, registry) => {
   const { coordinate, options: { references, aggregations } } = definition;
   return createAllWrapper(
     coordinate,
-    async (itemQuery, locations) => {
+    async (itemQuery, locations, allOptions) => {
       try {
         const locs = locations ?? [];
         logger7.debug(`ALL operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
@@ -1023,7 +1207,31 @@ var getAllOperation = (models, definition, registry) => {
             options.include = mergeIncludes(existingIncludes, additionalIncludes);
           }
         }
-        logger7.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(", ") : "none"}, includes: ${options.include?.length || 0}`);
+        const effectiveLimit = allOptions?.limit ?? itemQuery?.limit;
+        const effectiveOffset = allOptions?.offset ?? itemQuery?.offset ?? 0;
+        const whereFields = options.where ? Object.keys(options.where).join(", ") : "none";
+        const includeCount = options.include?.length || 0;
+        logger7.default(
+          `All query configured for ${model.name} with where fields: ${whereFields}, includes: ${includeCount}, limit: ${effectiveLimit}, offset: ${effectiveOffset}`
+        );
+        const countOptions = {
+          where: options.where,
+          distinct: true
+        };
+        if (options.include) {
+          countOptions.include = options.include;
+        }
+        const countResult = await model.count(countOptions);
+        const total = Array.isArray(countResult) ? countResult.length : countResult;
+        logger7.debug(`[ALL] Total count for ${model.name}: ${total}`);
+        delete options.limit;
+        delete options.offset;
+        if (effectiveLimit !== void 0) {
+          options.limit = effectiveLimit;
+        }
+        if (effectiveOffset > 0) {
+          options.offset = effectiveOffset;
+        }
         try {
           logger7.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
         } catch {
@@ -1031,12 +1239,21 @@ var getAllOperation = (models, definition, registry) => {
         }
         const matchingItems = await model.findAll(options);
         const currentContext = contextManager.getCurrentContext();
-        const results = await Promise.all(matchingItems.map(async (row) => {
+        const items = await Promise.all(matchingItems.map(async (row) => {
           const processedRow = await processRow(row, coordinate.kta, references || [], aggregations || [], registry, currentContext);
           return validateKeys(processedRow, coordinate.kta);
         }));
-        logger7.debug(`[ALL] Returning ${results.length} ${model.name} records`);
-        return results;
+        logger7.debug(`[ALL] Returning ${items.length} of ${total} ${model.name} records`);
+        return {
+          items,
+          metadata: {
+            total,
+            returned: items.length,
+            limit: effectiveLimit,
+            offset: effectiveOffset,
+            hasMore: effectiveOffset + items.length < total
+          }
+        };
       } catch (error) {
         throw transformSequelizeError(error, coordinate.kta[0]);
       }
@@ -1045,7 +1262,7 @@ var getAllOperation = (models, definition, registry) => {
 };
 
 // src/ops/create.ts
-import { createCreateWrapper, isComKey as isComKey2, isPriKey as isPriKey2 } from "@fjell/core";
+import { createCreateWrapper, isComKey as isComKey3, isPriKey as isPriKey3 } from "@fjell/core";
 import { validateKeys as validateKeys2 } from "@fjell/core/validation";
 var logger8 = logger_default.get("sequelize", "ops", "create");
 async function validateHierarchicalChain(models, locKey, kta) {
@@ -1086,7 +1303,7 @@ var getCreateOperation = (models, definition, registry) => {
   return createCreateWrapper(
     coordinate,
     async (item, options) => {
-      const constraints = options?.key ? `key: pk=${options.key.pk}, loc=[${isComKey2(options.key) ? options.key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ") : ""}]` : options?.locations ? `locations: ${options.locations.map((loc) => `${loc.kt}=${loc.lk}`).join(", ")}` : "no constraints";
+      const constraints = options?.key ? `key: pk=${options.key.pk}, loc=[${isComKey3(options.key) ? options.key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ") : ""}]` : options?.locations ? `locations: ${options.locations.map((loc) => `${loc.kt}=${loc.lk}`).join(", ")}` : "no constraints";
       logger8.debug(`CREATE operation called on ${models[0].name} with ${constraints}`);
       logger8.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
       const model = models[0];
@@ -1094,6 +1311,12 @@ var getCreateOperation = (models, definition, registry) => {
       let itemData = { ...item };
       itemData = extractEvents(itemData);
       itemData = removeEvents(itemData);
+      if (references && references.length > 0) {
+        itemData = removeRefsFromSequelizeItem(itemData, references);
+      }
+      if (aggregations && aggregations.length > 0) {
+        itemData = removeAggsFromItem(itemData, aggregations);
+      }
       const invalidAttributes = [];
       for (const key of Object.keys(itemData)) {
         if (!modelAttributes[key]) {
@@ -1108,9 +1331,9 @@ var getCreateOperation = (models, definition, registry) => {
       }
       if (options?.key) {
         const key = options.key;
-        if (isPriKey2(key)) {
+        if (isPriKey3(key)) {
           itemData.id = key.pk;
-        } else if (isComKey2(key)) {
+        } else if (isComKey3(key)) {
           itemData.id = key.pk;
           const comKey = key;
           const directLocations = [];
@@ -1193,7 +1416,7 @@ var getFindOperation = (models, definition, registry) => {
   const { options: { finders, references, aggregations } } = definition;
   return createFindWrapper(
     definition.coordinate,
-    async (finder, finderParams, locations) => {
+    async (finder, finderParams, locations, findOptions) => {
       try {
         const locs = locations ?? [];
         const params = finderParams ?? {};
@@ -1202,30 +1425,45 @@ var getFindOperation = (models, definition, registry) => {
           `FIND operation called on ${models[0].name} with finder '${finder}' and ${locs.length} location filters: ${locationFilters}`
         );
         logger9.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(params).length} params`);
-        if (finders && finders[finder]) {
-          const finderMethod = finders[finder];
-          if (finderMethod) {
-            logger9.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(params)}, locations: ${stringifyJSON(locs)}`);
-            const results = await finderMethod(params, locs);
-            if (results && results.length > 0) {
-              const processedResults = await Promise.all(results.map(async (row) => {
-                const processedRow = await processRow(row, definition.coordinate.kta, references || [], aggregations || [], registry);
-                return validateKeys3(processedRow, definition.coordinate.kta);
-              }));
-              logger9.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
-              return processedResults;
-            } else {
-              logger9.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
-              return [];
-            }
-          } else {
-            logger9.error(`Finder %s not found`, finder);
-            throw new Error(`Finder ${finder} not found`);
-          }
-        } else {
+        if (!finders || !finders[finder]) {
           logger9.error(`No finders have been defined for this lib`);
           throw new Error(`No finders found`);
         }
+        const finderMethod = finders[finder];
+        if (!finderMethod) {
+          logger9.error(`Finder %s not found`, finder);
+          throw new Error(`Finder ${finder} not found`);
+        }
+        logger9.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(params)}, locations: ${stringifyJSON(locs)}, options: ${stringifyJSON(findOptions)}`);
+        const finderResult = await finderMethod(params, locs, findOptions);
+        const processItems = async (items) => {
+          return await Promise.all(items.map(async (row) => {
+            const processedRow = await processRow(row, definition.coordinate.kta, references || [], aggregations || [], registry);
+            return validateKeys3(processedRow, definition.coordinate.kta);
+          }));
+        };
+        const isOptInResult = finderResult && typeof finderResult === "object" && "items" in finderResult && "metadata" in finderResult;
+        if (isOptInResult) {
+          const optInResult = finderResult;
+          const processedResults2 = optInResult.items && optInResult.items.length > 0 ? await processItems(optInResult.items) : [];
+          logger9.debug(`[FIND] Finder opted-in, found ${processedResults2.length} ${models[0].name} records using finder '${finder}' (total: ${optInResult.metadata.total})`);
+          return {
+            items: processedResults2,
+            metadata: optInResult.metadata
+          };
+        }
+        const results = finderResult;
+        const processedResults = results && results.length > 0 ? await processItems(results) : [];
+        logger9.debug(`[FIND] Legacy finder, found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
+        return {
+          items: processedResults,
+          metadata: {
+            total: processedResults.length,
+            returned: processedResults.length,
+            offset: 0,
+            hasMore: false
+          }
+        };
       } catch (error) {
         throw transformSequelizeError(error, definition.coordinate.kta[0]);
       }
@@ -1236,8 +1474,8 @@ var getFindOperation = (models, definition, registry) => {
 // src/ops/get.ts
 import {
   createGetWrapper,
-  isComKey as isComKey3,
-  isPriKey as isPriKey3,
+  isComKey as isComKey4,
+  isPriKey as isPriKey4,
   isValidItemKey,
   validateKeys as validateKeys4
 } from "@fjell/core";
@@ -1280,16 +1518,16 @@ var getGetOperation = (models, definition, registry) => {
           logger10.error("Key for Get is not a valid ItemKey: %j", key);
           throw new Error("Key for Get is not a valid ItemKey");
         }
-        const keyDescription = isPriKey3(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
+        const keyDescription = isPriKey4(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
         logger10.debug(`GET operation called on ${models[0].name} with ${keyDescription}`);
-        logger10.default(`Get configured for ${models[0].name} with ${isPriKey3(key) ? "primary" : "composite"} key`);
+        logger10.default(`Get configured for ${models[0].name} with ${isPriKey4(key) ? "primary" : "composite"} key`);
         const itemKey = key;
         const model = models[0];
         let item;
-        if (isPriKey3(itemKey)) {
+        if (isPriKey4(itemKey)) {
           logger10.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
           item = await model.findByPk(itemKey.pk);
-        } else if (isComKey3(itemKey)) {
+        } else if (isComKey4(itemKey)) {
           const comKey = itemKey;
           if (comKey.loc.length === 0) {
             logger10.debug(`[GET] Empty loc array detected - finding by primary key across all locations: ${comKey.pk}`);
@@ -1331,11 +1569,11 @@ var getOneOperation = (models, definition, registry) => {
       const locs = locations ?? [];
       logger11.debug(`ONE operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
       logger11.default(`One configured for ${models[0].name} delegating to all operation`);
-      const items = await getAllOperation(models, definition, registry)(itemQuery ?? {}, locs);
-      if (items.length > 0) {
-        const result = items[0];
-        logger11.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : "unknown"}`);
-        return result;
+      const result = await getAllOperation(models, definition, registry)(itemQuery ?? {}, locs, { limit: 1 });
+      if (result.items.length > 0) {
+        const item = result.items[0];
+        logger11.debug(`[ONE] Found ${models[0].name} record with key: ${item.key ? JSON.stringify(item.key) : "unknown"}`);
+        return item;
       } else {
         logger11.debug(`[ONE] No ${models[0].name} record found`);
         return null;
@@ -1345,7 +1583,7 @@ var getOneOperation = (models, definition, registry) => {
 };
 
 // src/ops/remove.ts
-import { abbrevIK, isComKey as isComKey4, isPriKey as isPriKey4, isValidItemKey as isValidItemKey2, createRemoveWrapper } from "@fjell/core";
+import { abbrevIK, isComKey as isComKey5, isPriKey as isPriKey5, isValidItemKey as isValidItemKey2, createRemoveWrapper } from "@fjell/core";
 import { NotFoundError as NotFoundError2 } from "@fjell/core";
 var logger12 = logger_default.get("sequelize", "ops", "remove");
 var processCompositeKey2 = (comKey, model, kta) => {
@@ -1385,17 +1623,17 @@ var getRemoveOperation = (models, definition, _registry) => {
           logger12.error("Key for Remove is not a valid ItemKey: %j", key);
           throw new Error("Key for Remove is not a valid ItemKey");
         }
-        const keyDescription = isPriKey4(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
+        const keyDescription = isPriKey5(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
         logger12.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
-        logger12.default(`Remove configured for ${models[0].name} with ${isPriKey4(key) ? "primary" : "composite"} key`);
+        logger12.default(`Remove configured for ${models[0].name} with ${isPriKey5(key) ? "primary" : "composite"} key`);
         const model = models[0];
         let item;
         let returnItem;
         logger12.debug("remove: %s", abbrevIK(key));
-        if (isPriKey4(key)) {
+        if (isPriKey5(key)) {
           logger12.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
           item = await model.findByPk(key.pk);
-        } else if (isComKey4(key)) {
+        } else if (isComKey5(key)) {
           const comKey = key;
           const queryOptions = processCompositeKey2(comKey, model, kta);
           logger12.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
@@ -1433,6 +1671,10 @@ var getRemoveOperation = (models, definition, _registry) => {
           throw new Error("No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set");
         }
         logger12.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
+        const { references } = options;
+        if (references && references.length > 0) {
+          returnItem = addRefsToSequelizeItem(returnItem, references);
+        }
         return returnItem;
       } catch (error) {
         if (error instanceof NotFoundError2) throw error;
@@ -1446,8 +1688,8 @@ var getRemoveOperation = (models, definition, _registry) => {
 import {
   abbrevIK as abbrevIK2,
   createUpdateWrapper,
-  isComKey as isComKey5,
-  isPriKey as isPriKey5
+  isComKey as isComKey6,
+  isPriKey as isPriKey6
 } from "@fjell/core";
 import { validateKeys as validateKeys5 } from "@fjell/core/validation";
 import { NotFoundError as NotFoundError3 } from "@fjell/core";
@@ -1483,18 +1725,18 @@ var getUpdateOperation = (models, definition, registry) => {
             "UpdateOptions.replace is not supported for SQL databases. SQL UPDATE operations are always partial (they only update specified fields). To replace an entire record, use remove() followed by create(), or explicitly set all fields you want to change/clear."
           );
         }
-        const keyDescription = isPriKey5(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
+        const keyDescription = isPriKey6(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
         logger13.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`, { options });
         const { coordinate } = definition;
         const { kta } = coordinate;
         logger13.debug("update: %s, %j", abbrevIK2(key), item);
         const model = models[0];
         let response;
-        if (isPriKey5(key)) {
+        if (isPriKey6(key)) {
           const priKey = key;
           logger13.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
           response = await model.findByPk(priKey.pk);
-        } else if (isComKey5(key)) {
+        } else if (isComKey6(key)) {
           const comKey = key;
           const where = { id: comKey.pk };
           const additionalIncludes = [];
@@ -1535,6 +1777,12 @@ var getUpdateOperation = (models, definition, registry) => {
         let updateProps = removeKey(item);
         updateProps = extractEvents(updateProps);
         updateProps = removeEvents(updateProps);
+        if (references && references.length > 0) {
+          updateProps = removeRefsFromSequelizeItem(updateProps, references);
+        }
+        if (aggregations && aggregations.length > 0) {
+          updateProps = removeAggsFromItem(updateProps, aggregations);
+        }
         logger13.default(`Update found ${model.name} record to modify`);
         logger13.default(`Update properties configured: ${Object.keys(updateProps).join(", ")}`);
         logger13.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
@@ -1560,7 +1808,7 @@ var getUpsertOperation = (models, definition, registry) => {
   const create = getCreateOperation(models, definition, registry);
   return createUpsertWrapper(
     definition.coordinate,
-    async (key, item, options) => {
+    async (key, item, locations, options) => {
       if (!isValidItemKey3(key)) {
         logger14.error("Key for Upsert is not a valid ItemKey: %j", key);
         throw new Error(`Key for Upsert is not a valid ItemKey: ${stringifyJSON(key)}`);
@@ -1574,7 +1822,8 @@ var getUpsertOperation = (models, definition, registry) => {
         const isNotFound = error instanceof NotFoundError4 || error?.name === "NotFoundError" || error?.errorInfo?.code === "NOT_FOUND";
         if (isNotFound) {
           logger14.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}, errorType: ${error?.name}, errorCode: ${error?.errorInfo?.code}`);
-          resultItem = await create(item, { key });
+          const createOptions3 = locations ? { locations } : { key };
+          resultItem = await create(item, createOptions3);
         } else {
           logger14.error(`[UPSERT] Unexpected error during get operation`, { error: error?.message, name: error?.name, code: error?.errorInfo?.code });
           throw error;
@@ -1608,7 +1857,7 @@ var createOperations = (models, coordinate, registry, options) => {
   };
   implOps.findOne = async (finder, params, locations) => {
     const results = await implOps.find(finder, params || {}, locations);
-    return results.length > 0 ? results[0] : null;
+    return results.items.length > 0 ? results.items[0] : null;
   };
   return Library2.wrapImplementationOperations(implOps, options);
 };