nucleus-core-ts 0.9.846 → 0.9.848

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

@@ -25,6 +25,7 @@ export function ConnectionDelete({ actions, source, onDeleted }) {
             }
             setAsking(false);
             setTyped('');
+            store.removeSource(source.id);
             store.selectSource(null);
             onDeleted?.();
         }).catch((error)=>{

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

@@ -43,7 +43,12 @@ export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect a
    * detail treated the missing record as still loading and sat on skeletons
    * until the page was reloaded by hand. The write itself had succeeded.
    */ const [sourcesReloadToken, setSourcesReloadToken] = useState(0);
-    const handleSourceSaved = ()=>{
+    const handleSourceSaved = (saved)=>{
+        // Into the store FIRST. Bumping the token only tells the rail to refetch,
+        // and choosing a connection unmounts the rail — so on a NEW connection the
+        // token reached nobody and the detail below could not find the record it
+        // had just been switched to.
+        store.upsertSource(saved);
         setSourcesReloadToken((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/store/index.js

@@ -1,12 +1,28 @@
 'use client';
 import { batch, createStore } from 'h-state';
 import { initial } from './state';
+import { isNewTo, upsertInto } from './upsertInto';
 export const { useStore: useIntegrationsStore } = createStore(initial, {
     setSources: (store)=>(items, total)=>batch(()=>{
                 store.sources = items;
                 store.sourcesTotal = total;
                 store.sourcesLoading = false;
             }),
+    upsertSource: (store)=>(source)=>batch(()=>{
+                // The count moves only for an addition — an edit that bumped the total
+                // would make the rail claim a connection nobody can find.
+                if (isNewTo(store.sources, source)) store.sourcesTotal = store.sourcesTotal + 1;
+                store.sources = upsertInto(store.sources, source);
+            }),
+    removeSource: (store)=>(id)=>batch(()=>{
+                const kept = store.sources.filter((candidate)=>candidate.id !== id);
+                // Only when it was actually on this page — the count must not fall for a
+                // record the list never held.
+                if (kept.length !== store.sources.length) {
+                    store.sourcesTotal = Math.max(0, store.sourcesTotal - 1);
+                    store.sources = kept;
+                }
+            }),
     setSourcesSearch: (store)=>(search)=>batch(()=>{
                 store.sourcesSearch = search;
                 // A new search is a new result set; staying on page 4 would show an empty
@@ -50,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;
@@ -68,6 +95,17 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 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

@@ -58,12 +58,35 @@ export type State = {
 export type Actions = {
     [key: string]: unknown;
     setSources: (items: IntegrationSource[], total: number) => void;
+    /**
+     * Put one connection into the list, whether or not it is already there.
+     *
+     * The rail is what fetches connections, and choosing one UNMOUNTS the rail —
+     * so a connection created from the form was selected into a list that had
+     * never heard of it, and every panel below sat on skeletons until the page
+     * was reloaded by hand. The save already returns the record; this is where it
+     * goes so the detail can find it.
+     */
+    upsertSource: (source: IntegrationSource) => void;
+    /** Drop one connection from the list, for when it has just been deleted. */
+    removeSource: (id: string) => void;
     setSourcesSearch: (search: string) => void;
     setSourcesLoading: (loading: boolean) => void;
     selectSource: (id: string | null) => void;
     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.
      *
@@ -74,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/dist/fe/components/IntegrationsPage/store/upsertInto.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Where a saved record goes in a list that may or may not already hold it.
+ *
+ * Kept as a function so the rule can be tested apart from the store: the panel
+ * unmounts the connection rail the moment a connection is chosen, so a newly
+ * created connection is selected into a list that never fetched it. Putting the
+ * returned record in by hand is what stops the detail below from waiting for a
+ * fetch that no mounted component will make.
+ *
+ * A new record goes to the FRONT — it is the one just made, and the operator is
+ * about to be switched to it; an existing one is replaced where it already sits,
+ * so an edit never reorders a list somebody is reading.
+ */
+export declare function upsertInto<T extends {
+    id: string;
+}>(items: T[], record: T): T[];
+/** Whether `record` would be an addition rather than a replacement. */
+export declare function isNewTo<T extends {
+    id: string;
+}>(items: T[], record: T): boolean;

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

@@ -0,0 +1,21 @@
+/**
+ * Where a saved record goes in a list that may or may not already hold it.
+ *
+ * Kept as a function so the rule can be tested apart from the store: the panel
+ * unmounts the connection rail the moment a connection is chosen, so a newly
+ * created connection is selected into a list that never fetched it. Putting the
+ * returned record in by hand is what stops the detail below from waiting for a
+ * fetch that no mounted component will make.
+ *
+ * A new record goes to the FRONT — it is the one just made, and the operator is
+ * about to be switched to it; an existing one is replaced where it already sits,
+ * so an edit never reorders a list somebody is reading.
+ */ export function upsertInto(items, record) {
+    return items.some((candidate)=>candidate.id === record.id) ? items.map((candidate)=>candidate.id === record.id ? record : candidate) : [
+        record,
+        ...items
+    ];
+}
+/** Whether `record` would be an addition rather than a replacement. */ export function isNewTo(items, record) {
+    return !items.some((candidate)=>candidate.id === record.id);
+}

package/dist/fe/components/IntegrationsPage/store/upsertInto.test.d.ts

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

package/dist/fe/components/IntegrationsPage/store/upsertInto.test.js

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'bun:test';
+import { isNewTo, upsertInto } from './upsertInto';
+const a = {
+    id: 'a',
+    name: 'First'
+};
+const b = {
+    id: 'b',
+    name: 'Second'
+};
+describe('upsertInto', ()=>{
+    it('puts a new record at the front', ()=>{
+        expect(upsertInto([
+            a
+        ], b)).toEqual([
+            b,
+            a
+        ]);
+    });
+    it('adds to an empty list', ()=>{
+        expect(upsertInto([], a)).toEqual([
+            a
+        ]);
+    });
+    it('replaces an existing record where it already sits', ()=>{
+        const renamed = {
+            id: 'a',
+            name: 'Renamed'
+        };
+        expect(upsertInto([
+            b,
+            a
+        ], renamed)).toEqual([
+            b,
+            renamed
+        ]);
+    });
+    it('never duplicates — saving the same record twice leaves one', ()=>{
+        const once = upsertInto([], a);
+        expect(upsertInto(once, {
+            id: 'a',
+            name: 'Again'
+        })).toHaveLength(1);
+    });
+    it('leaves the original array untouched', ()=>{
+        const items = [
+            a
+        ];
+        upsertInto(items, b);
+        expect(items).toEqual([
+            a
+        ]);
+    });
+});
+describe('isNewTo', ()=>{
+    it('is true only for a record the list does not hold', ()=>{
+        expect(isNewTo([
+            a
+        ], b)).toBe(true);
+        expect(isNewTo([
+            a
+        ], {
+            id: 'a',
+            name: 'Renamed'
+        })).toBe(false);
+    });
+});

package/package.json

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