nucleus-core-ts 0.9.791 → 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/ParamBindingRow.js

@@ -2,6 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useId } from 'react';
 import { integrationsPageTheme as theme } from '../theme';
+import { endpointLabel } from './formSupport';
 import { Field } from './Primitives';
 export function ParamBindingRow({ binding, onChange, onRemove, siblings, entities, disabled }) {
     const rowId = useId();
@@ -107,7 +108,7 @@ export function ParamBindingRow({ binding, onChange, onRemove, siblings, entitie
                         value: binding.endpointId,
                         children: siblings.map((sibling)=>/*#__PURE__*/ _jsx("option", {
                                 value: sibling.id,
-                                children: sibling.tag
+                                children: endpointLabel(sibling)
                             }, sibling.id))
                     })
                 }),

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

@@ -1,6 +1,22 @@
 /**
- * Two things every form in this panel needs and neither of them deserves a file.
+ * The small things every form in this panel needs and none of them deserves a file.
  */
+import type { IntegrationEndpoint } from '../types';
+/**
+ * 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 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

@@ -1,6 +1,57 @@
 /**
- * Two things every form in this panel needs and neither of them deserves a file.
+ * The small things every form in this panel needs and none of them deserves a file.
  */ /**
+ * How an endpoint should read in a list someone has to choose from.
+ *
+ * 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.
+ */ /** 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();
+    if (path) return `${endpoint.method} ${path}`;
+    return endpoint.tag;
+}
+/**
  * The ids a control should point `aria-describedby` at.
  *
  * {@link Field} renders its hint as `<id>-hint` and its error as `<id>-error`,

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

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

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

@@ -0,0 +1,156 @@
+import { describe, expect, test } from 'bun:test';
+import { describedBy, endpointLabel, errorText, fieldsOfStoredSample } from './formSupport';
+const endpoint = (over)=>({
+        id: 'e1',
+        sourceId: 's1',
+        tag: 'corporate-portal',
+        method: 'GET',
+        path: '/api/v1/ext/corporate-portal/company',
+        ...over
+    });
+/**
+ * Seen while wiring a chained import against a real API: every endpoint of one
+ * service shares a tag, and the binding picker labelled its options with that
+ * tag — three entries reading "corporate-portal" and no way to tell which one
+ * feeds the parameter.
+ */ describe('endpointLabel', ()=>{
+    test('the name is what distinguishes one endpoint from its siblings', ()=>{
+        expect(endpointLabel(endpoint({
+            name: 'Şirketler'
+        }))).toBe('Şirketler');
+    });
+    test('without a name, the method and path do — never the shared tag', ()=>{
+        const label = endpointLabel(endpoint({
+            name: null
+        }));
+        expect(label).toBe('GET /api/v1/ext/corporate-portal/company');
+        expect(label).not.toBe('corporate-portal');
+    });
+    test('a name of only spaces is not a name', ()=>{
+        expect(endpointLabel(endpoint({
+            name: '   '
+        }))).toBe('GET /api/v1/ext/corporate-portal/company');
+    });
+    test('the tag is the last resort, not the first', ()=>{
+        expect(endpointLabel(endpoint({
+            name: null,
+            path: ''
+        }))).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');
+        expect(describedBy('f', true, false)).toBe('f-hint');
+        expect(describedBy('f', false, true)).toBe('f-error');
+        expect(describedBy('f', false, false)).toBeUndefined();
+    });
+});
+describe('errorText', ()=>{
+    test("the server's own wording is kept, because only it knows what was wrong", ()=>{
+        expect(errorText(new Error('Token request failed'), 'fallback')).toBe('Token request failed');
+        expect(errorText('plain reason', 'fallback')).toBe('plain reason');
+    });
+    test('an empty or unrecognised reason falls back rather than saying nothing', ()=>{
+        expect(errorText(new Error(''), 'fallback')).toBe('fallback');
+        expect(errorText(undefined, 'fallback')).toBe('fallback');
+        expect(errorText({}, 'fallback')).toBe('fallback');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.791",
+	"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",