@fjell/lib-sequelize 4.4.53 → 4.4.55

package/dist/index.js

@@ -26,7 +26,7 @@ var LibLogger = Logging.getLogger("@fjell/lib-sequelize");
 var logger_default = LibLogger;
 
 // src/Coordinate.ts
-import { createCoordinate as createBaseCoordinate } from "@fjell/registry";
+import { createCoordinate as createBaseCoordinate } from "@fjell/core";
 var logger = logger_default.get("Coordinate");
 var SCOPE_SEQUELIZE = "sequelize";
 var createCoordinate = (kta, scopes) => {
@@ -48,10 +48,14 @@ var createDefinition = (kta, scopes, libOptions) => {
 };
 
 // src/SequelizeLibrary.ts
+import * as Library3 from "@fjell/lib";
+
+// src/Operations.ts
 import * as Library2 from "@fjell/lib";
 
 // src/ops/all.ts
-import { validateKeys } from "@fjell/core";
+import { createAllWrapper } from "@fjell/core";
+import { validateKeys } from "@fjell/core/validation";
 
 // src/QueryBuilder.ts
 import {
@@ -376,52 +380,6 @@ var buildQuery = (itemQuery, model) => {
   return options;
 };
 
-// src/validation/LocationKeyValidator.ts
-var logger4 = logger_default.get("LocationKeyValidator");
-var validateLocations = (locations, coordinate, operation) => {
-  if (!locations || locations.length === 0) {
-    return;
-  }
-  const keyTypeArray = coordinate.kta;
-  const expectedLocationTypes = keyTypeArray.slice(1);
-  const actualLocationTypes = locations.map((loc) => loc.kt);
-  logger4.debug(`Validating locations for ${operation}`, {
-    expected: expectedLocationTypes,
-    actual: actualLocationTypes,
-    coordinate: keyTypeArray
-  });
-  if (actualLocationTypes.length > expectedLocationTypes.length) {
-    logger4.error("Location key array has too many elements", {
-      expected: expectedLocationTypes.length,
-      actual: actualLocationTypes.length,
-      expectedTypes: expectedLocationTypes,
-      actualTypes: actualLocationTypes,
-      coordinate,
-      operation
-    });
-    throw new Error(
-      `Invalid location key array for ${operation}: Expected at most ${expectedLocationTypes.length} location keys (hierarchy: [${expectedLocationTypes.join(", ")}]), but received ${actualLocationTypes.length} (types: [${actualLocationTypes.join(", ")}])`
-    );
-  }
-  for (let i = 0; i < actualLocationTypes.length; i++) {
-    if (expectedLocationTypes[i] !== actualLocationTypes[i]) {
-      logger4.error("Location key array order mismatch", {
-        position: i,
-        expected: expectedLocationTypes[i],
-        actual: actualLocationTypes[i],
-        expectedHierarchy: expectedLocationTypes,
-        actualOrder: actualLocationTypes,
-        coordinate,
-        operation
-      });
-      throw new Error(
-        `Invalid location key array order for ${operation}: At position ${i}, expected key type "${expectedLocationTypes[i]}" but received "${actualLocationTypes[i]}". Location keys must be ordered according to the hierarchy: [${expectedLocationTypes.join(", ")}]. Received order: [${actualLocationTypes.join(", ")}]`
-      );
-    }
-  }
-  logger4.debug(`Location key array validation passed for ${operation}`, { locations });
-};
-
 // src/util/relationshipUtils.ts
 var buildRelationshipChain = (targetModel, kta, currentIndex, targetIndex) => {
   const associationParts = [];
@@ -502,9 +460,9 @@ var buildRelationshipPath = (targetModel, locatorType, kta, includeIsDirect = fa
 };
 
 // src/KeyMaster.ts
-var logger5 = logger_default.get("sequelize", "KeyMaster");
+var logger4 = logger_default.get("sequelize", "KeyMaster");
 var extractLocationKeyValue = (model, item, locatorType, kta) => {
-  logger5.default("Extracting location key value", { locatorType, kta });
+  logger4.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. Key type array: [${kta.join(", ")}]. Available associations: [${Object.keys(model.associations || {}).join(", ")}]`);
@@ -548,12 +506,12 @@ var extractLocationKeyValue = (model, item, locatorType, kta) => {
   }
 };
 var removeKey = (item) => {
-  logger5.default("Removing Key", { item });
+  logger4.default("Removing Key", { item });
   delete item.key;
   return item;
 };
 var addKey = (model, item, keyTypes) => {
-  logger5.default("Adding Key", { item });
+  logger4.default("Adding Key", { item });
   const key = {};
   const modelClass = model.constructor;
   const primaryKeyAttr = modelClass.primaryKeyAttribute;
@@ -568,7 +526,7 @@ var addKey = (model, item, keyTypes) => {
         locationKeys.push({ kt: locatorType, lk });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger5.error(`Failed to extract location key for '${locatorType}'`, { error: errorMessage, item, keyTypes });
+        logger4.error(`Failed to extract location key for '${locatorType}'`, { error: errorMessage, item, keyTypes });
         throw error;
       }
     }
@@ -589,7 +547,7 @@ import {
 
 // src/EventCoordinator.ts
 import deepmerge from "deepmerge";
-var logger6 = logger_default.get("sequelize", "EventCoordinator");
+var logger5 = logger_default.get("sequelize", "EventCoordinator");
 var populateEvents = (item) => {
   const events = {
     created: { at: item.createdAt || null },
@@ -600,7 +558,7 @@ var populateEvents = (item) => {
   return item;
 };
 var extractEvents = (item) => {
-  logger6.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;
@@ -615,7 +573,7 @@ var extractEvents = (item) => {
   return item;
 };
 var removeEvents = (item) => {
-  logger6.default("Removing Events", { item });
+  logger5.default("Removing Events", { item });
   delete item.events;
   return item;
 };
@@ -623,10 +581,11 @@ var removeEvents = (item) => {
 // src/processing/ReferenceBuilder.ts
 var buildSequelizeReference = async (item, referenceDefinition, registry, context) => {
   const libLogger = logger_default.get("processing", "ReferenceBuilder");
+  const isCompositeItem = referenceDefinition.kta.length > 1;
   const primaryKeyType = referenceDefinition.kta[0];
-  if (referenceDefinition.kta.length > 1) {
+  if (isCompositeItem) {
     libLogger.debug(
-      "Using multikey reference with PriKey assumption",
+      "Detected composite item reference - will use ComKey with empty loc array",
       {
         kta: referenceDefinition.kta,
         primaryKeyType,
@@ -634,10 +593,6 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
         column: referenceDefinition.column
       }
     );
-    libLogger.debug(
-      'ASSUMPTION: The primary key for key type "%s" is unique and can be used to retrieve composite items',
-      primaryKeyType
-    );
   }
   if (!registry) {
     throw new Error(
@@ -655,38 +610,91 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
     item[referenceDefinition.property] = null;
     return item;
   }
-  const priKey = {
-    kt: primaryKeyType,
-    pk: columnValue
-  };
+  let itemKey;
+  if (!isCompositeItem) {
+    itemKey = {
+      kt: primaryKeyType,
+      pk: columnValue
+    };
+  } else if (referenceDefinition.locationColumns && referenceDefinition.locationColumns.length > 0) {
+    const locationTypes = referenceDefinition.kta.slice(1);
+    const loc = [];
+    for (let i = 0; i < referenceDefinition.locationColumns.length; i++) {
+      const columnName = referenceDefinition.locationColumns[i];
+      const locValue = item[columnName];
+      if (locValue == null) {
+        libLogger.warning(
+          `Location column '${columnName}' is null/undefined for reference '${referenceDefinition.property}'. Falling back to empty loc array search.`
+        );
+        itemKey = {
+          kt: primaryKeyType,
+          pk: columnValue,
+          loc: []
+        };
+        break;
+      }
+      loc.push({
+        kt: locationTypes[i],
+        lk: locValue
+      });
+    }
+    if (!itemKey) {
+      itemKey = {
+        kt: primaryKeyType,
+        pk: columnValue,
+        loc
+      };
+      libLogger.debug("Built full ComKey with location context", {
+        itemKey,
+        locationColumns: referenceDefinition.locationColumns,
+        property: referenceDefinition.property
+      });
+    }
+  } else {
+    itemKey = {
+      kt: primaryKeyType,
+      pk: columnValue,
+      loc: []
+    };
+    libLogger.debug("Using empty loc array for composite item reference", {
+      kta: referenceDefinition.kta,
+      property: referenceDefinition.property
+    });
+  }
+  libLogger.debug("Created reference key", {
+    itemKey,
+    isCompositeItem,
+    hasLocationColumns: !!referenceDefinition.locationColumns,
+    property: referenceDefinition.property
+  });
   let referencedItem;
   if (context) {
-    if (context.isCached(priKey)) {
-      libLogger.debug("Using cached reference", { priKey, property: referenceDefinition.property });
-      referencedItem = context.getCached(priKey);
-    } else if (context.isInProgress(priKey)) {
+    if (context.isCached(itemKey)) {
+      libLogger.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", {
-        priKey,
+        itemKey,
         property: referenceDefinition.property
       });
       referencedItem = {
-        key: priKey
+        key: itemKey
         // Add any other minimal properties that might be needed
         // This prevents infinite loops while still providing the key for identification
       };
     } else {
-      context.markInProgress(priKey);
+      context.markInProgress(itemKey);
       try {
-        referencedItem = await library.operations.get(priKey);
-        context.setCached(priKey, referencedItem);
+        referencedItem = await library.operations.get(itemKey);
+        context.setCached(itemKey, referencedItem);
       } catch (error) {
         throw error;
       } finally {
-        context.markComplete(priKey);
+        context.markComplete(itemKey);
       }
     }
   } else {
-    referencedItem = await library.operations.get(priKey);
+    referencedItem = await library.operations.get(itemKey);
   }
   item[referenceDefinition.property] = referencedItem;
   return item;
@@ -700,27 +708,27 @@ var stripSequelizeReferenceItems = (item, referenceDefinitions) => {
 };
 
 // src/RowProcessor.ts
-var logger7 = logger_default.get("sequelize", "RowProcessor");
+var logger6 = logger_default.get("sequelize", "RowProcessor");
 var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context) => {
-  logger7.default("Processing Row", { row });
+  logger6.default("Processing Row", { row });
   const operationContext = context || createOperationContext();
   return contextManager.withContext(operationContext, async () => {
     let item = row.get({ plain: true });
-    logger7.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);
-    logger7.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) {
-          logger7.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 buildSequelizeReference(item, referenceDefinition, registry, operationContext);
         }
       }
       if (aggregationDefinitions && aggregationDefinitions.length > 0) {
         for (const aggregationDefinition of aggregationDefinitions) {
-          logger7.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);
         }
       }
@@ -728,14 +736,205 @@ var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefiniti
     } finally {
       operationContext.markComplete(item.key);
     }
-    logger7.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 logger8 = logger_default.get("sequelize", "ops", "all");
+
+// src/errors/sequelizeErrorHandler.ts
+import {
+  BusinessLogicError,
+  DuplicateError,
+  ValidationError
+} from "@fjell/core";
+function transformSequelizeError(error, itemType, key, modelName, itemData) {
+  if (error.code === "23505" || error.original?.code === "23505") {
+    const constraint = error.original?.constraint;
+    const detail = error.original?.detail;
+    let message = "";
+    if (constraint && detail) {
+      message = `Duplicate value violates unique constraint '${constraint}'. ${detail}`;
+    } else if (detail) {
+      message = `Duplicate value detected. This record already exists. ${detail}`;
+    } else {
+      message = `${itemType} already exists`;
+    }
+    const field = error.fields ? Object.keys(error.fields)[0] : "unique constraint";
+    return new DuplicateError(message, key, field);
+  }
+  if (error.name === "SequelizeUniqueConstraintError" || error.code === "ER_DUP_ENTRY") {
+    const field = error.fields ? Object.keys(error.fields)[0] : "unique constraint";
+    return new DuplicateError(
+      `${itemType} already exists`,
+      key,
+      field
+    );
+  }
+  if (error.name === "SequelizeValidationError") {
+    const fields = error.errors?.map((e) => e.path) || [];
+    const message = error.errors?.map((e) => e.message).join(", ") || `Validation failed for ${itemType}`;
+    return new ValidationError(
+      message,
+      fields,
+      "Fix validation errors and try again"
+    );
+  }
+  if (error.code === "23503" || error.original?.code === "23503") {
+    const constraint = error.original?.constraint;
+    const detail = error.original?.detail;
+    let message = "";
+    if (constraint && detail) {
+      message = `Foreign key constraint '${constraint}' violated. Referenced record does not exist. ${detail}`;
+    } else if (constraint) {
+      message = `Foreign key constraint '${constraint}' violated. Referenced record does not exist.`;
+    } else if (detail) {
+      message = `Referenced record does not exist. Check that all related records are valid. ${detail}`;
+    } else {
+      message = "Referenced item does not exist";
+    }
+    return new ValidationError(
+      message,
+      void 0,
+      "Ensure all referenced items exist before creating this relationship"
+    );
+  }
+  if (error.name === "SequelizeForeignKeyConstraintError" || error.code === "ER_NO_REFERENCED_ROW") {
+    return new ValidationError(
+      "Referenced item does not exist",
+      void 0,
+      "Ensure all referenced items exist before creating this relationship"
+    );
+  }
+  if (error.code === "23502" || error.original?.code === "23502") {
+    const column = error.original?.column;
+    const fields = column ? [column] : void 0;
+    return new ValidationError(
+      column ? `Required field '${column}' cannot be null` : "Required field is missing or null",
+      fields,
+      "Provide all required fields"
+    );
+  }
+  if (error.code === "23514" || error.original?.code === "23514") {
+    const constraint = error.original?.constraint;
+    const detail = error.original?.detail;
+    let message = "";
+    if (constraint && detail) {
+      message = `Check constraint '${constraint}' violated. ${detail}`;
+    } else if (detail) {
+      message = `Data validation failed. Check constraint violated. ${detail}`;
+    } else if (constraint) {
+      message = `Check constraint '${constraint}' violated`;
+    } else {
+      message = "Data validation failed";
+    }
+    return new ValidationError(
+      message,
+      void 0,
+      "Ensure data meets all constraints"
+    );
+  }
+  if (error.name === "SequelizeDatabaseError" && error.message?.includes("Unknown column")) {
+    const match = error.message.match(/Unknown column '(.+?)'/);
+    const field = match ? match[1] : "unknown field";
+    return new ValidationError(
+      `Invalid field: ${field}`,
+      [field],
+      "Check the field names in your request"
+    );
+  }
+  if (error.code === "22001" || error.original?.code === "22001") {
+    const detail = error.original?.detail;
+    const message = detail ? `Data too long for field. Check string lengths. ${detail}` : "Data too long for field";
+    return new ValidationError(
+      message,
+      void 0,
+      "Check string lengths and try again"
+    );
+  }
+  if (error.code === "22003" || error.original?.code === "22003") {
+    const detail = error.original?.detail;
+    const message = detail ? `Numeric value out of range. Check number values. ${detail}` : "Numeric value out of range";
+    return new ValidationError(
+      message,
+      void 0,
+      "Check number values and try again"
+    );
+  }
+  if (error.code === "42703" || error.original?.code === "42703") {
+    const column = error.original?.column;
+    const fields = column ? [column] : void 0;
+    const message = column && modelName ? `Column '${column}' does not exist in table '${modelName}'` : column ? `Column '${column}' does not exist` : "Referenced column does not exist";
+    return new ValidationError(
+      message,
+      fields,
+      "Check the field names in your request"
+    );
+  }
+  if (error.code === "42P01" || error.original?.code === "42P01") {
+    const message = modelName ? `Table '${modelName}' does not exist` : "Table does not exist";
+    return new ValidationError(
+      message,
+      void 0,
+      "Check the table name and database configuration"
+    );
+  }
+  if (error.message?.includes("notNull Violation") || error.message?.includes("cannot be null")) {
+    const fieldMatches = error.message.match(/([a-zA-Z]+\.[a-zA-Z]+) cannot be null/g);
+    if (fieldMatches) {
+      const fields = fieldMatches.map((match) => {
+        const parts = match.split(".");
+        return parts[1]?.split(" ")[0];
+      }).filter(Boolean);
+      if (fields.length > 0) {
+        return new ValidationError(
+          `Required field${fields.length > 1 ? "s" : ""} ${fields.join(", ")} cannot be null`,
+          fields,
+          "Provide all required fields"
+        );
+      }
+    }
+    return new ValidationError(
+      "Required fields are missing",
+      void 0,
+      "Provide all required fields"
+    );
+  }
+  if (error.name === "SequelizeConnectionError" || error.name === "SequelizeConnectionRefusedError") {
+    return new BusinessLogicError(
+      "Database connection failed",
+      "Check database connectivity and try again",
+      true
+      // retryable
+    );
+  }
+  if (error.name === "SequelizeTimeoutError") {
+    return new BusinessLogicError(
+      "Database operation timed out",
+      "Try again or simplify the operation",
+      true
+      // retryable
+    );
+  }
+  if (!error.original && modelName && itemData && error.message) {
+    const formattedData = JSON.stringify(itemData, null, 2);
+    return new Error(
+      `Database error in ${modelName}.create(): ${error.message}. Item data: ${formattedData}`
+    );
+  }
+  if (error.original && modelName && itemData) {
+    const formattedData = JSON.stringify(itemData, null, 2);
+    return new Error(
+      `Database error in ${modelName}.create(): ${error.message}. Item data: ${formattedData}`
+    );
+  }
+  return error;
+}
+
+// src/ops/all.ts
+var logger7 = logger_default.get("sequelize", "ops", "all");
 var mergeIncludes = (existingIncludes, newIncludes) => {
   const mergedIncludes = [...existingIncludes];
   for (const newInclude of newIncludes) {
@@ -757,162 +956,105 @@ var mergeIncludes = (existingIncludes, newIncludes) => {
 };
 var getAllOperation = (models, definition, registry) => {
   const { coordinate, options: { references, aggregations } } = definition;
-  const all = async (itemQuery, locations) => {
-    logger8.debug(`ALL operation called on ${models[0].name} with ${locations?.length || 0} location filters: ${locations?.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
-    validateLocations(locations, coordinate, "all");
-    const loc = locations || [];
-    const model = models[0];
-    const options = buildQuery(itemQuery, model);
-    if (loc.length > 0) {
-      const { kta } = coordinate;
-      const directLocations = [];
-      const hierarchicalLocations = [];
-      const additionalIncludes = [];
-      for (const locKey of loc) {
-        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.`;
-          logger8.error(errorMessage, { locations: loc, kta });
-          throw new Error(errorMessage);
-        }
-        if (relationshipInfo.isDirect) {
-          directLocations.push(locKey);
-        } else {
-          hierarchicalLocations.push(locKey);
-        }
-      }
-      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) {
-          logger8.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]) {
-          logger8.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
-          continue;
-        }
-        logger8.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) {
-          logger8.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]) {
-            logger8.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
-            continue;
+  return createAllWrapper(
+    coordinate,
+    async (itemQuery, locations) => {
+      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"}`);
+        const loc = locs;
+        const model = models[0];
+        const options = buildQuery(itemQuery ?? {}, model);
+        if (loc.length > 0) {
+          const { kta } = coordinate;
+          const directLocations = [];
+          const hierarchicalLocations = [];
+          const additionalIncludes = [];
+          for (const locKey of loc) {
+            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.`;
+              logger7.error(errorMessage, { locations: loc, kta });
+              throw new Error(errorMessage);
+            }
+            if (relationshipInfo.isDirect) {
+              directLocations.push(locKey);
+            } else {
+              hierarchicalLocations.push(locKey);
+            }
           }
-          logger8.trace(`[ALL] Setting hierarchical location where clause: ${relationshipInfo.path} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
-          options.where[relationshipInfo.path] = {
-            [Op2.eq]: locKey.lk
-          };
-          if (relationshipInfo.includes) {
-            additionalIncludes.push(...relationshipInfo.includes);
+          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) {
+              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]) {
+              logger7.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
+              continue;
+            }
+            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) {
+              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]) {
+                logger7.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
+                continue;
+              }
+              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
+              };
+              if (relationshipInfo.includes) {
+                additionalIncludes.push(...relationshipInfo.includes);
+              }
+            }
+          }
+          if (additionalIncludes.length > 0) {
+            const existingIncludes = options.include || [];
+            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}`);
+        try {
+          logger7.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
+        } catch {
+          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();
+        const results = 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;
+      } catch (error) {
+        throw transformSequelizeError(error, coordinate.kta[0]);
       }
-      if (additionalIncludes.length > 0) {
-        const existingIncludes = options.include || [];
-        options.include = mergeIncludes(existingIncludes, additionalIncludes);
-      }
-    }
-    logger8.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(", ") : "none"}, includes: ${options.include?.length || 0}`);
-    try {
-      logger8.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
-    } catch {
-      logger8.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();
-    const results = await Promise.all(matchingItems.map(async (row) => {
-      const processedRow = await processRow(row, coordinate.kta, references || [], aggregations || [], registry, currentContext);
-      return validateKeys(processedRow, coordinate.kta);
-    }));
-    logger8.debug(`[ALL] Returning ${results.length} ${model.name} records`);
-    return results;
-  };
-  return all;
+  );
 };
 
 // src/ops/create.ts
-import { isComKey as isComKey2, isPriKey as isPriKey2, validateKeys as validateKeys2 } from "@fjell/core";
-var logger9 = 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;
-  logger9.error("Database error during create operation", {
-    errorCode,
-    constraint,
-    detail,
-    originalMessage,
-    modelName,
-    itemData: JSON.stringify(itemData, null, 2)
-  });
-  switch (errorCode) {
-    case "23505":
-      if (constraint) {
-        return new Error(`Duplicate value violates unique constraint '${constraint}'. ${detail || ""}`);
-      }
-      return new Error(`Duplicate value detected. This record already exists. ${detail || ""}`);
-    case "23503":
-      if (constraint) {
-        return new Error(`Foreign key constraint '${constraint}' violated. Referenced record does not exist. ${detail || ""}`);
-      }
-      return new Error(`Referenced record does not exist. Check that all related records are valid. ${detail || ""}`);
-    case "23502":
-      const column = error.original?.column;
-      if (column) {
-        return new Error(`Required field '${column}' cannot be null`);
-      }
-      return new Error(`Required field is missing or null`);
-    case "23514":
-      if (constraint) {
-        return new Error(`Check constraint '${constraint}' violated. ${detail || ""}`);
-      }
-      return new Error(`Data validation failed. Check constraint violated. ${detail || ""}`);
-    case "22001":
-      return new Error(`Data too long for field. Check string lengths. ${detail || ""}`);
-    case "22003":
-      return new Error(`Numeric value out of range. Check number values. ${detail || ""}`);
-    case "42703":
-      const undefinedColumn = error.original?.column;
-      if (undefinedColumn) {
-        return new Error(`Column '${undefinedColumn}' does not exist in table '${modelName}'`);
-      }
-      return new Error(`Referenced column does not exist`);
-    case "42P01":
-      return new Error(`Table '${modelName}' does not exist`);
-    default:
-      if (originalMessage.includes("notNull Violation")) {
-        const fieldMatches = originalMessage.match(/([a-zA-Z]+\.[a-zA-Z]+) cannot be null/g);
-        if (fieldMatches) {
-          const fields = fieldMatches.map((match) => {
-            const parts = match.split(".");
-            return parts[1]?.split(" ")[0];
-          }).filter(Boolean);
-          if (fields.length > 0) {
-            return new Error(`Required field${fields.length > 1 ? "s" : ""} ${fields.join(", ")} cannot be null`);
-          }
-        }
-        return new Error("Required fields are missing");
-      }
-      return new Error(`Database error in ${modelName}.create(): ${originalMessage}. Item data: ${JSON.stringify(itemData, null, 2)}`);
-  }
-}
+import { createCreateWrapper, isComKey as isComKey2, isPriKey as isPriKey2 } 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) {
+  const locatorIndex = kta.indexOf(locKey.kt);
+  if (locatorIndex === -1) {
+    throw new Error(`Locator type '${locKey.kt}' not found in kta array`);
+  }
+  const locatorModel = models[locatorIndex] || models[0];
   try {
-    const locatorIndex = kta.indexOf(locKey.kt);
-    if (locatorIndex === -1) {
-      throw new Error(`Locator type '${locKey.kt}' not found in kta array`);
-    }
-    const locatorModel = models[locatorIndex] || models[0];
     const chainResult = buildRelationshipChain(locatorModel, kta, locatorIndex, kta.length - 1);
     if (!chainResult.success) {
       const record2 = await locatorModel.findByPk(locKey.lk);
@@ -933,56 +1075,82 @@ async function validateHierarchicalChain(models, locKey, kta) {
     }
   } catch (error) {
     if (error.original) {
-      throw translateDatabaseError(error, { locKey, kta }, locKey.kt);
+      throw transformSequelizeError(error, locKey.kt, { locKey, kta }, locatorModel.name);
     }
     throw error;
   }
 }
 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";
-    logger9.debug(`CREATE operation called on ${models[0].name} with ${constraints}`);
-    logger9.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
-    const { coordinate, options: { references, aggregations } } = definition;
-    const { kta } = coordinate;
-    if (options?.locations) {
-      validateLocations(options.locations, coordinate, "create");
-    }
-    if (options?.key && isComKey2(options.key)) {
-      validateLocations(options.key.loc, coordinate, "create");
-    }
-    const model = models[0];
-    const modelAttributes = model.getAttributes();
-    let itemData = { ...item };
-    itemData = extractEvents(itemData);
-    itemData = removeEvents(itemData);
-    const invalidAttributes = [];
-    for (const key of Object.keys(itemData)) {
-      if (!modelAttributes[key]) {
-        invalidAttributes.push(key);
+  const { coordinate, options: { references, aggregations } } = definition;
+  const { kta } = coordinate;
+  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";
+      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];
+      const modelAttributes = model.getAttributes();
+      let itemData = { ...item };
+      itemData = extractEvents(itemData);
+      itemData = removeEvents(itemData);
+      const invalidAttributes = [];
+      for (const key of Object.keys(itemData)) {
+        if (!modelAttributes[key]) {
+          invalidAttributes.push(key);
+        }
       }
-    }
-    if (invalidAttributes.length > 0) {
-      const availableAttributes = Object.keys(modelAttributes).join(", ");
-      throw new Error(
-        `Invalid attributes for model '${model.name}': [${invalidAttributes.join(", ")}]. Available attributes: [${availableAttributes}]. Item data: ${JSON.stringify(itemData, null, 2)}`
-      );
-    }
-    if (options?.key) {
-      const key = options.key;
-      if (isPriKey2(key)) {
-        itemData.id = key.pk;
-      } else if (isComKey2(key)) {
-        itemData.id = key.pk;
-        const comKey = key;
+      if (invalidAttributes.length > 0) {
+        const availableAttributes = Object.keys(modelAttributes).join(", ");
+        throw new Error(
+          `Invalid attributes for model '${model.name}': [${invalidAttributes.join(", ")}]. Available attributes: [${availableAttributes}]. Item data: ${JSON.stringify(itemData, null, 2)}`
+        );
+      }
+      if (options?.key) {
+        const key = options.key;
+        if (isPriKey2(key)) {
+          itemData.id = key.pk;
+        } else if (isComKey2(key)) {
+          itemData.id = key.pk;
+          const comKey = key;
+          const directLocations = [];
+          const hierarchicalLocations = [];
+          for (const locKey of comKey.loc) {
+            const relationshipInfo = buildRelationshipPath(model, locKey.kt, kta, true);
+            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)}`;
+              logger8.error(errorMessage, { key: comKey, kta, associations });
+              throw new Error(errorMessage);
+            }
+            if (relationshipInfo.isDirect) {
+              directLocations.push(locKey);
+            } else {
+              hierarchicalLocations.push(locKey);
+            }
+          }
+          for (const locKey of directLocations) {
+            if (locKey.lk == null || locKey.lk === "") {
+              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";
+            itemData[foreignKeyField] = locKey.lk;
+          }
+          for (const locKey of hierarchicalLocations) {
+            await validateHierarchicalChain(models, locKey, kta);
+          }
+        }
+      }
+      if (options?.locations) {
         const directLocations = [];
         const hierarchicalLocations = [];
-        for (const locKey of comKey.loc) {
+        for (const locKey of options.locations) {
           const relationshipInfo = buildRelationshipPath(model, locKey.kt, kta, true);
           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)}`;
-            logger9.error(errorMessage, { key: comKey, kta, 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)}`;
+            logger8.error(errorMessage, { locations: options.locations, kta, associations });
             throw new Error(errorMessage);
           }
           if (relationshipInfo.isDirect) {
@@ -993,8 +1161,8 @@ var getCreateOperation = (models, definition, registry) => {
         }
         for (const locKey of directLocations) {
           if (locKey.lk == null || locKey.lk === "") {
-            logger9.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`);
+            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";
           itemData[foreignKeyField] = locKey.lk;
@@ -1003,99 +1171,78 @@ var getCreateOperation = (models, definition, registry) => {
           await validateHierarchicalChain(models, locKey, kta);
         }
       }
-    }
-    if (options?.locations) {
-      const directLocations = [];
-      const hierarchicalLocations = [];
-      for (const locKey of options.locations) {
-        const relationshipInfo = buildRelationshipPath(model, locKey.kt, kta, true);
-        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)}`;
-          logger9.error(errorMessage, { locations: options.locations, kta, associations });
-          throw new Error(errorMessage);
-        }
-        if (relationshipInfo.isDirect) {
-          directLocations.push(locKey);
-        } else {
-          hierarchicalLocations.push(locKey);
-        }
-      }
-      for (const locKey of directLocations) {
-        if (locKey.lk == null || locKey.lk === "") {
-          logger9.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";
-        itemData[foreignKeyField] = locKey.lk;
-      }
-      for (const locKey of hierarchicalLocations) {
-        await validateHierarchicalChain(models, locKey, kta);
+      try {
+        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);
+        logger8.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
+        return result;
+      } catch (error) {
+        throw transformSequelizeError(error, kta[0], options?.key, model.name, itemData);
       }
     }
-    try {
-      logger9.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);
-      logger9.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);
-    }
-  };
-  return create;
+  );
 };
 
 // src/ops/find.ts
-import { validateKeys as validateKeys3 } from "@fjell/core";
-var logger10 = logger_default.get("sequelize", "ops", "find");
+import { createFindWrapper } from "@fjell/core";
+import { validateKeys as validateKeys3 } from "@fjell/core/validation";
+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";
-    logger10.debug(
-      `FIND operation called on ${models[0].name} with finder '${finder}' and ${locations?.length || 0} location filters: ${locationFilters}`
-    );
-    logger10.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
-    validateLocations(locations, definition.coordinate, "find");
-    if (finders && finders[finder]) {
-      const finderMethod = finders[finder];
-      if (finderMethod) {
-        logger10.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);
-          }));
-          logger10.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
-          return processedResults;
+  return createFindWrapper(
+    definition.coordinate,
+    async (finder, finderParams, locations) => {
+      try {
+        const locs = locations ?? [];
+        const params = finderParams ?? {};
+        const locationFilters = locs.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none";
+        logger9.debug(
+          `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 {
-          logger10.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
-          return [];
+          logger9.error(`No finders have been defined for this lib`);
+          throw new Error(`No finders found`);
         }
-      } else {
-        logger10.error(`Finder %s not found`, finder);
-        throw new Error(`Finder ${finder} not found`);
+      } catch (error) {
+        throw transformSequelizeError(error, definition.coordinate.kta[0]);
       }
-    } else {
-      logger10.error(`No finders have been defined for this lib`);
-      throw new Error(`No finders found`);
     }
-  };
-  return find;
+  );
 };
 
 // src/ops/get.ts
 import {
+  createGetWrapper,
   isComKey as isComKey3,
   isPriKey as isPriKey3,
   isValidItemKey,
   validateKeys as validateKeys4
 } from "@fjell/core";
-import { NotFoundError } from "@fjell/lib";
-var logger11 = logger_default.get("sequelize", "ops", "get");
+import { NotFoundError } from "@fjell/core";
+var logger10 = logger_default.get("sequelize", "ops", "get");
 var processCompositeKey = (comKey, model, kta) => {
   const where = { id: comKey.pk };
   const includes = [];
@@ -1103,7 +1250,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(", ")}]`;
-      logger11.error(errorMessage, { key: comKey, kta });
+      logger10.error(errorMessage, { key: comKey, kta });
       throw new Error(errorMessage);
     }
     if (relationshipInfo.path) {
@@ -1125,64 +1272,82 @@ var processCompositeKey = (comKey, model, kta) => {
 var getGetOperation = (models, definition, registry) => {
   const { coordinate, options: { references, aggregations } } = definition;
   const { kta } = coordinate;
-  const get = async (key) => {
-    if (!isValidItemKey(key)) {
-      logger11.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(", ")}]`;
-    logger11.debug(`GET operation called on ${models[0].name} with ${keyDescription}`);
-    logger11.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)) {
-      logger11.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);
-      logger11.default("Composite key query", { queryOptions });
-      logger11.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-      item = await model.findOne(queryOptions);
-    }
-    if (!item) {
-      throw new NotFoundError("get", coordinate, key);
-    } else {
-      const currentContext = contextManager.getCurrentContext();
-      const result = validateKeys4(await processRow(item, kta, references || [], aggregations || [], registry, currentContext), kta);
-      logger11.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
-      return result;
+  return createGetWrapper(
+    coordinate,
+    async (key) => {
+      try {
+        if (!isValidItemKey(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(", ")}]`;
+        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)) {
+          logger10.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
+          item = await model.findByPk(itemKey.pk);
+        } else if (isComKey3(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}`);
+            logger10.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${comKey.pk}`);
+            item = await model.findByPk(comKey.pk);
+          } else {
+            const queryOptions = processCompositeKey(comKey, model, kta);
+            logger10.default("Composite key query", { queryOptions });
+            logger10.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+            item = await model.findOne(queryOptions);
+          }
+        }
+        if (!item) {
+          throw new NotFoundError(
+            `${kta[0]} not found`,
+            kta[0],
+            key
+          );
+        }
+        const currentContext = contextManager.getCurrentContext();
+        const result = validateKeys4(await processRow(item, kta, references || [], aggregations || [], registry, currentContext), kta);
+        logger10.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
+        return result;
+      } catch (error) {
+        if (error instanceof NotFoundError) throw error;
+        throw transformSequelizeError(error, kta[0], key);
+      }
     }
-  };
-  return get;
+  );
 };
 
 // src/ops/one.ts
-var logger12 = logger_default.get("sequelize", "ops", "one");
+import { createOneWrapper } from "@fjell/core";
+var logger11 = logger_default.get("sequelize", "ops", "one");
 var getOneOperation = (models, definition, registry) => {
-  const one = async (itemQuery, locations = []) => {
-    logger12.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
-    logger12.default(`One configured for ${models[0].name} delegating to all operation`);
-    validateLocations(locations, definition.coordinate, "one");
-    const items = await getAllOperation(models, definition, registry)(itemQuery, locations);
-    if (items.length > 0) {
-      const result = items[0];
-      logger12.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : "unknown"}`);
-      return result;
-    } else {
-      logger12.debug(`[ONE] No ${models[0].name} record found`);
-      return null;
+  return createOneWrapper(
+    definition.coordinate,
+    async (itemQuery, locations) => {
+      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;
+      } else {
+        logger11.debug(`[ONE] No ${models[0].name} record found`);
+        return null;
+      }
     }
-  };
-  return one;
+  );
 };
 
 // src/ops/remove.ts
-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 logger13 = logger_default.get("sequelize", "ops", "remove");
+import { abbrevIK, isComKey as isComKey4, isPriKey as isPriKey4, 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) => {
   const where = { id: comKey.pk };
   const includes = [];
@@ -1190,7 +1355,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.`;
-      logger13.error(errorMessage, { key: comKey, kta });
+      logger12.error(errorMessage, { key: comKey, kta });
       throw new Error(errorMessage);
     }
     if (relationshipInfo.path) {
@@ -1212,66 +1377,77 @@ var processCompositeKey2 = (comKey, model, kta) => {
 var getRemoveOperation = (models, definition, _registry) => {
   const { coordinate, options } = definition;
   const { kta } = coordinate;
-  const remove = async (key) => {
-    if (!isValidItemKey2(key)) {
-      logger13.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(", ")}]`;
-    logger13.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
-    logger13.default(`Remove configured for ${models[0].name} with ${isPriKey4(key) ? "primary" : "composite"} key`);
-    const model = models[0];
-    let item;
-    let returnItem;
-    logger13.debug("remove: %s", abbrevIK(key));
-    if (isPriKey4(key)) {
-      logger13.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);
-      logger13.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-      logger13.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
-      item = await model.findOne(queryOptions);
-    }
-    if (!item) {
-      throw new NotFoundError2("remove", coordinate, key);
-    }
-    const isDeletedAttribute = model.getAttributes().isDeleted;
-    const deletedAtAttribute = model.getAttributes().deletedAt;
-    if (isDeletedAttribute || deletedAtAttribute) {
-      if (model.getAttributes().isDeleted) {
-        item.isDeleted = true;
-      }
-      if (model.getAttributes().deletedAt) {
-        item.deletedAt = /* @__PURE__ */ new Date();
+  return createRemoveWrapper(
+    coordinate,
+    async (key) => {
+      try {
+        if (!isValidItemKey2(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(", ")}]`;
+        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;
+        logger12.debug("remove: %s", abbrevIK(key));
+        if (isPriKey4(key)) {
+          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);
+          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) {
+          throw new NotFoundError2(
+            `Cannot remove: ${kta[0]} not found`,
+            kta[0],
+            key
+          );
+        }
+        const isDeletedAttribute = model.getAttributes().isDeleted;
+        const deletedAtAttribute = model.getAttributes().deletedAt;
+        if (isDeletedAttribute || deletedAtAttribute) {
+          if (model.getAttributes().isDeleted) {
+            item.isDeleted = true;
+          }
+          if (model.getAttributes().deletedAt) {
+            item.deletedAt = /* @__PURE__ */ new Date();
+          }
+          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) {
+          logger12.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
+          await item?.destroy();
+          returnItem = item?.get({ plain: true });
+          returnItem = addKey(item, returnItem, kta);
+          returnItem = populateEvents(returnItem);
+        } else {
+          throw new Error("No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set");
+        }
+        logger12.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
+        return returnItem;
+      } catch (error) {
+        if (error instanceof NotFoundError2) throw error;
+        throw transformSequelizeError(error, kta[0], key);
       }
-      logger13.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) {
-      logger13.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
-      await item?.destroy();
-      returnItem = item?.get({ plain: true });
-      returnItem = addKey(item, returnItem, kta);
-      returnItem = populateEvents(returnItem);
-    } else {
-      throw new Error("No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set");
     }
-    logger13.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
-    return returnItem;
-  };
-  return remove;
+  );
 };
 
 // src/ops/update.ts
-import { abbrevIK as abbrevIK2, isComKey as isComKey5, validateKeys as validateKeys5 } from "@fjell/core";
-import { isPriKey as isPriKey5 } from "@fjell/core";
-import { NotFoundError as NotFoundError3 } from "@fjell/lib";
+import { abbrevIK as abbrevIK2, createUpdateWrapper, isComKey as isComKey5, isPriKey as isPriKey5 } from "@fjell/core";
+import { validateKeys as validateKeys5 } from "@fjell/core/validation";
+import { NotFoundError as NotFoundError3 } from "@fjell/core";
 import { Op as Op3 } from "sequelize";
-var logger14 = 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) {
@@ -1293,130 +1469,136 @@ var mergeIncludes2 = (existingIncludes, newIncludes) => {
 };
 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(", ")}]`;
-    logger14.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`);
-    const { coordinate } = definition;
-    const { kta } = coordinate;
-    logger14.debug("update: %s, %j", abbrevIK2(key), item);
-    const model = models[0];
-    let response;
-    if (isPriKey5(key)) {
-      const priKey = key;
-      logger14.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
-      response = await model.findByPk(priKey.pk);
-    } else if (isComKey5(key)) {
-      const comKey = key;
-      const where = { id: comKey.pk };
-      const additionalIncludes = [];
-      for (const locator of comKey.loc) {
-        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.`;
-          logger14.error(errorMessage, { key: comKey, kta });
-          throw new Error(errorMessage);
-        }
-        if (relationshipInfo.isDirect) {
-          const fieldName = `${locator.kt}Id`;
-          where[fieldName] = locator.lk;
-        } else if (relationshipInfo.path) {
-          where[relationshipInfo.path] = {
-            [Op3.eq]: locator.lk
-          };
-          if (relationshipInfo.includes) {
-            additionalIncludes.push(...relationshipInfo.includes);
+  return createUpdateWrapper(
+    definition.coordinate,
+    async (key, item) => {
+      try {
+        const keyDescription = isPriKey5(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}`);
+        const { coordinate } = definition;
+        const { kta } = coordinate;
+        logger13.debug("update: %s, %j", abbrevIK2(key), item);
+        const model = models[0];
+        let response;
+        if (isPriKey5(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)) {
+          const comKey = key;
+          const where = { id: comKey.pk };
+          const additionalIncludes = [];
+          for (const locator of comKey.loc) {
+            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.`;
+              logger13.error(errorMessage, { key: comKey, kta });
+              throw new Error(errorMessage);
+            }
+            if (relationshipInfo.isDirect) {
+              const fieldName = `${locator.kt}Id`;
+              where[fieldName] = locator.lk;
+            } else if (relationshipInfo.path) {
+              where[relationshipInfo.path] = {
+                [Op3.eq]: locator.lk
+              };
+              if (relationshipInfo.includes) {
+                additionalIncludes.push(...relationshipInfo.includes);
+              }
+            }
           }
+          const queryOptions = { where };
+          if (additionalIncludes.length > 0) {
+            queryOptions.include = mergeIncludes2([], additionalIncludes);
+          }
+          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) {
+          throw new NotFoundError3(
+            `Cannot update: ${kta[0]} not found`,
+            kta[0],
+            key
+          );
+        }
+        let updateProps = removeKey(item);
+        updateProps = extractEvents(updateProps);
+        updateProps = removeEvents(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);
+        logger13.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
+        return returnItem;
+      } catch (error) {
+        if (error instanceof NotFoundError3) throw error;
+        throw transformSequelizeError(error, definition.coordinate.kta[0], key);
       }
-      const queryOptions = { where };
-      if (additionalIncludes.length > 0) {
-        queryOptions.include = mergeIncludes2([], additionalIncludes);
-      }
-      logger14.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-      logger14.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);
-      logger14.default(`Update found ${model.name} record to modify`);
-      logger14.default(`Update properties configured: ${Object.keys(updateProps).join(", ")}`);
-      logger14.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);
-      logger14.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);
     }
-  };
-  return update;
+  );
 };
 
 // src/ops/upsert.ts
-import { isValidItemKey as isValidItemKey3 } from "@fjell/core";
-var logger15 = logger_default.get("sequelize", "ops", "upsert");
+import { createUpsertWrapper, isValidItemKey as isValidItemKey3 } from "@fjell/core";
+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)) {
-      logger15.error("Key for Upsert is not a valid ItemKey: %j", key);
-      throw new Error(`Key for Upsert is not a valid ItemKey: ${stringifyJSON(key)}`);
-    }
-    logger15.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`);
-    try {
-      const existingItem = await get(key);
-      if (existingItem) {
-        logger15.debug(`[UPSERT] Item exists, updating with key: ${stringifyJSON(key)}`);
-        return await update(key, item);
+  return createUpsertWrapper(
+    definition.coordinate,
+    async (key, item) => {
+      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)}`);
       }
-    } catch {
-      logger15.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}`);
+      logger14.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`);
+      try {
+        const existingItem = await get(key);
+        if (existingItem) {
+          logger14.debug(`[UPSERT] Item exists, updating with key: ${stringifyJSON(key)}`);
+          return await update(key, item);
+        }
+      } catch {
+        logger14.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}`);
+      }
+      return await create(item, { key });
     }
-    return await create(item, { key });
-  };
-  return upsert;
+  );
 };
 
 // src/Operations.ts
 var createOperations = (models, coordinate, registry, options) => {
-  const operations = {};
   const definition = { coordinate, options };
-  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, registry);
-  operations.find = getFindOperation(models, definition, registry);
-  operations.upsert = getUpsertOperation(models, definition, registry);
-  operations.allFacet = async () => {
-  };
-  operations.allAction = async () => {
-  };
-  operations.action = async () => {
+  const implOps = {
+    all: getAllOperation(models, definition, registry),
+    one: getOneOperation(models, definition, registry),
+    create: getCreateOperation(models, definition, registry),
+    update: getUpdateOperation(models, definition, registry),
+    get: getGetOperation(models, definition, registry),
+    remove: getRemoveOperation(models, definition, registry),
+    find: getFindOperation(models, definition, registry),
+    // findOne depends on find, so set it after
+    findOne: null,
+    upsert: getUpsertOperation(models, definition, registry)
   };
-  operations.facet = async () => {
+  implOps.findOne = async (finder, params, locations) => {
+    const results = await implOps.find(finder, params || {}, locations);
+    return results.length > 0 ? results[0] : null;
   };
-  operations.finders = { ...options.finders || {} };
-  operations.actions = { ...options.actions || {} };
-  operations.facets = { ...options.facets || {} };
-  operations.allActions = { ...options.allActions || {} };
-  operations.allFacets = { ...options.allFacets || {} };
-  return operations;
+  return Library2.wrapImplementationOperations(implOps, options);
 };
 
 // src/SequelizeLibrary.ts
-var logger16 = logger_default.get("SequelizeLibrary");
+var logger15 = logger_default.get("SequelizeLibrary");
 var createSequelizeLibrary = (registry, coordinate, models, options) => {
-  logger16.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);
+  const wrappedOperations = Library3.wrapOperations(operations, options, coordinate, registry);
+  const libLibrary = Library3.createLibrary(registry, coordinate, wrappedOperations, options);
   return {
     ...libLibrary,
     models
@@ -1427,10 +1609,10 @@ var isSequelizeLibrary = (library) => {
 };
 
 // src/SequelizeLibraryFactory.ts
-var logger17 = logger_default.get("InstanceFactory");
+var logger16 = logger_default.get("InstanceFactory");
 var createSequelizeLibraryFactory = (models, options) => {
   return (coordinate, context) => {
-    logger17.debug("Creating Sequelize instance", {
+    logger16.debug("Creating Sequelize instance", {
       coordinate,
       registry: context.registry,
       models: models.map((m) => m.name),
@@ -1475,9 +1657,9 @@ __export(primary_exports, {
 
 // src/primary/SequelizeLibrary.ts
 import { Primary } from "@fjell/lib";
-var logger18 = logger_default.get("lib-sequelize", "primary", "library");
+var logger17 = logger_default.get("lib-sequelize", "primary", "library");
 function createSequelizeLibrary3(keyType, models, libOptions = {}, scopes = [], registry) {
-  logger18.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);