@testgorilla/tgo-pact 0.0.0 → 1.0.0-rc.0

package/README.md

@@ -0,0 +1,384 @@
+# @testgorilla/tgo-pact
+
+Pact consumer test helpers for TestGorilla's Angular apps. It replaces the helpers each app kept its own copy of: `pact-test-bed.ts` and `api-contract.ts` in tgo-frontend, `core/testing/pact-test-bed.ts` in tgo-talent-frontend, `talent-backend.pact.mocks.ts` in tgo-talent-assessment-frontend and `src/pact/admin-tool-pact.ts` in tgo-admin-tool.
+
+- `createPact()` creates a V4 pact with the shared defaults.
+- `configurePactTestBed()` configures TestBed with HttpClient pointed at the Pact mock server.
+- `datetime`, `date`, `uuid`, `url`, `digits` and `shapeOf` build matchers.
+- `verifyServiceContracts()` drives service methods from a table of contracts, on top of `verifyInteraction()`.
+- `createPactJestConfig()`, from `@testgorilla/tgo-pact/jest`, turns the app's Jest config into the pact run's config.
+
+App-specific code stays in the app: provider state names and params, fixed ids, tokens the provider states create, stubs of app services, and tgo-frontend's OpenAPI-driven `ApiDocumentContract` and `verifyClientContracts`.
+
+Node 22.12 or later. Peer dependencies: `@angular/core` and `@angular/common` `>=21.0.0 <23.0.0`, `@pact-foundation/pact` `^17.0.0`, `jest` `^30.0.0`, `rxjs` `^7.8.0`.
+
+## Installation
+
+The package is published to npmjs under the `@testgorilla` scope. The apps' `.npmrc` already maps the scope:
+
+```ini
+@testgorilla:registry=https://registry.npmjs.org/
+```
+
+```bash
+npm install --save-dev @testgorilla/tgo-pact
+```
+
+To try an unreleased build, pack it and install the tarball:
+
+```bash
+# in tgo-fe-libraries
+npx nx build tgo-pact
+cd dist/packages/tgo-pact && npm pack --pack-destination /tmp
+
+# in the app
+npm install --save-dev /tmp/testgorilla-tgo-pact-<version>.tgz
+```
+
+## Jest config
+
+`createPactJestConfig(base?, overrides?)` takes the app's Jest config and returns one for the pact run. It keeps the preset, transforms, module mapping and setup files, and sets:
+
+| Setting                  | Value                                            | Why                                                                   |
+| ------------------------ | ------------------------------------------------ | --------------------------------------------------------------------- |
+| `testMatch`              | `['**/*.pact.spec.ts']`                          | Only pact specs                                                       |
+| `maxWorkers`             | `1`                                              | Runs in band: specs of one consumer-provider pair write the same file |
+| `testTimeout`            | `30000`                                          | Every test starts a mock server                                       |
+| `testPathIgnorePatterns` | the base's, minus those matching `.pact.spec.ts` | Unit configs usually ignore `*.pact.spec.ts`                          |
+| `displayName`            | the base's, else `pact`                          |                                                                       |
+| `collectCoverage`        | `false`                                          |                                                                       |
+| `testRegex`, `projects`  | removed                                          | They would override `testMatch` or run the unit projects              |
+
+`overrides` is a Jest config applied last, over the base and these defaults, e.g. `testMatch`, `displayName`, `globalSetup` or `reporters`.
+
+```js
+// jest.pact.config.js
+const { createPactJestConfig } = require('@testgorilla/tgo-pact/jest');
+const baseConfig = require('./jest.unit.config.js');
+
+module.exports = createPactJestConfig(baseConfig, {
+  reporters: [
+    'default',
+    ['jest-junit', { outputDirectory: './pact-test-results', outputName: 'results.xml' }],
+  ],
+});
+```
+
+```ts
+// jest/pact.config.ts
+import { createPactJestConfig } from '@testgorilla/tgo-pact/jest';
+
+import { baseJestConfig } from './base.config.ts';
+
+export default createPactJestConfig(baseJestConfig, {
+  testMatch: ['<rootDir>/src/**/*.pact.spec.ts'],
+  globalSetup: '<rootDir>/jest/pact.global-setup.ts',
+});
+```
+
+A TypeScript Jest config can share the unit config's base by exporting the unit project from `jest.config.ts` and importing it. The unit project's `displayName` then carries over, so override it: `createPactJestConfig(unitProject, { displayName: 'pact' })`.
+
+The secondary entry point has no Angular imports, so loading it from a Jest config stays cheap. It ships as ESM; Node 22.12 and later can `require()` it from a CommonJS config.
+
+## createPact
+
+```ts
+function createPact(consumer: string, provider: string, options?: CreatePactOptions): PactV4;
+type CreatePactOptions = Partial<Omit<PactV4Options, 'consumer' | 'provider'>>;
+```
+
+Defaults: V4 specification, `logLevel: 'warn'` and `cors: true`, because jsdom's XMLHttpRequest enforces CORS and the mock server runs on another origin. The pact file is written to `options.dir`, else `$PACT_DIR`, else `<cwd>/pacts`; `dir: undefined` counts as not given. Every other `PactV4` option, such as `port`, passes through.
+
+Use the app's repository name as the consumer: `tgo-frontend`, `tgo-talent-frontend`, `tgo-talent-assessment-frontend` and `tgo-admin-tool`. The broker and the providers' verification jobs know the pacts by these names, so keep them exact. Create one pact per spec file: each one gets its own mock server.
+
+```ts
+const pact = createPact('tgo-talent-frontend', 'tgo-talent-backend');
+```
+
+## configurePactTestBed
+
+```ts
+function configurePactTestBed(
+  mockServerUrl: string,
+  providers?: Provider[],
+  options?: PactTestBedOptions
+): void;
+
+interface PactTestBedOptions {
+  token?: string | null; // provided as PACT_AUTH_TOKEN; default null
+  authHeaders?: Record<string, string>; // added to every request that does not set them
+  interceptors?: HttpInterceptorFn[]; // functional interceptors, after the DI ones
+  interceptorClasses?: Type<HttpInterceptor>[]; // registered as HTTP_INTERCEPTORS
+  httpClient?: EnvironmentProviders; // replaces the default provideHttpClient(...)
+}
+```
+
+Call it inside `executeTest`, once the mock server URL is known. It provides:
+
+- `provideHttpClient(withInterceptorsFromDi(), withInterceptors([...]))`, or `options.httpClient`. `httpClient` with `authHeaders` or `interceptors` throws: add them to the app's providers instead. `interceptorClasses` are registered as `HTTP_INTERCEPTORS`, which HttpClient only reads with `withInterceptorsFromDi()`, so custom `httpClient` providers need it.
+- `HttpBackend` as `HttpXhrBackend`. jsdom has no `fetch`, and Angular 22 makes HttpClient use it by default.
+- `PACT_MOCK_SERVER_URL`, the mock server URL without a trailing slash.
+- `PACT_AUTH_TOKEN`, the token the app's auth stub hands to its real interceptor.
+- `providers`, last, so they can override any of the above.
+
+The package knows no app services. Stub them in `providers` and read the URL and token from the injection tokens with `useFactory`, so the app's real interceptors build the headers the provider sees. `authorizationHeader(token, scheme = 'Token')` returns `{ Authorization: '<scheme> <token>' }` for the expected request.
+
+```ts
+// core/testing/pact-test-bed.ts in tgo-talent-frontend
+export const PACT_API_TOKEN = 'pact-test-token-not-a-secret-talent-fe';
+export const PACT_AUTH_HEADER = authorizationHeader(PACT_API_TOKEN);
+
+export function configureTalentPactTestBed(
+  mockServerUrl: string,
+  providers: Provider[] = [],
+  token = PACT_API_TOKEN
+) {
+  configurePactTestBed(
+    mockServerUrl,
+    [
+      {
+        provide: AppConfigService,
+        useFactory: () => {
+          const apiUrl = `${inject(PACT_MOCK_SERVER_URL)}/api`;
+          return { config: { API_URL: apiUrl, CUSTOMER_APP_SERVICE_URL: apiUrl } };
+        },
+      },
+      {
+        provide: AuthenticationStore,
+        useFactory: () => ({ token: signal(inject(PACT_AUTH_TOKEN)), clearState: jest.fn() }),
+      },
+      { provide: Router, useValue: { navigate: jest.fn() } },
+      ...providers,
+    ],
+    { token, interceptorClasses: [TokenInterceptorService] }
+  );
+}
+```
+
+How each app wires its base URL and auth:
+
+| App                            | Base URL from `PACT_MOCK_SERVER_URL`                                                                                 | Auth                                                                                                                                                                                                       |
+| ------------------------------ | -------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| tgo-frontend                   | `APIConfigService`, `APIConfigServiceOptions` and `AppConfigService` (`apiUrl`, `cr2_endpoint`, `llm_api_url`) as is | `httpClient: provideAppHttpClient()`, `interceptorClasses: [AuthInterceptor]`, `AuthGeneralService` stub reading the tokens                                                                                |
+| tgo-talent-frontend            | `AppConfigService` `API_URL` and `CUSTOMER_APP_SERVICE_URL` as `<url>/api`                                           | `interceptorClasses: [TokenInterceptorService]`, `AuthenticationStore` stub with `token: signal(inject(PACT_AUTH_TOKEN))` and `candidateProfileUUId`, plus `FeatureFlagsStore` and `SnackbarService` stubs |
+| tgo-talent-assessment-frontend | `AppConfigService` `API_URL` as `<url>/api/`                                                                         | `interceptors: [apiInterceptor, cacheBusterInterceptor]`, `GlobalStateStore` stub holding the invitation uuid                                                                                              |
+| tgo-admin-tool                 | `APIConfigService` `options.apiUrl` as is                                                                            | `interceptorClasses: [AuthInterceptor]`, `AuthService` stub from `authServiceStub()`                                                                                                                       |
+
+A test that needs a second token, such as tgo-frontend's test taker or survey token or tgo-admin-tool's impersonation token, keeps it in the app's stub and passes it through the app's own wrapper.
+
+## Matchers
+
+```ts
+const datetime: (example?: string) => V3RegexMatcher; // ISO-8601 datetime, as DRF renders it
+const date: (example?: string) => V3RegexMatcher; // YYYY-MM-DD
+const uuid: (example?: string) => V3RegexMatcher; // lowercase canonical UUID
+const url: (example?: string) => V3RegexMatcher; // absolute http(s) URL
+const digits: (example: number | string) => V3RegexMatcher; // a string of digits
+function shapeOf(example: unknown, minItems?: number): unknown;
+```
+
+The patterns are exported as `ISO_DATETIME_PATTERN`, `ISO_DATE_PATTERN`, `UUID_PATTERN`, `URL_PATTERN` and `DIGITS_PATTERN`.
+
+`shapeOf` turns an example of the app's model into type matchers:
+
+- Whole numbers match integers only, so `{ price: 10 }` rejects `10.5`. Other numbers match any number. To accept decimals where the example is whole, pass the matcher: `{ price: MatchersV3.decimal(10) }` or `MatchersV3.number(10)`. This stays as it is, because changing it would change existing pacts.
+- ISO datetimes match `datetime`. Other strings and booleans match by type.
+- A top-level list needs `minItems` items (default 1). A nested list may be empty, except under a `results` key.
+- Every list in the example needs an item, which describes the items' shape. An empty one throws, naming its path, e.g. `$.tags`.
+- Matchers pass through unchanged.
+
+Leave nullable fields out of the example: the app copes with null, so the contract should not pin their type. A nested list the app indexes into needs an explicit `eachLike`, because `shapeOf` lets nested lists be empty.
+
+```ts
+willRespondWith(200, builder =>
+  builder.jsonBody(shapeOf({ results: [{ id: 1, created: '2026-10-01T09:30:00Z' }] }))
+);
+```
+
+## Provider states
+
+```ts
+interface ProviderState {
+  name: string;
+  params?: JsonMap;
+}
+const providerState: (name: string, params?: JsonMap) => ProviderState;
+function givenStates(pact: PactV4, states: readonly ProviderState[]): V4UnconfiguredInteraction;
+```
+
+`givenStates` starts an interaction with every state applied in order. It is useful when the auth state and the data states are kept as a list. Each app keeps its own state catalogue.
+
+```ts
+await givenStates(pact, [
+  providerState(CANDIDATE_AUTHENTICATED, { profileUuid }),
+  providerState('the candidate has a badge'),
+])
+  .uponReceiving("a request for the candidate's badges")
+  .withRequest('GET', BADGES_URL, builder => builder.headers(PACT_AUTH_HEADER))
+  .willRespondWith(200, builder =>
+    builder.jsonBody(shapeOf({ results: [{ badge_type: 'ai_fluency' }] }))
+  )
+  .executeTest(async mockServer => {
+    configureTalentPactTestBed(mockServer.url, [BadgesDataService]);
+    // call the service and assert
+  });
+```
+
+## verifyServiceContracts
+
+The table-driven contracts from tgo-frontend, with the app-specific parts moved to the suite:
+
+```ts
+function verifyServiceContracts<S, O = undefined>(
+  suite: ContractSuite<O>,
+  service: Type<S>,
+  contracts: ServiceContract<S, O>[]
+): void;
+function verifyServiceContract<S, O = undefined>(
+  suite: ContractSuite<O>,
+  service: Type<S>,
+  contract: ServiceContract<S, O>
+): Promise<void>;
+
+interface ContractSuite<O = undefined> {
+  pact: PactV4;
+  given?: ProviderState[]; // before each contract's own states
+  headers?: TemplateHeaders | ((options: O | undefined) => TemplateHeaders); // expected on every request
+  configureTestBed?: (mockServerUrl: string, providers: Provider[], options: O | undefined) => void; // default: configurePactTestBed(mockServerUrl, providers)
+  responseFor?: (operationId: string) => ContractResponse; // resolves response.operationId
+}
+
+interface ServiceContract<S, O = undefined> {
+  description: string; // test name: `should <description>`
+  given?: ProviderState[];
+  replaceGiven?: boolean; // apply only `given`, without the suite's states
+  request: {
+    method: string;
+    path: string;
+    query?: TemplateQuery;
+    headers?: TemplateHeaders;
+    body?: unknown;
+  };
+  replaceHeaders?: boolean; // expect only `request.headers`, without the suite's headers
+  call: (service: S) => Observable<unknown>;
+  response: { status?: number; body?: unknown; operationId?: string };
+  expect?: (result: unknown, body: unknown) => void | Promise<void>; // replaces the body check
+  options?: O; // per-contract context for headers and configureTestBed
+}
+```
+
+`verifyServiceContracts` declares one `it` per contract. Each one registers the interaction, calls `contract.call` on the service from TestBed and checks the result:
+
+- With a 2xx status and a body, the result must equal the reified body.
+- With a 2xx status and no body, it must be `null` or `''`.
+- With a status of 400 or more, the call must fail with an `HttpErrorResponse` of that status. Its `error` must equal the reified body, or be `null` or `''` without one.
+
+`response.operationId` takes the operation's documented 2xx response from the suite's `responseFor`; `status` may replace its 2xx status. A contract with both `operationId` and `body`, or with `operationId` and a status of 400 or more, throws: give an error response's body explicitly.
+
+`replaceGiven` and `replaceHeaders` fit calls the suite's defaults don't describe into the table, such as an anonymous call that gets a 401:
+
+```ts
+{
+  description: 'reject an anonymous request for the jobs',
+  replaceGiven: true,
+  replaceHeaders: true,
+  request: { method: 'GET', path: '/api/jobs/' },
+  call: service => service.jobs(),
+  response: { status: 401, body: shapeOf({ detail: 'Authentication credentials were not provided.' }) },
+  options: { anonymous: true },
+}
+```
+
+`expect` replaces the body check, for a method that hands back only part of the response or reshapes it. It gets what the call resolved to, or the `HttpErrorResponse` of a failing call, and the reified response body. A failing call's status is still checked.
+
+```ts
+{
+  description: 'list the recent talent searches',
+  request: { method: 'GET', path: '/api/sourcing/searches/', query: { limit: '5', offset: '0' } },
+  call: service => service.getRecentSearches(),
+  response: { body: shapeOf({ count: 1, results: [{ id: 3101 }] }) },
+  expect: (results, body) => expect(results).toEqual((body as { results: unknown[] }).results),
+}
+```
+
+`O` replaces tgo-frontend's `asTestTaker` and `surveyToken` flags. `responseFor` replaces the built-in OpenAPI lookup: the app resolves the operation from its own document.
+
+```ts
+interface Session {
+  asTestTaker?: boolean;
+}
+
+export const tgoBackendSuite = (): ContractSuite<Session> => ({
+  pact: createPact('tgo-frontend', 'tgo-backend'),
+  given: [providerState(CUSTOMER_ADMIN_STATE, { userId: ID.user, customerId: ID.customer })],
+  headers: session => (session?.asTestTaker ? TEST_TAKER_AUTH_HEADER : AUTH_HEADER),
+  configureTestBed: (url, providers, session) =>
+    configureFrontendPactTestBed(url, providers, session?.asTestTaker ? TEST_TAKER_TOKEN : null),
+  responseFor: operationId => {
+    const operation = tgoApi.operation(operationId);
+    return { status: operation.status, body: operation.schema && tgoApi.matcher(operation.schema) };
+  },
+});
+
+verifyServiceContracts(tgoBackendSuite(), PromptsDaoService, [
+  {
+    description: 'extract the signals of a sourcing prompt',
+    given: [cannedPrompts],
+    request: {
+      method: 'POST',
+      path: '/api/sourcing/prompts/lightweight-query-extractor/',
+      body: { query: 'react' },
+    },
+    call: service => service.extractPromptSignals({ query: ' React ' }),
+    response: { body: shapeOf({ job_role: true, extraction_failed: false }) },
+  },
+  {
+    description: 'answer as the test taker',
+    request: { method: 'GET', path: '/api/test-taker/answers/1/' },
+    call: service => service.answer(1),
+    response: { operationId: 'answers_read' },
+    options: { asTestTaker: true },
+  },
+]);
+```
+
+## verifyInteraction
+
+```ts
+function verifyInteraction(interaction: InteractionContract): Promise<void>;
+
+interface InteractionContract {
+  pact: PactV4;
+  description: string; // the interaction description
+  states?: readonly ProviderState[];
+  request: ContractRequest; // with every header the request must carry
+  response: ContractResponse; // { status?: number; body?: unknown }
+  run: (mockServerUrl: string) => Observable<unknown> | Promise<unknown>;
+  expect?: (result: unknown, body: unknown) => void | Promise<void>;
+}
+```
+
+The runner under `verifyServiceContract`, for contract tables that call something other than a service from TestBed, such as tgo-frontend's generated API clients. It registers the interaction, calls `run` with the mock server URL and checks the outcome the same way: the reified body, `null` or `''` for an empty response, and an `HttpErrorResponse` of the status for a 4xx/5xx one. `run` configures TestBed and makes the call.
+
+```ts
+await verifyInteraction({
+  pact: suite.pact,
+  description: contract.description,
+  states: [...suite.given, ...contract.given],
+  request: { method: operation.method, path, query, headers: { ...AUTH_HEADER, ...headers }, body },
+  response: { status, body },
+  run: mockServerUrl => {
+    configureFrontendPactTestBed(mockServerUrl, [client]);
+    return TestBed.inject(client)[contract.operationId](params);
+  },
+});
+```
+
+## Migration checklist
+
+1. Install the package and replace the app's pact Jest config with `createPactJestConfig`. Keep the `test:pact` script; the pact run no longer needs `--runInBand`, but leaving it in is harmless.
+2. Replace the app's `new PactV4({...})` with `createPact('<app repo name>', '<provider>')`. Pass `port` and other options through `options`.
+3. Rewrite the app's TestBed helper on top of `configurePactTestBed`. Keep its signature if many specs call it, and rename it if it was itself called `configurePactTestBed` (tgo-admin-tool's became `configureAdminToolPactTestBed`), so it doesn't shadow the package export. Point the app's config stub at `PACT_MOCK_SERVER_URL` and the auth stub at `PACT_AUTH_TOKEN`.
+4. Replace the local `datetime`, `date`, `uuid`, `url`, `digits` and `shapeOf` with the package's. The patterns are the same.
+5. In tgo-frontend, move `verifyServiceContracts` callers to the package's version through a `ContractSuite` like the one above. `ApiDocumentContract` and `verifyClientContracts` stay in the app, with `verifyClientContracts` built on `verifyInteraction`.
+6. Run the pact specs and compare the generated pact files with the old ones. Only intended differences should appear, for example nested lists `shapeOf` now lets be empty.

package/fesm2022/testgorilla-tgo-pact-jest.mjs

@@ -0,0 +1,31 @@
+const PACT_TEST_MATCH = ["**/*.pact.spec.ts"];
+const PACT_TEST_TIMEOUT = 3e4;
+const PACT_DISPLAY_NAME = "pact";
+const DEFAULT_TEST_PATH_IGNORE_PATTERNS = ["/node_modules/"];
+const PACT_SPEC_EXAMPLE_PATH = "/src/app/example.pact.spec.ts";
+const PACT_JEST_DEFAULTS = {
+	testMatch: PACT_TEST_MATCH,
+	testTimeout: PACT_TEST_TIMEOUT,
+	maxWorkers: 1,
+	collectCoverage: false
+};
+function createPactJestConfig(base = {}, overrides = {}) {
+	const config = {
+		...base,
+		...PACT_JEST_DEFAULTS,
+		displayName: base.displayName ?? "pact",
+		testPathIgnorePatterns: keepingPactSpecs(base.testPathIgnorePatterns ?? DEFAULT_TEST_PATH_IGNORE_PATTERNS)
+	};
+	delete config.testRegex;
+	delete config.projects;
+	return {
+		...config,
+		...overrides
+	};
+}
+function keepingPactSpecs(patterns) {
+	return patterns.filter((pattern) => !new RegExp(pattern.replace("<rootDir>", "")).test(PACT_SPEC_EXAMPLE_PATH));
+}
+export { DEFAULT_TEST_PATH_IGNORE_PATTERNS, PACT_DISPLAY_NAME, PACT_JEST_DEFAULTS, PACT_SPEC_EXAMPLE_PATH, PACT_TEST_MATCH, PACT_TEST_TIMEOUT, createPactJestConfig };
+
+//# sourceMappingURL=testgorilla-tgo-pact-jest.mjs.map

package/fesm2022/testgorilla-tgo-pact-jest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testgorilla-tgo-pact-jest.mjs","names":[],"sources":["../../../../packages/tgo-pact/jest/src/pact-jest-config.constants.ts","../../../../packages/tgo-pact/jest/src/pact-jest-config.ts"],"sourcesContent":["import type { Config } from 'jest';\n\nexport const PACT_TEST_MATCH = ['**/*.pact.spec.ts'];\nexport const PACT_TEST_TIMEOUT = 30000;\nexport const PACT_DISPLAY_NAME = 'pact';\n\n/** Used when the base config sets no `testPathIgnorePatterns`; Jest's own default. */\nexport const DEFAULT_TEST_PATH_IGNORE_PATTERNS = ['/node_modules/'];\n\n/** A pact spec's path, for finding the base config's ignore patterns that would skip pact specs. */\nexport const PACT_SPEC_EXAMPLE_PATH = '/src/app/example.pact.spec.ts';\n\nexport const PACT_JEST_DEFAULTS: Readonly<Config> = {\n  testMatch: PACT_TEST_MATCH,\n  testTimeout: PACT_TEST_TIMEOUT,\n  // Specs of one consumer-provider pair write the same pact file, and concurrent writers corrupt it.\n  // Jest runs in band with a single worker.\n  maxWorkers: 1,\n  collectCoverage: false,\n};\n","import type { Config } from 'jest';\nimport {\n  DEFAULT_TEST_PATH_IGNORE_PATTERNS,\n  PACT_DISPLAY_NAME,\n  PACT_JEST_DEFAULTS,\n  PACT_SPEC_EXAMPLE_PATH,\n} from './pact-jest-config.constants';\n\n/**\n * Turns the app's unit Jest config into one for Pact consumer specs: `*.pact.spec.ts` only, in band, a 30s timeout\n * and no coverage. Everything else (preset, transforms, module mapping, setup files, the other ignore patterns) comes\n * from `base`, minus `testRegex` and `projects` and the ignore patterns that would skip pact specs. `displayName`\n * defaults to `pact` when `base` has none. `overrides` apply last, over both.\n */\nexport function createPactJestConfig(base: Config = {}, overrides: Config = {}): Config {\n  const config: Config = {\n    ...base,\n    ...PACT_JEST_DEFAULTS,\n    displayName: base.displayName ?? PACT_DISPLAY_NAME,\n    testPathIgnorePatterns: keepingPactSpecs(\n      base.testPathIgnorePatterns ?? DEFAULT_TEST_PATH_IGNORE_PATTERNS\n    ),\n  };\n  delete config.testRegex;\n  delete config.projects;\n\n  return { ...config, ...overrides };\n}\n\nfunction keepingPactSpecs(patterns: string[]): string[] {\n  return patterns.filter(\n    pattern => !new RegExp(pattern.replace('<rootDir>', '')).test(PACT_SPEC_EXAMPLE_PATH)\n  );\n}\n"],"mappings":"AAEA,MAAa,kBAAkB,CAAC,mBAAmB;AACnD,MAAa,oBAAoB;AACjC,MAAa,oBAAoB;AAGjC,MAAa,oCAAoC,CAAC,gBAAgB;AAGlE,MAAa,yBAAyB;AAEtC,MAAa,qBAAuC;CAClD,WAAW;CACX,aAAa;CAGb,YAAY;CACZ,iBAAiB;AAClB;ACLD,SAAgB,qBAAqB,OAAe,CAAA,GAAI,YAAoB,CAAA,GAAE;CAC5E,MAAM,SAAiB;EACrB,GAAG;EACH,GAAG;EACH,aAAa,KAAK,eAAA;EAClB,wBAAwB,iBACtB,KAAK,0BAA0B,iCAAiC;CAEnE;CACD,OAAO,OAAO;CACd,OAAO,OAAO;CAEd,OAAO;EAAE,GAAG;EAAQ,GAAG;CAAS;AAClC;AAEA,SAAS,iBAAiB,UAAkB;CAC1C,OAAO,SAAS,QACd,YAAW,CAAC,IAAI,OAAO,QAAQ,QAAQ,aAAa,EAAE,CAAC,CAAC,CAAC,KAAK,sBAAsB,CAAC;AAEzF"}

package/fesm2022/testgorilla-tgo-pact.mjs

@@ -0,0 +1,172 @@
+import { HTTP_INTERCEPTORS, HttpBackend, HttpErrorResponse, HttpXhrBackend, provideHttpClient, withInterceptors, withInterceptorsFromDi } from "@angular/common/http";
+import { MatchersV3, PactV4, SpecificationVersion } from "@pact-foundation/pact";
+import { firstValueFrom, isObservable } from "rxjs";
+import { TestBed } from "@angular/core/testing";
+import { InjectionToken, inject } from "@angular/core";
+import { join } from "node:path";
+const providerState = (name, params) => ({
+	name,
+	params
+});
+function givenStates(pact, states) {
+	return states.reduce((interaction, state) => interaction.given(state.name, state.params), pact.addInteraction());
+}
+const JSON_CONTENT_TYPE = { "Content-Type": "application/json" };
+async function verifyInteraction(interaction) {
+	const { request, response, run } = interaction;
+	const status = response.status ?? 200;
+	const body = response.body === void 0 ? void 0 : MatchersV3.reify(response.body);
+	const headers = request.headers ?? {};
+	await givenStates(interaction.pact, interaction.states ?? []).uponReceiving(interaction.description).withRequest(request.method, request.path, (builder) => {
+		if (Object.keys(headers).length) builder.headers(headers);
+		if (request.query) builder.query(request.query);
+		if (request.body !== void 0) builder.jsonBody(request.body);
+	}).willRespondWith(status, (builder) => {
+		if (response.body !== void 0) builder.headers(JSON_CONTENT_TYPE).jsonBody(response.body);
+	}).executeTest(async (mockServer) => {
+		const outcome = run(mockServer.url);
+		const result = isObservable(outcome) ? firstValueFrom(outcome) : Promise.resolve(outcome);
+		const check = interaction.expect ?? expectBody;
+		if (status >= 400) {
+			await expect(result).rejects.toBeInstanceOf(HttpErrorResponse);
+			const error = await result.catch((failure) => failure);
+			expect(error.status).toBe(status);
+			await check(interaction.expect ? error : error.error, body);
+		} else await check(await result, body);
+	});
+}
+const expectBody = (result, body) => {
+	if (body === void 0) expect([null, ""]).toContain(result);
+	else expect(result).toEqual(body);
+};
+const PACT_MOCK_SERVER_URL = new InjectionToken("PACT_MOCK_SERVER_URL");
+const PACT_AUTH_TOKEN = new InjectionToken("PACT_AUTH_TOKEN");
+const PACT_AUTH_HEADERS = new InjectionToken("PACT_AUTH_HEADERS");
+const DEFAULT_AUTH_SCHEME = "Token";
+const authorizationHeader = (token, scheme = DEFAULT_AUTH_SCHEME) => ({ Authorization: `${scheme} ${token}` });
+const pactAuthHeadersInterceptor = (request, next) => {
+	const headers = Object.entries(inject(PACT_AUTH_HEADERS)).filter(([name]) => !request.headers.has(name));
+	return next(headers.length ? request.clone({ setHeaders: Object.fromEntries(headers) }) : request);
+};
+function configurePactTestBed(mockServerUrl, providers = [], options = {}) {
+	const { token = null, authHeaders = {}, interceptors = [], interceptorClasses = [], httpClient } = options;
+	const authInterceptors = Object.keys(authHeaders).length ? [pactAuthHeadersInterceptor] : [];
+	if (httpClient && (authInterceptors.length || interceptors.length)) throw new Error("configurePactTestBed applies authHeaders and interceptors only to its default HttpClient providers; add them to the httpClient providers instead");
+	TestBed.configureTestingModule({ providers: [
+		httpClient ?? provideHttpClient(withInterceptorsFromDi(), withInterceptors([...authInterceptors, ...interceptors])),
+		{
+			provide: HttpBackend,
+			useExisting: HttpXhrBackend
+		},
+		...interceptorClasses.map((useClass) => ({
+			provide: HTTP_INTERCEPTORS,
+			useClass,
+			multi: true
+		})),
+		{
+			provide: PACT_MOCK_SERVER_URL,
+			useValue: mockServerUrl.replace(/\/+$/, "")
+		},
+		{
+			provide: PACT_AUTH_TOKEN,
+			useValue: token
+		},
+		{
+			provide: PACT_AUTH_HEADERS,
+			useValue: authHeaders
+		},
+		...providers
+	] });
+}
+function resolveResponse(suite, response) {
+	const { operationId, ...given } = response;
+	if (!operationId) return given;
+	if ("body" in given) throw new Error(`Contract response ${operationId} has a body: give either operationId or body`);
+	if ((given.status ?? 0) >= 400) throw new Error(`Contract response ${operationId} has status ${given.status}: operationId resolves the documented 2xx body, so give the error body instead`);
+	if (!suite.responseFor) throw new Error(`Contract response ${operationId} needs the suite's responseFor`);
+	const resolved = suite.responseFor(operationId);
+	return {
+		...resolved,
+		status: given.status ?? resolved.status
+	};
+}
+async function verifyServiceContract(suite, service, contract) {
+	const { request, options } = contract;
+	const response = resolveResponse(suite, contract.response);
+	const suiteHeaders = typeof suite.headers === "function" ? suite.headers(options) : suite.headers;
+	const configureTestBed = suite.configureTestBed ?? ((mockServerUrl, providers) => configurePactTestBed(mockServerUrl, providers));
+	await verifyInteraction({
+		pact: suite.pact,
+		description: contract.description,
+		states: [...contract.replaceGiven ? [] : suite.given ?? [], ...contract.given ?? []],
+		request: {
+			...request,
+			headers: {
+				...contract.replaceHeaders ? {} : suiteHeaders,
+				...request.headers
+			}
+		},
+		response,
+		expect: contract.expect,
+		run: (mockServerUrl) => {
+			configureTestBed(mockServerUrl, [service], options);
+			return contract.call(TestBed.inject(service));
+		}
+	});
+}
+function verifyServiceContracts(suite, service, contracts) {
+	for (const contract of contracts) it(`should ${contract.description}`, () => verifyServiceContract(suite, service, contract));
+}
+const ISO_DATETIME_PATTERN = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$";
+const ISO_DATE_PATTERN = "^\\d{4}-\\d{2}-\\d{2}$";
+const UUID_PATTERN = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+const URL_PATTERN = "^https?://\\S+$";
+const DIGITS_PATTERN = "^\\d+$";
+const EXAMPLE_DATETIME = "2026-10-01T09:30:00Z";
+const EXAMPLE_DATE = "2026-10-01";
+const EXAMPLE_UUID = "2f1e7f9a-3c5b-4d7e-9a1b-6c8d0e2f4a6b";
+const EXAMPLE_URL = "https://example.com/pact";
+const LISTED_KEYS = ["results"];
+const ROOT_PATH = "$";
+const { regex } = MatchersV3;
+const datetime = (example = EXAMPLE_DATETIME) => regex(ISO_DATETIME_PATTERN, example);
+const date = (example = EXAMPLE_DATE) => regex(ISO_DATE_PATTERN, example);
+const uuid = (example = EXAMPLE_UUID) => regex(UUID_PATTERN, example);
+const url = (example = EXAMPLE_URL) => regex(URL_PATTERN, example);
+const digits = (example) => regex(DIGITS_PATTERN, String(example));
+function shapeOf(example, minItems = 1) {
+	return shapeAt(example, minItems, "$");
+}
+function shapeAt(example, minItems, path) {
+	if (Array.isArray(example)) {
+		if (!example.length) throw new Error(`shapeOf cannot describe the items of the empty list at ${path}: give it an example item, or pass an explicit matcher for the list`);
+		const item = shapeAt(example[0], 0, `${path}[0]`);
+		return minItems ? MatchersV3.eachLike(item, minItems) : MatchersV3.atLeastLike(item, 0, 1);
+	}
+	if (example !== null && typeof example === "object") {
+		if (MatchersV3.isMatcher(example)) return example;
+		return Object.fromEntries(Object.entries(example).map(([key, value]) => [key, shapeAt(value, LISTED_KEYS.includes(key) ? 1 : 0, `${path}.${key}`)]));
+	}
+	if (typeof example === "number") return Number.isInteger(example) ? MatchersV3.integer(example) : MatchersV3.number(example);
+	if (typeof example === "string" && (/* @__PURE__ */ new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$")).test(example)) return datetime(example);
+	return MatchersV3.like(example);
+}
+const PACT_DIR_ENV = "PACT_DIR";
+const DEFAULT_PACT_DIR_NAME = "pacts";
+const DEFAULT_PACT_OPTIONS = {
+	spec: SpecificationVersion.SPECIFICATION_VERSION_V4,
+	logLevel: "warn",
+	cors: true
+};
+function createPact(consumer, provider, options = {}) {
+	return new PactV4({
+		...DEFAULT_PACT_OPTIONS,
+		...options,
+		dir: options.dir ?? (process.env["PACT_DIR"] || join(process.cwd(), "pacts")),
+		consumer,
+		provider
+	});
+}
+export { DEFAULT_AUTH_SCHEME, DEFAULT_PACT_DIR_NAME, DEFAULT_PACT_OPTIONS, DIGITS_PATTERN, EXAMPLE_DATE, EXAMPLE_DATETIME, EXAMPLE_URL, EXAMPLE_UUID, ISO_DATETIME_PATTERN, ISO_DATE_PATTERN, LISTED_KEYS, PACT_AUTH_HEADERS, PACT_AUTH_TOKEN, PACT_DIR_ENV, PACT_MOCK_SERVER_URL, ROOT_PATH, URL_PATTERN, UUID_PATTERN, authorizationHeader, configurePactTestBed, createPact, date, datetime, digits, givenStates, pactAuthHeadersInterceptor, providerState, shapeOf, url, uuid, verifyInteraction, verifyServiceContract, verifyServiceContracts };
+
+//# sourceMappingURL=testgorilla-tgo-pact.mjs.map

package/fesm2022/testgorilla-tgo-pact.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"testgorilla-tgo-pact.mjs","names":[],"sources":["../../../../packages/tgo-pact/src/lib/pact/provider-states.ts","../../../../packages/tgo-pact/src/lib/contracts/contracts.constants.ts","../../../../packages/tgo-pact/src/lib/contracts/verify-interaction.ts","../../../../packages/tgo-pact/src/lib/test-bed/pact-test-bed.constants.ts","../../../../packages/tgo-pact/src/lib/test-bed/configure-pact-test-bed.ts","../../../../packages/tgo-pact/src/lib/contracts/verify-service-contracts.ts","../../../../packages/tgo-pact/src/lib/matchers/matchers.constants.ts","../../../../packages/tgo-pact/src/lib/matchers/matchers.ts","../../../../packages/tgo-pact/src/lib/pact/pact.constants.ts","../../../../packages/tgo-pact/src/lib/pact/create-pact.ts"],"sourcesContent":["import type { PactV4 } from '@pact-foundation/pact';\nimport type { PactInteraction, ProviderState, ProviderStateParams } from './provider-states.model';\n\nexport const providerState = (name: string, params?: ProviderStateParams): ProviderState => ({\n  name,\n  params,\n});\n\n/** Starts an interaction with every state applied in order. */\nexport function givenStates(pact: PactV4, states: readonly ProviderState[]): PactInteraction {\n  return states.reduce<PactInteraction>(\n    (interaction, state) => interaction.given(state.name, state.params),\n    pact.addInteraction()\n  );\n}\n","export const JSON_CONTENT_TYPE = { 'Content-Type': 'application/json' };\nexport const MIN_ERROR_STATUS = 400;\n","import { HttpErrorResponse } from '@angular/common/http';\nimport { MatchersV3 } from '@pact-foundation/pact';\nimport { firstValueFrom, isObservable } from 'rxjs';\nimport { givenStates } from '../pact/provider-states';\nimport { JSON_CONTENT_TYPE, MIN_ERROR_STATUS } from './contracts.constants';\nimport type { ContractExpectation, InteractionContract } from './contracts.model';\n\n/**\n * The core of the contract runners: registers the interaction, runs the call against the mock server and checks\n * its outcome. A 2xx call must resolve to the reified response body, or to null/'' for an empty one. A 4xx/5xx call\n * must fail with an `HttpErrorResponse` of that status, whose `error` equals the reified body, or is null/'' for an\n * empty one. `interaction.expect` replaces the body check.\n */\nexport async function verifyInteraction(interaction: InteractionContract): Promise<void> {\n  const { request, response, run } = interaction;\n  const status = response.status ?? 200;\n  const body = response.body === undefined ? undefined : MatchersV3.reify(response.body);\n  const headers = request.headers ?? {};\n\n  await givenStates(interaction.pact, interaction.states ?? [])\n    .uponReceiving(interaction.description)\n    .withRequest(request.method, request.path, builder => {\n      if (Object.keys(headers).length) {\n        builder.headers(headers);\n      }\n      if (request.query) {\n        builder.query(request.query);\n      }\n      if (request.body !== undefined) {\n        builder.jsonBody(request.body);\n      }\n    })\n    .willRespondWith(status, builder => {\n      if (response.body !== undefined) {\n        builder.headers(JSON_CONTENT_TYPE).jsonBody(response.body);\n      }\n    })\n    .executeTest(async mockServer => {\n      const outcome = run(mockServer.url);\n      const result = isObservable(outcome) ? firstValueFrom(outcome) : Promise.resolve(outcome);\n      const check = interaction.expect ?? expectBody;\n\n      if (status >= MIN_ERROR_STATUS) {\n        await expect(result).rejects.toBeInstanceOf(HttpErrorResponse);\n        const error = (await result.catch((failure: unknown) => failure)) as HttpErrorResponse;\n        expect(error.status).toBe(status);\n        await check(interaction.expect ? error : error.error, body);\n      } else {\n        await check(await result, body);\n      }\n    });\n}\n\nconst expectBody: ContractExpectation = (result, body) => {\n  if (body === undefined) {\n    // An empty body reaches JSON clients as null and text clients as ''.\n    expect([null, '']).toContain(result);\n  } else {\n    expect(result).toEqual(body);\n  }\n};\n","import { InjectionToken } from '@angular/core';\n\n/** Base URL of the Pact mock server, without a trailing slash. Build the app's API base URL from it. */\nexport const PACT_MOCK_SERVER_URL = new InjectionToken<string>('PACT_MOCK_SERVER_URL');\n\n/** Token the provider state creates, or null for anonymous calls. */\nexport const PACT_AUTH_TOKEN = new InjectionToken<string | null>('PACT_AUTH_TOKEN');\n\nexport const PACT_AUTH_HEADERS = new InjectionToken<Record<string, string>>('PACT_AUTH_HEADERS');\n\nexport const DEFAULT_AUTH_SCHEME = 'Token';\n","import {\n  HTTP_INTERCEPTORS,\n  HttpBackend,\n  HttpInterceptorFn,\n  HttpXhrBackend,\n  provideHttpClient,\n  withInterceptors,\n  withInterceptorsFromDi,\n} from '@angular/common/http';\nimport { inject, Provider } from '@angular/core';\nimport { TestBed } from '@angular/core/testing';\nimport {\n  DEFAULT_AUTH_SCHEME,\n  PACT_AUTH_HEADERS,\n  PACT_AUTH_TOKEN,\n  PACT_MOCK_SERVER_URL,\n} from './pact-test-bed.constants';\nimport type { PactTestBedOptions } from './pact-test-bed.model';\n\n/** `{ Authorization: '<scheme> <token>' }`, the header DRF token auth expects. */\nexport const authorizationHeader = (token: string, scheme: string = DEFAULT_AUTH_SCHEME) => ({\n  Authorization: `${scheme} ${token}`,\n});\n\n/** Adds `PactTestBedOptions.authHeaders` to every request that does not set them itself. */\nexport const pactAuthHeadersInterceptor: HttpInterceptorFn = (request, next) => {\n  const headers = Object.entries(inject(PACT_AUTH_HEADERS)).filter(\n    ([name]) => !request.headers.has(name)\n  );\n  return next(\n    headers.length ? request.clone({ setHeaders: Object.fromEntries(headers) }) : request\n  );\n};\n\n/**\n * Configures TestBed with HttpClient for a Pact interaction: the mock server URL and auth token are provided as\n * `PACT_MOCK_SERVER_URL` and `PACT_AUTH_TOKEN`, for the app's config and auth stubs in `providers` to read.\n * Requests go through `HttpXhrBackend`, which jsdom supports. Call it inside `executeTest`, once the mock server URL\n * is known. With `options.httpClient`, `authHeaders` and `interceptors` throw, and `interceptorClasses` apply only if\n * those providers include `withInterceptorsFromDi()`.\n */\nexport function configurePactTestBed(\n  mockServerUrl: string,\n  providers: Provider[] = [],\n  options: PactTestBedOptions = {}\n): void {\n  const {\n    token = null,\n    authHeaders = {},\n    interceptors = [],\n    interceptorClasses = [],\n    httpClient,\n  } = options;\n  const authInterceptors = Object.keys(authHeaders).length ? [pactAuthHeadersInterceptor] : [];\n  if (httpClient && (authInterceptors.length || interceptors.length)) {\n    throw new Error(\n      'configurePactTestBed applies authHeaders and interceptors only to its default HttpClient providers; add them to the httpClient providers instead'\n    );\n  }\n\n  TestBed.configureTestingModule({\n    providers: [\n      httpClient ??\n        provideHttpClient(\n          withInterceptorsFromDi(),\n          withInterceptors([...authInterceptors, ...interceptors])\n        ),\n      // jsdom has no fetch, and Angular 22 defaults HttpClient to it. withXhr() does not exist in Angular 21.\n      { provide: HttpBackend, useExisting: HttpXhrBackend },\n      ...interceptorClasses.map(useClass => ({\n        provide: HTTP_INTERCEPTORS,\n        useClass,\n        multi: true,\n      })),\n      { provide: PACT_MOCK_SERVER_URL, useValue: mockServerUrl.replace(/\\/+$/, '') },\n      { provide: PACT_AUTH_TOKEN, useValue: token },\n      { provide: PACT_AUTH_HEADERS, useValue: authHeaders },\n      ...providers,\n    ],\n  });\n}\n","import type { Provider, Type } from '@angular/core';\nimport { TestBed } from '@angular/core/testing';\nimport { configurePactTestBed } from '../test-bed/configure-pact-test-bed';\nimport { MIN_ERROR_STATUS } from './contracts.constants';\nimport type { ContractResponse, ContractSuite, ServiceContract } from './contracts.model';\nimport { verifyInteraction } from './verify-interaction';\n\nfunction resolveResponse<O>(\n  suite: ContractSuite<O>,\n  response: ServiceContract<unknown, O>['response']\n): ContractResponse {\n  const { operationId, ...given } = response;\n  if (!operationId) {\n    return given;\n  }\n  if ('body' in given) {\n    throw new Error(`Contract response ${operationId} has a body: give either operationId or body`);\n  }\n  if ((given.status ?? 0) >= MIN_ERROR_STATUS) {\n    throw new Error(\n      `Contract response ${operationId} has status ${given.status}: operationId resolves the documented 2xx body, so give the error body instead`\n    );\n  }\n  if (!suite.responseFor) {\n    throw new Error(`Contract response ${operationId} needs the suite's responseFor`);\n  }\n  const resolved = suite.responseFor(operationId);\n  return { ...resolved, status: given.status ?? resolved.status };\n}\n\n/**\n * Runs one contract through `verifyInteraction`: the suite's states and headers, then the contract's, unless it\n * replaces them. The call is made on the service from TestBed, configured by the suite.\n */\nexport async function verifyServiceContract<S, O = undefined>(\n  suite: ContractSuite<O>,\n  service: Type<S>,\n  contract: ServiceContract<S, O>\n): Promise<void> {\n  const { request, options } = contract;\n  const response = resolveResponse(suite, contract.response);\n  const suiteHeaders = typeof suite.headers === 'function' ? suite.headers(options) : suite.headers;\n  const configureTestBed =\n    suite.configureTestBed ??\n    ((mockServerUrl: string, providers: Provider[]) =>\n      configurePactTestBed(mockServerUrl, providers));\n\n  await verifyInteraction({\n    pact: suite.pact,\n    description: contract.description,\n    states: [...(contract.replaceGiven ? [] : (suite.given ?? [])), ...(contract.given ?? [])],\n    request: {\n      ...request,\n      headers: { ...(contract.replaceHeaders ? {} : suiteHeaders), ...request.headers },\n    },\n    response,\n    expect: contract.expect,\n    run: mockServerUrl => {\n      configureTestBed(mockServerUrl, [service], options);\n      return contract.call(TestBed.inject(service));\n    },\n  });\n}\n\n/** Declares one `it` per contract, driving a service method against the suite's mock server. */\nexport function verifyServiceContracts<S, O = undefined>(\n  suite: ContractSuite<O>,\n  service: Type<S>,\n  contracts: ServiceContract<S, O>[]\n): void {\n  for (const contract of contracts) {\n    it(`should ${contract.description}`, () => verifyServiceContract(suite, service, contract));\n  }\n}\n","export const ISO_DATETIME_PATTERN =\n  '^\\\\d{4}-\\\\d{2}-\\\\d{2}T\\\\d{2}:\\\\d{2}:\\\\d{2}(\\\\.\\\\d+)?(Z|[+-]\\\\d{2}:\\\\d{2})$';\nexport const ISO_DATE_PATTERN = '^\\\\d{4}-\\\\d{2}-\\\\d{2}$';\nexport const UUID_PATTERN = '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$';\nexport const URL_PATTERN = '^https?://\\\\S+$';\nexport const DIGITS_PATTERN = '^\\\\d+$';\n\nexport const EXAMPLE_DATETIME = '2026-10-01T09:30:00Z';\nexport const EXAMPLE_DATE = '2026-10-01';\nexport const EXAMPLE_UUID = '2f1e7f9a-3c5b-4d7e-9a1b-6c8d0e2f4a6b';\nexport const EXAMPLE_URL = 'https://example.com/pact';\n\n/** Keys whose lists `shapeOf` requires at least one item in, at any depth: paginated `results`. */\nexport const LISTED_KEYS: readonly string[] = ['results'];\n\n/** How `shapeOf` names the example itself in errors, e.g. `$.results[0].tags`. */\nexport const ROOT_PATH = '$';\n","import { MatchersV3 } from '@pact-foundation/pact';\nimport {\n  DIGITS_PATTERN,\n  EXAMPLE_DATE,\n  EXAMPLE_DATETIME,\n  EXAMPLE_URL,\n  EXAMPLE_UUID,\n  ISO_DATE_PATTERN,\n  ISO_DATETIME_PATTERN,\n  LISTED_KEYS,\n  ROOT_PATH,\n  URL_PATTERN,\n  UUID_PATTERN,\n} from './matchers.constants';\n\nconst { regex } = MatchersV3;\n\n/** ISO-8601 datetime, as DRF renders datetimes. */\nexport const datetime = (example: string = EXAMPLE_DATETIME) =>\n  regex(ISO_DATETIME_PATTERN, example);\n\n/** ISO-8601 date. */\nexport const date = (example: string = EXAMPLE_DATE) => regex(ISO_DATE_PATTERN, example);\n\n/** Lowercase canonical UUID. */\nexport const uuid = (example: string = EXAMPLE_UUID) => regex(UUID_PATTERN, example);\n\n/** Absolute http(s) URL, e.g. presigned S3 URLs. */\nexport const url = (example: string = EXAMPLE_URL) => regex(URL_PATTERN, example);\n\n/** A string of digits, e.g. an id sent as a string. */\nexport const digits = (example: number | string) => regex(DIGITS_PATTERN, String(example));\n\n/**\n * Turns an example the app's model describes into type matchers. Leave nullable fields out: the app copes with null,\n * so the contract should not pin their type. Top-level lists need `minItems` items (default 1); nested lists may be\n * empty, except `results`. Every list needs an item in the example to describe the items' shape, so an empty one\n * throws. ISO datetimes match the datetime pattern, and matchers pass through unchanged.\n *\n * A whole-number example becomes an `integer` matcher, so `{ price: 10 }` rejects `10.5`. Other numbers match any\n * number. To accept decimals for a field whose example is whole, pass the matcher yourself:\n * `{ price: MatchersV3.decimal(10) }` or `MatchersV3.number(10)`.\n */\nexport function shapeOf(example: unknown, minItems = 1): unknown {\n  return shapeAt(example, minItems, ROOT_PATH);\n}\n\nfunction shapeAt(example: unknown, minItems: number, path: string): unknown {\n  if (Array.isArray(example)) {\n    if (!example.length) {\n      throw new Error(\n        `shapeOf cannot describe the items of the empty list at ${path}: give it an example item, or pass an explicit matcher for the list`\n      );\n    }\n    const item = shapeAt(example[0], 0, `${path}[0]`);\n    return minItems ? MatchersV3.eachLike(item, minItems) : MatchersV3.atLeastLike(item, 0, 1);\n  }\n  if (example !== null && typeof example === 'object') {\n    if (MatchersV3.isMatcher(example)) {\n      return example;\n    }\n    return Object.fromEntries(\n      Object.entries(example).map(([key, value]) => [\n        key,\n        shapeAt(value, LISTED_KEYS.includes(key) ? 1 : 0, `${path}.${key}`),\n      ])\n    );\n  }\n  if (typeof example === 'number') {\n    return Number.isInteger(example) ? MatchersV3.integer(example) : MatchersV3.number(example);\n  }\n  if (typeof example === 'string' && new RegExp(ISO_DATETIME_PATTERN).test(example)) {\n    return datetime(example);\n  }\n  return MatchersV3.like(example);\n}\n","import { SpecificationVersion } from '@pact-foundation/pact';\nimport type { CreatePactOptions } from './pact.model';\n\nexport const PACT_DIR_ENV = 'PACT_DIR';\nexport const DEFAULT_PACT_DIR_NAME = 'pacts';\n\nexport const DEFAULT_PACT_OPTIONS = {\n  spec: SpecificationVersion.SPECIFICATION_VERSION_V4,\n  logLevel: 'warn',\n  // jsdom's XMLHttpRequest enforces CORS, and the mock server runs on another origin.\n  cors: true,\n} as const satisfies CreatePactOptions;\n","import { join } from 'node:path';\nimport { PactV4 } from '@pact-foundation/pact';\nimport { DEFAULT_PACT_DIR_NAME, DEFAULT_PACT_OPTIONS, PACT_DIR_ENV } from './pact.constants';\nimport type { CreatePactOptions } from './pact.model';\n\n/**\n * Creates a V4 pact between `consumer` and `provider`. The pact file goes to `options.dir`, else `$PACT_DIR`,\n * else `<cwd>/pacts`. Specs of one consumer-provider pair merge into the same file, so run them in band.\n */\nexport function createPact(\n  consumer: string,\n  provider: string,\n  options: CreatePactOptions = {}\n): PactV4 {\n  return new PactV4({\n    ...DEFAULT_PACT_OPTIONS,\n    ...options,\n    dir: options.dir ?? (process.env[PACT_DIR_ENV] || join(process.cwd(), DEFAULT_PACT_DIR_NAME)),\n    consumer,\n    provider,\n  });\n}\n"],"mappings":";;;;;;AAGA,MAAa,iBAAiB,MAAc,YAAiD;CAC3F;CACA;AACD;AAGD,SAAgB,YAAY,MAAc,QAAgC;CACxE,OAAO,OAAO,QACX,aAAa,UAAU,YAAY,MAAM,MAAM,MAAM,MAAM,MAAM,GAClE,KAAK,eAAc,CAAE;AAEzB;ACdA,MAAa,oBAAoB,EAAE,gBAAgB,mBAAkB;ACarE,eAAsB,kBAAkB,aAAgC;CACtE,MAAM,EAAE,SAAS,UAAU,QAAQ;CACnC,MAAM,SAAS,SAAS,UAAU;CAClC,MAAM,OAAO,SAAS,SAAS,SAAY,SAAY,WAAW,MAAM,SAAS,IAAI;CACrF,MAAM,UAAU,QAAQ,WAAW,CAAA;CAEnC,MAAM,YAAY,YAAY,MAAM,YAAY,UAAU,CAAA,CAAE,CAAC,CAC1D,cAAc,YAAY,WAAW,CAAC,CACtC,YAAY,QAAQ,QAAQ,QAAQ,OAAM,YAAU;EACnD,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,QACvB,QAAQ,QAAQ,OAAO;EAEzB,IAAI,QAAQ,OACV,QAAQ,MAAM,QAAQ,KAAK;EAE7B,IAAI,QAAQ,SAAS,QACnB,QAAQ,SAAS,QAAQ,IAAI;CAEjC,CAAC,CAAC,CACD,gBAAgB,SAAQ,YAAU;EACjC,IAAI,SAAS,SAAS,QACpB,QAAQ,QAAQ,iBAAiB,CAAC,CAAC,SAAS,SAAS,IAAI;CAE7D,CAAC,CAAC,CACD,YAAY,OAAM,eAAa;EAC9B,MAAM,UAAU,IAAI,WAAW,GAAG;EAClC,MAAM,SAAS,aAAa,OAAO,IAAI,eAAe,OAAO,IAAI,QAAQ,QAAQ,OAAO;EACxF,MAAM,QAAQ,YAAY,UAAU;EAEpC,IAAI,UAAA,KAA4B;GAC9B,MAAM,OAAO,MAAM,CAAC,CAAC,QAAQ,eAAe,iBAAiB;GAC7D,MAAM,QAAS,MAAM,OAAO,OAAO,YAAqB,OAAO;GAC/D,OAAO,MAAM,MAAM,CAAC,CAAC,KAAK,MAAM;GAChC,MAAM,MAAM,YAAY,SAAS,QAAQ,MAAM,OAAO,IAAI;EAC5D,OACE,MAAM,MAAM,MAAM,QAAQ,IAAI;CAElC,CAAC;AACL;AAEA,MAAM,cAAmC,QAAQ,SAAQ;CACvD,IAAI,SAAS,QAEX,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,UAAU,MAAM;MAEnC,OAAO,MAAM,CAAC,CAAC,QAAQ,IAAI;AAE/B;ACzDA,MAAa,uBAAuB,IAAI,eAAuB,sBAAsB;AAGrF,MAAa,kBAAkB,IAAI,eAA8B,iBAAiB;AAElF,MAAa,oBAAoB,IAAI,eAAuC,mBAAmB;AAE/F,MAAa,sBAAsB;ACUnC,MAAa,uBAAuB,OAAe,SAAiB,yBAAyB,EAC3F,eAAe,GAAG,OAAM,GAAI,QAC7B;AAGD,MAAa,8BAAiD,SAAS,SAAQ;CAC7E,MAAM,UAAU,OAAO,QAAQ,OAAO,iBAAiB,CAAC,CAAC,CAAC,QACvD,CAAC,UAAU,CAAC,QAAQ,QAAQ,IAAI,IAAI,CAAC;CAExC,OAAO,KACL,QAAQ,SAAS,QAAQ,MAAM,EAAE,YAAY,OAAO,YAAY,OAAO,EAAC,CAAE,IAAI,OAAO;AAEzF;AASA,SAAgB,qBACd,eACA,YAAwB,CAAA,GACxB,UAA8B,CAAA,GAAE;CAEhC,MAAM,EACJ,QAAQ,MACR,cAAc,CAAA,GACd,eAAe,CAAA,GACf,qBAAqB,CAAA,GACrB,eACE;CACJ,MAAM,mBAAmB,OAAO,KAAK,WAAW,CAAC,CAAC,SAAS,CAAC,0BAA0B,IAAI,CAAA;CAC1F,IAAI,eAAe,iBAAiB,UAAU,aAAa,SACzD,MAAM,IAAI,MACR,kJAAkJ;CAItJ,QAAQ,uBAAuB,EAC7B,WAAW;EACT,cACE,kBACE,uBAAsB,GACtB,iBAAiB,CAAC,GAAG,kBAAkB,GAAG,YAAY,CAAC,CAAC;EAG5D;GAAE,SAAS;GAAa,aAAa;EAAc;EACnD,GAAG,mBAAmB,KAAI,cAAa;GACrC,SAAS;GACT;GACA,OAAO;EACR,EAAC;EACF;GAAE,SAAS;GAAsB,UAAU,cAAc,QAAQ,QAAQ,EAAE;EAAC;EAC5E;GAAE,SAAS;GAAiB,UAAU;EAAK;EAC3C;GAAE,SAAS;GAAmB,UAAU;EAAW;EACnD,GAAG;CACJ,EACF,CAAA;AACH;ACzEA,SAAS,gBACP,OACA,UAAiD;CAEjD,MAAM,EAAE,aAAa,GAAG,UAAU;CAClC,IAAI,CAAC,aACH,OAAO;CAET,IAAI,UAAU,OACZ,MAAM,IAAI,MAAM,qBAAqB,YAAW,6CAA8C;CAEhG,KAAK,MAAM,UAAU,MAAA,KACnB,MAAM,IAAI,MACR,qBAAqB,YAAW,cAAe,MAAM,OAAM,+EAAgF;CAG/I,IAAI,CAAC,MAAM,aACT,MAAM,IAAI,MAAM,qBAAqB,YAAW,+BAAgC;CAElF,MAAM,WAAW,MAAM,YAAY,WAAW;CAC9C,OAAO;EAAE,GAAG;EAAU,QAAQ,MAAM,UAAU,SAAS;CAAM;AAC/D;AAMA,eAAsB,sBACpB,OACA,SACA,UAA+B;CAE/B,MAAM,EAAE,SAAS,YAAY;CAC7B,MAAM,WAAW,gBAAgB,OAAO,SAAS,QAAQ;CACzD,MAAM,eAAe,OAAO,MAAM,YAAY,aAAa,MAAM,QAAQ,OAAO,IAAI,MAAM;CAC1F,MAAM,mBACJ,MAAM,sBACJ,eAAuB,cACvB,qBAAqB,eAAe,SAAS;CAEjD,MAAM,kBAAkB;EACtB,MAAM,MAAM;EACZ,aAAa,SAAS;EACtB,QAAQ,CAAC,GAAI,SAAS,eAAe,CAAA,IAAM,MAAM,SAAS,CAAA,GAAM,GAAI,SAAS,SAAS,CAAA,CAAG;EACzF,SAAS;GACP,GAAG;GACH,SAAS;IAAE,GAAI,SAAS,iBAAiB,CAAA,IAAK;IAAe,GAAG,QAAQ;GAAO;EAChF;EACD;EACA,QAAQ,SAAS;EACjB,MAAK,kBAAgB;GACnB,iBAAiB,eAAe,CAAC,OAAO,GAAG,OAAO;GAClD,OAAO,SAAS,KAAK,QAAQ,OAAO,OAAO,CAAC;EAC9C;CACD,CAAA;AACH;AAGA,SAAgB,uBACd,OACA,SACA,WAAkC;CAElC,KAAK,MAAM,YAAY,WACrB,GAAG,UAAU,SAAS,qBAAqB,sBAAsB,OAAO,SAAS,QAAQ,CAAC;AAE9F;ACzEA,MAAa,uBACX;AACF,MAAa,mBAAmB;AAChC,MAAa,eAAe;AAC5B,MAAa,cAAc;AAC3B,MAAa,iBAAiB;AAE9B,MAAa,mBAAmB;AAChC,MAAa,eAAe;AAC5B,MAAa,eAAe;AAC5B,MAAa,cAAc;AAG3B,MAAa,cAAiC,CAAC,SAAS;AAGxD,MAAa,YAAY;ACDzB,MAAM,EAAE,UAAU;AAGlB,MAAa,YAAY,UAAkB,qBACzC,MAAM,sBAAsB,OAAO;AAGrC,MAAa,QAAQ,UAAkB,iBAAiB,MAAM,kBAAkB,OAAO;AAGvF,MAAa,QAAQ,UAAkB,iBAAiB,MAAM,cAAc,OAAO;AAGnF,MAAa,OAAO,UAAkB,gBAAgB,MAAM,aAAa,OAAO;AAGhF,MAAa,UAAU,YAA6B,MAAM,gBAAgB,OAAO,OAAO,CAAC;AAYzF,SAAgB,QAAQ,SAAkB,WAAW,GAAC;CACpD,OAAO,QAAQ,SAAS,UAAA,GAAmB;AAC7C;AAEA,SAAS,QAAQ,SAAkB,UAAkB,MAAY;CAC/D,IAAI,MAAM,QAAQ,OAAO,GAAG;EAC1B,IAAI,CAAC,QAAQ,QACX,MAAM,IAAI,MACR,0DAA0D,KAAI,oEAAqE;EAGvI,MAAM,OAAO,QAAQ,QAAQ,IAAI,GAAG,GAAG,KAAI,IAAK;EAChD,OAAO,WAAW,WAAW,SAAS,MAAM,QAAQ,IAAI,WAAW,YAAY,MAAM,GAAG,CAAC;CAC3F;CACA,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;EACnD,IAAI,WAAW,UAAU,OAAO,GAC9B,OAAO;EAET,OAAO,OAAO,YACZ,OAAO,QAAQ,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC5C,KACA,QAAQ,OAAO,YAAY,SAAS,GAAG,IAAI,IAAI,GAAG,GAAG,KAAI,GAAI,KAAK,CACnE,CAAA,CAAC;CAEN;CACA,IAAI,OAAO,YAAY,UACrB,OAAO,OAAO,UAAU,OAAO,IAAI,WAAW,QAAQ,OAAO,IAAI,WAAW,OAAO,OAAO;CAE5F,IAAI,OAAO,YAAY,6BAAY,IAAI,OAAA,4EAA2B,EAAC,CAAC,KAAK,OAAO,GAC9E,OAAO,SAAS,OAAO;CAEzB,OAAO,WAAW,KAAK,OAAO;AAChC;ACxEA,MAAa,eAAe;AAC5B,MAAa,wBAAwB;AAErC,MAAa,uBAAuB;CAClC,MAAM,qBAAqB;CAC3B,UAAU;CAEV,MAAM;AAC8B;ACFtC,SAAgB,WACd,UACA,UACA,UAA6B,CAAA,GAAE;CAE/B,OAAO,IAAI,OAAO;EAChB,GAAG;EACH,GAAG;EACH,KAAK,QAAQ,QAAQ,QAAQ,IAAA,eAAqB,KAAK,QAAQ,IAAG,GAAA,OAAyB;EAC3F;EACA;CACD,CAAA;AACH"}

package/package.json

@@ -1,5 +1,41 @@
 {
   "name": "@testgorilla/tgo-pact",
-  "version": "0.0.0",
-  "description": "Placeholder; the real package is published from TestGorilla-BV/tgo-fe-libraries CI."
+  "version": "1.0.0-rc.0",
+  "peerDependencies": {
+    "@angular/common": ">=21.0.0 <23.0.0",
+    "@angular/core": ">=21.0.0 <23.0.0",
+    "@pact-foundation/pact": "^17.0.0",
+    "jest": "^30.0.0",
+    "rxjs": "^7.8.0"
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "sideEffects": false,
+  "license": "PROPRIETARY",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "displayName": "Pact",
+  "description": "Pact consumer test helpers for Angular apps: V4 pacts, a TestBed wired to the mock server, matchers and a Jest config",
+  "module": "fesm2022/testgorilla-tgo-pact.mjs",
+  "typings": "types/testgorilla-tgo-pact.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/testgorilla-tgo-pact.d.ts",
+      "default": "./fesm2022/testgorilla-tgo-pact.mjs"
+    },
+    "./jest": {
+      "types": "./types/testgorilla-tgo-pact-jest.d.ts",
+      "default": "./fesm2022/testgorilla-tgo-pact-jest.mjs"
+    }
+  },
+  "type": "module",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
 }

package/types/testgorilla-tgo-pact-jest.d.ts

@@ -0,0 +1,16 @@
+import { Config } from "jest";
+/**
+ * Turns the app's unit Jest config into one for Pact consumer specs: `*.pact.spec.ts` only, in band, a 30s timeout
+ * and no coverage. Everything else (preset, transforms, module mapping, setup files, the other ignore patterns) comes
+ * from `base`, minus `testRegex` and `projects` and the ignore patterns that would skip pact specs. `displayName`
+ * defaults to `pact` when `base` has none. `overrides` apply last, over both.
+ */
+export declare function createPactJestConfig(base?: Config, overrides?: Config): Config;
+export declare const PACT_TEST_MATCH: string[];
+export declare const PACT_TEST_TIMEOUT = 30000;
+export declare const PACT_DISPLAY_NAME = "pact";
+/** Used when the base config sets no `testPathIgnorePatterns`; Jest's own default. */
+export declare const DEFAULT_TEST_PATH_IGNORE_PATTERNS: string[];
+/** A pact spec's path, for finding the base config's ignore patterns that would skip pact specs. */
+export declare const PACT_SPEC_EXAMPLE_PATH = "/src/app/example.pact.spec.ts";
+export declare const PACT_JEST_DEFAULTS: Readonly<Config>;

package/types/testgorilla-tgo-pact.d.ts

@@ -0,0 +1,182 @@
+import { EnvironmentProviders, InjectionToken, Provider, Type } from "@angular/core";
+import { MatchersV3, PactV4, SpecificationVersion, TemplateHeaders, TemplateQuery } from "@pact-foundation/pact";
+import { Observable } from "rxjs";
+import { HttpInterceptor, HttpInterceptorFn } from "@angular/common/http";
+export type PactInteraction = ReturnType<PactV4['addInteraction']>;
+export type ProviderStateParams = Parameters<PactInteraction['given']>[1];
+export interface ProviderState {
+  name: string;
+  params?: ProviderStateParams;
+}
+export interface ContractResponse {
+  status?: number;
+  /** A body or matchers. Leave out for an empty response, which the call must resolve to null or ''. */
+  body?: unknown;
+}
+export interface ContractRequest {
+  method: string;
+  path: string;
+  query?: TemplateQuery;
+  /** In a `ServiceContract`, merged over the suite's headers. */
+  headers?: TemplateHeaders;
+  body?: unknown;
+}
+/**
+ * Replaces the default check of the call's outcome against the response body. `result` is what a 2xx call resolved
+ * to, or the `HttpErrorResponse` of a 4xx/5xx one, whose status is still checked. `body` is the reified response
+ * body, undefined for an empty response.
+ */
+export type ContractExpectation = (result: unknown, body: unknown) => void | Promise<void>;
+/** One interaction, and how to make the app send its request: the input of `verifyInteraction`. */
+export interface InteractionContract {
+  pact: PactV4;
+  /** The interaction description. */
+  description: string;
+  states?: readonly ProviderState[];
+  /** The expected request, with every header it must carry. */
+  request: ContractRequest;
+  response: ContractResponse;
+  /** Configures TestBed for the mock server and makes the call, returning its result. */
+  run: (mockServerUrl: string) => Observable<unknown> | Promise<unknown>;
+  expect?: ContractExpectation;
+}
+/**
+ * One interaction of a service method. `O` is whatever per-contract context the suite needs, e.g.
+ * `{ asTestTaker: boolean }`, passed to the suite's `headers` and `configureTestBed`.
+ */
+export interface ServiceContract<S, O = undefined> {
+  /** Becomes the interaction description and the test name, `should <description>`. */
+  description: string;
+  /** States after the suite's own. */
+  given?: ProviderState[];
+  /** Applies `given` without the suite's states, e.g. for an anonymous call. */
+  replaceGiven?: boolean;
+  request: ContractRequest;
+  /** Expects `request.headers` without the suite's headers, e.g. for an anonymous call. */
+  replaceHeaders?: boolean;
+  call: (service: S) => Observable<unknown>;
+  /**
+   * A response, or the id of an operation the suite's `responseFor` resolves to its documented 2xx response. Not
+   * both: an `operationId` takes no `body`, nor a 4xx/5xx `status`.
+   */
+  response: ContractResponse & {
+    operationId?: string;
+  };
+  /** Replaces the default check, e.g. for a method that hands back only part of the body. */
+  expect?: ContractExpectation;
+  options?: O;
+}
+export interface ContractSuite<O = undefined> {
+  /** One pact per spec file: each gets its own mock server. */
+  pact: PactV4;
+  /** States every interaction needs, applied before the contract's own. */
+  given?: ProviderState[];
+  /** Headers every request carries, e.g. `authorizationHeader(token)`. */
+  headers?: TemplateHeaders | ((options: O | undefined) => TemplateHeaders);
+  /** Defaults to `configurePactTestBed(mockServerUrl, providers)`. */
+  configureTestBed?: (mockServerUrl: string, providers: Provider[], options: O | undefined) => void;
+  /** Resolves `response.operationId`, e.g. from an OpenAPI document. */
+  responseFor?: (operationId: string) => ContractResponse;
+}
+/**
+ * The core of the contract runners: registers the interaction, runs the call against the mock server and checks
+ * its outcome. A 2xx call must resolve to the reified response body, or to null/'' for an empty one. A 4xx/5xx call
+ * must fail with an `HttpErrorResponse` of that status, whose `error` equals the reified body, or is null/'' for an
+ * empty one. `interaction.expect` replaces the body check.
+ */
+export declare function verifyInteraction(interaction: InteractionContract): Promise<void>;
+/**
+ * Runs one contract through `verifyInteraction`: the suite's states and headers, then the contract's, unless it
+ * replaces them. The call is made on the service from TestBed, configured by the suite.
+ */
+export declare function verifyServiceContract<S, O = undefined>(suite: ContractSuite<O>, service: Type<S>, contract: ServiceContract<S, O>): Promise<void>;
+/** Declares one `it` per contract, driving a service method against the suite's mock server. */
+export declare function verifyServiceContracts<S, O = undefined>(suite: ContractSuite<O>, service: Type<S>, contracts: ServiceContract<S, O>[]): void;
+/** ISO-8601 datetime, as DRF renders datetimes. */
+export declare const datetime: (example?: string) => MatchersV3.V3RegexMatcher;
+/** ISO-8601 date. */
+export declare const date: (example?: string) => MatchersV3.V3RegexMatcher;
+/** Lowercase canonical UUID. */
+export declare const uuid: (example?: string) => MatchersV3.V3RegexMatcher;
+/** Absolute http(s) URL, e.g. presigned S3 URLs. */
+export declare const url: (example?: string) => MatchersV3.V3RegexMatcher;
+/** A string of digits, e.g. an id sent as a string. */
+export declare const digits: (example: number | string) => MatchersV3.V3RegexMatcher;
+/**
+ * Turns an example the app's model describes into type matchers. Leave nullable fields out: the app copes with null,
+ * so the contract should not pin their type. Top-level lists need `minItems` items (default 1); nested lists may be
+ * empty, except `results`. Every list needs an item in the example to describe the items' shape, so an empty one
+ * throws. ISO datetimes match the datetime pattern, and matchers pass through unchanged.
+ *
+ * A whole-number example becomes an `integer` matcher, so `{ price: 10 }` rejects `10.5`. Other numbers match any
+ * number. To accept decimals for a field whose example is whole, pass the matcher yourself:
+ * `{ price: MatchersV3.decimal(10) }` or `MatchersV3.number(10)`.
+ */
+export declare function shapeOf(example: unknown, minItems?: number): unknown;
+export declare const ISO_DATETIME_PATTERN = "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$";
+export declare const ISO_DATE_PATTERN = "^\\d{4}-\\d{2}-\\d{2}$";
+export declare const UUID_PATTERN = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+export declare const URL_PATTERN = "^https?://\\S+$";
+export declare const DIGITS_PATTERN = "^\\d+$";
+export declare const EXAMPLE_DATETIME = "2026-10-01T09:30:00Z";
+export declare const EXAMPLE_DATE = "2026-10-01";
+export declare const EXAMPLE_UUID = "2f1e7f9a-3c5b-4d7e-9a1b-6c8d0e2f4a6b";
+export declare const EXAMPLE_URL = "https://example.com/pact";
+/** Keys whose lists `shapeOf` requires at least one item in, at any depth: paginated `results`. */
+export declare const LISTED_KEYS: readonly string[];
+/** How `shapeOf` names the example itself in errors, e.g. `$.results[0].tags`. */
+export declare const ROOT_PATH = "$";
+export type PactV4Options = ConstructorParameters<typeof PactV4>[0];
+/** Everything `PactV4` accepts except the consumer and provider, which `createPact` takes as arguments. */
+export type CreatePactOptions = Partial<Omit<PactV4Options, 'consumer' | 'provider'>>;
+/**
+ * Creates a V4 pact between `consumer` and `provider`. The pact file goes to `options.dir`, else `$PACT_DIR`,
+ * else `<cwd>/pacts`. Specs of one consumer-provider pair merge into the same file, so run them in band.
+ */
+export declare function createPact(consumer: string, provider: string, options?: CreatePactOptions): PactV4;
+export declare const PACT_DIR_ENV = "PACT_DIR";
+export declare const DEFAULT_PACT_DIR_NAME = "pacts";
+export declare const DEFAULT_PACT_OPTIONS: {
+  readonly spec: SpecificationVersion.SPECIFICATION_VERSION_V4;
+  readonly logLevel: "warn";
+  readonly cors: true;
+};
+export declare const providerState: (name: string, params?: ProviderStateParams) => ProviderState;
+/** Starts an interaction with every state applied in order. */
+export declare function givenStates(pact: PactV4, states: readonly ProviderState[]): PactInteraction;
+export interface PactTestBedOptions {
+  /** Provided as `PACT_AUTH_TOKEN`, for the app's auth stubs to hand to its real interceptor. Defaults to null. */
+  token?: string | null;
+  /** Headers added to every request, for apps whose own interceptor is not under test. */
+  authHeaders?: Record<string, string>;
+  /** Functional interceptors, registered after the DI ones. */
+  interceptors?: HttpInterceptorFn[];
+  /** Class interceptors, registered as `HTTP_INTERCEPTORS`. */
+  interceptorClasses?: Type<HttpInterceptor>[];
+  /**
+   * Replaces the default `provideHttpClient(withInterceptorsFromDi(), withInterceptors([...]))`, e.g. with the
+   * app's own HttpClient providers. Combining it with `authHeaders` or `interceptors` throws, and `interceptorClasses`
+   * need `withInterceptorsFromDi()` in these providers.
+   */
+  httpClient?: EnvironmentProviders;
+}
+/** `{ Authorization: '<scheme> <token>' }`, the header DRF token auth expects. */
+export declare const authorizationHeader: (token: string, scheme?: string) => {
+  Authorization: string;
+};
+/** Adds `PactTestBedOptions.authHeaders` to every request that does not set them itself. */
+export declare const pactAuthHeadersInterceptor: HttpInterceptorFn;
+/**
+ * Configures TestBed with HttpClient for a Pact interaction: the mock server URL and auth token are provided as
+ * `PACT_MOCK_SERVER_URL` and `PACT_AUTH_TOKEN`, for the app's config and auth stubs in `providers` to read.
+ * Requests go through `HttpXhrBackend`, which jsdom supports. Call it inside `executeTest`, once the mock server URL
+ * is known. With `options.httpClient`, `authHeaders` and `interceptors` throw, and `interceptorClasses` apply only if
+ * those providers include `withInterceptorsFromDi()`.
+ */
+export declare function configurePactTestBed(mockServerUrl: string, providers?: Provider[], options?: PactTestBedOptions): void;
+/** Base URL of the Pact mock server, without a trailing slash. Build the app's API base URL from it. */
+export declare const PACT_MOCK_SERVER_URL: InjectionToken<string>;
+/** Token the provider state creates, or null for anonymous calls. */
+export declare const PACT_AUTH_TOKEN: InjectionToken<string | null>;
+export declare const PACT_AUTH_HEADERS: InjectionToken<Record<string, string>>;
+export declare const DEFAULT_AUTH_SCHEME = "Token";