nucleus-core-ts 0.9.792 → 0.9.793

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

@@ -3,6 +3,7 @@ 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';
@@ -42,6 +43,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);
@@ -88,8 +115,15 @@ 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 ?? [] : [];
+    // 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);
     return /*#__PURE__*/ _jsxs("section", {
         className: "flex flex-col gap-4",
         children: [

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