nucleus-core-ts 0.9.859 → 0.9.861

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

@@ -64,11 +64,15 @@ export function ConnectionList({ actions, onNewConnection, reloadToken = 0 }) {
     // which is where the editor looks for the record it is editing. Saving
     // triggers a reset, so saving is when the record vanished.
     useEffect(()=>{
-        if (list.settled) publishItems();
+        // And not when it FAILED. `settled` means the request finished, which a
+        // refused one also did — publishing that emptied the store on every
+        // failed refetch and took the record the editor was showing with it.
+        if (list.settled && !list.error) publishItems();
     }, [
         list.items,
         list.total,
-        list.settled
+        list.settled,
+        list.error
     ]);
     useEffect(()=>{
         publishLoading();

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

@@ -77,11 +77,15 @@ export function EndpointList({ sourceId, actions, onNewEndpoint, onSelect, reloa
     // which is where the editor looks for the record it is editing. Saving
     // triggers a reset, so saving is when the record vanished.
     useEffect(()=>{
-        if (list.settled) publishItems();
+        // And not when it FAILED. `settled` means the request finished, which a
+        // refused one also did — publishing that emptied the store on every
+        // failed refetch and took the record the editor was showing with it.
+        if (list.settled && !list.error) publishItems();
     }, [
         list.items,
         list.total,
-        list.settled
+        list.settled,
+        list.error
     ]);
     useEffect(()=>{
         publishLoading();

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

@@ -88,11 +88,15 @@ export function MappingList({ actions, sourceId, selectedId, reloadToken, onSele
     // which is where the editor looks for the record it is editing. Saving
     // triggers a reset, so saving is when the record vanished.
     useEffect(()=>{
-        if (list.settled) publishItems();
+        // And not when it FAILED. `settled` means the request finished, which a
+        // refused one also did — publishing that emptied the store on every
+        // failed refetch and took the record the editor was showing with it.
+        if (list.settled && !list.error) publishItems();
     }, [
         list.items,
         list.total,
-        list.settled
+        list.settled,
+        list.error
     ]);
     useEffect(()=>{
         publishLoading();

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

@@ -31,7 +31,8 @@ export function MappingsTab({ actions }) {
     const [reloadToken, setReloadToken] = useState(0);
     /** Set only when a new mapping is being started for a table named on arrival. */ const [pendingTarget, setPendingTarget] = useState('');
     const sourceId = store.selectedSourceId ?? '';
-    const newMappingEndpointId = store.selectedEndpointId ?? store.endpoints[0]?.id ?? '';
+    const [pickableEndpoints, setPickableEndpoints] = useState([]);
+    const newMappingEndpointId = store.selectedEndpointId ?? pickableEndpoints[0]?.id ?? '';
     const loadTargets = useEffectEvent(()=>{
         setTargetsLoading(true);
         actions.listTargets().then((result)=>{
@@ -53,21 +54,44 @@ export function MappingsTab({ actions }) {
    * and a disabled New mapping — about a connection with three of them. The
    * only way through was to visit the other tab first, which nothing said.
    *
-   * One page is enough to offer a source and to name one; the Endpoints tab
-   * remains the place that pages through them all.
-   */ const loadEndpointsIfMissing = useEffectEvent(()=>{
-        if (sourceId === '' || store.endpoints.length > 0) return;
-        actions.listEndpoints(sourceId, {
-            page: 1,
-            limit: 50
-        }).then((result)=>{
-            store.setEndpoints(result.items, result.meta?.totalItems ?? result.items.length);
-        }).catch((error)=>{
-            store.setError(messageOf(error));
-        });
+   * Its OWN list, not the one the Endpoints step is showing.
+   *
+   * `store.endpoints` holds whatever that step last fetched — including what a
+   * SEARCH narrowed it to. A mapping reads one call, and the picker offering
+   * them was reading that same array: typing "employee" into the endpoints
+   * search left the mapping editor able to choose only the calls matching it,
+   * and `loadEndpointsIfMissing` then declined to fetch because the array was
+   * not empty. Nothing said the list was a filtered one.
+   *
+   * Read to exhaustion rather than one page: a picker that silently stops at
+   * fifty is the same defect one step down.
+   */ const loadPickableEndpoints = useEffectEvent(()=>{
+        if (sourceId === '') {
+            setPickableEndpoints([]);
+            return;
+        }
+        const PAGE = 200;
+        const MAX_PAGES = 20;
+        const read = (page, collected)=>{
+            actions.listEndpoints(sourceId, {
+                page,
+                limit: PAGE
+            }).then((result)=>{
+                const all = collected.concat(result.items);
+                const total = result.meta?.totalItems ?? all.length;
+                if (result.items.length === PAGE && all.length < total && page < MAX_PAGES) {
+                    read(page + 1, all);
+                    return;
+                }
+                setPickableEndpoints(all);
+            }).catch((error)=>{
+                store.setError(messageOf(error));
+            });
+        };
+        read(1, []);
     });
     useEffect(()=>{
-        loadEndpointsIfMissing();
+        loadPickableEndpoints();
     }, [
         sourceId
     ]);
@@ -245,7 +269,7 @@ export function MappingsTab({ actions }) {
                         className: theme.layout.main,
                         children: draft ? /*#__PURE__*/ _jsx(MappingEditor, {
                             deleting: deleting,
-                            endpoints: store.endpoints,
+                            endpoints: pickableEndpoints,
                             freshSample: freshSample,
                             mapping: draft,
                             onCancel: closeEditor,

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

@@ -55,11 +55,15 @@ export function RunHistory({ actions, mappingId, refreshKey, onRefresh }) {
     // reset empties the hook's items before the first page is asked for, and
     // publishing that emptied the shared store.
     useEffect(()=>{
-        if (list.settled) publishRuns();
+        // And not when it FAILED. `settled` means the request finished, which a
+        // refused one also did — publishing that emptied the store on every
+        // failed refetch and took the record the editor was showing with it.
+        if (list.settled && !list.error) publishRuns();
     }, [
         list.items,
         list.total,
-        list.settled
+        list.settled,
+        list.error
     ]);
     useEffect(()=>{
         publishLoading();

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

@@ -44,13 +44,21 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
     const needsPassword = passwordIsNeeded(mapping);
     const passwordReady = !needsPassword || sharedPassword.length >= MIN_SHARED_PASSWORD;
     const activeRunId = store.activeRunId;
-    const plan = store.plan;
+    /**
+   * Only a plan computed for THIS mapping.
+   *
+   * A preview reads a whole source, so it can land long after the operator has
+   * moved on — and it used to land under whatever was selected by then. The
+   * counts an operator reads before pressing Run must describe the mapping they
+   * are looking at.
+   */ const plan = store.planMappingId === mapping.id ? store.plan : null;
     const preview = ()=>{
+        const requestedFor = mapping.id;
         store.setError(null);
         store.setPlanning(true);
-        actions.previewRun(mapping.id).then((result)=>{
+        actions.previewRun(requestedFor).then((result)=>{
             if (result.error) store.setError(result.error);
-            store.setPlan(result.plan);
+            store.setPlan(result.plan, requestedFor);
         }).catch((error)=>{
             store.setPlanning(false);
             store.setError(errorText(error, 'The preview could not be computed.'));

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

@@ -33,6 +33,10 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
             store.sourcesLoading = loading;
         },
     selectSource: (store)=>(id)=>batch(()=>{
+                // Same rule as selectMapping: everything below discards what belonged to
+                // the previous connection, so re-choosing the current one would empty the
+                // step somebody is working in for no reason.
+                if (store.selectedSourceId === id) return;
                 store.selectedSourceId = id;
                 // Everything below a connection belongs to THAT connection. Leaving the
                 // previous one's endpoints on screen under a new name is worse than empty.
@@ -55,6 +59,7 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.sampleEndpointId = null;
                 store.sampling = false;
                 store.plan = null;
+                store.planMappingId = null;
                 store.planning = false;
                 store.activeRunId = null;
                 store.progress = null;
@@ -97,6 +102,9 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
             store.endpointsLoading = loading;
         },
     selectEndpoint: (store)=>(id)=>batch(()=>{
+                // Re-choosing the call already open would throw away the sample just
+                // taken of it — and taking a sample is a real request to somebody's API.
+                if (store.selectedEndpointId === id) return;
                 store.selectedEndpointId = id;
                 // The sample describes ONE endpoint; carrying it over would offer the
                 // wrong field list to the next mapping.
@@ -150,6 +158,7 @@ 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;
+                store.planMappingId = 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.
@@ -177,8 +186,9 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
     setSampling: (store)=>(sampling)=>{
             store.sampling = sampling;
         },
-    setPlan: (store)=>(plan)=>batch(()=>{
+    setPlan: (store)=>(plan, mappingId)=>batch(()=>{
                 store.plan = plan;
+                store.planMappingId = plan ? mappingId : null;
                 store.planning = false;
             }),
     setPlanning: (store)=>(planning)=>{

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

@@ -61,6 +61,17 @@ export type State = {
     sampling: boolean;
     /** What a run would do. Cleared whenever the mapping changes underneath it. */
     plan: RunPlanValue | null;
+    /**
+     * The mapping the plan in hand was computed for.
+     *
+     * A preview reads a whole source and can take a while. Switching mapping
+     * while one is in flight used to land the answer under whatever was selected
+     * when it arrived — so an operator read "880 to create, 3 to skip" about a
+     * mapping that had never been previewed, and pressing Run beside it started
+     * an import against those numbers. Same shape as the endpoint sample, and the
+     * same fix: the answer is tagged, and only its own mapping reads it.
+     */
+    planMappingId: string | null;
     planning: boolean;
     /** Live progress of the run this panel started. */
     progress: RunProgressValue | null;
@@ -129,7 +140,7 @@ export type Actions = {
     setRunsLoading: (loading: boolean) => void;
     setSample: (sample: EndpointSampleValue | null, endpointId: string | null) => void;
     setSampling: (sampling: boolean) => void;
-    setPlan: (plan: RunPlanValue | null) => void;
+    setPlan: (plan: RunPlanValue | null, mappingId: string | null) => void;
     setPlanning: (planning: boolean) => void;
     setProgress: (progress: RunProgressValue | null) => void;
     setActiveRun: (runId: string | null) => void;

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

@@ -24,6 +24,7 @@ export const initial = {
     sampleEndpointId: null,
     sampling: false,
     plan: null,
+    planMappingId: null,
     planning: false,
     progress: null,
     activeRunId: null,