nucleus-core-ts 0.9.847 → 0.9.849

package/dist/fe/components/IntegrationsPage/components/EndpointForm.d.ts

@@ -5,7 +5,8 @@ export type EndpointFormProps = {
     endpoint: IntegrationEndpoint | null;
     actions: IntegrationsActions;
     onSaved: (endpoint: IntegrationEndpoint) => void;
-    onDeleted: () => void;
+    /** Told WHICH call went, so the list can drop it without waiting for a fetch. */
+    onDeleted: (deletedId: string) => void;
     onCancel: () => void;
 };
 export declare function EndpointForm({ sourceId, endpoint, actions, onSaved, onDeleted, onCancel, }: EndpointFormProps): import("react/jsx-runtime").JSX.Element;

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

@@ -113,7 +113,7 @@ export function EndpointForm({ sourceId, endpoint, actions, onSaved, onDeleted,
         store.setError(null);
         actions.deleteEndpoint(endpoint.id).then((ok)=>{
             setDeleting(false);
-            if (ok) onDeleted();
+            if (ok) onDeleted(endpoint.id);
             else store.setError('The endpoint was not deleted.');
         }).catch(fail('Deleting the endpoint failed.'));
     };

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

@@ -7,6 +7,7 @@ import { integrationsPageTheme } from '../theme';
 import { Badge, CodeBlock, Field, Notice, Stat } from './Primitives';
 import { pathParamNames } from './pathParams';
 import { CardSkeleton, StatGridSkeleton } from './Skeletons';
+import { settlementOf } from './settleOwnership';
 /**
  * One real request, shown in full.
  *
@@ -21,6 +22,7 @@ export function EndpointSample({ endpoint, actions }) {
     const [values, setValues] = useState({});
     // Kept in step with the render so an in-flight reply can ask what is selected
     // NOW, not what was selected when it was sent.
+    const generationRef = useRef(0);
     const selectedRef = useRef(store.selectedEndpointId);
     selectedRef.current = store.selectedEndpointId;
     const params = pathParamNames(endpoint.path);
@@ -29,20 +31,39 @@ export function EndpointSample({ endpoint, actions }) {
     for (const name of params){
         if (!(values[name] ?? '').trim()) unfilled += 1;
     }
+    /**
+   * Discard a late answer, but hand the busy flag back on the way out.
+   *
+   * The discard itself is right — the operator has moved on and the field list
+   * must describe the endpoint they are looking at. It used to be a bare
+   * `return`, which skipped the clearing too: `sampling` stayed set with nobody
+   * left to unset it, and the sample card showed a skeleton until the page was
+   * reloaded. See settleOwnership.ts for who owns the flag.
+   */ const settleElsewhere = (mine, requestedFor)=>{
+        const { discard, releaseFlag } = settlementOf({
+            mine,
+            latest: generationRef.current,
+            requestedFor,
+            selectedNow: selectedRef.current
+        });
+        if (releaseFlag) store.setSampling(false);
+        return discard;
+    };
     const run = ()=>{
         // The endpoint this request is FOR. A sample can take seconds against a slow
         // source, and an operator who clicks another endpoint meanwhile would
         // otherwise get the first one's answer written in as the second one's field
         // list — and then map against fields the endpoint does not have.
         const requestedFor = endpoint.id;
+        const mine = ++generationRef.current;
         store.setSampling(true);
         store.setError(null);
         actions.sampleEndpoint(requestedFor, params.length > 0 ? values : undefined).then((result)=>{
-            if (selectedRef.current !== requestedFor) return;
+            if (settleElsewhere(mine, requestedFor)) return;
             store.setSample(result);
             if (!result.ok && result.error) store.setError(result.error);
         }).catch((error)=>{
-            if (selectedRef.current !== requestedFor) return;
+            if (settleElsewhere(mine, requestedFor)) return;
             store.setSample(null);
             store.setError(error instanceof Error ? error.message : 'Sampling the endpoint failed.');
         });

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

@@ -52,13 +52,18 @@ export function EndpointsTab({ actions }) {
     };
     const handleSaved = (saved)=>{
         setCreating(false);
+        // Into the list FIRST. `editing` is looked up in store.endpoints, so
+        // 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);
         setReloadToken((token)=>token + 1);
     };
-    const handleDeleted = ()=>{
+    const handleDeleted = (deletedId)=>{
         setCreating(false);
+        store.removeEndpoint(deletedId);
         store.selectEndpoint(null);
         setReloadToken((token)=>token + 1);
     };

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

@@ -144,6 +144,11 @@ export function MappingsTab({ actions }) {
             if (!saved) return store.setError('The mapping was not saved.');
             setCreating(false);
             setSelected(saved);
+            // Into the list too, not just local state. The IMPORT step finds its
+            // mapping in store.mappings, and the list that fills it is unmounted
+            // the moment that step is shown — so "Run import" on a mapping saved a
+            // second earlier landed on "choose a mapping".
+            store.upsertMapping(saved);
             store.selectMapping(saved.id);
             setReloadToken((token)=>token + 1);
             then?.(saved);
@@ -178,6 +183,7 @@ export function MappingsTab({ actions }) {
         actions.deleteMapping(id).then((removed)=>{
             setDeleting(false);
             if (!removed) return store.setError('The mapping was not deleted.');
+            store.removeMapping(id);
             closeEditor();
             setReloadToken((token)=>token + 1);
         }).catch((error)=>{

package/dist/fe/components/IntegrationsPage/components/settleOwnership.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Who owns a busy flag when a late answer arrives.
+ *
+ * Every request in this panel sets a shared "in progress" flag on the way in and
+ * clears it on the way out. That breaks the moment an answer is DISCARDED —
+ * because the operator moved on, or because a newer request replaced this one —
+ * since a bare `return` skips the clearing too and the flag stays set with
+ * nobody left to unset it. The panel then shows a skeleton for a request that
+ * has already finished and will never be written.
+ *
+ * Two questions, and they are not the same question:
+ *
+ *   superseded — a NEWER request of the same kind has started. It set the flag
+ *                after this one did and will clear it when it settles, so this
+ *                answer must leave the flag strictly alone.
+ *   movedOn    — the operator is looking at something else. Nobody else is
+ *                coming: this request is the last one out and must clear the
+ *                flag before dropping its answer.
+ */
+export type Settlement = {
+    /** True when this answer must not be written. */
+    discard: boolean;
+    /** True when this request is responsible for clearing the busy flag. */
+    releaseFlag: boolean;
+};
+export declare function settlementOf(args: {
+    /** The generation this request was given when it started. */
+    mine: number;
+    /** The latest generation handed out. */
+    latest: number;
+    /** What this request was for. */
+    requestedFor: string;
+    /** What is selected right now. */
+    selectedNow: string | null;
+}): Settlement;

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

@@ -0,0 +1,30 @@
+/**
+ * Who owns a busy flag when a late answer arrives.
+ *
+ * Every request in this panel sets a shared "in progress" flag on the way in and
+ * clears it on the way out. That breaks the moment an answer is DISCARDED —
+ * because the operator moved on, or because a newer request replaced this one —
+ * since a bare `return` skips the clearing too and the flag stays set with
+ * nobody left to unset it. The panel then shows a skeleton for a request that
+ * has already finished and will never be written.
+ *
+ * Two questions, and they are not the same question:
+ *
+ *   superseded — a NEWER request of the same kind has started. It set the flag
+ *                after this one did and will clear it when it settles, so this
+ *                answer must leave the flag strictly alone.
+ *   movedOn    — the operator is looking at something else. Nobody else is
+ *                coming: this request is the last one out and must clear the
+ *                flag before dropping its answer.
+ */ export function settlementOf(args) {
+    const superseded = args.latest !== args.mine;
+    const movedOn = args.selectedNow !== args.requestedFor;
+    return {
+        discard: superseded || movedOn,
+        // Only the request that still holds the flag may clear it — otherwise a
+        // slow first answer would switch off the light on a second request that is
+        // still running, and the operator would watch a finished-looking panel fill
+        // in by itself a moment later.
+        releaseFlag: !superseded && movedOn
+    };
+}

package/dist/fe/components/IntegrationsPage/components/settleOwnership.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fe/components/IntegrationsPage/components/settleOwnership.test.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'bun:test';
+import { settlementOf } from './settleOwnership';
+const forEndpoint = (over = {})=>settlementOf({
+        mine: 1,
+        latest: 1,
+        requestedFor: 'a',
+        selectedNow: 'a',
+        ...over
+    });
+describe('settlementOf', ()=>{
+    it('writes the answer when nothing has changed', ()=>{
+        expect(forEndpoint()).toEqual({
+            discard: false,
+            releaseFlag: false
+        });
+    });
+    /**
+   * The bug this exists for: the operator clicked another endpoint while a
+   * sample was in flight, the answer was dropped, and the busy flag was left on
+   * with nobody coming to clear it.
+   */ it('drops the answer AND clears the flag when the operator moved on', ()=>{
+        expect(forEndpoint({
+            selectedNow: 'b'
+        })).toEqual({
+            discard: true,
+            releaseFlag: true
+        });
+    });
+    it('leaves the flag alone when a newer request has taken over', ()=>{
+        expect(forEndpoint({
+            latest: 2
+        })).toEqual({
+            discard: true,
+            releaseFlag: false
+        });
+    });
+    it('never clears the flag for a superseded request, even one that also moved on', ()=>{
+        // Both conditions at once: the newer request owns the flag, so this one must
+        // not switch it off while that one is still running.
+        expect(forEndpoint({
+            latest: 2,
+            selectedNow: 'b'
+        })).toEqual({
+            discard: true,
+            releaseFlag: false
+        });
+    });
+    it('treats nothing-selected as having moved on', ()=>{
+        expect(forEndpoint({
+            selectedNow: null
+        })).toEqual({
+            discard: true,
+            releaseFlag: true
+        });
+    });
+});

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

@@ -66,6 +66,17 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.endpointsTotal = total;
                 store.endpointsLoading = false;
             }),
+    upsertEndpoint: (store)=>(endpoint)=>batch(()=>{
+                if (isNewTo(store.endpoints, endpoint)) store.endpointsTotal = store.endpointsTotal + 1;
+                store.endpoints = upsertInto(store.endpoints, endpoint);
+            }),
+    removeEndpoint: (store)=>(id)=>batch(()=>{
+                const kept = store.endpoints.filter((candidate)=>candidate.id !== id);
+                if (kept.length !== store.endpoints.length) {
+                    store.endpointsTotal = Math.max(0, store.endpointsTotal - 1);
+                    store.endpoints = kept;
+                }
+            }),
     setEndpointsSearch: (store)=>(search)=>batch(()=>{
                 store.endpointsSearch = search;
                 store.endpointsPage = 1;
@@ -78,12 +89,29 @@ 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;
+                // 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
+                // to be written — permanently, because the answer, when it came, saw the
+                // selection had moved and returned without touching anything.
+                store.sampling = false;
             }),
     setMappings: (store)=>(items, total)=>batch(()=>{
                 store.mappings = items;
                 store.mappingsTotal = total;
                 store.mappingsLoading = false;
             }),
+    upsertMapping: (store)=>(mapping)=>batch(()=>{
+                if (isNewTo(store.mappings, mapping)) store.mappingsTotal = store.mappingsTotal + 1;
+                store.mappings = upsertInto(store.mappings, mapping);
+            }),
+    removeMapping: (store)=>(id)=>batch(()=>{
+                const kept = store.mappings.filter((candidate)=>candidate.id !== id);
+                if (kept.length !== store.mappings.length) {
+                    store.mappingsTotal = Math.max(0, store.mappingsTotal - 1);
+                    store.mappings = kept;
+                }
+            }),
     setMappingsTotal: (store)=>(total)=>{
             store.mappingsTotal = total;
         },

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

@@ -76,6 +76,17 @@ export type Actions = {
     setTab: (tab: ConnectionTab) => void;
     setFocusTargetEntity: (entity: string | null, step?: 'mapping' | 'import') => void;
     setEndpoints: (items: IntegrationEndpoint[], total: number) => void;
+    /**
+     * Put one call into the list, whether or not it is already there.
+     *
+     * Same reason as [upsertSource]: the list is the only thing that fetches, and
+     * the editor finds the record it is editing BY LOOKING IN THAT LIST. Between
+     * saving and the refetch landing, the record is in neither — so the editor
+     * collapsed to "pick one" and the form the operator was filling in vanished.
+     */
+    upsertEndpoint: (endpoint: IntegrationEndpoint) => void;
+    /** Drop one call from the list, for when it has just been deleted. */
+    removeEndpoint: (id: string) => void;
     /**
      * Just the count, without the rows.
      *
@@ -86,6 +97,17 @@ export type Actions = {
     setEndpointsLoading: (loading: boolean) => void;
     selectEndpoint: (id: string | null) => void;
     setMappings: (items: IntegrationMapping[], total: number) => void;
+    /**
+     * Put one mapping into the list, whether or not it is already there.
+     *
+     * The import step looks the selected mapping up in this array, and the list
+     * that fills it belongs to the MAPPINGS tab — which is unmounted the moment
+     * the import step is shown. Saving a mapping and pressing "Run import" landed
+     * on a screen that said "choose a mapping" about the one just saved.
+     */
+    upsertMapping: (mapping: IntegrationMapping) => void;
+    /** Drop one mapping from the list, for when it has just been deleted. */
+    removeMapping: (id: string) => void;
     setMappingsTotal: (total: number) => void;
     setMappingsSearch: (search: string) => void;
     setMappingsLoading: (loading: boolean) => void;

package/package.json

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