openchs-models 1.33.7 → 1.33.9

package/dist/framework/{RealmEmbeddedObjectHandler.js → RealmNestedObjectHandler.js}

@@ -13,19 +13,20 @@ function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /**
- * Framework-level handler for embedded object safety in Realm 12+
- * This automatically processes embedded objects to prevent invalidation issues
+ * Framework-level handler for nested object safety in Realm 12+
+ * This automatically processes nested objects (relationships) to prevent invalidation issues
+ * Note: This handles ALL nested objects, not just Realm's embedded object feature
  */
-class RealmEmbeddedObjectHandler {
+class RealmNestedObjectHandler {
   /**
-   * Automatically processes embedded objects in a data structure
+   * Automatically processes nested objects in a data structure
    * This should be called by RealmProxy.create() before creating objects
    * 
    * @param {Object} data - The object data to process
    * @param {Object} schema - The Realm schema for the object
-   * @returns {Object} Processed data with safe embedded objects
+   * @returns {Object} Processed data with safe nested objects
    */
-  static processEmbeddedObjects(data, schema) {
+  static processNestedObjects(data, schema) {
     if (!data || !schema || !schema.properties) {
       return data || {};
     }
@@ -34,23 +35,23 @@ class RealmEmbeddedObjectHandler {
       const propertySchema = schema.properties[propertyName];
       const propertyValue = data[propertyName];
 
-      // Handle embedded objects (including optional ones)
-      if (this.isEmbeddedObjectProperty(propertySchema) && propertyValue) {
-        processedData[propertyName] = this.safeCopyEmbeddedObject(propertyValue);
+      // Handle nested objects (including optional ones)
+      if (this.isNestedObjectProperty(propertySchema) && propertyValue) {
+        processedData[propertyName] = this.safeCopyNestedObject(propertyValue);
       }
 
-      // Handle lists with embedded objects
-      if (this.isListOfEmbeddedObjects(propertySchema) && Array.isArray(propertyValue)) {
-        processedData[propertyName] = propertyValue.map(item => item ? this.safeCopyEmbeddedObject(item) : item);
+      // Handle lists with nested objects
+      if (this.isListOfNestedObjects(propertySchema) && Array.isArray(propertyValue)) {
+        processedData[propertyName] = propertyValue.map(item => item ? this.safeCopyNestedObject(item) : item);
       }
     });
     return processedData;
   }
 
   /**
-   * Checks if a property schema defines an embedded object
+   * Checks if a property schema defines a nested object (relationship)
    */
-  static isEmbeddedObjectProperty(propertySchema) {
+  static isNestedObjectProperty(propertySchema) {
     if (!propertySchema || propertySchema.type !== 'object') {
       return false;
     }
@@ -58,53 +59,53 @@ class RealmEmbeddedObjectHandler {
   }
 
   /**
-   * Checks if a property schema defines a list of embedded objects
+   * Checks if a property schema defines a list of nested objects
    */
-  static isListOfEmbeddedObjects(propertySchema) {
+  static isListOfNestedObjects(propertySchema) {
     return propertySchema && propertySchema.type === 'list' && propertySchema.objectType && propertySchema.objectType !== 'string';
   }
 
   /**
-   * Safely copies an embedded object using the best available method
+   * Safely copies a nested object using the best available method
    */
-  static safeCopyEmbeddedObject(embeddedObj) {
-    if (!embeddedObj) {
+  static safeCopyNestedObject(nestedObj) {
+    if (!nestedObj) {
       return null;
     }
 
     // If it's not a Realm object, return as-is
-    if (!(0, _RealmCollectionHelper.isRealmObject)(embeddedObj)) {
-      return embeddedObj;
+    if (!(0, _RealmCollectionHelper.isRealmObject)(nestedObj)) {
+      return nestedObj;
     }
     try {
       // Method 1: Try toJSON() (convenient)
-      if (typeof embeddedObj.toJSON === 'function') {
-        return embeddedObj.toJSON();
+      if (typeof nestedObj.toJSON === 'function') {
+        return nestedObj.toJSON();
       }
     } catch (error) {
       // Fall back to manual copy if toJSON fails
     }
 
     // Method 2: Manual deep copy (reliable)
-    return this.deepCopyEmbeddedObject(embeddedObj);
+    return this.deepCopyNestedObject(nestedObj);
   }
 
   /**
-   * Manual deep copy of embedded object
+   * Manual deep copy of nested object
    */
-  static deepCopyEmbeddedObject(embeddedObj) {
-    if (!embeddedObj) {
+  static deepCopyNestedObject(nestedObj) {
+    if (!nestedObj) {
       return null;
     }
     const plainCopy = {};
 
     // Try to get schema properties
     try {
-      if (embeddedObj.objectSchema && typeof embeddedObj.objectSchema === 'function') {
-        const schema = embeddedObj.objectSchema();
+      if (nestedObj.objectSchema && typeof nestedObj.objectSchema === 'function') {
+        const schema = nestedObj.objectSchema();
         if (schema && schema.properties) {
           Object.keys(schema.properties).forEach(prop => {
-            plainCopy[prop] = embeddedObj[prop];
+            plainCopy[prop] = nestedObj[prop];
           });
           return plainCopy;
         }
@@ -114,13 +115,13 @@ class RealmEmbeddedObjectHandler {
     }
 
     // Fallback: Copy all enumerable properties
-    Object.keys(embeddedObj).forEach(prop => {
-      if (typeof embeddedObj[prop] !== 'function') {
-        plainCopy[prop] = embeddedObj[prop];
+    Object.keys(nestedObj).forEach(prop => {
+      if (typeof nestedObj[prop] !== 'function') {
+        plainCopy[prop] = nestedObj[prop];
       }
     });
     return plainCopy;
   }
 }
-var _default = RealmEmbeddedObjectHandler;
+var _default = RealmNestedObjectHandler;
 exports.default = _default;

package/dist/framework/RealmProxy.js

@@ -8,7 +8,7 @@ var _RealmResultsProxy = _interopRequireDefault(require("./RealmResultsProxy"));
 var _lodash = _interopRequireDefault(require("lodash"));
 var _RealmCollectionHelper = require("./RealmCollectionHelper");
 var _General = _interopRequireDefault(require("../utility/General"));
-var _RealmEmbeddedObjectHandler = _interopRequireDefault(require("./RealmEmbeddedObjectHandler"));
+var _RealmNestedObjectHandler = _interopRequireDefault(require("./RealmNestedObjectHandler"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const isVanillaArray = function (object) {
   return !_lodash.default.isNil(object) && "RealmListProxy" !== object.constructor.name && _lodash.default.isArrayLikeObject(object);
@@ -43,11 +43,12 @@ class RealmProxy {
   }
 
   /**
-   *
-   * @param schemaName
-   * @param object
-   * @param updateMode , all === true, modified , never === false
-   * @returns {*}
+   * Creates a new entity in the database
+   * 
+   * @param schemaName - The schema name of the entity to create
+   * @param object - The object data (can be entity wrapper or raw object)
+   * @param updateMode - Update mode: "never" (default), "modified", "all", or boolean equivalents
+   * @returns {*} - The created entity wrapped in its entity class
    */
   create(schemaName, object, updateMode = "never") {
     const entityClass = this.entityMappingConfig.getEntityClass(schemaName);
@@ -56,38 +57,30 @@ class RealmProxy {
     // Extract the underlying data from entity wrapper if needed
     const rawObject = (0, _RealmCollectionHelper.getUnderlyingRealmObject)(object) || object;
 
-    // Automatically process embedded objects for Realm 12+ safety
-    const processedObject = _RealmEmbeddedObjectHandler.default.processEmbeddedObjects(rawObject, schema);
+    // 🚀 FRAMEWORK-LEVEL: Automatically process nested objects for Realm 12+ safety
+    const processedObject = _RealmNestedObjectHandler.default.processNestedObjects(rawObject, schema);
 
-    // Only validate properties that are truly mandatory (no optional: true AND no default value)
-    // This maintains backward compatibility with existing data and Realm's native behavior
-    const mandatoryObjectSchemaProperties = _lodash.default.keys(_lodash.default.pickBy(schema.properties, property => !property.optional && !property.hasOwnProperty('default')));
-    const emptyMandatoryProperties = [];
+    // Lightweight validation: Check for null/undefined mandatory properties  
+    // This provides clear error messages for debugging production issues
+    // Validates when:
+    // 1. In strict creation mode ("never" or false), OR
+    // 2. Touching any mandatory property (prevents setting mandatory fields to null)
+    const mandatoryObjectSchemaProperties = this.entityMappingConfig.getMandatoryObjectSchemaProperties(schemaName);
     const saveObjectKeys = Object.keys(processedObject);
     if (updateMode === "never" || updateMode === false || _lodash.default.intersection(mandatoryObjectSchemaProperties, saveObjectKeys).length > 0) {
-      // Check for null/undefined mandatory properties that are present in the object
-      saveObjectKeys.forEach(x => {
-        const propertyValue = processedObject[x];
-        if (_lodash.default.isNil(propertyValue) && _lodash.default.some(mandatoryObjectSchemaProperties, y => y === x)) {
-          emptyMandatoryProperties.push(x);
+      const emptyMandatoryProperties = [];
+      saveObjectKeys.forEach(key => {
+        const propertyValue = processedObject[key];
+        if (_lodash.default.isNil(propertyValue) && _lodash.default.some(mandatoryObjectSchemaProperties, mandatoryProp => mandatoryProp === key)) {
+          emptyMandatoryProperties.push(key);
         }
       });
-
-      // Enhanced validation: Only check for missing mandatory properties in strict update modes
-      // or when we have some mandatory properties present (indicating intent to save a complete entity)
-      const isStrictUpdateMode = updateMode === "never" || updateMode === false;
-      const hasSomeMandatoryProperties = _lodash.default.intersection(mandatoryObjectSchemaProperties, saveObjectKeys).length > 0;
-      if (isStrictUpdateMode && hasSomeMandatoryProperties) {
-        mandatoryObjectSchemaProperties.forEach(mandatoryProp => {
-          if (!saveObjectKeys.includes(mandatoryProp)) {
-            emptyMandatoryProperties.push(mandatoryProp);
-          }
-        });
-      }
       if (emptyMandatoryProperties.length > 0) {
-        throw new Error(`${emptyMandatoryProperties.join(",")} are mandatory for ${schemaName}, Keys being saved - ${saveObjectKeys}. UUID: ${processedObject.uuid}`);
+        throw new Error(`${emptyMandatoryProperties.join(",")} are mandatory for ${schemaName}, ` + `Keys being saved - ${saveObjectKeys.join(",")}. UUID: ${processedObject.uuid}`);
       }
     }
+
+    // Let Realm handle remaining validation (types, constraints, etc.)
     const dbEntity = this.realmDb.create(schemaName, processedObject, updateMode);
     return new entityClass(dbEntity);
   }

package/dist/index.js

@@ -315,10 +315,10 @@ Object.defineProperty(exports, "EntityMappingConfig", {
     return _Schema.default;
   }
 });
-Object.defineProperty(exports, "RealmEmbeddedObjectHandler", {
+Object.defineProperty(exports, "RealmNestedObjectHandler", {
   enumerable: true,
   get: function () {
-    return _RealmEmbeddedObjectHandler.default;
+    return _RealmNestedObjectHandler.default;
   }
 });
 Object.defineProperty(exports, "Settings", {
@@ -875,7 +875,7 @@ var _ReferenceEntity = _interopRequireDefault(require("./ReferenceEntity"));
 var _RuleDependency = _interopRequireDefault(require("./RuleDependency"));
 var _Rule = _interopRequireDefault(require("./Rule"));
 var _Schema = _interopRequireDefault(require("./Schema"));
-var _RealmEmbeddedObjectHandler = _interopRequireDefault(require("./framework/RealmEmbeddedObjectHandler"));
+var _RealmNestedObjectHandler = _interopRequireDefault(require("./framework/RealmNestedObjectHandler"));
 var _Settings = _interopRequireDefault(require("./Settings"));
 var _SingleCodedValue = _interopRequireDefault(require("./observation/SingleCodedValue"));
 var _SingleSelectFilter = _interopRequireDefault(require("./application/SingleSelectFilter"));

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "openchs-models",
     "description": "OpenCHS data model to be used by front end clients",
-    "version": "1.33.7",
+    "version": "1.33.9",
     "private": false,
     "repository": {
         "type": "git",