@fjell/lib-sequelize 4.4.81 → 4.4.83

package/dist/index.js

@@ -55,14 +55,11 @@ import * as Library2 from "@fjell/lib";
 
 // src/ops/all.ts
 import { createAllWrapper } from "@fjell/core";
-import { validateKeys } from "@fjell/core/validation";
+import { validateKeys } from "@fjell/validation";
 
 // src/QueryBuilder.ts
-import {
-  isComKey,
-  isCondition,
-  isPriKey
-} from "@fjell/core";
+import { isCondition } from "@fjell/types";
+import { isComKey, isPriKey } from "@fjell/core";
 import { Op } from "sequelize";
 
 // src/util/general.ts
@@ -926,11 +923,11 @@ var removeEvents = (item) => {
 
 // src/processing/ReferenceBuilder.ts
 var buildSequelizeReference = async (item, referenceDefinition, registry, context) => {
-  const libLogger3 = logger_default.get("processing", "ReferenceBuilder");
+  const libLogger4 = logger_default.get("processing", "ReferenceBuilder");
   const isCompositeItem = referenceDefinition.kta.length > 1;
   const primaryKeyType = referenceDefinition.kta[0];
   if (isCompositeItem) {
-    libLogger3.debug(
+    libLogger4.debug(
       "Detected composite item reference - will use ComKey with empty loc array",
       {
         kta: referenceDefinition.kta,
@@ -941,7 +938,7 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
     );
   }
   if (!registry) {
-    libLogger3.error("Registry not provided for reference processing", {
+    libLogger4.error("Registry not provided for reference processing", {
       component: "lib-sequelize",
       subcomponent: "ReferenceBuilder",
       operation: "buildSequelizeReference",
@@ -956,7 +953,7 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
   }
   const library = registry.get(referenceDefinition.kta);
   if (!library) {
-    libLogger3.error("Referenced library not found in registry", {
+    libLogger4.error("Referenced library not found in registry", {
       component: "lib-sequelize",
       subcomponent: "ReferenceBuilder",
       operation: "buildSequelizeReference",
@@ -988,7 +985,7 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
       const columnName = referenceDefinition.locationColumns[i];
       const locValue = item[columnName];
       if (locValue == null) {
-        libLogger3.warning(
+        libLogger4.warning(
           `Location column '${columnName}' is null/undefined for reference '${referenceDefinition.property}'. Falling back to empty loc array search.`
         );
         hasNullLocation = true;
@@ -1011,7 +1008,7 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
         pk: columnValue,
         loc
       };
-      libLogger3.debug("Built full ComKey with location context", {
+      libLogger4.debug("Built full ComKey with location context", {
         itemKey,
         locationColumns: referenceDefinition.locationColumns,
         property: referenceDefinition.property
@@ -1023,12 +1020,12 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
       pk: columnValue,
       loc: []
     };
-    libLogger3.default("Using empty loc array for composite item reference", {
+    libLogger4.default("Using empty loc array for composite item reference", {
       kta: referenceDefinition.kta,
       property: referenceDefinition.property
     });
   }
-  libLogger3.default("Created reference key", {
+  libLogger4.default("Created reference key", {
     itemKey,
     isCompositeItem,
     hasLocationColumns: !!referenceDefinition.locationColumns,
@@ -1037,10 +1034,10 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
   let referencedItem;
   if (context) {
     if (context.isCached(itemKey)) {
-      libLogger3.debug("Using cached reference", { itemKey, property: referenceDefinition.property });
+      libLogger4.debug("Using cached reference", { itemKey, property: referenceDefinition.property });
       referencedItem = context.getCached(itemKey);
     } else if (context.isInProgress(itemKey)) {
-      libLogger3.default("Circular dependency detected, creating reference placeholder", {
+      libLogger4.default("Circular dependency detected, creating reference placeholder", {
         itemKey,
         property: referenceDefinition.property
       });
@@ -1055,7 +1052,7 @@ var buildSequelizeReference = async (item, referenceDefinition, registry, contex
         referencedItem = await library.operations.get(itemKey);
         context.setCached(itemKey, referencedItem);
       } catch (error) {
-        libLogger3.error("Failed to load reference", {
+        libLogger4.error("Failed to load reference", {
           component: "lib-sequelize",
           subcomponent: "ReferenceBuilder",
           operation: "buildSequelizeReference",
@@ -1767,7 +1764,7 @@ var getAllOperation = (models, definition, registry) => {
 
 // src/ops/create.ts
 import { createCreateWrapper, isComKey as isComKey3, isPriKey as isPriKey3 } from "@fjell/core";
-import { validateKeys as validateKeys2 } from "@fjell/core/validation";
+import { validateKeys as validateKeys2 } from "@fjell/validation";
 var logger10 = logger_default.get("sequelize", "ops", "create");
 async function validateHierarchicalChain(models, locKey, kta) {
   const locatorIndex = kta.indexOf(locKey.kt);
@@ -1913,7 +1910,42 @@ var getCreateOperation = (models, definition, registry) => {
         logger10.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
         queryMetrics.recordQuery(model.name);
         const createdRecord = await model.create(itemData);
-        const processedRecord = await processRow(createdRecord, kta, references || [], aggregations || [], registry, void 0, void 0);
+        let recordToProcess = createdRecord;
+        if (kta.length > 1) {
+          const includesForKey = [];
+          let currentInclude = null;
+          for (let i = kta.length - 1; i > 0; i--) {
+            const relationshipType = kta[i];
+            const relationshipInfo = buildRelationshipPath(model, relationshipType, kta, true);
+            if (relationshipInfo.found && !relationshipInfo.isDirect) {
+              const intermediateType = kta[i - 1];
+              const newInclude = {
+                association: intermediateType,
+                required: false
+              };
+              if (currentInclude) {
+                newInclude.include = [currentInclude];
+              }
+              currentInclude = newInclude;
+            }
+          }
+          if (currentInclude) {
+            includesForKey.push(currentInclude);
+          }
+          if (includesForKey.length > 0) {
+            logger10.debug(`[CREATE] Reloading ${model.name} with includes for key construction`, { includes: includesForKey });
+            queryMetrics.recordQuery(model.name);
+            const reloadedRecord = await model.findByPk(createdRecord.get("id"), {
+              include: includesForKey
+            });
+            if (reloadedRecord) {
+              recordToProcess = reloadedRecord;
+            } else {
+              logger10.warning(`[CREATE] Failed to reload ${model.name} after creation, using original record`);
+            }
+          }
+        }
+        const processedRecord = await processRow(recordToProcess, kta, references || [], aggregations || [], registry, void 0, void 0);
         const result = validateKeys2(processedRecord, kta);
         logger10.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
         return result;
@@ -1941,7 +1973,7 @@ var getCreateOperation = (models, definition, registry) => {
 
 // src/ops/find.ts
 import { createFindWrapper } from "@fjell/core";
-import { validateKeys as validateKeys3 } from "@fjell/core/validation";
+import { validateKeys as validateKeys3 } from "@fjell/validation";
 var logger11 = logger_default.get("sequelize", "ops", "find");
 var getFindOperation = (models, definition, registry) => {
   const { options: { finders, references, aggregations } } = definition;
@@ -2041,9 +2073,9 @@ import {
   isComKey as isComKey4,
   isPriKey as isPriKey4,
   isValidItemKey,
-  validateKeys as validateKeys4
+  NotFoundError
 } from "@fjell/core";
-import { NotFoundError } from "@fjell/core";
+import { validateKeys as validateKeys4 } from "@fjell/validation";
 var logger12 = logger_default.get("sequelize", "ops", "get");
 var processCompositeKey = (comKey, model, kta) => {
   const where = { id: comKey.pk };
@@ -2150,21 +2182,20 @@ var getGetOperation = (models, definition, registry) => {
 
 // src/ops/one.ts
 import { createOneWrapper } from "@fjell/core";
-var logger13 = logger_default.get("sequelize", "ops", "one");
 var getOneOperation = (models, definition, registry) => {
   return createOneWrapper(
     definition.coordinate,
     async (itemQuery, locations) => {
       const locs = locations ?? [];
-      logger13.debug(`ONE operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
-      logger13.default(`One configured for ${models[0].name} delegating to all operation`);
+      logger_default.debug(`ONE operation called on ${models[0].name} with ${locs.length} location filters: ${locs.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
+      logger_default.default(`One configured for ${models[0].name} delegating to all operation`);
       const result = await getAllOperation(models, definition, registry)(itemQuery ?? {}, locs, { limit: 1 });
       if (result.items.length > 0) {
         const item = result.items[0];
-        logger13.debug(`[ONE] Found ${models[0].name} record with key: ${item.key ? JSON.stringify(item.key) : "unknown"}`);
+        logger_default.debug(`[ONE] Found ${models[0].name} record with key: ${item.key ? JSON.stringify(item.key) : "unknown"}`);
         return item;
       } else {
-        logger13.debug(`[ONE] No ${models[0].name} record found`);
+        logger_default.debug(`[ONE] No ${models[0].name} record found`);
         return null;
       }
     }
@@ -2172,9 +2203,8 @@ var getOneOperation = (models, definition, registry) => {
 };
 
 // src/ops/remove.ts
-import { abbrevIK, isComKey as isComKey5, isPriKey as isPriKey5, isValidItemKey as isValidItemKey2, createRemoveWrapper } from "@fjell/core";
-import { NotFoundError as NotFoundError2 } from "@fjell/core";
-var logger14 = logger_default.get("sequelize", "ops", "remove");
+import { abbrevIK, isComKey as isComKey5, isPriKey as isPriKey5, isValidItemKey as isValidItemKey2, createRemoveWrapper, NotFoundError as NotFoundError2 } from "@fjell/core";
+var libLogger3 = logger_default.get("sequelize", "ops", "remove");
 var processCompositeKey2 = (comKey, model, kta) => {
   const where = { id: comKey.pk };
   const includes = [];
@@ -2182,7 +2212,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.`;
-      logger14.error(errorMessage, { key: comKey, kta });
+      libLogger3.error(errorMessage, { key: comKey, kta });
       throw new Error(errorMessage);
     }
     if (relationshipInfo.path) {
@@ -2209,25 +2239,25 @@ var getRemoveOperation = (models, definition, _registry) => {
     async (key) => {
       try {
         if (!isValidItemKey2(key)) {
-          logger14.error("Key for Remove is not a valid ItemKey: %j", key);
+          logger_default.error("Key for Remove is not a valid ItemKey: %j", key);
           throw new Error("Key for Remove is not a valid ItemKey");
         }
         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(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
-        logger14.default(`Remove configured for ${models[0].name} with ${isPriKey5(key) ? "primary" : "composite"} key`);
+        logger_default.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
+        logger_default.default(`Remove configured for ${models[0].name} with ${isPriKey5(key) ? "primary" : "composite"} key`);
         const model = models[0];
         let item;
         let returnItem;
-        logger14.debug("remove: %s", abbrevIK(key));
+        logger_default.debug("remove: %s", abbrevIK(key));
         if (isPriKey5(key)) {
-          logger14.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
+          logger_default.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
           queryMetrics.recordQuery(model.name);
           item = await model.findByPk(key.pk);
         } else if (isComKey5(key)) {
           const comKey = key;
           const queryOptions = processCompositeKey2(comKey, model, kta);
-          logger14.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-          logger14.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+          logger_default.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
+          logger_default.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
           queryMetrics.recordQuery(model.name);
           item = await model.findOne(queryOptions);
         }
@@ -2247,14 +2277,14 @@ var getRemoveOperation = (models, definition, _registry) => {
           if (model.getAttributes().deletedAt) {
             item.deletedAt = /* @__PURE__ */ new Date();
           }
-          logger14.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
+          logger_default.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
           queryMetrics.recordQuery(model.name);
           await item?.save();
           returnItem = item?.get({ plain: true });
           returnItem = addKey(item, returnItem, kta);
           returnItem = populateEvents(returnItem);
         } else if (options.deleteOnRemove) {
-          logger14.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
+          logger_default.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
           queryMetrics.recordQuery(model.name);
           await item?.destroy();
           returnItem = item?.get({ plain: true });
@@ -2263,7 +2293,7 @@ var getRemoveOperation = (models, definition, _registry) => {
         } else {
           throw new Error("No deletedAt or isDeleted attribute found in model, and deleteOnRemove is not set");
         }
-        logger14.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
+        logger_default.debug(`[REMOVE] Removed ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${item.id}`}`);
         const { references } = options;
         if (references && references.length > 0) {
           returnItem = addRefsToSequelizeItem(returnItem, references);
@@ -2278,16 +2308,11 @@ var getRemoveOperation = (models, definition, _registry) => {
 };
 
 // src/ops/update.ts
-import {
-  abbrevIK as abbrevIK2,
-  createUpdateWrapper,
-  isComKey as isComKey6,
-  isPriKey as isPriKey6
-} from "@fjell/core";
-import { validateKeys as validateKeys5 } from "@fjell/core/validation";
+import { abbrevIK as abbrevIK2, createUpdateWrapper, isComKey as isComKey6, isPriKey as isPriKey6 } from "@fjell/core";
+import { validateKeys as validateKeys5 } from "@fjell/validation";
 import { NotFoundError as NotFoundError3 } from "@fjell/core";
 import { Op as Op3 } from "sequelize";
-var logger15 = 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) {
@@ -2319,15 +2344,15 @@ var getUpdateOperation = (models, definition, registry) => {
           );
         }
         const keyDescription = isPriKey6(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
-        logger15.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`, { options });
+        logger13.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`, { options });
         const { coordinate } = definition;
         const { kta } = coordinate;
-        logger15.debug("update: %s, %j", abbrevIK2(key), item);
+        logger13.debug("update: %s, %j", abbrevIK2(key), item);
         const model = models[0];
         let response;
         if (isPriKey6(key)) {
           const priKey = key;
-          logger15.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
+          logger13.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
           queryMetrics.recordQuery(model.name);
           response = await model.findByPk(priKey.pk);
         } else if (isComKey6(key)) {
@@ -2338,7 +2363,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.`;
-              logger15.error(errorMessage, { key: comKey, kta });
+              logger13.error(errorMessage, { key: comKey, kta });
               throw new Error(errorMessage);
             }
             if (relationshipInfo.isDirect) {
@@ -2357,8 +2382,8 @@ var getUpdateOperation = (models, definition, registry) => {
           if (additionalIncludes.length > 0) {
             queryOptions.include = mergeIncludes2([], additionalIncludes);
           }
-          logger15.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
-          logger15.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)}`);
           queryMetrics.recordQuery(model.name);
           response = await model.findOne(queryOptions);
         }
@@ -2378,14 +2403,14 @@ var getUpdateOperation = (models, definition, registry) => {
         if (aggregations && aggregations.length > 0) {
           updateProps = removeAggsFromItem(updateProps, aggregations);
         }
-        logger15.default(`Update found ${model.name} record to modify`);
-        logger15.default(`Update properties configured: ${Object.keys(updateProps).join(", ")}`);
-        logger15.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)}`);
         queryMetrics.recordQuery(model.name);
         response = await response.update(updateProps);
         const processedItem = await processRow(response, kta, references || [], aggregations || [], registry, void 0, void 0);
         const returnItem = validateKeys5(processedItem, kta);
-        logger15.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;
       } catch (error) {
         if (error instanceof NotFoundError3) throw error;
@@ -2397,7 +2422,6 @@ var getUpdateOperation = (models, definition, registry) => {
 
 // src/ops/upsert.ts
 import { createUpsertWrapper, isValidItemKey as isValidItemKey3, NotFoundError as NotFoundError4 } from "@fjell/core";
-var logger16 = logger_default.get("sequelize", "ops", "upsert");
 var getUpsertOperation = (models, definition, registry) => {
   const get = getGetOperation(models, definition, registry);
   const update = getUpdateOperation(models, definition, registry);
@@ -2406,7 +2430,7 @@ var getUpsertOperation = (models, definition, registry) => {
     definition.coordinate,
     async (key, item, locations, options) => {
       if (!isValidItemKey3(key)) {
-        logger16.error("Invalid key for upsert operation", {
+        logger_default.error("Invalid key for upsert operation", {
           operation: "upsert",
           model: models[0]?.name,
           key: stringifyJSON(key),
@@ -2417,19 +2441,19 @@ var getUpsertOperation = (models, definition, registry) => {
         });
         throw new Error(`Invalid key for upsert operation: ${stringifyJSON(key)}. Expected valid PriKey or ComKey structure.`);
       }
-      logger16.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`, { options });
+      logger_default.debug(`[UPSERT] Attempting upsert with key: ${stringifyJSON(key)}`, { options });
       let resultItem = null;
       try {
-        logger16.debug(`[UPSERT] Retrieving item by key: ${stringifyJSON(key)}`);
+        logger_default.debug(`[UPSERT] Retrieving item by key: ${stringifyJSON(key)}`);
         resultItem = await get(key);
       } catch (error) {
         const isNotFound = error instanceof NotFoundError4 || error?.name === "NotFoundError" || error?.errorInfo?.code === "NOT_FOUND";
         if (isNotFound) {
-          logger16.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}, errorType: ${error?.name}, errorCode: ${error?.errorInfo?.code}`);
+          logger_default.debug(`[UPSERT] Item not found, creating new item with key: ${stringifyJSON(key)}, errorType: ${error?.name}, errorCode: ${error?.errorInfo?.code}`);
           const createOptions3 = locations ? { locations } : { key };
           resultItem = await create(item, createOptions3);
         } else {
-          logger16.error(`[UPSERT] Unexpected error during get operation`, {
+          logger_default.error(`[UPSERT] Unexpected error during get operation`, {
             operation: "upsert",
             phase: "get-existing",
             model: models[0]?.name,
@@ -2447,9 +2471,9 @@ var getUpsertOperation = (models, definition, registry) => {
       if (!resultItem) {
         throw new Error(`Failed to retrieve or create item for key: ${stringifyJSON(key)}`);
       }
-      logger16.debug(`[UPSERT] Updating item with properties, key: ${stringifyJSON(key)}`, { options });
+      logger_default.debug(`[UPSERT] Updating item with properties, key: ${stringifyJSON(key)}`, { options });
       resultItem = await update(resultItem.key, item, options);
-      logger16.debug(`[UPSERT] Item upserted successfully: ${stringifyJSON(resultItem)}`);
+      logger_default.debug(`[UPSERT] Item upserted successfully: ${stringifyJSON(resultItem)}`);
       return resultItem;
     }
   );
@@ -2478,9 +2502,9 @@ var createOperations = (models, coordinate, registry, options) => {
 };
 
 // src/SequelizeLibrary.ts
-var logger17 = logger_default.get("SequelizeLibrary");
+var logger14 = logger_default.get("SequelizeLibrary");
 var createSequelizeLibrary = (registry, coordinate, models, options) => {
-  logger17.debug("createSequelizeLibrary", { coordinate, models, registry, options });
+  logger14.debug("createSequelizeLibrary", { coordinate, models, registry, options });
   const operations = createOperations(models, coordinate, registry, options);
   const wrappedOperations = Library3.wrapOperations(operations, options, coordinate, registry);
   const libLibrary = Library3.createLibrary(registry, coordinate, wrappedOperations, options);
@@ -2494,10 +2518,10 @@ var isSequelizeLibrary = (library) => {
 };
 
 // src/SequelizeLibraryFactory.ts
-var logger18 = logger_default.get("InstanceFactory");
+var logger15 = logger_default.get("InstanceFactory");
 var createSequelizeLibraryFactory = (models, options) => {
   return (coordinate, context) => {
-    logger18.debug("Creating Sequelize instance", {
+    logger15.debug("Creating Sequelize instance", {
       coordinate,
       registry: context.registry,
       models: models.map((m) => m.name),
@@ -2542,9 +2566,9 @@ __export(primary_exports, {
 
 // src/primary/SequelizeLibrary.ts
 import { Primary } from "@fjell/lib";
-var logger19 = logger_default.get("lib-sequelize", "primary", "library");
+var logger16 = logger_default.get("lib-sequelize", "primary", "library");
 function createSequelizeLibrary3(keyType, models, libOptions = {}, scopes = [], registry) {
-  logger19.debug("createSequelizeLibrary", { keyType, models, libOptions, scopes });
+  logger16.debug("createSequelizeLibrary", { keyType, models, libOptions, scopes });
   const coordinate = createCoordinate([keyType], scopes);
   const options = createOptions2(libOptions);
   const operations = createOperations(models, coordinate, registry, options);