nucleus-core-ts 0.9.821 → 0.9.823

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

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'bun:test';
+import { missingRequiredCounts, suggestEmailTemplate } from './RunPlanSuggestions';
+/**
+ * A preview that says "561 records are missing e-mail" has told the truth and
+ * stopped one step short of being useful. The answer is nearly always to build
+ * the value from the fields that ARE there, and the panel knows which those are.
+ */ const plan = (issues)=>({
+        issues,
+        referenceInserts: [],
+        warnings: []
+    });
+const issue = (message, i)=>({
+        sourceIndex: i,
+        kind: 'missing_required',
+        message
+    });
+describe('counting what each missing field costs', ()=>{
+    it('counts the records one field kept out', ()=>{
+        const counts = missingRequiredCounts(plan([
+            issue('Required field(s) empty: email', 0),
+            issue('Required field(s) empty: email', 1)
+        ]));
+        expect(counts).toEqual([
+            {
+                field: 'email',
+                records: 2
+            }
+        ]);
+    });
+    it('counts each field of a record that is missing two', ()=>{
+        const counts = missingRequiredCounts(plan([
+            issue('Required field(s) empty: email, code', 0)
+        ]));
+        expect(counts).toEqual([
+            {
+                field: 'email',
+                records: 1
+            },
+            {
+                field: 'code',
+                records: 1
+            }
+        ]);
+    });
+    it('puts the biggest problem first', ()=>{
+        const counts = missingRequiredCounts(plan([
+            issue('Required field(s) empty: code', 0),
+            issue('Required field(s) empty: email', 1),
+            issue('Required field(s) empty: email', 2)
+        ]));
+        expect(counts[0]).toEqual({
+            field: 'email',
+            records: 2
+        });
+    });
+    it('ignores issues of every other kind', ()=>{
+        const counts = missingRequiredCounts(plan([
+            {
+                sourceIndex: 0,
+                kind: 'duplicate_in_batch',
+                message: 'twice'
+            }
+        ]));
+        expect(counts).toEqual([]);
+    });
+});
+describe('the address it suggests building', ()=>{
+    const mapping = (sources)=>({
+            fieldMappings: sources.map((source)=>({
+                    source,
+                    target: source
+                }))
+        });
+    it('is built from the fields this source really sends', ()=>{
+        expect(suggestEmailTemplate(mapping([
+            'name',
+            'surname',
+            'employeeNo'
+        ]))).toBe('{name}.{surname}@example.com');
+    });
+    it('recognises the other names those fields go by', ()=>{
+        expect(suggestEmailTemplate(mapping([
+            'firstName',
+            'lastName'
+        ]))).toBe('{firstName}.{lastName}@example.com');
+    });
+    it('offers what it can when only one of the two is there', ()=>{
+        expect(suggestEmailTemplate(mapping([
+            'surname'
+        ]))).toBe('{surname}@example.com');
+    });
+    it('suggests nothing rather than nonsense when there is no name at all', ()=>{
+        expect(suggestEmailTemplate(mapping([
+            'employeeNo',
+            'departmentCode'
+        ]))).toBeNull();
+    });
+    it('ignores a source that is already a template', ()=>{
+        expect(suggestEmailTemplate(mapping([
+            '{a}-{b}'
+        ]))).toBeNull();
+    });
+});

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

@@ -82,6 +82,11 @@ export function RunPlanSummary({ plan }) {
                     })
                 ]
             }),
+            plan.accountsToCreate > 0 ? /*#__PURE__*/ _jsx(Notice, {
+                title: `${plan.accountsToCreate} login(s) will be created, with the password typed above`,
+                tone: "info",
+                children: "Each new record gets an account in the same import — one password for all of them, which people change themselves afterwards. Anyone whose value already has an account is linked to it instead."
+            }) : null,
             plan.warnings.map((warning, index)=>/*#__PURE__*/ _jsx(Notice, {
                     title: warning,
                     tone: "warning"

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

@@ -26,7 +26,8 @@ export const TRANSFORMS = [
     'toBoolean',
     'dateOnly',
     'emailSafe',
-    'pathLeaf'
+    'pathLeaf',
+    'toList'
 ];
 export const TRANSFORM_LABEL = {
     none: 'No transform',
@@ -38,7 +39,8 @@ export const TRANSFORM_LABEL = {
     toBoolean: 'To boolean',
     dateOnly: 'Date only',
     emailSafe: 'E-mail safe (ascii, lowercase)',
-    pathLeaf: 'Last part of a path (A/B/C → C)'
+    pathLeaf: 'Last part of a path (A/B/C → C)',
+    toList: 'To a list (for a column that holds many)'
 };
 /** Narrows what a select reported back to a transform this panel knows. */ export function toTransform(value) {
     return TRANSFORMS.find((option)=>option === value) ?? 'none';

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

@@ -1,4 +1,4 @@
-import type { IntegrationMapping, ReferenceCheckValue } from '../types';
+import type { AccountRuleValue, IntegrationMapping, ReferenceCheckValue } from '../types';
 /**
  * The mapping while it is being edited.
  *
@@ -29,6 +29,8 @@ export type MappingDraft = {
     referenceChecks: ReferenceCheckValue[];
     /** Column that receives the shared opening password typed at run time. */
     passwordTargetColumn?: string | null;
+    /** Creates a login for each new record, in the same import. */
+    accountRule?: AccountRuleValue | null;
     enabled?: boolean;
 };
 /**

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

@@ -31,6 +31,7 @@ import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
         missingRecordValue: mapping.missingRecordValue,
         referenceChecks: asArray(mapping.referenceChecks),
         passwordTargetColumn: mapping.passwordTargetColumn ?? null,
+        accountRule: mapping.accountRule ?? null,
         enabled: mapping.enabled
     };
 }
@@ -46,6 +47,19 @@ 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.');
+    const account = draft.accountRule;
+    if (account) {
+        const missing = [
+            account.entity ? '' : 'the table accounts live in',
+            account.matchColumn ? '' : 'the column that identifies an account',
+            account.matchFrom ? '' : "the record's matching column",
+            account.passwordColumn ? '' : 'the column the password goes into',
+            account.idColumn ? '' : "where the account's id is stored"
+        ].filter(Boolean);
+        if (missing.length > 0) {
+            issues.push(`Creating a login needs ${missing.join(', ')}.`);
+        }
+    }
     for (const check of asArray(draft.referenceChecks)){
         if (check.column.trim() === '' || check.entity.trim() === '' || check.entityColumn.trim() === '') issues.push('Every reference needs a column, an entity and the column to match against.');
     }

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

@@ -1,11 +1,14 @@
 export { ConnectionList } from './components/ConnectionList';
 export type { ConnectionTabsProps } from './components/ConnectionTabs';
 export { ConnectionTabs, connectionTabId, connectionTabPanelId } from './components/ConnectionTabs';
+export { ConnectionTransfer } from './components/ConnectionTransfer';
 export { EndpointsTab } from './components/EndpointsTab';
 export { IntegrationsPage } from './components/IntegrationsPage';
+export { MappingAccountFields } from './components/MappingAccountFields';
 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';
+export { RunPlanSuggestions } from './components/RunPlanSuggestions';
 export { RunsTab } from './components/RunsTab';
 export type { ListSkeletonProps } from './components/Skeletons';
 export { CardSkeleton, ListSkeleton, StatGridSkeleton } from './components/Skeletons';

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

@@ -1,9 +1,12 @@
 export { ConnectionList } from './components/ConnectionList';
 export { ConnectionTabs, connectionTabId, connectionTabPanelId } from './components/ConnectionTabs';
+export { ConnectionTransfer } from './components/ConnectionTransfer';
 export { EndpointsTab } from './components/EndpointsTab';
 export { IntegrationsPage } from './components/IntegrationsPage';
+export { MappingAccountFields } from './components/MappingAccountFields';
 export { MappingsTab } from './components/MappingsTab';
 export { Badge, CodeBlock, Field, Notice, Stat } from './components/Primitives';
+export { RunPlanSuggestions } from './components/RunPlanSuggestions';
 export { RunsTab } from './components/RunsTab';
 export { CardSkeleton, ListSkeleton, StatGridSkeleton } from './components/Skeletons';
 export { useInfiniteList } from './components/useInfiniteList';

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

@@ -92,6 +92,24 @@ export type IntegrationsActions = {
         label: string;
         fields: string[];
     }[]>;
+    /**
+     * The whole connection as one portable document — WITHOUT any credential.
+     *
+     * A connection is the connection, its calls, the parameters those calls take
+     * from each other and the mappings that turn the answers into rows. Moving
+     * that by hand between environments is hours of work and a fresh chance to
+     * get one field wrong in a way nobody notices until an import writes it.
+     */
+    exportConnection: (sourceId: string) => Promise<unknown>;
+    /** Brings such a document in. Re-importing the same file updates rather than duplicates. */
+    importConnection: (document: unknown) => Promise<{
+        ok: boolean;
+        message: string;
+        problems?: {
+            path: string;
+            message: string;
+        }[];
+    }>;
 };
 export type IntegrationsPageProps = {
     title?: string;

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

@@ -86,7 +86,7 @@ export type IntegrationEndpoint = {
     } | null;
     enabled?: boolean;
 };
-export type MappingTransformValue = 'none' | 'trim' | 'upper' | 'lower' | 'toString' | 'toNumber' | 'toBoolean' | 'dateOnly' | 'emailSafe' | 'pathLeaf';
+export type MappingTransformValue = 'none' | 'trim' | 'upper' | 'lower' | 'toString' | 'toNumber' | 'toBoolean' | 'dateOnly' | 'emailSafe' | 'pathLeaf' | 'toList';
 export type FieldMappingValue = {
     source: string;
     target: string;
@@ -112,6 +112,29 @@ export type ReferenceCheckValue = {
     entityColumn: string;
     onMissing: 'create' | 'skipRecord' | 'ignore';
 };
+/**
+ * A login created alongside each imported record.
+ *
+ * A directory carries people, not accounts. Creating the logins afterwards, by
+ * hand, matching them up by e-mail one at a time, is the job nobody gets to.
+ */
+export type AccountRuleValue = {
+    /** Entity the account row goes into. */
+    entity: string;
+    /** Column on the target entity that receives the account's id. */
+    idColumn: string;
+    /** Column on the account that identifies it. */
+    matchColumn: string;
+    /** Column of the imported record carrying that same value. */
+    matchFrom: string;
+    /** Column on the account that receives the run's shared password. */
+    passwordColumn: string;
+    /** Other columns to fill on a new account, from the imported record. */
+    values?: {
+        column: string;
+        from: string;
+    }[];
+};
 export type IntegrationMapping = {
     id: string;
     endpointId: string;
@@ -127,6 +150,8 @@ export type IntegrationMapping = {
     referenceChecks?: ReferenceCheckValue[] | null;
     /** Column that receives the shared opening password typed at run time. */
     passwordTargetColumn?: string | null;
+    /** Creates a login for each new record, in the same import. */
+    accountRule?: AccountRuleValue | null;
     lastRunAt?: string | null;
     enabled?: boolean;
 };

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

@@ -49,6 +49,8 @@ export type RunPlanValue = {
     warnings: string[];
     /** Rows this run would add to OTHER tables so its records have something to point at. */
     referenceInserts: ReferenceInsertValue[];
+    /** Logins this run would create so its records can be signed in to. */
+    accountsToCreate: number;
     sample: Record<string, unknown>[];
 };
 export type ConnectionTestValue = {