v8r 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 📦 [0.13.0](https://www.npmjs.com/package/v8r/v/0.13.0) - 2022-06-11
+
+* Overhaul of CLI output/machine-readable output. Validation results are sent to stdout. Log messages are now sent to stderr only. Pass `--format [text|json] (default: text)` to specify what is sent to stdout.
+
+## 📦 [0.12.0](https://www.npmjs.com/package/v8r/v/0.12.0) - 2022-05-07
+
+* Add config file. See https://github.com/chris48s/v8r/blob/main/README.md#configuration for more details.
+
+## 📦 [0.11.1](https://www.npmjs.com/package/v8r/v/0.11.1) - 2022-03-03
+
+* Fix: call minimatch with `{dot: true}`, fixes [#174](https://github.com/chris48s/v8r/issues/174)
+
 ## 📦 [0.11.0](https://www.npmjs.com/package/v8r/v/0.11.0) - 2022-02-27
 
 * Drop compatibility with node 12, now requires node `^14.13.1 || >=15.0.0`

package/README.md

@@ -77,6 +77,83 @@ $ v8r feature.geojson -c my-catalog.json
 
 This can be used to specify different custom schemas for multiple file patterns.
 
+## Configuration
+
+v8r uses CosmiConfig to search for a configuration. This means you can specify your configuration in any of the following places:
+
+- `package.json`
+- `.v8rrc`
+- `.v8rrc.json`
+- `.v8rrc.yaml`
+- `.v8rrc.yml`
+- `.v8rrc.js`
+- `.v8rrc.cjs`
+- `v8r.config.js`
+- `v8r.config.cjs`
+
+v8r only searches for a config file in the current working directory.
+
+Example yaml config file:
+
+```yaml
+# - One or more filenames or glob patterns describing local file or files to validate
+# - overridden by passing one or more positional arguments
+patterns: ['*json']
+
+# - Level of verbose logging. 0 is standard, higher numbers are more verbose
+# - overridden by passing --verbose / -v
+# - default = 0
+verbose: 2
+
+# - Exit with code 0 even if an error was encountered. True means a non-zero exit
+#   code is only issued if validation could be completed successfully and one or
+#   more files were invalid
+# - overridden by passing --ignore-errors
+# - default = false
+ignoreErrors: true
+
+# - Remove cached HTTP responses older than cacheTtl seconds old.
+#   Specifying 0 clears and disables cache completely
+# - overridden by passing --cache-ttl
+# - default = 600
+cacheTtl: 86400
+
+# - Output format for validation results
+# - overridden by passing --format
+# - default = text
+format: "json"
+
+# - A custom schema catalog.
+#   This catalog will be searched ahead of any custom catalogs passed using
+#   --catalogs or SchemaStore.org
+#   The format of this is subtly different to the format of a catalog
+#   passed via --catalogs (which matches the SchemaStore.org format)
+customCatalog:
+    schemas:
+        - name: Custom Schema  # The name of the schema (required)
+          description: Custom Schema  # A description of the schema (optional)
+
+          # A Minimatch glob expression for matching up file names with a schema (required)
+          fileMatch: ["*.geojson"]
+
+          # A URL or local file path for the schema location (required)
+          # Unlike the SchemaStore.org format, which has a `url` key,
+          # custom catalogs defined in v8r config files have a `location` key
+          # which can refer to either a URL or local file.
+          # Relative paths are interpreted as relative to the config file location.
+          location: foo/bar/geojson-schema.json
+
+          # A custom parser to use for files matching fileMatch
+          # instead of trying to infer the correct parser from the filename (optional)
+          # This property is specific to custom catalogs defined in v8r config files
+          parser: json5
+```
+
+The config file format is specified more formally in a JSON Schema:
+
+- [machine-readable JSON](config-schema.json)
+- [human-readable HTML](https://json-schema-viewer.vercel.app/view?url=https%3A%2F%2Fraw.githubusercontent.com%2Fchris48s%2Fv8r%2Fmain%2Fconfig-schema.json&show_breadcrumbs=on&template_name=flat)
+
 ## Exit codes
 
 * v8r always exits with code `0` when:
@@ -91,6 +168,10 @@ This can be used to specify different custom schemas for multiple file patterns.
 
     This behaviour can be modified using the `--ignore-errors` flag. When invoked with `--ignore-errors` v8r will exit with code `0` even if one of these errors was encountered while attempting validation. A non-zero exit code will only be issued if validation could be completed successfully and the file was invalid.
 
+* v8r always exits with code `97` when:
+    * There was an error loading a config file
+    * A config file was loaded but failed validation
+
 * v8r always exits with code `98` when:
     * An input glob pattern was invalid
     * An input glob pattern was valid but did not match any files
@@ -127,4 +208,4 @@ This can be used to specify different custom schemas for multiple file patterns.
 
 ### ❓ Can `v8r` validate against a local schema?
 
-💡 Yes. The `--schema` flag can be either a path to a local file or a URL.
+💡 Yes. The `--schema` flag can be either a path to a local file or a URL. You can also use a [config file](#configuration) to include local schemas in a custom catalog.

package/config-schema.json

@@ -0,0 +1,92 @@
+{
+  "title": "JSON schema for v8r config files",
+  "$schema": "https://json-schema.org/draft/2019-09/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "cacheTtl": {
+      "description": "Remove cached HTTP responses older than cacheTtl seconds old. Specifying 0 clears and disables cache completely",
+      "type": "integer",
+      "minimum": 0
+    },
+    "customCatalog": {
+      "type": "object",
+      "description": "A custom schema catalog. This catalog will be searched ahead of any custom catalogs passed using --catalogs or SchemaStore.org",
+      "required": [
+        "schemas"
+      ],
+      "properties": {
+        "schemas": {
+          "type": "array",
+          "description": "A list of JSON schema references.",
+          "items": {
+            "type": "object",
+            "required": [
+              "name",
+              "fileMatch",
+              "location"
+            ],
+            "additionalProperties": false,
+            "properties": {
+              "description": {
+                "description": "A description of the schema",
+                "type": "string"
+              },
+              "fileMatch": {
+                "description": "A Minimatch glob expression for matching up file names with a schema.",
+                "uniqueItems": true,
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "location": {
+                "description": "A URL or local file path for the schema location",
+                "type": "string"
+              },
+              "name": {
+                "description": "The name of the schema",
+                "type": "string"
+              },
+              "parser": {
+                "description": "A custom parser to use for files matching fileMatch instead of trying to infer the correct parser from the filename",
+                "type": "string",
+                "enum": [
+                  "json",
+                  "yaml",
+                  "json5"
+                ]
+              }
+            }
+          }
+        }
+      }
+    },
+    "format": {
+      "description": "Output format for validation results",
+      "type": "string",
+      "enum": [
+        "text",
+        "json"
+      ]
+    },
+    "ignoreErrors": {
+      "description": "Exit with code 0 even if an error was encountered. True means a non-zero exit code is only issued if validation could be completed successfully and one or more files were invalid",
+      "type": "boolean"
+    },
+    "patterns": {
+      "type": "array",
+      "description": "One or more filenames or glob patterns describing local file or files to validate",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "type": "string"
+      }
+    },
+    "verbose": {
+      "description": "Level of verbose logging. 0 is standard, higher numbers are more verbose",
+      "type": "integer",
+      "minimum": 0
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v8r",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "A command-line JSON and YAML validator that's on your wavelength",
   "scripts": {
     "test": "V8R_CACHE_NAME=v8r-test c8 --reporter=text mocha \"src/**/*.spec.js\"",
@@ -27,8 +27,10 @@
     "ajv-draft-04": "^1.0.0",
     "ajv-formats": "^2.1.1",
     "chalk": "^5.0.0",
+    "cosmiconfig": "^7.0.1",
+    "decamelize": "^6.0.0",
     "flat-cache": "^3.0.4",
-    "glob": "^7.2.0",
+    "glob": "^8.0.1",
     "got": "^12.0.1",
     "is-url": "^1.2.4",
     "js-yaml": "^4.0.0",
@@ -44,12 +46,13 @@
     "eslint-config-prettier": "^8.1.0",
     "eslint-plugin-mocha": "^10.0.3",
     "eslint-plugin-prettier": "^4.0.0",
-    "mocha": "^9.0.0",
+    "mocha": "^10.0.0",
+    "mock-cwd": "^1.0.0",
     "nock": "^13.0.4",
     "prettier": "^2.1.2"
   },
   "engines": {
-    "node": "^14.13.1 || >=15.0.0"
+    "node": ">=14.13.1"
   },
   "type": "module",
   "keywords": [

package/src/ajv.js

@@ -9,9 +9,9 @@ import Ajv2019 from "ajv/dist/2019.js";
 import Ajv2020 from "ajv/dist/2020.js";
 import addFormats from "ajv-formats";
 
-function _ajvFactory(schema, cache) {
+function _ajvFactory(schema, strictMode, cache) {
   const resolver = (url) => cache.fetch(url);
-  const opts = { allErrors: true, loadSchema: resolver, strict: "log" };
+  const opts = { allErrors: true, loadSchema: resolver, strict: strictMode };
 
   if (
     typeof schema["$schema"] === "string" ||
@@ -53,17 +53,12 @@ function _ajvFactory(schema, cache) {
   */
 }
 
-async function validate(data, schema, cache) {
-  const ajv = _ajvFactory(schema, cache);
+async function validate(data, schema, strictMode, cache) {
+  const ajv = _ajvFactory(schema, strictMode, cache);
   addFormats(ajv);
   const validateFn = await ajv.compileAsync(schema);
   const valid = validateFn(data);
-  if (!valid) {
-    console.log("\nErrors:");
-    console.log(validateFn.errors);
-    console.log("");
-  }
-  return valid;
+  return { valid, errors: validateFn.errors ? validateFn.errors : [] };
 }
 
 export { _ajvFactory, validate };

package/src/cache.js

@@ -1,5 +1,5 @@
 import got from "got";
-import logging from "./logging.js";
+import logger from "./logger.js";
 
 class Cache {
   constructor(flatCache, ttl) {
@@ -13,10 +13,10 @@ class Cache {
     Object.entries(this.cache.all()).forEach(
       function ([url, cachedResponse]) {
         if (!("timestamp" in cachedResponse) || !("body" in cachedResponse)) {
-          logging.debug(`Cache error: deleting malformed response`);
+          logger.debug(`Cache error: deleting malformed response`);
           this.cache.removeKey(url);
         } else if (Date.now() > cachedResponse.timestamp + this.ttl) {
-          logging.debug(`Cache stale: deleting cached response from ${url}`);
+          logger.debug(`Cache stale: deleting cached response from ${url}`);
           this.cache.removeKey(url);
         }
         this.cache.save(true);
@@ -53,12 +53,12 @@ class Cache {
     this.expire();
     const cachedResponse = this.cache.getKey(url);
     if (cachedResponse !== undefined) {
-      logging.debug(`Cache hit: using cached response from ${url}`);
+      logger.debug(`Cache hit: using cached response from ${url}`);
       return cachedResponse.body;
     }
 
     try {
-      logging.debug(`Cache miss: calling ${url}`);
+      logger.debug(`Cache miss: calling ${url}`);
       const resp = await got(url);
       const parsedBody = JSON.parse(resp.body);
       if (this.ttl > 0) {

package/src/catalogs.js

@@ -0,0 +1,119 @@
+import minimatch from "minimatch";
+import path from "path";
+import { validate } from "./ajv.js";
+import { getFromUrlOrFile } from "./io.js";
+import logger from "./logger.js";
+
+const SCHEMASTORE_CATALOG_URL =
+  "https://www.schemastore.org/api/json/catalog.json";
+const SCHEMASTORE_CATALOG_SCHEMA_URL =
+  "https://json.schemastore.org/schema-catalog.json";
+
+function coerceMatch(inMatch) {
+  const outMatch = {};
+  outMatch.location = inMatch.url || inMatch.location;
+  for (const [key, value] of Object.entries(inMatch)) {
+    if (!["location", "url"].includes(key)) {
+      outMatch[key] = value;
+    }
+  }
+  return outMatch;
+}
+
+function getCatalogs(config) {
+  let catalogs = [];
+  if (config.customCatalog) {
+    catalogs.push({
+      location: config.configFileRelativePath,
+      catalog: config.customCatalog,
+    });
+  }
+  if (config.catalogs) {
+    catalogs = catalogs.concat(
+      config.catalogs.map(function (loc) {
+        return { location: loc };
+      })
+    );
+  }
+  catalogs.push({ location: SCHEMASTORE_CATALOG_URL });
+  return catalogs;
+}
+
+async function getMatchForFilename(catalogs, filename, cache) {
+  for (const [i, rec] of catalogs.entries()) {
+    const catalogLocation = rec.location;
+    const catalog =
+      rec.catalog || (await getFromUrlOrFile(catalogLocation, cache));
+
+    if (!rec.catalog) {
+      const catalogSchema = await getFromUrlOrFile(
+        SCHEMASTORE_CATALOG_SCHEMA_URL,
+        cache
+      );
+
+      // Validate the catalog
+      const strictMode = false;
+      const { valid } = await validate(
+        catalog,
+        catalogSchema,
+        strictMode,
+        cache
+      );
+      if (!valid || catalog.schemas === undefined) {
+        throw new Error(`Malformed catalog at ${catalogLocation}`);
+      }
+    }
+
+    const { schemas } = catalog;
+    const matches = getSchemaMatchesForFilename(schemas, filename);
+    logger.debug(`Searching for schema in ${catalogLocation} ...`);
+    if (matches.length === 1) {
+      logger.info(`Found schema in ${catalogLocation} ...`);
+      return coerceMatch(matches[0]); // Match found. We're done.
+    }
+    if (matches.length === 0 && i < catalogs.length - 1) {
+      continue; // No match found. Try the next catalog in the array.
+    }
+    if (matches.length > 1) {
+      // We found >1 matches in the same catalog. This is always a hard error.
+      const matchesLog = matches
+        .map(function (match) {
+          let outStr = "";
+          outStr += `  ${match.name}\n`;
+          if (match.description) {
+            outStr += `  ${match.description}\n`;
+          }
+          outStr += `  ${match.url || match.location}\n`;
+          return outStr;
+        })
+        .join("\n");
+      logger.info(
+        `Found multiple possible schemas for ${filename}. Possible matches:\n${matchesLog}`
+      );
+    }
+    // Either we found >1 matches in the same catalog or we found 0 matches
+    // in the last catalog and there are no more catalogs left to try.
+    throw new Error(`Could not find a schema to validate ${filename}`);
+  }
+}
+
+function getSchemaMatchesForFilename(schemas, filename) {
+  const matches = [];
+  schemas.forEach(function (schema) {
+    if ("fileMatch" in schema) {
+      if (schema.fileMatch.includes(path.basename(filename))) {
+        matches.push(schema);
+        return;
+      }
+      for (const glob of schema.fileMatch) {
+        if (minimatch(path.normalize(filename), glob, { dot: true })) {
+          matches.push(schema);
+          break;
+        }
+      }
+    }
+  });
+  return matches;
+}
+
+export { getCatalogs, getMatchForFilename, getSchemaMatchesForFilename };

package/src/cli.js

@@ -1,97 +1,27 @@
 import flatCache from "flat-cache";
 import fs from "fs";
-import isUrl from "is-url";
-import minimatch from "minimatch";
-import { createRequire } from "module";
 import os from "os";
 import path from "path";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
 import { validate } from "./ajv.js";
 import { Cache } from "./cache.js";
+import { getCatalogs, getMatchForFilename } from "./catalogs.js";
+import { getConfig } from "./config.js";
 import { getFiles } from "./glob.js";
-import logging from "./logging.js";
+import { getFromUrlOrFile } from "./io.js";
+import logger from "./logger.js";
+import { logErrors, resultsToJson } from "./output-formatters.js";
 import { parseFile } from "./parser.js";
 
-const SCHEMASTORE_CATALOG_URL =
-  "https://www.schemastore.org/api/json/catalog.json";
-
-const SCHEMASTORE_CATALOG_SCHEMA_URL =
-  "https://json.schemastore.org/schema-catalog.json";
-
 const EXIT = {
   VALID: 0,
   ERROR: 1,
-  NOTFOUND: 98,
+  INVALID_CONFIG: 97,
+  NOT_FOUND: 98,
   INVALID: 99,
 };
 
 const CACHE_DIR = path.join(os.tmpdir(), "flat-cache");
 
-async function getFromUrlOrFile(location, cache) {
-  return isUrl(location)
-    ? await cache.fetch(location)
-    : JSON.parse(await fs.promises.readFile(location, "utf8"));
-}
-
-async function getSchemaUrlForFilename(catalogs, filename, cache) {
-  for (const [i, catalogLocation] of catalogs.entries()) {
-    const catalog = await getFromUrlOrFile(catalogLocation, cache);
-    const catalogSchema = await getFromUrlOrFile(
-      SCHEMASTORE_CATALOG_SCHEMA_URL,
-      cache
-    );
-
-    // Validate the catalog
-    const valid = await validate(catalog, catalogSchema, cache);
-    if (!valid || catalog.schemas === undefined) {
-      throw new Error(`Malformed catalog at ${catalogLocation}`);
-    }
-
-    const { schemas } = catalog;
-    const matches = getSchemaMatchesForFilename(schemas, filename);
-    logging.debug(`Searching for schema in ${catalogLocation} ...`);
-    if (matches.length === 1) {
-      logging.info(`Found schema in ${catalogLocation} ...`);
-      return matches[0].url; // Match found. We're done.
-    }
-    if (matches.length === 0 && i < catalogs.length - 1) {
-      continue; // No match found. Try the next catalog in the array.
-    }
-    if (matches.length > 1) {
-      // We found >1 matches in the same catalog. This is always a hard error.
-      const matchesLog = matches
-        .map((match) => `  ${match.description}: ${match.url}`)
-        .join("\n");
-      logging.info(
-        `Found multiple possible schemas for ${filename}. Possible matches:\n${matchesLog}`
-      );
-    }
-    // Either we found >1 matches in the same catalog or we found 0 matches
-    // in the last catalog and there are no more catalogs left to try.
-    throw new Error(`Could not find a schema to validate ${filename}`);
-  }
-}
-
-function getSchemaMatchesForFilename(schemas, filename) {
-  const matches = [];
-  schemas.forEach(function (schema) {
-    if ("fileMatch" in schema) {
-      if (schema.fileMatch.includes(path.basename(filename))) {
-        matches.push(schema);
-        return;
-      }
-      for (const glob of schema.fileMatch) {
-        if (minimatch(path.normalize(filename), glob)) {
-          matches.push(schema);
-          break;
-        }
-      }
-    }
-  });
-  return matches;
-}
-
 function secondsToMilliseconds(seconds) {
   return seconds * 1000;
 }
@@ -103,45 +33,53 @@ function getFlatCache() {
   return flatCache.load("v8r", CACHE_DIR);
 }
 
-async function validateFile(filename, args, cache) {
-  logging.info(`Processing ${filename}`);
+async function validateFile(filename, config, cache) {
+  logger.info(`Processing ${filename}`);
+  let result = {
+    fileLocation: filename,
+    schemaLocation: null,
+    valid: null,
+    errors: [],
+    code: null,
+  };
   try {
-    const data = parseFile(
-      await fs.promises.readFile(filename, "utf8"),
-      path.extname(filename)
-    );
-
-    const schemaLocation =
-      args.schema ||
-      (await getSchemaUrlForFilename(
-        (args.catalogs || []).concat([SCHEMASTORE_CATALOG_URL]),
-        filename,
-        cache
-      ));
+    const catalogs = getCatalogs(config);
+    const catalogMatch = config.schema
+      ? {}
+      : await getMatchForFilename(catalogs, filename, cache);
+    const schemaLocation = config.schema || catalogMatch.location;
+    result.schemaLocation = schemaLocation;
     const schema = await getFromUrlOrFile(schemaLocation, cache);
-    logging.info(
+    logger.info(
       `Validating ${filename} against schema from ${schemaLocation} ...`
     );
 
-    const valid = await validate(data, schema, cache);
+    const data = parseFile(
+      await fs.promises.readFile(filename, "utf8"),
+      catalogMatch.parser ? `.${catalogMatch.parser}` : path.extname(filename)
+    );
+
+    const strictMode = config.verbose >= 2 ? "log" : false;
+    const { valid, errors } = await validate(data, schema, strictMode, cache);
+    result.valid = valid;
+    result.errors = errors;
     if (valid) {
-      logging.success(`${filename} is valid\n`);
+      logger.success(`${filename} is valid\n`);
     } else {
-      logging.error(`${filename} is invalid\n`);
+      logger.error(`${filename} is invalid\n`);
     }
 
-    if (valid) {
-      return EXIT.VALID;
-    }
-    return EXIT.INVALID;
+    result.code = valid ? EXIT.VALID : EXIT.INVALID;
+    return result;
   } catch (e) {
-    logging.error(`${e.message}\n`);
-    return EXIT.ERROR;
+    logger.error(`${e.message}\n`);
+    result.code = EXIT.ERROR;
+    return result;
   }
 }
 
-function mergeResults(results, ignoreErrors) {
-  const codes = Object.values(results);
+function resultsToStatusCode(results, ignoreErrors) {
+  const codes = Object.values(results).map((result) => result.code);
   if (codes.includes(EXIT.INVALID)) {
     return EXIT.INVALID;
   }
@@ -152,98 +90,60 @@ function mergeResults(results, ignoreErrors) {
 }
 
 function Validator() {
-  return async function (args) {
+  return async function (config) {
     let filenames = [];
-    for (const pattern of args.patterns) {
+    for (const pattern of config.patterns) {
       const matches = await getFiles(pattern);
       if (matches.length === 0) {
-        logging.error(`Pattern '${pattern}' did not match any files`);
-        return EXIT.NOTFOUND;
+        logger.error(`Pattern '${pattern}' did not match any files`);
+        return EXIT.NOT_FOUND;
       }
       filenames = filenames.concat(matches);
     }
 
-    const ttl = secondsToMilliseconds(args.cacheTtl || 0);
+    const ttl = secondsToMilliseconds(config.cacheTtl || 0);
     const cache = new Cache(getFlatCache(), ttl);
 
     const results = Object.fromEntries(filenames.map((key) => [key, null]));
     for (const [filename] of Object.entries(results)) {
-      results[filename] = await validateFile(filename, args, cache);
+      results[filename] = await validateFile(filename, config, cache);
+
+      if (results[filename].valid === false && config.format === "text") {
+        logErrors(filename, results[filename].errors);
+      }
+      // else: silence is golden
+
       cache.resetCounters();
     }
-    return mergeResults(results, args.ignoreErrors);
+
+    if (config.format === "json") {
+      resultsToJson(results);
+    }
+
+    return resultsToStatusCode(results, config.ignoreErrors);
   };
 }
 
-async function cli(args) {
-  logging.init(args.verbose);
+async function cli(config) {
+  if (!config) {
+    try {
+      config = await getConfig(process.argv);
+    } catch (e) {
+      logger.error(e.message);
+      return EXIT.INVALID_CONFIG;
+    }
+  }
+
+  logger.setVerbosity(config.verbose);
+  logger.debug(`Merged args/config: ${JSON.stringify(config, null, 2)}`);
+
   try {
     const validate = new Validator();
-    return await validate(args);
+    return await validate(config);
   } catch (e) {
-    logging.error(e.message);
+    logger.error(e.message);
     return EXIT.ERROR;
-  } finally {
-    logging.cleanup();
   }
 }
 
-function parseArgs(argv) {
-  return yargs(hideBin(argv))
-    .command(
-      "$0 <patterns..>",
-      "Validate local json/yaml files against schema(s)",
-      (yargs) => {
-        yargs.positional("patterns", {
-          describe:
-            "One or more filenames or glob patterns describing local file or files to validate",
-        });
-      }
-    )
-    .version(
-      // Workaround for https://github.com/yargs/yargs/issues/1934
-      // TODO: remove once fixed
-      createRequire(import.meta.url)("../package.json").version
-    )
-    .option("verbose", {
-      alias: "v",
-      type: "boolean",
-      description: "Run with verbose logging. Can be stacked e.g: -vv -vvv",
-    })
-    .count("verbose")
-    .option("schema", {
-      alias: "s",
-      type: "string",
-      describe:
-        "Local path or URL of a schema to validate against. " +
-        "If not supplied, we will attempt to find an appropriate schema on " +
-        "schemastore.org using the filename. If passed with glob pattern(s) " +
-        "matching multiple files, all matching files will be validated " +
-        "against this schema",
-    })
-    .option("catalogs", {
-      type: "string",
-      alias: "c",
-      array: true,
-      describe:
-        "Local path or URL of custom catalogs to use prior to schemastore.org",
-    })
-    .conflicts("schema", "catalogs")
-    .option("ignore-errors", {
-      type: "boolean",
-      default: false,
-      describe:
-        "Exit with code 0 even if an error was encountered. Passing this flag " +
-        "means a non-zero exit code is only issued if validation could be " +
-        "completed successfully and one or more files were invalid",
-    })
-    .option("cache-ttl", {
-      type: "number",
-      default: 600,
-      describe:
-        "Remove cached HTTP responses older than <cache-ttl> seconds old. " +
-        "Passing 0 clears and disables cache completely",
-    }).argv;
-}
-
-export { cli, parseArgs };
+export { cli };

package/src/config.js

@@ -0,0 +1,177 @@
+import { createRequire } from "module";
+// TODO: once JSON modules is stable these requires could become imports
+// https://nodejs.org/api/esm.html#esm_experimental_json_modules
+const require = createRequire(import.meta.url);
+
+import Ajv2019 from "ajv/dist/2019.js";
+import { cosmiconfig } from "cosmiconfig";
+import decamelize from "decamelize";
+import isUrl from "is-url";
+import path from "path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import logger from "./logger.js";
+import { logErrors } from "./output-formatters.js";
+
+function validateConfig(configFile) {
+  const ajv = new Ajv2019({ allErrors: true, strict: false });
+  const schema = require("../config-schema.json");
+  const validateFn = ajv.compile(schema);
+  const valid = validateFn(configFile.config);
+  if (!valid) {
+    logErrors(
+      configFile.filepath ? configFile.filepath : "",
+      validateFn.errors
+    );
+    throw new Error("Malformed config file");
+  }
+  return valid;
+}
+
+function preProcessConfig(configFile) {
+  if (!configFile?.config?.customCatalog?.schemas) {
+    return;
+  }
+  for (const schema of configFile.config.customCatalog.schemas) {
+    if (!path.isAbsolute(schema.location) && !isUrl(schema.location)) {
+      schema.location = path.join(
+        path.dirname(configFile.filepath),
+        schema.location
+      );
+    }
+  }
+}
+
+async function getCosmiConfig(cosmiconfigOptions) {
+  cosmiconfigOptions.stopDir = process.cwd();
+  const configFile = (await cosmiconfig("v8r", cosmiconfigOptions).search(
+    process.cwd()
+  )) || { config: {} };
+  if (configFile.filepath) {
+    logger.info(`Loaded config file from ${getRelativeFilePath(configFile)}`);
+  } else {
+    logger.info(`No config file found`);
+  }
+  validateConfig(configFile);
+  preProcessConfig(configFile);
+  return configFile;
+}
+
+function mergeConfigs(args, config) {
+  const mergedConfig = { ...args };
+  mergedConfig.cacheName = config?.config?.cacheName;
+  mergedConfig.customCatalog = config?.config?.customCatalog;
+  mergedConfig.configFileRelativePath = undefined;
+  if (config.filepath) {
+    mergedConfig.configFileRelativePath = getRelativeFilePath(config);
+  }
+  return mergedConfig;
+}
+
+function getRelativeFilePath(config) {
+  return path.relative(process.cwd(), config.filepath);
+}
+
+function parseArgs(argv, config) {
+  const parser = yargs(hideBin(argv));
+
+  let command = "$0 <patterns..>";
+  const patternsOpts = {
+    describe:
+      "One or more filenames or glob patterns describing local file or files to validate",
+  };
+  if (Object.keys(config.config).includes("patterns")) {
+    command = "$0 [patterns..]";
+    patternsOpts.default = config.config.patterns;
+    patternsOpts.defaultDescription = `${JSON.stringify(
+      config.config.patterns
+    )} (from config file ${getRelativeFilePath(config)})`;
+  }
+
+  parser
+    .command(
+      command,
+      "Validate local json/yaml files against schema(s)",
+      (yargs) => {
+        yargs.positional("patterns", patternsOpts);
+      }
+    )
+    .version(
+      // Workaround for https://github.com/yargs/yargs/issues/1934
+      // TODO: remove once fixed
+      require("../package.json").version
+    )
+    .option("verbose", {
+      alias: "v",
+      type: "boolean",
+      description: "Run with verbose logging. Can be stacked e.g: -vv -vvv",
+    })
+    .count("verbose")
+    .option("schema", {
+      alias: "s",
+      type: "string",
+      describe:
+        "Local path or URL of a schema to validate against. " +
+        "If not supplied, we will attempt to find an appropriate schema on " +
+        "schemastore.org using the filename. If passed with glob pattern(s) " +
+        "matching multiple files, all matching files will be validated " +
+        "against this schema",
+    })
+    .option("catalogs", {
+      type: "string",
+      alias: "c",
+      array: true,
+      describe:
+        "Local path or URL of custom catalogs to use prior to schemastore.org",
+    })
+    .conflicts("schema", "catalogs")
+    .option("ignore-errors", {
+      type: "boolean",
+      default: false,
+      describe:
+        "Exit with code 0 even if an error was encountered. Passing this flag " +
+        "means a non-zero exit code is only issued if validation could be " +
+        "completed successfully and one or more files were invalid",
+    })
+    .option("cache-ttl", {
+      type: "number",
+      default: 600,
+      describe:
+        "Remove cached HTTP responses older than <cache-ttl> seconds old. " +
+        "Passing 0 clears and disables cache completely",
+    })
+    .option("format", {
+      type: "string",
+      choices: ["text", "json"],
+      default: "text",
+      describe: "Output format for validation results",
+    })
+    .example([
+      ["$0 file.json", "Validate a single file"],
+      ["$0 file1.json file2.json", "Validate multiple files"],
+      [
+        "$0 'dir/*.yml' 'dir/*.yaml'",
+        "Specify files to validate with glob patterns",
+      ],
+    ]);
+
+  for (const [key, value] of Object.entries(config.config)) {
+    if (["cacheTtl", "format", "ignoreErrors", "verbose"].includes(key)) {
+      parser.default(
+        decamelize(key, { separator: "-" }),
+        value,
+        `${value} (from config file ${getRelativeFilePath(config)})`
+      );
+    }
+  }
+
+  return parser.argv;
+}
+
+async function getConfig(argv, cosmiconfigOptions = {}) {
+  const config = await getCosmiConfig(cosmiconfigOptions);
+  const args = parseArgs(argv, config);
+  return mergeConfigs(args, config);
+}
+
+export { getConfig, parseArgs, preProcessConfig, validateConfig };

package/src/glob.js

@@ -1,5 +1,5 @@
 import glob from "glob";
-import logging from "./logging.js";
+import logger from "./logger.js";
 
 const globPromise = function (pattern, options) {
   return new Promise((resolve, reject) => {
@@ -13,7 +13,7 @@ async function getFiles(pattern) {
   try {
     return await globPromise(pattern, { dot: true });
   } catch (e) {
-    logging.error(e.message);
+    logger.error(e.message);
     return [];
   }
 }

package/src/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-import { cli, parseArgs } from "./cli.js";
+import { cli } from "./cli.js";
 
 (async () => {
-  const exitCode = await cli(parseArgs(process.argv));
+  const exitCode = await cli();
   process.exit(exitCode);
 })();

package/src/io.js

@@ -0,0 +1,10 @@
+import fs from "fs";
+import isUrl from "is-url";
+
+async function getFromUrlOrFile(location, cache) {
+  return isUrl(location)
+    ? await cache.fetch(location)
+    : JSON.parse(await fs.promises.readFile(location, "utf8"));
+}
+
+export { getFromUrlOrFile };

package/src/logger.js

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+
+class Logger {
+  constructor(verbosity = 0) {
+    this.stderr = [];
+    this.stdout = [];
+    this.verbosity = verbosity;
+  }
+
+  setVerbosity(verbosity) {
+    this.verbosity = verbosity;
+  }
+
+  writeOut(message) {
+    process.stdout.write(message + "\n");
+  }
+
+  writeErr(message) {
+    process.stderr.write(message + "\n");
+  }
+
+  resetStderr() {
+    this.stderr = [];
+  }
+
+  resetStdout() {
+    this.stdout = [];
+  }
+
+  log(message) {
+    this.stdout.push(message);
+    this.writeOut(message);
+  }
+
+  info(message) {
+    const formatedMessage = chalk.blue.bold("ℹ ") + message;
+    this.stderr.push(formatedMessage);
+    this.writeErr(formatedMessage);
+  }
+
+  debug(message) {
+    const formatedMessage = chalk.blue.bold("ℹ ") + message;
+    this.stderr.push(formatedMessage);
+    if (this.verbosity === 0) {
+      return;
+    }
+    this.writeErr(formatedMessage);
+  }
+
+  error(message) {
+    const formatedMessage = chalk.red.bold("✖ ") + message;
+    this.stderr.push(formatedMessage);
+    this.writeErr(formatedMessage);
+  }
+
+  success(message) {
+    const formatedMessage = chalk.green.bold("✔ ") + message;
+    this.stderr.push(formatedMessage);
+    this.writeErr(formatedMessage);
+  }
+}
+
+const logger = new Logger();
+export default logger;

package/src/output-formatters.js

@@ -0,0 +1,19 @@
+import Ajv from "ajv";
+import logger from "./logger.js";
+
+function logErrors(filename, errors) {
+  const ajv = new Ajv();
+  logger.log(
+    ajv.errorsText(errors, {
+      separator: "\n",
+      dataVar: filename + "#",
+    })
+  );
+  logger.log("");
+}
+
+function resultsToJson(results) {
+  logger.log(JSON.stringify({ results }, null, 2));
+}
+
+export { logErrors, resultsToJson };

package/src/logging.js

@@ -1,39 +0,0 @@
-import chalk from "chalk";
-
-const origWarn = console.warn;
-const origInfo = console.info;
-const origDebug = console.debug;
-
-function init(verbosity) {
-  if (verbosity === 0) {
-    console.warn = function () {};
-    console.info = function () {};
-    console.debug = function () {};
-  }
-  // TODO: implement multiple log levels if/when you need them
-}
-
-function cleanup() {
-  console.warn = origWarn;
-  console.info = origInfo;
-  console.debug = origDebug;
-}
-
-function info(message) {
-  console.log(chalk.blue.bold("ℹ ") + message);
-}
-
-function debug(message) {
-  console.debug(chalk.blue.bold("ℹ ") + message);
-}
-
-function error(message) {
-  console.error(chalk.red.bold("✖ ") + message);
-}
-
-function success(message) {
-  console.log(chalk.green.bold("✔ ") + message);
-}
-
-const logging = { cleanup, init, info, debug, error, success };
-export default logging;