@memberjunction/server 6.2.0-edge.6 → 6.2.0-edge.7

package/src/__tests__/RSUProgressBridge.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { mkdtempSync, rmSync, readFileSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { RSUProgressBridge } from '../integration/RSUProgressBridge.js';
@@ -44,12 +44,39 @@ describe('RSUProgressBridge', () => {
         ItemCount: 2,
         Descriptions: ['add Orders', 'add OrderItems'],
         AffectedTables: ['Orders', 'OrderItems'],
-        StepTotal: 12,
+        StepTotal: 14,
+        CompanyIntegrationIDs: ['CI-1'],
     };
 
-    /** The emitter's writes are chained promises; let them drain before reading from disk. */
+    /**
+     * Waits for the emitter's append chain to quiesce.
+     *
+     * This was a flat 50 ms sleep, which is plenty on an idle machine and NOT always enough with
+     * the whole suite running in parallel — the emitter appends through a promise chain the test
+     * cannot await, so a slow write made the assertion read "the event was never emitted" when it
+     * simply had not landed yet. Observed as an intermittent failure of the stage.error test.
+     * Poll for the journal to stop growing instead of guessing how long that takes.
+     */
     async function settle(): Promise<void> {
-        await new Promise(resolve => setTimeout(resolve, 50));
+        const path = join(rootDir, bridge.CurrentRunID ?? '', 'progress.jsonl');
+        const deadline = Date.now() + 5000;
+        let last = -1;
+        let stableReads = 0;
+        while (Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, 10));
+            let size = -1;
+            try { size = statSync(path).size; } catch { /* not written yet */ }
+            if (size === last) {
+                stableReads++;
+                // A journal that exists and has stopped growing is settled. One that does not
+                // exist at all gets a short grace period and then counts as settled too, so a
+                // test asserting that NOTHING was written does not pay the full deadline.
+                if (stableReads >= 3 && (size >= 0 || stableReads >= 20)) return;
+            } else {
+                stableReads = 0;
+                last = size;
+            }
+        }
     }
 
     function runDir(): string {
@@ -100,7 +127,7 @@ describe('RSUProgressBridge', () => {
         expect(manifest.context).toMatchObject({
             itemCount: 2,
             affectedTables: ['Orders', 'OrderItems'],
-            stepTotal: 12,
+            stepTotal: 14,
         });
 
         const events = readEvents(dir);
@@ -237,6 +264,162 @@ describe('RSUProgressBridge', () => {
         expect(start?.message).toBe('step 0 of 12');
     });
 
+    // ── Connection identity: what makes an RSU run readable over the API at all ──────────────
+
+    it('stamps the batch connections onto the manifest, which is what the read check tests', async () => {
+        // Before this, an RSU manifest carried no connection, `userCanReadRunArtifact` returned false
+        // on the missing field, and EVERY RSU run answered "not authorized" to IntegrationGetRun and
+        // IntegrationTailRunEvents. The manifest field is the fix.
+        bridge.Observe({ ...RUN_START, CompanyIntegrationIDs: ['CI-1'] });
+        const dir = runDir();
+        await settle();
+
+        const manifest = JSON.parse(readFileSync(join(dir, 'manifest.json'), 'utf-8')) as IntegrationRunManifest;
+        expect(manifest.companyIntegrationIDs).toEqual(['CI-1']);
+        // Singular is set too, so the per-connection list filter and the GQL summary keep working.
+        expect(manifest.companyIntegrationID).toBe('CI-1');
+    });
+
+    it('leaves the SINGULAR connection empty for a batch spanning several, keeping the full set', async () => {
+        // Picking one member of the set to report as "the" connection would be a lie a client could
+        // act on; the AND authorization rule reads the set instead.
+        bridge.Observe({ ...RUN_START, CompanyIntegrationIDs: ['CI-1', 'CI-2'] });
+        const dir = runDir();
+        await settle();
+
+        const manifest = JSON.parse(readFileSync(join(dir, 'manifest.json'), 'utf-8')) as IntegrationRunManifest;
+        expect(manifest.companyIntegrationIDs).toEqual(['CI-1', 'CI-2']);
+        expect(manifest.companyIntegrationID).toBeUndefined();
+    });
+
+    it('records no connection when the batch supplied none, rather than inventing one', async () => {
+        bridge.Observe({ ...RUN_START, CompanyIntegrationIDs: [] });
+        const dir = runDir();
+        await settle();
+
+        const manifest = JSON.parse(readFileSync(join(dir, 'manifest.json'), 'utf-8')) as IntegrationRunManifest;
+        expect(manifest.companyIntegrationIDs).toEqual([]);
+        expect(manifest.companyIntegrationID).toBeUndefined();
+    });
+
+    // ── The restart boundary ─────────────────────────────────────────────────────────────────
+
+    it('closes the RestartMJAPI stage and checkpoints BEFORE the process is killed', async () => {
+        // `step.end` for RestartMJAPI is unreachable — pm2 kills the process inside the step — so
+        // without this the stream ends on an open stage and the run is in-flight forever.
+        bridge.Observe(RUN_START);
+        const dir = runDir();
+        bridge.Observe({ Kind: 'step.start', Name: 'RestartMJAPI', StepIndex: 10, StepTotal: 14 });
+
+        await bridge.Observe({
+            Kind: 'restart.pending',
+            RemainingSteps: ['CreateEntityMaps', 'StartSync'],
+            StepIndex: 10,
+            StepTotal: 14,
+            CompanyIntegrationIDs: ['CI-1'],
+            PendingWorkIDs: ['PW-1'],
+            TotalCount: 2,
+            SuccessCount: 2,
+        });
+
+        const events = readEvents(dir);
+        const done = events.find(e => e.eventType === 'stage.complete' && e.stage === 'RestartMJAPI');
+        const checkpoint = events.find(e => e.eventType === 'checkpoint' && e.stage === 'RestartMJAPI');
+        expect(done).toBeDefined();
+        expect(checkpoint?.resumableState).toMatchObject({
+            remainingSteps: ['CreateEntityMaps', 'StartSync'],
+            stepIndex: 10,
+            stepTotal: 14,
+            companyIntegrationIDs: ['CI-1'],
+            pendingWorkIDs: ['PW-1'],
+        });
+        // Still in flight: the run is finished by the process on the other side of the restart.
+        expect(existsSync(join(dir, 'result.json'))).toBe(false);
+    });
+
+    it('AWAITS the restart checkpoint to disk — an unflushed write would be lost to the kill', async () => {
+        // Deliberately does NOT call settle(): the returned promise must have flushed already.
+        bridge.Observe(RUN_START);
+        const dir = runDir();
+        await bridge.Observe({
+            Kind: 'restart.pending',
+            RemainingSteps: ['CreateEntityMaps', 'StartSync'],
+            CompanyIntegrationIDs: ['CI-1'],
+            PendingWorkIDs: [],
+            TotalCount: 1,
+            SuccessCount: 1,
+        });
+
+        const events = readEvents(dir);
+        expect(events.some(e => e.eventType === 'checkpoint' && e.stage === 'RestartMJAPI')).toBe(true);
+    });
+
+    it('ignores a restart.pending that arrives with no run open', async () => {
+        await expect(bridge.Observe({
+            Kind: 'restart.pending',
+            RemainingSteps: [],
+            CompanyIntegrationIDs: [],
+            PendingWorkIDs: [],
+            TotalCount: 0,
+            SuccessCount: 0,
+        })).resolves.toBeUndefined();
+    });
+
+    // ── Heartbeat staleness ──────────────────────────────────────────────────────────────────
+
+    it('never lets one run heartbeat stamp its stage name onto the NEXT run', async () => {
+        // The timer captures its stage; if it outlives the run it was armed for, it writes that
+        // stale name into whatever emitter the bridge points at next.
+        vi.useFakeTimers();
+        try {
+            bridge.Observe(RUN_START);
+            bridge.Observe({ Kind: 'step.start', Name: 'CompileTypeScript', StepIndex: 8, StepTotal: 14 });
+
+            // A retry starts a brand-new run while the previous step's heartbeat is still armed.
+            bridge.Observe(RUN_START);
+            const secondDir = runDir();
+            vi.advanceTimersByTime(300_000); // ten ticks' worth
+
+            vi.useRealTimers();
+            await settle();
+
+            const beats = readEvents(secondDir).filter(e => e.eventType === 'progress.heartbeat');
+            expect(beats.filter(b => b.stage === 'CompileTypeScript')).toHaveLength(0);
+            expect(beats).toHaveLength(0);
+        } finally {
+            vi.useRealTimers();
+        }
+    });
+
+    it('stops heart-beating once the restart boundary is published', async () => {
+        vi.useFakeTimers();
+        try {
+            bridge.Observe(RUN_START);
+            const dir = runDir();
+            bridge.Observe({ Kind: 'step.start', Name: 'RestartMJAPI', StepIndex: 10, StepTotal: 14 });
+            const pending = bridge.Observe({
+                Kind: 'restart.pending',
+                RemainingSteps: ['CreateEntityMaps', 'StartSync'],
+                CompanyIntegrationIDs: ['CI-1'],
+                PendingWorkIDs: [],
+                TotalCount: 1,
+                SuccessCount: 1,
+            });
+            vi.useRealTimers();
+            await pending;
+
+            vi.useFakeTimers();
+            vi.advanceTimersByTime(300_000);
+            vi.useRealTimers();
+            await settle();
+
+            const beats = readEvents(dir).filter(e => e.eventType === 'progress.heartbeat');
+            expect(beats).toHaveLength(0);
+        } finally {
+            vi.useRealTimers();
+        }
+    });
+
     it('ignores step and run.end events that arrive with no run open', async () => {
         // Defensive: an observer registered mid-run would see a trailing run.end for a run it never
         // saw start. That must be a no-op, not a crash.

package/src/__tests__/RSUStartupSweepWiring.test.ts

@@ -0,0 +1,30 @@
+/**
+ * Startup order in index.ts: the boot sweep must exempt restart-killed RSU runs on a replica that
+ * runs background workers (processRSUPendingWork is their continuation), and whichever of those
+ * nothing re-attached to must be swept once the resuming pass is over. The behaviour of each half
+ * is tested in RSUPostRestartProgress.test.ts; this pins the wiring between them, which lives in
+ * a bootstrap function no unit test can run.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const src = readFileSync(join(__dirname, '..', 'index.ts'), 'utf-8');
+
+describe('RSU startup sweep wiring', () => {
+    it('the boot sweep exempts restart-killed RSU runs only where background workers will resume them', () => {
+        expect(src).toMatch(
+            /const bootSweep = await SweepInterruptedRuns\(\s*undefined,\s*msg => console\.warn\(msg\),\s*runBackgroundWorkers \? RSUPostRestartProgressSession\.WasKilledAtRestart : undefined\s*\);/
+        );
+    });
+
+    it('the leftover sweep runs after the resuming pass, over exactly the runs the boot sweep left in flight', () => {
+        const pending = src.indexOf('processRSUPendingWork().catch(');
+        const leftover = src.indexOf('RSUPostRestartProgressSession.SweepUnattached(bootSweep.Skipped');
+        const boot = src.indexOf('const bootSweep = await SweepInterruptedRuns(');
+        expect(boot).toBeGreaterThan(-1);
+        expect(pending).toBeGreaterThan(boot);
+        expect(leftover).toBeGreaterThan(pending);
+        expect(src.slice(pending, leftover)).toMatch(/\.finally\(/);
+    });
+});

package/src/__tests__/ReactivateRefreshMessage.test.ts

@@ -19,6 +19,8 @@ function summary(over: Partial<SchemaRefreshSummaryLike> = {}): SchemaRefreshSum
         Succeeded: true,
         ObjectsCreated: 12,
         ObjectsUpdated: 3,
+        FieldsCreated: 69,
+        FieldsUpdated: 487,
         UnresolvedObjects: ['Widgets'],
         ...over,
     };
@@ -28,7 +30,7 @@ describe('BuildReactivateMessage', () => {
     it('leads with the reactivation on every path', () => {
         const paths = [
             BuildReactivateMessage(undefined),
-            BuildReactivateMessage(summary({ InProgress: true, ObjectsCreated: 0, ObjectsUpdated: 0, UnresolvedObjects: [] })),
+            BuildReactivateMessage(summary({ InProgress: true, ObjectsCreated: 0, ObjectsUpdated: 0, FieldsCreated: 0, FieldsUpdated: 0, UnresolvedObjects: [] })),
             BuildReactivateMessage(summary()),
             BuildReactivateMessage(summary({ Succeeded: false, FailureMessage: 'boom' })),
         ];
@@ -40,6 +42,8 @@ describe('BuildReactivateMessage', () => {
             InProgress: true,
             ObjectsCreated: 0,
             ObjectsUpdated: 0,
+            FieldsCreated: 0,
+            FieldsUpdated: 0,
             UnresolvedObjects: [],
         }));
 
@@ -50,10 +54,11 @@ describe('BuildReactivateMessage', () => {
         expect(msg).not.toMatch(/PK-unresolved/);
     });
 
-    it('reports real counts when the caller asked to block', () => {
+    it('reports real counts when the caller asked to block — fields included', () => {
         const msg = BuildReactivateMessage(summary());
-        expect(msg).toContain('12 created');
+        expect(msg).toContain('12 objects created');
         expect(msg).toContain('3 updated');
+        expect(msg).toContain('69 fields created');
         expect(msg).toContain('1 PK-unresolved');
         expect(msg).not.toMatch(/running/i);
     });
@@ -67,6 +72,8 @@ describe('BuildReactivateMessage', () => {
             FailureMessage: 'ConnectionTest failed: No Totara credentials found',
             ObjectsCreated: 0,
             ObjectsUpdated: 0,
+            FieldsCreated: 0,
+            FieldsUpdated: 0,
             UnresolvedObjects: [],
         }));
 

package/src/__tests__/RealtimeClientSessionResolver.test.ts

@@ -2695,6 +2695,28 @@ describe('RealtimeClientSessionResolver.RelayRealtimeUsage', () => {
         expect(promptRun.Save).not.toHaveBeenCalled();
     });
 
+    it('logs a missing co-agent promptRunID once per session, not once per relay', async () => {
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const missingRunLines = (): string[] =>
+            (errSpy?.mock.calls ?? []).map((c) => c.map(String).join(' ')).filter((m) => m.includes('has no co-agent promptRunID'));
+        const resolver = makeResolver();
+
+        for (const sessionID of ['session-no-run-a', 'session-no-run-b']) {
+            const { provider } = makeUsageProvider({
+                session: makeSessionEntity({ ID: sessionID, Config_: JSON.stringify({ targetAgentID: 'target-1' }) }),
+            });
+            currentProvider = provider;
+            for (let i = 0; i < 3; i++) {
+                await expect(resolver.RelayRealtimeUsage(sessionID, 10, 5, makeCtx())).resolves.toBe(false);
+            }
+        }
+
+        const lines = missingRunLines();
+        expect(lines).toHaveLength(2);
+        expect(lines[0]).toContain('session-no-run-a');
+        expect(lines[1]).toContain('session-no-run-b');
+    });
+
     it('returns false (tolerant, no throw) when the session config is missing/malformed', async () => {
         const { provider } = makeUsageProvider({ session: makeSessionEntity({ Config_: '{broken json' }) });
         currentProvider = provider;

package/src/__tests__/{RefreshAdoptsNewColumns.test.ts → RefreshReportsNewColumns.test.ts}

@@ -4,28 +4,37 @@ import { join } from 'node:path';
 import { DecideFieldMapReconcile } from '../integration/EntityMapLifecycle.js';
 
 /**
- * A REFRESH adopts the source's current shape: new objects and new columns both arrive ENABLED.
+ * A REFRESH REPORTS the source's current shape; it does not adopt it. New objects and new columns
+ * are created but arrive DISABLED, and the user turns them on.
  *
- * That is the deliberate asymmetry with SYNC-discovered columns, which are only ever *suggested* —
- * captured as candidates with their statistics and requiring acceptance before any DDL runs. A
- * refresh is an explicit act; a sync is not, and must not reshape the schema on its own.
+ * everything.txt: "we create entity maps for all objects that are determined as things that should
+ * be now added but arent, we enable nothing (because the user needs to, after the refresh, then go
+ * turn them on)". plan.md says the same for a schema refresh: "New tables are default deselected
+ * during schema refresh, and same with columns."
  *
- * `autoEnableNewColumns: false` (and `autoEnableNewObjects: false`) exist for a connection that
- * wants to review a refresh's additions before they sync.
+ * This file previously asserted the OPPOSITE, and that is how the regression survived: the flip to
+ * auto-adopt was pinned by a test whose own premise contradicted the spec. Its stated reason was
+ * that a disabled new object never reached a migration, which is false — CreateDisabled governs
+ * only the entity/field MAP status, the IntegrationObject row is written Active regardless, and
+ * phase 4 evolves over continuing + new objects either way. The table is always created; the flag
+ * only decides whether it starts SYNCING unasked.
+ *
+ * The asymmetry with SYNC-discovered columns still holds and is sharper now: a sync never creates
+ * anything, it only captures a candidate for acceptance.
  */
 const fm = (SourceFieldName: string, Status: string) => ({ SourceFieldName, Status });
 
-describe('decideFieldMapReconcile — a refresh adopts new columns', () => {
-    it('creates a new column ENABLED on an enabled map, by default', () => {
+describe('decideFieldMapReconcile — a refresh reports new columns, disabled', () => {
+    it('creates a new column DISABLED on an enabled map, by default', () => {
         const plan = DecideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true);
-        expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Active' }]);
+        expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Inactive' }]);
         expect(plan.Enable).toEqual([]);
         expect(plan.Disable).toEqual([]);
     });
 
-    it('autoEnableNewColumns:false gates it for a connection that wants to review first', () => {
-        const plan = DecideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true, false);
-        expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Inactive' }]);
+    it('autoEnableNewColumns:true is the explicit opt-in for a connection that wants adoption', () => {
+        const plan = DecideFieldMapReconcile(['id', 'brand_new_col'], [fm('id', 'Active')], true, true);
+        expect(plan.Create).toEqual([{ SourceFieldName: 'brand_new_col', Status: 'Active' }]);
     });
 
     it('a DISABLED map never gets an Active column — the map always bounds the column', () => {
@@ -73,12 +82,12 @@ describe('refresh adopts, sync only suggests — the defaults that encode it', (
     const promoter = readFileSync(
         join(__dirname, '..', 'integration', 'CustomColumnPromoter.ts'), 'utf8');
 
-    it('a REFRESH auto-enables new objects', () => {
-        expect(resolver).toMatch(/@Arg\("autoEnableNewObjects",\s*\{\s*defaultValue:\s*true/);
+    it('a REFRESH creates new objects DISABLED', () => {
+        expect(resolver).toMatch(/@Arg\("autoEnableNewObjects",\s*\{\s*defaultValue:\s*false/);
     });
 
-    it('a REFRESH auto-enables new columns', () => {
-        expect(resolver).toMatch(/@Arg\("autoEnableNewColumns",\s*\{\s*defaultValue:\s*true/);
+    it('a REFRESH creates new columns DISABLED', () => {
+        expect(resolver).toMatch(/@Arg\("autoEnableNewColumns",\s*\{\s*defaultValue:\s*false/);
     });
 
     it('a SYNC never auto-creates a column — it captures a candidate and waits for acceptance', () => {