@fjell/lib-sequelize 4.4.14 → 4.4.16

package/dist/index.js

@@ -0,0 +1,1488 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Options.ts
+import * as Library from "@fjell/lib";
+var DEFAULT_SEQUELIZE_OPTIONS = {
+  deleteOnRemove: false,
+  references: [],
+  aggregations: []
+};
+var createOptions2 = (sequelizeOptions) => {
+  const baseOptions = Library.createOptions(sequelizeOptions);
+  const result = {
+    ...baseOptions,
+    deleteOnRemove: sequelizeOptions?.deleteOnRemove ?? DEFAULT_SEQUELIZE_OPTIONS.deleteOnRemove,
+    references: sequelizeOptions?.references ?? DEFAULT_SEQUELIZE_OPTIONS.references,
+    aggregations: sequelizeOptions?.aggregations ?? DEFAULT_SEQUELIZE_OPTIONS.aggregations
+  };
+  return result;
+};
+
+// src/logger.ts
+import Logging from "@fjell/logging";
+var LibLogger = Logging.getLogger("@fjell/lib-sequelize");
+var logger_default = LibLogger;
+
+// src/Coordinate.ts
+import { createCoordinate as createBaseCoordinate } from "@fjell/registry";
+var logger = logger_default.get("Coordinate");
+var SCOPE_SEQUELIZE = "sequelize";
+var createCoordinate = (kta, scopes) => {
+  logger.debug("createCoordinate", { kta, scopes });
+  const coordinate = createBaseCoordinate(kta, [SCOPE_SEQUELIZE, ...scopes || []]);
+  return coordinate;
+};
+
+// src/Definition.ts
+var logger2 = logger_default.get("lib-sequelize", "Definition");
+var createDefinition = (kta, scopes, libOptions) => {
+  logger2.debug("createDefinition", { kta, scopes, libOptions });
+  const coordinate = createCoordinate(kta, scopes);
+  const options = createOptions2(libOptions);
+  return {
+    coordinate,
+    options
+  };
+};
+
+// src/SequelizeLibrary.ts
+import * as Library2 from "@fjell/lib";
+
+// src/ops/all.ts
+import { validateKeys } from "@fjell/core";
+
+// src/QueryBuilder.ts
+import {
+  isComKey,
+  isCondition,
+  isPriKey
+} from "@fjell/core";
+import { Op } from "sequelize";
+
+// src/util/general.ts
+var stringifyJSON = function(obj, visited = /* @__PURE__ */ new Set()) {
+  const arrOfKeyVals = [];
+  const arrVals = [];
+  let objKeys = [];
+  if (typeof obj === "number" || typeof obj === "boolean" || obj === null)
+    return "" + obj;
+  else if (typeof obj === "string")
+    return '"' + obj + '"';
+  if (obj instanceof Object && visited.has(obj)) {
+    return '"(circular)"';
+  } else if (Array.isArray(obj)) {
+    if (obj[0] === void 0)
+      return "[]";
+    else {
+      visited.add(obj);
+      obj.forEach(function(el) {
+        arrVals.push(stringifyJSON(el, visited));
+      });
+      return "[" + arrVals + "]";
+    }
+  } else if (obj instanceof Object) {
+    visited.add(obj);
+    objKeys = Object.keys(obj);
+    objKeys.forEach(function(key) {
+      const keyOut = '"' + key + '":';
+      const keyValOut = obj[key];
+      if (keyValOut instanceof Function || keyValOut === void 0)
+        return;
+      else if (typeof keyValOut === "string")
+        arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
+      else if (typeof keyValOut === "boolean" || typeof keyValOut === "number" || keyValOut === null)
+        arrOfKeyVals.push(keyOut + keyValOut);
+      else if (keyValOut instanceof Object) {
+        arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));
+      }
+    });
+    return "{" + arrOfKeyVals + "}";
+  }
+  return "";
+};
+
+// src/QueryBuilder.ts
+var logger3 = logger_default.get("sequelize", "QueryBuilder");
+var addDeleteQuery = (options, model) => {
+  logger3.default(`QueryBuilder adding delete query with options: ${stringifyJSON(options)}`);
+  if (model.getAttributes().deletedAt) {
+    options.where["deletedAt"] = {
+      [Op.eq]: null
+    };
+  } else if (model.getAttributes().isDeleted) {
+    options.where["isDeleted"] = {
+      [Op.eq]: false
+    };
+  }
+  return options;
+};
+var addEventQueries = (options, events, model) => {
+  logger3.default(`QueryBuilder adding event queries with options: ${stringifyJSON(options)}, events: ${stringifyJSON(events)}`);
+  Object.keys(events).forEach((key) => {
+    if (!model.getAttributes()[`${key}At`]) {
+      throw new Error(`Event ${key} is not supported on this model, column ${key}At not found`);
+    }
+    let whereClauses = {};
+    const event = events[key];
+    if (event.start) {
+      whereClauses = { ...whereClauses, [Op.gte]: new Date(event.start) };
+    }
+    if (event.end) {
+      whereClauses = { ...whereClauses, [Op.lt]: new Date(event.end) };
+    }
+    if (event.by) {
+      if (!model.getAttributes()[`${key}By`]) {
+        throw new Error(`Event ${key} is not supported on this model, column ${key}By not found`);
+      }
+      whereClauses = { ...whereClauses, [Op.eq]: event.by };
+    }
+    options.where[`${key}At`] = whereClauses;
+  });
+  return options;
+};
+var addReferenceQueries = (options, references, model) => {
+  logger3.default(`QueryBuilder adding reference queries with options: ${stringifyJSON(options)}, references: ${stringifyJSON(references)}`);
+  Object.keys(references).forEach((key) => {
+    logger3.default(`QueryBuilder adding reference query for key: ${key}, references: ${stringifyJSON(references)}`);
+    if (!model.getAttributes()[`${key}Id`]) {
+      throw new Error(`Reference ${key} is not supported on this model, column ${key}Id not found`);
+    }
+    if (isPriKey(references[key])) {
+      const priKey = references[key];
+      if (priKey.pk == null || priKey.pk === "" || typeof priKey.pk === "object" && Object.keys(priKey.pk).length === 0) {
+        logger3.error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`, { priKey, references });
+        throw new Error(`Reference key '${key}' has invalid pk value: ${stringifyJSON(priKey.pk)}`);
+      }
+      logger3.trace(`[QueryBuilder] Setting reference where clause: ${key}Id = ${stringifyJSON(priKey.pk)} (type: ${typeof priKey.pk})`);
+      options.where[`${key}Id`] = {
+        [Op.eq]: priKey.pk
+      };
+    } else if (isComKey(references[key])) {
+      throw new Error("ComKeys are not supported in Sequelize");
+    }
+  });
+  return options;
+};
+var addCompoundCondition = (options, compoundCondition, model) => {
+  options.where = options.where || {};
+  let compoundOp;
+  const compoundType = compoundCondition.compoundType;
+  if (compoundType === "AND") {
+    compoundOp = Op.and;
+  } else {
+    compoundOp = Op.or;
+  }
+  ;
+  let conditions = {};
+  compoundCondition.conditions.forEach((condition) => {
+    if (isCondition(condition)) {
+      conditions = addCondition(conditions, condition, model);
+    } else {
+      throw new Error("Nest Compound conditions not supported");
+    }
+  });
+  if (Object.keys(options.where).length > 0) {
+    options.where = {
+      [Op.and]: [
+        options.where,
+        { [compoundOp]: conditions }
+      ]
+    };
+  } else {
+    options.where[compoundOp] = conditions;
+  }
+  return options;
+};
+var getSequelizeOperator = (operator) => {
+  if (operator === "==") {
+    return Op.eq;
+  } else if (operator === "<") {
+    return Op.lt;
+  } else if (operator === ">") {
+    return Op.gt;
+  } else if (operator === "<=") {
+    return Op.lte;
+  } else if (operator === ">=") {
+    return Op.gte;
+  } else if (operator === "in") {
+    return Op.in;
+  } else {
+    throw new Error(`Operator ${operator} not supported`);
+  }
+};
+var addAssociationCondition = (conditions, condition, model) => {
+  const [associationName, attributeName] = condition.column.split(".", 2);
+  if (!model.associations || !model.associations[associationName]) {
+    throw new Error(`Association ${associationName} not found on model ${model.name}`);
+  }
+  const association = model.associations[associationName];
+  const associatedModel = association.target;
+  if (!associatedModel.getAttributes()[attributeName]) {
+    throw new Error(`Attribute ${attributeName} not found on associated model ${associatedModel.name} for association ${associationName}`);
+  }
+  const sequelizeAssociationColumn = `$${associationName}.${attributeName}$`;
+  const conditionOp = getSequelizeOperator(condition.operator);
+  if (condition.value == null && condition.operator !== "==" && condition.operator !== "in") {
+    logger3.error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`, { condition });
+    throw new Error(`Association condition for '${associationName}.${attributeName}' has undefined/null value`);
+  }
+  logger3.trace(`[QueryBuilder] Setting association condition: ${sequelizeAssociationColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
+  conditions[sequelizeAssociationColumn] = {
+    [conditionOp]: condition.value
+  };
+  return conditions;
+};
+var addAttributeCondition = (conditions, condition, model) => {
+  const conditionColumn = condition.column;
+  if (!model.getAttributes()[conditionColumn]) {
+    throw new Error(`Condition column ${conditionColumn} not found on model ${model.name}`);
+  }
+  const conditionOp = getSequelizeOperator(condition.operator);
+  if (condition.value == null && condition.operator !== "==" && condition.operator !== "in") {
+    logger3.error(`Attribute condition for '${conditionColumn}' has undefined/null value`, { condition });
+    throw new Error(`Attribute condition for '${conditionColumn}' has undefined/null value`);
+  }
+  logger3.trace(`[QueryBuilder] Setting attribute condition: ${conditionColumn} = ${stringifyJSON(condition.value)} (type: ${typeof condition.value})`);
+  conditions[conditionColumn] = {
+    [conditionOp]: condition.value
+  };
+  return conditions;
+};
+var addCondition = (conditions, condition, model) => {
+  const conditionColumn = condition.column;
+  if (conditionColumn.includes(".")) {
+    return addAssociationCondition(conditions, condition, model);
+  }
+  return addAttributeCondition(conditions, condition, model);
+};
+var collectAssociationsFromConditions = (conditions) => {
+  const associations = /* @__PURE__ */ new Set();
+  const processObject = (obj) => {
+    if (typeof obj === "object" && obj !== null) {
+      Object.keys(obj).forEach((key) => {
+        if (typeof key === "string" && key.startsWith("$") && key.endsWith("$") && key.includes(".")) {
+          const associationName = key.substring(1, key.indexOf("."));
+          associations.add(associationName);
+        }
+        if (typeof obj[key] === "object") {
+          processObject(obj[key]);
+        }
+      });
+      Object.getOwnPropertySymbols(obj).forEach((symbol) => {
+        if (typeof obj[symbol] === "object") {
+          processObject(obj[symbol]);
+        }
+      });
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach((item) => {
+        if (typeof item === "object") {
+          processObject(item);
+        }
+      });
+    }
+  };
+  processObject(conditions);
+  return associations;
+};
+var addAssociationIncludes = (options, model) => {
+  const referencedAssociations = collectAssociationsFromConditions(options.where);
+  if (referencedAssociations.size > 0) {
+    options.include = options.include || [];
+    referencedAssociations.forEach((associationName) => {
+      const alreadyIncluded = options.include.some(
+        (inc) => typeof inc === "string" && inc === associationName || typeof inc === "object" && inc.association === associationName
+      );
+      if (!alreadyIncluded && model.associations && model.associations[associationName]) {
+        options.include.push({
+          model: model.associations[associationName].target,
+          as: associationName,
+          required: false
+          // Use LEFT JOIN so records without associations are still returned
+        });
+      }
+    });
+  }
+  return options;
+};
+var buildQuery = (itemQuery, model) => {
+  logger3.default(`QueryBuilder build called with itemQuery: ${stringifyJSON(itemQuery)}`);
+  let options = {
+    where: {}
+  };
+  if (itemQuery.compoundCondition) {
+    logger3.default(`QueryBuilder adding conditions: ${stringifyJSON(itemQuery.compoundCondition)}`);
+    options = addCompoundCondition(options, itemQuery.compoundCondition, model);
+  }
+  if (model.getAttributes().deletedAt || model.getAttributes().isDeleted) {
+    options = addDeleteQuery(options, model);
+  }
+  if (itemQuery.refs) {
+    options = addReferenceQueries(options, itemQuery.refs, model);
+  }
+  if (itemQuery.events) {
+    options = addEventQueries(options, itemQuery.events, model);
+  }
+  if (itemQuery.limit) {
+    logger3.default(`QueryBuilder applying limit: ${itemQuery.limit}`);
+    options.limit = itemQuery.limit;
+  }
+  if (itemQuery.offset) {
+    options.offset = itemQuery.offset;
+  }
+  if (itemQuery.orderBy) {
+    itemQuery.orderBy.forEach((orderBy) => {
+      if (!model.getAttributes()[orderBy.field]) {
+        throw new Error(`Order by field ${orderBy.field} not found on model ${model.name}`);
+      }
+      options.order = [
+        [orderBy.field, orderBy.direction]
+      ];
+    });
+  }
+  options = addAssociationIncludes(options, model);
+  return options;
+};
+
+// src/util/relationshipUtils.ts
+var buildRelationshipChain = (targetModel, kta, currentIndex, targetIndex) => {
+  const associationParts = [];
+  const modelChain = [targetModel];
+  let currentModel = targetModel;
+  for (let i = currentIndex + 1; i <= targetIndex; i++) {
+    const intermediateType = kta[i];
+    const associationName = intermediateType;
+    if (!currentModel.associations || !currentModel.associations[associationName]) {
+      return { success: false };
+    }
+    associationParts.push(associationName);
+    currentModel = currentModel.associations[associationName].target;
+    modelChain.push(currentModel);
+  }
+  const targetPrimaryKey = currentModel.primaryKeyAttribute || "id";
+  const associationPath = `$${associationParts.join(".")}.${targetPrimaryKey}$`;
+  let deepestInclude = null;
+  for (let i = targetIndex; i > currentIndex; i--) {
+    const currentType = kta[i];
+    const modelIndex = i - currentIndex;
+    const includeObj = {
+      model: modelChain[modelIndex],
+      as: currentType,
+      required: true
+    };
+    if (deepestInclude) {
+      includeObj.include = [deepestInclude];
+    }
+    deepestInclude = includeObj;
+  }
+  const includes = deepestInclude ? [deepestInclude] : [];
+  return { success: true, path: associationPath, includes };
+};
+var buildRelationshipPath = (targetModel, locatorType, kta, includeIsDirect = false) => {
+  const directFieldName = `${locatorType}Id`;
+  const attributes = targetModel.getAttributes();
+  if (attributes && attributes[directFieldName]) {
+    const result2 = { found: true };
+    if (includeIsDirect) {
+      result2.isDirect = true;
+    }
+    return result2;
+  }
+  const targetIndex = kta.indexOf(locatorType);
+  if (targetIndex === -1) {
+    const result2 = { found: false };
+    if (includeIsDirect) {
+      result2.isDirect = false;
+    }
+    return result2;
+  }
+  const currentIndex = 0;
+  if (targetIndex <= currentIndex) {
+    const result2 = { found: false };
+    if (includeIsDirect) {
+      result2.isDirect = false;
+    }
+    return result2;
+  }
+  const chainResult = buildRelationshipChain(targetModel, kta, currentIndex, targetIndex);
+  if (chainResult.success) {
+    const result2 = {
+      found: true,
+      path: chainResult.path,
+      includes: chainResult.includes
+    };
+    if (includeIsDirect) {
+      result2.isDirect = false;
+    }
+    return result2;
+  }
+  const result = { found: false };
+  if (includeIsDirect) {
+    result.isDirect = false;
+  }
+  return result;
+};
+
+// src/KeyMaster.ts
+var logger4 = logger_default.get("sequelize", "KeyMaster");
+var extractLocationKeyValue = (model, item, 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.`);
+  }
+  if (relationshipInfo.isDirect) {
+    const foreignKeyField = `${locatorType}Id`;
+    const value = item[foreignKeyField];
+    if (typeof value === "undefined" || value === null) {
+      throw new Error(`Direct foreign key field '${foreignKeyField}' is missing or null in item`);
+    }
+    return value;
+  } else {
+    const locatorIndex = kta.indexOf(locatorType);
+    if (locatorIndex === -1) {
+      throw new Error(`Locator type '${locatorType}' not found in key type array`);
+    }
+    let currentObject = item;
+    for (let i = 1; i < locatorIndex; i++) {
+      const intermediateType = kta[i];
+      if (currentObject[intermediateType] && typeof currentObject[intermediateType] === "object") {
+        currentObject = currentObject[intermediateType];
+      } else {
+        const foreignKeyField2 = `${intermediateType}Id`;
+        if (typeof currentObject[foreignKeyField2] !== "undefined" && currentObject[foreignKeyField2] !== null) {
+          throw new Error(`Intermediate relationship '${intermediateType}' is not loaded. Cannot traverse to '${locatorType}'. Either include the relationship in your query or ensure it's loaded.`);
+        }
+        throw new Error(`Intermediate relationship '${intermediateType}' is missing in the relationship chain. Expected path: ${kta.slice(0, locatorIndex + 1).join(" \u2192 ")}`);
+      }
+    }
+    if (currentObject[locatorType] && typeof currentObject[locatorType] === "object" && typeof currentObject[locatorType].id !== "undefined") {
+      return currentObject[locatorType].id;
+    }
+    const foreignKeyField = `${locatorType}Id`;
+    if (typeof currentObject[foreignKeyField] !== "undefined" && currentObject[foreignKeyField] !== null) {
+      return currentObject[foreignKeyField];
+    }
+    const traversalPath = kta.slice(0, locatorIndex + 1).join(" \u2192 ");
+    throw new Error(
+      `Unable to extract location key for '${locatorType}'. Neither the relationship object nor direct foreign key is available. Traversal path: ${traversalPath}`
+    );
+  }
+};
+var removeKey = (item) => {
+  logger4.default("Removing Key", { item });
+  delete item.key;
+  return item;
+};
+var addKey = (model, item, keyTypes) => {
+  logger4.default("Adding Key", { item });
+  const key = {};
+  const modelClass = model.constructor;
+  const primaryKeyAttr = modelClass.primaryKeyAttribute;
+  if (Array.isArray(keyTypes) && keyTypes.length > 1) {
+    const type = [...keyTypes];
+    const pkType = type.shift();
+    Object.assign(key, { kt: pkType, pk: item[primaryKeyAttr] });
+    const locationKeys = [];
+    for (const locatorType of type) {
+      try {
+        const lk = extractLocationKeyValue(modelClass, item, locatorType, keyTypes);
+        locationKeys.push({ kt: locatorType, lk });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger4.error(`Failed to extract location key for '${locatorType}'`, { error: errorMessage, item, keyTypes });
+        throw error;
+      }
+    }
+    Object.assign(key, { loc: locationKeys });
+  } else {
+    Object.assign(key, { kt: keyTypes[0], pk: item[primaryKeyAttr] });
+  }
+  Object.assign(item, { key });
+  return item;
+};
+
+// src/ReferenceBuilder.ts
+var logger5 = logger_default.get("sequelize", "ReferenceBuilder");
+var buildReference = async (item, referenceDefinition, registry, context) => {
+  if (referenceDefinition.kta.length > 1) {
+    throw new Error("The ReferenceBuilder doesn't work with more than one key type yet");
+  }
+  if (!registry) {
+    throw new Error("This model definition has a reference definition, but the registry is not present");
+  }
+  const library = registry.get(referenceDefinition.kta);
+  if (!library) {
+    throw new Error("This model definition has a reference definition, but the dependency is not present");
+  }
+  const columnValue = item[referenceDefinition.column];
+  if (columnValue == null) {
+    item[referenceDefinition.property] = null;
+    return item;
+  }
+  const priKey = {
+    kt: referenceDefinition.kta[0],
+    pk: columnValue
+  };
+  let referencedItem;
+  if (context) {
+    if (context.isCached(priKey)) {
+      logger5.default("Using cached reference", { priKey, property: referenceDefinition.property });
+      referencedItem = context.getCached(priKey);
+    } else if (context.isInProgress(priKey)) {
+      logger5.default("Circular dependency detected, creating reference placeholder", {
+        priKey,
+        property: referenceDefinition.property
+      });
+      referencedItem = {
+        key: priKey
+        // Add any other minimal properties that might be needed
+        // This prevents infinite loops while still providing the key for identification
+      };
+    } else {
+      context.markInProgress(priKey);
+      try {
+        referencedItem = await library.operations.get(priKey);
+        context.setCached(priKey, referencedItem);
+      } finally {
+        context.markComplete(priKey);
+      }
+    }
+  } else {
+    referencedItem = await library.operations.get(priKey);
+  }
+  item[referenceDefinition.property] = referencedItem;
+  return item;
+};
+
+// src/AggregationBuilder.ts
+import { ikToLKA } from "@fjell/core";
+
+// src/OperationContext.ts
+var logger6 = logger_default.get("sequelize", "OperationContext");
+var serializeKey = (key) => {
+  if ("pk" in key && "kt" in key && !("loc" in key)) {
+    return `${key.kt}:${key.pk}`;
+  } else if ("pk" in key && "kt" in key && "loc" in key) {
+    const locStr = key.loc.map((l) => `${l.kt}:${l.lk}`).join(",");
+    return `${key.kt}:${key.pk}|${locStr}`;
+  }
+  throw new Error(`Unsupported key type: ${JSON.stringify(key)}`);
+};
+var createOperationContext = () => {
+  const inProgress = /* @__PURE__ */ new Set();
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    inProgress,
+    cache,
+    markInProgress(key) {
+      const serialized = serializeKey(key);
+      logger6.default("Marking key as in progress", { key, serialized });
+      inProgress.add(serialized);
+    },
+    markComplete(key) {
+      const serialized = serializeKey(key);
+      logger6.default("Marking key as complete", { key, serialized });
+      inProgress.delete(serialized);
+    },
+    isInProgress(key) {
+      const serialized = serializeKey(key);
+      const result = inProgress.has(serialized);
+      logger6.default("Checking if key is in progress", { key, serialized, result });
+      return result;
+    },
+    getCached(key) {
+      const serialized = serializeKey(key);
+      const result = cache.get(serialized);
+      logger6.default("Getting cached item", { key, serialized, found: !!result });
+      return result;
+    },
+    setCached(key, item) {
+      const serialized = serializeKey(key);
+      logger6.default("Caching item", { key, serialized });
+      cache.set(serialized, item);
+    },
+    isCached(key) {
+      const serialized = serializeKey(key);
+      const result = cache.has(serialized);
+      logger6.default("Checking if key is cached", { key, serialized, result });
+      return result;
+    }
+  };
+};
+var ContextManager = class {
+  contexts = /* @__PURE__ */ new Map();
+  currentContextId = null;
+  /**
+   * Set the current context for the current operation chain
+   */
+  setCurrentContext(context) {
+    const contextId = Math.random().toString(36).substring(7);
+    this.contexts.set(contextId, context);
+    this.currentContextId = contextId;
+    logger6.default("Set current context", { contextId });
+    return contextId;
+  }
+  /**
+   * Get the current context if one is set
+   */
+  getCurrentContext() {
+    if (this.currentContextId) {
+      const context = this.contexts.get(this.currentContextId);
+      logger6.default("Got current context", { contextId: this.currentContextId, found: !!context });
+      return context;
+    }
+    return;
+  }
+  /**
+   * Clear the current context
+   */
+  clearCurrentContext() {
+    if (this.currentContextId) {
+      logger6.default("Clearing current context", { contextId: this.currentContextId });
+      this.contexts.delete(this.currentContextId);
+      this.currentContextId = null;
+    }
+  }
+  /**
+   * Execute a function with a specific context set as current
+   */
+  async withContext(context, fn) {
+    const previousContextId = this.currentContextId;
+    this.setCurrentContext(context);
+    try {
+      return await fn();
+    } finally {
+      this.clearCurrentContext();
+      if (previousContextId) {
+        this.currentContextId = previousContextId;
+      }
+    }
+  }
+};
+var contextManager = new ContextManager();
+
+// src/AggregationBuilder.ts
+var logger7 = logger_default.get("sequelize", "AggregationBuilder");
+var buildAggregation = async (item, aggregationDefinition, registry, context) => {
+  const location = ikToLKA(item.key);
+  const libraryInstance = registry.get(aggregationDefinition.kta);
+  if (!libraryInstance) {
+    throw new Error(`Library instance not found for key type array: ${aggregationDefinition.kta.join(", ")}`);
+  }
+  const aggregationCacheKey = `${aggregationDefinition.kta.join(".")}_${aggregationDefinition.cardinality}_${serializeKey(item.key)}`;
+  if (context) {
+    if (context.cache.has(aggregationCacheKey)) {
+      const cachedResult = context.cache.get(aggregationCacheKey);
+      logger7.default("Using cached aggregation result", {
+        aggregationCacheKey,
+        property: aggregationDefinition.property
+      });
+      item[aggregationDefinition.property] = cachedResult;
+      return item;
+    }
+  }
+  return contextManager.withContext(context || contextManager.getCurrentContext() || { inProgress: /* @__PURE__ */ new Set(), cache: /* @__PURE__ */ new Map() }, async () => {
+    if (aggregationDefinition.cardinality === "one") {
+      return libraryInstance.operations.one({}, location).then((result) => {
+        if (context) {
+          context.cache.set(aggregationCacheKey, result);
+        }
+        item[aggregationDefinition.property] = result;
+        return item;
+      });
+    } else {
+      return libraryInstance.operations.all({}, location).then((results) => {
+        if (context) {
+          context.cache.set(aggregationCacheKey, results);
+        }
+        item[aggregationDefinition.property] = results;
+        return item;
+      });
+    }
+  });
+};
+
+// src/EventCoordinator.ts
+import deepmerge from "deepmerge";
+var logger8 = logger_default.get("sequelize", "EventCoordinator");
+var populateEvents = (item) => {
+  const events = {
+    created: { at: item.createdAt || null },
+    updated: { at: item.updatedAt || null },
+    deleted: { at: null }
+  };
+  item.events = events;
+  return item;
+};
+var extractEvents = (item) => {
+  logger8.default("Extracting Events to database fields", { item });
+  if (item.events) {
+    if (item.events.created?.at) {
+      item.createdAt = item.events.created.at;
+    }
+    if (item.events.updated?.at) {
+      item.updatedAt = item.events.updated.at;
+    }
+    if (item.events.deleted?.at) {
+      item.deletedAt = item.events.deleted.at;
+    }
+  }
+  return item;
+};
+var removeEvents = (item) => {
+  logger8.default("Removing Events", { item });
+  delete item.events;
+  return item;
+};
+
+// src/RowProcessor.ts
+var logger9 = logger_default.get("sequelize", "RowProcessor");
+var processRow = async (row, keyTypes, referenceDefinitions, aggregationDefinitions, registry, context) => {
+  logger9.default("Processing Row", { row });
+  const operationContext = context || createOperationContext();
+  return contextManager.withContext(operationContext, async () => {
+    let item = row.get({ plain: true });
+    logger9.default("Adding Key to Item with Key Types: %s", stringifyJSON(keyTypes));
+    item = addKey(row, item, keyTypes);
+    item = populateEvents(item);
+    logger9.default("Key Added to Item: %s", stringifyJSON(item.key));
+    operationContext.markInProgress(item.key);
+    try {
+      if (referenceDefinitions && referenceDefinitions.length > 0) {
+        for (const referenceDefinition of referenceDefinitions) {
+          logger9.default("Processing Reference for %s to %s", item.key.kt, stringifyJSON(referenceDefinition.kta));
+          item = await buildReference(item, referenceDefinition, registry, operationContext);
+        }
+      }
+      if (aggregationDefinitions && aggregationDefinitions.length > 0) {
+        for (const aggregationDefinition of aggregationDefinitions) {
+          logger9.default("Processing Aggregation for %s from %s", item.key.kt, stringifyJSON(aggregationDefinition.kta));
+          item = await buildAggregation(item, aggregationDefinition, registry, operationContext);
+        }
+      }
+      operationContext.setCached(item.key, item);
+    } finally {
+      operationContext.markComplete(item.key);
+    }
+    logger9.default("Processed Row: %j", stringifyJSON(item));
+    return item;
+  });
+};
+
+// src/ops/all.ts
+import { Op as Op2 } from "sequelize";
+var logger10 = logger_default.get("sequelize", "ops", "all");
+var mergeIncludes = (existingIncludes, newIncludes) => {
+  const mergedIncludes = [...existingIncludes];
+  for (const newInclude of newIncludes) {
+    const existingIndex = mergedIncludes.findIndex(
+      (existing) => existing.as === newInclude.as && existing.model === newInclude.model
+    );
+    if (existingIndex === -1) {
+      mergedIncludes.push(newInclude);
+    } else if (newInclude.include && mergedIncludes[existingIndex].include) {
+      mergedIncludes[existingIndex].include = [
+        ...mergedIncludes[existingIndex].include,
+        ...newInclude.include
+      ];
+    } else if (newInclude.include) {
+      mergedIncludes[existingIndex].include = newInclude.include;
+    }
+  }
+  return mergedIncludes;
+};
+var getAllOperation = (models, definition, registry) => {
+  const { coordinate, options: { references, aggregations } } = definition;
+  const all = async (itemQuery, locations) => {
+    logger10.debug(`ALL operation called on ${models[0].name} with ${locations?.length || 0} location filters: ${locations?.map((loc2) => `${loc2.kt}=${loc2.lk}`).join(", ") || "none"}`);
+    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.`;
+          logger10.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) {
+          logger10.error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
+          throw new Error(`Location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
+        }
+        const foreignKeyField = locKey.kt + "Id";
+        if (options.where[foreignKeyField]) {
+          logger10.debug(`[ALL] Field ${foreignKeyField} already constrained by itemQuery, skipping location constraint to avoid conflicts`);
+          continue;
+        }
+        logger10.trace(`[ALL] Setting direct location where clause: ${foreignKeyField} = ${stringifyJSON(locKey.lk)} (type: ${typeof locKey.lk})`);
+        options.where[foreignKeyField] = {
+          [Op2.eq]: locKey.lk
+        };
+      }
+      for (const locKey of hierarchicalLocations) {
+        if (locKey.lk === void 0 || locKey.lk == null || locKey.lk === "" || typeof locKey.lk === "object" && Object.keys(locKey.lk).length === 0) {
+          logger10.error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`, { locKey, locations: loc });
+          throw new Error(`Hierarchical location key '${locKey.kt}' has invalid lk value: ${stringifyJSON(locKey.lk)}`);
+        }
+        const relationshipInfo = buildRelationshipPath(model, locKey.kt, kta);
+        if (relationshipInfo.found && relationshipInfo.path) {
+          if (options.where[relationshipInfo.path]) {
+            logger10.debug(`[ALL] Field ${relationshipInfo.path} already constrained by itemQuery, skipping hierarchical location constraint to avoid conflicts`);
+            continue;
+          }
+          logger10.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);
+      }
+    }
+    logger10.default(`All query configured for ${model.name} with where fields: ${options.where ? Object.keys(options.where).join(", ") : "none"}, includes: ${options.include?.length || 0}`);
+    try {
+      logger10.trace(`[ALL] Executing ${model.name}.findAll() with options: ${JSON.stringify(options, null, 2)}`);
+    } catch {
+      logger10.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 context = contextManager.getCurrentContext();
+    const results = await Promise.all(matchingItems.map(async (row) => {
+      const processedRow = await processRow(row, coordinate.kta, references, aggregations, registry, context);
+      return validateKeys(processedRow, coordinate.kta);
+    }));
+    logger10.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 logger11 = logger_default.get("sequelize", "ops", "create");
+function translateDatabaseError(error, itemData, modelName) {
+  const originalMessage = error.message || "";
+  const errorCode = error.original?.code;
+  const constraint = error.original?.constraint;
+  const detail = error.original?.detail;
+  logger11.error("Database error during create operation", {
+    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:
+      return new Error(`Database error in ${modelName}.create(): ${originalMessage}. Item data: ${JSON.stringify(itemData, null, 2)}`);
+  }
+}
+async function validateHierarchicalChain(models, locKey, kta) {
+  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);
+      if (!record2) {
+        throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist`);
+      }
+      return;
+    }
+    const queryOptions = {
+      where: { id: locKey.lk }
+    };
+    if (chainResult.includes && chainResult.includes.length > 0) {
+      queryOptions.include = chainResult.includes;
+    }
+    const record = await locatorModel.findOne(queryOptions);
+    if (!record) {
+      throw new Error(`Referenced ${locKey.kt} with id ${locKey.lk} does not exist or chain is invalid`);
+    }
+  } catch (error) {
+    if (error.original) {
+      throw translateDatabaseError(error, { locKey, kta }, locKey.kt);
+    }
+    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";
+    logger11.debug(`CREATE operation called on ${models[0].name} with ${constraints}`);
+    logger11.default(`Create configured for ${models[0].name} with ${Object.keys(item).length} item fields`);
+    const { coordinate, options: { references, aggregations } } = definition;
+    const { kta } = coordinate;
+    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;
+        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)}`;
+            logger11.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 === "") {
+            logger11.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 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)}`;
+          logger11.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 === "") {
+          logger11.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 {
+      logger11.trace(`[CREATE] Executing ${model.name}.create() with data: ${stringifyJSON(itemData)}`);
+      const createdRecord = await model.create(itemData);
+      const processedRecord = await processRow(createdRecord, kta, references, aggregations, registry);
+      const result = validateKeys2(processedRecord, kta);
+      logger11.debug(`[CREATE] Created ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${createdRecord.id}`}`);
+      return result;
+    } catch (error) {
+      throw translateDatabaseError(error, itemData, model.name);
+    }
+  };
+  return create;
+};
+
+// src/ops/find.ts
+import { validateKeys as validateKeys3 } from "@fjell/core";
+var logger12 = logger_default.get("sequelize", "ops", "find");
+var getFindOperation = (models, definition, registry) => {
+  const { options: { finders, references, aggregations } } = definition;
+  const find = async (finder, finderParams, locations) => {
+    const locationFilters = locations?.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none";
+    logger12.debug(
+      `FIND operation called on ${models[0].name} with finder '${finder}' and ${locations?.length || 0} location filters: ${locationFilters}`
+    );
+    logger12.default(`Find configured for ${models[0].name} using finder '${finder}' with ${Object.keys(finderParams).length} params`);
+    if (finders && finders[finder]) {
+      const finderMethod = finders[finder];
+      if (finderMethod) {
+        logger12.trace(`[FIND] Executing finder '${finder}' on ${models[0].name} with params: ${stringifyJSON(finderParams)}, locations: ${stringifyJSON(locations)}`);
+        const results = await finderMethod(finderParams, locations);
+        if (results && results.length > 0) {
+          const processedResults = await Promise.all(results.map(async (row) => {
+            const processedRow = await processRow(row, definition.coordinate.kta, references, aggregations, registry);
+            return validateKeys3(processedRow, definition.coordinate.kta);
+          }));
+          logger12.debug(`[FIND] Found ${processedResults.length} ${models[0].name} records using finder '${finder}'`);
+          return processedResults;
+        } else {
+          logger12.debug(`[FIND] Found 0 ${models[0].name} records using finder '${finder}'`);
+          return [];
+        }
+      } else {
+        logger12.error(`Finder %s not found`, finder);
+        throw new Error(`Finder ${finder} not found`);
+      }
+    } else {
+      logger12.error(`No finders have been defined for this lib`);
+      throw new Error(`No finders found`);
+    }
+  };
+  return find;
+};
+
+// src/ops/get.ts
+import {
+  isComKey as isComKey3,
+  isPriKey as isPriKey3,
+  isValidItemKey,
+  validateKeys as validateKeys4
+} from "@fjell/core";
+import { NotFoundError } from "@fjell/lib";
+var logger13 = logger_default.get("sequelize", "ops", "get");
+var processCompositeKey = (comKey, model, kta) => {
+  const where = { id: comKey.pk };
+  const includes = [];
+  for (const locator of comKey.loc) {
+    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 });
+      throw new Error(errorMessage);
+    }
+    if (relationshipInfo.path) {
+      where[relationshipInfo.path] = locator.lk;
+      if (relationshipInfo.includes) {
+        includes.push(...relationshipInfo.includes);
+      }
+    } else {
+      const fieldName = `${locator.kt}Id`;
+      where[fieldName] = locator.lk;
+    }
+  }
+  const result = { where };
+  if (includes.length > 0) {
+    result.include = includes;
+  }
+  return result;
+};
+var getGetOperation = (models, definition, registry) => {
+  const { coordinate, options: { references, aggregations } } = definition;
+  const { kta } = coordinate;
+  const get = async (key) => {
+    if (!isValidItemKey(key)) {
+      logger13.error("Key for Get is not a valid ItemKey: %j", key);
+      throw new Error("Key for Get is not a valid ItemKey");
+    }
+    const keyDescription = isPriKey3(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
+    logger13.debug(`GET operation called on ${models[0].name} with ${keyDescription}`);
+    logger13.default(`Get configured for ${models[0].name} with ${isPriKey3(key) ? "primary" : "composite"} key`);
+    const itemKey = key;
+    const model = models[0];
+    let item;
+    if (isPriKey3(itemKey)) {
+      logger13.trace(`[GET] Executing ${model.name}.findByPk() with pk: ${itemKey.pk}`);
+      item = await model.findByPk(itemKey.pk);
+    } else if (isComKey3(itemKey)) {
+      const comKey = itemKey;
+      const queryOptions = processCompositeKey(comKey, model, kta);
+      logger13.default("Composite key query", { queryOptions });
+      logger13.trace(`[GET] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+      item = await model.findOne(queryOptions);
+    }
+    if (!item) {
+      throw new NotFoundError("get", coordinate, key);
+    } else {
+      const context = contextManager.getCurrentContext();
+      const result = validateKeys4(await processRow(item, kta, references, aggregations, registry, context), kta);
+      logger13.debug(`[GET] Retrieved ${model.name} with key: ${result.key ? JSON.stringify(result.key) : `id=${item.id}`}`);
+      return result;
+    }
+  };
+  return get;
+};
+
+// src/ops/one.ts
+var logger14 = logger_default.get("sequelize", "ops", "one");
+var getOneOperation = (models, definition, registry) => {
+  const one = async (itemQuery, locations = []) => {
+    logger14.debug(`ONE operation called on ${models[0].name} with ${locations.length} location filters: ${locations.map((loc) => `${loc.kt}=${loc.lk}`).join(", ") || "none"}`);
+    logger14.default(`One configured for ${models[0].name} delegating to all operation`);
+    const items = await getAllOperation(models, definition, registry)(itemQuery, locations);
+    if (items.length > 0) {
+      const result = items[0];
+      logger14.debug(`[ONE] Found ${models[0].name} record with key: ${result.key ? JSON.stringify(result.key) : "unknown"}`);
+      return result;
+    } else {
+      logger14.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";
+var logger15 = logger_default.get("sequelize", "ops", "remove");
+var processCompositeKey2 = (comKey, model, kta) => {
+  const where = { id: comKey.pk };
+  const includes = [];
+  for (const locator of comKey.loc) {
+    const relationshipInfo = buildRelationshipPath(model, locator.kt, kta);
+    if (!relationshipInfo.found) {
+      const errorMessage = `Composite key locator '${locator.kt}' cannot be resolved on model '${model.name}' or through its relationships.`;
+      logger15.error(errorMessage, { key: comKey, kta });
+      throw new Error(errorMessage);
+    }
+    if (relationshipInfo.path) {
+      where[relationshipInfo.path] = locator.lk;
+      if (relationshipInfo.includes) {
+        includes.push(...relationshipInfo.includes);
+      }
+    } else {
+      const fieldName = `${locator.kt}Id`;
+      where[fieldName] = locator.lk;
+    }
+  }
+  const result = { where };
+  if (includes.length > 0) {
+    result.include = includes;
+  }
+  return result;
+};
+var getRemoveOperation = (models, definition, registry) => {
+  const { coordinate, options } = definition;
+  const { kta } = coordinate;
+  const remove = async (key) => {
+    if (!isValidItemKey2(key)) {
+      logger15.error("Key for Remove is not a valid ItemKey: %j", key);
+      throw new Error("Key for Remove is not a valid ItemKey");
+    }
+    const keyDescription = isPriKey4(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
+    logger15.debug(`REMOVE operation called on ${models[0].name} with ${keyDescription}`);
+    logger15.default(`Remove configured for ${models[0].name} with ${isPriKey4(key) ? "primary" : "composite"} key`);
+    const model = models[0];
+    let item;
+    let returnItem;
+    logger15.debug("remove: %s", abbrevIK(key));
+    if (isPriKey4(key)) {
+      logger15.debug(`[REMOVE] Executing ${model.name}.findByPk() with pk: ${key.pk}`);
+      item = await model.findByPk(key.pk);
+    } else if (isComKey4(key)) {
+      const comKey = key;
+      const queryOptions = processCompositeKey2(comKey, model, kta);
+      logger15.default(`Remove composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
+      logger15.debug(`[REMOVE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+      item = await model.findOne(queryOptions);
+    }
+    if (!item) {
+      throw new Error(`Item not found for removal with key: ${abbrevIK(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();
+      }
+      logger15.debug(`[REMOVE] Executing ${model.name}.save() for soft delete`);
+      await item?.save();
+      returnItem = item?.get({ plain: true });
+      returnItem = addKey(item, returnItem, kta);
+      returnItem = populateEvents(returnItem);
+    } else if (options.deleteOnRemove) {
+      logger15.debug(`[REMOVE] Executing ${model.name}.destroy() for hard delete`);
+      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");
+    }
+    logger15.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 NotFoundError2 } from "@fjell/lib";
+import { Op as Op3 } from "sequelize";
+var logger16 = logger_default.get("sequelize", "ops", "update");
+var mergeIncludes2 = (existingIncludes, newIncludes) => {
+  const mergedIncludes = [...existingIncludes];
+  for (const newInclude of newIncludes) {
+    const existingIndex = mergedIncludes.findIndex(
+      (existing) => existing.as === newInclude.as && existing.model === newInclude.model
+    );
+    if (existingIndex === -1) {
+      mergedIncludes.push(newInclude);
+    } else if (newInclude.include && mergedIncludes[existingIndex].include) {
+      mergedIncludes[existingIndex].include = [
+        ...mergedIncludes[existingIndex].include,
+        ...newInclude.include
+      ];
+    } else if (newInclude.include) {
+      mergedIncludes[existingIndex].include = newInclude.include;
+    }
+  }
+  return mergedIncludes;
+};
+var getUpdateOperation = (models, definition, registry) => {
+  const { options: { references, aggregations } } = definition;
+  const update = async (key, item) => {
+    const keyDescription = isPriKey5(key) ? `primary key: pk=${key.pk}` : `composite key: pk=${key.pk}, loc=[${key.loc.map((l) => `${l.kt}=${l.lk}`).join(", ")}]`;
+    logger16.debug(`UPDATE operation called on ${models[0].name} with ${keyDescription}`);
+    const { coordinate } = definition;
+    const { kta } = coordinate;
+    logger16.debug("update: %s, %j", abbrevIK2(key), item);
+    const model = models[0];
+    let response;
+    if (isPriKey5(key)) {
+      const priKey = key;
+      logger16.trace(`[UPDATE] Executing ${model.name}.findByPk() with pk: ${priKey.pk}`);
+      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.`;
+          logger16.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);
+      }
+      logger16.default(`Update composite key query for ${model.name} with where fields: ${queryOptions.where ? Object.keys(queryOptions.where).join(", ") : "none"}`);
+      logger16.trace(`[UPDATE] Executing ${model.name}.findOne() with options: ${stringifyJSON(queryOptions)}`);
+      response = await model.findOne(queryOptions);
+    }
+    if (response) {
+      let updateProps = removeKey(item);
+      updateProps = extractEvents(updateProps);
+      updateProps = removeEvents(updateProps);
+      logger16.default(`Update found ${model.name} record to modify`);
+      logger16.default(`Update properties configured: ${Object.keys(updateProps).join(", ")}`);
+      logger16.trace(`[UPDATE] Executing ${model.name}.update() with properties: ${stringifyJSON(updateProps)}`);
+      response = await response.update(updateProps);
+      const processedItem = await processRow(response, kta, references, aggregations, registry);
+      const returnItem = validateKeys5(processedItem, kta);
+      logger16.debug(`[UPDATE] Updated ${model.name} with key: ${returnItem.key ? JSON.stringify(returnItem.key) : `id=${response.id}`}`);
+      return returnItem;
+    } else {
+      throw new NotFoundError2("update", coordinate, key);
+    }
+  };
+  return update;
+};
+
+// 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 = async () => {
+    throw new Error("Not implemented");
+  };
+  return operations;
+};
+
+// src/SequelizeLibrary.ts
+var logger17 = logger_default.get("SequelizeLibrary");
+var createSequelizeLibrary = (registry, coordinate, models, options) => {
+  logger17.debug("createSequelizeLibrary", { coordinate, models, registry, options });
+  const operations = createOperations(models, coordinate, registry, options);
+  const libLibrary = Library2.createLibrary(registry, coordinate, operations, options);
+  return {
+    ...libLibrary,
+    models
+  };
+};
+var isSequelizeLibrary = (library) => {
+  return library != null && library.coordinate != null && library.operations != null && library.options != null && library.registry != null && library.models != null && Array.isArray(library.models);
+};
+
+// src/SequelizeLibraryFactory.ts
+var logger18 = logger_default.get("InstanceFactory");
+var createSequelizeLibraryFactory = (models, options) => {
+  return (coordinate, context) => {
+    logger18.debug("Creating Sequelize instance", {
+      coordinate,
+      registry: context.registry,
+      models: models.map((m) => m.name),
+      options
+    });
+    return createSequelizeLibrary(
+      context.registry,
+      coordinate,
+      models,
+      options
+    );
+  };
+};
+
+// src/contained/index.ts
+var contained_exports = {};
+__export(contained_exports, {
+  createInstance: () => createInstance,
+  createSequelizeLibrary: () => createSequelizeLibrary2
+});
+
+// src/contained/SequelizeLibrary.ts
+import { Contained } from "@fjell/lib";
+function createSequelizeLibrary2(keyTypes, models, libOptions = {}, scopes = [], registry) {
+  const coordinate = createCoordinate(keyTypes, scopes);
+  const options = createOptions2(libOptions);
+  const operations = createOperations(models, coordinate, registry, options);
+  const wrappedOperations = Contained.wrapOperations(operations, options, coordinate, registry);
+  return {
+    coordinate,
+    registry,
+    operations: wrappedOperations,
+    options,
+    models
+  };
+}
+var createInstance = createSequelizeLibrary2;
+
+// src/primary/index.ts
+var primary_exports = {};
+__export(primary_exports, {
+  createInstance: () => createInstance2,
+  createSequelizeLibrary: () => createSequelizeLibrary3
+});
+
+// src/primary/SequelizeLibrary.ts
+import { Primary } from "@fjell/lib";
+var logger19 = logger_default.get("lib-sequelize", "primary", "instance");
+function createSequelizeLibrary3(keyType, models, libOptions = {}, scopes = [], registry) {
+  logger19.debug("createSequelizeLibrary", { keyType, models, libOptions, scopes });
+  const coordinate = createCoordinate([keyType], scopes);
+  const options = createOptions2(libOptions);
+  const operations = createOperations(models, coordinate, registry, options);
+  const wrappedOperations = Primary.wrapOperations(operations, options, coordinate, registry);
+  return {
+    coordinate,
+    registry,
+    operations: wrappedOperations,
+    options,
+    models
+  };
+}
+var createInstance2 = createSequelizeLibrary3;
+export {
+  contained_exports as Contained,
+  primary_exports as Primary,
+  SCOPE_SEQUELIZE,
+  createCoordinate,
+  createDefinition,
+  createOperations,
+  createOptions2 as createOptions,
+  createSequelizeLibrary,
+  createSequelizeLibraryFactory,
+  isSequelizeLibrary
+};
+//# sourceMappingURL=index.js.map