nucleus-core-ts 0.9.796 → 0.9.798

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

@@ -4,6 +4,7 @@ import { useEffect, useEffectEvent, useState } from 'react';
 import { useIntegrationsStore } from '../store';
 import { integrationsPageTheme } from '../theme';
 import { EndpointFormFields } from './EndpointFormFields';
+import { formatJsonObject, parseJsonObject } from './jsonObjectField';
 import { PaginationFields } from './PaginationFields';
 import { ParamBindingRows } from './ParamBindingRows';
 import { pathParamNames } from './pathParams';
@@ -30,7 +31,9 @@ export function EndpointForm({ sourceId, endpoint, actions, onSaved, onDeleted,
         pagination: endpoint?.pagination ?? {
             kind: 'none'
         },
-        paramBindings: endpoint?.paramBindings ?? []
+        paramBindings: endpoint?.paramBindings ?? [],
+        queryParams: formatJsonObject(endpoint?.queryParams),
+        requestBody: formatJsonObject(endpoint?.requestBody)
     });
     // Which tables a binding may read a column from. Loaded once; the list is
     // small and an operator picking a parameter source should not wait for it.
@@ -59,7 +62,18 @@ export function EndpointForm({ sourceId, endpoint, actions, onSaved, onDeleted,
     const tag = draft.tag.trim();
     const path = draft.path.trim();
     const busy = saving || deleting;
-    const canSave = tag.length > 0 && path.length > 0;
+    // Parsed here rather than on save so the message appears under the field
+    // being typed in. A body stored as broken text fails at RUN time, against a
+    // live service, with an error that names neither this field nor this screen.
+    const parsedQuery = parseJsonObject(draft.queryParams);
+    const parsedBody = parseJsonObject(draft.requestBody);
+    const errors = {
+        queryParams: parsedQuery.ok ? undefined : parsedQuery.reason,
+        // A GET carries no body, so text left behind in that field cannot block a
+        // save it will never be part of.
+        requestBody: draft.method === 'GET' || parsedBody.ok ? undefined : parsedBody.reason
+    };
+    const canSave = tag.length > 0 && path.length > 0 && !errors.queryParams && !errors.requestBody;
     const handleSubmit = (event)=>{
         event.preventDefault();
         if (!canSave || busy) return;
@@ -79,6 +93,10 @@ export function EndpointForm({ sourceId, endpoint, actions, onSaved, onDeleted,
             responseRootPath: draft.responseRootPath.trim() || null,
             pagination: draft.pagination,
             paramBindings: draft.paramBindings,
+            queryParams: parsedQuery.ok ? parsedQuery.value : null,
+            // A GET's body is dropped rather than stored: the engine never sends one,
+            // and a value kept out of sight is a value that surprises someone later.
+            requestBody: draft.method === 'GET' ? null : parsedBody.ok ? parsedBody.value : null,
             enabled: draft.enabled
         }).then((saved)=>{
             setSaving(false);
@@ -114,6 +132,7 @@ export function EndpointForm({ sourceId, endpoint, actions, onSaved, onDeleted,
                     /*#__PURE__*/ _jsx(EndpointFormFields, {
                         disabled: busy,
                         draft: draft,
+                        errors: errors,
                         onChange: set
                     }),
                     /*#__PURE__*/ _jsx(PaginationFields, {

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

@@ -10,10 +10,19 @@ export type EndpointDraft = {
     pagination: PaginationProfileValue;
     /** Where each path/query parameter of this endpoint gets its value. */
     paramBindings: ParamBindingValue[];
+    /** JSON as typed. Parsed on save so a broken object cannot be stored. */
+    queryParams: string;
+    requestBody: string;
+};
+/** What could not be parsed, keyed the way the draft names it. */
+export type EndpointDraftErrors = {
+    queryParams?: string;
+    requestBody?: string;
 };
 export type EndpointFormFieldsProps = {
     draft: EndpointDraft;
     disabled?: boolean;
+    errors?: EndpointDraftErrors;
     onChange: (patch: Partial<EndpointDraft>) => void;
 };
-export declare function EndpointFormFields({ draft, disabled, onChange }: EndpointFormFieldsProps): import("react/jsx-runtime").JSX.Element;
+export declare function EndpointFormFields({ draft, disabled, errors, onChange }: EndpointFormFieldsProps): import("react/jsx-runtime").JSX.Element;

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

@@ -2,6 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { cn } from '../../../utils/cn';
 import { integrationsPageTheme } from '../theme';
+import { describedBy } from './formSupport';
 import { Field } from './Primitives';
 /**
  * The plain fields of an endpoint.
@@ -16,7 +17,7 @@ const METHODS = [
     'PATCH',
     'DELETE'
 ];
-export function EndpointFormFields({ draft, disabled, onChange }) {
+export function EndpointFormFields({ draft, disabled, errors, onChange }) {
     return /*#__PURE__*/ _jsxs(_Fragment, {
         children: [
             /*#__PURE__*/ _jsxs("div", {
@@ -122,6 +123,42 @@ export function EndpointFormFields({ draft, disabled, onChange }) {
                     value: draft.responseRootPath
                 })
             }),
+            /*#__PURE__*/ _jsx(Field, {
+                error: errors?.queryParams,
+                hint: "Sent with every call, as JSON. A parameter bound below overrides the same name here.",
+                htmlFor: "endpoint-query",
+                label: "Fixed query parameters",
+                children: /*#__PURE__*/ _jsx("textarea", {
+                    "aria-describedby": describedBy('endpoint-query', true, Boolean(errors?.queryParams)),
+                    className: cn(theme.field.input, 'h-auto min-h-16 py-2 font-mono text-xs'),
+                    disabled: disabled,
+                    id: "endpoint-query",
+                    onChange: (event)=>onChange({
+                            queryParams: event.target.value
+                        }),
+                    placeholder: '{"state": "ACTIVE"}',
+                    rows: 3,
+                    value: draft.queryParams
+                })
+            }),
+            draft.method === 'GET' ? null : /*#__PURE__*/ _jsx(Field, {
+                error: errors?.requestBody,
+                hint: "The JSON body sent with this call. Some list endpoints are a POST whose body decides what comes back.",
+                htmlFor: "endpoint-body",
+                label: "Request body",
+                children: /*#__PURE__*/ _jsx("textarea", {
+                    "aria-describedby": describedBy('endpoint-body', true, Boolean(errors?.requestBody)),
+                    className: cn(theme.field.input, 'h-auto min-h-20 py-2 font-mono text-xs'),
+                    disabled: disabled,
+                    id: "endpoint-body",
+                    onChange: (event)=>onChange({
+                            requestBody: event.target.value
+                        }),
+                    placeholder: '{"employeeTypes": ["A", "S"]}',
+                    rows: 4,
+                    value: draft.requestBody
+                })
+            }),
             /*#__PURE__*/ _jsx(Field, {
                 htmlFor: "endpoint-description",
                 label: "Description",

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

@@ -43,9 +43,13 @@ export function RunPlanIssues({ issues }) {
                                 className: theme.field.hint,
                                 children: `Dedup key: ${issue.dedupKey}`
                             }) : null,
+                            issue.keptRow ? /*#__PURE__*/ _jsx("span", {
+                                className: theme.field.hint,
+                                children: `Kept — ${describeRow(issue.keptRow)}`
+                            }) : null,
                             issue.row ? /*#__PURE__*/ _jsx("span", {
                                 className: theme.field.hint,
-                                children: describeRow(issue.row)
+                                children: issue.keptRow ? `Skipped — ${describeRow(issue.row)}` : describeRow(issue.row)
                             }) : null
                         ]
                     }, `${issue.sourceIndex}-${issue.kind}-${index}`))

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

@@ -0,0 +1,27 @@
+/**
+ * A JSON object typed into a form field.
+ *
+ * Query parameters and a request body are `Record<string, unknown>` on the wire
+ * — an endpoint may need `{"employeeTypes": ["A", "S"]}`, which no key/value
+ * grid of strings can express. So the field takes JSON, and the only question
+ * is whether a form is allowed to save what it cannot parse. It is not: a body
+ * saved as broken text fails at RUN time, against a live service, with an error
+ * from somewhere else entirely.
+ */
+export type JsonObjectResult = {
+    ok: true;
+    value: Record<string, unknown> | null;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Parses the text of a JSON-object field.
+ *
+ * Empty is `null` rather than `{}` — "nothing configured" and "an empty object
+ * configured" read the same on screen but not in a request, and the column is
+ * nullable precisely so the difference survives.
+ */
+export declare function parseJsonObject(text: string): JsonObjectResult;
+/** What a stored object looks like back in the field. */
+export declare function formatJsonObject(value: Record<string, unknown> | null | undefined): string;

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

@@ -0,0 +1,49 @@
+/**
+ * A JSON object typed into a form field.
+ *
+ * Query parameters and a request body are `Record<string, unknown>` on the wire
+ * — an endpoint may need `{"employeeTypes": ["A", "S"]}`, which no key/value
+ * grid of strings can express. So the field takes JSON, and the only question
+ * is whether a form is allowed to save what it cannot parse. It is not: a body
+ * saved as broken text fails at RUN time, against a live service, with an error
+ * from somewhere else entirely.
+ */ /**
+ * Parses the text of a JSON-object field.
+ *
+ * Empty is `null` rather than `{}` — "nothing configured" and "an empty object
+ * configured" read the same on screen but not in a request, and the column is
+ * nullable precisely so the difference survives.
+ */ export function parseJsonObject(text) {
+    const trimmed = text.trim();
+    if (trimmed === '') return {
+        ok: true,
+        value: null
+    };
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    } catch (error) {
+        return {
+            ok: false,
+            reason: error instanceof Error ? error.message : 'This is not valid JSON.'
+        };
+    }
+    if (parsed === null) return {
+        ok: true,
+        value: null
+    };
+    if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return {
+            ok: false,
+            reason: 'Expected an object — {"key": "value"}.'
+        };
+    }
+    return {
+        ok: true,
+        value: parsed
+    };
+}
+/** What a stored object looks like back in the field. */ export function formatJsonObject(value) {
+    if (!value || Object.keys(value).length === 0) return '';
+    return JSON.stringify(value, null, 2);
+}

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

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

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

@@ -0,0 +1,86 @@
+import { describe, expect, test } from 'bun:test';
+import { formatJsonObject, parseJsonObject } from './jsonObjectField';
+/**
+ * The HR service's employee list is a POST whose body selects which employees
+ * come back — `{"employeeTypes": ["A", "S"]}`. The engine has always sent a
+ * stored body; the panel had no field for one, so that endpoint could be
+ * described everywhere except in the one place that decides what it returns.
+ */ describe('parseJsonObject', ()=>{
+    test('an object comes back as an object', ()=>{
+        expect(parseJsonObject('{"employeeTypes": ["A", "S"]}')).toEqual({
+            ok: true,
+            value: {
+                employeeTypes: [
+                    'A',
+                    'S'
+                ]
+            }
+        });
+    });
+    test('empty means nothing configured, not an empty object', ()=>{
+        expect(parseJsonObject('')).toEqual({
+            ok: true,
+            value: null
+        });
+        expect(parseJsonObject('   \n ')).toEqual({
+            ok: true,
+            value: null
+        });
+        expect(parseJsonObject('null')).toEqual({
+            ok: true,
+            value: null
+        });
+    });
+    test('broken JSON is refused here rather than at run time', ()=>{
+        const result = parseJsonObject('{"a": }');
+        expect(result.ok).toBe(false);
+        if (!result.ok) expect(result.reason.length).toBeGreaterThan(0);
+    });
+    test('an array or a scalar is not a body — both are refused', ()=>{
+        expect(parseJsonObject('[1, 2]').ok).toBe(false);
+        expect(parseJsonObject('"text"').ok).toBe(false);
+        expect(parseJsonObject('42').ok).toBe(false);
+    });
+    test('nested values survive, which is why this is JSON and not a key/value grid', ()=>{
+        const result = parseJsonObject('{"filter": {"state": ["ACTIVE"], "limit": 50}}');
+        expect(result).toEqual({
+            ok: true,
+            value: {
+                filter: {
+                    state: [
+                        'ACTIVE'
+                    ],
+                    limit: 50
+                }
+            }
+        });
+    });
+});
+describe('formatJsonObject', ()=>{
+    test('a stored object comes back readable', ()=>{
+        expect(formatJsonObject({
+            employeeTypes: [
+                'A'
+            ]
+        })).toBe('{\n  "employeeTypes": [\n    "A"\n  ]\n}');
+    });
+    test('nothing stored shows an empty field, not the word null or a bare {}', ()=>{
+        expect(formatJsonObject(null)).toBe('');
+        expect(formatJsonObject(undefined)).toBe('');
+        expect(formatJsonObject({})).toBe('');
+    });
+    test('a round trip through the form changes nothing', ()=>{
+        const original = {
+            employeeTypes: [
+                'A',
+                'S'
+            ],
+            employeeNo: '101307'
+        };
+        const result = parseJsonObject(formatJsonObject(original));
+        expect(result).toEqual({
+            ok: true,
+            value: original
+        });
+    });
+});

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

@@ -16,6 +16,8 @@ export type RunIssueValue = {
      * narrow and rows are being lost. The values are the difference.
      */
     row?: Record<string, unknown>;
+    /** The record that claimed this key first — what the skipped one lost to. */
+    keptRow?: Record<string, unknown>;
 };
 /** What a run would do, computed without writing. */
 export type RunPlanValue = {