js-bao 0.2.10 → 0.2.12

package/dist/chunk-DANSD6BE.js

@@ -0,0 +1,709 @@
+import {
+  BaseModel,
+  Logger
+} from "./chunk-6UX3YSCW.js";
+
+// src/models/relationshipManager.ts
+function generateRefersToMethod(_sourceModelClass, config, targetModelClass) {
+  return async function() {
+    const relatedId = this[config.relatedIdField];
+    if (relatedId === null || typeof relatedId === "undefined") return null;
+    return targetModelClass.find(relatedId);
+  };
+}
+function generateHasManyMethod(_sourceModelClass, config, targetModelClass, _dbEngine) {
+  return async function(paginationArgs) {
+    const {
+      limit,
+      afterCursor,
+      beforeCursor,
+      direction = "forward"
+    } = paginationArgs || {};
+    const {
+      relatedIdField,
+      orderByField = "id",
+      orderDirection = "ASC"
+    } = config;
+    const targetSchema = targetModelClass.getSchema();
+    if (!targetSchema || !targetSchema.options || !targetSchema.options.name) {
+      Logger.error(
+        `[RelationshipManager] Target model ${targetModelClass.name} for hasMany relationship has no valid schema name.`
+      );
+      return { data: [], nextCursor: null, prevCursor: null };
+    }
+    const filter = { [relatedIdField]: this.id };
+    const queryOptions = {
+      sort: { [orderByField]: orderDirection === "ASC" ? 1 : -1 }
+    };
+    if (limit !== void 0) {
+      queryOptions.limit = limit + 1;
+    }
+    if (direction === "forward" && afterCursor) {
+      filter[orderByField] = {
+        [orderDirection === "ASC" ? "$gt" : "$lt"]: afterCursor
+      };
+    } else if (direction === "backward") {
+      if (beforeCursor) {
+        filter[orderByField] = {
+          [orderDirection === "ASC" ? "$lt" : "$gt"]: beforeCursor
+        };
+      }
+      queryOptions.sort = { [orderByField]: orderDirection === "ASC" ? -1 : 1 };
+    }
+    const result = await targetModelClass.query(filter, queryOptions);
+    const results = result.data;
+    let nextCursor = null;
+    let prevCursor = null;
+    const isFirstPage = direction === "forward" && !afterCursor;
+    if (limit !== void 0) {
+      if (direction === "forward") {
+        if (results.length > limit) {
+          nextCursor = results[limit - 1][orderByField];
+          results.pop();
+        }
+        if (results.length > 0 && !isFirstPage) {
+          prevCursor = results[0][orderByField];
+        }
+      } else {
+        if (results.length > limit) {
+          prevCursor = results[limit - 1][orderByField];
+          results.pop();
+        }
+        results.reverse();
+        if (results.length > 0 && beforeCursor) {
+          nextCursor = results[results.length - 1][orderByField];
+        }
+        if (results.length > 0 && !beforeCursor) {
+          if (results.length === limit) {
+            prevCursor = results[0][orderByField];
+          }
+        }
+      }
+    }
+    return { data: results, nextCursor, prevCursor };
+  };
+}
+function generateHasManyThroughMethod(_sourceModelClass, config, targetModelClass, joinModelClass, _dbEngine) {
+  return async function(paginationArgs) {
+    const {
+      limit,
+      afterCursor,
+      beforeCursor,
+      direction = "forward"
+    } = paginationArgs || {};
+    const joinSchema = joinModelClass.getSchema();
+    const targetSchema = targetModelClass.getSchema();
+    if (!joinSchema || !joinSchema.options || !joinSchema.options.name) {
+      Logger.error(
+        `[RelationshipManager] Join model ${joinModelClass.name} for hasManyThrough relationship has no valid schema name.`
+      );
+      return { data: [], nextCursor: null, prevCursor: null };
+    }
+    if (!targetSchema || !targetSchema.options || !targetSchema.options.name) {
+      Logger.error(
+        `[RelationshipManager] Target model ${targetModelClass.name} for hasManyThrough relationship has no valid schema name.`
+      );
+      return { data: [], nextCursor: null, prevCursor: null };
+    }
+    const {
+      joinModelLocalField,
+      joinModelRelatedField,
+      joinModelOrderByField = "id",
+      joinModelOrderDirection = "ASC"
+    } = config;
+    const joinFilter = { [joinModelLocalField]: this.id };
+    const joinQueryOptions = {
+      sort: {
+        [joinModelOrderByField]: joinModelOrderDirection === "ASC" ? 1 : -1
+      },
+      projection: { [joinModelRelatedField]: 1, [joinModelOrderByField]: 1 }
+    };
+    if (limit !== void 0) {
+      joinQueryOptions.limit = limit + 1;
+    }
+    if (direction === "forward" && afterCursor) {
+      joinFilter[joinModelOrderByField] = {
+        [joinModelOrderDirection === "ASC" ? "$gt" : "$lt"]: afterCursor
+      };
+    } else if (direction === "backward") {
+      if (beforeCursor) {
+        joinFilter[joinModelOrderByField] = {
+          [joinModelOrderDirection === "ASC" ? "$lt" : "$gt"]: beforeCursor
+        };
+      }
+      joinQueryOptions.sort = {
+        [joinModelOrderByField]: joinModelOrderDirection === "ASC" ? -1 : 1
+      };
+    }
+    const joinResult = await joinModelClass.query(
+      joinFilter,
+      joinQueryOptions
+    );
+    const joinResults = joinResult.data;
+    let nextCursorFromJoin = null;
+    let prevCursorFromJoin = null;
+    const isFirstPage = direction === "forward" && !afterCursor;
+    if (limit !== void 0) {
+      if (direction === "forward") {
+        if (joinResults.length > limit) {
+          nextCursorFromJoin = joinResults[limit - 1][joinModelOrderByField];
+          joinResults.pop();
+        }
+        if (joinResults.length > 0 && !isFirstPage) {
+          prevCursorFromJoin = joinResults[0][joinModelOrderByField];
+        }
+      } else {
+        if (joinResults.length > limit) {
+          prevCursorFromJoin = joinResults[limit - 1][joinModelOrderByField];
+          joinResults.pop();
+        }
+        joinResults.reverse();
+        if (joinResults.length > 0 && beforeCursor) {
+          nextCursorFromJoin = joinResults[joinResults.length - 1][joinModelOrderByField];
+        }
+        if (joinResults.length > 0 && !beforeCursor) {
+          if (joinResults.length === limit) {
+            prevCursorFromJoin = joinResults[0][joinModelOrderByField];
+          }
+        }
+      }
+    }
+    const relatedIds = joinResults.map((r) => r[joinModelRelatedField]).filter((id) => id != null && typeof id === "string");
+    if (relatedIds.length === 0)
+      return { data: [], nextCursor: null, prevCursor: null };
+    const targetResult = await targetModelClass.query({
+      id: { $in: relatedIds }
+    });
+    return {
+      data: targetResult.data,
+      nextCursor: nextCursorFromJoin,
+      prevCursor: prevCursorFromJoin
+    };
+  };
+}
+function generateHasManyThroughAddMethod(_sourceModelClass, config, _targetModelClass, joinModelClass) {
+  return async function(targetInstanceOrId) {
+    const targetId = typeof targetInstanceOrId === "string" ? targetInstanceOrId : targetInstanceOrId.id;
+    if (!targetId) {
+      Logger.error("[RelationshipManager.add] Target ID is missing.");
+      throw new Error("Target ID is missing for add operation.");
+    }
+    const joinData = {};
+    joinData[config.joinModelLocalField] = this.id;
+    joinData[config.joinModelRelatedField] = targetId;
+    let yDoc = null;
+    let targetDocId = null;
+    const sourceModelConstructor = this.constructor;
+    const connectedDocuments = sourceModelConstructor.connectedDocuments;
+    if (this._metaDocId && connectedDocuments) {
+      targetDocId = this._metaDocId;
+      if (targetDocId) {
+        const documentInfo = connectedDocuments.get(targetDocId);
+        if (documentInfo) {
+          yDoc = documentInfo.yDoc;
+        }
+      }
+    }
+    if (!yDoc) {
+      const legacyDocId = "__legacy_default__";
+      const legacyDocInfo = joinModelClass.connectedDocuments?.get(
+        legacyDocId
+      );
+      if (legacyDocInfo) {
+        yDoc = legacyDocInfo.yDoc;
+      }
+    }
+    if (!yDoc) {
+      throw new Error(
+        `[${joinModelClass.name}] No Y.Doc is connected for this join model. Connect a document via initJsBao(...).connectDocument or call initializeForDocument(yDoc, db, docId, permissionHint) before managing relationships.`
+      );
+    }
+    await yDoc.transact(async () => {
+      const newJoinInstance = new joinModelClass(joinData);
+      if (targetDocId) {
+        await newJoinInstance.save({ targetDocument: targetDocId });
+      } else {
+        await newJoinInstance.save();
+      }
+      Logger.debug(
+        `[RelationshipManager.add] Created join entry in ${config.joinModel}:`,
+        newJoinInstance.toJSON()
+      );
+    }, `add-join-${config.joinModel}-${this.id}-${targetId}`);
+  };
+}
+function generateHasManyThroughRemoveMethod(_sourceModelClass, config, _targetModelClass, joinModelClass) {
+  return async function(targetInstanceOrId) {
+    const targetId = typeof targetInstanceOrId === "string" ? targetInstanceOrId : targetInstanceOrId.id;
+    if (!targetId) {
+      Logger.error("[RelationshipManager.remove] Target ID is missing.");
+      throw new Error("Target ID is missing for remove operation.");
+    }
+    let yDoc = null;
+    let targetDocId = null;
+    const sourceModelConstructor = this.constructor;
+    const connectedDocuments = sourceModelConstructor.connectedDocuments;
+    if (this._metaDocId && connectedDocuments) {
+      targetDocId = this._metaDocId;
+      if (targetDocId) {
+        const documentInfo = connectedDocuments.get(targetDocId);
+        if (documentInfo) {
+          yDoc = documentInfo.yDoc;
+        }
+      }
+    }
+    if (!yDoc) {
+      const legacyDocId = "__legacy_default__";
+      const legacyDocInfo = joinModelClass.connectedDocuments?.get(
+        legacyDocId
+      );
+      if (legacyDocInfo) {
+        yDoc = legacyDocInfo.yDoc;
+      }
+    }
+    if (!yDoc) {
+      throw new Error(
+        `[${joinModelClass.name}] No Y.Doc is connected for this join model. Connect a document via initJsBao(...).connectDocument or call initializeForDocument(yDoc, db, docId, permissionHint) before managing relationships.`
+      );
+    }
+    await yDoc.transact(async () => {
+      const joinRecordsResult = await joinModelClass.query(
+        {
+          [config.joinModelLocalField]: this.id,
+          [config.joinModelRelatedField]: targetId
+        },
+        {
+          limit: 1,
+          projection: { id: 1 }
+        }
+      );
+      if (joinRecordsResult.data.length > 0) {
+        for (const record of joinRecordsResult.data) {
+          const instanceToDelete = await joinModelClass.find(
+            record.id
+          );
+          if (instanceToDelete) {
+            await instanceToDelete.delete();
+            Logger.debug(
+              `[RelationshipManager.remove] Deleted join entry from ${config.joinModel} with ID: ${record.id}`
+            );
+          } else {
+            Logger.warn(
+              `[RelationshipManager.remove] Join entry with ID ${record.id} found by query but not in YMap for deletion.`
+            );
+          }
+        }
+      } else {
+        Logger.debug(
+          `[RelationshipManager.remove] No join entry found in ${config.joinModel} for localId: ${this.id}, relatedId: ${targetId}. No action taken.`
+        );
+      }
+    }, `remove-join-${config.joinModel}-${this.id}-${targetId}`);
+  };
+}
+
+// src/models/ModelRegistry.ts
+var ModelRegistry = class _ModelRegistry {
+  static instance;
+  // Stores globally registered model classes by their name (from @Model decorator)
+  models = /* @__PURE__ */ new Map();
+  // Stores options for globally registered models (from @Model decorator)
+  modelOptions = /* @__PURE__ */ new Map();
+  // Stores fields for globally registered models (from @Model decorator, or a static getter on class)
+  // For simplicity, let's assume fields can be derived or are less critical for this registry part
+  // private modelFields: Map<string, Map<string, FieldOptions>> = new Map();
+  // Holds the subset of models explicitly set for the current initialization session
+  activeSessionModels = null;
+  dbEngine = null;
+  // Store dbEngine for relationship methods
+  constructor() {
+  }
+  static getInstance() {
+    if (!_ModelRegistry.instance) {
+      _ModelRegistry.instance = new _ModelRegistry();
+    }
+    return _ModelRegistry.instance;
+  }
+  registerModel(modelClass, options, fields) {
+    if (!options.name) {
+      throw new Error(
+        `[ModelRegistry] Model class is missing a name in its @Model options. Ensure the @Model decorator includes a 'name' property.`
+      );
+    }
+    if (this.models.has(options.name)) {
+      console.warn(
+        `[ModelRegistry] Model "${options.name}" is already registered. Overwriting.`
+      );
+    }
+    this.models.set(options.name, modelClass);
+    if (fields) {
+      BaseModel.attachFieldAccessors(modelClass, fields);
+    }
+    this.modelOptions.set(options.name, options);
+    console.log(
+      `[ModelRegistry] Model "${options.name}" registered successfully.`
+    );
+  }
+  // Gets the class for a globally registered model
+  getModelClass(name) {
+    return this.models.get(name);
+  }
+  getModelOptions(name) {
+    return this.modelOptions.get(name);
+  }
+  // This method might need to be adapted based on how fields are ultimately managed
+  getModelInfo(modelName) {
+    const modelClass = this.models.get(modelName);
+    const options = this.modelOptions.get(modelName);
+    if (modelClass && options) {
+      const fields = modelClass.getSchema ? modelClass.getSchema().fields : /* @__PURE__ */ new Map();
+      return { class: modelClass, options, fields };
+    }
+    return void 0;
+  }
+  getAllRegisteredModelsInfo() {
+    const infos = [];
+    for (const modelName of this.models.keys()) {
+      const info = this.getModelInfo(modelName);
+      if (info) {
+        infos.push(info);
+      }
+    }
+    return infos;
+  }
+  // Helper to get model name from class (assuming static property from @Model decorator)
+  getModelNameFromClass(modelClass) {
+    return modelClass.modelName;
+  }
+  setExplicitModelsForSession(modelClasses) {
+    if (modelClasses && modelClasses.length > 0) {
+      this.activeSessionModels = /* @__PURE__ */ new Map();
+      modelClasses.forEach((modelClass) => {
+        const modelName = this.getModelNameFromClass(modelClass);
+        if (!modelName) {
+          console.warn(
+            `[ModelRegistry] A model class provided to setExplicitModelsForSession does not have a static 'modelName' property or it's undefined. It will be ignored. Ensure @Model decorator sets this.`
+          );
+          return;
+        }
+        if (!this.models.has(modelName) || this.models.get(modelName) !== modelClass) {
+          console.warn(
+            `[ModelRegistry] Model class with name ${modelName} provided to setExplicitModelsForSession was not found in the global decorator-based registry or does not match. It will be ignored. Ensure the model file is imported and the @Model decorator has run correctly.`
+          );
+          return;
+        }
+        if (this.activeSessionModels) {
+          this.activeSessionModels.set(modelName, modelClass);
+        }
+      });
+      let sessionModelNamesMessage = "none (no models were successfully added or session map is null)";
+      if (this.activeSessionModels) {
+        const currentSessionModelKeys = Array.from(
+          this.activeSessionModels.keys()
+        );
+        if (currentSessionModelKeys.length > 0) {
+          sessionModelNamesMessage = currentSessionModelKeys.join(", ");
+        } else {
+          sessionModelNamesMessage = "none (session map initialized but no models added)";
+        }
+      }
+      Logger.debug(
+        `[ModelRegistry] Explicit models set for session: ${sessionModelNamesMessage}`
+      );
+    } else if (modelClasses && modelClasses.length === 0) {
+      this.activeSessionModels = /* @__PURE__ */ new Map();
+      Logger.debug(
+        "[ModelRegistry] Explicitly no models for session (empty array passed)."
+      );
+    } else {
+      this.activeSessionModels = null;
+      console.log(
+        "[ModelRegistry] No explicit models specified for session (undefined), will use all decorator-registered models."
+      );
+    }
+    this.validateSessionModels();
+  }
+  async initializeAll(yDoc, dbEngine) {
+    Logger.debug("[ModelRegistry] Attempting to initialize models...");
+    this.dbEngine = dbEngine;
+    const modelsToInitialize = this.activeSessionModels || this.models;
+    if (modelsToInitialize.size === 0) {
+      console.warn(
+        "[ModelRegistry] No models to initialize (either no explicit models set for session or no models globally registered via @Model decorator)."
+      );
+      return;
+    }
+    console.log(
+      `[ModelRegistry] Initializing models: ${Array.from(
+        modelsToInitialize.keys()
+      ).join(", ")}`
+    );
+    for (const [modelName, modelClass] of modelsToInitialize.entries()) {
+      if (modelClass && typeof modelClass.initialize === "function") {
+        Logger.debug(`[ModelRegistry] Initializing model: ${modelName}`);
+        await modelClass.initialize(yDoc, dbEngine);
+      } else {
+        const staticModelName = modelClass?.modelName || "unknown";
+        console.warn(
+          `[ModelRegistry] Model ${staticModelName} (class name: ${modelClass?.name}) does not have a static initialize method or class is not defined.`
+        );
+      }
+    }
+    Logger.debug("[ModelRegistry] Model initialization phase complete.");
+  }
+  // New method to initialize models for a specific document
+  async initializeAllForDocument(yDoc, dbEngine, docId, permissionHint) {
+    Logger.debug(
+      `[ModelRegistry] Initializing models for document ${docId}...`
+    );
+    this.dbEngine = dbEngine;
+    const modelsToInitialize = this.activeSessionModels || this.models;
+    if (modelsToInitialize.size === 0) {
+      Logger.warn(
+        "[ModelRegistry] No models to initialize for document (either no explicit models set for session or no models globally registered via @Model decorator)."
+      );
+      return;
+    }
+    Logger.debug(
+      `[ModelRegistry] Initializing models for document ${docId}: ${Array.from(
+        modelsToInitialize.keys()
+      ).join(", ")}`
+    );
+    for (const [modelName, modelClass] of modelsToInitialize.entries()) {
+      if (modelClass && typeof modelClass.initializeForDocument === "function") {
+        Logger.debug(
+          `[ModelRegistry] Initializing model ${modelName} for document ${docId}`
+        );
+        await modelClass.initializeForDocument(
+          yDoc,
+          dbEngine,
+          docId,
+          permissionHint
+        );
+      } else {
+        const staticModelName = modelClass?.modelName || "unknown";
+        console.warn(
+          `[ModelRegistry] Model ${staticModelName} (class name: ${modelClass?.name}) does not have a static initializeForDocument method or class is not defined.`
+        );
+      }
+    }
+    await this.initializeRelationships();
+    Logger.debug(
+      `[ModelRegistry] Model initialization complete for document ${docId}`
+    );
+  }
+  // New method to remove data from a disconnected document
+  async removeDocumentData(docId, dbEngine) {
+    Logger.debug(`[ModelRegistry] Removing data for document ${docId}...`);
+    const modelsToCleanup = this.activeSessionModels || this.models;
+    if (modelsToCleanup.size === 0) {
+      console.warn(
+        "[ModelRegistry] No models to cleanup for document (either no explicit models set for session or no models globally registered via @Model decorator)."
+      );
+      return;
+    }
+    for (const [modelName, modelClass] of modelsToCleanup.entries()) {
+      try {
+        Logger.debug(
+          `[ModelRegistry] Removing ${modelName} data for document ${docId}`
+        );
+        await dbEngine.deleteByDocumentId(modelName, docId);
+        if (modelClass && typeof modelClass.cleanupDocumentData === "function") {
+          await modelClass.cleanupDocumentData(docId);
+        }
+      } catch (error) {
+        console.error(
+          `[ModelRegistry] Error removing ${modelName} data for document ${docId}:`,
+          error
+        );
+      }
+    }
+    Logger.debug(`[ModelRegistry] Data removal complete for document ${docId}`);
+  }
+  // New method to initialize relationships
+  async initializeRelationships() {
+    if (!this.dbEngine) {
+      console.error(
+        "[ModelRegistry] DB engine not available for initializing relationships. Ensure initializeAll has been called."
+      );
+      return;
+    }
+    const dbEngine = this.dbEngine;
+    Logger.debug(
+      "[ModelRegistry] Initializing relationships for active models..."
+    );
+    const activeModels = this.getActiveModels();
+    for (const [modelName, modelClass] of activeModels.entries()) {
+      const modelSchema = modelClass.getSchema ? modelClass.getSchema() : null;
+      const relationshipsConfig = modelSchema?.options?.relationships;
+      if (relationshipsConfig) {
+        Logger.debug(
+          `[ModelRegistry] Setting up relationships for ${modelName}`
+        );
+        for (const relName in relationshipsConfig) {
+          const config = relationshipsConfig[relName];
+          if (!config.model) {
+            throw new Error(
+              `[ModelRegistry] Relationship "${relName}" on model "${modelName}" is missing a target model name.`
+            );
+          }
+          const targetModelClass = this.getModelClass(config.model);
+          if (!targetModelClass) {
+            throw new Error(
+              `[ModelRegistry] Relationship "${relName}" on model "${modelName}" refers to an unknown model "${config.model}". Ensure "${config.model}" is registered and included in the session.`
+            );
+          }
+          if (typeof targetModelClass.getSchema !== "function") {
+            throw new Error(
+              `[ModelRegistry] Target model "${config.model}" for relationship "${relName}" on "${modelName}" does not have a getSchema method.`
+            );
+          }
+          switch (config.type) {
+            case "refersTo":
+              Logger.debug(
+                `   - Adding '${relName}' (refersTo ${config.model}) to ${modelName}`
+              );
+              const refersToMethod = generateRefersToMethod(
+                modelClass,
+                config,
+                targetModelClass
+              );
+              this.addPrototypeMethod(modelClass, relName, refersToMethod);
+              break;
+            case "hasMany":
+              Logger.debug(
+                `   - Adding '${relName}' (hasMany ${config.model}) to ${modelName}`
+              );
+              const hasManyMethod = generateHasManyMethod(
+                modelClass,
+                config,
+                targetModelClass,
+                dbEngine
+              );
+              this.addPrototypeMethod(modelClass, relName, hasManyMethod);
+              break;
+            case "hasManyThrough":
+              const joinModelName = config.joinModel;
+              const joinModelClass = this.getModelClass(joinModelName);
+              if (!joinModelClass) {
+                throw new Error(
+                  `[ModelRegistry] Join model "${joinModelName}" for relationship "${relName}" on model "${modelName}" not found. Ensure it is registered and included in the session.`
+                );
+              }
+              if (typeof joinModelClass.getSchema !== "function") {
+                throw new Error(
+                  `[ModelRegistry] Join model "${joinModelName}" for relationship "${relName}" on "${modelName}" does not have a getSchema method.`
+                );
+              }
+              Logger.debug(
+                `   - Adding '${relName}' (hasManyThrough ${config.model} via ${joinModelName}) to ${modelName}`
+              );
+              const hasManyThroughFetchMethod = generateHasManyThroughMethod(
+                modelClass,
+                config,
+                targetModelClass,
+                joinModelClass,
+                dbEngine
+              );
+              this.addPrototypeMethod(
+                modelClass,
+                relName,
+                hasManyThroughFetchMethod
+              );
+              const relNameSingular = config.model.endsWith("s") ? config.model.slice(0, -1) : config.model;
+              const capitalizedSingularRelName = relNameSingular.charAt(0).toUpperCase() + relNameSingular.slice(1);
+              const addMethodName = `add${capitalizedSingularRelName}`;
+              const addMethodLogic = generateHasManyThroughAddMethod(
+                modelClass,
+                config,
+                targetModelClass,
+                joinModelClass
+              );
+              this.addPrototypeMethod(
+                modelClass,
+                addMethodName,
+                addMethodLogic
+              );
+              Logger.debug(
+                `   - Adding '${addMethodName}' helper to ${modelName} (for relationship ${relName})`
+              );
+              const removeMethodName = `remove${capitalizedSingularRelName}`;
+              const removeMethodLogic = generateHasManyThroughRemoveMethod(
+                modelClass,
+                config,
+                targetModelClass,
+                joinModelClass
+              );
+              this.addPrototypeMethod(
+                modelClass,
+                removeMethodName,
+                removeMethodLogic
+              );
+              Logger.debug(
+                `   - Adding '${removeMethodName}' helper to ${modelName} (for relationship ${relName})`
+              );
+              break;
+            default:
+              console.warn(
+                `[ModelRegistry] Unknown relationship type "${config.type}" for ${relName} on ${modelName}. Skipping.`
+              );
+          }
+        }
+      }
+    }
+    Logger.debug("[ModelRegistry] Relationship initialization phase complete.");
+  }
+  // Helper to add methods to prototype
+  addPrototypeMethod(modelClass, methodName, methodLogic) {
+    Object.defineProperty(modelClass.prototype, methodName, {
+      value: methodLogic,
+      writable: true,
+      enumerable: false,
+      // Keep it clean, like other prototype methods
+      configurable: true
+    });
+  }
+  clearSessionState() {
+    this.activeSessionModels = null;
+    Logger.debug(
+      "[ModelRegistry] Session state cleared (activeSessionModels reset)."
+    );
+  }
+  getActiveModels() {
+    return this.activeSessionModels || this.models;
+  }
+  validateSessionModels() {
+    const activeModels = this.getActiveModels();
+    if (!activeModels || activeModels.size === 0) {
+      return;
+    }
+    for (const [modelName, modelClass] of activeModels.entries()) {
+      const modelSchema = modelClass.getSchema ? modelClass.getSchema() : null;
+      const relationships = modelSchema?.options?.relationships;
+      if (relationships) {
+        for (const relName in relationships) {
+          const config = relationships[relName];
+          const targetModelName = config.model;
+          if (!activeModels.has(targetModelName)) {
+            throw new Error(
+              `[ModelRegistry] Validation Error: Model "${modelName}" has a relationship "${relName}" that refers to model "${targetModelName}", but "${targetModelName}" is not active in the current session. Please include it in the 'models' array during initialization.`
+            );
+          }
+          if (config.type === "hasManyThrough") {
+            const joinModelName = config.joinModel;
+            if (!activeModels.has(joinModelName)) {
+              throw new Error(
+                `[ModelRegistry] Validation Error: Model "${modelName}" has a relationship "${relName}" that uses join model "${joinModelName}", but "${joinModelName}" is not active in the current session. Please include it in the 'models' array during initialization.`
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export {
+  ModelRegistry
+};
+//# sourceMappingURL=chunk-DANSD6BE.js.map