@redocly/openapi-core 1.0.0-beta.98 → 1.0.0-rc.1

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

@@ -1,231 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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/redocly-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;
-};