nucleus-core-ts 0.9.825 → 0.9.826

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

@@ -7,6 +7,7 @@ import { FieldMappingRows } from './FieldMappingRows';
 import { endpointLabel, fieldsOfStoredSample } from './formSupport';
 import { MappingAccountFields } from './MappingAccountFields';
 import { MappingPasswordField } from './MappingPasswordField';
+import { MappingScheduleFields } from './MappingScheduleFields';
 import { MappingWriteModeFields } from './MappingWriteModeFields';
 import { mappingDraftIssues } from './mappingDraft';
 import { Field } from './Primitives';
@@ -213,6 +214,18 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         targets: targets,
                         value: draft.accountRule ?? null
                     }),
+                    /*#__PURE__*/ _jsx(MappingScheduleFields, {
+                        cron: draft.scheduleCron ?? '',
+                        disabled: busy,
+                        enabled: draft.scheduleEnabled ?? false,
+                        needsPassword: Boolean(draft.accountRule || draft.passwordTargetColumn),
+                        onChange: (next)=>patch({
+                                scheduleEnabled: next.enabled,
+                                scheduleCron: next.cron,
+                                scheduleTimezone: next.timezone
+                            }),
+                        timezone: draft.scheduleTimezone ?? ''
+                    }),
                     /*#__PURE__*/ _jsx(MappingPasswordField, {
                         disabled: busy,
                         onChange: (value)=>patch({

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

@@ -0,0 +1,14 @@
+export type MappingScheduleFieldsProps = {
+    enabled: boolean;
+    cron: string;
+    timezone: string;
+    /** A mapping that creates logins cannot run unattended — there is no password. */
+    needsPassword?: boolean;
+    disabled?: boolean;
+    onChange: (next: {
+        enabled: boolean;
+        cron: string;
+        timezone: string;
+    }) => void;
+};
+export declare function MappingScheduleFields({ enabled, cron, timezone, needsPassword, disabled, onChange, }: MappingScheduleFieldsProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,150 @@
+'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 { integrationsPageTheme } from '../theme';
+import { Field, Notice } from './Primitives';
+/**
+ * Running this import without anybody clicking anything.
+ *
+ * The mapping has carried a cron, a timezone and an enabled flag since it was
+ * first designed, and nothing read them — an operator could fill one in, save
+ * it, see it on the screen, and it would never run. This is the screen for the
+ * half that now does.
+ *
+ * The expression is checked as it is typed and read back in plain words. Cron is
+ * a language people write once a year, and "0 2 * * *" and "2 0 * * *" look
+ * alike until one of them has been importing at two minutes past midnight for a
+ * month.
+ */ const theme = integrationsPageTheme;
+/** Offered because they are what people actually mean, spelled correctly. */ const PRESETS = [
+    {
+        label: 'Every night at 02:00',
+        cron: '0 2 * * *'
+    },
+    {
+        label: 'Every weekday at 07:00',
+        cron: '0 7 * * 1-5'
+    },
+    {
+        label: 'Every Monday at 06:00',
+        cron: '0 6 * * 1'
+    },
+    {
+        label: 'Every hour',
+        cron: '0 * * * *'
+    },
+    {
+        label: 'Every 15 minutes',
+        cron: '*/15 * * * *'
+    }
+];
+export function MappingScheduleFields({ enabled, cron, timezone, needsPassword, disabled, onChange }) {
+    const uid = useId();
+    const parsed = cron.trim() === '' ? null : parseCron(cron);
+    const invalid = parsed !== null && !parsed.ok;
+    const patch = (next)=>{
+        onChange({
+            enabled,
+            cron,
+            timezone,
+            ...next
+        });
+    };
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "flex flex-col gap-3",
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center justify-between gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx("h3", {
+                        className: theme.card.title,
+                        children: "Run this import on a schedule"
+                    }),
+                    /*#__PURE__*/ _jsxs("label", {
+                        className: "flex items-center gap-2 text-sm",
+                        children: [
+                            /*#__PURE__*/ _jsx("input", {
+                                checked: enabled,
+                                disabled: disabled,
+                                id: `${uid}-enabled`,
+                                onChange: (event)=>patch({
+                                        enabled: event.target.checked
+                                    }),
+                                type: "checkbox"
+                            }),
+                            /*#__PURE__*/ _jsx("span", {
+                                className: theme.field.label,
+                                children: "Enabled"
+                            })
+                        ]
+                    })
+                ]
+            }),
+            enabled ? /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "grid grid-cols-1 gap-3 sm:grid-cols-2",
+                        children: [
+                            /*#__PURE__*/ _jsx(Field, {
+                                error: invalid && !parsed.ok ? parsed.error : null,
+                                hint: cron.trim() === '' ? 'Five parts: minute hour day-of-month month day-of-week.' : describeCron(cron, timezone),
+                                htmlFor: `${uid}-cron`,
+                                label: "When",
+                                children: /*#__PURE__*/ _jsx("input", {
+                                    className: theme.field.input,
+                                    disabled: disabled,
+                                    id: `${uid}-cron`,
+                                    onChange: (event)=>patch({
+                                            cron: event.target.value
+                                        }),
+                                    placeholder: "0 2 * * *",
+                                    value: cron
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(Field, {
+                                hint: "The company's own clock, so 02:00 stays 02:00 across a daylight-saving change.",
+                                htmlFor: `${uid}-timezone`,
+                                label: "In this timezone",
+                                children: /*#__PURE__*/ _jsx("input", {
+                                    className: theme.field.input,
+                                    disabled: disabled,
+                                    id: `${uid}-timezone`,
+                                    onChange: (event)=>patch({
+                                            timezone: event.target.value
+                                        }),
+                                    placeholder: "Europe/Istanbul",
+                                    value: timezone
+                                })
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        className: "flex flex-wrap gap-2",
+                        children: PRESETS.map((preset)=>/*#__PURE__*/ _jsx("button", {
+                                className: theme.button.ghost,
+                                disabled: disabled,
+                                onClick: ()=>patch({
+                                        cron: preset.cron
+                                    }),
+                                type: "button",
+                                children: preset.label
+                            }, preset.cron))
+                    }),
+                    needsPassword ? /*#__PURE__*/ _jsx(Notice, {
+                        title: "This import cannot run on its own",
+                        tone: "warning",
+                        children: "It creates a login for every new record, and a login needs a password — which there is nobody to type at that hour. Either start this import by hand, or turn the login off and give people their accounts another way."
+                    }) : null,
+                    /*#__PURE__*/ _jsx("p", {
+                        className: theme.field.hint,
+                        children: "Every server running this app checks the schedule, and exactly one of them takes the import — the same lock that stops two people running it at once."
+                    })
+                ]
+            }) : /*#__PURE__*/ _jsx("p", {
+                className: theme.list.empty,
+                children: "Off. This import runs when somebody asks for it, and at no other time."
+            })
+        ]
+    });
+}

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

@@ -31,6 +31,10 @@ export type MappingDraft = {
     passwordTargetColumn?: string | null;
     /** Creates a login for each new record, in the same import. */
     accountRule?: AccountRuleValue | null;
+    /** Runs on its own, when the expression names this minute. */
+    scheduleEnabled?: boolean;
+    scheduleCron?: string | null;
+    scheduleTimezone?: string | null;
     enabled?: boolean;
 };
 /**

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

@@ -32,6 +32,9 @@ import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
         referenceChecks: asArray(mapping.referenceChecks),
         passwordTargetColumn: mapping.passwordTargetColumn ?? null,
         accountRule: mapping.accountRule ?? null,
+        scheduleEnabled: mapping.scheduleEnabled ?? false,
+        scheduleCron: mapping.scheduleCron ?? '',
+        scheduleTimezone: mapping.scheduleTimezone ?? '',
         enabled: mapping.enabled
     };
 }
@@ -47,6 +50,9 @@ import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
     if (draft.endpointId.trim() === '') issues.push('Select the endpoint this mapping reads from.');
     const usable = asArray(draft.fieldMappings).some((row)=>row.target.trim() !== '' && (row.source.trim() !== '' || (row.constant ?? '').trim() !== ''));
     if (!usable) issues.push('Map at least one field to a target column.');
+    if (draft.scheduleEnabled && (draft.scheduleCron ?? '').trim() === '') {
+        issues.push('A schedule that is on needs to say when.');
+    }
     const account = draft.accountRule;
     if (account) {
         const missing = [

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

@@ -5,6 +5,7 @@ export { ConnectionTransfer } from './components/ConnectionTransfer';
 export { EndpointsTab } from './components/EndpointsTab';
 export { IntegrationsPage } from './components/IntegrationsPage';
 export { MappingAccountFields } from './components/MappingAccountFields';
+export { MappingScheduleFields } from './components/MappingScheduleFields';
 export { MappingsTab } from './components/MappingsTab';
 export type { BadgeProps, BadgeTone, CodeBlockProps, FieldProps, NoticeProps, NoticeTone, StatProps, } from './components/Primitives';
 export { Badge, CodeBlock, Field, Notice, Stat } from './components/Primitives';

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

@@ -4,6 +4,7 @@ export { ConnectionTransfer } from './components/ConnectionTransfer';
 export { EndpointsTab } from './components/EndpointsTab';
 export { IntegrationsPage } from './components/IntegrationsPage';
 export { MappingAccountFields } from './components/MappingAccountFields';
+export { MappingScheduleFields } from './components/MappingScheduleFields';
 export { MappingsTab } from './components/MappingsTab';
 export { Badge, CodeBlock, Field, Notice, Stat } from './components/Primitives';
 export { RunPlanSuggestions } from './components/RunPlanSuggestions';

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

@@ -152,6 +152,10 @@ export type IntegrationMapping = {
     passwordTargetColumn?: string | null;
     /** Creates a login for each new record, in the same import. */
     accountRule?: AccountRuleValue | null;
+    /** Runs on its own, without anybody clicking anything. */
+    scheduleEnabled?: boolean | null;
+    scheduleCron?: string | null;
+    scheduleTimezone?: string | null;
     lastRunAt?: string | null;
     enabled?: boolean;
 };