@redocly/openapi-core 1.0.0-beta.91 → 1.0.0-beta.92

package/src/rules/common/assertions/__tests__/asserts.test.ts

@@ -0,0 +1,231 @@
+import { asserts } from '../asserts';
+
+describe('oas3 assertions', () => {
+  describe('generic rules', () => {
+    const fakeNode = {
+      foo: '',
+      bar: '',
+      baz: '',
+    };
+
+    describe('pattern', () => {
+      it('value should match regex pattern', () => {
+        expect(asserts.pattern('test string', '/test/')).toBeTruthy();
+        expect(asserts.pattern('test string', '/test me/')).toBeFalsy();
+        expect(asserts.pattern(['test string', 'test me'], '/test/')).toBeTruthy();
+        expect(asserts.pattern(['test string', 'test me'], '/test me/')).toBeFalsy();
+      });
+    });
+
+    describe('enum', () => {
+      it('value should be among predefined keys', () => {
+        expect(asserts.enum('test', ['test', 'example'])).toBeTruthy();
+        expect(asserts.enum(['test'], ['test', 'example'])).toBeTruthy();
+        expect(asserts.enum(['test', 'example'], ['test', 'example'])).toBeTruthy();
+        expect(asserts.enum(['test', 'example', 'foo'], ['test', 'example'])).toBeFalsy();
+        expect(asserts.enum('test', ['foo', 'example'])).toBeFalsy();
+        expect(asserts.enum(['test', 'foo'], ['test', 'example'])).toBeFalsy();
+      });
+    });
+
+    describe('defined', () => {
+      it('value should be defined', () => {
+        expect(asserts.defined('test', true)).toBeTruthy();
+        expect(asserts.defined(undefined, true)).toBeFalsy();
+      });
+      it('value should be undefined', () => {
+        expect(asserts.defined(undefined, false)).toBeTruthy();
+        expect(asserts.defined('test', false)).toBeFalsy();
+      });
+    });
+
+    describe('undefined', () => {
+      it('value should be undefined', () => {
+        expect(asserts.undefined(undefined, true)).toBeTruthy();
+        expect(asserts.undefined('test', true)).toBeFalsy();
+      });
+      it('value should be defined', () => {
+        expect(asserts.undefined('test', false)).toBeTruthy();
+        expect(asserts.undefined(undefined, false)).toBeFalsy();
+      });
+    });
+
+    describe('required', () => {
+      it('values should be required', () => {
+        expect(asserts.required(['one', 'two', 'three'], ['one', 'two'])).toBeTruthy();
+        expect(asserts.required(['one', 'two'], ['one', 'two', 'three'])).toBeFalsy();
+      });
+    });
+
+    describe('nonEmpty', () => {
+      it('value should not be empty', () => {
+        expect(asserts.nonEmpty('test', true)).toBeTruthy();
+        expect(asserts.nonEmpty('', true)).toBeFalsy();
+        expect(asserts.nonEmpty(null, true)).toBeFalsy();
+        expect(asserts.nonEmpty(undefined, true)).toBeFalsy();
+      });
+      it('value should be empty', () => {
+        expect(asserts.nonEmpty('', false)).toBeTruthy();
+        expect(asserts.nonEmpty(null, false)).toBeTruthy();
+        expect(asserts.nonEmpty(undefined, false)).toBeTruthy();
+        expect(asserts.nonEmpty('test', false)).toBeFalsy();
+      });
+    });
+
+    describe('minLength', () => {
+      it('value should have less or equal than 5 symbols length', () => {
+        expect(asserts.minLength('test', 5)).toBeFalsy();
+        expect(asserts.minLength([1, 2, 3, 4], 5)).toBeFalsy();
+        expect(asserts.minLength([1, 2, 3, 4, 5], 5)).toBeTruthy();
+        expect(asserts.minLength([1, 2, 3, 4, 5, 6], 5)).toBeTruthy();
+        expect(asserts.minLength('example', 5)).toBeTruthy();
+        expect(asserts.minLength([], 5)).toBeFalsy();
+        expect(asserts.minLength('', 5)).toBeFalsy();
+      });
+    });
+
+    describe('maxLength', () => {
+      it('value should have more or equal than 5 symbols length', () => {
+        expect(asserts.maxLength('test', 5)).toBeTruthy();
+        expect(asserts.maxLength([1, 2, 3, 4], 5)).toBeTruthy();
+        expect(asserts.maxLength([1, 2, 3, 4, 5], 5)).toBeTruthy();
+        expect(asserts.maxLength([1, 2, 3, 4, 5, 6], 5)).toBeFalsy();
+        expect(asserts.maxLength('example', 5)).toBeFalsy();
+        expect(asserts.maxLength([], 5)).toBeTruthy();
+        expect(asserts.maxLength('', 5)).toBeTruthy();
+      });
+    });
+
+    describe('casing', () => {
+      it('value should be camelCase', () => {
+        expect(asserts.casing(['testExample', 'fooBar'], 'camelCase')).toBeTruthy();
+        expect(asserts.casing(['testExample', 'FooBar'], 'camelCase')).toBeFalsy();
+        expect(asserts.casing('testExample', 'camelCase')).toBeTruthy();
+        expect(asserts.casing('TestExample', 'camelCase')).toBeFalsy();
+        expect(asserts.casing('test-example', 'camelCase')).toBeFalsy();
+        expect(asserts.casing('test_example', 'camelCase')).toBeFalsy();
+      });
+      it('value should be PascalCase', () => {
+        expect(asserts.casing('TestExample', 'PascalCase')).toBeTruthy();
+        expect(asserts.casing(['TestExample', 'FooBar'], 'PascalCase')).toBeTruthy();
+        expect(asserts.casing(['TestExample', 'fooBar'], 'PascalCase')).toBeFalsy();
+        expect(asserts.casing('testExample', 'PascalCase')).toBeFalsy();
+        expect(asserts.casing('test-example', 'PascalCase')).toBeFalsy();
+        expect(asserts.casing('test_example', 'PascalCase')).toBeFalsy();
+      });
+      it('value should be kebab-case', () => {
+        expect(asserts.casing('test-example', 'kebab-case')).toBeTruthy();
+        expect(asserts.casing(['test-example', 'foo-bar'], 'kebab-case')).toBeTruthy();
+        expect(asserts.casing(['test-example', 'foo_bar'], 'kebab-case')).toBeFalsy();
+        expect(asserts.casing('testExample', 'kebab-case')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'kebab-case')).toBeFalsy();
+        expect(asserts.casing('test_example', 'kebab-case')).toBeFalsy();
+      });
+      it('value should be snake_case', () => {
+        expect(asserts.casing('test_example', 'snake_case')).toBeTruthy();
+        expect(asserts.casing(['test_example', 'foo_bar'], 'snake_case')).toBeTruthy();
+        expect(asserts.casing(['test_example', 'foo-bar'], 'snake_case')).toBeFalsy();
+        expect(asserts.casing('testExample', 'snake_case')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'snake_case')).toBeFalsy();
+        expect(asserts.casing('test-example', 'snake_case')).toBeFalsy();
+      });
+      it('value should be MACRO_CASE', () => {
+        expect(asserts.casing('TEST_EXAMPLE', 'MACRO_CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO_BAR'], 'MACRO_CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO-BAR'], 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TEST_EXAMPLE_', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('_TEST_EXAMPLE', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TEST__EXAMPLE', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TEST-EXAMPLE', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('testExample', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'MACRO_CASE')).toBeFalsy();
+        expect(asserts.casing('test-example', 'MACRO_CASE')).toBeFalsy();
+      });
+      it('value should be COBOL-CASE', () => {
+        expect(asserts.casing('TEST-EXAMPLE', 'COBOL-CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO-BAR'], 'COBOL-CASE')).toBeTruthy();
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO_BAR'], 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TEST-EXAMPLE-', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('0TEST-EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('-TEST-EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TEST--EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TEST_EXAMPLE', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('testExample', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'COBOL-CASE')).toBeFalsy();
+        expect(asserts.casing('test-example', 'COBOL-CASE')).toBeFalsy();
+      });
+      it('value should be flatcase', () => {
+        expect(asserts.casing('testexample', 'flatcase')).toBeTruthy();
+        expect(asserts.casing(['testexample', 'foobar'], 'flatcase')).toBeTruthy();
+        expect(asserts.casing(['testexample', 'foo_bar'], 'flatcase')).toBeFalsy();
+        expect(asserts.casing('testexample_', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('0testexample', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('testExample', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('TestExample', 'flatcase')).toBeFalsy();
+        expect(asserts.casing('test-example', 'flatcase')).toBeFalsy();
+      });
+    });
+
+    describe.skip('sortOrder', () => {
+      it('value should be ordered in ASC direction', () => {
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'asc')).toBeTruthy();
+        expect(asserts.sortOrder(['example', 'foo', 'test'], { direction: 'asc' })).toBeTruthy();
+        expect(asserts.sortOrder(['example'], 'asc')).toBeTruthy();
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'asc')).toBeFalsy();
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'desc')).toBeFalsy();
+        expect(
+          asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], {
+            direction: 'asc',
+            property: 'name',
+          }),
+        ).toBeTruthy();
+        expect(
+          asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], {
+            direction: 'desc',
+            property: 'name',
+          }),
+        ).toBeFalsy();
+      });
+      it('value should be ordered in DESC direction', () => {
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'desc')).toBeTruthy();
+        expect(asserts.sortOrder(['test', 'foo', 'example'], { direction: 'desc' })).toBeTruthy();
+        expect(asserts.sortOrder(['example'], 'desc')).toBeTruthy();
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'desc')).toBeFalsy();
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'asc')).toBeFalsy();
+        expect(
+          asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], {
+            direction: 'desc',
+            property: 'name',
+          }),
+        ).toBeTruthy();
+        expect(
+          asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], {
+            direction: 'asc',
+            property: 'name',
+          }),
+        ).toBeFalsy();
+      });
+    });
+
+    describe('mutuallyExclusive', () => {
+      it('node should not have more than one property from predefined list', () => {
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'test'])).toBeTruthy();
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), [])).toBeTruthy();
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar'])).toBeFalsy();
+        expect(
+          asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar', 'test']),
+        ).toBeFalsy();
+      });
+    });
+
+    describe('mutuallyRequired', () => {
+      it('node should have all the properties from predefined list', () => {
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar'])).toBeTruthy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'baz'])).toBeTruthy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), [])).toBeTruthy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'test'])).toBeFalsy();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'test'])).toBeFalsy();
+      });
+    });
+  });
+});

package/src/rules/common/assertions/__tests__/index.test.ts

@@ -0,0 +1,65 @@
+import { Assertions } from '../.';
+
+const opts = {
+  '0': {
+    subject: 'Operation',
+    property: 'summary',
+    description: 'example warn text',
+    severity: 'warn',
+    pattern: '/example/',
+  },
+  '1': {
+    subject: 'PathItem',
+    context: [{ type: 'Operation', matchParentKeys: ['post'] }],
+    description: 'example warn text',
+    severity: 'warn',
+    mutuallyExclusive: ['summary', 'security'],
+  },
+  '2': {
+    subject: ['PathItem'],
+    context: [{ type: 'Operation' }],
+    property: 'tags',
+    description: 'example warn text',
+    severity: 'warn',
+    sortOrder: 'desc',
+  },
+  '3': {
+    subject: ['Foo'],
+    context: [{ type: 'Bar' }, { type: 'Baz' }],
+    property: 'test',
+    description: 'example warn text',
+    severity: 'warn',
+    sortOrder: 'desc',
+  },
+};
+
+describe('Oas3 assertions', () => {
+  it('should return the right visitor structure', () => {
+    const visitors = Assertions(opts) as any;
+    expect(visitors).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "Operation": [Function],
+        },
+        Object {
+          "Operation": Object {
+            "PathItem": [Function],
+            "skip": [Function],
+          },
+        },
+        Object {
+          "Operation": Object {
+            "PathItem": [Function],
+          },
+        },
+        Object {
+          "Bar": Object {
+            "Baz": Object {
+              "Foo": [Function],
+            },
+          },
+        },
+      ]
+    `);
+  });
+});

package/src/rules/common/assertions/__tests__/utils.test.ts

@@ -0,0 +1,89 @@
+import { isOrdered, buildVisitorObject, getIntersectionLength } from '../utils';
+
+describe('Oas3 assertions', () => {
+  describe('Utils', () => {
+    describe('getCounts', () => {
+      it('should return the right counts', () => {
+        const arr = ['foo', 'bar', 'baz'];
+        expect(getIntersectionLength(arr, ['foo'])).toBe(1);
+        expect(getIntersectionLength(arr, ['foo', 'bar', 'baz'])).toBe(3);
+        expect(getIntersectionLength(arr, ['foo', 'test', 'baz'])).toBe(2);
+        expect(getIntersectionLength(arr, ['example', 'test'])).toBe(0);
+      });
+    });
+
+    describe('isOrdered', () => {
+      it('should say if array is ordered or not in specific direction', () => {
+        expect(isOrdered(['example', 'foo', 'test'], 'asc')).toBeTruthy();
+        expect(isOrdered(['example'], 'asc')).toBeTruthy();
+        expect(isOrdered(['test', 'foo', 'example'], 'desc')).toBeTruthy();
+        expect(isOrdered(['example'], 'desc')).toBeTruthy();
+        expect(isOrdered(['example', 'test', 'foo'], 'asc')).toBeFalsy();
+        expect(isOrdered(['example', 'foo', 'test'], 'desc')).toBeFalsy();
+      });
+    });
+
+    describe('buildVisitorObject', () => {
+      it('should return a consistent visitor structure', () => {
+        const context = [
+          {
+            type: 'Foo',
+            matchParentKeys: ['test'],
+          },
+          {
+            type: 'Bar',
+            matchParentKeys: ['test'],
+          },
+          {
+            type: 'Roof',
+            matchParentKeys: ['test'],
+          },
+        ];
+
+        const visitors = buildVisitorObject('Bar', context, () => {}) as any;
+
+        expect(visitors).toMatchInlineSnapshot(`
+          Object {
+            "Foo": Object {
+              "Bar": Object {
+                "Roof": Object {
+                  "Bar": [Function],
+                  "skip": [Function],
+                },
+                "skip": [Function],
+              },
+              "skip": [Function],
+            },
+          }
+        `);
+      });
+
+      it('should return the right visitor structure', () => {
+        const context = [
+          {
+            type: 'Operation',
+            matchParentKeys: ['put'],
+          },
+          {
+            type: 'ResponsesMap',
+            matchParentKeys: [201, 200],
+          },
+        ];
+
+        const visitors = buildVisitorObject('MediaTypeMap', context, () => {}) as any;
+
+        expect(visitors).toMatchInlineSnapshot(`
+          Object {
+            "Operation": Object {
+              "ResponsesMap": Object {
+                "MediaTypeMap": [Function],
+                "skip": [Function],
+              },
+              "skip": [Function],
+            },
+          }
+        `);
+      });
+    });
+  });
+});

package/src/rules/common/assertions/asserts.ts

@@ -0,0 +1,137 @@
+import { OrderOptions, OrderDirection, isOrdered, getIntersectionLength } from './utils';
+
+type Asserts = Record<string, (value: any, condition: any) => boolean>;
+
+export const runOnKeysSet = new Set([
+  'mutuallyExclusive',
+  'mutuallyRequired',
+  'enum',
+  'pattern',
+  'minLength',
+  'maxLength',
+  'casing',
+  'sortOrder',
+  'disallowed',
+  'required',
+]);
+export const runOnValuesSet = new Set([
+  'pattern',
+  'enum',
+  'defined',
+  'undefined',
+  'nonEmpty',
+  'minLength',
+  'maxLength',
+  'casing',
+  'sortOrder',
+]);
+
+export const asserts: Asserts = {
+  pattern: (value: string | string[], condition: string): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    const values = typeof value === 'string' ? [value] : value;
+    const regexOptions = condition.match(/(\b\/\b)(.+)/g) || ['/'];
+    condition = condition.slice(1).replace(regexOptions[0], '');
+    const regx = new RegExp(condition, regexOptions[0].slice(1));
+    for (let _val of values) {
+      if (!_val.match(regx)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  enum: (value: string | string[], condition: string[]): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    const values = typeof value === 'string' ? [value] : value;
+    for (let _val of values) {
+      if (!condition.includes(_val)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  defined: (value: string | undefined, condition: boolean = true): boolean => {
+    const isDefined = typeof value !== 'undefined';
+    return condition ? isDefined : !isDefined;
+  },
+  required: (value: string[], keys: string[]): boolean => {
+    for (const requiredKey of keys) {
+      if (!value.includes(requiredKey)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  disallowed: (value: string | string[], condition: string[]): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    const values = typeof value === 'string' ? [value] : value;
+    for (let _val of values) {
+      if (condition.includes(_val)) {
+        return false;
+      }
+    }
+    return true;
+  },
+  undefined: (value: any, condition: boolean = true): boolean => {
+    const isUndefined = typeof value === 'undefined';
+    return condition ? isUndefined : !isUndefined;
+  },
+  nonEmpty: (value: string | undefined | null, condition: boolean = true): boolean => {
+    const isEmpty = typeof value === 'undefined' || value === null || value === '';
+    return condition ? !isEmpty : isEmpty;
+  },
+  minLength: (value: string | any[], condition: number): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    return value.length >= condition;
+  },
+  maxLength: (value: string | any[], condition: number): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    return value.length <= condition;
+  },
+  casing: (value: string | string[], condition: string): boolean => {
+    if (typeof value === 'undefined') return true; // property doesn't exist, no need to lint it with this assert
+    const values = typeof value === 'string' ? [value] : value;
+    for (let _val of values) {
+      let matchCase = false;
+      switch (condition) {
+        case 'camelCase':
+          matchCase = !!_val.match(/^[a-z][a-zA-Z0-9]+$/g);
+          break;
+        case 'kebab-case':
+          matchCase = !!_val.match(/^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g);
+          break;
+        case 'snake_case':
+          matchCase = !!_val.match(/^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g);
+          break;
+        case 'PascalCase':
+          matchCase = !!_val.match(/^[A-Z][a-zA-Z0-9]+$/g);
+          break;
+        case 'MACRO_CASE':
+          matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g);
+          break;
+        case 'COBOL-CASE':
+          matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g);
+          break;
+        case 'flatcase':
+          matchCase = !!_val.match(/^[a-z][a-z0-9]+$/g);
+          break;
+      }
+      if (!matchCase) {
+        return false;
+      }
+    }
+    return true;
+  },
+  sortOrder: (value: any[], condition: OrderOptions | OrderDirection): boolean => {
+    if (typeof value === 'undefined') return true;
+    return isOrdered(value, condition);
+  },
+  mutuallyExclusive: (value: string[], condition: string[]): boolean => {
+    return getIntersectionLength(value, condition) < 2;
+  },
+  mutuallyRequired: (value: string[], condition: string[]): boolean => {
+    return getIntersectionLength(value, condition) > 0
+      ? getIntersectionLength(value, condition) === condition.length
+      : true;
+  },
+};

package/src/rules/common/assertions/index.ts

@@ -0,0 +1,75 @@
+import { asserts, runOnKeysSet, runOnValuesSet } from './asserts';
+import { AssertToApply, buildSubjectVisitor, buildVisitorObject } from './utils';
+import { Oas2Rule, Oas3Rule } from '../../../visitors';
+
+export const Assertions: Oas3Rule | Oas2Rule = (opts: object) => {
+  let visitors: any[] = [];
+
+  // As 'Assertions' has an array of asserts,
+  // that array spreads into an 'opts' object on init rules phase here
+  // https://github.com/Redocly/openapi-cli/blob/master/packages/core/src/config/config.ts#L311
+  // that is why we need to iterate through 'opts' values;
+  // before - filter only object 'opts' values
+  const assertions: any[] = Object.values(opts).filter(
+    (opt: unknown) => typeof opt === 'object' && opt !== null,
+  );
+
+  for (const [index, assertion] of assertions.entries()) {
+    const assertId =
+      (assertion.assertionId && `${assertion.assertionId} assertion`) || `assertion #${index + 1}`;
+
+    if (!assertion.subject) {
+      throw new Error(`${assertId}: 'subject' is required`);
+    }
+
+    const subjects: string[] = Array.isArray(assertion.subject)
+      ? assertion.subject
+      : [assertion.subject];
+
+    const assertsToApply: AssertToApply[] = Object.keys(asserts)
+      .filter((assertName: string) => assertion[assertName] !== undefined)
+      .map((assertName: string) => {
+        return {
+          assertId,
+          name: assertName,
+          conditions: assertion[assertName],
+          message: assertion.message,
+          severity: assertion.severity || 'error',
+          suggest: assertion.suggest || [],
+          runsOnKeys: runOnKeysSet.has(assertName),
+          runsOnValues: runOnValuesSet.has(assertName),
+        };
+      });
+
+    const shouldRunOnKeys: AssertToApply | undefined = assertsToApply.find(
+      (assert: AssertToApply) => assert.runsOnKeys && !assert.runsOnValues,
+    );
+    const shouldRunOnValues: AssertToApply | undefined = assertsToApply.find(
+      (assert: AssertToApply) => assert.runsOnValues && !assert.runsOnKeys,
+    );
+
+    if (shouldRunOnValues && !assertion.property) {
+      throw new Error(
+        `${shouldRunOnValues.name} can't be used on all keys. Please provide a single property.`,
+      );
+    }
+
+    if (shouldRunOnKeys && assertion.property) {
+      throw new Error(
+        `${shouldRunOnKeys.name} can't be used on a single property. Please use 'property'.`,
+      );
+    }
+
+    for (const subject of subjects) {
+      const subjectVisitor = buildSubjectVisitor(
+        assertion.property,
+        assertsToApply,
+        assertion.context,
+      );
+      const visitorObject = buildVisitorObject(subject, assertion.context, subjectVisitor);
+      visitors.push(visitorObject);
+    }
+  }
+
+  return visitors;
+};