@apidiff/core 1.0.0

package/tests/rules/param.test.ts

@@ -0,0 +1,242 @@
+import { describe, it, expect } from 'vitest';
+import { ParamRemovedRule } from '../../src/rules/param/param-removed.js';
+import { ParamAddedRule } from '../../src/rules/param/param-added.js';
+import { ParamDeprecatedRule } from '../../src/rules/param/param-deprecated.js';
+import { ParamTypeChangedRule } from '../../src/rules/param/param-type-changed.js';
+import { ParamRequiredAddedRule } from '../../src/rules/param/param-required-added.js';
+import { ParamLocationChangedRule } from '../../src/rules/param/param-location-changed.js';
+import { ParamEnumValueRemovedRule } from '../../src/rules/param/param-enum-value-removed.js';
+import { ParamEnumValueAddedRule } from '../../src/rules/param/param-enum-value-added.js';
+import { ParamRequiredTrueToFalseRule } from '../../src/rules/param/param-required-true-to-false.js';
+import type { DiffSet, RuleContext } from '../../src/types/index.js';
+
+describe('Parameter Rules', () => {
+  const context: RuleContext = {
+    config: { failOn: 'breaking', disabledRules: [], ignorePaths: [], output: { format: 'terminal' } },
+    oldSpec: { meta: { title: 'v1', version: '1.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+    newSpec: { meta: { title: 'v2', version: '2.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+  };
+
+  const dummyEndpoint = { id: 'GET:/test', path: '/test', method: 'GET' as const, summary: '', description: '', tags: [], deprecated: false, security: [], parameters: [], responses: [] };
+
+  it('PARAM_REMOVED triggers on required param removal', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query'], changeType: 'removed', oldValue: { name: 'testParam', in: 'query', required: true, schema: { type: 'string' } } }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_REMOVED');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('PARAM_OPTIONAL_REMOVED triggers on optional param removal', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query'], changeType: 'removed', oldValue: { name: 'testParam', in: 'query', required: false, schema: { type: 'string' } } }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_OPTIONAL_REMOVED');
+    expect(changes[0].severity).toBe('warning');
+  });
+
+  it('PARAM_ADDED_REQUIRED triggers on required param added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query'], changeType: 'added', newValue: { name: 'testParam', in: 'query', required: true, schema: { type: 'string' } } }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_ADDED_REQUIRED');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('PARAM_ADDED triggers on optional param added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query'], changeType: 'added', newValue: { name: 'testParam', in: 'query', required: false, schema: { type: 'string' } } }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_ADDED');
+    expect(changes[0].severity).toBe('info');
+  });
+
+  it('PARAM_DEPRECATED triggers on deprecated change', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query', 'deprecated'], changeType: 'changed', oldValue: false, newValue: true }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamDeprecatedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_DEPRECATED');
+    expect(changes[0].severity).toBe('warning');
+  });
+
+  it('PARAM_TYPE_CHANGED triggers on schema type change', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query', 'schema', 'type'], changeType: 'changed', oldValue: 'string', newValue: 'number' }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamTypeChangedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_TYPE_CHANGED');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('PARAM_REQUIRED_FALSE_TO_TRUE triggers when optional becomes required', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query', 'required'], changeType: 'changed', oldValue: false, newValue: true }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamRequiredAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_REQUIRED_FALSE_TO_TRUE');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('PARAM_LOCATION_CHANGED triggers when parameter moves', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query'], changeType: 'removed', oldValue: { name: 'testParam', in: 'query' } },
+            { fieldPath: ['parameters', 'testParam:header'], changeType: 'added', newValue: { name: 'testParam', in: 'header' } }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamLocationChangedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_LOCATION_CHANGED');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('PARAM_ENUM_VALUE_REMOVED triggers when enum is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query', 'schema', 'enum', 'oldVal'], changeType: 'removed', oldValue: 'oldVal' }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamEnumValueRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_ENUM_VALUE_REMOVED');
+    expect(changes[0].severity).toBe('breaking');
+  });
+
+  it('PARAM_ENUM_VALUE_ADDED triggers when enum is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query', 'schema', 'enum', 'newVal'], changeType: 'added', newValue: 'newVal' }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamEnumValueAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_ENUM_VALUE_ADDED');
+    expect(changes[0].severity).toBe('info');
+  });
+
+  it('PARAM_REQUIRED_TRUE_TO_FALSE triggers when required becomes optional', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { 
+          type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, 
+          fieldChanges: [
+            { fieldPath: ['parameters', 'testParam:query', 'required'], changeType: 'changed', oldValue: true, newValue: false }
+          ] 
+        }
+      ],
+      componentDiffs: []
+    };
+    
+    const rule = new ParamRequiredTrueToFalseRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('PARAM_REQUIRED_TRUE_TO_FALSE');
+    expect(changes[0].severity).toBe('info');
+  });
+});

package/tests/rules/request.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest';
+import { RequestBodyAddedRequiredRule } from '../../src/rules/request/request-body-added-required.js';
+import { RequestBodyRemovedRule } from '../../src/rules/request/request-body-removed.js';
+import { RequestContentTypeAddedRule } from '../../src/rules/request/request-content-type-added.js';
+import { RequestContentTypeRemovedRule } from '../../src/rules/request/request-content-type-removed.js';
+import { RequestFieldRemovedRule } from '../../src/rules/request/request-field-removed.js';
+import { RequestFieldAddedRequiredRule } from '../../src/rules/request/request-field-added-required.js';
+import { RequestFieldTypeChangedRule } from '../../src/rules/request/request-field-type-changed.js';
+import { RequestRequiredFalseToTrueRule } from '../../src/rules/request/request-required-false-to-true.js';
+import type { DiffSet, RuleContext } from '../../src/types/index.js';
+
+describe('Request Rules', () => {
+  const context: RuleContext = {
+    config: { failOn: 'breaking', disabledRules: [], ignorePaths: [], output: { format: 'terminal' } },
+    oldSpec: { meta: { title: 'v1', version: '1.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+    newSpec: { meta: { title: 'v2', version: '2.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+  };
+
+  const dummyEndpoint = { id: 'POST:/test', path: '/test', method: 'POST' as const, summary: '', description: '', tags: [], deprecated: false, security: [], parameters: [], responses: [] };
+
+  it('REQUEST_BODY_ADDED_REQUIRED triggers when required body is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody'], changeType: 'added', newValue: { required: true, content: {} } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestBodyAddedRequiredRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_BODY_ADDED_REQUIRED');
+  });
+
+  it('REQUEST_BODY_REMOVED triggers when body is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody'], changeType: 'removed', oldValue: { required: false, content: {} } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestBodyRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_BODY_REMOVED');
+  });
+
+  it('REQUEST_CONTENT_TYPE_ADDED triggers when content type is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody', 'content', 'application/json'], changeType: 'added', newValue: { schema: {} } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestContentTypeAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_CONTENT_TYPE_ADDED');
+  });
+
+  it('REQUEST_CONTENT_TYPE_REMOVED triggers when content type is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody', 'content', 'application/json'], changeType: 'removed', oldValue: { schema: {} } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestContentTypeRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_CONTENT_TYPE_REMOVED');
+  });
+
+  it('REQUEST_FIELD_REMOVED triggers when field is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody', 'content', 'application/json', 'schema', 'properties', 'testField'], changeType: 'removed', oldValue: { type: 'string' } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestFieldRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_FIELD_REMOVED');
+  });
+
+  it('REQUEST_FIELD_ADDED_REQUIRED triggers when required field is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody', 'content', 'application/json', 'schema', 'required', 'testField'], changeType: 'added', newValue: 'testField' },
+          { fieldPath: ['requestBody', 'content', 'application/json', 'schema', 'properties', 'testField'], changeType: 'added', newValue: { type: 'string' } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestFieldAddedRequiredRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_FIELD_ADDED_REQUIRED');
+  });
+
+  it('REQUEST_FIELD_TYPE_CHANGED triggers when type changes', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody', 'content', 'application/json', 'schema', 'properties', 'testField', 'type'], changeType: 'changed', oldValue: 'string', newValue: 'number' }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestFieldTypeChangedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_FIELD_TYPE_CHANGED');
+  });
+
+  it('REQUEST_REQUIRED_FALSE_TO_TRUE triggers when body becomes required', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody', 'required'], changeType: 'changed', oldValue: false, newValue: true }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestRequiredFalseToTrueRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_REQUIRED_FALSE_TO_TRUE');
+  });
+
+  it('REQUEST_REQUIRED_FALSE_TO_TRUE triggers when existing field becomes required', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'POST:/test', path: '/test', method: 'POST', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['requestBody', 'content', 'application/json', 'schema', 'required', 'testField'], changeType: 'added', newValue: 'testField' }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new RequestRequiredFalseToTrueRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('REQUEST_REQUIRED_FALSE_TO_TRUE');
+  });
+});

package/tests/rules/response.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect } from 'vitest';
+import { ResponseFieldRemovedRule } from '../../src/rules/response/response-field-removed.js';
+import { ResponseFieldAddedRule } from '../../src/rules/response/response-field-added.js';
+import { ResponseFieldTypeChangedRule } from '../../src/rules/response/response-field-type-changed.js';
+import { ResponseStatusRemovedRule } from '../../src/rules/response/response-status-removed.js';
+import { ResponseStatusAddedRule } from '../../src/rules/response/response-status-added.js';
+import { ResponseMediaTypeRemovedRule } from '../../src/rules/response/response-media-type-removed.js';
+import { ResponseMediaTypeAddedRule } from '../../src/rules/response/response-media-type-added.js';
+import { ResponseHeaderRemovedRule } from '../../src/rules/response/response-header-removed.js';
+import { ResponseHeaderAddedRequiredRule } from '../../src/rules/response/response-header-added-required.js';
+import type { DiffSet, RuleContext } from '../../src/types/index.js';
+
+describe('Response Rules', () => {
+  const context: RuleContext = {
+    config: { failOn: 'breaking', disabledRules: [], ignorePaths: [], output: { format: 'terminal' } },
+    oldSpec: { meta: { title: 'v1', version: '1.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+    newSpec: { meta: { title: 'v2', version: '2.0.0', format: 'openapi3', rawVersion: '3.0.0' }, servers: [], endpoints: [], components: { schemas: {}, securitySchemes: {}, parameters: {}, responses: {}, headers: {}, requestBodies: {} }, security: [] },
+  };
+
+  const dummyEndpoint = { id: 'GET:/test', path: '/test', method: 'GET' as const, summary: '', description: '', tags: [], deprecated: false, security: [], parameters: [], responses: [] };
+
+  it('RESPONSE_FIELD_REMOVED triggers when field is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'content', 'application/json', 'schema', 'properties', 'testField'], changeType: 'removed', oldValue: { type: 'string' } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseFieldRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_FIELD_REMOVED');
+  });
+
+  it('RESPONSE_FIELD_ADDED triggers when field is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'content', 'application/json', 'schema', 'properties', 'testField'], changeType: 'added', newValue: { type: 'string' } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseFieldAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_FIELD_ADDED');
+  });
+
+  it('RESPONSE_FIELD_TYPE_CHANGED triggers when type changes', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'content', 'application/json', 'schema', 'properties', 'testField', 'type'], changeType: 'changed', oldValue: 'string', newValue: 'number' }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseFieldTypeChangedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_FIELD_TYPE_CHANGED');
+  });
+
+  it('RESPONSE_STATUS_REMOVED triggers when status code is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '201'], changeType: 'removed', oldValue: {} }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseStatusRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_STATUS_REMOVED');
+  });
+
+  it('RESPONSE_STATUS_ADDED triggers when status code is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '201'], changeType: 'added', newValue: {} }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseStatusAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_STATUS_ADDED');
+  });
+
+  it('RESPONSE_MEDIA_TYPE_REMOVED triggers when media type is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'content', 'application/json'], changeType: 'removed', oldValue: {} }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseMediaTypeRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_MEDIA_TYPE_REMOVED');
+  });
+
+  it('RESPONSE_MEDIA_TYPE_ADDED triggers when media type is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'content', 'application/json'], changeType: 'added', newValue: {} }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseMediaTypeAddedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_MEDIA_TYPE_ADDED');
+  });
+
+  it('RESPONSE_HEADER_REMOVED triggers when header is removed', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'headers', 'X-Rate-Limit'], changeType: 'removed', oldValue: {} }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseHeaderRemovedRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_HEADER_REMOVED');
+  });
+
+  it('RESPONSE_HEADER_ADDED_REQUIRED triggers when required header is added', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'headers', 'X-Rate-Limit'], changeType: 'added', newValue: { required: true } }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseHeaderAddedRequiredRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_HEADER_ADDED_REQUIRED');
+  });
+
+  it('RESPONSE_HEADER_ADDED_REQUIRED triggers when optional header becomes required', () => {
+    const diff: DiffSet = {
+      endpointDiffs: [
+        { type: 'changed', endpointId: 'GET:/test', path: '/test', method: 'GET', oldEndpoint: dummyEndpoint, newEndpoint: dummyEndpoint, fieldChanges: [
+          { fieldPath: ['responses', '200', 'headers', 'X-Rate-Limit', 'required'], changeType: 'changed', oldValue: false, newValue: true }
+        ]}
+      ], componentDiffs: []
+    };
+    const rule = new ResponseHeaderAddedRequiredRule();
+    const changes = rule.apply(diff, context);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].ruleId).toBe('RESPONSE_HEADER_ADDED_REQUIRED');
+  });
+});

package/tests/rules/rules-coverage.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { BUILT_IN_RULES, runRules } from '../../src/rules/index.js';
+import type { DiffSet, RuleContext, Endpoint } from '../../src/types/index.js';
+
+describe('Rules Early Return Coverage', () => {
+  it('covers early returns and ignored endpoints for all rules', () => {
+    const oldE: Endpoint = {
+      id: 'test',
+      method: 'GET',
+      path: '/ignored',
+      security: [],
+      parameters: [],
+      responses: [],
+      tags: [],
+      deprecated: false,
+      extensions: {}
+    };
+
+    const newE: Endpoint = { ...oldE };
+
+    const context: RuleContext = {
+      config: {
+        severity: 'info',
+        disabledRules: [],
+        ignorePaths: ['/ignored']
+      },
+      oldAst: { meta: {} as any, endpoints: [], components: {} as any, servers: [], security: [] },
+      newAst: { meta: {} as any, endpoints: [], components: {} as any, servers: [], security: [] },
+      sourcePath: ''
+    };
+
+    const diffSet: DiffSet = {
+      endpointDiffs: [
+        // Ignored path
+        { type: 'changed', endpointId: 'test1', method: 'GET', path: '/ignored', oldEndpoint: oldE, newEndpoint: newE, fieldChanges: [] },
+        // Not changed
+        { type: 'added', endpointId: 'test2', method: 'GET', path: '/test', newEndpoint: newE, fieldChanges: [] },
+        { type: 'removed', endpointId: 'test3', method: 'GET', path: '/test', oldEndpoint: oldE, fieldChanges: [] },
+        // Changed but irrelevant field change
+        { 
+          type: 'changed', 
+          endpointId: 'test4', 
+          method: 'GET', 
+          path: '/test', 
+          oldEndpoint: oldE, 
+          newEndpoint: newE, 
+          fieldChanges: [
+            { fieldPath: ['unknown'], changeType: 'changed', oldValue: 'a', newValue: 'b' },
+            { fieldPath: ['parameters', 'p:query'], changeType: 'removed', oldValue: {} },
+            { fieldPath: ['parameters', 'p:header'], changeType: 'added', newValue: {} }
+          ] 
+        }
+      ],
+      serverDiffs: [],
+      securityDiffs: []
+    };
+
+    // Run all rules against this diffSet
+    const changes = runRules(diffSet, context);
+    
+    // Some endpoints may produce changes depending on the rule, but most will early return
+    expect(changes).toBeInstanceOf(Array);
+  });
+});

package/tests/types-errors.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { ApidiffError, LoadError, ParseError, RefError, ConfigError, FormatError } from '../src/types/errors.js';
+
+describe('Errors', () => {
+  it('instantiates correctly', () => {
+    const parseErr = new ParseError('Test error', 10, 20, 'file.yaml', new Error('cause'));
+    expect(parseErr.name).toBe('ParseError');
+    expect(parseErr.message).toBe('Test error');
+    expect(parseErr.line).toBe(10);
+    expect(parseErr.col).toBe(20);
+    expect(parseErr.filePath).toBe('file.yaml');
+
+    const refErr = new RefError('Test ref error', '#/test');
+    expect(refErr.name).toBe('RefError');
+    expect(refErr.message).toBe('Test ref error');
+    expect(refErr.ref).toBe('#/test');
+
+    expect(new LoadError('load').name).toBe('LoadError');
+    expect(new ConfigError('config').name).toBe('ConfigError');
+    expect(new FormatError('format').name).toBe('FormatError');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}