@empire-builder-kit/nx 1.0.0-beta.9 → 1.0.0-rc.2

package/src/api-contract/compatibility.js

@@ -0,0 +1,643 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_CONTRACT_COMPATIBILITY_FINDING_CODES = exports.API_CONTRACT_COMPATIBILITY_CLASSIFICATIONS = exports.API_CONTRACT_COMPATIBILITY_REPORT_KIND = exports.API_CONTRACT_COMPATIBILITY_REPORT_SCHEMA_VERSION = void 0;
+exports.compareApiContracts = compareApiContracts;
+const model_js_1 = require("./model.js");
+exports.API_CONTRACT_COMPATIBILITY_REPORT_SCHEMA_VERSION = 1;
+exports.API_CONTRACT_COMPATIBILITY_REPORT_KIND = 'api-contract-compatibility-report';
+exports.API_CONTRACT_COMPATIBILITY_CLASSIFICATIONS = [
+    'compatible',
+    'conditionally-compatible',
+    'breaking',
+];
+exports.API_CONTRACT_COMPATIBILITY_FINDING_CODES = [
+    'contract-slice-changed',
+    'contract-title-changed',
+    'contract-version-advanced',
+    'contract-version-regressed',
+    'operation-added',
+    'operation-removed',
+    'http-method-changed',
+    'route-changed',
+    'authentication-changed',
+    'authorization-actions-changed',
+    'success-status-changed',
+    'feature-changed',
+    'summary-changed',
+    'operation-lifecycle-changed',
+    'problem-added',
+    'problem-removed',
+    'problem-changed',
+    'idempotency-added',
+    'idempotency-removed',
+    'idempotency-changed',
+    'pagination-added',
+    'pagination-removed',
+    'pagination-changed',
+    'conditional-write-added',
+    'conditional-write-removed',
+    'conditional-write-changed',
+    'request-location-added',
+    'request-location-removed',
+    'request-body-limit-changed',
+    'request-property-added',
+    'request-property-removed',
+    'request-required-added',
+    'request-required-removed',
+    'response-property-added',
+    'response-property-removed',
+    'response-required-added',
+    'response-required-removed',
+    'schema-type-widened',
+    'schema-type-narrowed',
+    'schema-type-changed',
+    'schema-nullability-changed',
+    'schema-enum-expanded',
+    'schema-enum-narrowed',
+    'schema-constraint-widened',
+    'schema-constraint-narrowed',
+    'schema-format-changed',
+    'schema-additional-properties-changed',
+    'schema-composition-changed',
+    'schema-const-changed',
+    'schema-description-changed',
+    'schema-review-required',
+];
+const CLASSIFICATION_WEIGHT = {
+    compatible: 0,
+    'conditionally-compatible': 1,
+    breaking: 2,
+};
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function pointerToken(value) {
+    return value.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function jsonEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function semanticVersionCore(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(value);
+    if (!match)
+        return [0n, 0n, 0n];
+    return [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])];
+}
+function compareSemanticVersions(left, right) {
+    const leftCore = semanticVersionCore(left);
+    const rightCore = semanticVersionCore(right);
+    for (let index = 0; index < leftCore.length; index += 1) {
+        const leftPart = leftCore[index];
+        const rightPart = rightCore[index];
+        if (leftPart !== rightPart)
+            return leftPart < rightPart ? -1 : 1;
+    }
+    return compareStrings(left, right);
+}
+class FindingCollector {
+    findings = [];
+    add(classification, code, location, pointer, summary, operationId) {
+        this.findings.push({
+            classification,
+            code,
+            location,
+            ...(operationId ? { operationId } : {}),
+            pointer,
+            summary,
+        });
+    }
+    sorted() {
+        return this.findings.sort((left, right) => compareStrings(left.operationId ?? '', right.operationId ?? '') ||
+            compareStrings(left.pointer, right.pointer) ||
+            compareStrings(left.code, right.code) ||
+            compareStrings(left.location, right.location));
+    }
+}
+function schemaTypes(schema) {
+    return new Set(schema.type === undefined
+        ? []
+        : Array.isArray(schema.type)
+            ? schema.type
+            : [schema.type]);
+}
+function setRelation(baseline, candidate) {
+    const baselineOnly = [...baseline].some((value) => !candidate.has(value));
+    const candidateOnly = [...candidate].some((value) => !baseline.has(value));
+    if (!baselineOnly && !candidateOnly)
+        return 'equal';
+    if (!baselineOnly)
+        return 'expanded';
+    if (!candidateOnly)
+        return 'narrowed';
+    return 'changed';
+}
+function primitiveSet(values) {
+    return values
+        ? new Set(values.map((value) => JSON.stringify(value)))
+        : undefined;
+}
+function nullableSchema(value) {
+    if (value.oneOf === undefined) {
+        return { inner: value, nullable: false };
+    }
+    if (value.oneOf.length !== 2)
+        return undefined;
+    const nullIndexes = value.oneOf.flatMap((entry, index) => entry.type === 'null' &&
+        Object.keys(entry).every((name) => ['$schema', 'description', 'type'].includes(name))
+        ? [index]
+        : []);
+    if (nullIndexes.length !== 1)
+        return undefined;
+    const innerIndex = nullIndexes[0] === 0 ? 1 : 0;
+    return {
+        inner: value.oneOf[innerIndex],
+        innerIndex,
+        nullable: true,
+    };
+}
+function compareBound(baseline, candidate, kind) {
+    if (baseline === candidate)
+        return 'equal';
+    if (baseline === undefined)
+        return 'narrowed';
+    if (candidate === undefined)
+        return 'widened';
+    if (kind === 'minimum') {
+        return candidate < baseline ? 'widened' : 'narrowed';
+    }
+    return candidate > baseline ? 'widened' : 'narrowed';
+}
+function addConstraintFinding(collector, direction, relation, pointer, operationId) {
+    const compatible = (direction === 'request' && relation === 'widened') ||
+        (direction === 'response' && relation === 'narrowed');
+    collector.add(compatible ? 'compatible' : 'breaking', relation === 'widened'
+        ? 'schema-constraint-widened'
+        : 'schema-constraint-narrowed', 'candidate', pointer, `${direction} schema constraint ${relation}`, operationId);
+}
+function addDirectionalFinding(collector, direction, relation, code, pointer, summary, operationId) {
+    const compatible = (direction === 'request' && relation === 'widened') ||
+        (direction === 'response' && relation === 'narrowed');
+    collector.add(compatible ? 'compatible' : 'breaking', code, 'candidate', pointer, summary, operationId);
+}
+function addNullabilityFinding(collector, direction, candidateNullable, pointer, operationId) {
+    collector.add(direction === 'request' && !candidateNullable
+        ? 'breaking'
+        : 'conditionally-compatible', 'schema-nullability-changed', 'candidate', pointer, `${direction} schema nullability ${candidateNullable ? 'widened' : 'narrowed'}`, operationId);
+}
+function addEnumFinding(collector, direction, expanded, pointer, summary, operationId) {
+    const classification = direction === 'response' && expanded
+        ? 'conditionally-compatible'
+        : (direction === 'request' && expanded) ||
+            (direction === 'response' && !expanded)
+            ? 'compatible'
+            : 'breaking';
+    collector.add(classification, expanded ? 'schema-enum-expanded' : 'schema-enum-narrowed', 'candidate', pointer, summary, operationId);
+}
+function additionalPropertiesRelation(baseline, candidate) {
+    if (baseline === false)
+        return 'widened';
+    if (candidate === false)
+        return 'narrowed';
+    if (baseline === true || baseline === undefined)
+        return 'narrowed';
+    if (candidate === true || candidate === undefined)
+        return 'widened';
+    return 'changed';
+}
+function compareSchema(baseline, candidate, direction, baselinePointer, candidatePointer, operationId, collector) {
+    if (baseline.description !== candidate.description) {
+        collector.add('compatible', 'schema-description-changed', 'candidate', `${candidatePointer}/description`, `${direction} schema description changed`, operationId);
+    }
+    if (!jsonEqual(baseline.const, candidate.const)) {
+        const baselineHasConst = baseline.const !== undefined;
+        const candidateHasConst = candidate.const !== undefined;
+        const compatible = baselineHasConst !== candidateHasConst &&
+            ((direction === 'request' && !candidateHasConst) ||
+                (direction === 'response' && candidateHasConst));
+        collector.add(compatible ? 'compatible' : 'breaking', 'schema-const-changed', 'candidate', `${candidatePointer}/const`, `${direction} schema constant changed`, operationId);
+    }
+    if (baseline.oneOf !== undefined || candidate.oneOf !== undefined) {
+        const baselineNullable = nullableSchema(baseline);
+        const candidateNullable = nullableSchema(candidate);
+        if (baselineNullable && candidateNullable) {
+            if (baselineNullable.nullable !== candidateNullable.nullable) {
+                addNullabilityFinding(collector, direction, candidateNullable.nullable, candidateNullable.nullable
+                    ? `${candidatePointer}/oneOf`
+                    : `${candidatePointer}/type`, operationId);
+            }
+            if (baselineNullable.nullable || candidateNullable.nullable) {
+                compareSchema(baselineNullable.inner, candidateNullable.inner, direction, baselineNullable.nullable
+                    ? `${baselinePointer}/oneOf/${baselineNullable.innerIndex}`
+                    : baselinePointer, candidateNullable.nullable
+                    ? `${candidatePointer}/oneOf/${candidateNullable.innerIndex}`
+                    : candidatePointer, operationId, collector);
+                return;
+            }
+        }
+        if (!jsonEqual(baseline.oneOf, candidate.oneOf)) {
+            collector.add('breaking', 'schema-composition-changed', 'candidate', `${candidatePointer}/oneOf`, `${direction} schema composition changed without a provable subset relation`, operationId);
+        }
+        return;
+    }
+    const baselineTypes = schemaTypes(baseline);
+    const candidateTypes = schemaTypes(candidate);
+    const baselineNullable = baselineTypes.has('null');
+    const candidateNullable = candidateTypes.has('null');
+    if (baselineNullable !== candidateNullable) {
+        addNullabilityFinding(collector, direction, candidateNullable, `${candidatePointer}/type`, operationId);
+    }
+    const typesWithoutNull = (values) => new Set([...values].filter((value) => value !== 'null'));
+    const typeRelation = setRelation(typesWithoutNull(baselineTypes), typesWithoutNull(candidateTypes));
+    if (typeRelation !== 'equal') {
+        const relation = typeRelation === 'expanded'
+            ? 'widened'
+            : typeRelation === 'narrowed'
+                ? 'narrowed'
+                : 'changed';
+        const compatible = relation !== 'changed' &&
+            ((direction === 'request' && relation === 'widened') ||
+                (direction === 'response' && relation === 'narrowed'));
+        collector.add(compatible ? 'compatible' : 'breaking', relation === 'widened'
+            ? 'schema-type-widened'
+            : relation === 'narrowed'
+                ? 'schema-type-narrowed'
+                : 'schema-type-changed', 'candidate', `${candidatePointer}/type`, `${direction} schema type ${relation}`, operationId);
+    }
+    const baselineEnum = primitiveSet(baseline.enum);
+    const candidateEnum = primitiveSet(candidate.enum);
+    if (baselineEnum && candidateEnum) {
+        const enumRelation = setRelation(baselineEnum, candidateEnum);
+        if (enumRelation !== 'equal') {
+            if (enumRelation === 'changed') {
+                collector.add('breaking', 'schema-review-required', 'candidate', `${candidatePointer}/enum`, `${direction} schema replaced enum values`, operationId);
+            }
+            else {
+                const expanded = enumRelation === 'expanded';
+                addEnumFinding(collector, direction, expanded, `${candidatePointer}/enum`, `${direction} schema enum ${expanded ? 'expanded' : 'narrowed'}`, operationId);
+            }
+        }
+    }
+    else if (baselineEnum || candidateEnum) {
+        const expanded = baselineEnum !== undefined;
+        addEnumFinding(collector, direction, expanded, `${candidatePointer}/enum`, `${direction} schema enum ${expanded ? 'removed' : 'added'}`, operationId);
+    }
+    for (const member of ['minimum', 'minLength', 'minItems']) {
+        const relation = compareBound(baseline[member], candidate[member], 'minimum');
+        if (relation !== 'equal') {
+            addConstraintFinding(collector, direction, relation, `${candidatePointer}/${member}`, operationId);
+        }
+    }
+    for (const member of ['maximum', 'maxLength', 'maxItems']) {
+        const relation = compareBound(baseline[member], candidate[member], 'maximum');
+        if (relation !== 'equal') {
+            addConstraintFinding(collector, direction, relation, `${candidatePointer}/${member}`, operationId);
+        }
+    }
+    for (const [member, code] of [['format', 'schema-format-changed']]) {
+        if (baseline[member] !== candidate[member]) {
+            if (baseline[member] === undefined || candidate[member] === undefined) {
+                const relation = candidate[member] === undefined ? 'widened' : 'narrowed';
+                addDirectionalFinding(collector, direction, relation, code, `${candidatePointer}/${member}`, `${direction} schema ${member} ${relation}`, operationId);
+            }
+            else {
+                collector.add('breaking', code, 'candidate', `${candidatePointer}/${member}`, `${direction} schema ${member} changed without a provable subset relation`, operationId);
+            }
+        }
+    }
+    if (!jsonEqual(baseline.additionalProperties, candidate.additionalProperties)) {
+        const relation = additionalPropertiesRelation(baseline.additionalProperties, candidate.additionalProperties);
+        if (relation === 'changed') {
+            collector.add('breaking', 'schema-additional-properties-changed', 'candidate', `${candidatePointer}/additionalProperties`, `${direction} schema additional-property policy changed without a provable subset relation`, operationId);
+        }
+        else {
+            addDirectionalFinding(collector, direction, relation, 'schema-additional-properties-changed', `${candidatePointer}/additionalProperties`, `${direction} schema additional-property policy ${relation}`, operationId);
+        }
+    }
+    if (baseline.items && candidate.items) {
+        compareSchema(baseline.items, candidate.items, direction, `${baselinePointer}/items`, `${candidatePointer}/items`, operationId, collector);
+    }
+    else if (baseline.items || candidate.items) {
+        collector.add('breaking', 'schema-review-required', candidate.items ? 'candidate' : 'baseline', candidate.items
+            ? `${candidatePointer}/items`
+            : `${baselinePointer}/items`, `${direction} array item schema was added or removed`, operationId);
+    }
+    compareSchemaProperties(baseline, candidate, direction, baselinePointer, candidatePointer, operationId, collector);
+}
+function compareSchemaProperties(baseline, candidate, direction, baselinePointer, candidatePointer, operationId, collector) {
+    const baselineProperties = baseline.properties ?? {};
+    const candidateProperties = candidate.properties ?? {};
+    const baselineRequired = new Set(baseline.required ?? []);
+    const candidateRequired = new Set(candidate.required ?? []);
+    const names = [
+        ...new Set([
+            ...Object.keys(baselineProperties),
+            ...Object.keys(candidateProperties),
+        ]),
+    ].sort(compareStrings);
+    for (const name of names) {
+        const baselineProperty = baselineProperties[name];
+        const candidateProperty = candidateProperties[name];
+        const token = pointerToken(name);
+        if (!baselineProperty && candidateProperty) {
+            const required = candidateRequired.has(name);
+            collector.add(direction === 'request' && required ? 'breaking' : 'compatible', direction === 'request'
+                ? 'request-property-added'
+                : 'response-property-added', 'candidate', `${candidatePointer}/properties/${token}`, `${direction} property ${name} was added${required ? ' as required' : ''}`, operationId);
+            continue;
+        }
+        if (baselineProperty && !candidateProperty) {
+            collector.add('breaking', direction === 'request'
+                ? 'request-property-removed'
+                : 'response-property-removed', 'baseline', `${baselinePointer}/properties/${token}`, `${direction} property ${name} was removed`, operationId);
+            continue;
+        }
+        if (!baselineProperty || !candidateProperty)
+            continue;
+        if (baselineRequired.has(name) !== candidateRequired.has(name)) {
+            const required = candidateRequired.has(name);
+            const classification = direction === 'request'
+                ? required
+                    ? 'breaking'
+                    : 'compatible'
+                : required
+                    ? 'compatible'
+                    : 'breaking';
+            collector.add(classification, direction === 'request'
+                ? required
+                    ? 'request-required-added'
+                    : 'request-required-removed'
+                : required
+                    ? 'response-required-added'
+                    : 'response-required-removed', 'candidate', `${candidatePointer}/required`, `${direction} property ${name} became ${required ? 'required' : 'optional'}`, operationId);
+        }
+        compareSchema(baselineProperty, candidateProperty, direction, `${baselinePointer}/properties/${token}`, `${candidatePointer}/properties/${token}`, operationId, collector);
+    }
+}
+function strongestClassification(...classifications) {
+    return classifications.reduce((strongest, classification) => CLASSIFICATION_WEIGHT[classification] > CLASSIFICATION_WEIGHT[strongest]
+        ? classification
+        : strongest, 'compatible');
+}
+function compareIdempotencySemantics(baseline, candidate) {
+    const changes = [];
+    const classifications = [];
+    if (baseline.required !== candidate.required) {
+        changes.push(`key became ${candidate.required ? 'required' : 'optional'}`);
+        classifications.push(candidate.required ? 'breaking' : 'compatible');
+    }
+    if (baseline.maxKeyLength !== candidate.maxKeyLength) {
+        changes.push(`maximum key length ${candidate.maxKeyLength < baseline.maxKeyLength ? 'narrowed' : 'widened'}`);
+        classifications.push(candidate.maxKeyLength < baseline.maxKeyLength
+            ? 'breaking'
+            : 'compatible');
+    }
+    if (baseline.retentionSeconds !== candidate.retentionSeconds) {
+        changes.push(`retention ${candidate.retentionSeconds < baseline.retentionSeconds
+            ? 'shortened'
+            : 'extended'}`);
+        classifications.push(candidate.retentionSeconds < baseline.retentionSeconds
+            ? 'breaking'
+            : 'conditionally-compatible');
+    }
+    if (baseline.concurrentDuplicate !== candidate.concurrentDuplicate) {
+        changes.push(`concurrent duplicate behavior changed from ${baseline.concurrentDuplicate} to ${candidate.concurrentDuplicate}`);
+        classifications.push(baseline.concurrentDuplicate === 'wait'
+            ? 'breaking'
+            : 'conditionally-compatible');
+    }
+    return {
+        classification: strongestClassification(...classifications),
+        summary: changes.join('; '),
+    };
+}
+function compareConditionalWriteSemantics(baseline, candidate) {
+    return {
+        classification: candidate.required ? 'breaking' : 'compatible',
+        summary: `precondition became ${candidate.required ? 'required' : 'optional'}`,
+    };
+}
+function comparePaginationSemantics(baseline, candidate) {
+    const changes = [];
+    const classifications = [];
+    for (const field of [
+        'cursorQueryParameter',
+        'cursorResponseField',
+        'limitQueryParameter',
+    ]) {
+        if (baseline[field] !== candidate[field]) {
+            changes.push(`${field} changed`);
+            classifications.push('breaking');
+        }
+    }
+    if (baseline.minimumLimit !== candidate.minimumLimit) {
+        changes.push(`minimum limit ${candidate.minimumLimit > baseline.minimumLimit ? 'raised' : 'lowered'}`);
+        classifications.push(candidate.minimumLimit > baseline.minimumLimit
+            ? 'breaking'
+            : 'compatible');
+    }
+    if (baseline.maximumLimit !== candidate.maximumLimit) {
+        changes.push(`maximum limit ${candidate.maximumLimit < baseline.maximumLimit ? 'lowered' : 'raised'}`);
+        classifications.push(candidate.maximumLimit < baseline.maximumLimit
+            ? 'breaking'
+            : 'compatible');
+    }
+    if (baseline.defaultLimit !== candidate.defaultLimit) {
+        changes.push('default limit changed');
+        classifications.push('conditionally-compatible');
+    }
+    if (baseline.stability !== candidate.stability) {
+        changes.push(`stability changed from ${baseline.stability} to ${candidate.stability}`);
+        classifications.push(baseline.stability === 'snapshot' ? 'breaking' : 'compatible');
+    }
+    if (baseline.expirySeconds !== candidate.expirySeconds) {
+        if (candidate.expirySeconds === undefined) {
+            changes.push('cursor expiry was removed');
+            classifications.push('compatible');
+        }
+        else if (baseline.expirySeconds === undefined) {
+            changes.push('cursor expiry was introduced');
+            classifications.push('breaking');
+        }
+        else {
+            changes.push(`cursor expiry ${candidate.expirySeconds < baseline.expirySeconds
+                ? 'shortened'
+                : 'extended'}`);
+            classifications.push(candidate.expirySeconds < baseline.expirySeconds
+                ? 'breaking'
+                : 'compatible');
+        }
+    }
+    return {
+        classification: strongestClassification(...classifications),
+        summary: changes.join('; '),
+    };
+}
+function compareOptionalSemantics(baseline, candidate, member, candidatePointer, baselinePointer, operationId, collector) {
+    if (jsonEqual(baseline, candidate))
+        return;
+    const codePrefix = member === 'conditionalWrite' ? 'conditional-write' : member;
+    if (baseline === undefined) {
+        const required = member === 'pagination'
+            ? false
+            : candidate.required;
+        collector.add(required ? 'breaking' : 'conditionally-compatible', `${codePrefix}-added`, 'candidate', candidatePointer, `${member} semantics were added${required ? ' as required' : ''}`, operationId);
+    }
+    else if (candidate === undefined) {
+        collector.add('breaking', `${codePrefix}-removed`, 'baseline', baselinePointer, `${member} semantics were removed`, operationId);
+    }
+    else {
+        const comparison = member === 'idempotency'
+            ? compareIdempotencySemantics(baseline, candidate)
+            : member === 'conditionalWrite'
+                ? compareConditionalWriteSemantics(baseline, candidate)
+                : comparePaginationSemantics(baseline, candidate);
+        collector.add(comparison.classification, `${codePrefix}-changed`, 'candidate', candidatePointer, `${member} semantics changed: ${comparison.summary}`, operationId);
+    }
+}
+function compareProblems(baseline, candidate, baselinePointer, candidatePointer, collector) {
+    const baselineProblems = new Map(baseline.problems.map((problem, index) => [
+        problem.type,
+        { index, problem },
+    ]));
+    const candidateProblems = new Map(candidate.problems.map((problem, index) => [
+        problem.type,
+        { index, problem },
+    ]));
+    const types = [
+        ...new Set([...baselineProblems.keys(), ...candidateProblems.keys()]),
+    ].sort(compareStrings);
+    for (const type of types) {
+        const before = baselineProblems.get(type);
+        const after = candidateProblems.get(type);
+        if (!before && after) {
+            collector.add('conditionally-compatible', 'problem-added', 'candidate', `${candidatePointer}/problems/${after.index}`, `problem ${type} was added`, candidate.operationId);
+        }
+        else if (before && !after) {
+            collector.add('breaking', 'problem-removed', 'baseline', `${baselinePointer}/problems/${before.index}`, `problem ${type} was removed`, baseline.operationId);
+        }
+        else if (before && after && !jsonEqual(before.problem, after.problem)) {
+            collector.add('breaking', 'problem-changed', 'candidate', `${candidatePointer}/problems/${after.index}`, `problem ${type} changed`, candidate.operationId);
+        }
+    }
+}
+function compareRequestLocations(baseline, candidate, baselinePointer, candidatePointer, collector) {
+    for (const location of ['body', 'headers', 'path', 'query']) {
+        const before = baseline.request?.[location];
+        const after = candidate.request?.[location];
+        if (!before && after) {
+            const required = location === 'body' ||
+                location === 'path' ||
+                (after.required?.length ?? 0) > 0;
+            collector.add(required ? 'breaking' : 'conditionally-compatible', 'request-location-added', 'candidate', `${candidatePointer}/request/${location}`, `request ${location} contract was added${required ? ' with required input' : ''}`, candidate.operationId);
+        }
+        else if (before && !after) {
+            collector.add('breaking', 'request-location-removed', 'baseline', `${baselinePointer}/request/${location}`, `request ${location} contract was removed`, baseline.operationId);
+        }
+        else if (before && after) {
+            compareSchema(before, after, 'request', `${baselinePointer}/request/${location}`, `${candidatePointer}/request/${location}`, candidate.operationId, collector);
+        }
+    }
+    const baselineLimit = baseline.request?.maxBodyBytes;
+    const candidateLimit = candidate.request?.maxBodyBytes;
+    if (baselineLimit !== candidateLimit) {
+        const widened = candidateLimit === undefined ||
+            (baselineLimit !== undefined && candidateLimit > baselineLimit);
+        collector.add(widened ? 'compatible' : 'breaking', 'request-body-limit-changed', 'candidate', `${candidatePointer}/request/maxBodyBytes`, `request body limit ${widened ? 'widened' : 'narrowed'}`, candidate.operationId);
+    }
+}
+function compareOperation(baseline, candidate, baselinePointer, candidatePointer, collector) {
+    for (const [member, code, classification] of [
+        ['method', 'http-method-changed', 'breaking'],
+        ['path', 'route-changed', 'breaking'],
+        ['authentication', 'authentication-changed', 'breaking'],
+        ['authorizationActions', 'authorization-actions-changed', 'breaking'],
+        ['feature', 'feature-changed', 'conditionally-compatible'],
+        ['summary', 'summary-changed', 'compatible'],
+    ]) {
+        if (!jsonEqual(baseline[member], candidate[member])) {
+            collector.add(classification, code, 'candidate', `${candidatePointer}/${member}`, `${member} changed`, candidate.operationId);
+        }
+    }
+    if (!jsonEqual(baseline.lifecycle, candidate.lifecycle)) {
+        collector.add(baseline.lifecycle.status === 'active' &&
+            candidate.lifecycle.status === 'deprecated'
+            ? 'compatible'
+            : 'conditionally-compatible', 'operation-lifecycle-changed', 'candidate', `${candidatePointer}/lifecycle`, 'operation lifecycle metadata changed', candidate.operationId);
+    }
+    if (baseline.response.status !== candidate.response.status) {
+        collector.add('breaking', 'success-status-changed', 'candidate', `${candidatePointer}/response/status`, 'successful response status changed', candidate.operationId);
+    }
+    compareRequestLocations(baseline, candidate, baselinePointer, candidatePointer, collector);
+    compareSchema(baseline.response.body, candidate.response.body, 'response', `${baselinePointer}/response/body`, `${candidatePointer}/response/body`, candidate.operationId, collector);
+    compareProblems(baseline, candidate, baselinePointer, candidatePointer, collector);
+    for (const member of [
+        'conditionalWrite',
+        'idempotency',
+        'pagination',
+    ]) {
+        compareOptionalSemantics(baseline[member], candidate[member], member, `${candidatePointer}/${member}`, `${baselinePointer}/${member}`, candidate.operationId, collector);
+    }
+}
+function compareApiContracts(baselineInput, candidateInput) {
+    const baseline = (0, model_js_1.normalizeApiContractBaseline)(baselineInput);
+    const candidate = (0, model_js_1.createApiContractBaseline)(candidateInput);
+    const collector = new FindingCollector();
+    if (baseline.slice !== candidate.slice) {
+        collector.add('breaking', 'contract-slice-changed', 'candidate', '/slice', 'owning Slice changed');
+    }
+    if (baseline.title !== candidate.title) {
+        collector.add('compatible', 'contract-title-changed', 'candidate', '/title', 'contract title changed');
+    }
+    const versionComparison = compareSemanticVersions(candidate.version, baseline.version);
+    if (versionComparison > 0) {
+        collector.add('compatible', 'contract-version-advanced', 'candidate', '/version', 'contract version advanced');
+    }
+    else if (versionComparison < 0) {
+        collector.add('breaking', 'contract-version-regressed', 'candidate', '/version', 'contract version regressed');
+    }
+    const baselineOperations = new Map(baseline.operations.map((operation, index) => [
+        operation.operationId,
+        { index, operation },
+    ]));
+    const candidateOperations = new Map(candidate.operations.map((operation, index) => [
+        operation.operationId,
+        { index, operation },
+    ]));
+    const operationIds = [
+        ...new Set([...baselineOperations.keys(), ...candidateOperations.keys()]),
+    ].sort(compareStrings);
+    for (const operationId of operationIds) {
+        const before = baselineOperations.get(operationId);
+        const after = candidateOperations.get(operationId);
+        if (!before && after) {
+            collector.add('compatible', 'operation-added', 'candidate', `/operations/${after.index}`, `operation ${operationId} was added`, operationId);
+        }
+        else if (before && !after) {
+            collector.add('breaking', 'operation-removed', 'baseline', `/operations/${before.index}`, `operation ${operationId} was removed`, operationId);
+        }
+        else if (before && after) {
+            compareOperation(before.operation, after.operation, `/operations/${before.index}`, `/operations/${after.index}`, collector);
+        }
+    }
+    const findings = collector.sorted();
+    const classification = findings.reduce((current, finding) => CLASSIFICATION_WEIGHT[finding.classification] >
+        CLASSIFICATION_WEIGHT[current]
+        ? finding.classification
+        : current, 'compatible');
+    return {
+        baseline: {
+            digest: (0, model_js_1.digestApiContractBaseline)(baseline),
+            version: baseline.version,
+        },
+        candidate: {
+            digest: (0, model_js_1.digestApiContractBaseline)(candidate),
+            version: candidate.version,
+        },
+        classification,
+        findings,
+        kind: exports.API_CONTRACT_COMPATIBILITY_REPORT_KIND,
+        schemaVersion: exports.API_CONTRACT_COMPATIBILITY_REPORT_SCHEMA_VERSION,
+        slice: candidate.slice,
+    };
+}
+//# sourceMappingURL=compatibility.js.map