nucleus-core-ts 0.9.864 → 0.9.866

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

@@ -6,7 +6,7 @@ import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { ConnectionAuthFields } from './ConnectionAuthFields';
 import { ConnectionBasicFields } from './ConnectionBasicFields';
-import { draftFromSource, draftToSource, emptyConnectionDraft, validateConnectionDraft } from './connectionDraft';
+import { draftFromSource, draftPatchFromSource, draftToSource, emptyConnectionDraft, validateConnectionDraft } from './connectionDraft';
 import { errorText } from './formSupport';
 import { Badge } from './Primitives';
 import { CardSkeleton } from './Skeletons';
@@ -58,6 +58,26 @@ export function ConnectionForm({ actions, source, loading = false, onSaved }) {
             // it into the list, and selecting an id the list does not hold is the
             // state every card below renders a skeleton for.
             onSaved?.(saved);
+            /**
+         * The boxes are re-derived from what was actually STORED.
+         *
+         * The effect above resets them only when the id changes, so a create
+         * showed the truth and an edit never did. Two ways that was visible:
+         * emptying "Timeout" and saving left the box empty while the connection
+         * went on timing out at the stored value — the draft omits a blank
+         * timeout, so the patch never mentions it and the server rightly keeps
+         * what it had; and a trailing space in the name was trimmed on the way
+         * out, so the switcher above showed "Acme" while the box below still
+         * read "Acme ". One screen, disagreeing with itself, until F5.
+         *
+         * MERGED rather than replaced: a field-scoped patch claim can strip
+         * columns out of the reply, and re-deriving wholesale from a partial
+         * record would blank the boxes those columns fill. Nothing can have been
+         * typed in the meantime — every field is disabled while `saving`.
+         */ if (source) setDraft((current)=>({
+                    ...current,
+                    ...draftPatchFromSource(saved)
+                }));
             // Selecting resets everything hanging off a connection, so it is only
             // right for a NEW one — doing it on an edit would empty the endpoint,
             // mapping and run lists the operator is working in.

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

@@ -174,6 +174,21 @@ export function MappingsTab({ actions }) {
             // second earlier landed on "choose a mapping".
             store.upsertMapping(saved);
             store.selectMapping(saved.id);
+            /**
+         * The plan described the mapping as it WAS.
+         *
+         * A preview is an answer about one particular mapping, and editing that
+         * mapping makes the answer wrong — silently, because the import step
+         * prints its own heading from the saved record and the counts from the
+         * plan. Switching the write mode to `replace` after previewing gave a
+         * screen that said `replace` above numbers computed for `upsert`, and
+         * the destructive confirmation then combined the new mode with the old
+         * count: "1240 rows will be deleted", from a plan that never considered
+         * deleting anything.
+         *
+         * `selectMapping` cannot do this — it returns early when the id has not
+         * changed, and on a save it never does.
+         */ store.setPlan(null, null);
             setReloadToken((token)=>token + 1);
             then?.(saved);
         }).catch((error)=>{

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

@@ -42,6 +42,11 @@ export function RunHistoryRow({ run, actions, onReverted }) {
             setReverting(false);
             if (result.ok) {
                 setConflicts(null);
+                // An undo moves the rows a plan was counted against, so the plan on
+                // the import step above is now describing a database that no longer
+                // exists. Leaving it up invited a re-import against numbers that were
+                // true two states ago.
+                store.setPlan(null, null);
                 onReverted();
                 return;
             }

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

@@ -111,11 +111,23 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
     };
     // Progress for SOMEONE ELSE'S run is dropped: the topic is shared, and a
     // second operator's import must not drive this panel's bar.
+    /**
+   * A plan describes a database that no longer exists once it has been run.
+   *
+   * The plan is what the buttons act on and what the destructive confirmation
+   * quotes. Left standing after the import, it went on saying "880 to create"
+   * next to a history entry reporting 880 created — and the buttons came back
+   * enabled, so a second press started a second full import against numbers
+   * that were no longer true, with the confirmation showing those same stale
+   * numbers. Cleared here, the operator has to preview again, which is the only
+   * honest answer to "what would this do now".
+   */ const forgetPlan = ()=>store.setPlan(null, null);
     const applyProgress = useEffectEvent((progress)=>{
         if (store.activeRunId !== progress.runId) return;
         store.setProgress(progress);
         if (progress.phase === 'done') {
             store.setActiveRun(null);
+            forgetPlan();
             onRunSettled?.();
         }
     });
@@ -155,6 +167,9 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
             if (!run || run.status === 'running' || run.status === 'queued') return;
             store.setActiveRun(null);
             store.setProgress(null);
+            // The other place a run ends. Both have to forget the plan, or the
+            // realtime path and the polling path disagree about what is on screen.
+            forgetPlan();
             if (run.status === 'failed') {
                 store.setError(run.errors?.[0] ?? 'The import failed. Its history entry has the detail.');
             }

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

@@ -41,6 +41,21 @@ export type ConnectionFieldsProps = {
 };
 export declare const emptyConnectionDraft: ConnectionDraft;
 export declare function draftFromSource(source: IntegrationSource): ConnectionDraft;
+/**
+ * The boxes a SAVED record should correct, and only those.
+ *
+ * After an edit the form has to show what was actually stored — the server
+ * trims, defaults and ignores things, and the boxes went on showing what was
+ * typed. But re-deriving the whole draft from the reply is not safe: a
+ * field-scoped patch claim strips columns out of the response, and
+ * {@link draftFromSource} substitutes a default for every column it does not
+ * find. A reply that legitimately omits `name` would therefore blank the name
+ * box — trading a stale screen for a destroyed one.
+ *
+ * So this reads the reply key by key and says nothing about a key that is not
+ * there. What it returns is a patch, applied over the draft the operator has.
+ */
+export declare function draftPatchFromSource(source: Partial<IntegrationSource>): Partial<ConnectionDraft>;
 export declare function usesHeaderName(authType: IntegrationAuthType): boolean;
 export declare function usesQueryParam(authType: IntegrationAuthType): boolean;
 export declare function usesOauth(authType: IntegrationAuthType): boolean;

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

@@ -45,6 +45,47 @@ export function draftFromSource(source) {
         timeoutMs: source.timeoutMs == null ? '' : String(source.timeoutMs)
     };
 }
+/**
+ * The boxes a SAVED record should correct, and only those.
+ *
+ * After an edit the form has to show what was actually stored — the server
+ * trims, defaults and ignores things, and the boxes went on showing what was
+ * typed. But re-deriving the whole draft from the reply is not safe: a
+ * field-scoped patch claim strips columns out of the response, and
+ * {@link draftFromSource} substitutes a default for every column it does not
+ * find. A reply that legitimately omits `name` would therefore blank the name
+ * box — trading a stale screen for a destroyed one.
+ *
+ * So this reads the reply key by key and says nothing about a key that is not
+ * there. What it returns is a patch, applied over the draft the operator has.
+ */ export function draftPatchFromSource(source) {
+    const full = draftFromSource(source);
+    const patch = {};
+    const carry = (key, column)=>{
+        if (column in source && source[column] !== undefined) patch[key] = full[key];
+    };
+    carry('name', 'name');
+    carry('slug', 'slug');
+    carry('baseUrl', 'baseUrl');
+    carry('description', 'description');
+    carry('enabled', 'enabled');
+    carry('authType', 'authType');
+    carry('authHeaderName', 'authHeaderName');
+    carry('authQueryParam', 'authQueryParam');
+    carry('tokenUrl', 'tokenUrl');
+    carry('oauthGrantType', 'oauthGrantType');
+    carry('oauthClientId', 'oauthClientId');
+    carry('oauthUsername', 'oauthUsername');
+    carry('oauthScope', 'oauthScope');
+    carry('oauthClientAuth', 'oauthClientAuth');
+    carry('tlsVerify', 'tlsVerify');
+    // `timeoutMs` is the reason this exists at all: emptying the box omits it
+    // from the patch, the server keeps its stored value, and the box has to be
+    // told. `null` is a real answer here — it means "no timeout set" — so the
+    // presence of the KEY is what is checked, not its truthiness.
+    if ('timeoutMs' in source) patch.timeoutMs = full.timeoutMs;
+    return patch;
+}
 // ── which extras an auth type actually uses ─────────────────────────────────
 export function usesHeaderName(authType) {
     return authType === 'bearer' || authType === 'api_key';

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

@@ -1,5 +1,5 @@
-import { describe, expect, test } from 'bun:test';
-import { draftFromSource, draftToSource, emptyConnectionDraft, validateConnectionDraft } from './connectionDraft';
+import { describe, expect, it, test } from 'bun:test';
+import { draftFromSource, draftPatchFromSource, draftToSource, emptyConnectionDraft, validateConnectionDraft } from './connectionDraft';
 /**
  * Found in production, creating the first connection: the form said "Empty
  * means the server default" under the timeout, and saving with it empty
@@ -131,3 +131,68 @@ describe('draftFromSource', ()=>{
         expect(draftToSource(draftFromSource(source), 'a').timeoutMs).toBe(30000);
     });
 });
+/**
+ * What a save is allowed to correct in the boxes.
+ *
+ * After an edit the form showed what was TYPED, not what was stored: emptying
+ * the timeout left the box empty while the connection kept timing out at the
+ * stored value, and a trailing space in the name was trimmed on the way out so
+ * the switcher above and the box below disagreed until F5. The reply has to be
+ * read back — but only the parts of it that are actually there, because a
+ * field-scoped patch claim strips columns out, and `draftFromSource` fills a
+ * default for every column it does not find. Blanking a required box is worse
+ * than leaving it stale.
+ */ describe('the boxes a saved record corrects', ()=>{
+    const stored = {
+        id: 's1',
+        name: 'Acme',
+        slug: 'acme',
+        baseUrl: 'https://acme.test',
+        timeoutMs: 30000
+    };
+    it('takes the server’s value for a field it answered with', ()=>{
+        // Typed "Acme " with a trailing space; stored trimmed.
+        expect(draftPatchFromSource(stored).name).toBe('Acme');
+    });
+    /** The case this exists for: the box says empty, the server says 30000. */ it('corrects a timeout the server kept when the box was emptied', ()=>{
+        expect(draftPatchFromSource(stored).timeoutMs).toBe('30000');
+    });
+    it('says nothing at all about a field the reply left out', ()=>{
+        const patch = draftPatchFromSource({
+            id: 's1',
+            name: 'Acme'
+        });
+        expect(patch).toEqual({
+            name: 'Acme'
+        });
+        expect('slug' in patch).toBe(false);
+        expect('timeoutMs' in patch).toBe(false);
+    });
+    /**
+   * The failure this shape prevents: applied over a real draft, a partial reply
+   * must correct what it mentions and leave everything else alone.
+   */ it('leaves the rest of the draft untouched when applied over it', ()=>{
+        const draft = {
+            ...emptyConnectionDraft,
+            name: 'Acme ',
+            slug: 'acme',
+            baseUrl: 'https://a.test'
+        };
+        const next = {
+            ...draft,
+            ...draftPatchFromSource({
+                id: 's1',
+                name: 'Acme'
+            })
+        };
+        expect(next.name).toBe('Acme');
+        expect(next.slug).toBe('acme');
+        expect(next.baseUrl).toBe('https://a.test');
+    });
+    /** null is an answer — "no timeout" — not an absence. */ it('treats a null the server returned as a value, not as silence', ()=>{
+        expect(draftPatchFromSource({
+            id: 's1',
+            timeoutMs: null
+        }).timeoutMs).toBe('');
+    });
+});