feat: add default resolvers

package.json

@@ -60,15 +60,16 @@
     "@oclif/config": "^1.12.11",
     "@oclif/plugin-help": "^2.0",
     "@stoplight/json": "^2.1.0",
-    "@stoplight/json-ref-resolver": "1.x.x",
-    "@stoplight/types": "^5.1.0",
+    "@stoplight/json-ref-resolver": "^1.5.0",
+    "@stoplight/types": "^7.0.1",
     "@stoplight/yaml": "^2.3.0",
+    "@types/urijs": "^1.19.1",
     "ajv": "6.x.x",
     "ajv-oai": "^1.1.1",
     "chalk": "^2.4.2",
     "jsonpath": "https://github.com/stoplightio/jsonpath#f1c0e9e634da2d45671b7639fa0a99afc807da17",
     "lodash": ">=4.17.5",
-    "node-fetch": "2.x.x",
+    "node-fetch": "^2.6.0",
     "strip-ansi": "^5.2.0",
     "text-table": "^0.2.0",
     "typescript-json-schema": "^0.38.0"
@@ -97,7 +98,7 @@
     "ts-node": "^8.1.0",
     "tslint": "5.16.0",
     "tslint-config-stoplight": "1.3.0",
-    "typescript": "3.4.5",
+    "typescript": "3.5.1",
     "yaml": "^1.5.1"
   },
   "lint-staged": {

src/__tests__/__fixtures__/todos.invalid.oas2.json

@@ -79,6 +79,14 @@
                 "completed": false
               }
             }
+          },
+          {
+            "name": "missing",
+            "in": "query",
+            "schema": {
+              "$ref": "#/parameters/missing",
+              "example": "test"
+            }
           }
         ],
         "responses": {

src/__tests__/linter.test.ts

@@ -12,6 +12,7 @@ const invalidSchema = fs.readFileSync(
   path.join(__dirname, './__fixtures__/petstore.invalid-schema.oas3.yaml'),
   'utf-8',
 );
+const todosInvalid = fs.readFileSync(path.join(__dirname, './__fixtures__/todos.invalid.oas2.json'), 'utf-8');
 
 const fnName = 'fake';
 const fnName2 = 'fake2';
@@ -205,26 +206,69 @@ responses:: !!foo
 
     const result = await spectral.run(invalidSchema);
 
-    expect(result).toEqual([
-      expect.objectContaining({
-        code: 'oas3-schema',
-        message: 'should NOT have additional properties: type',
-        summary: 'should NOT have additional properties: type',
-        path: ['paths', '/pets', 'get', 'responses', '200', 'headers', 'header-1'],
-      }),
-      expect.objectContaining({
-        code: 'oas3-schema',
-        message: 'should match exactly one schema in oneOf',
-        summary: 'should match exactly one schema in oneOf',
-        path: ['paths', '/pets', 'get', 'responses', '200', 'headers', 'header-1'],
-      }),
-      expect.objectContaining({
-        code: 'oas3-schema',
-        message: "should have required property '$ref'",
-        summary: "should have required property '$ref'",
-        path: ['paths', '/pets', 'get', 'responses', '200', 'headers', 'header-1'],
-      }),
-    ]);
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'oas3-schema',
+          message: 'should NOT have additional properties: type',
+          summary: 'should NOT have additional properties: type',
+          path: ['paths', '/pets', 'get', 'responses', '200', 'headers', 'header-1'],
+        }),
+        expect.objectContaining({
+          code: 'oas3-schema',
+          message: 'should match exactly one schema in oneOf',
+          summary: 'should match exactly one schema in oneOf',
+          path: ['paths', '/pets', 'get', 'responses', '200', 'headers', 'header-1'],
+        }),
+        expect.objectContaining({
+          code: 'oas3-schema',
+          message: "should have required property '$ref'",
+          summary: "should have required property '$ref'",
+          path: ['paths', '/pets', 'get', 'responses', '200', 'headers', 'header-1'],
+        }),
+      ]),
+    );
+  });
+
+  test('should report invalid schema $refs', async () => {
+    spectral.addRules(oas3Ruleset.rules as RuleCollection);
+    spectral.addFunctions(oas3Functions());
+
+    const result = await spectral.run(todosInvalid);
+
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'valid-example',
+          message: '"schema" property can\'t resolve reference #/parameters/missing from id #',
+          path: ['paths', '/todos/{todoId}', 'put', 'parameters', 1, 'schema'],
+        }),
+      ]),
+    );
+  });
+
+  test('should report invalid $refs', async () => {
+    spectral.addRules(oas3Ruleset.rules as RuleCollection);
+    spectral.addFunctions(oas3Functions());
+
+    const result = await spectral.run(invalidSchema);
+
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'invalid-ref',
+          message: "No reader defined for scheme 'file' in ref file://models/pet.yaml",
+          path: ['paths', '/pets', 'get', 'responses', '200', 'content', 'application/json', 'schema', '$ref'],
+          severity: DiagnosticSeverity.Error,
+        }),
+        expect.objectContaining({
+          code: 'invalid-ref',
+          message: "No reader defined for scheme 'file' in ref file://../common/models/error.yaml",
+          path: ['paths', '/pets', 'get', 'responses', 'default', 'content', 'application/json', 'schema', '$ref'],
+          severity: DiagnosticSeverity.Error,
+        }),
+      ]),
+    );
   });
 
   describe('functional tests for the given property', () => {

src/__tests__/spectral.test.ts

@@ -104,14 +104,14 @@ describe('spectral', () => {
       };
 
       const s = new Spectral({
-        resolver: fakeResolver,
+        resolver: fakeResolver as any,
       });
 
       const target = { foo: 'bar' };
 
       await s.run(target);
 
-      expect(fakeResolver.resolve).toBeCalledWith(target);
+      expect(fakeResolver.resolve).toBeCalledWith(target, { authority: undefined });
     });
   });
 

src/cli/commands/lint.ts

@@ -4,11 +4,14 @@ import { getLocationForJsonPath } from '@stoplight/yaml';
 import { writeFile } from 'fs';
 import { isNil, omitBy } from 'lodash';
 import { resolve } from 'path';
+import * as URI from 'urijs';
 import { promisify } from 'util';
+
 import { IRuleResult } from '../..';
 import { createEmptyConfig, getDefaultConfigFile, load as loadConfig } from '../../config/configLoader';
 import { json, stylish } from '../../formatters';
 import { readParsable } from '../../fs/reader';
+import { httpAndFileResolver } from '../../resolvers/http-and-file';
 import { oas2Functions, rules as oas2Rules } from '../../rulesets/oas2';
 import { oas3Functions, rules as oas3Rules } from '../../rulesets/oas3';
 import { readRulesFromRulesets } from '../../rulesets/reader';
@@ -124,8 +127,11 @@ async function lint(name: string, flags: any, command: Lint, rules?: RuleCollect
   if (flags.verbose) {
     command.log(`Linting ${name}`);
   }
-  const spec: IParserResult = await readParsable(name, flags.encoding);
-  const spectral = new Spectral();
+
+  const targetUri = isValidURI(name) ? name : resolve(name);
+
+  const spec: IParserResult = await readParsable(targetUri, flags.encoding);
+  const spectral = new Spectral({ resolver: httpAndFileResolver });
   if (parseInt(spec.data.swagger) === 2) {
     command.log('Adding OpenAPI 2.0 (Swagger) functions');
     spectral.addFunctions(oas2Functions());
@@ -163,12 +169,17 @@ async function lint(name: string, flags: any, command: Lint, rules?: RuleCollect
   let results = [];
   try {
     const parsedResult: IParsedResult = {
-      source: resolve(process.cwd(), name),
+      source: targetUri,
       parsed: spec,
       getLocationForJsonPath,
     };
 
-    results = await spectral.run(parsedResult);
+    results = await spectral.run(parsedResult, {
+      resolve: {
+        documentUri: targetUri,
+      },
+    });
+
     if (results.length === 0) {
       command.log('No errors or warnings found!');
       return;
@@ -244,3 +255,13 @@ function mergeConfig(config: IConfig, flags: any): ILintConfig {
     ),
   };
 }
+
+const isValidURI = (maybeUri: string) => {
+  try {
+    // tslint:disable-next-line:no-unused-expression
+    new URI(maybeUri);
+    return true;
+  } catch {
+    return false;
+  }
+};

src/functions/schema.ts

@@ -55,34 +55,46 @@ export const schema: IFunction<ISchemaOptions> = (targetVal, opts, paths) => {
       },
     ];
 
+  // we already access a resolved object in src/functions/schema-path.ts
   const { schema: schemaObj } = opts;
 
-  if (!ajv.validate(schemaObj, targetVal) && ajv.errors) {
-    // TODO: potential performance improvements (compile, etc)?
-    const collectedErrors: string[] = [];
+  try {
+    if (!ajv.validate(schemaObj, targetVal) && ajv.errors) {
+      // TODO: potential performance improvements (compile, etc)?
+      const collectedErrors: string[] = [];
 
-    for (const error of ajv.errors) {
-      if (collectedErrors.length > 0) {
-        const index = collectedErrors.indexOf(error.keyword);
-        if (index !== -1) {
-          if (mergeErrors(results[index], error)) continue;
+      for (const error of ajv.errors) {
+        if (collectedErrors.length > 0) {
+          const index = collectedErrors.indexOf(error.keyword);
+          if (index !== -1) {
+            if (mergeErrors(results[index], error)) continue;
+          }
         }
-      }
 
-      let message = error.message || '';
+        let message = error.message || '';
 
-      if (
-        error.keyword === 'additionalProperties' &&
-        (error.params as AJV.AdditionalPropertiesParams).additionalProperty
-      ) {
-        message += `: ${(error.params as AJV.AdditionalPropertiesParams).additionalProperty}`;
-      }
+        if (
+          error.keyword === 'additionalProperties' &&
+          (error.params as AJV.AdditionalPropertiesParams).additionalProperty
+        ) {
+          message += `: ${(error.params as AJV.AdditionalPropertiesParams).additionalProperty}`;
+        }
 
-      collectedErrors.push(error.keyword);
+        collectedErrors.push(error.keyword);
+        results.push({
+          path: [...path, ...formatPath(error.dataPath)],
+          message,
+        });
+      }
+    }
+  } catch (ex) {
+    if (ex instanceof AJV.MissingRefError) {
       results.push({
-        path: [...path, ...formatPath(error.dataPath)],
-        message,
+        message: ex.message,
+        path,
       });
+    } else {
+      throw ex;
     }
   }
 

src/linter.ts

@@ -3,15 +3,15 @@ import * as jp from 'jsonpath';
 import { get, has } from 'lodash';
 
 import { message } from './rulesets/message';
-import { IFunction, IGivenNode, IParsedResult, IRuleResult, IRunOpts, IRunRule, IThen } from './types';
+import { IFunction, IGivenNode, IParsedResult, IRuleResult, IRunRule, IRunRuleOpts, IThen } from './types';
 
 // TODO(SO-23): unit test but mock whatShouldBeLinted
 export const lintNode = (
   node: IGivenNode,
   rule: IRunRule,
   then: IThen<string, any>,
   apply: IFunction,
-  opts: IRunOpts,
+  opts: IRunRuleOpts,
   parsedResult: IParsedResult,
 ): IRuleResult[] => {
   const givenPath = node.path[0] === '$' ? node.path.slice(1) : node.path;

src/resolvers/http-and-file.ts

@@ -0,0 +1,23 @@
+import { Resolver } from '@stoplight/json-ref-resolver';
+import * as fs from 'fs';
+
+import { httpReader } from './http';
+
+// resolves files, http and https $refs, and internal $refs
+export const httpAndFileResolver = new Resolver({
+  readers: {
+    https: httpReader,
+    http: httpReader,
+    file: {
+      read(ref: any) {
+        return new Promise((resolve, reject) => {
+          const path = ref.path();
+          return fs.readFile(path, 'utf8', (err, data) => {
+            if (err) reject(err);
+            resolve(data);
+          });
+        });
+      },
+    },
+  },
+});

src/resolvers/http.ts

@@ -0,0 +1,17 @@
+import { Resolver } from '@stoplight/json-ref-resolver';
+
+const fetch = require('node-fetch');
+
+export const httpReader = {
+  async read(ref: unknown) {
+    return (await fetch(String(ref))).text();
+  },
+};
+
+// resolves http and https $refs, and internal $refs
+export const httpResolver = new Resolver({
+  readers: {
+    https: httpReader,
+    http: httpReader,
+  },
+});

src/resolvers/local.ts

@@ -0,0 +1,4 @@
+import { Resolver } from '@stoplight/json-ref-resolver';
+
+// just resolves internal #/definitions/user type $refs
+export const localResolver = new Resolver();