nucleus-core-ts 0.9.850 → 0.9.851

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

@@ -25,10 +25,21 @@ export function ConnectionTest({ actions, source, loading = false }) {
         setResult(null);
         setTesting(false);
     });
-    useEffect(()=>{
+    /**
+   * A verdict describes the settings it was given, not the connection's name.
+   *
+   * Keyed on the id alone, "Reachable" survived editing the base URL and saving:
+   * 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.
+   */ useEffect(()=>{
         clear();
     }, [
-        source?.id
+        source?.id,
+        source?.baseUrl,
+        source?.authType,
+        source?.tokenUrl,
+        source?.tlsVerify
     ]);
     const handleTest = ()=>{
         if (!source) return;

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

@@ -26,7 +26,15 @@ export function EndpointSample({ endpoint, actions }) {
     const selectedRef = useRef(store.selectedEndpointId);
     selectedRef.current = store.selectedEndpointId;
     const params = pathParamNames(endpoint.path);
-    const sample = store.sample;
+    /**
+   * Only a sample taken of THIS call.
+   *
+   * The card is keyed per selection, so switching calls removes it and a request
+   * still in flight settles with nowhere to report to — except the shared slot,
+   * which it writes to regardless. Before the tag, that answer appeared under
+   * whichever call was open when it landed, and the mapping built next took its
+   * field list from a call that had never returned those fields.
+   */ const sample = store.sampleEndpointId === endpoint.id ? store.sample : null;
     let unfilled = 0;
     for (const name of params){
         if (!(values[name] ?? '').trim()) unfilled += 1;
@@ -60,11 +68,11 @@ export function EndpointSample({ endpoint, actions }) {
         store.setError(null);
         actions.sampleEndpoint(requestedFor, params.length > 0 ? values : undefined).then((result)=>{
             if (settleElsewhere(mine, requestedFor)) return;
-            store.setSample(result);
+            store.setSample(result, requestedFor);
             if (!result.ok && result.error) store.setError(result.error);
         }).catch((error)=>{
             if (settleElsewhere(mine, requestedFor)) return;
-            store.setSample(null);
+            store.setSample(null, requestedFor);
             store.setError(error instanceof Error ? error.message : 'Sampling the endpoint failed.');
         });
     };

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

@@ -196,7 +196,10 @@ export function MappingsTab({ actions }) {
     // to and the editor matches it against the mapping's own choice. The editor
     // falls back to the endpoint's STORED sample — which is why the sample is
     // persisted at all, and what a connection revisited tomorrow has.
-    const freshSample = store.selectedEndpointId && store.sample ? {
+    const freshSample = // The tag must match: a field list offered here becomes the mapping, and a
+    // sample left over from another call would name fields the chosen one does
+    // not return.
+    store.selectedEndpointId && store.sample && store.sampleEndpointId === store.selectedEndpointId ? {
         endpointId: store.selectedEndpointId,
         fields: store.sample.fields ?? []
     } : null;

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

@@ -52,6 +52,7 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.mappingsLoading = false;
                 store.runsLoading = false;
                 store.sample = null;
+                store.sampleEndpointId = null;
                 store.sampling = false;
                 store.plan = null;
                 store.planning = false;
@@ -100,6 +101,7 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 // The sample describes ONE endpoint; carrying it over would offer the
                 // wrong field list to the next mapping.
                 store.sample = null;
+                store.sampleEndpointId = null;
                 // And the WAIT for a sample belongs to the endpoint that was left, not to
                 // the one arrived at. Clearing the record without clearing the flag left
                 // the next endpoint showing a skeleton for a request that was never going
@@ -157,8 +159,9 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
     setRunsLoading: (store)=>(loading)=>{
             store.runsLoading = loading;
         },
-    setSample: (store)=>(sample)=>batch(()=>{
+    setSample: (store)=>(sample, endpointId)=>batch(()=>{
                 store.sample = sample;
+                store.sampleEndpointId = sample ? endpointId : null;
                 store.sampling = false;
             }),
     setSampling: (store)=>(sampling)=>{

package/dist/fe/components/IntegrationsPage/store/state.d.ts

@@ -45,6 +45,19 @@ export type State = {
     runsLoading: boolean;
     /** The real shape of the selected endpoint's response, once sampled. */
     sample: EndpointSampleValue | null;
+    /**
+     * The call the sample in hand describes.
+     *
+     * A sample is a field list, and a field list is what the next mapping is built
+     * from — so one written against the wrong call produces a mapping of fields
+     * that call never returns. The card is keyed per selection and therefore
+     * REMOVED when the operator clicks another call, which means a request still
+     * in flight settles into a component that no longer exists and writes to this
+     * shared slot anyway. Tagging is what makes that write harmless: it lands
+     * under the call it was asked for, and whoever is showing a different one
+     * simply does not read it.
+     */
+    sampleEndpointId: string | null;
     sampling: boolean;
     /** What a run would do. Cleared whenever the mapping changes underneath it. */
     plan: RunPlanValue | null;
@@ -114,7 +127,7 @@ export type Actions = {
     selectMapping: (id: string | null) => void;
     setRuns: (items: IntegrationRun[], total: number) => void;
     setRunsLoading: (loading: boolean) => void;
-    setSample: (sample: EndpointSampleValue | null) => void;
+    setSample: (sample: EndpointSampleValue | null, endpointId: string | null) => void;
     setSampling: (sampling: boolean) => void;
     setPlan: (plan: RunPlanValue | null) => void;
     setPlanning: (planning: boolean) => void;

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

@@ -21,6 +21,7 @@ export const initial = {
     runsTotal: 0,
     runsLoading: false,
     sample: null,
+    sampleEndpointId: null,
     sampling: false,
     plan: null,
     planning: false,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.850",
+	"version": "0.9.851",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",