chore(ruleset): improve then validation

.editorconfig

@@ -3,7 +3,7 @@ root = true
 [*]
 charset = utf-8
 
-[*.{ts,js,yaml,scenario,md}]
+[*.{ts,js,yaml,yml,json,scenario,md}]
 indent_style = space
 indent_size = 2
 

karma-jest.ts

@@ -29,3 +29,6 @@ test.each = input => (name: string, fn: Function) => {
     }
   }
 };
+
+// @ts-ignore
+describe.each = test.each;

src/__tests__/linter.jest.test.ts

@@ -10,7 +10,7 @@ import { httpAndFileResolver } from '../resolvers/http-and-file';
 import { readRuleset } from '../rulesets';
 import { setFunctionContext } from '../rulesets/evaluators';
 import oasDocumentSchema from '../rulesets/oas/functions/oasDocumentSchema';
-import { Spectral } from '../spectral';
+import { IFunctionResult, Spectral } from '../spectral';
 import { IRuleset, RulesetExceptionCollection } from '../types/ruleset';
 
 const customFunctionOASRuleset = path.join(__dirname, './__fixtures__/custom-functions-oas-ruleset.json');
@@ -257,7 +257,7 @@ console.log(this.cache.get('test') || this.cache.set('test', []).get('test'));
       it('should handle basic example', async () => {
         spectral.setFunctions({
           [fnName]() {
-            return new Promise(resolve => {
+            return new Promise<IFunctionResult[]>(resolve => {
               setTimeout(resolve, 200, [
                 {
                   message: 'Error reported by async fn',
@@ -289,7 +289,7 @@ console.log(this.cache.get('test') || this.cache.set('test', []).get('test'));
       it('should handle rejections', async () => {
         spectral.setFunctions({
           [fnName]() {
-            return new Promise((resolve, reject) => {
+            return new Promise<void>((resolve, reject) => {
               setTimeout(reject, 1000, new Error('Some unknown error'));
             });
           },

src/__tests__/linter.test.ts

@@ -60,7 +60,7 @@ describe('linter', () => {
     const message = '4xx responses require a description';
 
     spectral.setFunctions({
-      func1: val => {
+      func1: (val: unknown) => {
         if (!val) {
           return [
             {

src/functions/__tests__/casing.test.ts

@@ -1,4 +1,3 @@
-import { AssertionError } from 'assert';
 import { casing, CasingType } from '../casing';
 
 function runCasing(target: unknown, type: CasingType, disallowDigits?: boolean, separator?: any) {
@@ -20,10 +19,6 @@ describe('casing', () => {
     expect(runCasing('', CasingType.camel)).toBeUndefined();
   });
 
-  test('given unknown case type should return nothing', () => {
-    expect(() => runCasing('2', 'foo' as any)).toThrowError(AssertionError);
-  });
-
   describe('casing type', () => {
     describe('flat', () => {
       const invalid = ['foo_test', 'Foo', '123', '1d', 'foo-bar'];
@@ -220,39 +215,6 @@ describe('casing', () => {
   });
 
   describe('casing with custom separator configuration', () => {
-    describe('parameters validation', () => {
-      const casingTypes = Object.keys(CasingType);
-
-      test.each([...casingTypes])(
-        'with "%s" type - throws when allowLeadingSeparator option is used without specifying separator',
-        type => {
-          expect(() =>
-            runCasing('irrelevant value', CasingType[type], undefined, { char: undefined, allowLeading: true }),
-          ).toThrow(AssertionError);
-        },
-      );
-
-      const invalidSepLengthCombinations = Object.values(casingTypes).reduce<Array<[string, number]>>(
-        (combinations, type) => {
-          for (const len of [0, 2, 3, 17]) {
-            combinations.push([type, len]);
-          }
-
-          return combinations;
-        },
-        [],
-      );
-
-      test.each(invalidSepLengthCombinations)(
-        'with type "%s" - throws when separator value is "%i" (not exactly one char long)',
-        (type, len) => {
-          expect(() => runCasing('irrelevant value', CasingType[type], undefined, { char: '-'.repeat(len) })).toThrow(
-            AssertionError,
-          );
-        },
-      );
-    });
-
     const baseData: Array<[string, string, string, string]> = [[CasingType.flat, 'flat', 'flat01', 'Nope']];
 
     const testCases: Array<[string, boolean, string, boolean, string, string, string]> = [];

src/functions/__tests__/schema.test.ts

@@ -2,7 +2,7 @@ import { Optional } from '@stoplight/types';
 import { JSONSchema4, JSONSchema6 } from 'json-schema';
 import { schema } from '../schema';
 
-function runSchema(target: any, schemaObj: object, oasVersion?: Optional<number>) {
+function runSchema(target: any, schemaObj: object, oasVersion?: Optional<2 | 3 | 3.1>) {
   return schema(target, { schema: schemaObj, oasVersion }, { given: [] }, { given: null, original: null } as any);
 }
 

src/functions/alphabetical.ts

@@ -28,7 +28,7 @@ const getUnsortedItems = <T>(arr: T[], compareFn: (a: T, B: T) => number): null
   return null;
 };
 
-export const alphabetical: IFunction<IAlphaRuleOptions> = (targetVal, opts, paths, { documentInventory }) => {
+export const alphabetical: IFunction<IAlphaRuleOptions | null> = (targetVal, opts, paths, { documentInventory }) => {
   const results: IFunctionResult[] = [];
 
   if (!isObject(targetVal)) {
@@ -49,7 +49,7 @@ export const alphabetical: IFunction<IAlphaRuleOptions> = (targetVal, opts, path
     return results;
   }
 
-  const { keyedBy } = opts;
+  const keyedBy = opts?.keyedBy;
 
   const unsortedItems = getUnsortedItems<unknown>(
     targetArray,

src/functions/casing.ts

@@ -1,5 +1,4 @@
 import { Dictionary } from '@stoplight/types';
-import { AssertionError } from 'assert';
 import { escapeRegExp } from 'lodash';
 import { IFunction } from '../types';
 
@@ -37,8 +36,6 @@ export const casing: IFunction<ICasingOptions> = (targetVal, opts) => {
     return;
   }
 
-  assertValidOptions(opts);
-
   const casingValidator = buildFrom(CASES[opts.type], opts);
 
   if (casingValidator.test(targetVal)) {
@@ -52,26 +49,6 @@ export const casing: IFunction<ICasingOptions> = (targetVal, opts) => {
   ];
 };
 
-function assertValidOptions(opts: ICasingOptions): asserts opts is ICasingOptions {
-  if (!(opts.type in CASES)) {
-    throw new AssertionError({ message: `Invalid '${opts.type}' type value.` });
-  }
-
-  if (opts.separator === undefined) {
-    return;
-  }
-
-  if (opts.separator.allowLeading !== undefined && opts.separator.char === undefined) {
-    throw new AssertionError({
-      message: "'separator.allowLeading' can only be valued when 'separator.char' is defined.",
-    });
-  }
-
-  if (opts.separator.char.length !== 1) {
-    throw new AssertionError({ message: "When valued, 'separator.char' should only be one character long." });
-  }
-}
-
 const DIGITS_PATTERN = '0-9';
 
 const buildFrom = (basePattern: string, overrides: ICasingOptions): RegExp => {

src/functions/schema-path.ts

@@ -20,7 +20,7 @@ export interface ISchemaPathOptions {
   // the `path.to.prop` to field, or special `@key` value to target keys for matched `given` object
   field?: string;
   // The oasVersion, either 2 or 3 for OpenAPI Spec versions, could also be 3.1 or a larger number if there's a need for it, otherwise JSON Schema
-  oasVersion?: Optional<number>;
+  oasVersion?: Optional<2 | 3 | 3.1>;
   allErrors?: boolean;
 }
 

src/functions/schema.ts

@@ -24,7 +24,7 @@ export interface ISchemaFunction extends IFunction<ISchemaOptions> {
 export interface ISchemaOptions {
   schema: object;
   // The oasVersion, either 2 or 3 for OpenAPI Spec versions, could also be 3.1 or a larger number if there's a need for it, otherwise JSON Schema
-  oasVersion?: Optional<number>;
+  oasVersion?: Optional<2 | 3 | 3.1>;
   allErrors?: boolean;
   ajv?: ValidateFunction;