nucleus-core-ts 0.9.845 → 0.9.847

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

@@ -2,10 +2,12 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState } from 'react';
 import { useIntegrationsStore } from '../store';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme as theme } from '../theme';
 import { deleteIsConfirmed } from './deleteIsConfirmed';
 import { Notice } from './Primitives';
 export function ConnectionDelete({ actions, source, onDeleted }) {
+    const labels = useLabels();
     const store = useIntegrationsStore();
     const [asking, setAsking] = useState(false);
     const [typed, setTyped] = useState('');
@@ -18,11 +20,12 @@ export function ConnectionDelete({ actions, source, onDeleted }) {
         actions.deleteSource(source.id).then((done)=>{
             setBusy(false);
             if (!done) {
-                store.setError('The connection was not deleted.');
+                store.setError(labels.connections.deleteFailed);
                 return;
             }
             setAsking(false);
             setTyped('');
+            store.removeSource(source.id);
             store.selectSource(null);
             onDeleted?.();
         }).catch((error)=>{
@@ -38,13 +41,13 @@ export function ConnectionDelete({ actions, source, onDeleted }) {
                 children: [
                     /*#__PURE__*/ _jsx("h3", {
                         className: theme.card.title,
-                        children: "Remove this connection"
+                        children: labels.connections.deleteHeading
                     }),
                     asking ? null : /*#__PURE__*/ _jsx("button", {
                         className: theme.button.danger,
                         onClick: ()=>setAsking(true),
                         type: "button",
-                        children: "Delete"
+                        children: labels.connections.deleteStart
                     })
                 ]
             }),
@@ -52,27 +55,17 @@ export function ConnectionDelete({ actions, source, onDeleted }) {
                 className: theme.card.body,
                 children: asking ? /*#__PURE__*/ _jsxs(_Fragment, {
                     children: [
-                        /*#__PURE__*/ _jsxs(Notice, {
-                            title: "This takes its calls and mappings with it",
+                        /*#__PURE__*/ _jsx(Notice, {
+                            title: labels.connections.deleteWarnTitle,
                             tone: "danger",
-                            children: [
-                                "Everything configured under “",
-                                source.name,
-                                "” goes: the calls, the mappings and the record of what they imported. The rows already written into your tables stay where they are — but nothing will be able to undo the imports that put them there."
-                            ]
+                            children: labels.connections.deleteWarnBody(source.name)
                         }),
                         /*#__PURE__*/ _jsxs("label", {
                             className: theme.field.wrapper,
                             children: [
-                                /*#__PURE__*/ _jsxs("span", {
+                                /*#__PURE__*/ _jsx("span", {
                                     className: theme.field.label,
-                                    children: [
-                                        "Type ",
-                                        /*#__PURE__*/ _jsx("strong", {
-                                            children: source.name
-                                        }),
-                                        " to confirm"
-                                    ]
+                                    children: labels.connections.deleteTypeToConfirm
                                 }),
                                 /*#__PURE__*/ _jsx("input", {
                                     className: theme.field.input,
@@ -94,21 +87,21 @@ export function ConnectionDelete({ actions, source, onDeleted }) {
                                         setTyped('');
                                     },
                                     type: "button",
-                                    children: "Cancel"
+                                    children: labels.common.cancel
                                 }),
                                 /*#__PURE__*/ _jsx("button", {
                                     className: theme.button.danger,
                                     disabled: busy || !confirmed,
                                     onClick: remove,
                                     type: "button",
-                                    children: busy ? 'Deleting…' : 'Delete this connection'
+                                    children: busy ? labels.common.deleting : labels.connections.deleteConfirm
                                 })
                             ]
                         })
                     ]
                 }) : /*#__PURE__*/ _jsx("p", {
                     className: theme.field.hint,
-                    children: "A connection can be turned off instead — that stops every call and import through it and keeps the settings. Deleting is for one that should not have existed."
+                    children: labels.connections.deleteHint
                 })
             })
         ]

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

@@ -66,13 +66,9 @@ export function ConnectionTest({ actions, source, loading = false }) {
             /*#__PURE__*/ _jsxs("div", {
                 className: theme.card.body,
                 children: [
-                    source ? /*#__PURE__*/ _jsxs("p", {
+                    source ? /*#__PURE__*/ _jsx("p", {
                         className: theme.field.hint,
-                        children: [
-                            "Calls ",
-                            source.baseUrl,
-                            " with the settings and credentials as they are stored right now."
-                        ]
+                        children: labels.auth.testCalls(source.baseUrl)
                     }) : /*#__PURE__*/ _jsx("p", {
                         className: theme.field.hint,
                         children: labels.auth.testSaveFirst

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

@@ -43,7 +43,12 @@ export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect a
    * detail treated the missing record as still loading and sat on skeletons
    * until the page was reloaded by hand. The write itself had succeeded.
    */ const [sourcesReloadToken, setSourcesReloadToken] = useState(0);
-    const handleSourceSaved = ()=>{
+    const handleSourceSaved = (saved)=>{
+        // Into the store FIRST. Bumping the token only tells the rail to refetch,
+        // and choosing a connection unmounts the rail — so on a NEW connection the
+        // token reached nobody and the detail below could not find the record it
+        // had just been switched to.
+        store.upsertSource(saved);
         setSourcesReloadToken((token)=>token + 1);
     };
     /**

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

@@ -261,7 +261,7 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         disabled: busy,
                         onClick: ()=>onDelete(draft.id ?? ''),
                         type: "button",
-                        children: deleting ? 'Deleting…' : 'Delete'
+                        children: deleting ? labels.common.deleting : labels.common.delete
                     }) : null,
                     /*#__PURE__*/ _jsx("button", {
                         className: theme.button.secondary,
@@ -282,7 +282,7 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         disabled: busy || issues.length > 0,
                         onClick: ()=>onSave(draft),
                         type: "button",
-                        children: saving ? 'Saving…' : 'Save mapping'
+                        children: saving ? labels.common.saving : labels.mappings.save
                     })
                 ]
             })

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

@@ -60,13 +60,10 @@ import { Notice } from './Primitives';
                         className: theme.field.hint,
                         children: labels.endpoints.bindingsNone
                     }) : null,
-                    unbound.length > 0 ? /*#__PURE__*/ _jsxs(Notice, {
+                    unbound.length > 0 ? /*#__PURE__*/ _jsx(Notice, {
                         title: labels.endpoints.bindingsTitle,
                         tone: "warning",
-                        children: [
-                            unbound.join(', '),
-                            " — an import cannot run until every one of them is bound. Add a binding for each below."
-                        ]
+                        children: labels.endpoints.bindingsUnbound(unbound.join(', '))
                     }) : null,
                     value.map((binding, index)=>/*#__PURE__*/ _jsx(ParamBindingRow, {
                             binding: binding,

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

@@ -1,5 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { Notice } from './Primitives';
 /**
@@ -10,6 +11,7 @@ import { Notice } from './Primitives';
  * sure?" transfers no information, so this one refuses to be that.
  */ const theme = integrationsPageTheme;
 export function RunConfirmStep({ lines, counted, working, onConfirm, onDismiss }) {
+    const labels = useLabels();
     return /*#__PURE__*/ _jsxs(Notice, {
         tone: "danger",
         title: "This import destroys data. Read what it removes, then confirm.",
@@ -32,7 +34,7 @@ export function RunConfirmStep({ lines, counted, working, onConfirm, onDismiss }
                         disabled: working,
                         onClick: onConfirm,
                         type: "button",
-                        children: working ? 'Starting…' : 'Run it and remove those rows'
+                        children: working ? labels.runs.starting : 'Run it and remove those rows'
                     }),
                     /*#__PURE__*/ _jsx("button", {
                         className: theme.button.secondary,

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

@@ -1,6 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { cn } from '../../../utils/cn';
+import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 /**
  * How far the run this panel started has got.
@@ -17,6 +18,7 @@ const PHASE_LABEL = {
     done: 'Finished'
 };
 export function RunProgressBar({ runId, progress, cancelling, onCancel }) {
+    const labels = useLabels();
     const total = progress?.total ?? 0;
     const processed = progress?.processed ?? 0;
     const determinate = total > 0;
@@ -68,7 +70,7 @@ export function RunProgressBar({ runId, progress, cancelling, onCancel }) {
                         disabled: cancelling,
                         onClick: onCancel,
                         type: "button",
-                        children: cancelling ? 'Cancelling…' : 'Cancel'
+                        children: cancelling ? labels.runs.cancelling : labels.runs.cancel
                     })
                 ]
             })

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

@@ -1,15 +1,28 @@
 'use client';
 import { batch, createStore } from 'h-state';
 import { initial } from './state';
+import { isNewTo, upsertInto } from './upsertInto';
 export const { useStore: useIntegrationsStore } = createStore(initial, {
     setSources: (store)=>(items, total)=>batch(()=>{
                 store.sources = items;
                 store.sourcesTotal = total;
                 store.sourcesLoading = false;
             }),
-    setSourcesPage: (store)=>(page)=>{
-            store.sourcesPage = page;
-        },
+    upsertSource: (store)=>(source)=>batch(()=>{
+                // The count moves only for an addition — an edit that bumped the total
+                // would make the rail claim a connection nobody can find.
+                if (isNewTo(store.sources, source)) store.sourcesTotal = store.sourcesTotal + 1;
+                store.sources = upsertInto(store.sources, source);
+            }),
+    removeSource: (store)=>(id)=>batch(()=>{
+                const kept = store.sources.filter((candidate)=>candidate.id !== id);
+                // Only when it was actually on this page — the count must not fall for a
+                // record the list never held.
+                if (kept.length !== store.sources.length) {
+                    store.sourcesTotal = Math.max(0, store.sourcesTotal - 1);
+                    store.sources = kept;
+                }
+            }),
     setSourcesSearch: (store)=>(search)=>batch(()=>{
                 store.sourcesSearch = search;
                 // A new search is a new result set; staying on page 4 would show an empty
@@ -53,12 +66,6 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.endpointsTotal = total;
                 store.endpointsLoading = false;
             }),
-    setEndpointsTotal: (store)=>(total)=>{
-            store.endpointsTotal = total;
-        },
-    setEndpointsPage: (store)=>(page)=>{
-            store.endpointsPage = page;
-        },
     setEndpointsSearch: (store)=>(search)=>batch(()=>{
                 store.endpointsSearch = search;
                 store.endpointsPage = 1;
@@ -80,9 +87,6 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
     setMappingsTotal: (store)=>(total)=>{
             store.mappingsTotal = total;
         },
-    setMappingsPage: (store)=>(page)=>{
-            store.mappingsPage = page;
-        },
     setMappingsSearch: (store)=>(search)=>batch(()=>{
                 store.mappingsSearch = search;
                 store.mappingsPage = 1;
@@ -107,12 +111,6 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.runsTotal = total;
                 store.runsLoading = false;
             }),
-    setRunsTotal: (store)=>(total)=>{
-            store.runsTotal = total;
-        },
-    setRunsPage: (store)=>(page)=>{
-            store.runsPage = page;
-        },
     setRunsLoading: (store)=>(loading)=>{
             store.runsLoading = loading;
         },

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

@@ -15,7 +15,6 @@ export type State = {
     [key: string]: unknown;
     sources: IntegrationSource[];
     sourcesTotal: number;
-    sourcesPage: number;
     sourcesSearch: string;
     sourcesLoading: boolean;
     selectedSourceId: string | null;
@@ -33,19 +32,16 @@ export type State = {
     focusStep: 'mapping' | 'import';
     endpoints: IntegrationEndpoint[];
     endpointsTotal: number;
-    endpointsPage: number;
     endpointsSearch: string;
     endpointsLoading: boolean;
     selectedEndpointId: string | null;
     mappings: IntegrationMapping[];
     mappingsTotal: number;
-    mappingsPage: number;
     mappingsSearch: string;
     mappingsLoading: boolean;
     selectedMappingId: string | null;
     runs: IntegrationRun[];
     runsTotal: number;
-    runsPage: number;
     runsLoading: boolean;
     /** The real shape of the selected endpoint's response, once sampled. */
     sample: EndpointSampleValue | null;
@@ -62,7 +58,18 @@ export type State = {
 export type Actions = {
     [key: string]: unknown;
     setSources: (items: IntegrationSource[], total: number) => void;
-    setSourcesPage: (page: number) => void;
+    /**
+     * Put one connection into the list, whether or not it is already there.
+     *
+     * The rail is what fetches connections, and choosing one UNMOUNTS the rail —
+     * so a connection created from the form was selected into a list that had
+     * never heard of it, and every panel below sat on skeletons until the page
+     * was reloaded by hand. The save already returns the record; this is where it
+     * goes so the detail can find it.
+     */
+    upsertSource: (source: IntegrationSource) => void;
+    /** Drop one connection from the list, for when it has just been deleted. */
+    removeSource: (id: string) => void;
     setSourcesSearch: (search: string) => void;
     setSourcesLoading: (loading: boolean) => void;
     selectSource: (id: string | null) => void;
@@ -75,20 +82,15 @@ export type Actions = {
      * The step strip reports how far a connection has got, and it cannot wait for
      * the tab that lists the rows to have been opened — so it counts directly.
      */
-    setEndpointsTotal: (total: number) => void;
-    setEndpointsPage: (page: number) => void;
     setEndpointsSearch: (search: string) => void;
     setEndpointsLoading: (loading: boolean) => void;
     selectEndpoint: (id: string | null) => void;
     setMappings: (items: IntegrationMapping[], total: number) => void;
     setMappingsTotal: (total: number) => void;
-    setMappingsPage: (page: number) => void;
     setMappingsSearch: (search: string) => void;
     setMappingsLoading: (loading: boolean) => void;
     selectMapping: (id: string | null) => void;
     setRuns: (items: IntegrationRun[], total: number) => void;
-    setRunsTotal: (total: number) => void;
-    setRunsPage: (page: number) => void;
     setRunsLoading: (loading: boolean) => void;
     setSample: (sample: EndpointSampleValue | null) => void;
     setSampling: (sampling: boolean) => void;

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

@@ -1,7 +1,6 @@
 export const initial = {
     sources: [],
     sourcesTotal: 0,
-    sourcesPage: 1,
     sourcesSearch: '',
     sourcesLoading: false,
     selectedSourceId: null,
@@ -10,19 +9,16 @@ export const initial = {
     focusStep: 'mapping',
     endpoints: [],
     endpointsTotal: 0,
-    endpointsPage: 1,
     endpointsSearch: '',
     endpointsLoading: false,
     selectedEndpointId: null,
     mappings: [],
     mappingsTotal: 0,
-    mappingsPage: 1,
     mappingsSearch: '',
     mappingsLoading: false,
     selectedMappingId: null,
     runs: [],
     runsTotal: 0,
-    runsPage: 1,
     runsLoading: false,
     sample: null,
     sampling: false,

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

@@ -0,0 +1,20 @@
+/**
+ * Where a saved record goes in a list that may or may not already hold it.
+ *
+ * Kept as a function so the rule can be tested apart from the store: the panel
+ * unmounts the connection rail the moment a connection is chosen, so a newly
+ * created connection is selected into a list that never fetched it. Putting the
+ * returned record in by hand is what stops the detail below from waiting for a
+ * fetch that no mounted component will make.
+ *
+ * A new record goes to the FRONT — it is the one just made, and the operator is
+ * about to be switched to it; an existing one is replaced where it already sits,
+ * so an edit never reorders a list somebody is reading.
+ */
+export declare function upsertInto<T extends {
+    id: string;
+}>(items: T[], record: T): T[];
+/** Whether `record` would be an addition rather than a replacement. */
+export declare function isNewTo<T extends {
+    id: string;
+}>(items: T[], record: T): boolean;

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

@@ -0,0 +1,21 @@
+/**
+ * Where a saved record goes in a list that may or may not already hold it.
+ *
+ * Kept as a function so the rule can be tested apart from the store: the panel
+ * unmounts the connection rail the moment a connection is chosen, so a newly
+ * created connection is selected into a list that never fetched it. Putting the
+ * returned record in by hand is what stops the detail below from waiting for a
+ * fetch that no mounted component will make.
+ *
+ * A new record goes to the FRONT — it is the one just made, and the operator is
+ * about to be switched to it; an existing one is replaced where it already sits,
+ * so an edit never reorders a list somebody is reading.
+ */ export function upsertInto(items, record) {
+    return items.some((candidate)=>candidate.id === record.id) ? items.map((candidate)=>candidate.id === record.id ? record : candidate) : [
+        record,
+        ...items
+    ];
+}
+/** Whether `record` would be an addition rather than a replacement. */ export function isNewTo(items, record) {
+    return !items.some((candidate)=>candidate.id === record.id);
+}

package/dist/fe/components/IntegrationsPage/store/upsertInto.test.d.ts

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

package/dist/fe/components/IntegrationsPage/store/upsertInto.test.js

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'bun:test';
+import { isNewTo, upsertInto } from './upsertInto';
+const a = {
+    id: 'a',
+    name: 'First'
+};
+const b = {
+    id: 'b',
+    name: 'Second'
+};
+describe('upsertInto', ()=>{
+    it('puts a new record at the front', ()=>{
+        expect(upsertInto([
+            a
+        ], b)).toEqual([
+            b,
+            a
+        ]);
+    });
+    it('adds to an empty list', ()=>{
+        expect(upsertInto([], a)).toEqual([
+            a
+        ]);
+    });
+    it('replaces an existing record where it already sits', ()=>{
+        const renamed = {
+            id: 'a',
+            name: 'Renamed'
+        };
+        expect(upsertInto([
+            b,
+            a
+        ], renamed)).toEqual([
+            b,
+            renamed
+        ]);
+    });
+    it('never duplicates — saving the same record twice leaves one', ()=>{
+        const once = upsertInto([], a);
+        expect(upsertInto(once, {
+            id: 'a',
+            name: 'Again'
+        })).toHaveLength(1);
+    });
+    it('leaves the original array untouched', ()=>{
+        const items = [
+            a
+        ];
+        upsertInto(items, b);
+        expect(items).toEqual([
+            a
+        ]);
+    });
+});
+describe('isNewTo', ()=>{
+    it('is true only for a record the list does not hold', ()=>{
+        expect(isNewTo([
+            a
+        ], b)).toBe(true);
+        expect(isNewTo([
+            a
+        ], {
+            id: 'a',
+            name: 'Renamed'
+        })).toBe(false);
+    });
+});

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

@@ -63,6 +63,14 @@ export type IntegrationsLabels = {
         disabledBadge: string;
         saveChanges: string;
         createSubmit: string;
+        deleteHeading: string;
+        deleteStart: string;
+        deleteWarnTitle: string;
+        deleteWarnBody: (name: string) => string;
+        deleteTypeToConfirm: string;
+        deleteConfirm: string;
+        deleteHint: string;
+        deleteFailed: string;
     };
     runs: {
         /** The one-line summary above the buttons. */
@@ -72,6 +80,7 @@ export type IntegrationsLabels = {
         start: string;
         starting: string;
         cancel: string;
+        cancelling: string;
         previewExplainTitle: string;
         previewExplainBody: string;
         historyHeading: string;

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

@@ -56,7 +56,15 @@
         enabledBadge: 'Enabled',
         disabledBadge: 'Off',
         saveChanges: 'Save changes',
-        createSubmit: 'Create connection'
+        createSubmit: 'Create connection',
+        deleteHeading: 'Remove this connection',
+        deleteStart: 'Delete',
+        deleteWarnTitle: 'This takes its calls and mappings with it',
+        deleteWarnBody: (name)=>`Everything configured under “${name}” goes: the calls, the mappings and the record of what they imported. The rows already written into your tables stay where they are — but nothing will be able to undo the imports that put them there.`,
+        deleteTypeToConfirm: 'Type the connection name to confirm',
+        deleteConfirm: 'Delete this connection',
+        deleteHint: 'A connection can be turned off instead — that stops every call and import through it and keeps the settings. Deleting is for one that should not have existed.',
+        deleteFailed: 'The connection was not deleted.'
     },
     runs: {
         summary: (target, writeMode, missing)=>`Writes into ${target} · ${writeMode} · missing rows: ${missing}`,
@@ -65,6 +73,7 @@
         start: 'Run import',
         starting: 'Starting…',
         cancel: 'Cancel',
+        cancelling: 'Cancelling…',
         previewExplainTitle: 'Preview before you run',
         previewExplainBody: 'A preview reads the source without writing anything, and reports how many rows would be created, updated, skipped, and how many rows in the target the source no longer returns.',
         historyHeading: 'History',

package/package.json

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