nucleus-core-ts 0.9.793 → 0.9.795

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

@@ -107,6 +107,21 @@ export function FieldMappingRows({ rows, sourceFields, targetFields, disabled, o
                             }),
                             " to take the value from the parent endpoint's record instead of this one."
                         ]
+                    }),
+                    /*#__PURE__*/ _jsxs("p", {
+                        className: theme.field.hint,
+                        children: [
+                            "Name several fields in ",
+                            /*#__PURE__*/ _jsx("strong", {
+                                children: '{braces}'
+                            }),
+                            " to build one value from them —",
+                            ' ',
+                            /*#__PURE__*/ _jsx("strong", {
+                                children: '{companyCode}-{organizationCode}'
+                            }),
+                            ". Use it when no single field is unique on its own, which is what the deduplication column needs."
+                        ]
                     })
                 ]
             })

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

@@ -1,15 +1,30 @@
+import type { IntegrationEndpoint } from '../types';
 import { type MappingDraft, type MappingTarget } from './mappingDraft';
 export type MappingEditorProps = {
     /** Starting values. Read once — remount with a new `key` to load another. */
     mapping: MappingDraft;
     targets: MappingTarget[];
     targetsLoading: boolean;
-    /** Field names the selected endpoint's last sample reported. */
-    sourceFields: string[];
+    /**
+     * The connection's endpoints. A mapping reads from exactly one, and which one
+     * is half of what a mapping IS — so it is chosen here rather than inherited
+     * from whatever happens to be selected on another tab.
+     */
+    endpoints: IntegrationEndpoint[];
+    /**
+     * The sample taken in this session and the endpoint it describes.
+     *
+     * Fresher than the endpoint's stored sample, but only for that one endpoint —
+     * offering it against any other would suggest columns that never arrive.
+     */
+    freshSample: {
+        endpointId: string;
+        fields: string[];
+    } | null;
     saving: boolean;
     deleting: boolean;
     onSave: (draft: MappingDraft) => void;
     onDelete: (id: string) => void;
     onCancel: () => void;
 };
-export declare function MappingEditor({ mapping, targets, targetsLoading, sourceFields, saving, deleting, onSave, onDelete, onCancel, }: MappingEditorProps): import("react/jsx-runtime").JSX.Element;
+export declare function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel, }: MappingEditorProps): import("react/jsx-runtime").JSX.Element;

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

@@ -3,6 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useId, useState } from 'react';
 import { integrationsPageTheme } from '../theme';
 import { FieldMappingRows } from './FieldMappingRows';
+import { endpointLabel, fieldsOfStoredSample } from './formSupport';
 import { MappingWriteModeFields } from './MappingWriteModeFields';
 import { mappingDraftIssues } from './mappingDraft';
 import { Field } from './Primitives';
@@ -17,7 +18,7 @@ import { CardSkeleton } from './Skeletons';
  * Mount it with a `key` of the mapping id so switching rows starts a fresh
  * draft instead of pouring one mapping's edits into another.
  */ const theme = integrationsPageTheme;
-export function MappingEditor({ mapping, targets, targetsLoading, sourceFields, saving, deleting, onSave, onDelete, onCancel }) {
+export function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel }) {
     const uid = useId();
     const [draft, setDraft] = useState(mapping);
     const patch = (next)=>{
@@ -45,6 +46,10 @@ export function MappingEditor({ mapping, targets, targetsLoading, sourceFields,
     const targetFields = targets.find((option)=>option.entity === draft.targetEntity)?.fields ?? [];
     const issues = mappingDraftIssues(draft);
     const busy = saving || deleting;
+    // Follows the endpoint CHOSEN here, so changing it changes the field list
+    // rather than leaving the previous endpoint's names on offer.
+    const readsFrom = endpoints.find((endpoint)=>endpoint.id === draft.endpointId);
+    const sourceFields = freshSample && freshSample.endpointId === draft.endpointId && freshSample.fields.length > 0 ? freshSample.fields : fieldsOfStoredSample(readsFrom?.sampleResponse);
     return /*#__PURE__*/ _jsxs("section", {
         className: theme.card.wrapper,
         children: [
@@ -58,6 +63,30 @@ export function MappingEditor({ mapping, targets, targetsLoading, sourceFields,
             /*#__PURE__*/ _jsxs("div", {
                 className: theme.card.body,
                 children: [
+                    /*#__PURE__*/ _jsx(Field, {
+                        hint: endpoints.length === 0 ? 'This connection has no endpoints yet. Add one on the Endpoints tab.' : readsFrom?.path ?? 'Every mapping reads from exactly one endpoint.',
+                        htmlFor: `${uid}-endpoint`,
+                        label: "Reads from",
+                        children: /*#__PURE__*/ _jsxs("select", {
+                            className: theme.field.input,
+                            disabled: busy || endpoints.length === 0,
+                            id: `${uid}-endpoint`,
+                            onChange: (event)=>patch({
+                                    endpointId: event.target.value
+                                }),
+                            value: draft.endpointId,
+                            children: [
+                                /*#__PURE__*/ _jsx("option", {
+                                    value: "",
+                                    children: "Not set"
+                                }),
+                                endpoints.map((endpoint)=>/*#__PURE__*/ _jsx("option", {
+                                        value: endpoint.id,
+                                        children: endpointLabel(endpoint)
+                                    }, endpoint.id))
+                            ]
+                        })
+                    }),
                     /*#__PURE__*/ _jsxs("div", {
                         className: "grid grid-cols-1 gap-3 sm:grid-cols-2",
                         children: [

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

@@ -3,7 +3,6 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useEffectEvent, useState } from 'react';
 import { useIntegrationsStore } from '../store';
 import { integrationsPageTheme } from '../theme';
-import { fieldsOfStoredSample } from './formSupport';
 import { MappingEditor } from './MappingEditor';
 import { MappingList } from './MappingList';
 import { blankMappingDraft, toMappingDraft } from './mappingDraft';
@@ -114,16 +113,14 @@ export function MappingsTab({ actions }) {
         });
     };
     const draft = creating ? blankMappingDraft(newMappingEndpointId) : selected ? toMappingDraft(selected) : null;
-    // A sample describes ONE endpoint. Offering its field names against a mapping
-    // that reads from a different one would suggest columns that never arrive —
-    // so both the in-session sample and the stored one are matched to the
-    // mapping's OWN endpoint, never to whatever happens to be selected elsewhere.
-    //
-    // The stored sample is the fallback rather than an afterthought: it is why the
-    // sample is persisted at all. Reading only the in-session one meant a
-    // connection revisited tomorrow claimed it had never been sampled.
-    const draftEndpoint = draft ? store.endpoints.find((e)=>e.id === draft.endpointId) : undefined;
-    const sourceFields = draft && store.selectedEndpointId === draft.endpointId && store.sample?.fields?.length ? store.sample.fields : fieldsOfStoredSample(draftEndpoint?.sampleResponse);
+    // A sample describes ONE endpoint, so it travels with the endpoint it belongs
+    // 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 ? {
+        endpointId: store.selectedEndpointId,
+        fields: store.sample.fields ?? []
+    } : null;
     return /*#__PURE__*/ _jsxs("section", {
         className: "flex flex-col gap-4",
         children: [
@@ -147,9 +144,9 @@ export function MappingsTab({ actions }) {
                 ]
             }),
             newMappingEndpointId === '' ? /*#__PURE__*/ _jsx(Notice, {
-                title: "Select an endpoint first",
+                title: "No endpoints to read from",
                 tone: "info",
-                children: "Every mapping reads from one endpoint. Choose one on the Endpoints tab and it becomes the source of the next mapping created here."
+                children: "A mapping turns one endpoint's response into rows, so there has to be an endpoint first. Add one on the Endpoints tab and it becomes selectable here."
             }) : null,
             /*#__PURE__*/ _jsxs("div", {
                 className: theme.layout.split,
@@ -168,12 +165,13 @@ export function MappingsTab({ actions }) {
                         className: theme.layout.main,
                         children: draft ? /*#__PURE__*/ _jsx(MappingEditor, {
                             deleting: deleting,
+                            endpoints: store.endpoints,
+                            freshSample: freshSample,
                             mapping: draft,
                             onCancel: closeEditor,
                             onDelete: remove,
                             onSave: save,
                             saving: saving,
-                            sourceFields: sourceFields,
                             targets: targets,
                             targetsLoading: targetsLoading
                         }, draft.id ?? 'new-mapping') : /*#__PURE__*/ _jsx("p", {