nucleus-core-ts 0.9.849 → 0.9.851

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

@@ -54,11 +54,14 @@ export function ConnectionForm({ actions, source, loading = false, onSaved }) {
                 store.setError('The connection was not saved. The server did not return the record.');
                 return;
             }
+            // Told about the record BEFORE it is selected. The caller is what puts
+            // it into the list, and selecting an id the list does not hold is the
+            // state every card below renders a skeleton for.
+            onSaved?.(saved);
             // Selecting resets everything hanging off a connection, so it is only
             // right for a NEW one — doing it on an edit would empty the endpoint,
             // mapping and run lists the operator is working in.
             if (!source) store.selectSource(saved.id);
-            onSaved?.(saved);
         }).catch((reason)=>{
             setSaving(false);
             store.setError(errorText(reason, 'The connection could not be saved.'));

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

@@ -59,17 +59,31 @@ export function ConnectionList({ actions, onNewConnection, reloadToken = 0 }) {
     const publishLoading = useEffectEvent(()=>{
         store.setSourcesLoading(list.loading);
     });
+    // Only what the SERVER said. A reset empties the hook's items before the
+    // first page is asked for, and publishing that emptied the shared store —
+    // which is where the editor looks for the record it is editing. Saving
+    // triggers a reset, so saving is when the record vanished.
     useEffect(()=>{
-        publishItems();
+        if (list.settled) publishItems();
     }, [
         list.items,
-        list.total
+        list.total,
+        list.settled
     ]);
     useEffect(()=>{
         publishLoading();
     }, [
         list.loading
     ]);
+    // Handed back on the way out. This flag has exactly one writer — this
+    // component — and unmounting mid-request left it true with nobody able to
+    // clear it, so whatever else reads it showed a skeleton for a request that
+    // had already finished.
+    useEffect(()=>{
+        return ()=>{
+            store.setSourcesLoading(false);
+        };
+    }, []);
     const handleNew = ()=>{
         store.selectSource(null);
         onNewConnection?.();

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

@@ -22,27 +22,35 @@ import { CredentialFields } from './CredentialFields';
  */ export function ConnectionSettingsTab({ actions, onSaved, onDeleted }) {
     const store = useIntegrationsStore();
     const source = store.sources.find((candidate)=>candidate.id === store.selectedSourceId) ?? null;
-    // The list holds only the current page, so a connection selected before a
-    // later page loaded may not be in it yet. Saying so beats an empty form that
-    // looks like the record was lost.
-    const missingFromPage = store.selectedSourceId !== null && source === null;
+    /**
+   * Waiting for THIS record, and nothing else.
+   *
+   * It used to be `store.sourcesLoading || missingFromPage`, and sourcesLoading
+   * is true whenever the rail is fetching ANY page — including a page fetched
+   * because somebody typed a letter into the search box. With no connection
+   * chosen this tab is the blank "new connection" form, and every keystroke in
+   * the rail beside it replaced that form with skeletons.
+   *
+   * A form that is not editing a record is never loading: there is nothing to
+   * wait for. A form that IS editing one waits only until that record is here.
+   */ const waitingForRecord = store.selectedSourceId !== null && source === null;
     return /*#__PURE__*/ _jsxs("div", {
         className: theme.layout.main,
         children: [
             /*#__PURE__*/ _jsx(ConnectionForm, {
                 actions: actions,
-                loading: store.sourcesLoading || missingFromPage,
+                loading: waitingForRecord,
                 onSaved: onSaved,
                 source: source
             }),
             /*#__PURE__*/ _jsx(CredentialFields, {
                 actions: actions,
-                loading: store.sourcesLoading || missingFromPage,
+                loading: waitingForRecord,
                 source: source
             }),
             /*#__PURE__*/ _jsx(ConnectionTest, {
                 actions: actions,
-                loading: store.sourcesLoading || missingFromPage,
+                loading: waitingForRecord,
                 source: source
             }),
             /*#__PURE__*/ _jsx(ConnectionDelete, {

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/EndpointList.js

@@ -72,17 +72,31 @@ export function EndpointList({ sourceId, actions, onNewEndpoint, onSelect, reloa
     const publishLoading = useEffectEvent(()=>{
         store.setEndpointsLoading(list.loading);
     });
+    // Only what the SERVER said. A reset empties the hook's items before the
+    // first page is asked for, and publishing that emptied the shared store —
+    // which is where the editor looks for the record it is editing. Saving
+    // triggers a reset, so saving is when the record vanished.
     useEffect(()=>{
-        publishItems();
+        if (list.settled) publishItems();
     }, [
         list.items,
-        list.total
+        list.total,
+        list.settled
     ]);
     useEffect(()=>{
         publishLoading();
     }, [
         list.loading
     ]);
+    // Handed back on the way out. This flag has exactly one writer — this
+    // component — and unmounting mid-request left it true with nobody able to
+    // clear it, so whatever else reads it showed a skeleton for a request that
+    // had already finished.
+    useEffect(()=>{
+        return ()=>{
+            store.setEndpointsLoading(false);
+        };
+    }, []);
     const handleNew = ()=>{
         store.selectEndpoint(null);
         onNewEndpoint?.();

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/MappingList.js

@@ -83,17 +83,31 @@ export function MappingList({ actions, sourceId, selectedId, reloadToken, onSele
     const publishLoading = useEffectEvent(()=>{
         store.setMappingsLoading(list.loading);
     });
+    // Only what the SERVER said. A reset empties the hook's items before the
+    // first page is asked for, and publishing that emptied the shared store —
+    // which is where the editor looks for the record it is editing. Saving
+    // triggers a reset, so saving is when the record vanished.
     useEffect(()=>{
-        publishItems();
+        if (list.settled) publishItems();
     }, [
         list.items,
-        list.total
+        list.total,
+        list.settled
     ]);
     useEffect(()=>{
         publishLoading();
     }, [
         list.loading
     ]);
+    // Handed back on the way out. This flag has exactly one writer — this
+    // component — and unmounting mid-request left it true with nobody able to
+    // clear it, so whatever else reads it showed a skeleton for a request that
+    // had already finished.
+    useEffect(()=>{
+        return ()=>{
+            store.setMappingsLoading(false);
+        };
+    }, []);
     const showSkeleton = list.loading && list.items.length === 0;
     return /*#__PURE__*/ _jsxs("section", {
         className: "flex flex-col gap-3",

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/components/RunHistory.js

@@ -51,17 +51,30 @@ export function RunHistory({ actions, mappingId, refreshKey, onRefresh }) {
     const publishLoading = useEffectEvent(()=>{
         store.setRunsLoading(list.loading);
     });
+    // Only what the SERVER said — see the same guard on the other three lists: a
+    // reset empties the hook's items before the first page is asked for, and
+    // publishing that emptied the shared store.
     useEffect(()=>{
-        publishRuns();
+        if (list.settled) publishRuns();
     }, [
         list.items,
-        list.total
+        list.total,
+        list.settled
     ]);
     useEffect(()=>{
         publishLoading();
     }, [
         list.loading
     ]);
+    // Handed back on the way out. This flag has exactly one writer — this
+    // component — and unmounting mid-request left it true with nobody able to
+    // clear it, so whatever else reads it showed a skeleton for a request that
+    // had already finished.
+    useEffect(()=>{
+        return ()=>{
+            store.setRunsLoading(false);
+        };
+    }, []);
     const firstPagePending = list.loading && list.items.length === 0;
     return /*#__PURE__*/ _jsxs("section", {
         className: theme.card.wrapper,

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

@@ -66,11 +66,16 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
                 setConfirming(true);
                 return;
             }
+            // A refusal ENDS the confirmation. Left standing, the panel kept asking
+            // "are you sure?" about an import the server had already turned down,
+            // and pressing the confirm button again just collected the same refusal.
             if (result.error) {
+                setConfirming(false);
                 store.setError(result.error);
                 return;
             }
             if (!result.runId) {
+                setConfirming(false);
                 store.setError('The import was accepted but no run id came back, so it cannot be tracked.');
                 return;
             }
@@ -80,6 +85,7 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
             store.setActiveRun(result.runId);
         }).catch((error)=>{
             setStarting(false);
+            setConfirming(false);
             store.setError(errorText(error, 'The import could not be started.'));
         });
     };
@@ -120,10 +126,21 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
    */ const pollActiveRun = useEffectEvent(()=>{
         const runId = store.activeRunId;
         if (!runId) return;
-        actions.listRuns({
+        actions// NEWEST first, explicitly. Without a sort the server answers in its own
+        // order — which is the order the rows were written — so from the sixth
+        // import of a mapping onwards the run being watched was not among the
+        // five that came back. The tick below then found nothing, returned, and
+        // left the progress bar running for an import that had already finished.
+        .listRuns({
             mappingId: mapping.id,
             page: 1,
-            limit: 5
+            limit: 5,
+            sort: [
+                {
+                    field: 'createdAt',
+                    direction: 'desc'
+                }
+            ]
         }).then((result)=>{
             if (store.activeRunId !== runId) return;
             const run = result.items.find((item)=>item.id === runId);

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

@@ -33,6 +33,19 @@ export type UseInfiniteListResult<T> = {
      * hook reports the failure and the caller must show it.
      */
     error: string | null;
+    /**
+     * Whether what `items` holds has actually come back from the server.
+     *
+     * A reset empties `items` BEFORE the first page is asked for, and callers
+     * mirror `items` into the shared store — so every refetch published an empty
+     * page, and whatever was reading that store lost the record it was showing.
+     * Saving is what triggers a refetch, which is why saving is when it was seen:
+     * the editor asked the store for the record it had just saved and the store
+     * had been emptied a moment earlier.
+     *
+     * False from a reset until the first page settles, success or failure.
+     */
+    settled: boolean;
     /** Put this on an element after the last row; seeing it asks for the next page. */
     sentinelRef: RefObject<HTMLDivElement | null>;
     reload: () => void;

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

@@ -17,6 +17,7 @@ export function useInfiniteList(options) {
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
     const [reloadToken, setReloadToken] = useState(0);
+    const [settled, setSettled] = useState(false);
     const sentinelRef = useRef(null);
     const nextPageRef = useRef(1);
     const loadedCountRef = useRef(0);
@@ -32,6 +33,7 @@ export function useInfiniteList(options) {
             if (generation !== generationRef.current) return;
             inFlightRef.current = false;
             setLoading(false);
+            setSettled(true);
             setTotal(result.total);
             setItems((previous)=>page === 1 ? result.items : [
                     ...previous,
@@ -47,6 +49,9 @@ export function useInfiniteList(options) {
             if (generation !== generationRef.current) return;
             inFlightRef.current = false;
             setLoading(false);
+            // Settled, even though it failed: the caller must be free to show the
+            // error instead of waiting on a page that is never coming.
+            setSettled(true);
             setError(reason instanceof Error ? reason.message : String(reason));
             // Stop asking. The sentinel stays on screen, so retrying on failure
             // would hammer a broken endpoint for as long as the panel is open;
@@ -67,6 +72,7 @@ export function useInfiniteList(options) {
         setItems([]);
         setTotal(0);
         setLoading(true);
+        setSettled(false);
         setError(null);
         fetchPage(1);
         return ()=>{
@@ -103,6 +109,7 @@ export function useInfiniteList(options) {
         items,
         total,
         loading,
+        settled,
         error,
         sentinelRef,
         reload

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

@@ -39,13 +39,25 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.tab = 'connection';
                 store.endpoints = [];
                 store.endpointsTotal = 0;
-                store.endpointsPage = 1;
                 store.endpointsSearch = '';
                 store.selectedEndpointId = null;
                 store.mappings = [];
                 store.mappingsTotal = 0;
-                store.mappingsPage = 1;
                 store.mappingsSearch = '';
+                // Every WAIT below a connection ends with it too. These are the flags the
+                // cards read to decide between a skeleton and their content, and their
+                // only writers live under the connection being left — so leaving one set
+                // meant the next connection opened onto a skeleton with nothing running.
+                store.endpointsLoading = false;
+                store.mappingsLoading = false;
+                store.runsLoading = false;
+                store.sample = null;
+                store.sampleEndpointId = null;
+                store.sampling = false;
+                store.plan = null;
+                store.planning = false;
+                store.activeRunId = null;
+                store.progress = null;
                 store.selectedMappingId = null;
                 store.runs = [];
                 store.runsTotal = 0;
@@ -89,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
@@ -127,6 +140,10 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 // A plan belongs to the mapping it was computed for. Showing it against a
                 // different one would have an operator approve counts from another import.
                 store.plan = null;
+                // And the WAIT for a plan goes with it. Discarding the plan while leaving
+                // this set put the next mapping's panel on a counting skeleton for a
+                // preview that had been computed for a different mapping and thrown away.
+                store.planning = false;
                 // And so does a RUN, which says something stronger than a plan does: that
                 // this import happened. Seen live — the Ünvanlar run stayed on screen
                 // under a header reading "Writes into locations", for a mapping that had
@@ -142,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.849",
+	"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",