nucleus-core-ts 0.9.815 → 0.9.816

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

@@ -1,2 +1,2 @@
 import type { IntegrationsPageProps } from '../types';
-export declare function IntegrationsPage({ title, subtitle, className, actions, labels: labelsOverride, onSubscribeProgress, }: IntegrationsPageProps): import("react/jsx-runtime").JSX.Element;
+export declare function IntegrationsPage({ title, subtitle, className, actions, labels: labelsOverride, focusTargetEntity, onSubscribeProgress, }: IntegrationsPageProps): import("react/jsx-runtime").JSX.Element;

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

@@ -25,7 +25,7 @@ import { RunsTab } from './RunsTab';
  * page from the server rather than being handed a list to slice.
  */ gsap.registerPlugin(useGSAP);
 const theme = integrationsPageTheme;
-export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect an external service, describe the data you want and import it on your terms.', className, actions, labels: labelsOverride, onSubscribeProgress }) {
+export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect an external service, describe the data you want and import it on your terms.', className, actions, labels: labelsOverride, focusTargetEntity, onSubscribeProgress }) {
     const store = useIntegrationsStore();
     // Resolved here rather than read from the context, because this component is
     // the one that PROVIDES it — and passed down so a control four levels deep
@@ -83,6 +83,37 @@ export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect a
         store.selectedSourceId,
         sourcesReloadToken
     ]);
+    /**
+   * Somebody arrived from the table they want filled.
+   *
+   * They have already said which table; being shown a connection chooser and
+   * four mappings is asking the same question again. So the entity is handed to
+   * the mappings step, and — when there is only one connection to be meant — it
+   * is chosen for them. With several, the choice is real and stays theirs.
+   */ const takeFocus = useEffectEvent(()=>{
+        if (!focusTargetEntity) return;
+        store.setFocusTargetEntity(focusTargetEntity);
+    });
+    useEffect(()=>{
+        takeFocus();
+    }, [
+        focusTargetEntity
+    ]);
+    const followFocus = useEffectEvent(()=>{
+        if (!store.focusTargetEntity) return;
+        if (!store.selectedSourceId) {
+            if (store.sources.length === 1 && store.sources[0]) store.selectSource(store.sources[0].id);
+            return;
+        }
+        if (store.tab !== 'mappings') store.setTab('mappings');
+    });
+    useEffect(()=>{
+        followFocus();
+    }, [
+        store.focusTargetEntity,
+        store.selectedSourceId,
+        store.sources.length
+    ]);
     // One measured entrance. Anything longer makes an operator wait to read counts
     // they came here to check.
     useGSAP(()=>{

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

@@ -29,6 +29,7 @@ export function MappingsTab({ actions }) {
     const [saving, setSaving] = useState(false);
     const [deleting, setDeleting] = useState(false);
     const [reloadToken, setReloadToken] = useState(0);
+    /** Set only when a new mapping is being started for a table named on arrival. */ const [pendingTarget, setPendingTarget] = useState('');
     const sourceId = store.selectedSourceId ?? '';
     const newMappingEndpointId = store.selectedEndpointId ?? store.endpoints[0]?.id ?? '';
     const loadTargets = useEffectEvent(()=>{
@@ -72,6 +73,7 @@ export function MappingsTab({ actions }) {
     ]);
     const startNew = ()=>{
         setSelected(null);
+        setPendingTarget('');
         setCreating(true);
         store.selectMapping(null);
     };
@@ -80,8 +82,53 @@ export function MappingsTab({ actions }) {
         setSelected(mapping);
         store.selectMapping(mapping.id);
     };
+    /**
+   * Opens the mapping for the table somebody arrived asking about.
+   *
+   * Asked of the SERVER by target entity rather than searched in the page this
+   * tab happens to be holding: the list is paged, so the mapping being looked
+   * for is frequently not in it. If there is none yet, a new one is started
+   * already aimed at that table — which is the other half of the answer.
+   *
+   * Consumed once. Left set, it would drag the selection back every time the
+   * operator clicked a different mapping.
+   */ const followFocus = useEffectEvent(()=>{
+        const entity = store.focusTargetEntity;
+        if (!entity || sourceId === '') return;
+        store.setFocusTargetEntity(null);
+        actions.listMappings(sourceId, {
+            page: 1,
+            limit: 1,
+            filters: [
+                {
+                    field: 'targetEntity',
+                    operator: 'eq',
+                    value: entity
+                }
+            ]
+        }).then((result)=>{
+            const found = result.items[0];
+            if (found) {
+                openMapping(found);
+                return;
+            }
+            setSelected(null);
+            setPendingTarget(entity);
+            setCreating(true);
+            store.selectMapping(null);
+        }).catch((error)=>{
+            store.setError(messageOf(error));
+        });
+    });
+    useEffect(()=>{
+        followFocus();
+    }, [
+        store.focusTargetEntity,
+        sourceId
+    ]);
     const closeEditor = ()=>{
         setCreating(false);
+        setPendingTarget('');
         setSelected(null);
         store.selectMapping(null);
     };
@@ -114,7 +161,7 @@ export function MappingsTab({ actions }) {
             store.setError(messageOf(error));
         });
     };
-    const draft = creating ? blankMappingDraft(newMappingEndpointId) : selected ? toMappingDraft(selected) : null;
+    const draft = creating ? blankMappingDraft(newMappingEndpointId, pendingTarget) : selected ? toMappingDraft(selected) : null;
     // 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

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

@@ -31,8 +31,13 @@ export type MappingDraft = {
     passwordTargetColumn?: string | null;
     enabled?: boolean;
 };
-/** Upsert and ignore: the two choices that cannot lose a row by themselves. */
-export declare function blankMappingDraft(endpointId: string): MappingDraft;
+/**
+ * Upsert and ignore: the two choices that cannot lose a row by themselves.
+ *
+ * `targetEntity` is filled in when the operator arrived from the table itself —
+ * they have already said which one, and asking again is the panel forgetting.
+ */
+export declare function blankMappingDraft(endpointId: string, targetEntity?: string): MappingDraft;
 /** Copies field by field so a column the server added cannot ride along unseen. */
 export declare function toMappingDraft(mapping: IntegrationMapping): MappingDraft;
 /**

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

@@ -1,10 +1,15 @@
 import { asArray } from './jsonArray';
 import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
-/** Upsert and ignore: the two choices that cannot lose a row by themselves. */ export function blankMappingDraft(endpointId) {
+/**
+ * Upsert and ignore: the two choices that cannot lose a row by themselves.
+ *
+ * `targetEntity` is filled in when the operator arrived from the table itself —
+ * they have already said which one, and asking again is the panel forgetting.
+ */ export function blankMappingDraft(endpointId, targetEntity = '') {
     return {
         endpointId,
         name: '',
-        targetEntity: '',
+        targetEntity,
         fieldMappings: [],
         referenceChecks: [],
         writeMode: 'upsert',

package/dist/fe/components/IntegrationsPage/store/index.js

@@ -41,6 +41,9 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.plan = null;
                 store.error = null;
             }),
+    setFocusTargetEntity: (store)=>(entity)=>{
+            store.focusTargetEntity = entity;
+        },
     setTab: (store)=>(tab)=>{
             store.tab = tab;
         },

package/dist/fe/components/IntegrationsPage/store/state.d.ts

@@ -20,6 +20,15 @@ export type State = {
     sourcesLoading: boolean;
     selectedSourceId: string | null;
     tab: ConnectionTab;
+    /**
+     * The table somebody arrived here asking about.
+     *
+     * A management screen links straight in — "fill this table from a source" —
+     * and the panel is no use if it then asks which of four mappings was meant.
+     * Consumed once, on arrival: it steers the first render and is cleared, so a
+     * later click on another mapping is not dragged back.
+     */
+    focusTargetEntity: string | null;
     endpoints: IntegrationEndpoint[];
     endpointsTotal: number;
     endpointsPage: number;
@@ -56,6 +65,7 @@ export type Actions = {
     setSourcesLoading: (loading: boolean) => void;
     selectSource: (id: string | null) => void;
     setTab: (tab: ConnectionTab) => void;
+    setFocusTargetEntity: (entity: string | null) => void;
     setEndpoints: (items: IntegrationEndpoint[], total: number) => void;
     /**
      * Just the count, without the rows.

package/dist/fe/components/IntegrationsPage/store/state.js

@@ -6,6 +6,7 @@ export const initial = {
     sourcesLoading: false,
     selectedSourceId: null,
     tab: 'connection',
+    focusTargetEntity: null,
     endpoints: [],
     endpointsTotal: 0,
     endpointsPage: 1,

package/dist/fe/components/IntegrationsPage/types/actions.d.ts

@@ -98,6 +98,14 @@ export type IntegrationsPageProps = {
     subtitle?: string;
     className?: string;
     actions: IntegrationsActions;
+    /**
+     * The table a caller arrived asking about, e.g. from "fill this from a
+     * source" on a management screen.
+     *
+     * The panel opens on that table's mapping — or on a new one already aimed at
+     * it — instead of on a chooser the caller has already answered.
+     */
+    focusTargetEntity?: string;
     /**
      * The panel's own words, in the app's language.
      *

package/package.json

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