nucleus-core-ts 0.9.815 → 0.9.817

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, focusStep, 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, focusStep, 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,38 @@ 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, focusStep ?? 'mapping');
+    });
+    useEffect(()=>{
+        takeFocus();
+    }, [
+        focusTargetEntity,
+        focusStep
+    ]);
+    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/MappingEditor.d.ts

@@ -26,5 +26,19 @@ export type MappingEditorProps = {
     onSave: (draft: MappingDraft) => void;
     onDelete: (id: string) => void;
     onCancel: () => void;
+    /**
+     * Go and import with this mapping.
+     *
+     * The import lives on its own step, and it should: it is the destructive one,
+     * and it wants the whole width for a preview. But somebody who has just
+     * finished describing a mapping wants to RUN it, and leaving them to find the
+     * step themselves is the panel forgetting what they were doing. Absent for an
+     * unsaved mapping, because there is nothing to run yet.
+     *
+     * The DRAFT is handed over, not the id: what is on screen is what the operator
+     * means to run, so edits they have not saved yet are saved on the way rather
+     * than quietly ignored by an import of the older version.
+     */
+    onRunImport?: (draft: MappingDraft) => void;
 };
-export declare function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, 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, onRunImport, }: MappingEditorProps): import("react/jsx-runtime").JSX.Element;

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

@@ -21,7 +21,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, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel }) {
+export function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel, onRunImport }) {
     const labels = useLabels();
     const uid = useId();
     const [draft, setDraft] = useState(mapping);
@@ -236,6 +236,13 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         type: "button",
                         children: "Cancel"
                     }),
+                    draft.id && onRunImport ? /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: busy,
+                        onClick: ()=>onRunImport(draft),
+                        type: "button",
+                        children: "Preview and import"
+                    }) : null,
                     /*#__PURE__*/ _jsx("button", {
                         className: theme.button.primary,
                         disabled: busy || issues.length > 0,

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,12 +82,61 @@ 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;
+        const step = store.focusStep;
+        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);
+                // "Fill this table now" is a different errand from "describe how it is
+                // filled", and both are offered from the table itself.
+                if (step === 'import') store.setTab('runs');
+                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);
     };
-    const save = (draft)=>{
+    const save = (draft, then)=>{
         setSaving(true);
         store.setError(null);
         actions.saveMapping(draft).then((saved)=>{
@@ -95,11 +146,31 @@ export function MappingsTab({ actions }) {
             setSelected(saved);
             store.selectMapping(saved.id);
             setReloadToken((token)=>token + 1);
+            then?.(saved);
         }).catch((error)=>{
             setSaving(false);
             store.setError(messageOf(error));
         });
     };
+    /**
+   * Take this mapping to the import step.
+   *
+   * Saved first when it differs from what is stored: the operator is looking at
+   * the version they mean to run, and importing the older one instead — with no
+   * sign that it happened — is the worst kind of quiet.
+   */ const runImport = (draft)=>{
+        const stored = selected ? toMappingDraft(selected) : null;
+        const dirty = !stored || JSON.stringify(stored) !== JSON.stringify(draft);
+        const go = (id)=>{
+            store.selectMapping(id);
+            store.setTab('runs');
+        };
+        if (!dirty && draft.id) {
+            go(draft.id);
+            return;
+        }
+        save(draft, (saved)=>go(saved.id));
+    };
     const remove = (id)=>{
         if (id === '') return;
         setDeleting(true);
@@ -114,7 +185,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
@@ -166,6 +237,7 @@ export function MappingsTab({ actions }) {
                             mapping: draft,
                             onCancel: closeEditor,
                             onDelete: remove,
+                            onRunImport: runImport,
                             onSave: save,
                             saving: saving,
                             targets: targets,

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,10 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.plan = null;
                 store.error = null;
             }),
+    setFocusTargetEntity: (store)=>(entity, step)=>{
+            store.focusTargetEntity = entity;
+            if (step) store.focusStep = step;
+        },
     setTab: (store)=>(tab)=>{
             store.tab = tab;
         },

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

@@ -20,6 +20,17 @@ 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;
+    /** Whether that caller wanted to DESCRIBE the import or RUN it. */
+    focusStep: 'mapping' | 'import';
     endpoints: IntegrationEndpoint[];
     endpointsTotal: number;
     endpointsPage: number;
@@ -56,6 +67,7 @@ export type Actions = {
     setSourcesLoading: (loading: boolean) => void;
     selectSource: (id: string | null) => void;
     setTab: (tab: ConnectionTab) => void;
+    setFocusTargetEntity: (entity: string | null, step?: 'mapping' | 'import') => void;
     setEndpoints: (items: IntegrationEndpoint[], total: number) => void;
     /**
      * Just the count, without the rows.

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

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

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

@@ -98,6 +98,22 @@ 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;
+    /**
+     * What they came to do with it.
+     *
+     * "Describe how this table is filled" and "fill it now" are two different
+     * errands, and a management screen offers both. Landing on the wrong one
+     * means finding the right step by hand — which is what the button was for.
+     */
+    focusStep?: 'mapping' | 'import';
     /**
      * 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.817",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",