nucleus-core-ts 0.9.850 → 0.9.852

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

@@ -0,0 +1,6 @@
+import type { IntegrationSource, IntegrationsActions } from '../types';
+export type ConnectionExportProps = {
+    actions: IntegrationsActions;
+    source: IntegrationSource | null;
+};
+export declare function ConnectionExport({ actions, source }: ConnectionExportProps): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,104 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { useIntegrationsStore } from '../store';
+import { integrationsPageTheme as theme } from '../theme';
+import { Notice } from './Primitives';
+/**
+ * Taking one whole integration somewhere else.
+ *
+ * A connection is the address, the calls it makes, the parameters those calls
+ * take from each other, and the mappings that turn the answers into rows.
+ * Rebuilding that by hand in a second environment is hours of work and a fresh
+ * chance to get one field wrong in a way nobody notices until an import writes
+ * it. So it travels as one file.
+ *
+ * ## Why this is not next to Import
+ *
+ * It was, and it could not be pressed. Both buttons lived in the connection
+ * rail, and Export is only meaningful once a connection is CHOSEN — but
+ * choosing one replaces the rail with the connection's own screens, taking the
+ * button with it. So the button existed, was correct, and was reachable only in
+ * the state where it was disabled.
+ *
+ * Import belongs where there is nothing chosen yet, because that is when you
+ * bring one in. Export belongs here, on the connection being exported.
+ *
+ * The file carries NO credentials — deliberately, and it says so on both sides,
+ * because a connection that arrives looking configured and cannot authenticate
+ * is a confusing half hour otherwise.
+ */ /** A filename somebody can still recognise a week later. */ const fileNameFor = (slug)=>`integration-${slug || 'connection'}.json`;
+export function ConnectionExport({ actions, source }) {
+    const store = useIntegrationsStore();
+    const [busy, setBusy] = useState(false);
+    const [note, setNote] = useState(null);
+    if (!source) return null;
+    const exportOne = ()=>{
+        setBusy(true);
+        setNote(null);
+        store.setError(null);
+        actions.exportConnection(source.id).then((document)=>{
+            setBusy(false);
+            if (!document) {
+                store.setError('The connection could not be exported.');
+                return;
+            }
+            // Written from the browser rather than served as a download, so the file
+            // never travels back through a URL somebody could share by accident.
+            const blob = new Blob([
+                JSON.stringify(document, null, 2)
+            ], {
+                type: 'application/json'
+            });
+            const url = URL.createObjectURL(blob);
+            const link = window.document.createElement('a');
+            link.href = url;
+            link.download = fileNameFor(source.slug);
+            link.click();
+            URL.revokeObjectURL(url);
+            setNote('Exported. Credentials are not in the file — enter them wherever it lands.');
+        }).catch((error)=>{
+            setBusy(false);
+            store.setError(error instanceof Error ? error.message : 'The request failed.');
+        });
+    };
+    return /*#__PURE__*/ _jsxs("section", {
+        className: theme.card.wrapper,
+        children: [
+            /*#__PURE__*/ _jsxs("header", {
+                className: theme.card.header,
+                children: [
+                    /*#__PURE__*/ _jsx("h3", {
+                        className: theme.card.title,
+                        children: "Take this connection elsewhere"
+                    }),
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: busy,
+                        onClick: exportOne,
+                        type: "button",
+                        children: busy ? 'Exporting…' : 'Export'
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.card.body,
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        className: theme.field.hint,
+                        children: "One file holding this connection, its calls and its mappings — enough to rebuild the whole integration in another installation. Bring it in there with Import, on the connections screen."
+                    }),
+                    /*#__PURE__*/ _jsx(Notice, {
+                        title: "No secrets travel in the file",
+                        tone: "info",
+                        children: "Tokens, passwords and keys are left out on purpose. Whatever this connection authenticates with has to be entered again wherever the file lands."
+                    }),
+                    note ? /*#__PURE__*/ _jsx("p", {
+                        className: theme.field.hint,
+                        children: note
+                    }) : null
+                ]
+            })
+        ]
+    });
+}

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

@@ -3,6 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useIntegrationsStore } from '../store';
 import { integrationsPageTheme as theme } from '../theme';
 import { ConnectionDelete } from './ConnectionDelete';
+import { ConnectionExport } from './ConnectionExport';
 import { ConnectionForm } from './ConnectionForm';
 import { ConnectionTest } from './ConnectionTest';
 import { CredentialFields } from './CredentialFields';
@@ -53,6 +54,10 @@ import { CredentialFields } from './CredentialFields';
                 loading: waitingForRecord,
                 source: source
             }),
+            /*#__PURE__*/ _jsx(ConnectionExport, {
+                actions: actions,
+                source: source
+            }),
             /*#__PURE__*/ _jsx(ConnectionDelete, {
                 actions: actions,
                 onDeleted: onDeleted,

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

@@ -6,7 +6,7 @@ import { useIntegrationsStore } from '../store';
 import { integrationsPageTheme } from '../theme';
 import { Notice } from './Primitives';
 /**
- * Taking a whole integration somewhere else, and bringing one back.
+ * Bringing a whole integration in from another installation.
  *
  * A connection is the connection, the calls it makes, the parameters those calls
  * take from each other, and the mappings that turn the answers into rows.
@@ -17,46 +17,20 @@ import { Notice } from './Primitives';
  * The file carries NO credentials — deliberately, and it says so on both sides,
  * because a connection that arrives looking configured and cannot authenticate
  * is a confusing half hour otherwise.
+ *
+ * Export used to sit beside this button and could never be pressed: it needs a
+ * connection to be CHOSEN, and choosing one replaces this rail with that
+ * connection's own screens. It now lives there, on the thing being exported —
+ * see ConnectionExport. Importing is the one that belongs here, because
+ * importing is what you do when you have nothing chosen yet.
  */ const theme = integrationsPageTheme;
 const messageOf = (error)=>error instanceof Error ? error.message : 'The request failed.';
-/** A filename somebody can still recognise a week later. */ const fileNameFor = (slug)=>`integration-${slug || 'connection'}.json`;
 export function ConnectionTransfer({ actions, onImported }) {
     const store = useIntegrationsStore();
     const fileRef = useRef(null);
     const [busy, setBusy] = useState(false);
     const [problems, setProblems] = useState([]);
     const [note, setNote] = useState(null);
-    const selected = store.sources.find((source)=>source.id === store.selectedSourceId);
-    const exportOne = ()=>{
-        if (!selected) return;
-        setBusy(true);
-        setProblems([]);
-        setNote(null);
-        actions.exportConnection(selected.id).then((document)=>{
-            setBusy(false);
-            if (!document) {
-                store.setError('The connection could not be exported.');
-                return;
-            }
-            // Written from the browser rather than served as a download, so the file
-            // never travels back through a URL somebody could share by accident.
-            const blob = new Blob([
-                JSON.stringify(document, null, 2)
-            ], {
-                type: 'application/json'
-            });
-            const url = URL.createObjectURL(blob);
-            const link = window.document.createElement('a');
-            link.href = url;
-            link.download = fileNameFor(selected.slug);
-            link.click();
-            URL.revokeObjectURL(url);
-            setNote('Exported. Credentials are not in the file — enter them wherever it lands.');
-        }).catch((error)=>{
-            setBusy(false);
-            store.setError(messageOf(error));
-        });
-    };
     const importFile = (file)=>{
         setBusy(true);
         setProblems([]);
@@ -97,25 +71,12 @@ export function ConnectionTransfer({ actions, onImported }) {
     return /*#__PURE__*/ _jsxs("section", {
         className: "flex flex-col gap-2",
         children: [
-            /*#__PURE__*/ _jsxs("div", {
-                className: "grid grid-cols-2 gap-2",
-                children: [
-                    /*#__PURE__*/ _jsx("button", {
-                        className: cn(theme.button.secondary, 'w-full justify-center whitespace-nowrap'),
-                        disabled: busy || !selected,
-                        onClick: exportOne,
-                        title: selected ? `Export ${selected.name} — its calls and mappings, without any credential` : 'Choose a connection to export',
-                        type: "button",
-                        children: busy ? 'Working…' : 'Export'
-                    }),
-                    /*#__PURE__*/ _jsx("button", {
-                        className: cn(theme.button.secondary, 'w-full justify-center whitespace-nowrap'),
-                        disabled: busy,
-                        onClick: ()=>fileRef.current?.click(),
-                        type: "button",
-                        children: "Import"
-                    })
-                ]
+            /*#__PURE__*/ _jsx("button", {
+                className: cn(theme.button.secondary, 'w-full justify-center whitespace-nowrap'),
+                disabled: busy,
+                onClick: ()=>fileRef.current?.click(),
+                type: "button",
+                children: busy ? 'Working…' : 'Import a connection file'
             }),
             /*#__PURE__*/ _jsx("input", {
                 accept: "application/json,.json",

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.852",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",