@memberjunction/core 3.4.0 → 4.1.0

package/dist/generic/baseEntity.js

@@ -1,19 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntity = exports.BaseEntityEvent = exports.BaseEntityResult = exports.BaseEntityAIActionParams = exports.DataObjectParams = exports.DataObjectRelatedEntityParam = exports.EntityField = void 0;
-const global_1 = require("@memberjunction/global");
-const entityInfo_1 = require("./entityInfo");
-const interfaces_1 = require("./interfaces");
-const metadata_1 = require("./metadata");
-const runView_1 = require("../views/runView");
-const logging_1 = require("./logging");
-const compositeKey_1 = require("./compositeKey");
-const rxjs_1 = require("rxjs");
+import { MJEventType, MJGlobal, uuidv4, WarningManager } from '@memberjunction/global';
+import { EntityFieldInfo, EntityInfo, EntityFieldTSType, EntityPermissionType, RecordChange, ValidationErrorInfo, ValidationResult } from './entityInfo.js';
+import { EntityDeleteOptions, EntitySaveOptions, ProviderType } from './interfaces.js';
+import { Metadata } from './metadata.js';
+import { RunView } from '../views/runView.js';
+import { LogDebug, LogError } from './logging.js';
+import { CompositeKey } from './compositeKey.js';
+import { finalize, firstValueFrom, from, of, shareReplay, Subject, switchMap } from 'rxjs';
 /**
  * Represents a field in an instance of the BaseEntity class. This class is used to store the value of the field, dirty state, as well as other run-time information about the field. The class encapsulates the underlying field metadata and exposes some of the more commonly
  * used properties from the entity field metadata.
  */
-class EntityField {
+export class EntityField {
+    /**
+     * Static object containing the value ranges for various SQL number types.
+     * This is used to validate the value of the field when it is set or validated.
+     */
+    static { this.SQLTypeValueRanges = {
+        "int": { min: -2147483648, max: 2147483647 },
+        "bigint": { min: -9223372036854775808, max: 9223372036854775807 },
+        "smallint": { min: -32768, max: 32767 },
+        "tinyint": { min: 0, max: 255 },
+        "decimal": { min: -7922816251426433759354395033, max: 79228162514264337593543950335 },
+        "numeric": { min: -7922816251426433759354395033, max: 79228162514264337593543950335 },
+        "float": { min: -1.7976931348623157e+308, max: 1.7976931348623157e+308 },
+        "real": { min: -3.402823466e+38, max: 3.402823466e+38 },
+        "money": { min: -922337203685477.5808, max: 922337203685477.5807 },
+    }; }
     get Name() {
         return this._entityFieldInfo.Name;
     }
@@ -45,7 +57,7 @@ class EntityField {
         // Asserting status here for deprecated or disabled fields, not in constructor because
         // we legacy fields will exist
         if (this._assertActiveStatusRequired) {
-            entityInfo_1.EntityFieldInfo.AssertEntityFieldActiveStatus(this._entityFieldInfo, 'EntityField.Value setter');
+            EntityFieldInfo.AssertEntityFieldActiveStatus(this._entityFieldInfo, 'EntityField.Value setter');
         }
         return this._Value;
     }
@@ -75,7 +87,7 @@ class EntityField {
             // asserting status here becuase the flag is on AND the values
             // are different - this avoid assertions during sysops like SetMany that often aren't changing
             // the value of the field
-            entityInfo_1.EntityFieldInfo.AssertEntityFieldActiveStatus(this._entityFieldInfo, 'EntityField.Value setter');
+            EntityFieldInfo.AssertEntityFieldActiveStatus(this._entityFieldInfo, 'EntityField.Value setter');
         }
         if (!this.ReadOnly ||
             this._NeverSet /* Allow one time set of any field because BaseEntity Object passes in ReadOnly fields when we load,
@@ -121,7 +133,7 @@ class EntityField {
                     newCompare = this.Value.getTime();
                 }
                 // Special handling for bit/Boolean types - treat truthy values as equivalent
-                if (this._entityFieldInfo.TSType === entityInfo_1.EntityFieldTSType.Boolean ||
+                if (this._entityFieldInfo.TSType === EntityFieldTSType.Boolean ||
                     this._entityFieldInfo.Type.toLowerCase() === 'bit') {
                     // Convert both values to boolean for comparison
                     const oldBool = this.convertToBoolean(oldCompare);
@@ -129,7 +141,7 @@ class EntityField {
                     return oldBool !== newBool;
                 }
                 // Special handling for numeric types - treat numeric strings that convert to same value as equivalent
-                if (this._entityFieldInfo.TSType === entityInfo_1.EntityFieldTSType.Number || this.isNumericType(this._entityFieldInfo.Type)) {
+                if (this._entityFieldInfo.TSType === EntityFieldTSType.Number || this.isNumericType(this._entityFieldInfo.Type)) {
                     const oldNum = this.convertToNumber(oldCompare);
                     const newNum = this.convertToNumber(newCompare);
                     // Handle NaN cases - if both are NaN, they're equivalent
@@ -143,7 +155,7 @@ class EntityField {
                     return oldNum !== newNum;
                 }
                 // for string types where the comparisons are not both strings
-                if (this._entityFieldInfo.TSType === entityInfo_1.EntityFieldTSType.String) {
+                if (this._entityFieldInfo.TSType === EntityFieldTSType.String) {
                     if (typeof oldCompare === 'object') {
                         // need to convert the object to a string for comparison
                         oldCompare = JSON.stringify(oldCompare);
@@ -228,7 +240,7 @@ class EntityField {
      */
     Validate() {
         const ef = this._entityFieldInfo;
-        const result = new entityInfo_1.ValidationResult();
+        const result = new ValidationResult();
         result.Success = true; // assume success
         if (!ef.ReadOnly && !ef.SkipValidation) {
             // only do validation on updatable fields and skip the special case fields defined inside the SkipValidation property (like ID/CreatedAt/UpdatedAt)
@@ -237,24 +249,24 @@ class EntityField {
                 if (ef.DefaultValue === null || ef.DefaultValue === undefined || ef.DefaultValue.trim().length === 0) {
                     // we have no default value, so this is an error
                     result.Success = false;
-                    result.Errors.push(new entityInfo_1.ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} cannot be null`, null));
+                    result.Errors.push(new ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} cannot be null`, null));
                 }
                 else {
                     // we do have a default value, but our current value is null. If we are in an EXISTING record, this is an error, check the OldValue to determine this
                     if (this._OldValue !== null && this._OldValue !== undefined) {
                         result.Success = false;
-                        result.Errors.push(new entityInfo_1.ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} cannot be null`, null));
+                        result.Errors.push(new ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} cannot be null`, null));
                     }
                 }
             }
-            if (ef.TSType == entityInfo_1.EntityFieldTSType.String && ef.MaxLength > 0 && this.Value && this.Value.length > ef.MaxLength) {
+            if (ef.TSType == EntityFieldTSType.String && ef.MaxLength > 0 && this.Value && this.Value.length > ef.MaxLength) {
                 result.Success = false;
-                result.Errors.push(new entityInfo_1.ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} cannot be longer than ${ef.MaxLength} characters. Current value is ${this.Value.length} characters`, this.Value));
+                result.Errors.push(new ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} cannot be longer than ${ef.MaxLength} characters. Current value is ${this.Value.length} characters`, this.Value));
             }
-            if (ef.TSType == entityInfo_1.EntityFieldTSType.Date && (this.Value !== null && this.Value !== undefined && !(this.Value instanceof Date))) {
+            if (ef.TSType == EntityFieldTSType.Date && (this.Value !== null && this.Value !== undefined && !(this.Value instanceof Date))) {
                 // invalid non-null date, but that is okay if we are a new record and we have a default value
                 result.Success = false;
-                result.Errors.push(new entityInfo_1.ValidationErrorInfo(ef.Name, `${this.Value} is not a valid date for ${ef.DisplayNameOrName}`, this.Value));
+                result.Errors.push(new ValidationErrorInfo(ef.Name, `${this.Value} is not a valid date for ${ef.DisplayNameOrName}`, this.Value));
             }
             // add validation to ensure a number value is within range based on the
             // underlying SQL type
@@ -263,7 +275,7 @@ class EntityField {
                 if (typeLookup) {
                     if (this.Value < typeLookup.min || this.Value > typeLookup.max) {
                         result.Success = false;
-                        result.Errors.push(new entityInfo_1.ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} is ${ef.SQLFullType} in the database and must be a valid number between ${-typeLookup.min} and ${typeLookup.max}. Current value is ${this.Value}`, this.Value));
+                        result.Errors.push(new ValidationErrorInfo(ef.Name, `${ef.DisplayNameOrName} is ${ef.SQLFullType} in the database and must be a valid number between ${-typeLookup.min} and ${typeLookup.max}. Current value is ${this.Value}`, this.Value));
                     }
                 }
             }
@@ -288,14 +300,14 @@ class EntityField {
             this.Value = Value;
         }
         else if (fieldInfo.DefaultValue) {
-            if (fieldInfo.TSType === entityInfo_1.EntityFieldTSType.Boolean) {
+            if (fieldInfo.TSType === EntityFieldTSType.Boolean) {
                 // special handling for booleans as we don't want a string passed into a boolean field, we want a true boolean
                 if (typeof fieldInfo.DefaultValue === "string" && fieldInfo.DefaultValue.trim() === "1" || fieldInfo.DefaultValue.trim().toLowerCase() === "true")
                     this.Value = true;
                 else
                     this.Value = false;
             }
-            else if (fieldInfo.TSType === entityInfo_1.EntityFieldTSType.Number) {
+            else if (fieldInfo.TSType === EntityFieldTSType.Number) {
                 // special handling for numbers as we don't want a string passed into a value for a numeric field
                 if (!isNaN(Number(fieldInfo.DefaultValue))) {
                     this.Value = Number(fieldInfo.DefaultValue);
@@ -308,7 +320,7 @@ class EntityField {
                 // special handling for GUIDs, we don't want to populate anything here because the server always sets the value, leave blank
                 this.Value = null;
             }
-            else if (fieldInfo.TSType === entityInfo_1.EntityFieldTSType.Date) {
+            else if (fieldInfo.TSType === EntityFieldTSType.Date) {
                 if (fieldInfo.DefaultValue.trim().length > 0) {
                     // special handling for dates as we don't want to use getdate() type defaults as is, we want to convert them to a JS Date object
                     try {
@@ -324,7 +336,7 @@ class EntityField {
                     }
                     catch (e) {
                         // if we get here, that means the default value is not a valid date, so we need to check to see if it's a SQL current date function
-                        if (entityInfo_1.EntityFieldInfo.IsDefaultValueSQLCurrentDateFunction(fieldInfo.DefaultValue)) {
+                        if (EntityFieldInfo.IsDefaultValueSQLCurrentDateFunction(fieldInfo.DefaultValue)) {
                             // we have a SQL current date function default, leave the field alone if its a special date field as the server (i.e. database) will handle
                             //setting the value, otherwise set the value to the current date
                             if (fieldInfo.IsSpecialDateField) {
@@ -379,26 +391,9 @@ class EntityField {
         return this._OldValue;
     }
 }
-exports.EntityField = EntityField;
-/**
- * Static object containing the value ranges for various SQL number types.
- * This is used to validate the value of the field when it is set or validated.
- */
-EntityField.SQLTypeValueRanges = {
-    "int": { min: -2147483648, max: 2147483647 },
-    "bigint": { min: -9223372036854775808, max: 9223372036854775807 },
-    "smallint": { min: -32768, max: 32767 },
-    "tinyint": { min: 0, max: 255 },
-    "decimal": { min: -7922816251426433759354395033, max: 79228162514264337593543950335 },
-    "numeric": { min: -7922816251426433759354395033, max: 79228162514264337593543950335 },
-    "float": { min: -1.7976931348623157e+308, max: 1.7976931348623157e+308 },
-    "real": { min: -3.402823466e+38, max: 3.402823466e+38 },
-    "money": { min: -922337203685477.5808, max: 922337203685477.5807 },
-};
-class DataObjectRelatedEntityParam {
+export class DataObjectRelatedEntityParam {
 }
-exports.DataObjectRelatedEntityParam = DataObjectRelatedEntityParam;
-class DataObjectParams {
+export class DataObjectParams {
     constructor(oldValues = false, omitNullValues = false, omitEmptyStrings = false, excludeFields = [], includeRelatedEntityData = false, relatedEntityList = []) {
         this.oldValues = oldValues;
         this.omitNullValues = omitNullValues;
@@ -408,14 +403,12 @@ class DataObjectParams {
         this.relatedEntityList = relatedEntityList;
     }
 }
-exports.DataObjectParams = DataObjectParams;
-class BaseEntityAIActionParams {
+export class BaseEntityAIActionParams {
 }
-exports.BaseEntityAIActionParams = BaseEntityAIActionParams;
 /**
  * Used for storing the result of a Save or Delete or other transactional operation within a BaseEntity
  */
-class BaseEntityResult {
+export class BaseEntityResult {
     constructor(success, message, type) {
         /**
          * A copy of the values of the entity object BEFORE the operation was performed
@@ -463,18 +456,32 @@ class BaseEntityResult {
         return msg;
     }
 }
-exports.BaseEntityResult = BaseEntityResult;
 /**
  * Event type that is used to raise events and provided structured callbacks for any caller that is interested in registering for events.
  * This type is also used for whenever a BaseEntity instance raises an event with MJGlobal.
  */
-class BaseEntityEvent {
+export class BaseEntityEvent {
 }
-exports.BaseEntityEvent = BaseEntityEvent;
 /**
  * Base class used for all entity objects. This class is abstract and is sub-classes for each particular entity using the CodeGen tool. This class provides the basic functionality for loading, saving, and validating entity objects.
  */
-class BaseEntity {
+export class BaseEntity {
+    /**
+     * Gets the provider transaction handle for IS-A chain orchestration.
+     */
+    get ProviderTransaction() { return this._providerTransaction; }
+    /**
+     * Sets the provider transaction handle. Used during IS-A save/delete to share
+     * a single database transaction across the entire parent chain.
+     */
+    set ProviderTransaction(value) { this._providerTransaction = value; }
+    /**
+     * Returns the parent entity in the IS-A composition chain, or null if this
+     * entity is not an IS-A child type. Read-only public access for inspection.
+     * Named ISAParentEntity to avoid collision with generated Entity.ParentEntity
+     * string column (which contains the parent entity's name from the view).
+     */
+    get ISAParentEntity() { return this._parentEntity; }
     constructor(Entity, Provider = null) {
         this._Fields = [];
         this._recordLoaded = false;
@@ -485,6 +492,33 @@ class BaseEntity {
         this._everSaved = false;
         this._isLoading = false;
         this._pendingDelete$ = null;
+        /**************************************************************************
+         * IS-A Type Relationship — Parent Entity Composition
+         *
+         * For IS-A child entities, _parentEntity holds a persistent live reference
+         * to the parent entity instance. All data routing (Set/Get), dirty tracking,
+         * validation, and save/delete orchestration flow through this composition chain.
+         **************************************************************************/
+        /**
+         * Persistent reference to the parent entity in the IS-A chain.
+         * For example, if MeetingEntity IS-A ProductEntity, the MeetingEntity instance
+         * holds a reference to a ProductEntity instance here. This is null for entities
+         * that are not IS-A child types.
+         */
+        this._parentEntity = null;
+        /**
+         * Cached set of field names that belong to parent entities — used for
+         * efficient O(1) lookup during Set/Get routing to determine if a field
+         * should be forwarded to _parentEntity.
+         */
+        this._parentEntityFieldNames = null;
+        /**
+         * Opaque provider-level transaction handle. Used by IS-A save/delete orchestration
+         * to share a single SQL transaction across the parent chain.
+         * On client (GraphQLDataProvider), this remains null.
+         * On server (SQLServerDataProvider), this holds a sql.Transaction.
+         */
+        this._providerTransaction = null;
         this._compositeKey = null;
         // Holds the current pending save observable (if any)
         this._pendingSave$ = null;
@@ -494,12 +528,82 @@ class BaseEntity {
          * that embed multiple fields if desired.
          */
         this._vectors = new Map();
-        this._eventSubject = new rxjs_1.Subject();
+        this._eventSubject = new Subject();
         this._EntityInfo = Entity;
-        entityInfo_1.EntityInfo.AssertEntityActiveStatus(Entity, 'BaseEntity::constructor');
+        EntityInfo.AssertEntityActiveStatus(Entity, 'BaseEntity::constructor');
         this._provider = Provider;
         this.init();
     }
+    /**
+     * Initializes the IS-A parent entity composition chain. For child type entities,
+     * this creates the parent entity instance (and recursively its parent, etc.) and
+     * caches the parent field name set for routing.
+     *
+     * Must be called AFTER EntityInfo is available but BEFORE any Load/NewRecord/Set/Get.
+     * This is called by Metadata.GetEntityObject() after constructing the entity.
+     */
+    async InitializeParentEntity() {
+        if (!this.EntityInfo?.IsChildType)
+            return;
+        const md = new Metadata();
+        const parentEntityInfo = this.EntityInfo.ParentEntityInfo;
+        if (!parentEntityInfo)
+            return;
+        // Create the parent entity via Metadata to ensure proper class factory resolution
+        this._parentEntity = await md.GetEntityObject(parentEntityInfo.Name, this._contextCurrentUser);
+        // Recursive: the parent's InitializeParentEntity() was called by GetEntityObject()
+        // Cache the parent field names for O(1) routing lookups
+        this._parentEntityFieldNames = this.EntityInfo.ParentEntityFieldNames;
+    }
+    /**
+     * Resets this entity to a pristine state and populates it from the provided data object.
+     *
+     * Unlike {@link SetMany}, which incrementally updates existing field values, `Hydrate()`
+     * first resets ALL internal state — fields, composite key cache, loaded/saved flags —
+     * then populates from the provided data as if loading a fresh record from the database.
+     *
+     * This is critical for IS-A (table-per-type) inheritance: when a child entity loads
+     * its record, parent entities in the chain must be fully reset and re-populated from
+     * the child's view data, including the shared primary key. After `init()`, each
+     * EntityField's `_NeverSet` flag is `true`, allowing even ReadOnly PK fields to be
+     * set exactly once via `SetMany`.
+     *
+     * After population, entities are automatically marked as saved/loaded when all PK
+     * values are present (via {@link UpdateSavedStateFromPrimaryKeys}).
+     *
+     * The parent chain is handled recursively: if this entity has an IS-A parent, the
+     * parent is hydrated first (deepest ancestor first) via SetMany's built-in routing.
+     *
+     * @param data - A plain object whose properties map to field names on this entity
+     *               (and potentially parent entities in the IS-A chain).
+     */
+    Hydrate(data) {
+        // Reset this entity to pristine state: clears _compositeKey, _recordLoaded,
+        // _everSaved, and recreates all EntityField instances with _NeverSet = true
+        this.init();
+        // Recursively hydrate parent entities first (deepest ancestor resets first).
+        // After init(), parent fields have fresh _NeverSet=true, so SetMany can set PKs.
+        if (this._parentEntity) {
+            this._parentEntity.Hydrate(data);
+        }
+        // Populate this entity's fields. SetMany also routes parent field values to
+        // _parentEntity via the IS-A routing block (which now includes PK fields).
+        // replaceOldValues=true ensures OldValue matches Value (no false dirty flags).
+        // ignoreNonExistentFields=true because data may contain fields from other
+        // entities in the chain that don't exist on this entity.
+        this.SetMany(data, true, true, true);
+    }
+    /**
+     * Propagates the ProviderTransaction handle down the IS-A parent chain so all
+     * entities in the chain execute on the same database transaction.
+     */
+    PropagateTransactionToParents() {
+        let current = this._parentEntity;
+        while (current) {
+            current.ProviderTransaction = this._providerTransaction;
+            current = current._parentEntity;
+        }
+    }
     /**
      * Returns this provider to be used for a given instance of a BaseEntity derived subclass. If the provider is not set, the BaseEntity.Provider is returned.
      */
@@ -552,6 +656,7 @@ class BaseEntity {
     RaiseReadyForTransaction() {
         this.RaiseEvent('transaction_ready', null);
     }
+    static { this._baseEventCode = 'BaseEntityEvent'; }
     /**
      * When a BaseEntity class raises an event with MJGlobal, the eventCode property is set to this value. This is used to identify events that are raised by BaseEntity objects.
      * Any MJGlobal event that is raised by a BaseEntity class will use a BaseEntityEvent type as the args parameter
@@ -564,7 +669,7 @@ class BaseEntity {
      */
     RaiseEvent(type, payload, saveSubType = undefined) {
         // this is the local event handler that is specific to THIS instance of the entity object
-        (0, logging_1.LogDebug)(`BaseEntity.RaiseEvent() - ${type === 'save' ? 'save:' + saveSubType : type} event raised for ${this.EntityInfo.Name}, about to call this._eventSubject.next()`);
+        LogDebug(`BaseEntity.RaiseEvent() - ${type === 'save' ? 'save:' + saveSubType : type} event raised for ${this.EntityInfo.Name}, about to call this._eventSubject.next()`);
         this._eventSubject.next({ type: type, payload: payload, saveSubType: saveSubType, baseEntity: this });
         // this next call is to MJGlobal to let everyone who cares knows that we had an event on an entity object
         // we broadcast save/delete/load events and their _started counterparts
@@ -575,10 +680,10 @@ class BaseEntity {
             event.payload = payload;
             event.type = type;
             event.saveSubType = saveSubType;
-            (0, logging_1.LogDebug)(`BaseEntity.RaiseEvent() - ${type === 'save' ? 'save:' + saveSubType : type} event raised for ${this.EntityInfo.Name}, about to call MJGlobal.RaiseEvent()`);
-            global_1.MJGlobal.Instance.RaiseEvent({
+            LogDebug(`BaseEntity.RaiseEvent() - ${type === 'save' ? 'save:' + saveSubType : type} event raised for ${this.EntityInfo.Name}, about to call MJGlobal.RaiseEvent()`);
+            MJGlobal.Instance.RaiseEvent({
                 component: this,
-                event: global_1.MJEventType.ComponentEvent,
+                event: MJEventType.ComponentEvent,
                 eventCode: BaseEntity.BaseEventCode,
                 args: event
             });
@@ -758,7 +863,9 @@ class BaseEntity {
      * Returns true if the object is Dirty, meaning something has changed since it was last saved to the database, and false otherwise. For new records, this will always return true.
      */
     get Dirty() {
-        return !this.IsSaved || this.Fields.some(f => f.Dirty);
+        return !this.IsSaved ||
+            this.Fields.some(f => f.Dirty) ||
+            (this._parentEntity?.Dirty ?? false);
     }
     /**
      * Returns an array of all primary key fields for the entity. If the entity has a composite primary key, this method will return an array of all primary key fields.
@@ -773,7 +880,7 @@ class BaseEntity {
      */
     get PrimaryKey() {
         if (this._compositeKey === null) {
-            this._compositeKey = new compositeKey_1.CompositeKey();
+            this._compositeKey = new CompositeKey();
             this._compositeKey.LoadFromEntityFields(this.PrimaryKeys);
         }
         return this._compositeKey;
@@ -793,16 +900,36 @@ class BaseEntity {
     /**
      * Sets the value of a given field. If the field doesn't exist, nothing happens.
      * The field's type is used to convert the value to the appropriate type.
+     *
+     * For IS-A child entities, parent fields are routed to `_parentEntity.Set()` (recursive
+     * for N-level chains). The value is also mirrored on the child's own virtual EntityField
+     * so that code iterating `entity.Fields` still sees it. The authoritative state for parent
+     * fields lives on `_parentEntity`.
+     *
      * @param FieldName
      * @param Value
      */
     Set(FieldName, Value) {
+        // IS-A routing: if this field belongs to a parent entity, route to parent
+        if (this._parentEntity && this._parentEntityFieldNames?.has(FieldName)) {
+            this._parentEntity.Set(FieldName, Value); // recursive for N-level chains
+            // Also mirror the value on our own virtual EntityField for UI compatibility
+            this.SetLocal(FieldName, Value);
+            return;
+        }
+        this.SetLocal(FieldName, Value);
+    }
+    /**
+     * Internal helper that sets a field value directly on THIS entity's own Fields array
+     * without IS-A routing. Used by Set() for own-fields and for mirroring parent field values.
+     */
+    SetLocal(FieldName, Value) {
         const field = this.GetFieldByName(FieldName);
         if (field != null) {
-            if (field.EntityFieldInfo.TSType === entityInfo_1.EntityFieldTSType.Date && (typeof Value === 'string' || typeof Value === 'number')) {
+            if (field.EntityFieldInfo.TSType === EntityFieldTSType.Date && (typeof Value === 'string' || typeof Value === 'number')) {
                 field.Value = new Date(Value);
             }
-            else if (field.EntityFieldInfo.TSType === entityInfo_1.EntityFieldTSType.Number && typeof Value === 'string' && Value !== null && Value !== undefined) {
+            else if (field.EntityFieldInfo.TSType === EntityFieldTSType.Number && typeof Value === 'string' && Value !== null && Value !== undefined) {
                 const numericValue = Number(Value);
                 if (!isNaN(numericValue)) {
                     field.Value = numericValue;
@@ -811,7 +938,7 @@ class BaseEntity {
                     field.Value = Value;
                 }
             }
-            else if (field.EntityFieldInfo.TSType === entityInfo_1.EntityFieldTSType.Boolean && Value !== null && Value !== undefined) {
+            else if (field.EntityFieldInfo.TSType === EntityFieldTSType.Boolean && Value !== null && Value !== undefined) {
                 if (typeof Value === 'string') {
                     if (Value.trim() === '1' || Value.trim().toLowerCase() === 'true') {
                         field.Value = true;
@@ -837,14 +964,22 @@ class BaseEntity {
     }
     /**
      * Returns the value of the field with the given name. If the field is a date, and the value is a string, it will be converted to a date object.
+     *
+     * For IS-A child entities, parent fields return the authoritative value from `_parentEntity.Get()`
+     * (recursive for N-level chains), NOT the mirrored value on the child's own Fields array.
+     *
      * @param FieldName
      * @returns
      */
     Get(FieldName) {
+        // IS-A routing: return the authoritative value from the parent entity
+        if (this._parentEntity && this._parentEntityFieldNames?.has(FieldName)) {
+            return this._parentEntity.Get(FieldName); // recursive for N-level chains
+        }
         const field = this.GetFieldByName(FieldName);
         if (field != null) {
             // if the field is a date and the value is a string, convert it to a date
-            if (field.EntityFieldInfo.TSType === entityInfo_1.EntityFieldTSType.Date && (typeof field.Value === 'string' || typeof field.Value === 'number')) {
+            if (field.EntityFieldInfo.TSType === EntityFieldTSType.Date && (typeof field.Value === 'string' || typeof field.Value === 'number')) {
                 field.Value = new Date(field.Value);
             }
             return field.Value;
@@ -855,6 +990,11 @@ class BaseEntity {
      * NOTE: Do not call this method directly. Use the {@link From} method instead
      *
      * Sets any number of values on the entity object from the object passed in. The properties of the object being passed in must either match the field name (in most cases) or the CodeName (which is only different from field name if field name has spaces in it)
+     *
+     * For IS-A child entities, all fields are first set on self (including parent fields as mirrors),
+     * then parent fields are extracted and forwarded to `_parentEntity.SetMany()` for authoritative
+     * state, including proper OldValue tracking via the replaceOldValues parameter.
+     *
      * @param object
      * @param ignoreNonExistentFields - if set to true, fields that don't exist on the entity object will be ignored, if false, an error will be thrown if a field doesn't exist
      * @param replaceOldValues - if set to true, the old values of the fields will be reset to the values provided in the object parameter, if false, they will be left alone
@@ -871,7 +1011,8 @@ class BaseEntity {
                 if (ignoreActiveStatusAssertions) {
                     field.ActiveStatusAssertions = false; // disable active status assertions for this field
                 }
-                this.Set(key, object[key]);
+                // Use SetLocal here so we set on OUR fields (mirrors for parent fields)
+                this.SetLocal(key, object[key]);
                 if (replaceOldValues) {
                     field.ResetOldValue();
                 }
@@ -888,7 +1029,8 @@ class BaseEntity {
                     if (ignoreActiveStatusAssertions) {
                         field.ActiveStatusAssertions = false; // disable active status assertions for this field
                     }
-                    this.Set(field.Name, object[key]);
+                    // Use SetLocal here so we set on OUR fields (mirrors for parent fields)
+                    this.SetLocal(field.Name, object[key]);
                     if (replaceOldValues) {
                         field.ResetOldValue();
                     }
@@ -897,16 +1039,56 @@ class BaseEntity {
                     }
                 }
                 else {
+                    // IS-A routing: parent fields may not have local mirrors (virtual EntityField records)
+                    // yet — they'll be handled by the IS-A routing block below, so skip the error/warning
+                    if (this._parentEntityFieldNames?.has(key)) {
+                        continue; // parent field — will be forwarded to _parentEntity below
+                    }
                     // if we get here, we have a field that doesn't match either the field name or the code name, so throw an error
                     if (!ignoreNonExistentFields)
                         throw new Error(`Field ${key} does not exist on ${this.EntityInfo.Name}`);
                     else {
                         // Record field-not-found warning - will be batched and displayed after debounce period
-                        global_1.WarningManager.Instance.RecordFieldNotFoundWarning(this.EntityInfo.Name, key, 'BaseEntity::SetMany');
+                        WarningManager.Instance.RecordFieldNotFoundWarning(this.EntityInfo.Name, key, 'BaseEntity::SetMany');
                     }
                 }
             }
         }
+        // IS-A routing: forward parent fields to _parentEntity for authoritative state
+        // This ensures proper OldValue tracking and dirty flags on the parent entity
+        if (this._parentEntity && this._parentEntityFieldNames) {
+            const parentData = {};
+            for (const key of Object.keys(object)) {
+                if (this._parentEntityFieldNames.has(key)) {
+                    parentData[key] = object[key];
+                }
+            }
+            if (Object.keys(parentData).length > 0) {
+                this._parentEntity.SetMany(parentData, true, replaceOldValues, ignoreActiveStatusAssertions);
+            }
+        }
+        // When replaceOldValues is true, this is a load operation (not a user edit).
+        // If all primary keys are set, mark the entity as a saved record. This is critical
+        // for IS-A parent entities whose data is populated via SetMany routing from the child's
+        // load — without this, the parent would think it's a new record and attempt CREATE
+        // instead of UPDATE on save.
+        if (replaceOldValues) {
+            this.UpdateSavedStateFromPrimaryKeys();
+        }
+    }
+    /**
+     * Checks if all primary key fields have values set, and if so, marks the entity as
+     * a saved/loaded record. This enables entities populated via SetMany (e.g., IS-A parent
+     * entities) to correctly recognize themselves as existing records.
+     */
+    UpdateSavedStateFromPrimaryKeys() {
+        if (!this.PrimaryKeys || this.PrimaryKeys.length === 0)
+            return;
+        const allPKsSet = this.PrimaryKeys.every(pk => pk.Value !== null && pk.Value !== undefined);
+        if (allPKsSet) {
+            this._recordLoaded = true;
+            this._everSaved = true;
+        }
     }
     /**
      * NOTE: Do not call this method directly. Use the {@link To} method instead
@@ -924,12 +1106,19 @@ class BaseEntity {
                 const tempStatus = field.ActiveStatusAssertions; // save the current active status assertions
                 field.ActiveStatusAssertions = false; // disable active status assertions for this field
                 obj[field.Name] = oldValues ? field.OldValue : field.Value;
-                if (field.EntityFieldInfo.TSType == entityInfo_1.EntityFieldTSType.Date && obj[field.Name] && !(obj[field.Name] instanceof Date)) {
+                if (field.EntityFieldInfo.TSType == EntityFieldTSType.Date && obj[field.Name] && !(obj[field.Name] instanceof Date)) {
                     obj[field.Name] = new Date(obj[field.Name]); // a timestamp, convert to JS Date Object
                 }
                 field.ActiveStatusAssertions = tempStatus; // restore the prior status for assertions
             }
         }
+        // IS-A composition: merge parent entity data with own data
+        // Parent data goes first, own fields override (for shared PK 'ID')
+        // Parent's GetAll() recursively collects from its own parent for N-level chains
+        if (this._parentEntity) {
+            const parentData = this._parentEntity.GetAll(oldValues, onlyDirtyFields);
+            return { ...parentData, ...obj };
+        }
         return obj;
     }
     /**
@@ -1009,8 +1198,8 @@ class BaseEntity {
     }
     async GetRelatedEntityDataExt(re, filter = null, maxRecords = null) {
         // we need to query the database to get related entity info
-        const params = entityInfo_1.EntityInfo.BuildRelationshipViewParams(this, re, filter, maxRecords);
-        const rv = new runView_1.RunView();
+        const params = EntityInfo.BuildRelationshipViewParams(this, re, filter, maxRecords);
+        const rv = new RunView();
         const result = await rv.RunView(params, this._contextCurrentUser);
         if (result && result.Success) {
             return {
@@ -1030,7 +1219,7 @@ class BaseEntity {
             for (const rawField of this.EntityInfo.Fields) {
                 const key = this.EntityInfo.Name + '.' + rawField.Name;
                 // support for sub-classes of the EntityField class
-                const newField = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(EntityField, key, rawField);
+                const newField = MJGlobal.Instance.ClassFactory.CreateInstance(EntityField, key, rawField);
                 this.Fields.push(newField);
             }
         }
@@ -1059,7 +1248,7 @@ class BaseEntity {
             return true;
         }
         catch (e) {
-            (0, logging_1.LogError)(`Error in BaseEntity.CopyFrom: ${e}`);
+            LogError(`Error in BaseEntity.CopyFrom: ${e}`);
             return false;
         }
     }
@@ -1090,7 +1279,7 @@ class BaseEntity {
                 pk.Type.toLowerCase().trim() === 'uniqueidentifier' &&
                 !this.Get(pk.Name)) {
                 // Generate and set UUID for this primary key
-                const uuid = (0, global_1.uuidv4)();
+                const uuid = uuidv4();
                 this.Set(pk.Name, uuid);
                 const field = this.GetFieldByName(pk.Name);
                 if (field) {
@@ -1104,6 +1293,18 @@ class BaseEntity {
                 this.Set(kv.FieldName, kv.Value);
             });
         }
+        // IS-A composition: propagate PK value to parent entity chain
+        // Parent needs NewRecord() called first, then share the same PK value
+        if (this._parentEntity) {
+            this._parentEntity.NewRecord();
+            // Propagate PK — child and parent must share the same UUID
+            for (const pk of this.EntityInfo.PrimaryKeys) {
+                const pkValue = this.Get(pk.Name);
+                if (pkValue != null) {
+                    this._parentEntity.Set(pk.Name, pkValue);
+                }
+            }
+        }
         this.RaiseEvent('new_record', null);
         return true;
     }
@@ -1120,17 +1321,17 @@ class BaseEntity {
     async Save(options) {
         // If a save is already in progress, return its promise.
         if (this._pendingSave$) {
-            return (0, rxjs_1.firstValueFrom)(this._pendingSave$);
+            return firstValueFrom(this._pendingSave$);
         }
         // Create a new observable that debounces duplicative calls, and executes the save.
-        this._pendingSave$ = (0, rxjs_1.of)(options).pipe(
+        this._pendingSave$ = of(options).pipe(
         // Execute the actual save logic.
-        (0, rxjs_1.switchMap)(opts => (0, rxjs_1.from)(this._InnerSave(opts))), 
+        switchMap(opts => from(this._InnerSave(opts))), 
         // When the save completes (whether successfully or not), clear the pending save observable.
-        (0, rxjs_1.finalize)(() => { this._pendingSave$ = null; }), 
+        finalize(() => { this._pendingSave$ = null; }), 
         // Ensure that all subscribers get the same result.
-        (0, rxjs_1.shareReplay)(1));
-        return (0, rxjs_1.firstValueFrom)(this._pendingSave$);
+        shareReplay(1));
+        return firstValueFrom(this._pendingSave$);
     }
     /**
      * Private, internal method to handle saving the current state of the object to the database. This method is called by the public facing Save() method
@@ -1143,10 +1344,45 @@ class BaseEntity {
         const newResult = new BaseEntityResult();
         newResult.StartedAt = new Date();
         try {
-            const _options = options ? options : new interfaces_1.EntitySaveOptions();
-            const type = this.IsSaved ? entityInfo_1.EntityPermissionType.Update : entityInfo_1.EntityPermissionType.Create;
+            const _options = options ? options : new EntitySaveOptions();
+            // IS-A orchestration: determine if this is the initiating save in a parent chain
+            const isISAInitiator = (!!this._parentEntity) && !_options.IsParentEntitySave;
+            // Begin provider transaction if IS-A initiator and NOT in a TransactionGroup
+            // TransactionGroup manages its own atomicity; IS-A just orchestrates save order within it
+            if (isISAInitiator && !this.TransactionGroup) {
+                const txn = await this.ProviderToUse?.BeginISATransaction?.();
+                if (txn) {
+                    this.ProviderTransaction = txn;
+                    this.PropagateTransactionToParents();
+                }
+            }
+            // Save parent chain first (root → branch → immediate parent)
+            // Parent calls Save() recursively which handles its own parents, permissions, validation
+            if (this._parentEntity) {
+                const parentSaveOptions = new EntitySaveOptions();
+                parentSaveOptions.IgnoreDirtyState = _options.IgnoreDirtyState;
+                parentSaveOptions.SkipEntityAIActions = _options.SkipEntityAIActions;
+                parentSaveOptions.SkipEntityActions = _options.SkipEntityActions;
+                parentSaveOptions.ReplayOnly = _options.ReplayOnly;
+                parentSaveOptions.SkipOldValuesCheck = _options.SkipOldValuesCheck;
+                parentSaveOptions.SkipAsyncValidation = _options.SkipAsyncValidation;
+                parentSaveOptions.IsParentEntitySave = true;
+                const parentResult = await this._parentEntity.Save(parentSaveOptions); // we know parent entity exists hre 
+                if (!parentResult) {
+                    // Parent save failed — rollback if we started the transaction
+                    await this.RollbackISATransaction(isISAInitiator);
+                    return false;
+                }
+            }
+            const type = this.IsSaved ? EntityPermissionType.Update : EntityPermissionType.Create;
             const saveSubType = this.IsSaved ? 'update' : 'create';
             this.CheckPermissions(type, true); // this will throw an error and exit out if we don't have permission
+            // IS-A disjoint subtype enforcement: on CREATE, ensure parent record
+            // isn't already claimed by another child type (e.g., can't create Meeting
+            // if a Publication already exists with the same Product ID)
+            if (!this.IsSaved && this.EntityInfo.IsChildType && !_options.ReplayOnly) {
+                await this.EnforceDisjointSubtype();
+            }
             if (_options.IgnoreDirtyState || this.Dirty || _options.ReplayOnly) {
                 // Raise save_started event only when we're actually going to save
                 this.RaiseEvent('save_started', null, saveSubType);
@@ -1154,7 +1390,7 @@ class BaseEntity {
                     throw new Error('No provider set');
                 }
                 else {
-                    let valResult = new entityInfo_1.ValidationResult();
+                    let valResult = new ValidationResult();
                     if (_options.ReplayOnly) {
                         valResult.Success = true; // bypassing validation since we are in replay only....
                     }
@@ -1183,12 +1419,18 @@ class BaseEntity {
                         const data = await this.ProviderToUse.Save(this, this.ActiveUser, _options);
                         if (!this.TransactionGroup) {
                             // no transaction group, so we have our results here
-                            return this.finalizeSave(data, saveSubType);
+                            const result = this.finalizeSave(data, saveSubType);
+                            // IS-A: commit transaction after successful save (only the initiator commits)
+                            if (isISAInitiator && this.ProviderTransaction) {
+                                await this.ProviderToUse.CommitISATransaction?.(this.ProviderTransaction);
+                                this.ProviderTransaction = null;
+                            }
+                            return result;
                         }
                         else {
                             // we are part of a transaction group, so we return true and subscribe to the transaction groups' events and do the finalization work then
                             this.TransactionGroup.TransactionNotifications$.subscribe(({ success, results, error }) => {
-                                if (success) {
+                                if (success && results) {
                                     const transItem = results.find(r => r.Transaction.BaseEntity === this);
                                     if (transItem) {
                                         this.finalizeSave(transItem.Result, saveSubType); // we get the resulting data from the transaction result, not data above as that will be blank when in a TG
@@ -1214,6 +1456,9 @@ class BaseEntity {
                 return true; // nothing to save since we're not dirty
         }
         catch (e) {
+            // IS-A: rollback transaction on failure (only the initiator rolls back)
+            const isISAInitiator = this._parentEntity != null && !options?.IsParentEntitySave;
+            await this.RollbackISATransaction(isISAInitiator);
             if (currentResultCount === this.ResultHistory.length) {
                 // this means that NO new results were added to the history anywhere
                 // so we need to add a new result to the history here
@@ -1228,6 +1473,21 @@ class BaseEntity {
             return false;
         }
     }
+    /**
+     * Helper to rollback an IS-A provider transaction if one is active.
+     * Only called by the IS-A initiator (the leaf entity that started the chain).
+     */
+    async RollbackISATransaction(isInitiator) {
+        if (isInitiator && this.ProviderTransaction) {
+            try {
+                await this.ProviderToUse?.RollbackISATransaction?.(this.ProviderTransaction);
+            }
+            catch (rollbackError) {
+                LogError(`Error rolling back IS-A transaction: ${rollbackError}`);
+            }
+            this.ProviderTransaction = null;
+        }
+    }
     finalizeSave(data, saveSubType) {
         if (data) {
             this.init(); // wipe out the current data to flush out the DIRTY flags, load the ID as part of this too
@@ -1236,6 +1496,8 @@ class BaseEntity {
             const result = this.LatestResult;
             if (result)
                 result.NewValues = this.Fields.map(f => { return { FieldName: f.CodeName, Value: f.Value }; }); // set the latest values here
+            // Cache the record name for faster lookups (updates cache with potentially new name)
+            this.CacheRecordName();
             this.RaiseEvent('save', null, saveSubType);
             return true;
         }
@@ -1247,7 +1509,24 @@ class BaseEntity {
      * Internal helper method for the class and sub-classes - used to easily get the Active User which is either the ContextCurrentUser, if defined, or the Metadata.Provider.CurrentUser if not.
      */
     get ActiveUser() {
-        return this.ContextCurrentUser || metadata_1.Metadata.Provider.CurrentUser; // use the context user ahead of the Provider.Current User - this is for SERVER side ops where the user changes per request
+        return this.ContextCurrentUser || Metadata.Provider.CurrentUser; // use the context user ahead of the Provider.Current User - this is for SERVER side ops where the user changes per request
+    }
+    /**
+     * Caches the entity record name in the provider's EntityRecordNameCache for faster lookups.
+     * Called automatically after successful Load(), LoadFromData(), and Save() operations.
+     */
+    CacheRecordName() {
+        // Only cache if we have a valid primary key
+        if (!this.PrimaryKey || !this.PrimaryKey.HasValue) {
+            return;
+        }
+        // Get the record name
+        const recordName = this.GetRecordName();
+        if (!recordName) {
+            return;
+        }
+        // Cache it via the provider's public API
+        Metadata.Provider.SetCachedRecordName(this.EntityInfo.Name, this.PrimaryKey, recordName);
     }
     /**
      * Utility method that returns true if the given permission being checked is enabled for the current user, and false if not.
@@ -1259,9 +1538,20 @@ class BaseEntity {
         const u = this.ActiveUser;
         if (!u)
             throw new Error('No user set - either the context user for the entity object must be set, or the Metadata.Provider.CurrentUser must be set');
+        // Virtual entities are read-only — block Create, Update, Delete at the ORM level
+        // This catches server-side code calling .Save()/.Delete() directly, which bypasses the API layer flags
+        if (this.EntityInfo.VirtualEntity &&
+            (type === EntityPermissionType.Create ||
+                type === EntityPermissionType.Update ||
+                type === EntityPermissionType.Delete)) {
+            const msg = `Cannot ${type} on virtual entity '${this.EntityInfo.Name}' — virtual entities are read-only`;
+            if (throwError)
+                throw new Error(msg);
+            return false;
+        }
         // first check if the AllowCreateAPI/AllowUpdateAPI/AllowDeleteAPI settings are flipped on for the entity in question
         switch (type) {
-            case entityInfo_1.EntityPermissionType.Create:
+            case EntityPermissionType.Create:
                 if (!this.EntityInfo.AllowCreateAPI) {
                     if (throwError)
                         throw new Error(`Create API is disabled for ${this.EntityInfo.Name}`);
@@ -1269,7 +1559,7 @@ class BaseEntity {
                         return false;
                 }
                 break;
-            case entityInfo_1.EntityPermissionType.Update:
+            case EntityPermissionType.Update:
                 if (!this.EntityInfo.AllowUpdateAPI) {
                     if (throwError)
                         throw new Error(`Update API is disabled for ${this.EntityInfo.Name}`);
@@ -1277,7 +1567,7 @@ class BaseEntity {
                         return false;
                 }
                 break;
-            case entityInfo_1.EntityPermissionType.Delete:
+            case EntityPermissionType.Delete:
                 if (!this.EntityInfo.AllowDeleteAPI) {
                     if (throwError)
                         throw new Error(`Delete API is disabled for ${this.EntityInfo.Name}`);
@@ -1285,7 +1575,7 @@ class BaseEntity {
                         return false;
                 }
                 break;
-            case entityInfo_1.EntityPermissionType.Read:
+            case EntityPermissionType.Read:
                 if (!this.EntityInfo.IncludeInAPI) {
                     if (throwError)
                         throw new Error(`API is disabled for ${this.EntityInfo.Name}`);
@@ -1297,16 +1587,16 @@ class BaseEntity {
         const permissions = this.EntityInfo.GetUserPermisions(u);
         let bAllowed = false;
         switch (type) {
-            case entityInfo_1.EntityPermissionType.Create:
+            case EntityPermissionType.Create:
                 bAllowed = permissions.CanCreate;
                 break;
-            case entityInfo_1.EntityPermissionType.Read:
+            case EntityPermissionType.Read:
                 bAllowed = permissions.CanRead;
                 break;
-            case entityInfo_1.EntityPermissionType.Update:
+            case EntityPermissionType.Update:
                 bAllowed = permissions.CanUpdate;
                 break;
-            case entityInfo_1.EntityPermissionType.Delete:
+            case EntityPermissionType.Delete:
                 bAllowed = permissions.CanDelete;
                 break;
         }
@@ -1318,7 +1608,7 @@ class BaseEntity {
     }
     ThrowPermissionError(u, type, additionalInfoMessage) {
         throw new Error(`User: ${u.Name} (ID: ${u.ID}, Email: ${u.Email})
-                         Does NOT have permission to ${entityInfo_1.EntityPermissionType[type]} ${this.EntityInfo.Name} records.
+                         Does NOT have permission to ${EntityPermissionType[type]} ${this.EntityInfo.Name} records.
                          If you believe this is an error, please contact your system administrator.${additionalInfoMessage ? '\nAdditional Information: ' + additionalInfoMessage : ''}}`);
     }
     /**
@@ -1330,6 +1620,10 @@ class BaseEntity {
             for (let field of this.Fields) {
                 field.Value = field.OldValue;
             }
+            // IS-A composition: revert parent entity chain as well
+            if (this._parentEntity) {
+                this._parentEntity.Revert();
+            }
         }
         return true;
     }
@@ -1349,7 +1643,7 @@ class BaseEntity {
         const valResult = CompositeKey.Validate();
         if (!valResult || !valResult.IsValid)
             throw new Error(`Invalid CompositeKey passed to BaseEntity.Load(${this.EntityInfo.Name}): ${valResult.ErrorMessage}`);
-        this.CheckPermissions(entityInfo_1.EntityPermissionType.Read, true); // this will throw an error and exit out if we don't have permission
+        this.CheckPermissions(EntityPermissionType.Read, true); // this will throw an error and exit out if we don't have permission
         // Set loading state and raise load_started event
         this._isLoading = true;
         this.RaiseEvent('load_started', { CompositeKey });
@@ -1359,9 +1653,16 @@ class BaseEntity {
             }
             const data = await this.ProviderToUse.Load(this, CompositeKey, EntityRelationshipsToLoad, this.ActiveUser);
             if (!data) {
-                (0, logging_1.LogError)(`Error in BaseEntity.Load(${this.EntityInfo.Name}, Key: ${CompositeKey.ToString()}`);
+                LogError(`Error in BaseEntity.Load(${this.EntityInfo.Name}, Key: ${CompositeKey.ToString()}`);
                 return false; // no data loaded, return false
             }
+            // IS-A: hydrate parent chain from loaded data before populating self.
+            // Hydrate resets each parent via init() (giving fresh _NeverSet=true on PK fields)
+            // then populates from data. This must happen before self's SetMany so parents
+            // are in clean state when they receive routed field values.
+            if (this._parentEntity) {
+                this._parentEntity.Hydrate(data);
+            }
             this.SetMany(data, false, true, true); // don't ignore non-existent fields, but DO replace old values
             if (EntityRelationshipsToLoad) {
                 for (let relationship of EntityRelationshipsToLoad) {
@@ -1374,6 +1675,8 @@ class BaseEntity {
             this._recordLoaded = true;
             this._everSaved = true; // Mark as saved since we loaded from database
             this._compositeKey = CompositeKey; // set the composite key to the one we just loaded
+            // Cache the record name for faster lookups
+            this.CacheRecordName();
             // Raise load completion event
             this.RaiseEvent('load_complete', { CompositeKey });
             return true;
@@ -1437,11 +1740,16 @@ class BaseEntity {
      * @returns Promise<boolean> - Returns true if the load was successful
      */
     async LoadFromData(data, _replaceOldValues = false) {
+        // IS-A: hydrate parent chain from data before populating self.
+        // Hydrate resets each parent via init() (giving fresh _NeverSet=true on PK fields)
+        // then populates from data, ensuring correct PK and saved state on parents.
+        if (this._parentEntity) {
+            this._parentEntity.Hydrate(data);
+        }
         this.SetMany(data, true, _replaceOldValues, true); // ignore non-existent fields, but DO replace old values based on the provided param
         // now, check to see if we have the primary key set, if so, we should consider ourselves
         // loaded from the database and set the _recordLoaded flag to true along with the _everSaved flag
         if (this.PrimaryKeys && this.PrimaryKeys.length > 0) {
-            // chck each pkey's value to make sur it is set
             this._recordLoaded = true; // all primary keys are set, so we are loaded
             this._everSaved = true; // Mark as saved since we loaded from data
             for (let pkey of this.PrimaryKeys) {
@@ -1450,10 +1758,14 @@ class BaseEntity {
                     this._everSaved = false; // if any primary key is not set, we cannot consider ourselves loaded
                 }
             }
+            // Cache the record name for faster lookups if successfully loaded
+            if (this._recordLoaded) {
+                this.CacheRecordName();
+            }
         }
         else {
             // this is an error state as every entity must have > 0 primary keys defined
-            (0, logging_1.LogError)(`BaseEntity.LoadFromData() called on ${this.EntityInfo.Name} with no primary keys defined. This is an error state and should not happen.`);
+            LogError(`BaseEntity.LoadFromData() called on ${this.EntityInfo.Name} with no primary keys defined. This is an error state and should not happen.`);
             this._recordLoaded = false;
             this._everSaved = false; // Mark as NOT saved since we loaded from data without primary keys
         }
@@ -1466,9 +1778,21 @@ class BaseEntity {
      * @returns ValidationResult The validation result
      */
     Validate() {
-        const result = new entityInfo_1.ValidationResult();
+        const result = new ValidationResult();
         result.Success = true; // start off with assumption of success, if any field fails, we'll set this to false
+        // IS-A composition: validate parent entity first to collect all chain errors
+        if (this._parentEntity) {
+            const parentResult = this._parentEntity.Validate();
+            if (!parentResult.Success) {
+                result.Success = false;
+                parentResult.Errors.forEach(err => result.Errors.push(err));
+            }
+        }
+        // Validate own fields — for IS-A entities, skip parent field mirrors since
+        // those are validated via _parentEntity above
         for (let field of this.Fields) {
+            if (this._parentEntityFieldNames?.has(field.Name))
+                continue; // skip parent field mirrors — authoritative validation is on _parentEntity
             const err = field.Validate();
             err.Errors.forEach(element => {
                 result.Errors.push(element);
@@ -1507,7 +1831,7 @@ class BaseEntity {
     async ValidateAsync() {
         // Default implementation just returns success
         // Subclasses should override this to perform actual async validation
-        const result = new entityInfo_1.ValidationResult();
+        const result = new ValidationResult();
         result.Success = true;
         return result;
     }
@@ -1522,17 +1846,17 @@ class BaseEntity {
     async Delete(options) {
         // If a delete is already in progress, return its promise.
         if (this._pendingDelete$) {
-            return (0, rxjs_1.firstValueFrom)(this._pendingDelete$);
+            return firstValueFrom(this._pendingDelete$);
         }
         // Create a new observable that debounces duplicative calls, and executes the delete.
-        this._pendingDelete$ = (0, rxjs_1.of)(options).pipe(
+        this._pendingDelete$ = of(options).pipe(
         // Execute the actual delete logic.
-        (0, rxjs_1.switchMap)(opts => (0, rxjs_1.from)(this._InnerDelete(opts))), 
+        switchMap(opts => from(this._InnerDelete(opts))), 
         // When the delete completes (whether successfully or not), clear the pending delete observable.
-        (0, rxjs_1.finalize)(() => { this._pendingDelete$ = null; }), 
+        finalize(() => { this._pendingDelete$ = null; }), 
         // Ensure that all subscribers get the same result.
-        (0, rxjs_1.shareReplay)(1));
-        return (0, rxjs_1.firstValueFrom)(this._pendingDelete$);
+        shareReplay(1));
+        return firstValueFrom(this._pendingDelete$);
     }
     /**
      * Private, internal method to handle deleting a record from the database. This method is called by the public facing Delete() method
@@ -1549,7 +1873,43 @@ class BaseEntity {
                 throw new Error('No provider set');
             }
             else {
-                this.CheckPermissions(entityInfo_1.EntityPermissionType.Delete, true); // this will throw an error and exit out if we don't have permission
+                const _options = options ? options : new EntityDeleteOptions();
+                // IS-A orchestration: determine if this is the initiating delete
+                const hasParentChain = this._parentEntity != null;
+                const isISAInitiator = hasParentChain && !_options.IsParentEntityDelete;
+                // IS-A parent delete protection: prevent deleting a parent record
+                // that has child records — FK constraints require child deletion first.
+                // If CascadeDeletes is enabled, auto-delete child records through the chain.
+                if (this.EntityInfo.IsParentType && !_options.IsParentEntityDelete) {
+                    const childCheck = await this.CheckForChildRecords();
+                    if (childCheck.HasChildren) {
+                        if (this.EntityInfo.CascadeDeletes) {
+                            // CascadeDeletes enabled: auto-delete the child record
+                            // This will recursively cascade through the IS-A chain
+                            const cascadeResult = await this.CascadeDeleteChildRecord(childCheck, _options);
+                            if (!cascadeResult) {
+                                throw new Error(`Cascade delete failed for ${childCheck.ChildEntityName} child record ` +
+                                    `of ${this.EntityInfo.Name} '${this.PrimaryKey.Values()}'.`);
+                            }
+                            // After cascade, proceed with our own delete (parent chain will be handled)
+                        }
+                        else {
+                            throw new Error(`Cannot delete ${this.EntityInfo.Name} record '${this.PrimaryKey.Values()}': ` +
+                                `it is referenced as a ${childCheck.ChildEntityName} record. ` +
+                                `Delete the ${childCheck.ChildEntityName} record first, ` +
+                                `or enable CascadeDeletes on the ${this.EntityInfo.Name} entity.`);
+                        }
+                    }
+                }
+                // Begin provider transaction if IS-A initiator and NOT in a TransactionGroup
+                if (isISAInitiator && !this.TransactionGroup) {
+                    const txn = await this.ProviderToUse?.BeginISATransaction?.();
+                    if (txn) {
+                        this.ProviderTransaction = txn;
+                        this.PropagateTransactionToParents();
+                    }
+                }
+                this.CheckPermissions(EntityPermissionType.Delete, true); // this will throw an error and exit out if we don't have permission
                 // Raise delete_started event before the actual delete operation begins
                 this.RaiseEvent('delete_started', null);
                 // stash the old values for the event
@@ -1561,7 +1921,27 @@ class BaseEntity {
                     includeRelatedEntityData: false,
                     relatedEntityList: null
                 });
-                if (await this.ProviderToUse.Delete(this, options, this.ActiveUser)) {
+                // Delete OWN row first (FK constraint: child must be deleted before parent)
+                if (await this.ProviderToUse.Delete(this, _options, this.ActiveUser)) {
+                    // IS-A: after own delete succeeds, cascade to parent chain
+                    if (hasParentChain) {
+                        const parentDeleteOptions = new EntityDeleteOptions();
+                        parentDeleteOptions.SkipEntityAIActions = _options.SkipEntityAIActions;
+                        parentDeleteOptions.SkipEntityActions = _options.SkipEntityActions;
+                        parentDeleteOptions.ReplayOnly = _options.ReplayOnly;
+                        parentDeleteOptions.IsParentEntityDelete = true;
+                        const parentResult = await this._parentEntity.Delete(parentDeleteOptions);
+                        if (!parentResult) {
+                            // Parent delete failed — rollback if we started the transaction
+                            await this.RollbackISATransaction(isISAInitiator);
+                            return false;
+                        }
+                    }
+                    // IS-A: commit transaction after successful chain delete
+                    if (isISAInitiator && this.ProviderTransaction) {
+                        await this.ProviderToUse.CommitISATransaction?.(this.ProviderTransaction);
+                        this.ProviderTransaction = null;
+                    }
                     if (!this.TransactionGroup) {
                         // NOT part of a transaction - raise event immediately
                         // record deleted correctly
@@ -1592,11 +1972,14 @@ class BaseEntity {
                     }
                     return true;
                 }
-                else // record didn't save, return false, but also don't wipe out the entity like we do if the Delete() worked
+                else // record didn't delete, return false, but also don't wipe out the entity like we do if the Delete() worked
                     return false;
             }
         }
         catch (e) {
+            // IS-A: rollback transaction on failure (only the initiator rolls back)
+            const isISAInitiator = this._parentEntity != null && !options?.IsParentEntityDelete;
+            await this.RollbackISATransaction(isISAInitiator);
             if (currentResultCount === this.ResultHistory.length) {
                 // this means that NO new results were added to the history anywhere
                 // so we need to add a new result to the history here
@@ -1611,6 +1994,155 @@ class BaseEntity {
             return false;
         }
     }
+    /**
+     * Checks if this entity has any child records in IS-A child entity tables.
+     * Used for parent delete protection — a parent record cannot be deleted
+     * while child type records referencing it still exist.
+     * @returns Object with HasChildren flag and the name of the child entity found
+     */
+    async CheckForChildRecords() {
+        const childEntities = this.EntityInfo.ChildEntities;
+        if (childEntities.length === 0) {
+            return { HasChildren: false, ChildEntityName: '' };
+        }
+        // Use RunView to check each child entity for records with our PK
+        const rv = new RunView();
+        const pkValue = this.PrimaryKey.Values();
+        for (const childEntity of childEntities) {
+            const pkField = childEntity.PrimaryKeys[0];
+            if (!pkField)
+                continue;
+            const result = await rv.RunView({
+                EntityName: childEntity.Name,
+                ExtraFilter: `${pkField.Name} = '${pkValue}'`,
+                ResultType: 'simple',
+                Fields: [pkField.Name],
+                MaxRows: 1
+            }, this._contextCurrentUser);
+            if (result && result.Success && result.Results && result.Results.length > 0) {
+                return { HasChildren: true, ChildEntityName: childEntity.Name };
+            }
+        }
+        return { HasChildren: false, ChildEntityName: '' };
+    }
+    /**
+     * Cascade-deletes an IS-A child record when the parent entity has CascadeDeletes enabled.
+     * Loads the child entity, then deletes it through the normal IS-A chain. The child's
+     * delete will cascade further down if it also has children and CascadeDeletes.
+     */
+    async CascadeDeleteChildRecord(childCheck, parentOptions) {
+        const md = new Metadata();
+        const childEntity = await md.GetEntityObject(childCheck.ChildEntityName, this._contextCurrentUser);
+        if (!childEntity)
+            return false;
+        // Load the child record using the same PK as this parent
+        const loaded = await childEntity.InnerLoad(this.PrimaryKey);
+        if (!loaded)
+            return false;
+        // If the child entity itself is a parent with cascade, its delete will
+        // handle its own children recursively through _InnerDelete
+        const deleteOptions = new EntityDeleteOptions();
+        deleteOptions.SkipEntityAIActions = parentOptions.SkipEntityAIActions;
+        deleteOptions.SkipEntityActions = parentOptions.SkipEntityActions;
+        deleteOptions.ReplayOnly = parentOptions.ReplayOnly;
+        // Note: do NOT set IsParentEntityDelete — the child is the chain initiator
+        return childEntity.Delete(deleteOptions);
+    }
+    /**
+     * Resolves the leaf (most-derived) entity type for a given parent entity record.
+     * Walks down the IS-A child hierarchy to find which child type a record belongs to.
+     * Returns the child entity name, or the parent's own name if no children exist.
+     * Useful for polymorphic operations where you have a parent record and need
+     * to know its actual leaf type.
+     *
+     * @param entityName The parent entity name
+     * @param primaryKey The primary key to look up
+     * @param contextUser Optional context user for server-side operations
+     * @returns The leaf entity name and whether it was resolved to a child type
+     */
+    static async ResolveLeafEntity(entityName, primaryKey, contextUser) {
+        const md = new Metadata();
+        const entityInfo = md.Entities.find(e => e.Name === entityName);
+        if (!entityInfo) {
+            return { LeafEntityName: entityName, IsLeaf: true };
+        }
+        return BaseEntity.ResolveLeafEntityRecursive(entityInfo, primaryKey, contextUser);
+    }
+    /**
+     * Internal recursive helper for leaf entity resolution.
+     * Walks down the child hierarchy until no more children are found.
+     */
+    static async ResolveLeafEntityRecursive(entityInfo, primaryKey, contextUser) {
+        const childEntities = entityInfo.ChildEntities;
+        if (childEntities.length === 0) {
+            return { LeafEntityName: entityInfo.Name, IsLeaf: true };
+        }
+        const rv = new RunView();
+        const pkValue = primaryKey.Values();
+        for (const child of childEntities) {
+            const childPK = child.PrimaryKeys[0];
+            if (!childPK)
+                continue;
+            const result = await rv.RunView({
+                EntityName: child.Name,
+                ExtraFilter: `${childPK.Name} = '${pkValue}'`,
+                ResultType: 'simple',
+                Fields: [childPK.Name],
+                MaxRows: 1
+            }, contextUser);
+            if (result?.Success && result.Results?.length > 0) {
+                // Found a child — recurse to see if there's an even more specific leaf
+                return BaseEntity.ResolveLeafEntityRecursive(child, primaryKey, contextUser);
+            }
+        }
+        // No child found — this entity IS the leaf
+        return { LeafEntityName: entityInfo.Name, IsLeaf: true };
+    }
+    /**
+     * Enforces disjoint subtype constraint during IS-A child entity creation.
+     * A parent record can only be ONE child type at a time. Checks all sibling
+     * child types (excluding self) for records with the same PK value.
+     * Throws if a sibling child record is found.
+     *
+     * Only runs on Database providers — client-side (Network/GraphQL) skips this
+     * because the server-side save will perform the check authoritatively.
+     */
+    async EnforceDisjointSubtype() {
+        // Skip on client-side providers — the server will enforce this during its save
+        const md = this.ProviderToUse;
+        if (md.ProviderType !== ProviderType.Database)
+            return;
+        const parentEntityInfo = this.EntityInfo.ParentEntityInfo;
+        if (!parentEntityInfo)
+            return;
+        const siblingChildEntities = parentEntityInfo.ChildEntities.filter(e => e.ID !== this.EntityInfo.ID);
+        if (siblingChildEntities.length === 0)
+            return;
+        const pkValue = this.PrimaryKey.Values();
+        if (!pkValue)
+            return;
+        // Build all sibling queries and execute them in a single batch
+        const rv = new RunView();
+        const validSiblings = siblingChildEntities.filter(s => s.PrimaryKeys[0]);
+        if (validSiblings.length === 0)
+            return;
+        const viewParams = validSiblings.map(sibling => ({
+            EntityName: sibling.Name,
+            ExtraFilter: `${sibling.PrimaryKeys[0].Name} = '${pkValue}'`,
+            ResultType: 'simple',
+            Fields: [sibling.PrimaryKeys[0].Name],
+            MaxRows: 1
+        }));
+        const results = await rv.RunViews(viewParams, this._contextCurrentUser);
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result?.Success && result.Results?.length > 0) {
+                const sibling = validSiblings[i];
+                throw new Error(`Cannot create ${this.EntityInfo.Name} record: ID '${pkValue}' already exists as ${sibling.Name}. ` +
+                    `A ${parentEntityInfo.Name} record can only be one child type at a time.`);
+            }
+        }
+    }
     /**
      * Called before an Action is executed by the AI Engine
      * This is intended to be overriden by subclass as needed, these methods called at the right time by the execution context
@@ -1624,20 +2156,21 @@ class BaseEntity {
     async AfterEntityAIAction(params) {
         return true; // default implementation does nothing
     }
+    static { this._globalProviderKey = 'MJ_BaseEntityProvider'; }
     /**
      * Static property to get/set the IEntityDataProvider that is used by all BaseEntity objects. This is a global setting that is used by all BaseEntity objects. It can be overriden for a given BaseEntity object instance by passing in a provider to the
      * constructor of the BaseEntity object. Typically, a provider will pass itself into BaseEntity objects it creates to create a tight coupling between the provider and the BaseEntity objects it creates. This allows multiple concurrent
      * connections to exist in the same process space without interfering with each other.
      */
     static get Provider() {
-        const g = global_1.MJGlobal.Instance.GetGlobalObjectStore();
+        const g = MJGlobal.Instance.GetGlobalObjectStore();
         if (g)
             return g[BaseEntity._globalProviderKey];
         else
             throw new Error('No global object store, so we cant get the static provider');
     }
     static set Provider(value) {
-        const g = global_1.MJGlobal.Instance.GetGlobalObjectStore();
+        const g = MJGlobal.Instance.GetGlobalObjectStore();
         if (g)
             g[BaseEntity._globalProviderKey] = value;
         else
@@ -1683,7 +2216,7 @@ class BaseEntity {
             if (results) {
                 const changes = [];
                 for (let result of results)
-                    changes.push(new entityInfo_1.RecordChange(result));
+                    changes.push(new RecordChange(result));
                 return changes;
             }
             else
@@ -1704,7 +2237,7 @@ class BaseEntity {
                 return true;
             }
             else {
-                (0, logging_1.LogError)(parseResult.error.flatten());
+                LogError(parseResult.error.flatten());
                 return false;
             }
         }
@@ -1725,7 +2258,7 @@ class BaseEntity {
                 parseResult.data;
             }
             else {
-                (0, logging_1.LogError)(parseResult.error.flatten());
+                LogError(parseResult.error.flatten());
                 return null;
             }
         }
@@ -1846,7 +2379,4 @@ class BaseEntity {
         this._vectors.clear();
     }
 }
-exports.BaseEntity = BaseEntity;
-BaseEntity._baseEventCode = 'BaseEntityEvent';
-BaseEntity._globalProviderKey = 'MJ_BaseEntityProvider';
 //# sourceMappingURL=baseEntity.js.map