@pactflow/openapi-pact-comparator 2.0.1 → 2.2.0

package/dist/index.cjs

@@ -4252,14 +4252,199 @@ function* compareMessageHeaders(ajv, message, content, interactionContext, metad
     }
 }
 
-const canValidate$2 = (contentType) => {
+const PARAMETER_SEPARATOR = ";";
+const WILDCARD = "*";
+const TYPE_SUBTYPE_SEPARATOR = "/";
+const EXTENSION_SEPARATOR = "+";
+const quality = (a) => {
+    const match = /.*;q=([01].?\d*)/.exec(a);
+    return match ? parseFloat(match[1]) : 1.0;
+};
+const byQuality = (a, b) => {
+    return quality(b) - quality(a);
+};
+const ignoreCasing = (t) => t.toLowerCase();
+const ignoreWhitespace = (t) => t.replace(/\s+/g, "");
+const ignoreParameters = (t) => t.split(PARAMETER_SEPARATOR)[0];
+const removeQuality = (t) => t.replace(/;q=[01].?\d*/, "");
+const type$a = (t) => t.split(TYPE_SUBTYPE_SEPARATOR)[0];
+const subtype = (t) => {
+    const [_maintype, subtype] = t.split(TYPE_SUBTYPE_SEPARATOR);
+    return subtype?.split(EXTENSION_SEPARATOR).pop();
+};
+function findMatchingType(requestType, responseTypes) {
+    // exact match
+    let accept = requestType
+        .split(",")
+        .map(ignoreWhitespace)
+        .map(ignoreCasing)
+        .sort(byQuality)
+        .map(removeQuality);
+    let available = responseTypes.map(ignoreWhitespace).map(ignoreCasing);
+    for (const a of accept) {
+        const matchExactly = (t) => t === a;
+        const index = available.findIndex(matchExactly);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    // ignore additional parameters
+    accept = accept.map(ignoreParameters);
+    available = available.map(ignoreParameters);
+    for (const a of accept) {
+        const matchExactly = (t) => t === a;
+        const index = available.findIndex(matchExactly);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    // ignore vendor extensions
+    for (const a of accept) {
+        const matchTypesAndSubtypes = (t) => type$a(t) === type$a(a) && subtype(t) === subtype(a);
+        const index = available.findIndex(matchTypesAndSubtypes);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    // wildcards in responseTypes
+    for (const a of accept) {
+        const matchSubtype = (t) => subtype(t) === WILDCARD && type$a(t) === type$a(a);
+        const index = available.findIndex(matchSubtype);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    if (available.includes(`${WILDCARD}/${WILDCARD}`)) {
+        return `${WILDCARD}/${WILDCARD}`;
+    }
+    // wildcards in requestTypes
+    for (const a of accept) {
+        const matchSubtype = (t) => subtype(a) === WILDCARD && type$a(t) === type$a(a);
+        const index = available.findIndex(matchSubtype);
+        if (index >= 0) {
+            return responseTypes[index];
+        }
+    }
+    if (accept.includes(`${WILDCARD}/${WILDCARD}`)) {
+        return responseTypes[0];
+    }
+    return undefined;
+}
+const getByContentType = (object = {}, contentType) => {
+    const key = findMatchingType(contentType, Object.keys(object));
+    return object[key];
+};
+const standardHttpRequestHeaders = [
+    "accept",
+    "accept-charset",
+    "accept-datetime",
+    "accept-encoding",
+    "accept-language",
+    "authorization",
+    "cache-control",
+    "connection",
+    "content-length",
+    "content-md5",
+    "content-type",
+    "cookie",
+    "date",
+    "expect",
+    "forwarded",
+    "from",
+    "host",
+    "if-match",
+    "if-modified-since",
+    "if-none-match",
+    "if-range",
+    "if-unmodified-since",
+    "max-forwards",
+    "origin",
+    "pragma",
+    "proxy-authorization",
+    "range",
+    "referer",
+    "te",
+    "upgrade",
+    "user-agent",
+    "via",
+    "warning",
+];
+const standardHttpResponseHeaders = [
+    "access-control-allow-origin",
+    "accept-patch",
+    "accept-ranges",
+    "age",
+    "allow",
+    "alt-svc",
+    "cache-control",
+    "connection",
+    "content-disposition",
+    "content-encoding",
+    "content-language",
+    "content-length",
+    "content-location",
+    "content-md5",
+    "content-range",
+    "date",
+    "etag",
+    "expires",
+    "last-modified",
+    "link",
+    "location",
+    "p3p",
+    "pragma",
+    "proxy-authenticate",
+    "public-key-pins",
+    "refresh",
+    "retry-after",
+    "server",
+    "set-cookie",
+    "status",
+    "strict-transport-security",
+    "trailer",
+    "transfer-encoding",
+    "tsv",
+    "upgrade",
+    "vary",
+    "via",
+    "warning",
+    "www-authenticate",
+    "x-frame-options",
+];
+
+const VALIDATABLE_CONTENT_TYPES = [
+    "application/json",
+    "application/x-www-form-urlencoded",
+    "multipart/form-data",
+];
+const bodyValidationStatus = (contentType, body, validatableTypes = [...VALIDATABLE_CONTENT_TYPES]) => {
     if (typeof contentType !== "string")
-        return false;
-    const normalized = contentType.split(";", 1)[0].trim().toLowerCase();
-    return normalized === "application/json" || normalized.endsWith("+json");
+        return "skip";
+    if (findMatchingType(contentType, validatableTypes))
+        return "validate";
+    return body !== undefined ? "warn" : "skip";
 };
+
 function* compareMessagePayload(ajv, message, content, interactionContext, contentLocation, messagePath, direction) {
-    if (!canValidate$2(content.contentType))
+    const status = bodyValidationStatus(content.contentType, content.payload);
+    if (status === "warn") {
+        yield {
+            code: "message.payload.unvalidatable",
+            message: `Body with content type '${content.contentType}' is not supported by the spec comparator`,
+            mockDetails: {
+                ...baseMockDetails(interactionContext),
+                location: contentLocation,
+                value: content.payload,
+            },
+            specDetails: {
+                location: messagePath,
+                value: undefined,
+            },
+            type: "warning",
+        };
+        return;
+    }
+    if (status === "skip")
         return;
     if (!message.payload) {
         if (content.payload !== undefined) {
@@ -4722,16 +4907,16 @@ function requireMultipart () {
 var multipartExports = requireMultipart();
 var multipart = /*@__PURE__*/getDefaultExportFromCjs(multipartExports);
 
-var type$a;
+var type$9;
 var hasRequiredType;
 
 function requireType () {
-	if (hasRequiredType) return type$a;
+	if (hasRequiredType) return type$9;
 	hasRequiredType = 1;
 
 	/** @type {import('./type')} */
-	type$a = TypeError;
-	return type$a;
+	type$9 = TypeError;
+	return type$9;
 }
 
 var util_inspect;
@@ -7853,166 +8038,6 @@ var qs = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
 const isValidRequest = (interaction) => interaction.response.status < 400;
 
-const PARAMETER_SEPARATOR = ";";
-const WILDCARD = "*";
-const TYPE_SUBTYPE_SEPARATOR = "/";
-const EXTENSION_SEPARATOR = "+";
-const quality = (a) => {
-    const match = /.*;q=([01].?\d*)/.exec(a);
-    return match ? parseFloat(match[1]) : 1.0;
-};
-const byQuality = (a, b) => {
-    return quality(b) - quality(a);
-};
-const ignoreCasing = (t) => t.toLowerCase();
-const ignoreWhitespace = (t) => t.replace(/\s+/g, "");
-const ignoreParameters = (t) => t.split(PARAMETER_SEPARATOR)[0];
-const removeQuality = (t) => t.replace(/;q=[01].?\d*/, "");
-const type$9 = (t) => t.split(TYPE_SUBTYPE_SEPARATOR)[0];
-const subtype = (t) => {
-    const [_maintype, subtype] = t.split(TYPE_SUBTYPE_SEPARATOR);
-    return subtype?.split(EXTENSION_SEPARATOR).pop();
-};
-function findMatchingType(requestType, responseTypes) {
-    // exact match
-    let accept = requestType
-        .split(",")
-        .map(ignoreWhitespace)
-        .map(ignoreCasing)
-        .sort(byQuality)
-        .map(removeQuality);
-    let available = responseTypes.map(ignoreWhitespace).map(ignoreCasing);
-    for (const a of accept) {
-        const matchExactly = (t) => t === a;
-        const index = available.findIndex(matchExactly);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    // ignore additional parameters
-    accept = accept.map(ignoreParameters);
-    available = available.map(ignoreParameters);
-    for (const a of accept) {
-        const matchExactly = (t) => t === a;
-        const index = available.findIndex(matchExactly);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    // ignore vendor extensions
-    for (const a of accept) {
-        const matchTypesAndSubtypes = (t) => type$9(t) === type$9(a) && subtype(t) === subtype(a);
-        const index = available.findIndex(matchTypesAndSubtypes);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    // wildcards in responseTypes
-    for (const a of accept) {
-        const matchSubtype = (t) => subtype(t) === WILDCARD && type$9(t) === type$9(a);
-        const index = available.findIndex(matchSubtype);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    if (available.includes(`${WILDCARD}/${WILDCARD}`)) {
-        return `${WILDCARD}/${WILDCARD}`;
-    }
-    // wildcards in requestTypes
-    for (const a of accept) {
-        const matchSubtype = (t) => subtype(a) === WILDCARD && type$9(t) === type$9(a);
-        const index = available.findIndex(matchSubtype);
-        if (index >= 0) {
-            return responseTypes[index];
-        }
-    }
-    if (accept.includes(`${WILDCARD}/${WILDCARD}`)) {
-        return responseTypes[0];
-    }
-    return undefined;
-}
-const getByContentType = (object = {}, contentType) => {
-    const key = findMatchingType(contentType, Object.keys(object));
-    return object[key];
-};
-const standardHttpRequestHeaders = [
-    "accept",
-    "accept-charset",
-    "accept-datetime",
-    "accept-encoding",
-    "accept-language",
-    "authorization",
-    "cache-control",
-    "connection",
-    "content-length",
-    "content-md5",
-    "content-type",
-    "cookie",
-    "date",
-    "expect",
-    "forwarded",
-    "from",
-    "host",
-    "if-match",
-    "if-modified-since",
-    "if-none-match",
-    "if-range",
-    "if-unmodified-since",
-    "max-forwards",
-    "origin",
-    "pragma",
-    "proxy-authorization",
-    "range",
-    "referer",
-    "te",
-    "upgrade",
-    "user-agent",
-    "via",
-    "warning",
-];
-const standardHttpResponseHeaders = [
-    "access-control-allow-origin",
-    "accept-patch",
-    "accept-ranges",
-    "age",
-    "allow",
-    "alt-svc",
-    "cache-control",
-    "connection",
-    "content-disposition",
-    "content-encoding",
-    "content-language",
-    "content-length",
-    "content-location",
-    "content-md5",
-    "content-range",
-    "date",
-    "etag",
-    "expires",
-    "last-modified",
-    "link",
-    "location",
-    "p3p",
-    "pragma",
-    "proxy-authenticate",
-    "public-key-pins",
-    "refresh",
-    "retry-after",
-    "server",
-    "set-cookie",
-    "status",
-    "strict-transport-security",
-    "trailer",
-    "transfer-encoding",
-    "tsv",
-    "upgrade",
-    "vary",
-    "via",
-    "warning",
-    "www-authenticate",
-    "x-frame-options",
-];
-
 const parseBody = (body, contentType, legacyParser) => {
     if (contentType.includes("application/x-www-form-urlencoded") &&
         typeof body === "string") {
@@ -8036,13 +8061,6 @@ const parseBody = (body, contentType, legacyParser) => {
     }
     return body;
 };
-const canValidate$1 = (contentType, disableMultipartFormdata) => {
-    return !!findMatchingType(contentType, [
-        "application/json",
-        "application/x-www-form-urlencoded",
-        disableMultipartFormdata ? "" : "multipart/form-data",
-    ].filter(Boolean));
-};
 const DEFAULT_CONTENT_TYPE$1 = "application/json";
 function* compareReqBody(ajv, route, interaction, index, config) {
     const { method, oas, operation, path } = route.store;
@@ -8062,8 +8080,30 @@ function* compareReqBody(ajv, route, interaction, index, config) {
     if (!required && body === undefined) {
         return;
     }
+    const bodyStatus = bodyValidationStatus(contentType, body, VALIDATABLE_CONTENT_TYPES.filter((t) => t !== "multipart/form-data" ||
+        !config.get("disable-multipart-formdata")));
+    if (bodyStatus === "skip")
+        return;
+    if (bodyStatus === "warn" && isValidRequest(interaction)) {
+        yield {
+            code: "request.body.unvalidatable",
+            message: `Body with content type '${contentType}' is not supported by the spec comparator`,
+            mockDetails: {
+                ...baseMockDetails(interaction),
+                location: `[root].interactions[${index}].request.body`,
+                value: body,
+            },
+            specDetails: {
+                location: `[root].paths.${path}.${method}.requestBody.content`,
+                pathMethod: method,
+                pathName: path,
+                value: get$1(operation, "requestBody.content"),
+            },
+            type: "warning",
+        };
+        return;
+    }
     if (schema &&
-        canValidate$1(contentType, config.get("disable-multipart-formdata")) &&
         isValidRequest(interaction) &&
         (config.get("no-validate-request-body-unless-application-json")
             ? !!findMatchingType("application/json", availableRequestContentTypes)
@@ -8702,9 +8742,6 @@ function* compareReqSecurity(ajv, route, interaction, index, config) {
 
 const patternedStatus = (status) => `${Math.floor(status / 100)}XX`;
 
-const canValidate = (contentType = "") => {
-    return !!findMatchingType(contentType, ["application/json"]);
-};
 const DEFAULT_CONTENT_TYPE = "application/json";
 function* compareResBody(ajv, route, interaction, index, config) {
     const { method, oas, operation, path } = route.store;
@@ -8759,14 +8796,15 @@ function* compareResBody(ajv, route, interaction, index, config) {
                 type: "warning",
             };
         }
-        if (value && canValidate(contentType) && !schema) {
+        const bodyStatus = bodyValidationStatus(contentType, value);
+        if (bodyStatus === "warn") {
             yield {
-                code: "response.body.unknown",
-                message: "No matching schema found for response body",
+                code: "response.body.unvalidatable",
+                message: `Body with content type '${contentType}' is not supported by the spec comparator`,
                 mockDetails: {
                     ...baseMockDetails(interaction),
                     location: `[root].interactions[${index}].response.body`,
-                    value: value,
+                    value,
                 },
                 specDetails: {
                     location: `[root].paths.${path}.${method}.responses.${status}.content`,
@@ -8774,32 +8812,52 @@ function* compareResBody(ajv, route, interaction, index, config) {
                     pathName: path,
                     value: response.content,
                 },
-                type: "error",
+                type: "warning",
             };
         }
-        if (value && canValidate(contentType) && schema) {
-            const schemaId = `[root].paths.${path}.${method}.responses.${status}.content.${contentType}`;
-            const validate = getValidateFunction(ajv, schemaId, () => transformReceivedSchema(minimumSchema(schema, oas), config.get("no-transform-non-nullable-response-schema")));
-            if (!validate(value)) {
-                for (const error of validate.errors) {
-                    yield {
-                        code: "response.body.incompatible",
-                        message: `Response body is incompatible with the response body schema in the spec file: ${formatMessage(error)}`,
-                        mockDetails: {
-                            ...baseMockDetails(interaction),
-                            location: `[root].interactions[${index}].response.body${formatInstancePath(error)}`,
-                            value: error.instancePath
-                                ? get$1(value, splitPath(error.instancePath))
-                                : value,
-                        },
-                        specDetails: {
-                            location: `${schemaId}.schema.${formatSchemaPath(error)}`,
-                            pathMethod: method,
-                            pathName: path,
-                            value: get$1(validate.schema, splitPath(error.schemaPath)),
-                        },
-                        type: "error",
-                    };
+        else if (bodyStatus === "validate") {
+            if (value && !schema) {
+                yield {
+                    code: "response.body.unknown",
+                    message: "No matching schema found for response body",
+                    mockDetails: {
+                        ...baseMockDetails(interaction),
+                        location: `[root].interactions[${index}].response.body`,
+                        value: value,
+                    },
+                    specDetails: {
+                        location: `[root].paths.${path}.${method}.responses.${status}.content`,
+                        pathMethod: method,
+                        pathName: path,
+                        value: response.content,
+                    },
+                    type: "error",
+                };
+            }
+            if (value && schema) {
+                const schemaId = `[root].paths.${path}.${method}.responses.${status}.content.${contentType}`;
+                const validate = getValidateFunction(ajv, schemaId, () => transformReceivedSchema(minimumSchema(schema, oas), config.get("no-transform-non-nullable-response-schema")));
+                if (!validate(value)) {
+                    for (const error of validate.errors) {
+                        yield {
+                            code: "response.body.incompatible",
+                            message: `Response body is incompatible with the response body schema in the spec file: ${formatMessage(error)}`,
+                            mockDetails: {
+                                ...baseMockDetails(interaction),
+                                location: `[root].interactions[${index}].response.body${formatInstancePath(error)}`,
+                                value: error.instancePath
+                                    ? get$1(value, splitPath(error.instancePath))
+                                    : value,
+                            },
+                            specDetails: {
+                                location: `${schemaId}.schema.${formatSchemaPath(error)}`,
+                                pathMethod: method,
+                                pathName: path,
+                                value: get$1(validate.schema, splitPath(error.schemaPath)),
+                            },
+                            type: "error",
+                        };
+                    }
                 }
             }
         }
@@ -8995,11 +9053,17 @@ function* compareHttpInteraction(ajvCoerce, ajvNocoerce, router, interaction, in
         return;
     }
     yield* compareReqSecurity(ajvCoerce, route, interaction, index, config);
-    yield* compareReqHeader(ajvCoerce, route, interaction, index, config);
+    const reqHeaderResults = Array.from(compareReqHeader(ajvCoerce, route, interaction, index, config));
+    yield* reqHeaderResults;
     yield* compareReqQuery(ajvCoerce, route, interaction, index, config);
-    yield* compareReqBody(ajvNocoerce, route, interaction, index, config);
-    yield* compareResHeader(ajvCoerce, route, interaction, index);
-    yield* compareResBody(ajvNocoerce, route, interaction, index, config);
+    if (!reqHeaderResults.some((r) => r.code === "request.content-type.incompatible")) {
+        yield* compareReqBody(ajvNocoerce, route, interaction, index, config);
+    }
+    const resHeaderResults = Array.from(compareResHeader(ajvCoerce, route, interaction, index));
+    yield* resHeaderResults;
+    if (!resHeaderResults.some((r) => r.code === "response.content-type.incompatible")) {
+        yield* compareResBody(ajvNocoerce, route, interaction, index, config);
+    }
 }
 
 const isSwagger2 = (oas) => Object.hasOwn(oas, "swagger") &&