nucleus-core-ts 0.9.792 → 0.9.794

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

@@ -42,6 +42,32 @@ export function MappingsTab({ actions }) {
     useEffect(()=>{
         loadTargets();
     }, []);
+    /**
+   * The connection's endpoints, when nothing has fetched them yet.
+   *
+   * `store.endpoints` is filled by the Endpoints tab, so opening a connection
+   * and going straight to Mappings met "No endpoints on this connection yet"
+   * 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));
+        });
+    });
+    useEffect(()=>{
+        loadEndpointsIfMissing();
+    }, [
+        sourceId
+    ]);
     const startNew = ()=>{
         setSelected(null);
         setCreating(true);
@@ -87,9 +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.
-    const sourceFields = draft && store.selectedEndpointId === draft.endpointId ? store.sample?.fields ?? [] : [];
+    // 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: [
@@ -113,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,
@@ -134,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", {

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

@@ -3,14 +3,19 @@
  */
 import type { IntegrationEndpoint } from '../types';
 /**
- * How an endpoint should read in a list someone has to choose from.
+ * The field names an endpoint's STORED sample reports.
  *
- * The parameter-binding picker showed `tag`, which groups the endpoints of one
- * API — so a source whose endpoints are all tagged `corporate-portal` offered
- * three identical options and no way to tell which one supplied the value.
- * The name is what distinguishes them; the path is what distinguishes them when
- * nobody typed a name, since it is the one field that cannot be blank.
+ * A sample is persisted on the endpoint precisely so the field list survives a
+ * reload, but the mapping editor was reading only the sample taken in this
+ * browser session. Come back to a connection tomorrow and it said "sample the
+ * endpoint first" about an endpoint it had already sampled and saved — so the
+ * source names had to be typed from memory, which is the one thing the sample
+ * exists to prevent.
+ *
+ * Mirrors the engine's `flattenKeys` rather than calling it: that lives in the
+ * server bundle, which this kit cannot import.
  */
+export declare function fieldsOfStoredSample(sample: IntegrationEndpoint['sampleResponse']): string[];
 export declare function endpointLabel(endpoint: IntegrationEndpoint): string;
 /**
  * The ids a control should point `aria-describedby` at.

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

@@ -8,7 +8,43 @@
  * three identical options and no way to tell which one supplied the value.
  * The name is what distinguishes them; the path is what distinguishes them when
  * nobody typed a name, since it is the one field that cannot be blank.
- */ export function endpointLabel(endpoint) {
+ */ /** Same caps as the engine's `flattenKeys`: this feeds a dropdown, not an analysis. */ const MAX_FIELDS_LISTED = 200;
+const MAX_FIELD_DEPTH = 4;
+function walkKeys(value, prefix, out, depth) {
+    if (out.length > MAX_FIELDS_LISTED || depth > MAX_FIELD_DEPTH) return out;
+    if (value == null || typeof value !== 'object') return out;
+    if (Array.isArray(value)) {
+        if (prefix) out.push(prefix);
+        return out;
+    }
+    for (const [key, child] of Object.entries(value)){
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (child != null && typeof child === 'object' && !Array.isArray(child)) {
+            walkKeys(child, path, out, depth + 1);
+        } else {
+            out.push(path);
+        }
+    }
+    return out;
+}
+/**
+ * The field names an endpoint's STORED sample reports.
+ *
+ * A sample is persisted on the endpoint precisely so the field list survives a
+ * reload, but the mapping editor was reading only the sample taken in this
+ * browser session. Come back to a connection tomorrow and it said "sample the
+ * endpoint first" about an endpoint it had already sampled and saved — so the
+ * source names had to be typed from memory, which is the one thing the sample
+ * exists to prevent.
+ *
+ * Mirrors the engine's `flattenKeys` rather than calling it: that lives in the
+ * server bundle, which this kit cannot import.
+ */ export function fieldsOfStoredSample(sample) {
+    const first = sample?.records?.[0];
+    if (!first || typeof first !== 'object') return [];
+    return walkKeys(first, '', [], 0);
+}
+export function endpointLabel(endpoint) {
     const name = endpoint.name?.trim();
     if (name) return name;
     const path = endpoint.path?.trim();

package/dist/fe/components/IntegrationsPage/components/formSupport.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test';
-import { describedBy, endpointLabel, errorText } from './formSupport';
+import { describedBy, endpointLabel, errorText, fieldsOfStoredSample } from './formSupport';
 const endpoint = (over)=>({
         id: 'e1',
         sourceId: 's1',
@@ -38,6 +38,103 @@ const endpoint = (over)=>({
         }))).toBe('corporate-portal');
     });
 });
+/**
+ * The sample is persisted on the endpoint so the field list survives a reload.
+ * The mapping editor was reading only the sample taken in the current browser
+ * session, so a connection revisited later said "sample the endpoint first"
+ * about an endpoint it had already sampled and stored.
+ */ describe('fieldsOfStoredSample', ()=>{
+    test('reads the field names off the stored first record', ()=>{
+        const fields = fieldsOfStoredSample({
+            records: [
+                {
+                    companyCode: 'TAT',
+                    companyName: 'TATMETAL ÇELİK SAN. VE TİC.A.Ş.',
+                    organizationCode: '010',
+                    organizationName: 'YÖNETİM KURULU',
+                    parentOrganizationCode: '*'
+                }
+            ]
+        });
+        expect(fields).toEqual([
+            'companyCode',
+            'companyName',
+            'organizationCode',
+            'organizationName',
+            'parentOrganizationCode'
+        ]);
+    });
+    test('nested objects become dot-paths, the way the engine reports them', ()=>{
+        const fields = fieldsOfStoredSample({
+            records: [
+                {
+                    a: 1,
+                    b: {
+                        c: 2,
+                        d: {
+                            e: 3
+                        }
+                    }
+                }
+            ]
+        });
+        expect(fields).toEqual([
+            'a',
+            'b.c',
+            'b.d.e'
+        ]);
+    });
+    test('an array is a leaf — its contents are a shape, not a field name', ()=>{
+        const fields = fieldsOfStoredSample({
+            records: [
+                {
+                    organizationName: 'GENEL MÜDÜRLÜK',
+                    subOrganization: [
+                        {
+                            x: 1
+                        }
+                    ]
+                }
+            ]
+        });
+        expect(fields).toEqual([
+            'organizationName',
+            'subOrganization'
+        ]);
+    });
+    test('nothing stored yields nothing, rather than throwing', ()=>{
+        expect(fieldsOfStoredSample(null)).toEqual([]);
+        expect(fieldsOfStoredSample(undefined)).toEqual([]);
+        expect(fieldsOfStoredSample({
+            records: []
+        })).toEqual([]);
+        expect(fieldsOfStoredSample({
+            records: [
+                'not an object'
+            ]
+        })).toEqual([]);
+    });
+    test('depth is capped, so a deep document cannot flood the picker', ()=>{
+        const deep = {
+            l1: {
+                l2: {
+                    l3: {
+                        l4: {
+                            l5: {
+                                l6: 'too far'
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        expect(fieldsOfStoredSample({
+            records: [
+                deep
+            ]
+        })).toEqual([]);
+    });
+});
 describe('describedBy', ()=>{
     test('names only the ids that were rendered', ()=>{
         expect(describedBy('f', true, true)).toBe('f-hint f-error');

package/package.json

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