@redocly/openapi-core 1.0.0-beta.102 → 1.0.0-beta.105

package/src/decorators/common/filters/filter-in.ts

@@ -0,0 +1,18 @@
+import { Oas2Decorator, Oas3Decorator } from '../../../visitors';
+import { checkIfMatchByStrategy, filter } from './filter-helper';
+
+const DEFAULT_STRATEGY = 'any';
+
+export const FilterIn: Oas3Decorator | Oas2Decorator = ({ property, value, matchStrategy }) => {
+  const strategy = matchStrategy || DEFAULT_STRATEGY;
+  const filterInCriteria = (item: any) =>
+    item?.[property] && !checkIfMatchByStrategy(item?.[property], value, strategy);
+
+  return {
+    any: {
+      enter: (node, ctx) => {
+        filter(node, ctx, filterInCriteria);
+      },
+    },
+  };
+};

package/src/decorators/common/filters/filter-out.ts

@@ -0,0 +1,18 @@
+import { Oas2Decorator, Oas3Decorator } from '../../../visitors';
+import { checkIfMatchByStrategy, filter } from './filter-helper';
+
+const DEFAULT_STRATEGY = 'any';
+
+export const FilterOut: Oas3Decorator | Oas2Decorator = ({ property, value, matchStrategy }) => {
+  const strategy = matchStrategy || DEFAULT_STRATEGY;
+  const filterOutCriteria = (item: any) =>
+    checkIfMatchByStrategy(item?.[property], value, strategy);
+
+  return {
+    any: {
+      enter: (node, ctx) => {
+        filter(node, ctx, filterOutCriteria);
+      },
+    },
+  };
+};

package/src/decorators/oas2/index.ts

@@ -4,11 +4,15 @@ import { OperationDescriptionOverride } from '../common/operation-description-ov
 import { TagDescriptionOverride } from '../common/tag-description-override';
 import { InfoDescriptionOverride } from '../common/info-description-override';
 import { RemoveXInternal } from '../common/remove-x-internal';
+import { FilterIn } from '../common/filters/filter-in';
+import { FilterOut } from '../common/filters/filter-out';
 
 export const decorators = {
   'registry-dependencies': RegistryDependencies as Oas2Decorator,
   'operation-description-override': OperationDescriptionOverride as Oas2Decorator,
   'tag-description-override': TagDescriptionOverride as Oas2Decorator,
   'info-description-override': InfoDescriptionOverride as Oas2Decorator,
-  'remove-x-internal': RemoveXInternal as Oas2Decorator
+  'remove-x-internal': RemoveXInternal as Oas2Decorator,
+  'filter-in': FilterIn as Oas2Decorator,
+  'filter-out': FilterOut as Oas2Decorator,
 };

package/src/decorators/oas3/index.ts

@@ -4,11 +4,15 @@ import { OperationDescriptionOverride } from '../common/operation-description-ov
 import { TagDescriptionOverride } from '../common/tag-description-override';
 import { InfoDescriptionOverride } from '../common/info-description-override';
 import { RemoveXInternal } from '../common/remove-x-internal';
+import { FilterIn } from '../common/filters/filter-in';
+import { FilterOut } from '../common/filters/filter-out';
 
 export const decorators = {
   'registry-dependencies': RegistryDependencies as Oas3Decorator,
   'operation-description-override': OperationDescriptionOverride as Oas3Decorator,
   'tag-description-override': TagDescriptionOverride as Oas3Decorator,
   'info-description-override': InfoDescriptionOverride as Oas3Decorator,
-  'remove-x-internal': RemoveXInternal as Oas3Decorator
+  'remove-x-internal': RemoveXInternal as Oas3Decorator,
+  'filter-in': FilterIn as Oas3Decorator,
+  'filter-out': FilterOut as Oas3Decorator,
 };

package/src/index.ts

@@ -1,4 +1,4 @@
-export { BundleOutputFormat, readFileFromUrl, slash } from './utils';
+export { BundleOutputFormat, readFileFromUrl, slash, doesYamlFileExist } from './utils';
 export { Oas3_1Types } from './types/oas3_1';
 export { Oas3Types } from './types/oas3';
 export { Oas2Types } from './types/oas2';
@@ -33,6 +33,7 @@ export {
   getConfig,
   findConfig,
   CONFIG_FILE_NAMES,
+  RuleSeverity
 } from './config';
 
 

package/src/lint.ts

@@ -94,9 +94,10 @@ export async function lintDocument(opts: {
 }
 
 export async function lintConfig(opts: {
-  document: Document,
+  document: Document
+  severity?: ProblemSeverity 
 }) {
-  const { document } = opts;
+  const { document, severity } = opts;
 
   const ctx: WalkContext = {
     problems: [],
@@ -110,7 +111,7 @@ export async function lintConfig(opts: {
   });
 
   const types = normalizeTypes(ConfigTypes, config);
-  const rules = [{ severity: 'error' as ProblemSeverity, ruleId: 'spec', visitor: OasSpec({ severity: 'error' }) }];
+  const rules = [{ severity: severity || 'error', ruleId: 'configuration spec', visitor: OasSpec({ severity: 'error' }) }];
   const normalizedVisitors = normalizeVisitors(rules, types);
 
   walkDocument({

package/src/redocly/registry-api-types.ts

@@ -17,6 +17,8 @@ export namespace RegistryApiTypes {
     branch?: string;
     isUpsert?: boolean;
     isPublic?: boolean;
+    batchId?: string;
+    batchSize?: number;
   }
 
   export interface PrepareFileuploadOKResponse {

package/src/redocly/registry-api.ts

@@ -105,6 +105,8 @@ export class RegistryApi {
     branch,
     isUpsert,
     isPublic,
+    batchId,
+    batchSize
   }: RegistryApiTypes.PushApiParams) {
     const response = await this.request(
       `/${organizationId}/${name}/${version}`,
@@ -120,6 +122,8 @@ export class RegistryApi {
           branch,
           isUpsert,
           isPublic,
+          batchId,
+          batchSize
         }),
       },
       this.region,

package/src/rules/ajv.ts

@@ -8,7 +8,7 @@ export function releaseAjvInstance() {
   ajvInstance = null;
 }
 
-function getAjv(resolve: ResolveFn<any>, disallowAdditionalProperties: boolean) {
+function getAjv(resolve: ResolveFn, disallowAdditionalProperties: boolean) {
   if (!ajvInstance) {
     ajvInstance = new Ajv({
       schemaId: '$id',
@@ -23,7 +23,7 @@ function getAjv(resolve: ResolveFn<any>, disallowAdditionalProperties: boolean)
       defaultAdditionalProperties: !disallowAdditionalProperties,
       loadSchemaSync(base: string, $ref: string) {
         const resolvedRef = resolve({ $ref }, base.split('#')[0]);
-        if (!resolvedRef || !resolvedRef.location) return undefined;
+        if (!resolvedRef || !resolvedRef.location) return false;
         return { $id: resolvedRef.location.absolutePointer, ...resolvedRef.node };
       },
       logger: false,
@@ -35,7 +35,7 @@ function getAjv(resolve: ResolveFn<any>, disallowAdditionalProperties: boolean)
 function getAjvValidator(
   schema: any,
   loc: Location,
-  resolve: ResolveFn<any>,
+  resolve: ResolveFn,
   disallowAdditionalProperties: boolean,
 ): ValidateFunction | undefined {
   const ajv = getAjv(resolve, disallowAdditionalProperties);
@@ -52,7 +52,7 @@ export function validateJsonSchema(
   schema: any,
   schemaLoc: Location,
   instancePath: string,
-  resolve: ResolveFn<any>,
+  resolve: ResolveFn,
   disallowAdditionalProperties: boolean,
 ): { valid: boolean; errors: (ErrorObject & { suggest?: string[] })[] } {
   const validate = getAjvValidator(schema, schemaLoc, resolve, disallowAdditionalProperties);

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

@@ -1,5 +1,9 @@
+import { Location } from '../../../../ref-utils';
+import { Source } from '../../../../resolve';
 import { asserts } from '../asserts';
 
+let baseLocation = new Location(jest.fn() as any as Source, 'pointer');
+
 describe('oas3 assertions', () => {
   describe('generic rules', () => {
     const fakeNode = {
@@ -10,232 +14,231 @@ describe('oas3 assertions', () => {
 
     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();
+        expect(asserts.pattern('test string', '/test/', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.pattern('test string', '/test me/', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.pattern(['test string', 'test me'], '/test/', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.pattern(['test string', 'test me'], '/test me/', baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.pattern('./components/smth/test.yaml', '/^(./)?components/.*.yaml$/', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.pattern('./other.yaml', '/^(./)?components/.*.yaml$/', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+      });
+    });
+
+    describe('ref', () => {
+      it('value should have ref', () => {
+        expect(asserts.ref({ $ref: 'text' }, true, baseLocation, { $ref: 'text' })).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.ref({}, true, baseLocation, {})).toEqual({ isValid: false, location: baseLocation.key() });
+      });
+
+      it('value should not have ref', () => {
+        expect(asserts.ref({ $ref: 'text' }, false, baseLocation, { $ref: 'text' })).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.ref({}, false, baseLocation, {})).toEqual({ isValid: true, location: baseLocation.key() });
+      });
+
+      it('value should match regex pattern', () => {
+        expect(asserts.ref({ $ref: 'test string' }, '/test/', baseLocation, { $ref: 'test string' })).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.ref({ $ref: 'test string' }, '/test me/', baseLocation, { $ref: 'test string' })).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.ref({ $ref: './components/smth/test.yaml' }, '/^(./)?components/.*.yaml$/', baseLocation, { $ref: './components/smth/test.yaml' })).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.ref({ $ref: './paths/smth/test.yaml' }, '/^(./)?components/.*.yaml$/', baseLocation, { $ref: './paths/smth/test.yaml' })).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     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();
+        expect(asserts.enum('test', ['test', 'example'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.enum(['test'], ['test', 'example'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.enum(['test', 'example'], ['test', 'example'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.enum(['test', 'example', 'foo'], ['test', 'example'], baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo').key() });
+        expect(asserts.enum('test', ['foo', 'example'], baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.enum(['test', 'foo'], ['test', 'example'], baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo').key() });
       });
     });
 
     describe('defined', () => {
       it('value should be defined', () => {
-        expect(asserts.defined('test', true)).toBeTruthy();
-        expect(asserts.defined(undefined, true)).toBeFalsy();
+        expect(asserts.defined('test', true, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.defined(undefined, true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be undefined', () => {
-        expect(asserts.defined(undefined, false)).toBeTruthy();
-        expect(asserts.defined('test', false)).toBeFalsy();
+        expect(asserts.defined(undefined, false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.defined('test', false, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     describe('undefined', () => {
       it('value should be undefined', () => {
-        expect(asserts.undefined(undefined, true)).toBeTruthy();
-        expect(asserts.undefined('test', true)).toBeFalsy();
+        expect(asserts.undefined(undefined, true, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.undefined('test', true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       it('value should be defined', () => {
-        expect(asserts.undefined('test', false)).toBeTruthy();
-        expect(asserts.undefined(undefined, false)).toBeFalsy();
+        expect(asserts.undefined('test', false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.undefined(undefined, false, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     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();
+        expect(asserts.required(['one', 'two', 'three'], ['one', 'two'], baseLocation)).toEqual({ isValid: true });
+        expect(asserts.required(['one', 'two'], ['one', 'two', 'three'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
       });
     });
 
     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();
+        expect(asserts.nonEmpty('test', true, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty('', true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.nonEmpty(null, true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.nonEmpty(undefined, true, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.nonEmpty('', false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty(null, false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty(undefined, false, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.nonEmpty('test', false, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     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();
+        expect(asserts.minLength('test', 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.minLength([1, 2, 3, 4], 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.minLength([1, 2, 3, 4, 5], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.minLength([1, 2, 3, 4, 5, 6], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.minLength('example', 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.minLength([], 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.minLength('', 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     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();
+        expect(asserts.maxLength('test', 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength([1, 2, 3, 4], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength([1, 2, 3, 4, 5], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength([1, 2, 3, 4, 5, 6], 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.maxLength('example', 5, baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.maxLength([], 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.maxLength('', 5, baseLocation)).toEqual({ isValid: true, location: baseLocation });
       });
     });
 
     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();
+        expect(asserts.casing(['testExample', 'fooBar'], 'camelCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['testExample', 'FooBar'], 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('FooBar').key() });
+        expect(asserts.casing('testExample', 'camelCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing('TestExample', 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test_example', 'camelCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.casing('TestExample', 'PascalCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TestExample', 'FooBar'], 'PascalCase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TestExample', 'fooBar'], 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('fooBar').key() });
+        expect(asserts.casing('testExample', 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test_example', 'PascalCase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.casing('test-example', 'kebab-case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test-example', 'foo-bar'], 'kebab-case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test-example', 'foo_bar'], 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo_bar').key() });
+        expect(asserts.casing('testExample', 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test_example', 'kebab-case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.casing('test_example', 'snake_case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test_example', 'foo_bar'], 'snake_case', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['test_example', 'foo-bar'], 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo-bar').key() });
+        expect(asserts.casing('testExample', 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'snake_case', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.casing('TEST_EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO_BAR'], 'MACRO_CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST_EXAMPLE', 'FOO-BAR'], 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('FOO-BAR').key() });
+        expect(asserts.casing('TEST_EXAMPLE_', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('_TEST_EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST__EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST-EXAMPLE', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('testExample', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'MACRO_CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.casing('TEST-EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO-BAR'], 'COBOL-CASE', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['TEST-EXAMPLE', 'FOO_BAR'], 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('FOO_BAR').key() });
+        expect(asserts.casing('TEST-EXAMPLE-', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('0TEST-EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('-TEST-EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST--EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TEST_EXAMPLE', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('testExample', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'COBOL-CASE', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.casing('testexample', 'flatcase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['testexample', 'foobar'], 'flatcase', baseLocation)).toEqual({ isValid: true });
+        expect(asserts.casing(['testexample', 'foo_bar'], 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation.child('foo_bar').key() });
+        expect(asserts.casing('testexample_', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('0testexample', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('testExample', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('TestExample', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.casing('test-example', 'flatcase', baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     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();
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'asc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'foo', 'test'], { direction: 'asc' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example'], 'asc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'asc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'foo', 'test'], 'desc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], { direction: 'asc', property: 'name' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'bar' }, { name: 'baz' }, { name: 'foo' }], { direction: 'desc', property: 'name' }, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
       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();
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'desc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['test', 'foo', 'example'], { direction: 'desc' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example'], 'desc', baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder(['example', 'test', 'foo'], 'desc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder(['test', 'foo', 'example'], 'asc', baseLocation)).toEqual({ isValid: false, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], { direction: 'desc', property: 'name' }, baseLocation)).toEqual({ isValid: true, location: baseLocation });
+        expect(asserts.sortOrder([{ name: 'foo' }, { name: 'baz' }, { name: 'bar' }], { direction: 'asc', property: 'name' }, baseLocation)).toEqual({ isValid: false, location: baseLocation });
       });
     });
 
     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();
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'test'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), [], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.mutuallyExclusive(Object.keys(fakeNode), ['foo', 'bar', 'test'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
       });
     });
 
     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();
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'baz'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), [], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'test'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.mutuallyRequired(Object.keys(fakeNode), ['foo', 'bar', 'test'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
       });
     });
 
     describe('requireAny', () => {
       it('node must have at least one property from predefined list', () => {
-        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'test'])).toBeTruthy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'bar'])).toBeTruthy();
-        expect(asserts.requireAny(Object.keys(fakeNode), [])).toBeFalsy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'test1'])).toBeFalsy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar'])).toBeTruthy();
-        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar', 'test'])).toBeTruthy();
+        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'test'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'bar'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), [], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['test', 'test1'], baseLocation)).toEqual({ isValid: false, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
+        expect(asserts.requireAny(Object.keys(fakeNode), ['foo', 'bar', 'test'], baseLocation)).toEqual({ isValid: true, location: baseLocation.key() });
       });
     });
   });