nucleus-core-ts 0.9.829 → 0.9.831

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.d.ts

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

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/components/runFormat.js

@@ -53,6 +53,13 @@ export function formatDuration(startedAt, finishedAt) {
         `${run.updatedCount} updated`,
         `${run.skippedCount} skipped`
     ];
+    // An import that also opened 877 logins did the largest thing it did that day
+    // and said nothing about it — the history read exactly like one that opened
+    // none, and the only way to tell was to go and count the users table.
+    if ((run.accountsCreatedCount ?? 0) > 0) parts.push(`${run.accountsCreatedCount} login(s)`);
+    if ((run.referencesCreatedCount ?? 0) > 0) {
+        parts.push(`${run.referencesCreatedCount} value(s) added elsewhere`);
+    }
     if (run.deletedCount > 0) parts.push(`${run.deletedCount} deleted`);
     if (run.deactivatedCount > 0) parts.push(`${run.deactivatedCount} deactivated`);
     if (run.errorCount > 0) parts.push(`${run.errorCount} failed`);

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

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

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

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'bun:test';
+import { countersLine } from './runFormat';
+/**
+ * An import that also opened 877 logins did the largest thing it did that day.
+ * The history line read exactly like one that opened none, and the only way to
+ * tell them apart was to go and count the users table.
+ */ const run = (over)=>({
+        createdCount: 0,
+        updatedCount: 0,
+        skippedCount: 0,
+        deletedCount: 0,
+        deactivatedCount: 0,
+        errorCount: 0,
+        ...over
+    });
+describe('the counts of a finished run', ()=>{
+    it('always says what it created, updated and skipped', ()=>{
+        expect(countersLine(run({
+            createdCount: 3,
+            updatedCount: 2,
+            skippedCount: 1
+        }))).toBe('3 created · 2 updated · 1 skipped');
+    });
+    it('says how many logins it opened', ()=>{
+        expect(countersLine(run({
+            createdCount: 880,
+            accountsCreatedCount: 877
+        }))).toContain('877 login(s)');
+    });
+    it('says what it added to other tables', ()=>{
+        expect(countersLine(run({
+            referencesCreatedCount: 2
+        }))).toContain('2 value(s) added elsewhere');
+    });
+    it('stays quiet about the kinds that did not happen', ()=>{
+        // A line of zeros is a line nobody reads.
+        const line = countersLine(run({
+            createdCount: 5
+        }));
+        expect(line).not.toContain('login');
+        expect(line).not.toContain('deleted');
+        expect(line).not.toContain('failed');
+    });
+    it('reads an older run that never recorded these at all', ()=>{
+        expect(()=>countersLine(run({}))).not.toThrow();
+    });
+});

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

@@ -180,6 +180,10 @@ export type IntegrationRun = {
     totalFetched: number;
     sourceReportedTotal?: number | null;
     createdCount: number;
+    /** Logins this run opened so its records could be signed in to. */
+    accountsCreatedCount?: number;
+    /** Rows it added to OTHER tables so its records had something to point at. */
+    referencesCreatedCount?: number;
     updatedCount: number;
     skippedCount: number;
     deletedCount: number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.829",
+	"version": "0.9.831",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",