nucleus-core-ts 0.9.781 → 0.9.783

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

@@ -0,0 +1,150 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { integrationsPageTheme } from '../theme';
+import { Field, Notice } from './Primitives';
+/**
+ * The two choices that decide what an import DOES to the table.
+ *
+ * They sit together because they are the destructive pair: one decides how the
+ * fetched records land, the other decides what happens to the rows the source
+ * stopped sending. Every other field on a mapping only moves values around.
+ */ const theme = integrationsPageTheme;
+const WRITE_MODES = [
+    'upsert',
+    'append',
+    'replace'
+];
+const WRITE_MODE_LABEL = {
+    upsert: 'Upsert — update what matches, insert the rest',
+    append: 'Append — insert every fetched record',
+    replace: 'Replace — rebuild the table from this response'
+};
+const WRITE_MODE_HINT = {
+    upsert: 'Rows keep their identity, so whatever points at them keeps working.',
+    append: 'Nothing is matched, so running this import twice stores every record twice.',
+    replace: 'The table is emptied and refilled on every run.'
+};
+const MISSING_POLICIES = [
+    'ignore',
+    'deactivate',
+    'delete'
+];
+const MISSING_POLICY_LABEL = {
+    ignore: 'Ignore — leave them exactly as they are',
+    deactivate: 'Deactivate — mark them with a column value',
+    delete: 'Delete — remove them from the table'
+};
+const MISSING_POLICY_HINT = {
+    ignore: 'Safest. Records removed at the source stay in the table until someone acts.',
+    deactivate: 'Reversible. The row survives and history that refers to it stays readable.',
+    delete: 'Permanent. A source that returns a short page for any reason takes rows with it.'
+};
+function toWriteMode(value) {
+    return WRITE_MODES.find((mode)=>mode === value) ?? 'upsert';
+}
+function toMissingPolicy(value) {
+    return MISSING_POLICIES.find((policy)=>policy === value) ?? 'ignore';
+}
+/** Deactivate has nowhere to write its flag without both of these. */ export function missingRecordFieldsIncomplete(policy, column, value) {
+    return policy === 'deactivate' && (column.trim() === '' || value.trim() === '');
+}
+export function MappingWriteModeFields({ idPrefix, writeMode, missingRecordPolicy, missingRecordColumn, missingRecordValue, dedupConfigured, disabled, onWriteModeChange, onMissingRecordPolicyChange, onMissingRecordColumnChange, onMissingRecordValueChange }) {
+    const modeId = `${idPrefix}-write-mode`;
+    const policyId = `${idPrefix}-missing-policy`;
+    const columnId = `${idPrefix}-missing-column`;
+    const valueId = `${idPrefix}-missing-value`;
+    const columnMissing = missingRecordPolicy === 'deactivate' && missingRecordColumn.trim() === '';
+    const valueMissing = missingRecordPolicy === 'deactivate' && missingRecordValue.trim() === '';
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "flex flex-col gap-3",
+        children: [
+            /*#__PURE__*/ _jsx(Field, {
+                htmlFor: modeId,
+                hint: WRITE_MODE_HINT[writeMode],
+                label: "Write mode",
+                children: /*#__PURE__*/ _jsx("select", {
+                    "aria-describedby": `${modeId}-hint`,
+                    className: theme.field.input,
+                    disabled: disabled,
+                    id: modeId,
+                    onChange: (event)=>onWriteModeChange(toWriteMode(event.target.value)),
+                    value: writeMode,
+                    children: WRITE_MODES.map((mode)=>/*#__PURE__*/ _jsx("option", {
+                            value: mode,
+                            children: WRITE_MODE_LABEL[mode]
+                        }, mode))
+                })
+            }),
+            writeMode === 'replace' ? /*#__PURE__*/ _jsxs(Notice, {
+                title: "Replace rebuilds the table on every run",
+                tone: "danger",
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        children: "Every existing row is dropped and written again, so row ids change. Foreign keys, saved links, exports, report filters and anything else holding one of those ids breaks, and no amount of re-running repairs it."
+                    }),
+                    /*#__PURE__*/ _jsx("p", {
+                        className: "mt-1",
+                        children: dedupConfigured ? 'This mapping already has a deduplication field, so Upsert does the same job in place and the ids survive.' : 'Set a deduplication field and choose Upsert instead: it matches each record and updates it in place, leaving the ids alone.'
+                    })
+                ]
+            }) : null,
+            /*#__PURE__*/ _jsx(Field, {
+                htmlFor: policyId,
+                hint: MISSING_POLICY_HINT[missingRecordPolicy],
+                label: "Records the source no longer returns",
+                children: /*#__PURE__*/ _jsx("select", {
+                    "aria-describedby": `${policyId}-hint`,
+                    className: theme.field.input,
+                    disabled: disabled,
+                    id: policyId,
+                    onChange: (event)=>onMissingRecordPolicyChange(toMissingPolicy(event.target.value)),
+                    value: missingRecordPolicy,
+                    children: MISSING_POLICIES.map((policy)=>/*#__PURE__*/ _jsx("option", {
+                            value: policy,
+                            children: MISSING_POLICY_LABEL[policy]
+                        }, policy))
+                })
+            }),
+            missingRecordPolicy === 'delete' ? /*#__PURE__*/ _jsx(Notice, {
+                title: "Deleting is not reversible",
+                tone: "warning",
+                children: "A source that answers with a short page — a filter left on, a timeout, an expired token honoured with an empty list — looks exactly like records that went away."
+            }) : null,
+            missingRecordPolicy === 'deactivate' ? /*#__PURE__*/ _jsxs("div", {
+                className: "grid grid-cols-1 gap-3 sm:grid-cols-2",
+                children: [
+                    /*#__PURE__*/ _jsx(Field, {
+                        error: columnMissing ? 'Required while Deactivate is selected.' : null,
+                        hint: "A column on the target entity.",
+                        htmlFor: columnId,
+                        label: "Deactivation column",
+                        children: /*#__PURE__*/ _jsx("input", {
+                            "aria-describedby": `${columnId}-hint`,
+                            className: theme.field.input,
+                            disabled: disabled,
+                            id: columnId,
+                            onChange: (event)=>onMissingRecordColumnChange(event.target.value),
+                            placeholder: "isActive",
+                            value: missingRecordColumn
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx(Field, {
+                        error: valueMissing ? 'Required while Deactivate is selected.' : null,
+                        hint: "Written into that column.",
+                        htmlFor: valueId,
+                        label: "Deactivation value",
+                        children: /*#__PURE__*/ _jsx("input", {
+                            "aria-describedby": `${valueId}-hint`,
+                            className: theme.field.input,
+                            disabled: disabled,
+                            id: valueId,
+                            onChange: (event)=>onMissingRecordValueChange(event.target.value),
+                            placeholder: "false",
+                            value: missingRecordValue
+                        })
+                    })
+                ]
+            }) : null
+        ]
+    });
+}

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

@@ -0,0 +1,5 @@
+import type { IntegrationsActions } from '../types';
+export type MappingsTabProps = {
+    actions: IntegrationsActions;
+};
+export declare function MappingsTab({ actions }: MappingsTabProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,154 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useEffectEvent, useState } from 'react';
+import { useIntegrationsStore } from '../store';
+import { integrationsPageTheme } from '../theme';
+import { MappingEditor } from './MappingEditor';
+import { MappingList } from './MappingList';
+import { blankMappingDraft, toMappingDraft } from './mappingDraft';
+import { Notice } from './Primitives';
+/**
+ * The mappings of the selected connection: the list on one side, the mapping
+ * being edited on the other.
+ *
+ * Only this component talks to the injected actions — the list renders what it
+ * is given and the editor edits a draft, so neither can save half a change on
+ * its own or refetch behind the other's back.
+ */ const theme = integrationsPageTheme;
+function messageOf(error) {
+    return error instanceof Error ? error.message : 'The request failed.';
+}
+export function MappingsTab({ actions }) {
+    const store = useIntegrationsStore();
+    const [targets, setTargets] = useState([]);
+    const [targetsLoading, setTargetsLoading] = useState(true);
+    const [selected, setSelected] = useState(null);
+    const [creating, setCreating] = useState(false);
+    const [saving, setSaving] = useState(false);
+    const [deleting, setDeleting] = useState(false);
+    const [reloadToken, setReloadToken] = useState(0);
+    const sourceId = store.selectedSourceId ?? '';
+    const newMappingEndpointId = store.selectedEndpointId ?? store.endpoints[0]?.id ?? '';
+    const loadTargets = useEffectEvent(()=>{
+        setTargetsLoading(true);
+        actions.listTargets().then((result)=>{
+            setTargets(result);
+            setTargetsLoading(false);
+        }).catch((error)=>{
+            setTargetsLoading(false);
+            store.setError(messageOf(error));
+        });
+    });
+    useEffect(()=>{
+        loadTargets();
+    }, []);
+    const startNew = ()=>{
+        setSelected(null);
+        setCreating(true);
+        store.selectMapping(null);
+    };
+    const openMapping = (mapping)=>{
+        setCreating(false);
+        setSelected(mapping);
+        store.selectMapping(mapping.id);
+    };
+    const closeEditor = ()=>{
+        setCreating(false);
+        setSelected(null);
+        store.selectMapping(null);
+    };
+    const save = (draft)=>{
+        setSaving(true);
+        store.setError(null);
+        actions.saveMapping(draft).then((saved)=>{
+            setSaving(false);
+            if (!saved) return store.setError('The mapping was not saved.');
+            setCreating(false);
+            setSelected(saved);
+            store.selectMapping(saved.id);
+            setReloadToken((token)=>token + 1);
+        }).catch((error)=>{
+            setSaving(false);
+            store.setError(messageOf(error));
+        });
+    };
+    const remove = (id)=>{
+        if (id === '') return;
+        setDeleting(true);
+        store.setError(null);
+        actions.deleteMapping(id).then((removed)=>{
+            setDeleting(false);
+            if (!removed) return store.setError('The mapping was not deleted.');
+            closeEditor();
+            setReloadToken((token)=>token + 1);
+        }).catch((error)=>{
+            setDeleting(false);
+            store.setError(messageOf(error));
+        });
+    };
+    const draft = creating ? blankMappingDraft(newMappingEndpointId) : selected ? toMappingDraft(selected) : null;
+    // A sample describes ONE endpoint. Offering its field names against a mapping
+    // that reads from a different one would suggest columns that never arrive.
+    const sourceFields = draft && store.selectedEndpointId === draft.endpointId ? store.sample?.fields ?? [] : [];
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "flex flex-col gap-4",
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.header.wrapper,
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        className: theme.header.subtitle,
+                        children: "A mapping turns one endpoint's response into rows of one entity."
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        className: theme.header.actions,
+                        children: /*#__PURE__*/ _jsx("button", {
+                            className: theme.button.primary,
+                            disabled: newMappingEndpointId === '',
+                            onClick: startNew,
+                            type: "button",
+                            children: "New mapping"
+                        })
+                    })
+                ]
+            }),
+            newMappingEndpointId === '' ? /*#__PURE__*/ _jsx(Notice, {
+                title: "Select an endpoint first",
+                tone: "info",
+                children: "Every mapping reads from one endpoint. Choose one on the Endpoints tab and it becomes the source of the next mapping created here."
+            }) : null,
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.layout.split,
+                children: [
+                    /*#__PURE__*/ _jsx("div", {
+                        className: theme.layout.aside,
+                        children: /*#__PURE__*/ _jsx(MappingList, {
+                            actions: actions,
+                            sourceId: sourceId,
+                            onSelect: openMapping,
+                            reloadToken: reloadToken,
+                            selectedId: selected?.id ?? null
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        className: theme.layout.main,
+                        children: draft ? /*#__PURE__*/ _jsx(MappingEditor, {
+                            deleting: deleting,
+                            mapping: draft,
+                            onCancel: closeEditor,
+                            onDelete: remove,
+                            onSave: save,
+                            saving: saving,
+                            sourceFields: sourceFields,
+                            targets: targets,
+                            targetsLoading: targetsLoading
+                        }, draft.id ?? 'new-mapping') : /*#__PURE__*/ _jsx("p", {
+                            className: theme.list.empty,
+                            children: "Pick a mapping to edit it, or create one to describe what an import writes."
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { PaginationProfileValue } from '../types';
+export type PaginationFieldsProps = {
+    /** Prefixes every control id so two of these can share one page. */
+    idPrefix: string;
+    value: PaginationProfileValue;
+    disabled?: boolean;
+    onChange: (next: PaginationProfileValue) => void;
+};
+export declare function PaginationFields({ idPrefix, value, disabled, onChange }: PaginationFieldsProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,218 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { integrationsPageTheme } from '../theme';
+import { Field, Notice } from './Primitives';
+/**
+ * How the panel walks a list endpoint to its end.
+ *
+ * Nothing here is detected. The profile is a statement about the API being read,
+ * and the warning above the picker is why it has to be one: the wrong choice
+ * does not fail — it succeeds on page one and reports a total that looks fine.
+ */ const theme = integrationsPageTheme;
+const KINDS = [
+    {
+        value: 'none',
+        label: 'None — one response holds every record'
+    },
+    {
+        value: 'page_number',
+        label: 'Page number — ?page=1&size=100'
+    },
+    {
+        value: 'offset',
+        label: 'Offset — ?offset=0&limit=100'
+    },
+    {
+        value: 'cursor',
+        label: 'Cursor — the body carries a token for the next page'
+    },
+    {
+        value: 'link_header',
+        label: 'Link header — RFC 5988 rel="next"'
+    }
+];
+const TOTAL_HINT = 'Dotted path to the record count, when the body reports one.';
+const SIZE_LABEL = 'Records per request';
+/** Only the parameters the chosen style actually sends. */ const FIELDS = {
+    none: [],
+    page_number: [
+        {
+            as: 'text',
+            key: 'pageParam',
+            label: 'Page query parameter',
+            placeholder: 'page'
+        },
+        {
+            as: 'text',
+            key: 'sizeParam',
+            label: 'Page size query parameter',
+            placeholder: 'size'
+        },
+        {
+            as: 'number',
+            key: 'firstPage',
+            label: 'First page number',
+            placeholder: '1',
+            hint: 'Some APIs count from 0, most from 1.'
+        },
+        {
+            as: 'number',
+            key: 'pageSize',
+            label: SIZE_LABEL,
+            placeholder: '100'
+        },
+        {
+            as: 'text',
+            key: 'totalPath',
+            label: 'Total count path',
+            placeholder: 'meta.totalItems',
+            hint: TOTAL_HINT
+        },
+        {
+            as: 'text',
+            key: 'lastPagePath',
+            label: 'Last page path',
+            placeholder: 'meta.totalPages',
+            hint: 'Stops the walk when there is a last page number but no total.'
+        }
+    ],
+    offset: [
+        {
+            as: 'text',
+            key: 'offsetParam',
+            label: 'Offset query parameter',
+            placeholder: 'offset'
+        },
+        {
+            as: 'text',
+            key: 'limitParam',
+            label: 'Limit query parameter',
+            placeholder: 'limit'
+        },
+        {
+            as: 'number',
+            key: 'pageSize',
+            label: SIZE_LABEL,
+            placeholder: '100'
+        },
+        {
+            as: 'text',
+            key: 'totalPath',
+            label: 'Total count path',
+            placeholder: 'meta.totalItems',
+            hint: TOTAL_HINT
+        }
+    ],
+    cursor: [
+        {
+            as: 'text',
+            key: 'cursorParam',
+            label: 'Cursor query parameter',
+            placeholder: 'cursor'
+        },
+        {
+            as: 'text',
+            key: 'nextCursorPath',
+            label: 'Next cursor path',
+            placeholder: 'meta.nextCursor',
+            hint: 'Dotted path to the next token. Empty or absent ends the walk.'
+        },
+        {
+            as: 'number',
+            key: 'pageSize',
+            label: SIZE_LABEL,
+            placeholder: '100'
+        }
+    ],
+    link_header: [
+        {
+            as: 'text',
+            key: 'sizeParam',
+            label: 'Page size query parameter',
+            placeholder: 'per_page',
+            hint: 'Only if the API accepts one; the next URL comes from the header.'
+        },
+        {
+            as: 'number',
+            key: 'pageSize',
+            label: SIZE_LABEL,
+            placeholder: '100'
+        }
+    ]
+};
+export function PaginationFields({ idPrefix, value, disabled, onChange }) {
+    const write = (spec, entered)=>{
+        const next = {
+            ...value
+        };
+        if (spec.as === 'number') {
+            const parsed = Number.parseInt(entered, 10);
+            next[spec.key] = Number.isFinite(parsed) ? parsed : undefined;
+        } else {
+            next[spec.key] = entered;
+        }
+        onChange(next);
+    };
+    const read = (spec)=>{
+        const current = value[spec.key];
+        return current === undefined || current === null ? '' : String(current);
+    };
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "flex flex-col gap-3",
+        children: [
+            /*#__PURE__*/ _jsx(Notice, {
+                title: "The pagination profile is chosen, not guessed",
+                tone: "warning",
+                children: "Nothing here is detected for you. Pick the wrong style and the import still succeeds — it reads the first page and never asks for the rest. In a destructive write mode the records it never saw count as missing, so the run deletes or deactivates them."
+            }),
+            /*#__PURE__*/ _jsx(Field, {
+                hint: "Match this to how the API documents its own list endpoints.",
+                htmlFor: `${idPrefix}-kind`,
+                label: "Pagination style",
+                children: /*#__PURE__*/ _jsx("select", {
+                    "aria-describedby": `${idPrefix}-kind-hint`,
+                    className: theme.field.input,
+                    disabled: disabled,
+                    id: `${idPrefix}-kind`,
+                    onChange: (event)=>onChange({
+                            ...value,
+                            kind: toKind(event.target.value)
+                        }),
+                    value: value.kind,
+                    children: KINDS.map((option)=>/*#__PURE__*/ _jsx("option", {
+                            value: option.value,
+                            children: option.label
+                        }, option.value))
+                })
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                className: "grid grid-cols-1 gap-3 sm:grid-cols-2",
+                children: FIELDS[value.kind].map((spec)=>{
+                    const id = `${idPrefix}-${spec.key}`;
+                    return /*#__PURE__*/ _jsx(Field, {
+                        hint: spec.hint,
+                        htmlFor: id,
+                        label: spec.label,
+                        children: /*#__PURE__*/ _jsx("input", {
+                            "aria-describedby": spec.hint ? `${id}-hint` : undefined,
+                            className: theme.field.input,
+                            disabled: disabled,
+                            id: id,
+                            inputMode: spec.as === 'number' ? 'numeric' : 'text',
+                            onChange: (event)=>write(spec, event.target.value),
+                            placeholder: spec.placeholder,
+                            type: "text",
+                            value: read(spec)
+                        })
+                    }, spec.key);
+                })
+            })
+        ]
+    });
+}
+function toKind(candidate) {
+    for (const option of KINDS){
+        if (option.value === candidate) return option.value;
+    }
+    return 'none';
+}

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

@@ -0,0 +1,24 @@
+import type { IntegrationEndpoint, ParamBindingValue } from '../types';
+/**
+ * One parameter and where its value comes from.
+ *
+ * Split out of the list because the three sources each need different controls,
+ * and keeping them together put the whole screen over the size a single file is
+ * allowed to be.
+ */
+export type ParamBindingRowProps = {
+    binding: ParamBindingValue;
+    onChange: (next: ParamBindingValue) => void;
+    onRemove: () => void;
+    siblings: IntegrationEndpoint[];
+    entities: {
+        entity: string;
+        label: string;
+        fields: string[];
+    }[];
+    disabled: boolean;
+};
+export declare function ParamBindingRow({ binding, onChange, onRemove, siblings, entities, disabled, }: ParamBindingRowProps): import("react/jsx-runtime").JSX.Element;
+export type ParamBindingValueFieldsProps = ParamBindingRowProps & {
+    rowId: string;
+};