@pactflow/openapi-pact-comparator 1.15.0 → 2.0.1

package/dist/src/cli/runner.d.ts

@@ -1,6 +1,15 @@
 import type { OpenAPIV2, OpenAPIV3 } from "openapi-types";
+import type { AsyncAPIDocument } from "../documents/asyncapi";
 import { type Result } from "../index";
 type OASDocument = OpenAPIV2.Document | OpenAPIV3.Document;
+export interface SpecPaths {
+    oasPath?: string;
+    asyncapiPath?: string;
+}
+export interface ComparatorDocs {
+    oas?: OASDocument;
+    asyncapi?: AsyncAPIDocument;
+}
 export interface ComparatorLike {
     compare(pact: unknown): AsyncGenerator<Result>;
 }
@@ -8,7 +17,7 @@ export interface RunnerDependencies {
     readFile: (path: string) => Promise<string>;
     fetch: (url: string) => Promise<Response>;
     output: (message: string) => void;
-    createComparator: (oas: OASDocument) => ComparatorLike;
+    createComparator: (docs: ComparatorDocs) => ComparatorLike;
 }
 export declare class Runner {
     private deps;
@@ -17,6 +26,6 @@ export declare class Runner {
     private readContent;
     private parseContent;
     private readAndParse;
-    run(oasPath: string, pactPaths: string[]): Promise<number>;
+    run(specPaths: SpecPaths, pactPaths: string[]): Promise<number>;
 }
 export {};

package/dist/src/compare/asyncapi/index.d.ts

@@ -0,0 +1,5 @@
+import type Ajv from "ajv/dist/2019";
+import type { AsyncAPIDocument, ResolvedMessage } from "#documents/asyncapi";
+import type { AsyncInteraction } from "#documents/pact";
+import type { Result } from "#results/index";
+export declare function compareAsyncInteraction(ajv: Ajv, asyncapi: AsyncAPIDocument | undefined, cache: Map<string, ResolvedMessage>, interaction: AsyncInteraction, index: number): Iterable<Result>;

package/dist/src/compare/asyncapi/matchMessages.d.ts

@@ -0,0 +1,33 @@
+import type Ajv from "ajv/dist/2019";
+import type { AsyncAPIDocument, ResolvedMessage } from "#documents/asyncapi";
+import type { Result } from "#results/index";
+type InteractionContext = {
+    description?: string;
+    providerState?: string;
+    asyncapiReferences?: {
+        operationId: string;
+    };
+};
+export declare function checkAsyncapiPreamble(asyncapi: AsyncAPIDocument | undefined, interaction: InteractionContext, index: number, interactionKind: string): {
+    ok: true;
+    asyncapi: AsyncAPIDocument;
+    operationId: string;
+} | {
+    ok: false;
+    result: Result;
+};
+type MessageContent = {
+    payload: unknown;
+    contentType?: string;
+    metadata?: Record<string, string>;
+};
+type MessageLocations = {
+    payload: string;
+    headers: string;
+    spec: string;
+};
+export declare function tryMatchAllMessages(ajv: Ajv, asyncapi: AsyncAPIDocument, candidates: Iterable<ResolvedMessage>, content: MessageContent, interactionContext: {
+    description?: string;
+    providerState?: string;
+}, locations: MessageLocations, direction: "request" | "response", noMatchMockDetails: NonNullable<Result["mockDetails"]>): Generator<Result>;
+export {};

package/dist/src/compare/asyncapi/messageHeaders.d.ts

@@ -0,0 +1,9 @@
+import type Ajv from "ajv/dist/2019";
+import type { Message } from "#documents/asyncapi";
+import type { Result } from "#results/index";
+export declare function compareMessageHeaders(ajv: Ajv, message: Message, content: {
+    metadata?: Record<string, string>;
+}, interactionContext: {
+    description?: string;
+    providerState?: string;
+}, metadataLocation: string, messagePath: string, direction: "request" | "response"): Iterable<Result>;

package/dist/src/compare/asyncapi/messagePayload.d.ts

@@ -0,0 +1,10 @@
+import type Ajv from "ajv/dist/2019";
+import type { Message } from "#documents/asyncapi";
+import type { Result } from "#results/index";
+export declare function compareMessagePayload(ajv: Ajv, message: Message, content: {
+    payload: unknown;
+    contentType?: string;
+}, interactionContext: {
+    description?: string;
+    providerState?: string;
+}, contentLocation: string, messagePath: string, direction: "request" | "response"): Iterable<Result>;

package/dist/src/compare/asyncapi/syncMessage.d.ts

@@ -0,0 +1,5 @@
+import type Ajv from "ajv/dist/2019";
+import type { AsyncAPIDocument, ResolvedMessage } from "#documents/asyncapi";
+import type { SyncInteraction } from "#documents/pact";
+import type { Result } from "#results/index";
+export declare function compareSyncInteraction(ajv: Ajv, asyncapi: AsyncAPIDocument | undefined, cache: Map<string, ResolvedMessage>, interaction: SyncInteraction, index: number): Iterable<Result>;

package/dist/src/compare/index.d.ts

@@ -1,8 +1,13 @@
 import type { OpenAPIV2, OpenAPIV3 } from "openapi-types";
+import type { AsyncAPIDocument } from "#documents/asyncapi";
 import type { Pact } from "#documents/pact";
 import type { Result } from "#results/index";
+export interface ComparatorOptions {
+    oas?: OpenAPIV2.Document | OpenAPIV3.Document;
+    asyncapi?: AsyncAPIDocument;
+}
 export declare class Comparator {
     #private;
-    constructor(oas: OpenAPIV2.Document | OpenAPIV3.Document);
+    constructor(options?: ComparatorOptions);
     compare(pact: Pact): AsyncGenerator<Result>;
 }

package/dist/src/compare/oas/index.d.ts

@@ -0,0 +1,6 @@
+import type Ajv from "ajv/dist/2019";
+import type Router from "find-my-way";
+import type { HttpInteraction } from "#documents/pact";
+import type { Result } from "#results/index";
+import type { Config } from "#utils/config";
+export declare function compareHttpInteraction(ajvCoerce: Ajv, ajvNocoerce: Ajv, router: Router.Instance<Router.HTTPVersion.V1> | undefined, interaction: HttpInteraction, index: number, config: Config): Iterable<Result>;

package/dist/src/compare/{requestBody.d.ts → oas/requestBody.d.ts}

@@ -1,6 +1,6 @@
 import type Ajv from "ajv/dist/2019";
 import type Router from "find-my-way";
-import type { Interaction } from "#documents/pact";
+import type { HttpInteraction } from "#documents/pact";
 import type { Result } from "#results/index";
 import type { Config } from "#utils/config";
-export declare function compareReqBody(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: Interaction, index: number, config: Config): Iterable<Result>;
+export declare function compareReqBody(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: HttpInteraction, index: number, config: Config): Iterable<Result>;

package/dist/src/compare/{requestHeader.d.ts → oas/requestHeader.d.ts}

@@ -1,6 +1,6 @@
 import type Ajv from "ajv/dist/2019";
 import type Router from "find-my-way";
-import type { Interaction } from "#documents/pact";
+import type { HttpInteraction } from "#documents/pact";
 import type { Result } from "#results/index";
 import type { Config } from "#utils/config";
-export declare function compareReqHeader(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: Interaction, index: number, config: Config): Iterable<Result>;
+export declare function compareReqHeader(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: HttpInteraction, index: number, config: Config): Iterable<Result>;

package/dist/src/compare/{requestPath.d.ts → oas/requestPath.d.ts}

@@ -1,6 +1,6 @@
 import type Ajv from "ajv/dist/2019";
 import type Router from "find-my-way";
-import type { Interaction } from "#documents/pact";
+import type { HttpInteraction } from "#documents/pact";
 import type { Result } from "#results/index";
 import type { Config } from "#utils/config";
-export declare function compareReqPath(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: Interaction, index: number, config: Config): Iterable<Result>;
+export declare function compareReqPath(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: HttpInteraction, index: number, config: Config): Iterable<Result>;

package/dist/src/compare/{requestQuery.d.ts → oas/requestQuery.d.ts}

@@ -1,6 +1,6 @@
 import type Ajv from "ajv/dist/2019";
 import type Router from "find-my-way";
+import type { HttpInteraction } from "#documents/pact";
 import type { Result } from "#results/index";
-import type { Interaction } from "#documents/pact";
 import type { Config } from "#utils/config";
-export declare function compareReqQuery(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: Interaction, index: number, config: Config): Iterable<Result>;
+export declare function compareReqQuery(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: HttpInteraction, index: number, config: Config): Iterable<Result>;

package/dist/src/compare/{requestSecurity.d.ts → oas/requestSecurity.d.ts}

@@ -1,6 +1,6 @@
 import type Ajv from "ajv/dist/2019";
 import type Router from "find-my-way";
-import type { Interaction } from "#documents/pact";
+import type { HttpInteraction } from "#documents/pact";
 import type { Result } from "#results/index";
 import type { Config } from "#utils/config";
-export declare function compareReqSecurity(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: Interaction, index: number, config: Config): Iterable<Result>;
+export declare function compareReqSecurity(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: HttpInteraction, index: number, config: Config): Iterable<Result>;

package/dist/src/compare/{responseBody.d.ts → oas/responseBody.d.ts}

@@ -1,6 +1,6 @@
 import type Ajv from "ajv/dist/2019";
 import type Router from "find-my-way";
-import type { Interaction } from "#documents/pact";
+import type { HttpInteraction } from "#documents/pact";
 import type { Result } from "#results/index";
 import type { Config } from "#utils/config";
-export declare function compareResBody(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: Interaction, index: number, config: Config): Iterable<Result>;
+export declare function compareResBody(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: HttpInteraction, index: number, config: Config): Iterable<Result>;

package/dist/src/compare/{responseHeader.d.ts → oas/responseHeader.d.ts}

@@ -1,6 +1,6 @@
 import type Ajv from "ajv/dist/2019";
 import type Router from "find-my-way";
-import type { Interaction } from "#documents/pact";
+import type { HttpInteraction } from "#documents/pact";
 import type { Result } from "#results/index";
 import type { Config } from "#utils/config";
-export declare function compareResHeader(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: Interaction, index: number, _config: Config): Iterable<Result>;
+export declare function compareResHeader(ajv: Ajv, route: Router.FindResult<Router.HTTPVersion.V1>, interaction: HttpInteraction, index: number, _config: Config): Iterable<Result>;

package/dist/src/compare/oas/setup.d.ts

@@ -0,0 +1,4 @@
+import Router from "find-my-way";
+import type { OpenAPIV2, OpenAPIV3 } from "openapi-types";
+import type { Config } from "#utils/config";
+export declare function setupRouter(oas: OpenAPIV2.Document | OpenAPIV3.Document, config: Config): Router.Instance<Router.HTTPVersion.V1>;

package/dist/src/compare/setup.d.ts

@@ -1,6 +1,2 @@
-import type { OpenAPIV2, OpenAPIV3 } from "openapi-types";
-import Ajv, { Options } from "ajv/dist/2019.js";
-import Router from "find-my-way";
-import type { Config } from "#utils/config";
+import Ajv, { type Options } from "ajv/dist/2019.js";
 export declare function setupAjv(options: Options): Ajv;
-export declare function setupRouter(oas: OpenAPIV2.Document | OpenAPIV3.Document, config: Config): Router.Instance<Router.HTTPVersion.V1>;

package/dist/src/documents/asyncapi.d.ts

@@ -0,0 +1,44 @@
+export interface AsyncAPIDocument {
+    asyncapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    channels?: Record<string, Channel>;
+    operations?: Record<string, Operation>;
+    components?: {
+        messages?: Record<string, Message>;
+        schemas?: Record<string, object>;
+    };
+}
+export interface Channel {
+    messages?: Record<string, Message | Ref>;
+}
+export interface OperationReply {
+    channel?: Ref;
+    messages?: Array<Ref | Message>;
+}
+export interface Operation {
+    action: "send" | "receive";
+    channel: Ref;
+    messages?: Array<Ref | Message>;
+    reply?: OperationReply;
+}
+export interface Message {
+    payload?: object;
+    headers?: object;
+    contentType?: string;
+}
+export interface Ref {
+    $ref: string;
+}
+export declare class ParserError extends Error {
+    constructor();
+}
+export declare const parse: (doc: AsyncAPIDocument) => void;
+export interface ResolvedMessage {
+    message: Message;
+    path: string;
+}
+export declare function iterateMessages(doc: AsyncAPIDocument, operationId: string, cache: Map<string, ResolvedMessage>): Generator<ResolvedMessage>;
+export declare function iterateReplyMessages(doc: AsyncAPIDocument, operationId: string, cache: Map<string, ResolvedMessage>): Generator<ResolvedMessage>;

package/dist/src/documents/pact.d.ts

@@ -1,24 +1,5 @@
-import { Static } from "@sinclair/typebox";
-import { ErrorObject } from "ajv";
-export declare const Interaction: import("@sinclair/typebox").TObject<{
-    _skip: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    providerState: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    request: import("@sinclair/typebox").TObject<{
-        body: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
-        headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>]>>;
-        method: import("@sinclair/typebox").TString;
-        path: import("@sinclair/typebox").TString;
-        query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TString, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>]>>;
-    }>;
-    response: import("@sinclair/typebox").TObject<{
-        body: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
-        headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>]>>;
-        status: import("@sinclair/typebox").TNumber;
-    }>;
-}>;
-export type Interaction = Static<typeof Interaction>;
+import { type Static } from "@sinclair/typebox";
+import { type ErrorObject } from "ajv";
 export declare const Pact: import("@sinclair/typebox").TObject<{
     metadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         pactSpecification: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
@@ -29,27 +10,64 @@ export declare const Pact: import("@sinclair/typebox").TObject<{
             version: import("@sinclair/typebox").TString;
         }>>;
     }>>;
-    interactions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        _skip: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-        type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        providerState: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-        request: import("@sinclair/typebox").TObject<{
-            body: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
-            headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>]>>;
-            method: import("@sinclair/typebox").TString;
-            path: import("@sinclair/typebox").TString;
-            query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TString, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>]>>;
-        }>;
-        response: import("@sinclair/typebox").TObject<{
-            body: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
-            headers: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>]>>;
-            status: import("@sinclair/typebox").TNumber;
-        }>;
-    }>>;
+    interactions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>;
 }>;
 export type Pact = Static<typeof Pact>;
-export declare const parse: (pact: Pact) => Pact;
+export interface HttpInteraction {
+    _kind: "http";
+    description?: string;
+    providerState?: string;
+    request: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        method: string;
+        path: string;
+        query?: string | Record<string, string>;
+    };
+    response: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        status: number;
+    };
+}
+export interface AsyncInteraction {
+    _kind: "async";
+    description?: string;
+    providerState?: string;
+    asyncapiReferences?: {
+        operationId: string;
+    };
+    payload: unknown;
+    contentType?: string;
+    metadata?: Record<string, string>;
+}
+export interface SyncInteraction {
+    _kind: "sync";
+    description?: string;
+    providerState?: string;
+    asyncapiReferences?: {
+        operationId: string;
+    };
+    request: {
+        payload: unknown;
+        contentType?: string;
+        metadata?: Record<string, string>;
+    };
+    responses: Array<{
+        payload: unknown;
+        contentType?: string;
+        metadata?: Record<string, string>;
+    }>;
+}
+export interface SkippedInteraction {
+    _kind: "skip";
+}
+export type Interaction = HttpInteraction | AsyncInteraction | SyncInteraction | SkippedInteraction;
+export interface ParsedPact {
+    metadata?: Pact["metadata"];
+    interactions: Interaction[];
+}
+export declare const parse: (pact: Pact) => ParsedPact;
 export declare class ParserError extends Error {
     errors: ErrorObject[];
     constructor(errors: ErrorObject[]);

package/dist/src/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./compare";
-export { type Result } from "./results";
+export type { AsyncAPIDocument } from "./documents/asyncapi";
+export type { Result } from "./results";

package/dist/src/results/index.d.ts

@@ -1,9 +1,9 @@
 import type { ErrorObject } from "ajv";
-import type { Interaction } from "../documents/pact";
-type ErrorCode = "request.accept.incompatible" | "request.authorization.missing" | "request.body.incompatible" | "request.content-type.incompatible" | "request.header.incompatible" | "request.path-or-method.unknown" | "request.query.incompatible" | "response.body.incompatible" | "response.body.unknown" | "response.content-type.incompatible" | "response.header.incompatible" | "response.header.unknown" | "response.status.unknown";
-type WarningCode = "pact-broker.no-pacts-found" | "request.accept.unknown" | "request.body.unknown" | "request.content-type.missing" | "request.content-type.unknown" | "request.header.unknown" | "request.query.unknown" | "response.content-type.unknown" | "response.header.undefined" | "response.status.default";
+type InfoCode = "message.matched";
+type ErrorCode = "message.headers.incompatible" | "message.no.match" | "message.operation.unknown" | "message.payload.incompatible" | "message.references.missing" | "message.reply.missing" | "message.spec.missing" | "request.accept.incompatible" | "request.authorization.missing" | "request.body.incompatible" | "request.content-type.incompatible" | "request.header.incompatible" | "request.path-or-method.unknown" | "request.query.incompatible" | "request.spec.missing" | "response.body.incompatible" | "response.body.unknown" | "response.content-type.incompatible" | "response.header.incompatible" | "response.header.unknown" | "response.status.unknown";
+type WarningCode = "message.payload.unknown" | "message.response.missing" | "pact-broker.no-pacts-found" | "request.accept.unknown" | "request.body.unknown" | "request.content-type.missing" | "request.content-type.unknown" | "request.header.unknown" | "request.query.unknown" | "response.content-type.unknown" | "response.header.undefined" | "response.status.default";
 export interface Result {
-    code: ErrorCode | WarningCode;
+    code: ErrorCode | WarningCode | InfoCode;
     message: string;
     mockDetails?: {
         interactionDescription?: string | null;
@@ -17,12 +17,16 @@ export interface Result {
         pathName?: string | null;
         value: unknown;
     };
-    type: "error" | "warning";
+    type: "error" | "warning" | "info";
+    causes?: Result[];
 }
 export declare const formatMessage: (error: ErrorObject) => string | undefined;
 export declare const formatInstancePath: (error: ErrorObject) => string;
 export declare const formatSchemaPath: (error: ErrorObject) => string;
-export declare const baseMockDetails: (interaction: Interaction) => {
+export declare const baseMockDetails: (interaction: {
+    description?: string;
+    providerState?: string;
+}) => {
     interactionDescription: string | undefined;
     interactionState: string;
 };

package/dist/src/transform/flattenAllOf.d.ts

@@ -1,2 +1,2 @@
-import { SchemaObject } from "ajv";
+import type { SchemaObject } from "ajv";
 export declare function flattenAllOf(s: SchemaObject, refs: string[]): SchemaObject;

package/dist/src/transform/index.d.ts

@@ -1,2 +1,2 @@
-export { transformResponseSchema } from "./responseSchema";
 export { minimumSchema } from "./minimumSchema";
+export { transformReceivedSchema } from "./responseSchema";

package/dist/src/transform/minimumSchema.d.ts

@@ -1,3 +1,3 @@
+import type { SchemaObject } from "ajv";
 import type { OpenAPIV3 } from "openapi-types";
-import { SchemaObject } from "ajv";
 export declare const minimumSchema: (originalSchema: SchemaObject, oas: OpenAPIV3.Document) => SchemaObject;

package/dist/src/transform/responseSchema.d.ts

@@ -1,2 +1,2 @@
-import { SchemaObject } from "ajv";
-export declare const transformResponseSchema: (schema: SchemaObject, noTransformNonNullableResponseSchema: boolean) => SchemaObject;
+import type { SchemaObject } from "ajv";
+export declare const transformReceivedSchema: (schema: SchemaObject, quirks?: boolean) => SchemaObject;

package/dist/src/utils/interaction.d.ts

@@ -1,2 +1,2 @@
-import type { Interaction } from "../documents/pact";
-export declare const isValidRequest: (interaction: Interaction) => boolean;
+import type { HttpInteraction } from "../documents/pact";
+export declare const isValidRequest: (interaction: HttpInteraction) => boolean;

package/dist/src/utils/quirks.d.ts

@@ -1,3 +1,3 @@
-import type { OpenAPIV3 } from "openapi-types";
 import type { SchemaObject } from "ajv";
+import type { OpenAPIV3 } from "openapi-types";
 export declare const isSimpleSchema: (s: SchemaObject | undefined, oas: OpenAPIV3.Document) => boolean;

package/dist/src/utils/schema.d.ts

@@ -1,6 +1,10 @@
-import type { OpenAPIV3 } from "openapi-types";
 import type { SchemaObject } from "ajv";
+import type { OpenAPIV3 } from "openapi-types";
+export declare const resolveSchemaRefs: (schema: unknown, doc: object, visited?: Set<string>) => unknown;
 export declare const splitPath: (path: string) => string | string[];
 export declare const dereferenceOas: (schema: SchemaObject, oas: OpenAPIV3.Document) => any;
+export declare const dereferenceDoc: (schema: {
+    $ref?: string;
+}, doc: object) => unknown;
 export declare const traverse: (schema: SchemaObject, visitor: (schema: SchemaObject) => void) => void;
 export declare const traverseWithDereferencing: (schema: SchemaObject, visitor: (schema: SchemaObject) => void) => void;

package/dist/src/utils/validation.d.ts

@@ -1,2 +1,3 @@
-import Ajv, { AnySchema, ValidateFunction } from "ajv";
+import type Ajv from "ajv";
+import type { AnySchema, ValidateFunction } from "ajv";
 export declare const getValidateFunction: (ajv: Ajv, schemaId: string, create: () => AnySchema) => ValidateFunction;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pactflow/openapi-pact-comparator",
-  "version": "1.15.0",
+  "version": "2.0.1",
   "description": "An OpenAPI Specification and Pact Comparison library",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -25,6 +25,7 @@
     "changeset:version": "changeset version",
     "lint": "eslint --max-warnings=0",
     "patch-package": "patch-package",
+    "postinstall": "patch-package",
     "prepare": "npm run build",
     "prettier": "prettier --check .",
     "prettier:fix": "prettier --cache --list-different --write .",
@@ -43,39 +44,43 @@
     "email": "voon.wong@smartbear.com"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
   "type": "module",
   "devDependencies": {
     "@changesets/cli": "2.31.0",
     "@eslint/js": "10.0.1",
-    "@rollup/plugin-commonjs": "29.0.2",
+    "@rollup/plugin-commonjs": "29.0.3",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-node-resolve": "16.0.3",
     "@rollup/plugin-typescript": "12.3.0",
     "@sinclair/typebox": "0.34.49",
+    "@tsconfig/node22": "22.0.5",
     "@types/js-yaml": "4.0.9",
     "@types/lodash-es": "4.17.12",
     "@types/node": "24.12.4",
     "@types/qs": "6.15.1",
-    "@vitest/coverage-v8": "4.1.6",
+    "@vitest/coverage-v8": "4.1.8",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
-    "commander": "14.0.3",
-    "eslint": "10.3.0",
+    "commander": "15.0.0",
+    "eslint": "10.4.1",
     "eslint-config-prettier": "10.1.8",
     "find-my-way": "9.6.0",
-    "js-yaml": "4.1.1",
+    "js-yaml": "4.2.0",
     "lodash-es": "4.18.1",
     "openapi-types": "12.1.3",
     "parse-multipart-data": "1.5.0",
     "patch-package": "8.0.1",
     "prettier": "3.8.3",
-    "qs": "6.15.1",
-    "rollup": "4.60.4",
+    "qs": "6.15.2",
+    "rollup": "4.61.0",
     "tslib": "2.8.1",
-    "tsx": "4.22.0",
+    "tsx": "4.22.4",
     "typescript": "6.0.3",
-    "typescript-eslint": "8.59.3",
-    "vitest": "4.1.6"
+    "typescript-eslint": "8.60.1",
+    "vitest": "4.1.8"
   },
   "imports": {
     "#compare/*": "./src/compare/*.ts",