nucleus-core-ts 0.9.828 → 0.9.830

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

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useId } from 'react';
-import { describeCron, parseCron } from '../../../../src/Services/Integrations/cron';
+import { describeCron, parseCron } from '../../../../src/Shared/cron';
 import { integrationsPageTheme } from '../theme';
 import { Field, Notice } from './Primitives';
 /**

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

@@ -191,6 +191,95 @@ export function ReferenceCheckRows({ rows, targetFields, targets, disabled, onCh
                                     })
                                 ]
                             }),
+                            row.onMissing === 'create' ? /*#__PURE__*/ _jsxs("div", {
+                                className: "mt-3 flex flex-col gap-2",
+                                children: [
+                                    /*#__PURE__*/ _jsxs("div", {
+                                        className: "flex flex-wrap items-center justify-between gap-2",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("span", {
+                                                className: theme.field.label,
+                                                children: "Also fill on the values it creates"
+                                            }),
+                                            /*#__PURE__*/ _jsx("button", {
+                                                className: theme.button.ghost,
+                                                disabled: disabled || !referenced,
+                                                onClick: ()=>patch(index, {
+                                                        createValues: [
+                                                            ...row.createValues ?? [],
+                                                            {
+                                                                column: '',
+                                                                from: ''
+                                                            }
+                                                        ]
+                                                    }),
+                                                type: "button",
+                                                children: "Add a column"
+                                            })
+                                        ]
+                                    }),
+                                    (row.createValues ?? []).length === 0 ? /*#__PURE__*/ _jsx("p", {
+                                        className: theme.field.hint,
+                                        children: `A new ${row.entity || 'row'} carries only the value itself. The record that needed it usually has the rest — its code, its parent — and those can be filled here.`
+                                    }) : null,
+                                    (row.createValues ?? []).map((pair, pairIndex)=>/*#__PURE__*/ _jsxs("div", {
+                                            className: "grid grid-cols-1 gap-2 sm:grid-cols-[1fr_1fr_auto]",
+                                            children: [
+                                                /*#__PURE__*/ _jsxs("select", {
+                                                    className: theme.field.input,
+                                                    disabled: disabled,
+                                                    onChange: (event)=>patch(index, {
+                                                            createValues: (row.createValues ?? []).with(pairIndex, {
+                                                                ...pair,
+                                                                column: event.target.value
+                                                            })
+                                                        }),
+                                                    value: pair.column,
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx("option", {
+                                                            value: "",
+                                                            children: "Column to fill…"
+                                                        }),
+                                                        (referenced?.fields ?? []).map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                                value: field,
+                                                                children: field
+                                                            }, field))
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ _jsxs("select", {
+                                                    className: theme.field.input,
+                                                    disabled: disabled,
+                                                    onChange: (event)=>patch(index, {
+                                                            createValues: (row.createValues ?? []).with(pairIndex, {
+                                                                ...pair,
+                                                                from: event.target.value
+                                                            })
+                                                        }),
+                                                    value: pair.from,
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx("option", {
+                                                            value: "",
+                                                            children: "…from this record's"
+                                                        }),
+                                                        targetFields.map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                                value: field,
+                                                                children: field
+                                                            }, field))
+                                                    ]
+                                                }),
+                                                /*#__PURE__*/ _jsx("button", {
+                                                    className: theme.button.ghost,
+                                                    disabled: disabled,
+                                                    onClick: ()=>patch(index, {
+                                                            createValues: (row.createValues ?? []).toSpliced(pairIndex, 1)
+                                                        }),
+                                                    type: "button",
+                                                    children: "Remove"
+                                                })
+                                            ]
+                                        }, pairIndex))
+                                ]
+                            }) : null,
                             /*#__PURE__*/ _jsxs("div", {
                                 className: "mt-2 flex items-center justify-between gap-3",
                                 children: [

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

@@ -5,6 +5,7 @@ import { useIntegrationsStore } from '../store';
 import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { Notice } from './Primitives';
+import { passwordIsNeeded } from './passwordIsNeeded';
 import { RunConfirmStep } from './RunConfirmStep';
 import { MIN_SHARED_PASSWORD, RunPasswordField } from './RunPasswordField';
 import { RunPlanReferences } from './RunPlanReferences';
@@ -35,7 +36,12 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
     // here, once, and goes no further than this run.
     const accountRule = mapping.accountRule ?? null;
     const passwordColumn = mapping.passwordTargetColumn ?? '';
-    const needsPassword = passwordColumn !== '' || accountRule !== null;
+    // ONE answer, used by the field, the button and the request alike. Asked three
+    // times in three places, they drifted: the field appeared and the button
+    // enabled, while the request still tested the older condition and sent no
+    // password at all — so every import that created logins was refused, by a
+    // message the app then replaced with "the import did not start".
+    const needsPassword = passwordIsNeeded(mapping);
     const passwordReady = !needsPassword || sharedPassword.length >= MIN_SHARED_PASSWORD;
     const activeRunId = store.activeRunId;
     const plan = store.plan;
@@ -53,7 +59,7 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
     const start = (confirm, referenceMode)=>{
         store.setError(null);
         setStarting(true);
-        actions.startRun(mapping.id, confirm, passwordColumn ? sharedPassword : undefined, referenceMode).then((result)=>{
+        actions.startRun(mapping.id, confirm, needsPassword ? sharedPassword : undefined, referenceMode).then((result)=>{
             setStarting(false);
             // The server decides what counts as destructive; the panel only asks.
             if (result.needsConfirm) {

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

@@ -0,0 +1,16 @@
+import type { IntegrationMapping } from '../types';
+/**
+ * Does starting this import require a password?
+ *
+ * Two ways it can: the mapping writes one into a column of the record's own
+ * table, or it creates a login alongside each record. Either way the operator
+ * types it once, on the run screen, and it goes no further than that run.
+ *
+ * A function rather than three expressions, because it WAS three: the field that
+ * asks for the password, the button that starts the import, and the request that
+ * carries it each decided for themselves. Two were updated when accounts were
+ * added and one was not — so the field appeared, the button enabled, and the
+ * request sent nothing. Every import that created logins was refused for a
+ * missing password the operator had typed.
+ */
+export declare function passwordIsNeeded(mapping: IntegrationMapping): boolean;

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

@@ -0,0 +1,16 @@
+/**
+ * Does starting this import require a password?
+ *
+ * Two ways it can: the mapping writes one into a column of the record's own
+ * table, or it creates a login alongside each record. Either way the operator
+ * types it once, on the run screen, and it goes no further than that run.
+ *
+ * A function rather than three expressions, because it WAS three: the field that
+ * asks for the password, the button that starts the import, and the request that
+ * carries it each decided for themselves. Two were updated when accounts were
+ * added and one was not — so the field appeared, the button enabled, and the
+ * request sent nothing. Every import that created logins was refused for a
+ * missing password the operator had typed.
+ */ export function passwordIsNeeded(mapping) {
+    return Boolean(mapping.passwordTargetColumn) || mapping.accountRule != null;
+}

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

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'bun:test';
+import { passwordIsNeeded } from './passwordIsNeeded';
+/**
+ * The field that ASKS for the password, the button that starts the import and
+ * the request that CARRIES it each decided this for themselves. Two were updated
+ * when accounts were added and one was not: the field appeared, the button
+ * enabled, and the request sent nothing — so every import that created logins
+ * was refused for a password the operator had typed.
+ */ const mapping = (over)=>({
+        id: 'm1',
+        name: 'x',
+        targetEntity: 'employees',
+        ...over
+    });
+describe('does this import need a password', ()=>{
+    it('yes, when it writes one into the record own table', ()=>{
+        expect(passwordIsNeeded(mapping({
+            passwordTargetColumn: 'passwordHash'
+        }))).toBe(true);
+    });
+    it('yes, when it creates a login alongside each record', ()=>{
+        // The case that was missed. Nothing about the record's own table says so.
+        expect(passwordIsNeeded(mapping({
+            accountRule: {
+                entity: 'users',
+                idColumn: 'userId',
+                matchColumn: 'email',
+                matchFrom: 'email',
+                passwordColumn: 'password'
+            }
+        }))).toBe(true);
+    });
+    it('no, for an import that creates no accounts at all', ()=>{
+        expect(passwordIsNeeded(mapping({}))).toBe(false);
+        expect(passwordIsNeeded(mapping({
+            passwordTargetColumn: null,
+            accountRule: null
+        }))).toBe(false);
+    });
+    it('treats an empty column name as no column', ()=>{
+        expect(passwordIsNeeded(mapping({
+            passwordTargetColumn: ''
+        }))).toBe(false);
+    });
+});

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

@@ -111,6 +111,16 @@ export type ReferenceCheckValue = {
     /** Column in that entity to match against. */
     entityColumn: string;
     onMissing: 'create' | 'skipRecord' | 'ignore';
+    /**
+     * Other columns to fill when this run CREATES the missing value.
+     *
+     * A department created from nothing but its own name is a row somebody has to
+     * finish by hand — and the record that needed it usually carries the rest.
+     */
+    createValues?: {
+        column: string;
+        from: string;
+    }[];
 };
 /**
  * A login created alongside each imported record.