autotel-pact 6.0.0 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-pact",
-  "version": "6.0.0",
+  "version": "7.0.1",
   "description": "Runtime evidence for Pact contracts — autotel bridge that records which contract interactions were actually exercised, and audits 'contracted but never observed'.",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,7 +52,6 @@
   },
   "files": [
     "dist",
-    "src",
     "schemas",
     "README.md"
   ],
@@ -70,7 +69,7 @@
   "license": "MIT",
   "peerDependencies": {
     "@pact-foundation/pact": ">=16",
-    "autotel": "4.1.0"
+    "autotel": "4.2.1"
   },
   "peerDependenciesMeta": {
     "@pact-foundation/pact": {
@@ -84,7 +83,7 @@
     "tsdown": "^0.22.2",
     "typescript": "^6.0.3",
     "vitest": "^4.1.8",
-    "autotel": "4.1.0"
+    "autotel": "4.2.1"
   },
   "repository": {
     "type": "git",

package/src/attrs.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildPactAttributes, outcomeAttribute, PACT_ATTRS } from './attrs.js';
-import type { PactInteractionMeta } from './types.js';
-
-const meta: PactInteractionMeta = {
-  consumer: 'OrderShipper',
-  provider: 'OrderService',
-  description: 'an OrderCreated event',
-  states: ['an order exists'],
-  kind: 'message',
-};
-
-describe('buildPactAttributes', () => {
-  it('emits the canonical pact.* attribute set', () => {
-    const attrs = buildPactAttributes(meta);
-    expect(attrs[PACT_ATTRS.CONSUMER]).toBe('OrderShipper');
-    expect(attrs[PACT_ATTRS.PROVIDER]).toBe('OrderService');
-    expect(attrs[PACT_ATTRS.KIND]).toBe('message');
-    expect(attrs[PACT_ATTRS.INTERACTION_DESCRIPTION]).toBe('an OrderCreated event');
-    expect(attrs[PACT_ATTRS.INTERACTION_STATES]).toEqual(['an order exists']);
-    expect(attrs[PACT_ATTRS.CONTRACT_FILE]).toBeUndefined();
-  });
-
-  it('includes pact.contract.file when supplied', () => {
-    const attrs = buildPactAttributes(meta, { contractFile: 'pacts/OrderShipper-OrderService.json' });
-    expect(attrs[PACT_ATTRS.CONTRACT_FILE]).toBe('pacts/OrderShipper-OrderService.json');
-  });
-});
-
-describe('outcomeAttribute', () => {
-  it('returns a single-key record for the outcome', () => {
-    expect(outcomeAttribute('passed')).toEqual({ [PACT_ATTRS.OUTCOME]: 'passed' });
-    expect(outcomeAttribute('failed')).toEqual({ [PACT_ATTRS.OUTCOME]: 'failed' });
-  });
-});

package/src/attrs.ts

@@ -1,53 +0,0 @@
-import type { PactInteractionMeta, PactOutcome } from './types.js';
-
-/**
- * Attribute keys for Pact interactions. Centralised so the namespace is
- * a single source of truth and is forward-compatible with eventual OTel
- * semantic conventions.
- */
-export const PACT_ATTRS = {
-  CONSUMER: 'pact.consumer',
-  PROVIDER: 'pact.provider',
-  KIND: 'pact.kind',
-  INTERACTION_DESCRIPTION: 'pact.interaction.description',
-  INTERACTION_ID: 'pact.interaction.id',
-  INTERACTION_STATES: 'pact.interaction.states',
-  CONTRACT_FILE: 'pact.contract.file',
-  OUTCOME: 'pact.outcome',
-} as const;
-
-export type PactAttributeKey = (typeof PACT_ATTRS)[keyof typeof PACT_ATTRS];
-
-/**
- * Build the set of attributes to stamp on a span when an interaction is
- * about to be exercised. `outcome` is added later by the wrapper.
- */
-export function buildPactAttributes(
-  meta: PactInteractionMeta,
-  opts: { contractFile?: string } = {},
-): Record<string, string | string[]> {
-  const attrs: Record<string, string | string[]> = {
-    [PACT_ATTRS.CONSUMER]: meta.consumer,
-    [PACT_ATTRS.PROVIDER]: meta.provider,
-    [PACT_ATTRS.KIND]: meta.kind,
-    [PACT_ATTRS.INTERACTION_DESCRIPTION]: meta.description,
-    [PACT_ATTRS.INTERACTION_STATES]: meta.states,
-  };
-  if (opts.contractFile) {
-    attrs[PACT_ATTRS.CONTRACT_FILE] = opts.contractFile;
-  }
-  if (meta.interactionId) {
-    attrs[PACT_ATTRS.INTERACTION_ID] = meta.interactionId;
-  }
-  return attrs;
-}
-
-/**
- * Helper that returns just the outcome attribute — stamped after the
- * handler resolves or rejects.
- */
-export function outcomeAttribute(
-  outcome: PactOutcome,
-): Record<string, string> {
-  return { [PACT_ATTRS.OUTCOME]: outcome };
-}

package/src/audit.test.ts

@@ -1,189 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { computeAuditMatrix, runAuditSync } from './audit.js';
-import type { InteractionLedgerEntry, PactFile } from './types.js';
-import { AUDIT_MATRIX_SPEC, LEDGER_ENTRY_SPEC } from './types.js';
-
-const NOW = new Date('2026-06-01T00:00:00.000Z');
-const DAY = 24 * 60 * 60 * 1000;
-
-function entry(overrides: Partial<InteractionLedgerEntry>): InteractionLedgerEntry {
-  return {
-    type: 'interaction',
-    spec: LEDGER_ENTRY_SPEC,
-    consumer: 'A',
-    provider: 'B',
-    interaction: 'evt',
-    states: [],
-    kind: 'message',
-    source: 'test',
-    role: 'consumer',
-    outcome: 'passed',
-    duration_ms: 1,
-    observed_at: NOW.toISOString(),
-    ...overrides,
-  };
-}
-
-describe('computeAuditMatrix', () => {
-  it('marks contracted-and-seen-in-test as OK', () => {
-    const m = computeAuditMatrix({
-      contracted: [{ consumer: 'A', provider: 'B', interaction: 'evt', kind: 'message' }],
-      ledger: [entry({})],
-      now: NOW,
-    });
-    expect(m.counts).toMatchObject({ contracted_and_test_seen: 1, contracted_not_test_seen: 0 });
-    expect(m.rows[0]).toMatchObject({ contracted: true, test_seen: true, observed: true });
-  });
-
-  it('flags contracted-but-not-seen-in-test (STALE)', () => {
-    const m = computeAuditMatrix({
-      contracted: [{ consumer: 'A', provider: 'B', interaction: 'evt', kind: 'message' }],
-      ledger: [],
-      now: NOW,
-    });
-    expect(m.counts.contracted_not_test_seen).toBe(1);
-    expect(m.rows[0]).toMatchObject({ contracted: true, test_seen: false });
-  });
-
-  it('flags seen-but-not-contracted', () => {
-    const m = computeAuditMatrix({
-      contracted: [],
-      ledger: [entry({})],
-      now: NOW,
-    });
-    expect(m.counts.test_or_prod_seen_not_contracted).toBe(1);
-    expect(m.rows[0]).toMatchObject({ contracted: false, test_seen: true });
-  });
-
-  it('tracks prod_seen separately from test_seen', () => {
-    const m = computeAuditMatrix({
-      contracted: [{ consumer: 'A', provider: 'B', interaction: 'evt', kind: 'message' }],
-      ledger: [entry({ source: 'production' })],
-      now: NOW,
-    });
-    expect(m.rows[0]).toMatchObject({
-      test_seen: false,
-      prod_seen: true,
-    });
-    expect(m.counts.contracted_not_test_seen).toBe(1);
-  });
-
-  it('sets provider_verified only for provider role passed entries', () => {
-    const m = computeAuditMatrix({
-      contracted: [{ consumer: 'A', provider: 'B', interaction: 'evt', kind: 'message' }],
-      ledger: [
-        entry({ role: 'provider', outcome: 'passed' }),
-      ],
-      now: NOW,
-    });
-    expect(m.rows[0]!.provider_verified).toBe(true);
-    expect(m.rows[0]!.test_seen).toBe(false);
-  });
-
-  it('ignores provider_verification_run for per-interaction columns', () => {
-    const m = computeAuditMatrix({
-      contracted: [{ consumer: 'A', provider: 'B', interaction: 'evt', kind: 'message' }],
-      ledger: [
-        {
-          type: 'provider_verification_run',
-          spec: LEDGER_ENTRY_SPEC,
-          consumer: 'A',
-          provider: 'B',
-          outcome: 'failed',
-          source: 'test',
-          role: 'provider',
-          observed_at: NOW.toISOString(),
-          error: 'setup failed',
-        },
-      ],
-      now: NOW,
-    });
-    expect(m.rows[0]!.provider_verified).toBe(false);
-    expect(m.verification_failures).toHaveLength(1);
-  });
-
-  it('applies broker_verified at pact-pair level', () => {
-    const m = computeAuditMatrix({
-      contracted: [
-        { consumer: 'A', provider: 'B', interaction: 'evt1', kind: 'message' },
-        { consumer: 'A', provider: 'B', interaction: 'evt2', kind: 'message' },
-      ],
-      ledger: [],
-      brokerVerifications: [
-        { consumer: 'A', provider: 'B', success: true, verifiedAt: NOW.toISOString() },
-      ],
-      now: NOW,
-    });
-    expect(m.rows.every((r) => r.broker_verified)).toBe(true);
-    expect(m.counts.broker_verified).toBe(2);
-  });
-
-  it('excludes ledger entries outside the window', () => {
-    const oldEntry = entry({
-      observed_at: new Date(NOW.getTime() - 20 * DAY).toISOString(),
-    });
-    const m = computeAuditMatrix({
-      contracted: [{ consumer: 'A', provider: 'B', interaction: 'evt', kind: 'message' }],
-      ledger: [oldEntry],
-      windowDays: 14,
-      now: NOW,
-    });
-    expect(m.counts.contracted_not_test_seen).toBe(1);
-  });
-
-  it('emits v0.2 audit matrix spec', () => {
-    const m = computeAuditMatrix({
-      contracted: [],
-      ledger: [],
-      now: NOW,
-    });
-    expect(m.spec).toBe(AUDIT_MATRIX_SPEC);
-  });
-});
-
-describe('runAuditSync (integration)', () => {
-  let workDir: string;
-  let originalCwd: string;
-
-  beforeEach(() => {
-    originalCwd = process.cwd();
-    workDir = mkdtempSync(path.join(tmpdir(), 'autotel-pact-audit-'));
-    process.chdir(workDir);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    rmSync(workDir, { recursive: true, force: true });
-  });
-
-  it('reads pacts and ledger from disk and produces a matrix', () => {
-    mkdirSync('pacts', { recursive: true });
-    const pact: PactFile = {
-      consumer: { name: 'OrderShipper' },
-      provider: { name: 'OrderService' },
-      messages: [
-        { description: 'an OrderCreated event' },
-        { description: 'an OrderCancelled event' },
-      ],
-    };
-    writeFileSync('pacts/OrderShipper-OrderService.json', JSON.stringify(pact));
-
-    mkdirSync('.autotel-pact', { recursive: true });
-    const observed = entry({
-      consumer: 'OrderShipper',
-      provider: 'OrderService',
-      interaction: 'an OrderCreated event',
-      observed_at: new Date().toISOString(),
-    });
-    writeFileSync('.autotel-pact/ledger-x.jsonl', JSON.stringify(observed) + '\n');
-
-    const m = runAuditSync({});
-
-    expect(m.counts.contracted).toBe(2);
-    expect(m.counts.contracted_and_test_seen).toBe(1);
-    expect(m.counts.contracted_not_test_seen).toBe(1);
-  });
-});

package/src/audit.ts

@@ -1,251 +0,0 @@
-import path from 'node:path';
-import { fetchBrokerVerifications, type BrokerConfig } from './broker.js';
-import { readLedger, type LedgerOptions } from './ledger.js';
-import {
-  interactionsFromPactFile,
-  listPactFiles,
-  parsePactFile,
-} from './pact-file.js';
-import {
-  AUDIT_MATRIX_SPEC,
-  isInteractionLedgerEntry,
-  isProviderVerificationRun,
-  type AuditMatrix,
-  type AuditRow,
-  type BrokerVerification,
-  type InteractionLedgerEntry,
-  type LedgerRecord,
-  type PactInteractionKey,
-  type ProviderVerificationRunEntry,
-} from './types.js';
-
-export interface AuditOptions extends LedgerOptions {
-  pactsDir?: string;
-  windowDays?: number;
-  broker?: BrokerConfig;
-}
-
-const DEFAULT_PACTS_DIR = './pacts';
-const DEFAULT_WINDOW_DAYS = 14;
-
-export function keyOf(k: PactInteractionKey): string {
-  const identity = k.interactionId ?? k.interaction;
-  return `${k.consumer}::${k.provider}::${k.kind}::${identity}`;
-}
-
-function pairKey(consumer: string, provider: string): string {
-  return `${consumer}::${provider}`;
-}
-
-function inWindow(observedAt: string, cutoff: number): boolean {
-  const t = Date.parse(observedAt);
-  return Number.isFinite(t) && t >= cutoff;
-}
-
-/**
- * Compute the audit matrix from pact files, ledger, and optional broker data.
- */
-export function computeAuditMatrix(input: {
-  contracted: PactInteractionKey[];
-  ledger: LedgerRecord[];
-  brokerVerifications?: BrokerVerification[];
-  windowDays?: number;
-  now?: Date;
-}): AuditMatrix {
-  const windowDays = input.windowDays ?? DEFAULT_WINDOW_DAYS;
-  const now = input.now ?? new Date();
-  const cutoff = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
-
-  const verificationFailures: ProviderVerificationRunEntry[] = [];
-  const recentInteractions: InteractionLedgerEntry[] = [];
-
-  for (const entry of input.ledger) {
-    if (!inWindow(entry.observed_at, cutoff)) continue;
-    if (isProviderVerificationRun(entry)) {
-      verificationFailures.push(entry);
-      continue;
-    }
-    if (isInteractionLedgerEntry(entry)) {
-      recentInteractions.push(entry);
-    }
-  }
-
-  const brokerByPair = new Map<string, BrokerVerification>();
-  for (const b of input.brokerVerifications ?? []) {
-    brokerByPair.set(pairKey(b.consumer, b.provider), b);
-  }
-
-  const testSeenByKey = new Map<string, InteractionLedgerEntry[]>();
-  const prodSeenByKey = new Map<string, InteractionLedgerEntry[]>();
-  const providerVerifiedByKey = new Map<string, InteractionLedgerEntry[]>();
-  const anyObservedByKey = new Map<string, InteractionLedgerEntry[]>();
-
-  for (const entry of recentInteractions) {
-    const k = keyOf({
-      consumer: entry.consumer,
-      provider: entry.provider,
-      interaction: entry.interaction,
-      kind: entry.kind,
-      interactionId: entry.interaction_id,
-    });
-
-    const push = (map: Map<string, InteractionLedgerEntry[]>) => {
-      const arr = map.get(k) ?? [];
-      arr.push(entry);
-      map.set(k, arr);
-    };
-
-    push(anyObservedByKey);
-
-    if (entry.source === 'test' && entry.role === 'consumer') {
-      push(testSeenByKey);
-    }
-    if (entry.source === 'production') {
-      push(prodSeenByKey);
-    }
-    if (entry.role === 'provider' && entry.outcome === 'passed') {
-      push(providerVerifiedByKey);
-    }
-  }
-
-  const contractedByKey = new Map<string, PactInteractionKey>();
-  for (const c of input.contracted) {
-    contractedByKey.set(keyOf(c), c);
-  }
-
-  const rows: AuditRow[] = [];
-
-  function pushRow(parts: PactInteractionKey, k: string, isContracted: boolean): void {
-    const testObs = testSeenByKey.get(k) ?? [];
-    const prodObs = prodSeenByKey.get(k) ?? [];
-    const providerObs = providerVerifiedByKey.get(k) ?? [];
-    const allObs = anyObservedByKey.get(k) ?? [];
-    const latest = allObs.toSorted((a, b) =>
-      b.observed_at.localeCompare(a.observed_at),
-    )[0];
-    const broker = brokerByPair.get(pairKey(parts.consumer, parts.provider));
-
-    rows.push({
-      consumer: parts.consumer,
-      provider: parts.provider,
-      interaction: parts.interaction,
-      interaction_id: parts.interactionId ?? latest?.interaction_id,
-      kind: parts.kind,
-      contracted: isContracted,
-      observed: testObs.length > 0 || prodObs.length > 0,
-      test_seen: testObs.length > 0,
-      prod_seen: prodObs.length > 0,
-      provider_verified: providerObs.length > 0,
-      broker_verified: broker?.success === true,
-      broker_verified_at: broker?.verifiedAt,
-      broker_error: broker?.error,
-      last_observed_at: latest?.observed_at,
-      last_outcome: latest?.outcome,
-    });
-  }
-
-  for (const [k, contracted] of contractedByKey) {
-    pushRow(contracted, k, true);
-  }
-  for (const [k, observations] of anyObservedByKey) {
-    if (contractedByKey.has(k)) continue;
-    const first = observations[0]!;
-    pushRow(
-      {
-        consumer: first.consumer,
-        provider: first.provider,
-        interaction: first.interaction,
-        kind: first.kind,
-        interactionId: first.interaction_id,
-      },
-      k,
-      false,
-    );
-  }
-
-  rows.sort((a, b) =>
-    a.consumer.localeCompare(b.consumer) ||
-    a.provider.localeCompare(b.provider) ||
-    a.interaction.localeCompare(b.interaction),
-  );
-
-  const counts = {
-    total: rows.length,
-    contracted: rows.filter((r) => r.contracted).length,
-    observed: rows.filter((r) => r.observed).length,
-    contracted_and_test_seen: rows.filter((r) => r.contracted && r.test_seen).length,
-    contracted_not_test_seen: rows.filter((r) => r.contracted && !r.test_seen).length,
-    test_or_prod_seen_not_contracted: rows.filter(
-      (r) => !r.contracted && (r.test_seen || r.prod_seen),
-    ).length,
-    test_seen: rows.filter((r) => r.test_seen).length,
-    prod_seen: rows.filter((r) => r.prod_seen).length,
-    provider_verified: rows.filter((r) => r.provider_verified).length,
-    broker_verified: rows.filter((r) => r.broker_verified).length,
-  };
-
-  const matrix: AuditMatrix = {
-    spec: AUDIT_MATRIX_SPEC,
-    rows,
-    counts,
-    window_days: windowDays,
-    generated_at: now.toISOString(),
-  };
-
-  if (verificationFailures.length > 0) {
-    matrix.verification_failures = verificationFailures;
-  }
-
-  return matrix;
-}
-
-export async function runAudit(opts: AuditOptions = {}): Promise<AuditMatrix> {
-  const pactsDir = path.resolve(process.cwd(), opts.pactsDir ?? DEFAULT_PACTS_DIR);
-  const contracted: PactInteractionKey[] = [];
-  const pairs = new Set<string>();
-
-  for (const file of listPactFiles(pactsDir)) {
-    const pact = parsePactFile(file);
-    if (!pact) continue;
-    const interactions = interactionsFromPactFile(pact);
-    contracted.push(...interactions);
-    const consumer = pact.consumer?.name;
-    const provider = pact.provider?.name;
-    if (consumer && provider) {
-      pairs.add(pairKey(consumer, provider));
-    }
-  }
-
-  const ledger = readLedger(opts);
-
-  let brokerVerifications: BrokerVerification[] | undefined;
-  if (opts.broker) {
-    brokerVerifications = await fetchBrokerVerifications(opts.broker, [...pairs].map((p) => {
-      const [consumer, provider] = p.split('::');
-      return { consumer: consumer!, provider: provider! };
-    }));
-  }
-
-  return computeAuditMatrix({
-    contracted,
-    ledger,
-    brokerVerifications,
-    windowDays: opts.windowDays,
-  });
-}
-
-/** Sync audit without broker (backward compatible for tests). */
-export function runAuditSync(opts: Omit<AuditOptions, 'broker'> = {}): AuditMatrix {
-  const pactsDir = path.resolve(process.cwd(), opts.pactsDir ?? DEFAULT_PACTS_DIR);
-  const contracted: PactInteractionKey[] = [];
-  for (const file of listPactFiles(pactsDir)) {
-    const pact = parsePactFile(file);
-    if (pact) contracted.push(...interactionsFromPactFile(pact));
-  }
-  const ledger = readLedger(opts);
-  return computeAuditMatrix({
-    contracted,
-    ledger,
-    windowDays: opts.windowDays,
-  });
-}