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

package/src/redocly/registry-api.ts

@@ -22,28 +22,43 @@ export class RegistryApi {
 
   private async request(path = '', options: RequestInit = {}, region?: Region) {
     const headers = Object.assign({}, options.headers || {}, { 'x-redocly-cli-version': version });
-    if (!headers.hasOwnProperty('authorization')) { throw new Error('Unauthorized'); }
+
+    if (!headers.hasOwnProperty('authorization')) {
+      throw new Error('Unauthorized');
+    }
+
     const response = await fetch(
       `${this.getBaseUrl(region)}${path}`,
       Object.assign({}, options, { headers }),
     );
-    if (response.status === 401) { throw new Error('Unauthorized'); }
+
+    if (response.status === 401) {
+      throw new Error('Unauthorized');
+    }
+
     if (response.status === 404) {
       const body: RegistryApiTypes.NotFoundProblemResponse = await response.json();
       throw new Error(body.code);
     }
+
     return response;
   }
 
-  async authStatus(accessToken: string, region: Region, verbose = false) {
+  async authStatus(
+    accessToken: string,
+    region: Region,
+    verbose = false,
+  ): Promise<{ viewerId: string; organizations: string[] }> {
     try {
-      const response = await this.request('', { headers: { authorization: accessToken }}, region);
-      return response.ok;
+      const response = await this.request('', { headers: { authorization: accessToken } }, region);
+
+      return await response.json();
     } catch (error) {
       if (verbose) {
         console.log(error);
       }
-      return false;
+
+      throw error;
     }
   }
 
@@ -69,7 +84,7 @@ export class RegistryApi {
           isUpsert,
         }),
       },
-      this.region
+      this.region,
     );
 
     if (response.ok) {
@@ -88,20 +103,22 @@ export class RegistryApi {
     branch,
     isUpsert,
   }: RegistryApiTypes.PushApiParams) {
-    const response = await this.request(`/${organizationId}/${name}/${version}`, {
-      method: 'PUT',
-      headers: {
-        'content-type': 'application/json',
-        authorization: this.accessToken
-      } as HeadersInit,
-      body: JSON.stringify({
-        rootFilePath,
-        filePaths,
-        branch,
-        isUpsert,
-      }),
-    },
-      this.region
+    const response = await this.request(
+      `/${organizationId}/${name}/${version}`,
+      {
+        method: 'PUT',
+        headers: {
+          'content-type': 'application/json',
+          authorization: this.accessToken,
+        } as HeadersInit,
+        body: JSON.stringify({
+          rootFilePath,
+          filePaths,
+          branch,
+          isUpsert,
+        }),
+      },
+      this.region,
     );
 
     if (response.ok) {

package/src/ref-utils.ts

@@ -60,7 +60,7 @@ export function pointerBaseName(pointer: string) {
 
 export function refBaseName(ref: string) {
   const parts = ref.split(/[\/\\]/); // split by '\' and '/'
-  return parts[parts.length - 1].split('.')[0];
+  return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
 }
 
 export function isAbsoluteUrl(ref: string) {

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;
+  },
+};