@fjell/lib-sequelize 4.4.43 → 4.4.45

package/dist/index.js

@@ -6,18 +6,13 @@ var __export = (target, all) => {
 
 // src/Options.ts
 import * as Library from "@fjell/lib";
-var DEFAULT_SEQUELIZE_OPTIONS = {
-  deleteOnRemove: false,
-  references: [],
-  aggregations: []
-};
 var createOptions2 = (sequelizeOptions) => {
   const baseOptions = Library.createOptions(sequelizeOptions);
   const result = {
     ...baseOptions,
-    deleteOnRemove: sequelizeOptions?.deleteOnRemove ?? DEFAULT_SEQUELIZE_OPTIONS.deleteOnRemove,
-    references: sequelizeOptions?.references ?? DEFAULT_SEQUELIZE_OPTIONS.references,
-    aggregations: sequelizeOptions?.aggregations ?? DEFAULT_SEQUELIZE_OPTIONS.aggregations
+    references: baseOptions.references ?? [],
+    aggregations: baseOptions.aggregations ?? [],
+    deleteOnRemove: sequelizeOptions?.deleteOnRemove ?? false
   };
   return result;
 };
@@ -508,201 +503,17 @@ var addKey = (model, item, keyTypes) => {
   return item;
 };
 
-// src/ReferenceBuilder.ts
-var logger5 = logger_default.get("sequelize", "ReferenceBuilder");
-var buildReference = async (item, referenceDefinition, registry, context) => {
-  const primaryKeyType = referenceDefinition.kta[0];
-  if (referenceDefinition.kta.length > 1) {
-    logger5.default(
-      "Using multikey reference with PriKey assumption",
-      {
-        kta: referenceDefinition.kta,
-        primaryKeyType,
-        property: referenceDefinition.property,
-        column: referenceDefinition.column
-      }
-    );
-    logger5.default(
-      'ASSUMPTION: The primary key for key type "%s" is unique and can be used to retrieve composite items',
-      primaryKeyType
-    );
-  }
-  if (!registry) {
-    throw new Error(
-      `This model definition has a reference definition, but the registry is not present. Reference property: '${referenceDefinition.property}', key types: [${referenceDefinition.kta.join(", ")}], column: '${referenceDefinition.column}'`
-    );
-  }
-  const library = registry.get(referenceDefinition.kta);
-  if (!library) {
-    throw new Error(
-      `This model definition has a reference definition, but the dependency is not present in registry. Reference property: '${referenceDefinition.property}', missing key type: '${primaryKeyType}', column: '${referenceDefinition.column}'`
-    );
-  }
-  const columnValue = item[referenceDefinition.column];
-  if (columnValue == null) {
-    item[referenceDefinition.property] = null;
-    return item;
-  }
-  const priKey = {
-    kt: primaryKeyType,
-    pk: columnValue
-  };
-  let referencedItem;
-  if (context) {
-    if (context.isCached(priKey)) {
-      logger5.default("Using cached reference", { priKey, property: referenceDefinition.property });
-      referencedItem = context.getCached(priKey);
-    } else if (context.isInProgress(priKey)) {
-      logger5.default("Circular dependency detected, creating reference placeholder", {
-        priKey,
-        property: referenceDefinition.property
-      });
-      referencedItem = {
-        key: priKey
-        // Add any other minimal properties that might be needed
-        // This prevents infinite loops while still providing the key for identification
-      };
-    } else {
-      context.markInProgress(priKey);
-      try {
-        referencedItem = await library.operations.get(priKey);
-        context.setCached(priKey, referencedItem);
-      } catch (error) {
-        throw error;
-      } finally {
-        context.markComplete(priKey);
-      }
-    }
-  } else {
-    referencedItem = await library.operations.get(priKey);
-  }
-  item[referenceDefinition.property] = referencedItem;
-  return item;
-};
-
-// src/AggregationBuilder.ts
-import { ikToLKA } from "@fjell/core";
-
-// src/OperationContext.ts
-import { AsyncLocalStorage } from "async_hooks";
-var logger6 = logger_default.get("sequelize", "OperationContext");
-var serializeKey = (key) => {
-  if ("pk" in key && "kt" in key && !("loc" in key)) {
-    return `${key.kt}:${key.pk}`;
-  } else if ("pk" in key && "kt" in key && "loc" in key) {
-    const locStr = key.loc.map((l) => `${l.kt}:${l.lk}`).join(",");
-    return `${key.kt}:${key.pk}|${locStr}`;
-  }
-  throw new Error(`Unsupported key type: ${JSON.stringify(key)}`);
-};
-var createOperationContext = () => {
-  const inProgress = /* @__PURE__ */ new Set();
-  const cache = /* @__PURE__ */ new Map();
-  return {
-    inProgress,
-    cache,
-    markInProgress(key) {
-      const serialized = serializeKey(key);
-      logger6.default("Marking key as in progress", { key, serialized });
-      inProgress.add(serialized);
-    },
-    markComplete(key) {
-      const serialized = serializeKey(key);
-      logger6.default("Marking key as complete", { key, serialized });
-      inProgress.delete(serialized);
-    },
-    isInProgress(key) {
-      const serialized = serializeKey(key);
-      const result = inProgress.has(serialized);
-      logger6.default("Checking if key is in progress", { key, serialized, result });
-      return result;
-    },
-    getCached(key) {
-      const serialized = serializeKey(key);
-      const result = cache.get(serialized);
-      logger6.default("Getting cached item", { key, serialized, found: !!result });
-      return result;
-    },
-    setCached(key, item) {
-      const serialized = serializeKey(key);
-      logger6.default("Caching item", { key, serialized });
-      cache.set(serialized, item);
-    },
-    isCached(key) {
-      const serialized = serializeKey(key);
-      const result = cache.has(serialized);
-      logger6.default("Checking if key is cached", { key, serialized, result });
-      return result;
-    }
-  };
-};
-var ContextManager = class {
-  asyncLocalStorage = new AsyncLocalStorage();
-  /**
-   * Get the current context if one is set
-   */
-  getCurrentContext() {
-    const context = this.asyncLocalStorage.getStore();
-    if (context) {
-      logger6.default("Got current context from AsyncLocalStorage");
-    }
-    return context;
-  }
-  /**
-   * Execute a function with a specific context set as current
-   * The context will be available to all async operations within the function
-   */
-  async withContext(context, fn) {
-    logger6.default("Running with context in AsyncLocalStorage");
-    return this.asyncLocalStorage.run(context, fn);
-  }
-};
-var contextManager = new ContextManager();
-
-// src/AggregationBuilder.ts
-var logger7 = logger_default.get("sequelize", "AggregationBuilder");
-var buildAggregation = async (item, aggregationDefinition, registry, context) => {
-  const location = ikToLKA(item.key);
-  const libraryInstance = registry.get(aggregationDefinition.kta);
-  if (!libraryInstance) {
-    throw new Error(`Library instance not found for key type array: ${aggregationDefinition.kta.join(", ")}`);
-  }
-  const aggregationCacheKey = `${aggregationDefinition.kta.join(".")}_${aggregationDefinition.cardinality}_${serializeKey(item.key)}`;
-  if (context) {
-    if (context.cache.has(aggregationCacheKey)) {
-      const cachedResult = context.cache.get(aggregationCacheKey);
-      logger7.default("Using cached aggregation result", {
-        aggregationCacheKey,
-        property: aggregationDefinition.property
-      });
-      item[aggregationDefinition.property] = cachedResult;
-      return item;
-    }
-  }
-  return contextManager.withContext(context || contextManager.getCurrentContext() || { inProgress: /* @__PURE__ */ new Set(), cache: /* @__PURE__ */ new Map() }, async () => {
-    if (aggregationDefinition.cardinality === "one") {
-      return libraryInstance.operations.one({}, location).then((result) => {
-        if (context) {
-          context.cache.set(aggregationCacheKey, result);
-        }
-        item[aggregationDefinition.property] = result;
-        return item;
-      });
-    } else {
-      return libraryInstance.operations.all({}, location).then((results) => {
-        if (context) {
-          context.cache.set(aggregationCacheKey, results);
-        }
-        item[aggregationDefinition.property] = results;
-        return item;
-      });
-    }
-  });
-};
+// src/RowProcessor.ts
+import {
+  buildAggregation,
+  buildReference,
+  contextManager,
+  createOperationContext
+} from "@fjell/lib";
 
 // src/EventCoordinator.ts
 import deepmerge from "deepmerge";
-var logger8 = logger_default.get("sequelize", "EventCoordinator");
+var logger5 = logger_default.get("sequelize", "EventCoordinator");
 var populateEvents = (item) => {
   const events = {
     created: { at: item.createdAt || null },
@@ -713,7 +524,7 @@ var populateEvents = (item) => {
   return item;
 };
 var extractEvents = (item) => {
-  logger8.default("Extracting Events to database fields", { item });
+  logger5.default("Extracting Events to database fields", { item });
   if (item.events) {
     if (item.events.created?.at) {
       item.createdAt = item.events.created.at;
@@ -728,33 +539,33 @@ var extractEvents = (item) => {
   return item;
 };
 var removeEvents = (item) => {
-  logger8.default("Removing Events", { item });
+  logger5.default("Removing Events", { item });
   delete item.events;
   return item;
 };
 
 // src/RowProcessor.ts
-var logger9 = logger_default.get("sequelize", "RowProcessor");
+var logger6 = logger_default.get("sequelize", "RowProcessor");
 var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context) => {
-  logger9.default("Processing Row", { row });
+  logger6.default("Processing Row", { row });
   const operationContext = context || createOperationContext();
   return contextManager.withContext(operationContext, async () => {
     let item = row.get({ plain: true });
-    logger9.default("Adding Key to Item with Key Types: %s", stringifyJSON(keyTypes));
+    logger6.default("Adding Key to Item with Key Types: %s", stringifyJSON(keyTypes));
     item = addKey(row, item, keyTypes);
     item = populateEvents(item);
-    logger9.default("Key Added to Item: %s", stringifyJSON(item.key));
+    logger6.default("Key Added to Item: %s", stringifyJSON(item.key));
     operationContext.markInProgress(item.key);
     try {
       if (referenceDefinitions && referenceDefinitions.length > 0) {
         for (const referenceDefinition of referenceDefinitions) {
-          logger9.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
+          logger6.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
           item = await buildReference(item, referenceDefinition, registry, operationContext);
         }
       }
       if (aggregationDefinitions && aggregationDefinitions.length > 0) {
         for (const aggregationDefinition of aggregationDefinitions) {
-          logger9.default("Processing Aggregation for %s from %s", item.key.kt, stringifyJSON(aggregationDefinition.kta));
+          logger6.default("Processing Aggregation for %s from %s", item.key.kt, stringifyJSON(aggregationDefinition.kta));
           item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
         }
       }
@@ -762,14 +573,14 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
     } finally {
       operationContext.markComplete(item.key);
     }
-    logger9.default("Processed Row: %j", stringifyJSON(item));
+    logger6.default("Processed Row: %j", stringifyJSON(item));
     return item;
   });
 };
 
 // src/ops/all.ts
 import { Op as Op2 } from "sequelize";
-var logger10 = logger_default.get("sequelize", "ops", "all");
+var logger7 = logger_default.get("sequelize", "ops", "all");
 var mergeIncludes = (existingIncludes, newIncludes) => {
   const mergedIncludes = [...existingIncludes];
   for (const newInclude of newIncludes) {
@@ -792,7 +603,7 @@ var mergeIncludes = (existingIncludes, newIncludes) => {
 var getAllOperation = (models, definition, registry) => {
   const { coordinate, options: { references, aggregations } } = definition;
   const all = async (itemQuery, locations) => {
-    logger10.debug(`ALL operation called on ${models[0].name} with ${locations?.length || 0} location filters: ${locations?.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
+    logger7.debug(`ALL operation called on ${models[0].name} with ${locations?.length || 0} location filters: ${locations?.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
     const loc = locations || [];
     const model = models[0];
     const options = buildQuery(itemQuery, model);
@@ -805,7 +616,7 @@ var getAllOperation = (models, definition, registry) => {
         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.`;
-          logger10.error(errorMessage, { locations: loc, kta });
+          logger7.error(errorMessage, { locations: loc, kta });
           throw new Error(errorMessage);
         }
         if (relationshipInfo.isDirect) {
@@ -816,31 +627,31 @@ var getAllOperation = (models, definition, registry) => {
       }
       for (const locKey of directLocations) {
         if (locKey.lk === void 0 || locKey.lk == null || locKey.lk === "" || typeof locKey.lk === "object" && Object.keys(locKey.lk).length === 0) {
-          logger10.error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
+          logger7.error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
           throw new Error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
         }
         const foreignKeyField = locKey.kt + "Id";
         if (options.where[foreignKeyField]) {
-          logger10.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
+          logger7.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
           continue;
         }
-        logger10.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+        logger7.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
         options.where[foreignKeyField] = {
           [Op2.eq]: locKey.lk
         };
       }
       for (const locKey of hierarchicalLocations) {
         if (locKey.lk === void 0 || locKey.lk == null || locKey.lk === "" || typeof locKey.lk === "object" && Object.keys(locKey.lk).length === 0) {
-          logger10.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
+          logger7.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
           throw new Error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
         }
         const relationshipInfo = buildRelationshipPath(model, locKey.kt, kta);
         if (relationshipInfo.found && relationshipInfo.path) {
           if (options.where[relationshipInfo.path]) {
-            logger10.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
+            logger7.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
             continue;
           }
-          logger10.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+          logger7.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
           options.where[relationshipInfo.path] = {
             [Op2.eq]: locKey.lk
           };
@@ -854,11 +665,11 @@ var getAllOperation = (models, definition, registry) => {
         options.include = mergeIncludes(existingIncludes, additionalIncludes);
       }
     }
-    logger10.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(", ") : "none"}, includes: ${options.include?.length || 0}`);
+    logger7.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(", ") : "none"}, includes: ${options.include?.length || 0}`);
     try {
-      logger10.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
+      logger7.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
     } catch {
-      logger10.trace(`[ALL] Executing ${model.name}.findAll() with options containing non-serializable operators (${Object.keys(options.where || {}).length} where conditions)`);
+      logger7.trace(`[ALL] Executing ${model.name}.findAll() with options containing non-serializable operators (${Object.keys(options.where || {}).length} where conditions)`);
     }
     const matchingItems = await model.findAll(options);
     const currentContext = contextManager.getCurrentContext();
@@ -866,7 +677,7 @@ var getAllOperation = (models, definition, registry) => {
       const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry, currentContext);
       return validateKeys(processedRow, coordinate.kta);
     }));
-    logger10.debug(`[ALL] Returning ${results.length} ${model.name} records`);
+    logger7.debug(`[ALL] Returning ${results.length} ${model.name} records`);
     return results;
   };
   return all;
@@ -874,13 +685,13 @@ var getAllOperation = (models, definition, registry) => {
 
 // src/ops/create.ts
 import { isComKey as isComKey2, isPriKey as isPriKey2, validateKeys as validateKeys2 } from "@fjell/core";
-var logger11 = logger_default.get("sequelize", "ops", "create");
+var logger8 = logger_default.get("sequelize", "ops", "create");
 function translateDatabaseError(error, itemData, modelName) {
   const originalMessage = error.message || "";
   const errorCode = error.original?.code;
   const constraint = error.original?.constraint;
   const detail = error.original?.detail;
-  logger11.error("Database error during create operation", {
+  logger8.error("Database error during create operation", {
     errorCode,
     constraint,
     detail,
@@ -974,8 +785,8 @@ async function validateHierarchicalChain(models, locKey, kta) {
 var getCreateOperation = (models, definition, registry) => {
   const create = 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";
-    logger11.debug(`CREATE operation called on ${models[0].name} with ${constraints}`);
-    logger11.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
+    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 { coordinate, options: { references, aggregations } } = definition;
     const { kta } = coordinate;
     const model = models[0];
@@ -1009,7 +820,7 @@ var getCreateOperation = (models, definition, registry) => {
           if (!relationshipInfo.found) {
             const associations = model.associations ? Object.keys(model.associations) : [];
             const errorMessage = `Composite key locator '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships. Available associations: [${associations.join(", ")}]. KTA: [${kta.join(", ")}]. Composite key: ${JSON.stringify(comKey, null, 2)}`;
-            logger11.error(errorMessage, { key: comKey, kta, associations });
+            logger8.error(errorMessage, { key: comKey, kta, associations });
             throw new Error(errorMessage);
           }
           if (relationshipInfo.isDirect) {
@@ -1020,7 +831,7 @@ var getCreateOperation = (models, definition, registry) => {
         }
         for (const locKey of directLocations) {
           if (locKey.lk == null || locKey.lk === "") {
-            logger11.error(`Composite key location '${locKey.kt}' has undefined/null lk value`, { locKey, key: comKey });
+            logger8.error(`Composite key location '${locKey.kt}' has undefined/null lk value`, { locKey, key: comKey });
             throw new Error(`Composite key location '${locKey.kt}' has undefined/null lk value`);
           }
           const foreignKeyField = locKey.kt + "Id";
@@ -1039,7 +850,7 @@ var getCreateOperation = (models, definition, registry) => {
         if (!relationshipInfo.found) {
           const associations = model.associations ? Object.keys(model.associations) : [];
           const errorMessage = `Location key '${locKey.kt}' cannot be resolved on model '${model.name}' or through its relationships. Available associations: [${associations.join(", ")}]. KTA: [${kta.join(", ")}]. Locations: ${JSON.stringify(options.locations, null, 2)}`;
-          logger11.error(errorMessage, { locations: options.locations, kta, associations });
+          logger8.error(errorMessage, { locations: options.locations, kta, associations });
           throw new Error(errorMessage);
         }
         if (relationshipInfo.isDirect) {
@@ -1050,7 +861,7 @@ var getCreateOperation = (models, definition, registry) => {
       }
       for (const locKey of directLocations) {
         if (locKey.lk == null || locKey.lk === "") {
-          logger11.error(`Location option '${locKey.kt}' has undefined/null lk value`, { locKey, locations: options.locations });
+          logger8.error(`Location option '${locKey.kt}' has undefined/null lk value`, { locKey, locations: options.locations });
           throw new Error(`Location option '${locKey.kt}' has undefined/null lk value`);
         }
         const foreignKeyField = locKey.kt + "Id";
@@ -1061,11 +872,11 @@ var getCreateOperation = (models, definition, registry) => {
       }
     }
     try {
-      logger11.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
+      logger8.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
       const createdRecord = await model.create(itemData);
       const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
       const result = validateKeys2(processedRecord, kta);
-      logger11.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
+      logger8.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
       return result;
     } catch (error) {
       throw translateDatabaseError(error, itemData, model.name);
@@ -1076,37 +887,37 @@ var getCreateOperation = (models, definition, registry) => {
 
 // src/ops/find.ts
 import { validateKeys as validateKeys3 } from "@fjell/core";
-var logger12 = logger_default.get("sequelize", "ops", "find");
+var logger9 = logger_default.get("sequelize", "ops", "find");
 var getFindOperation = (models, definition, registry) => {
   const { options: { finders, references, aggregations } } = definition;
   const find = async (finder, finderParams, locations) => {
     const locationFilters = locations?.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none";
-    logger12.debug(
+    logger9.debug(
       `FIND operation called on ${models[0].name} with finder '${finder}' and ${locations?.length || 0} location filters: ${locationFilters}`
     );
-    logger12.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
+    logger9.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
     if (finders && finders[finder]) {
       const finderMethod = finders[finder];
       if (finderMethod) {
-        logger12.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
+        logger9.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
         const results = await finderMethod(finderParams, locations);
         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);
           }));
-          logger12.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
+          logger9.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
           return processedResults;
         } else {
-          logger12.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
+          logger9.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
           return [];
         }
       } else {
-        logger12.error(`Finder %s not found`, finder);
+        logger9.error(`Finder %s not found`, finder);
         throw new Error(`Finder ${finder} not found`);
       }
     } else {
-      logger12.error(`No finders have been defined for this lib`);
+      logger9.error(`No finders have been defined for this lib`);
       throw new Error(`No finders found`);
     }
   };
@@ -1121,7 +932,7 @@ import {
   validateKeys as validateKeys4
 } from "@fjell/core";
 import { NotFoundError } from "@fjell/lib";
-var logger13 = logger_default.get("sequelize", "ops", "get");
+var logger10 = logger_default.get("sequelize", "ops", "get");
 var processCompositeKey = (comKey, model, kta) => {
   const where = { id: comKey.pk };
   const includes = [];
@@ -1129,7 +940,7 @@ var processCompositeKey = (comKey, model, kta) => {
     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. Key type array: [${kta.join(", ")}], Composite key: ${stringifyJSON(comKey)}, Available associations: [${Object.keys(model.associations || {}).join(", ")}]`;
-      logger13.error(errorMessage, { key: comKey, kta });
+      logger10.error(errorMessage, { key: comKey, kta });
       throw new Error(errorMessage);
     }
     if (relationshipInfo.path) {
@@ -1153,23 +964,23 @@ var getGetOperation = (models, definition, registry) => {
   const { kta } = coordinate;
   const get = async (key) => {
     if (!isValidItemKey(key)) {
-      logger13.error("Key for Get is not a valid ItemKey: %j", key);
+      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(", ")}]`;
-    logger13.debug(`GET operation called on ${models[0].name} with ${keyDescription}`);
-    logger13.default(`Get configured for ${models[0].name} with ${isPriKey3(key) ? "primary" : "composite"} key`);
+    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`);
     const itemKey = key;
     const model = models[0];
     let item;
     if (isPriKey3(itemKey)) {
-      logger13.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
+      logger10.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
       item = await model.findByPk(itemKey.pk);
     } else if (isComKey3(itemKey)) {
       const comKey = itemKey;
       const queryOptions = processCompositeKey(comKey, model, kta);
-      logger13.default("Composite key query", { queryOptions });
-      logger13.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+      logger10.default("Composite key query", { queryOptions });
+      logger10.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
       item = await model.findOne(queryOptions);
     }
     if (!item) {
@@ -1177,7 +988,7 @@ var getGetOperation = (models, definition, registry) => {
     } else {
       const currentContext = contextManager.getCurrentContext();
       const result = validateKeys4(await processRow(item, kta, references, aggregations, registry, currentContext), kta);
-      logger13.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
+      logger10.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
       return result;
     }
   };
@@ -1185,18 +996,18 @@ var getGetOperation = (models, definition, registry) => {
 };
 
 // src/ops/one.ts
-var logger14 = logger_default.get("sequelize", "ops", "one");
+var logger11 = logger_default.get("sequelize", "ops", "one");
 var getOneOperation = (models, definition, registry) => {
   const one = async (itemQuery, locations = []) => {
-    logger14.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
-    logger14.default(`One configured for ${models[0].name} delegating to all operation`);
+    logger11.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.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, locations);
     if (items.length > 0) {
       const result = items[0];
-      logger14.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : "unknown"}`);
+      logger11.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : "unknown"}`);
       return result;
     } else {
-      logger14.debug(`[ONE] No ${models[0].name} record found`);
+      logger11.debug(`[ONE] No ${models[0].name} record found`);
       return null;
     }
   };
@@ -1207,7 +1018,7 @@ var getOneOperation = (models, definition, registry) => {
 import { isValidItemKey as isValidItemKey2 } from "@fjell/core";
 import { abbrevIK, isComKey as isComKey4, isPriKey as isPriKey4 } from "@fjell/core";
 import { NotFoundError as NotFoundError2 } from "@fjell/lib";
-var logger15 = logger_default.get("sequelize", "ops", "remove");
+var logger12 = logger_default.get("sequelize", "ops", "remove");
 var processCompositeKey2 = (comKey, model, kta) => {
   const where = { id: comKey.pk };
   const includes = [];
@@ -1215,7 +1026,7 @@ var processCompositeKey2 = (comKey, model, kta) => {
     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.`;
-      logger15.error(errorMessage, { key: comKey, kta });
+      logger12.error(errorMessage, { key: comKey, kta });
       throw new Error(errorMessage);
     }
     if (relationshipInfo.path) {
@@ -1234,29 +1045,29 @@ var processCompositeKey2 = (comKey, model, kta) => {
   }
   return result;
 };
-var getRemoveOperation = (models, definition, registry) => {
+var getRemoveOperation = (models, definition, _registry) => {
   const { coordinate, options } = definition;
   const { kta } = coordinate;
   const remove = async (key) => {
     if (!isValidItemKey2(key)) {
-      logger15.error("Key for Remove is not a valid ItemKey: %j", key);
+      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(", ")}]`;
-    logger15.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
-    logger15.default(`Remove configured for ${models[0].name} with ${isPriKey4(key) ? "primary" : "composite"} key`);
+    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`);
     const model = models[0];
     let item;
     let returnItem;
-    logger15.debug("remove: %s", abbrevIK(key));
+    logger12.debug("remove: %s", abbrevIK(key));
     if (isPriKey4(key)) {
-      logger15.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
+      logger12.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
       item = await model.findByPk(key.pk);
     } else if (isComKey4(key)) {
       const comKey = key;
       const queryOptions = processCompositeKey2(comKey, model, kta);
-      logger15.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-      logger15.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+      logger12.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
+      logger12.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
       item = await model.findOne(queryOptions);
     }
     if (!item) {
@@ -1271,13 +1082,13 @@ var getRemoveOperation = (models, definition, registry) => {
       if (model.getAttributes().deletedAt) {
         item.deletedAt = /* @__PURE__ */ new Date();
       }
-      logger15.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
+      logger12.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
       await item?.save();
       returnItem = item?.get({ plain: true });
       returnItem = addKey(item, returnItem, kta);
       returnItem = populateEvents(returnItem);
     } else if (options.deleteOnRemove) {
-      logger15.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
+      logger12.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
       await item?.destroy();
       returnItem = item?.get({ plain: true });
       returnItem = addKey(item, returnItem, kta);
@@ -1285,7 +1096,7 @@ var getRemoveOperation = (models, definition, registry) => {
     } else {
       throw new Error("No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set");
     }
-    logger15.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
+    logger12.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
     return returnItem;
   };
   return remove;
@@ -1296,7 +1107,7 @@ import { abbrevIK as abbrevIK2, isComKey as isComKey5, validateKeys as validateK
 import { isPriKey as isPriKey5 } from "@fjell/core";
 import { NotFoundError as NotFoundError3 } from "@fjell/lib";
 import { Op as Op3 } from "sequelize";
-var logger16 = logger_default.get("sequelize", "ops", "update");
+var logger13 = logger_default.get("sequelize", "ops", "update");
 var mergeIncludes2 = (existingIncludes, newIncludes) => {
   const mergedIncludes = [...existingIncludes];
   for (const newInclude of newIncludes) {
@@ -1320,15 +1131,15 @@ var getUpdateOperation = (models, definition, registry) => {
   const { options: { references, aggregations } } = definition;
   const update = async (key, item) => {
     const keyDescription = isPriKey5(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
-    logger16.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`);
+    logger13.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`);
     const { coordinate } = definition;
     const { kta } = coordinate;
-    logger16.debug("update: %s, %j", abbrevIK2(key), item);
+    logger13.debug("update: %s, %j", abbrevIK2(key), item);
     const model = models[0];
     let response;
     if (isPriKey5(key)) {
       const priKey = key;
-      logger16.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
+      logger13.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
       response = await model.findByPk(priKey.pk);
     } else if (isComKey5(key)) {
       const comKey = key;
@@ -1338,7 +1149,7 @@ var getUpdateOperation = (models, definition, registry) => {
         const relationshipInfo = buildRelationshipPath(model, locator.kt, kta, true);
         if (!relationshipInfo.found) {
           const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
-          logger16.error(errorMessage, { key: comKey, kta });
+          logger13.error(errorMessage, { key: comKey, kta });
           throw new Error(errorMessage);
         }
         if (relationshipInfo.isDirect) {
@@ -1357,21 +1168,21 @@ var getUpdateOperation = (models, definition, registry) => {
       if (additionalIncludes.length > 0) {
         queryOptions.include = mergeIncludes2([], additionalIncludes);
       }
-      logger16.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-      logger16.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+      logger13.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
+      logger13.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
       response = await model.findOne(queryOptions);
     }
     if (response) {
       let updateProps = removeKey(item);
       updateProps = extractEvents(updateProps);
       updateProps = removeEvents(updateProps);
-      logger16.default(`Update found ${model.name} record to modify`);
-      logger16.default(`Update properties configured: ${Object.keys(updateProps).join(", ")}`);
-      logger16.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
+      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)}`);
       response = await response.update(updateProps);
       const processedItem = await processRow(response, kta, references, aggregations, registry);
       const returnItem = validateKeys5(processedItem, kta);
-      logger16.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
+      logger13.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
       return returnItem;
     } else {
       throw new NotFoundError3("update", coordinate, key);
@@ -1382,25 +1193,25 @@ var getUpdateOperation = (models, definition, registry) => {
 
 // src/ops/upsert.ts
 import { isValidItemKey as isValidItemKey3 } from "@fjell/core";
-var logger17 = logger_default.get("sequelize", "ops", "upsert");
+var logger14 = logger_default.get("sequelize", "ops", "upsert");
 var getUpsertOperation = (models, definition, registry) => {
   const get = getGetOperation(models, definition, registry);
   const update = getUpdateOperation(models, definition, registry);
   const create = getCreateOperation(models, definition, registry);
   const upsert = async (key, item) => {
     if (!isValidItemKey3(key)) {
-      logger17.error("Key for Upsert is not a valid ItemKey: %j", 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)}`);
     }
-    logger17.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`);
+    logger14.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`);
     try {
       const existingItem = await get(key);
       if (existingItem) {
-        logger17.debug(`[UPSERT] Item exists, updating with key: ${stringifyJSON(key)}`);
+        logger14.debug(`[UPSERT] Item exists, updating with key: ${stringifyJSON(key)}`);
         return await update(key, item);
       }
     } catch {
-      logger17.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}`);
+      logger14.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}`);
     }
     return await create(item, { key });
   };
@@ -1436,9 +1247,9 @@ var createOperations = (models, coordinate, registry, options) => {
 };
 
 // src/SequelizeLibrary.ts
-var logger18 = logger_default.get("SequelizeLibrary");
+var logger15 = logger_default.get("SequelizeLibrary");
 var createSequelizeLibrary = (registry, coordinate, models, options) => {
-  logger18.debug("createSequelizeLibrary", { coordinate, models, registry, options });
+  logger15.debug("createSequelizeLibrary", { coordinate, models, registry, options });
   const operations = createOperations(models, coordinate, registry, options);
   const wrappedOperations = Library2.wrapOperations(operations, options, coordinate, registry);
   const libLibrary = Library2.createLibrary(registry, coordinate, wrappedOperations, options);
@@ -1452,10 +1263,10 @@ var isSequelizeLibrary = (library) => {
 };
 
 // src/SequelizeLibraryFactory.ts
-var logger19 = logger_default.get("InstanceFactory");
+var logger16 = logger_default.get("InstanceFactory");
 var createSequelizeLibraryFactory = (models, options) => {
   return (coordinate, context) => {
-    logger19.debug("Creating Sequelize instance", {
+    logger16.debug("Creating Sequelize instance", {
       coordinate,
       registry: context.registry,
       models: models.map((m) => m.name),
@@ -1500,9 +1311,9 @@ __export(primary_exports, {
 
 // src/primary/SequelizeLibrary.ts
 import { Primary } from "@fjell/lib";
-var logger20 = logger_default.get("lib-sequelize", "primary", "library");
+var logger17 = logger_default.get("lib-sequelize", "primary", "library");
 function createSequelizeLibrary3(keyType, models, libOptions = {}, scopes = [], registry) {
-  logger20.debug("createSequelizeLibrary", { keyType, models, libOptions, scopes });
+  logger17.debug("createSequelizeLibrary", { keyType, models, libOptions, scopes });
   const coordinate = createCoordinate([keyType], scopes);
   const options = createOptions2(libOptions);
   const operations = createOperations(models, coordinate, registry, options);