nucleus-core-ts 0.9.866 → 0.9.868

package/dist/fe/components/IntegrationsPage/components/ConnectionTest.js

@@ -32,6 +32,13 @@ export function ConnectionTest({ actions, source, loading = false }) {
    * the record object is replaced but its id is not, so this never re-ran and a
    * green badge sat under an address that had never been called. Everything the
    * test actually depends on is in the key.
+   *
+   * A stored CREDENTIAL is such a setting, and it was the one left out. Clearing
+   * a token left the green verdict standing for a connection that would now be
+   * refused; the mirror image costs more of an afternoon — a red "Not reachable"
+   * from a 401 stayed up after the right password was saved, reading as "the
+   * password did not help". The masked hints are what move when a credential
+   * does, so they are what this watches.
    */ useEffect(()=>{
         clear();
     }, [
@@ -39,7 +46,10 @@ export function ConnectionTest({ actions, source, loading = false }) {
         source?.baseUrl,
         source?.authType,
         source?.tokenUrl,
-        source?.tlsVerify
+        source?.tlsVerify,
+        source?.authTokenHint,
+        source?.oauthClientSecretHint,
+        source?.oauthPasswordHint
     ]);
     const handleTest = ()=>{
         if (!source) return;

package/dist/fe/components/IntegrationsPage/components/EndpointSample.js

@@ -69,6 +69,30 @@ export function EndpointSample({ endpoint, actions }) {
         actions.sampleEndpoint(requestedFor, params.length > 0 ? values : undefined).then((result)=>{
             if (settleElsewhere(mine, requestedFor)) return;
             store.setSample(result, requestedFor);
+            /**
+         * The ROW learns it has been tried, not just this card.
+         *
+         * The step strip counts "tried" off `endpoints[].sampleResponse`,
+         * because whether a call has ever been run is a fact about the call and
+         * not about whichever screen is open. The server stores it there. This
+         * panel never did, so a connection whose calls had all been sampled
+         * went on announcing "7 call(s), 0 tried" — seen exactly that way on a
+         * customer's live connection, where it read as "nobody has ever tried
+         * these", which was not true.
+         *
+         * Only a sample that actually returned records counts, which is the
+         * same rule the strip applies.
+         */ if (result.ok && result.recordCount > 0) {
+                const row = store.endpoints.find((candidate)=>candidate.id === requestedFor);
+                if (row) {
+                    store.upsertEndpoint({
+                        ...row,
+                        sampleResponse: {
+                            records: result.sample
+                        }
+                    });
+                }
+            }
             if (!result.ok && result.error) store.setError(result.error);
         }).catch((error)=>{
             if (settleElsewhere(mine, requestedFor)) return;

package/dist/fe/components/IntegrationsPage/components/EndpointsTab.js

@@ -56,9 +56,22 @@ export function EndpointsTab({ actions }) {
         // selecting an id the list has not fetched yet made the whole editor
         // collapse to "pick one" — with the form still half-filled a moment ago.
         store.upsertEndpoint(saved);
-        // Re-selecting drops the old sample: it described the call as it was
-        // configured a moment ago, and the mapping would be built from it.
         store.selectEndpoint(saved.id);
+        /**
+     * The sample described the call as it was BEFORE this save.
+     *
+     * Re-selecting was supposed to drop it, and does not: `selectEndpoint`
+     * returns early when the id has not changed, which on a save it never has —
+     * it is the guard that stops re-choosing the open call from throwing away a
+     * sample somebody just paid a real request for. Correct there, and the
+     * reason nothing was cleared here.
+     *
+     * So the sample sat under an edited call: change `responseRootPath` from
+     * empty to `data`, save, and the card still reports "Status 200, 0 records"
+     * with the old body keys — and the mapping's field list is built from those
+     * keys. The answer on screen belonged to a request that is no longer the one
+     * configured.
+     */ store.setSample(null, null);
         setReloadToken((token)=>token + 1);
     };
     const handleDeleted = (deletedId)=>{

package/dist/fe/components/IntegrationsPage/store/index.js

@@ -93,6 +93,25 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                     store.endpointsTotal = Math.max(0, store.endpointsTotal - 1);
                     store.endpoints = kept;
                 }
+                /**
+       * A mapping cannot outlive the call it reads from.
+       *
+       * The server deletes them — the foreign key cascades — and this list did
+       * not, so the step strip went on counting mappings that no longer existed
+       * and the IMPORT step stayed unlocked by them. Pressing it landed on an
+       * import whose mapping the server had already removed.
+       *
+       * Filtered here rather than at the call site because the store is what
+       * every one of those readings comes from; a caller that forgot would put
+       * the same ghost back.
+       */ const survivors = store.mappings.filter((mapping)=>mapping.endpointId !== id);
+                if (survivors.length !== store.mappings.length) {
+                    store.mappingsTotal = Math.max(0, store.mappingsTotal - (store.mappings.length - survivors.length));
+                    store.mappings = survivors;
+                    if (store.selectedMappingId && !survivors.some((m)=>m.id === store.selectedMappingId)) {
+                        store.selectedMappingId = null;
+                    }
+                }
             }),
     setEndpointsSearch: (store)=>(search)=>batch(()=>{
                 store.endpointsSearch = search;