@substrat-run/contract-tests 0.98.1 → 0.103.0

package/dist/scope-host-suite.js

@@ -143,6 +143,9 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             expect(row.id).toMatch(/^[0-9A-HJKMNP-TV-Z]{26}$/);
             expect(new Date(row.occurred_at).getTime()).not.toBeNaN();
             expect(row.pii_class).toBe('none');
+            // #1231: the signals `operation` dimension — the exact invoke() string,
+            // stamped kernel-side so module code can neither forge nor suppress it.
+            expect(row.operation).toBe('test/emit-event');
         });
         it('ctx.now() is one instant for the whole operation, and the envelope agrees (#812)', async () => {
             const stub = await host.getScope(alice, t1, s1);
@@ -814,6 +817,38 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                 const vCol = page.columns.indexOf('v');
                 expect(page.rows.map((r) => r[vCol])).toContain('fork-me');
             });
+            it('replays a LEGACY dump and re-applies the additive spine columns — the next emit still lands (#1231)', async () => {
+                const stub = await host.getScope(alice, t1, s1);
+                await stub.invoke('test/emit-event');
+                const dump = await host.admin.exportScope(staff, t1, s1);
+                // Doctor the dump into one captured before the `operation` column existed:
+                // the DDL loses the column and every row loses that cell — exactly what a
+                // dump exported by an older platform carries. The replay's DDL is
+                // authoritative, and KERNEL_DDL's IF NOT EXISTS cannot widen a table the
+                // dump brought, so without the post-replay re-run of the additive
+                // migrations the emit below fails with `no such column: operation`.
+                const doctored = dump.tables.map((t) => {
+                    if (t.name !== '_substrat_outbox')
+                        return t;
+                    const idx = t.columns.indexOf('operation');
+                    expect(idx).toBeGreaterThanOrEqual(0);
+                    return {
+                        ...t,
+                        ddl: t.ddl.replace(/\s*operation TEXT,/, ''),
+                        columns: t.columns.filter((c) => c !== 'operation'),
+                        rows: t.rows.map((r) => r.filter((_, i) => i !== idx)),
+                    };
+                });
+                const copy = scopeId.parse(ulid());
+                await host.importScope(staff, { tenantId: t1, scopeId: copy, jurisdiction: 'eu', vertical: 'connector-vertical' }, { ...dump, tables: doctored });
+                const copyStub = await host.getScope(alice, t1, copy);
+                await copyStub.invoke('test/emit-event');
+                const rows = await copyStub.invoke('test/read-outbox');
+                const last = rows[rows.length - 1];
+                // Stamped, not merely tolerated — and the imported legacy rows read NULL.
+                expect(last.operation).toBe('test/emit-event');
+                expect(rows.filter((r) => r.operation === null).length).toBeGreaterThan(0);
+            });
             it('is an independent copy — a later write to the source does not reach it', async () => {
                 const dump = await host.admin.exportScope(staff, t1, s1);
                 const copy = scopeId.parse(ulid());
@@ -1553,6 +1588,64 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                 expect(page2.length).toBe(1);
                 expect(page2[0].id).not.toBe(page1[0].id);
             });
+            it('stamps and filters by version — the signals dimension that joins a failure to its push (#1231)', async () => {
+                await host.admin.recordOpsFailure({
+                    actor: staff,
+                    operation: 'deploy.upload',
+                    vertical: 'acme/versioned',
+                    version: '01JVERSIONAAAAAAAAAAAAAAAA',
+                    message: 'failed under the new version',
+                });
+                await host.admin.recordOpsFailure({
+                    actor: staff,
+                    operation: 'deploy.upload',
+                    vertical: 'acme/versioned',
+                    // No version — a writer that cannot say says nothing, and the row reads null.
+                    message: 'failed with no version in play',
+                });
+                const stamped = await host.admin.listOpsFailures(staff, {
+                    version: '01JVERSIONAAAAAAAAAAAAAAAA',
+                });
+                expect(stamped.length).toBe(1);
+                expect(stamped[0].version).toBe('01JVERSIONAAAAAAAAAAAAAAAA');
+                // The unstamped row round-trips as an explicit null, never undefined: the
+                // entry schema owns the distinction between "predates the stamp" and a typo.
+                const both = await host.admin.listOpsFailures(staff, { vertical: 'acme/versioned' });
+                expect(both.length).toBe(2);
+                expect(both.map((r) => r.version).sort()).toEqual([
+                    '01JVERSIONAAAAAAAAAAAAAAAA',
+                    null,
+                ].sort());
+            });
+            it('carries the error shape — origin and code round-trip and narrow (#1233)', async () => {
+                await host.admin.recordOpsFailure({
+                    actor: staff,
+                    operation: 'intent.connector:testprov',
+                    stage: 'terminal',
+                    vertical: 'acme/shaped',
+                    origin: 'platform',
+                    code: 'permission_denied',
+                    message: 'platform intent 01JTESTINTENT failed: permission denied',
+                });
+                await host.admin.recordOpsFailure({
+                    actor: staff,
+                    operation: 'intent.connector:testprov',
+                    stage: 'terminal',
+                    vertical: 'acme/shaped',
+                    // Unclassified — a writer that cannot say says nothing, like the version stamp.
+                    message: 'platform intent 01JOTHERINTENT failed: socket hang up',
+                });
+                // The fingerprint's narrowing: code is a COLUMN, never a message regex.
+                const denied = await host.admin.listOpsFailures(staff, { code: 'permission_denied' });
+                expect(denied.length).toBe(1);
+                expect(denied[0].origin).toBe('platform');
+                expect(denied[0].code).toBe('permission_denied');
+                // The unclassified row round-trips as explicit nulls, never undefined.
+                const both = await host.admin.listOpsFailures(staff, { vertical: 'acme/shaped' });
+                expect(both.length).toBe(2);
+                expect(both.map((r) => r.code).sort()).toEqual(['permission_denied', null].sort());
+                expect(both.map((r) => r.origin).sort()).toEqual(['platform', null].sort());
+            });
             it('bounds the recorded message — a runaway upstream body never becomes a runaway row', async () => {
                 await host.admin.recordOpsFailure({
                     actor: staff,
@@ -1564,6 +1657,165 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                 expect(rows[0].message.length).toBeLessThanOrEqual(2000);
             });
         });
+        // -- issues (#1233): failures grouped by fingerprint, with a lifecycle --
+        describe('issues (#1233)', () => {
+            it('groups recurring failures into one counted issue, and links the exemplars', async () => {
+                for (let i = 0; i < 3; i++) {
+                    await host.admin.recordOpsFailure({
+                        actor: staff,
+                        operation: 'intent.connector:groupprov',
+                        stage: 'terminal',
+                        vertical: 'acme/grouped',
+                        origin: 'provider',
+                        message: `platform intent 01JATTEMPT${i} failed: provider said no`,
+                    });
+                }
+                await host.admin.recordOpsFailure({
+                    actor: staff,
+                    operation: 'intent.connector:groupprov',
+                    stage: 'terminal',
+                    vertical: 'acme/grouped',
+                    origin: 'platform',
+                    code: 'permission_denied',
+                    message: 'platform intent 01JDENIED failed: permission denied',
+                });
+                // Same operation+stage, different code -> a different defect, a different issue.
+                const issues = await host.admin.listIssues(staff, { operation: 'intent.connector:groupprov' });
+                expect(issues.length).toBe(2);
+                const recurring = issues.find((i) => i.code === null);
+                expect(recurring.count).toBe(3);
+                expect(recurring.status).toBe('new');
+                expect(recurring.origin).toBe('provider');
+                expect(recurring.lastVertical).toBe('acme/grouped');
+                expect(recurring.firstSeen <= recurring.lastSeen).toBe(true);
+                // The exemplar walk: the issue's fingerprint narrows the failure list to its rows.
+                const exemplars = await host.admin.listOpsFailures(staff, { fingerprint: recurring.fingerprint });
+                expect(exemplars.length).toBe(3);
+                expect(new Set(exemplars.map((r) => r.fingerprint)).size).toBe(1);
+            });
+            it('walks the lifecycle: resolved regresses on a fresh arrival, ignored stays ignored', async () => {
+                const record = () => host.admin.recordOpsFailure({
+                    actor: staff,
+                    operation: 'deploy.upload',
+                    stage: 'lifecycle-check',
+                    origin: 'platform',
+                    code: 'unavailable',
+                    message: 'upstream unavailable',
+                });
+                await record();
+                const [issue] = await host.admin.listIssues(staff, { operation: 'deploy.upload', code: 'unavailable' });
+                const resolved = await host.admin.setIssueStatus(staff, issue.fingerprint, 'resolved');
+                expect(resolved?.status).toBe('resolved');
+                expect(resolved?.resolvedAt).not.toBeNull();
+                // Sentry's best retention trick, minus the release half: seen again after
+                // resolved = regressed, back into attention without anyone re-filing it.
+                await record();
+                const [regressed] = await host.admin.listIssues(staff, { operation: 'deploy.upload', code: 'unavailable' });
+                expect(regressed.status).toBe('regressed');
+                expect(regressed.count).toBe(2);
+                // The resolution timestamp survives the regression: "when somebody last
+                // thought this was over" is part of the regression's story.
+                expect(regressed.resolvedAt).not.toBeNull();
+                // Ignored is a verdict about the future, and a fresh arrival does not overturn it.
+                await host.admin.setIssueStatus(staff, issue.fingerprint, 'ignored');
+                await record();
+                const [ignored] = await host.admin.listIssues(staff, { operation: 'deploy.upload', code: 'unavailable' });
+                expect(ignored.status).toBe('ignored');
+                expect(ignored.count).toBe(3);
+                // Reopening clears the resolution; an unknown fingerprint is undefined, never an invented row.
+                const reopened = await host.admin.setIssueStatus(staff, issue.fingerprint, 'new');
+                expect(reopened?.status).toBe('new');
+                expect(reopened?.resolvedAt).toBeNull();
+                expect(await host.admin.setIssueStatus(staff, 'no-such-fingerprint', 'resolved')).toBeUndefined();
+            });
+        });
+        // -- the durable sweep record (#1232): what a pass touched, and how it went --
+        describe('sweep runs (#1232)', () => {
+            it('records unit outcomes and walks them newest-first per unit, with a cursor', async () => {
+                const conn = ulid();
+                for (const outcome of ['ok', 'ok', 'failed']) {
+                    await host.admin.recordSweepRun({
+                        kind: 'connector',
+                        unit: conn,
+                        outcome,
+                        tenantId: t1,
+                        vertical: 'acme/crm',
+                        operation: 'sweep.connector:testprov',
+                        connectionId: conn,
+                        ...(outcome === 'failed' ? { error: 'provider said no' } : { elapsedMs: 12 }),
+                    });
+                }
+                // Newest-first by default: "how did the LAST sweep go" is the first row.
+                const strip = await host.admin.listSweepRuns(staff, { kind: 'connector', unit: conn });
+                expect(strip.length).toBe(3);
+                expect(strip[0].outcome).toBe('failed');
+                expect(strip[0].error).toBe('provider said no');
+                expect(strip[2].outcome).toBe('ok');
+                expect(strip[2].elapsedMs).toBe(12);
+                // The cursor pages exactly like ops failures: the row id IS the cursor.
+                const page1 = await host.admin.listSweepRuns(staff, { unit: conn, limit: 2 });
+                const page2 = await host.admin.listSweepRuns(staff, { unit: conn, limit: 2, cursor: page1[1].id });
+                expect(page1.length).toBe(2);
+                expect(page2.length).toBe(1);
+                expect(page2[0].id).not.toBe(page1[0].id);
+            });
+            it('round-trips the dimensions, and a structurally absent one reads an explicit null', async () => {
+                const sched = `${s1}:acme/tick`;
+                await host.admin.recordSweepRun({
+                    kind: 'schedule',
+                    unit: sched,
+                    outcome: 'skipped',
+                    tenantId: t1,
+                    scopeId: s1,
+                    vertical: 'acme/crm',
+                    version: '01JSWEEPVERSIONAAAAAAAAAAA',
+                    operation: 'acme/tick',
+                });
+                const [row] = await host.admin.listSweepRuns(staff, { kind: 'schedule', unit: sched });
+                expect(row.scopeId).toBe(s1);
+                expect(row.version).toBe('01JSWEEPVERSIONAAAAAAAAAAA');
+                expect(row.operation).toBe('acme/tick');
+                // A schedule row names no connection, and the null is a fact, not a gap —
+                // exactly as a connector row's scope/version nulls are.
+                expect(row.connectionId).toBeNull();
+                expect(row.error).toBeNull();
+                expect(row.elapsedMs).toBeNull();
+            });
+            it('dedupes on (requestId, unit) — a replayed drained batch writes nothing twice (#1232)', async () => {
+                const unit = `${ulid()}:sched/tick`;
+                const write = () => host.admin.recordSweepRun({
+                    kind: 'schedule',
+                    unit,
+                    outcome: 'ok',
+                    tenantId: t1,
+                    at: '2026-09-07T10:00:00.000Z',
+                    requestId: '01JDEDUPEINTENTAAAAAAAAAAA',
+                });
+                await write();
+                await write(); // the replay — a settle lost in transport re-runs the batch
+                const rows = await host.admin.listSweepRuns(staff, { unit });
+                expect(rows).toHaveLength(1);
+                // The carried pass time survives, never overwritten by write time.
+                expect(rows[0].at).toBe('2026-09-07T10:00:00.000Z');
+                // The DIRECT path (no requestId) never dedupes: NULLs are distinct, and two
+                // real passes over one unit are two facts.
+                const direct = `${ulid()}:direct`;
+                await host.admin.recordSweepRun({ kind: 'schedule', unit: direct, outcome: 'ok' });
+                await host.admin.recordSweepRun({ kind: 'schedule', unit: direct, outcome: 'ok' });
+                expect(await host.admin.listSweepRuns(staff, { unit: direct })).toHaveLength(2);
+            });
+            it('bounds the recorded error — one runaway provider body never becomes a runaway row', async () => {
+                const unit = ulid();
+                await host.admin.recordSweepRun({
+                    kind: 'connector',
+                    unit,
+                    outcome: 'failed',
+                    error: 'x'.repeat(10_000),
+                });
+                const [row] = await host.admin.listSweepRuns(staff, { unit });
+                expect(row.error.length).toBeLessThanOrEqual(2000);
+            });
+        });
         //
         // The store exists so a vertical's connector can reach a tenant's provider
         // without any module ever holding a credential. So the properties that
@@ -3097,6 +3349,9 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             expect(actors.length).toBeGreaterThan(0);
             for (const row of actors) {
                 expect(JSON.parse(row.actor)).toEqual({ system: '@test/flow' });
+                // #1231: a consumer runs on behalf of NO operation, and the row says so —
+                // NULL, never a synthesized pseudo-name that would pollute the dimension.
+                expect(row.operation).toBeNull();
             }
         });
         // -- tenant registry + lifecycle (control-plane.md §4.1) -----------------