@memberjunction/ng-explorer-core 5.37.0 → 5.38.0

package/dist/lib/shell/components/tabs/tab-container.component.js

@@ -504,21 +504,24 @@ export class TabContainerComponent extends BaseAngularComponent {
         }
         // Get driver class for component lookup
         const driverClass = resourceData.Configuration?.resourceTypeDriverClass || resourceData.ResourceType;
+        // Entity name discriminates between "new record" tabs of different entities (all
+        // have empty ResourceRecordID otherwise). For non-Records resources this is undefined.
+        const cacheDiscriminator = resourceData.Configuration?.Entity;
         // **OPTIMIZATION: Check cache first to reuse existing loaded component**
-        const cached = this.cacheManager.getCachedComponent(driverClass, resourceData.ResourceRecordID || '', activeTab.applicationId);
+        const cached = this.cacheManager.getCachedComponent(driverClass, resourceData.ResourceRecordID || '', activeTab.applicationId, cacheDiscriminator);
         if (cached) {
             // Clean up previous single-resource component (if different)
             this.cleanupSingleResourceComponent();
             // Mark cached component as attached to this tab (it was detached / available for reuse).
             // IMPORTANT: We use markAsAttached here, NOT markAsDetached — the component is being
             // reattached to the DOM and should NOT be eligible for LRU eviction.
-            this.cacheManager.markAsAttached(driverClass, resourceData.ResourceRecordID || '', activeTab.applicationId, activeTab.id);
+            this.cacheManager.markAsAttached(driverClass, resourceData.ResourceRecordID || '', activeTab.applicationId, activeTab.id, cacheDiscriminator);
             // Reattach the cached wrapper element to single-resource container
             cached.wrapperElement.style.height = "100%"; // Ensure full height
             container.appendChild(cached.wrapperElement);
             // Store reference and identity for cleanup/detachment
             this.singleResourceComponentRef = cached.componentRef;
-            this.singleResourceCacheIdentity = { driverClass, recordId: resourceData.ResourceRecordID || '', appId: activeTab.applicationId, tabId: activeTab.id };
+            this.singleResourceCacheIdentity = { driverClass, recordId: resourceData.ResourceRecordID || '', appId: activeTab.applicationId, tabId: activeTab.id, discriminator: cacheDiscriminator };
             // Reconcile the cached component's preserved queryParams with any INCOMING navigation
             // intent already on the tab config (e.g. a Home pin / deep link that targeted a specific
             // conversation via SwitchToApp before we got here).
@@ -592,6 +595,17 @@ export class TabContainerComponent extends BaseAngularComponent {
                 }
             }
         };
+        // When a record is saved, re-key the tab and cache (new-record → saved transition)
+        // and refresh the tab title to reflect the entity's current display name.
+        instance.ResourceRecordSavedEvent = (entity) => {
+            this.handleResourceRecordSaved(driverClass, activeTab.applicationId, activeTab.id, instance, entity);
+        };
+        // Resource asked to be closed (e.g., user discarded a brand-new record — there's
+        // no actual record to view, so leaving the tab open serves no purpose and would
+        // also poison the cache for the next "Create New" click of the same entity).
+        instance.ResourceCloseRequestedEvent = () => {
+            this.handleResourceCloseRequested(activeTab.id, instance);
+        };
         // Get the native element and append to container
         const nativeElement = componentRef.hostView.rootNodes[0];
         container.appendChild(nativeElement);
@@ -605,7 +619,7 @@ export class TabContainerComponent extends BaseAngularComponent {
         this.cacheManager.cacheComponent(componentRef, wrapperElement, resourceData, activeTab.id);
         // Store reference and identity for cleanup/detachment
         this.singleResourceComponentRef = componentRef;
-        this.singleResourceCacheIdentity = { driverClass, recordId: resourceData.ResourceRecordID || '', appId: activeTab.applicationId, tabId: activeTab.id };
+        this.singleResourceCacheIdentity = { driverClass, recordId: resourceData.ResourceRecordID || '', appId: activeTab.applicationId, tabId: activeTab.id, discriminator: cacheDiscriminator };
     }
     /**
      * Clean up single-resource mode component
@@ -654,9 +668,9 @@ export class TabContainerComponent extends BaseAngularComponent {
     cleanupSingleResourceComponent() {
         if (this.singleResourceComponentRef) {
             if (this.singleResourceCacheIdentity) {
-                const { driverClass, recordId, appId } = this.singleResourceCacheIdentity;
+                const { driverClass, recordId, appId, discriminator } = this.singleResourceCacheIdentity;
                 // Mark as DETACHED by resource identity — the ONE consistent key used everywhere.
-                this.cacheManager.markAsDetached(driverClass, recordId, appId);
+                this.cacheManager.markAsDetached(driverClass, recordId, appId, discriminator);
             }
             this.singleResourceComponentRef = null;
             this.singleResourceCacheIdentity = null;
@@ -671,6 +685,162 @@ export class TabContainerComponent extends BaseAngularComponent {
             }
         }
     }
+    /**
+     * Handle a record-saved event from a hosted resource component.
+     *
+     * Does two things on every save:
+     *
+     * 1. **Re-key new-record tabs.** When a tab opened as "Create New Record" (empty
+     *    `resourceRecordId`) transitions to a saved record, we update both the workspace
+     *    tab's id and the component-cache key to the new PK. Without this, the next
+     *    `OpenNewEntityRecord(<sameEntity>)` would match this tab (both have empty
+     *    `resourceRecordId`) and focus the stale form instead of opening a fresh one.
+     *    For existing records being re-saved, this step is a no-op.
+     *
+     * 2. **Refresh the tab title.** Whether new or existing, the entity's display name
+     *    (typically its `Name` field) may have changed. We call the resource component's
+     *    `GetResourceDisplayName` and push the result to the tab — so a tab that read
+     *    "New Foo Record" before save now reads the actual entered name.
+     */
+    handleResourceRecordSaved(driverClass, appId, tabId, instance, entity) {
+        const tab = this.workspaceManager.GetTab(tabId);
+        if (!tab) {
+            return;
+        }
+        const oldRecordId = tab.resourceRecordId || '';
+        // ToURLSegment, NOT ToString — must match the format NavigationService.OpenEntityRecord
+        // uses and that EntityRecordResource.GetPrimaryKey expects via LoadFromURLSegment.
+        const newRecordId = entity?.PrimaryKey?.ToURLSegment?.() ?? '';
+        const isNewRecordTransition = oldRecordId === '' && !!newRecordId;
+        // The cache entry for an empty-recordId tab was keyed with the entity name as
+        // discriminator (to avoid new-record collisions across entities). Re-key has to
+        // pass that same old discriminator to find the entry. After save the record has
+        // a real PK, so the new key needs no discriminator.
+        const oldDiscriminator = tab.configuration?.['Entity'];
+        if (isNewRecordTransition) {
+            // Re-key the cache entry first, so when the workspace config emission triggers
+            // signature/needsReload checks below, the cache lookup at the new id succeeds.
+            this.cacheManager.rekeyComponent(driverClass, oldRecordId, newRecordId, appId, oldDiscriminator, undefined);
+            // Keep the in-memory single-resource identity in sync so detach uses the correct key.
+            if (this.singleResourceCacheIdentity?.tabId === tabId) {
+                this.singleResourceCacheIdentity = {
+                    ...this.singleResourceCacheIdentity,
+                    recordId: newRecordId,
+                    discriminator: undefined
+                };
+            }
+            // Pre-compute and stamp the new signature so the configuration-subscription path
+            // in single-resource mode doesn't see a "content changed" delta and trigger a
+            // needless reload cycle (which would destroy the currently attached component).
+            if (this.useSingleResourceMode && this.currentSingleResourceSignature !== null) {
+                const updatedTab = {
+                    ...tab,
+                    resourceRecordId: newRecordId,
+                    configuration: { ...tab.configuration, recordId: newRecordId, isNew: undefined }
+                };
+                this.currentSingleResourceSignature = this.getTabContentSignature(updatedTab);
+            }
+            // Propagate the new id to the workspace tab.
+            this.workspaceManager.UpdateTabResourceRecordId(tabId, newRecordId);
+        }
+        // Always refresh the tab title — the entity's display-name field (typically Name)
+        // may have just been set or changed. Done after the rekey so the resource component's
+        // Data.ResourceRecordID reflects the saved PK before GetResourceDisplayName reads it.
+        //
+        // ProviderBase caches GetEntityRecordName results, so a plain call here would return
+        // the pre-edit name. Pre-warm the cache with a forceRefresh so the downstream read
+        // inside GetResourceDisplayName picks up the saved name. Only meaningful for entity
+        // records with a PK; other resource types' GetResourceDisplayName doesn't hit the
+        // record-name cache and will work either way.
+        void this.refreshTabTitleAfterSave(tabId, instance, entity);
+    }
+    /**
+     * After a save, invalidate the entity-record-name cache for the saved record and then
+     * push the resource component's current display name into the tab title.
+     *
+     * Errors are swallowed (logged via the inner call paths) — failing to refresh a tab
+     * title should never break the save flow.
+     */
+    async refreshTabTitleAfterSave(tabId, instance, entity) {
+        try {
+            const entityName = entity?.EntityInfo?.Name;
+            const pk = entity?.PrimaryKey;
+            if (entityName && pk?.HasValue) {
+                // forceRefresh: true overwrites the cached (pre-edit) name with the fresh one.
+                // GetResourceDisplayName (called next) reads the same cache and now sees fresh data.
+                const md = instance.ProviderToUse;
+                await md.GetEntityRecordName(entityName, pk, md.CurrentUser, true);
+            }
+        }
+        catch {
+            // Cache pre-warm failures are non-fatal — the title update below will fall back
+            // to whatever the cache has and the user can still interact with the form.
+        }
+        await this.updateTabTitleFromResource(tabId, instance, instance.Data);
+    }
+    /**
+     * A resource component asked to be dismissed — typically the user clicked Discard
+     * on a brand-new record. Behavior depends on workspace state:
+     *
+     * - **Multi-tab mode (or > 1 tab)**: just close the tab. `WorkspaceStateManager.CloseTab`
+     *   activates the next tab, `syncTabsWithConfiguration` removes the tab from Golden
+     *   Layout, and the user lands on whatever tab was previously active.
+     *
+     * - **Last tab in the workspace**: `CloseTab` intentionally keeps the last tab around
+     *   (just unpins it) so the workspace is never empty — correct for the
+     *   user-clicked-X-button case, wrong here. We want the user OFF this discarded form.
+     *   Workaround: `CloseTab` makes the tab unpinned (= a temp tab), then we open the
+     *   app's default tab via `CreateDefaultTab()` which goes through `OpenTab` and
+     *   replaces the now-temp tab. End result: user lands on the app's home/default view.
+     */
+    async handleResourceCloseRequested(tabId, _instance) {
+        const config = this.workspaceManager.GetConfiguration();
+        const tab = config?.tabs.find(t => t.id === tabId);
+        const isLastTab = config?.tabs.length === 1 && config.tabs[0].id === tabId;
+        // DESTROY (not just detach) the cached component before closing. The default
+        // tab-close path detaches and keeps components alive for reuse — but the
+        // discarded form is exactly what we DON'T want to keep: it holds a stale
+        // BaseEntity in view mode. The next "Create New Record" click for the same
+        // entity would otherwise hit the cache discriminator lookup, find this stale
+        // component, and reattach it — surfacing a blank form in view mode instead
+        // of a fresh edit-mode form. Destroy here forces a cache miss on the next click.
+        if (this.singleResourceCacheIdentity?.tabId === tabId) {
+            // Single-resource mode: the component is tracked via singleResource* fields,
+            // and its cache entry is currently marked attached. Use the identity directly
+            // to destroy it (markAsDetached would clear attachedToTabId and break a
+            // subsequent destroyComponentByTabId lookup).
+            const { driverClass, recordId, appId, discriminator } = this.singleResourceCacheIdentity;
+            this.cacheManager.destroyComponent(driverClass, recordId, appId, discriminator);
+            this.singleResourceComponentRef = null;
+            this.singleResourceCacheIdentity = null;
+            // Clear the host container's DOM so the user isn't briefly looking at the
+            // destroyed component's wrapper between CloseTab and the default-tab load.
+            const directContainer = this.directContentContainer?.nativeElement;
+            if (directContainer) {
+                while (directContainer.firstChild)
+                    directContainer.removeChild(directContainer.firstChild);
+            }
+        }
+        else {
+            // Multi-tab mode: cache entry is keyed by attachedToTabId; the convenience
+            // method handles the lookup.
+            this.cacheManager.destroyComponentByTabId(tabId);
+            this.componentRefs.delete(tabId);
+        }
+        this.workspaceManager.CloseTab(tabId);
+        if (isLastTab && tab) {
+            // CloseTab kept the tab around but unpinned it. Replace it with the app's
+            // default tab so the user lands on a meaningful surface (typically the
+            // home dashboard) instead of staying on the discarded form.
+            const app = this.appManager.GetAppById(tab.applicationId);
+            if (app) {
+                const defaultTabRequest = await app.CreateDefaultTab();
+                if (defaultTabRequest) {
+                    this.workspaceManager.OpenTab(defaultTabRequest, app.GetColor());
+                }
+            }
+        }
+    }
     /**
      * Generate a signature for tab content to detect when content changes
      * This is needed because in single-resource mode, the same tab ID can have different content
@@ -753,13 +923,16 @@ export class TabContainerComponent extends BaseAngularComponent {
             glContainer.element.innerHTML = '';
             // Get driver class for cache lookup (resolves to actual component class name)
             const driverClass = resourceData.Configuration?.resourceTypeDriverClass || resourceData.ResourceType;
+            // Discriminate distinct "new record" tabs of different entities (all have empty
+            // ResourceRecordID otherwise — would silently collide in the cache).
+            const cacheDiscriminator = resourceData.Configuration?.Entity;
             // Check if we have a cached component for this resource
-            const cached = this.cacheManager.getCachedComponent(driverClass, resourceData.ResourceRecordID || '', tab.applicationId);
+            const cached = this.cacheManager.getCachedComponent(driverClass, resourceData.ResourceRecordID || '', tab.applicationId, cacheDiscriminator);
             if (cached) {
                 // Reattach the cached wrapper element
                 glContainer.element.appendChild(cached.wrapperElement);
                 // Mark as attached to this tab
-                this.cacheManager.markAsAttached(driverClass, resourceData.ResourceRecordID || '', tab.applicationId, tabId);
+                this.cacheManager.markAsAttached(driverClass, resourceData.ResourceRecordID || '', tab.applicationId, tabId, cacheDiscriminator);
                 // Keep legacy componentRefs map updated
                 this.componentRefs.set(tabId, cached.componentRef);
                 // If resource is already loaded, update tab title immediately and signal
@@ -802,10 +975,11 @@ export class TabContainerComponent extends BaseAngularComponent {
                 this.emitFirstLoadCompleteOnce();
             };
             instance.ResourceRecordSavedEvent = (entity) => {
-                // Update tab title if needed
-                if (entity && entity.Get && entity.Get('Name')) {
-                    // TODO: Implement UpdateTabTitle in WorkspaceStateManager
-                }
+                this.handleResourceRecordSaved(driverClass, tab.applicationId, tabId, instance, entity);
+            };
+            // Resource asked to be closed (e.g., user discarded a brand-new record).
+            instance.ResourceCloseRequestedEvent = () => {
+                this.handleResourceCloseRequested(tabId, instance);
             };
             // Wire up display name change notifications
             instance.DisplayNameChangedEvent = (newName) => {