validate.js

#!/usr/bin/env node

const { parseOpenRPCDocument, validateOpenRPCDocument, dereferenceDocument } = require("@open-rpc/schema-utils-js");
const Dereferencer = require("@json-schema-tools/dereferencer");
const fs = require('fs-extra');

async function runValidation(filename) {
    try {
        let docToParse = await fileContentAsJSON(filename)
        let docToParseWithExternalRefs = await fetchExternalRefsFor(docToParse);
        let dereffedDoc = await derefAll(docToParseWithExternalRefs);

        let doc = await parseOpenRPCDocument(dereffedDoc, { dereference: true });

        const errors = validateOpenRPCDocument(doc);
        if (errors === true) {
            console.log("Ok!")
        } else {
            console.error(errors.name)
            console.error(errors.message)
        }
    }
    catch (exn) {
        console.error(exn && exn.message)
    }
}

/**
 * Given a JSON document with an OpenRPC schema, fetch all references pointing to schemas in external files,
 * and add them to the schemas in this document.
 * @param {JSON} docToParse The OpenRPC document
 * @returns The amended objects.
 */
async function fetchExternalRefsFor(docToParse) {
    let externalRefs = await externalRefsFrom(docToParse.components.schemas);
    let allExternalSchemas = await fetchExternalSchemas(externalRefs);
    Object.keys(allExternalSchemas).forEach(key => docToParse.components.schemas[key] = allExternalSchemas[key]);

    return docToParse;
}

/**
 * For a given dereferencer object, make sure its initial refs don't include refs that are already
 * in the ref cache it has. So it won't try to resolve these.
 *
 * @param {Dereferencer} dereffer The dereferncer object
 * @returns The amended dereferencer.
 */
function fixRefs(dereffer) {
    dereffer.refs = dereffer.refs.filter(r => dereffer.refCache[r] === undefined);
    return dereffer;
}

/**
 * For a given OpenRPC document, resolve all references.
 * This takes care of working around a bug with recursive definitions.
 * @param {JSON} doc The OpenRPC document
 * @returns The document, with the references resolved.
 */
async function derefAll(doc) {

    let allSchemas = doc.components.schemas;
    let refCacheWithRecursiveRef = {
        "#/components/schemas/NESTED_CALL": allSchemas["NESTED_CALL"]
    }
    let dereferencerOptions = {
        refCache: refCacheWithRecursiveRef,
        rootSchema: doc
    }
    //resolve all schemas, and remember them
    await Promise.all(Object.keys(allSchemas).map(async k => {
        let s = allSchemas[k]
        let dereffer = fixRefs(new Dereferencer.default(s, dereferencerOptions));
        allSchemas[k] = await dereffer.resolve();
        return allSchemas[k];
    }))
    return doc;
}


/**
 * Retrieve external schema definitions, from other files.
 * @param {Map<string,string} externalRefs Mapping of schema definitions, pointing to external files.
 * @returns The actual referenced schema objects
 */
async function fetchExternalSchemas(externalRefs) {
    let externalFilenames = Object.values(externalRefs).map(ref => filenameFromExternalRef(ref.value))
    let uniqueExtFilenames = [...new Set(externalFilenames)]
    let externalJSONPromises = uniqueExtFilenames
        .map(relative => { return { key: relative, fullpath: fullPathForRefFile(relative) } })
        .map(entry => fileContentAsJSON(entry.fullpath).then(c => {
            return { key: entry.key, content: c }
        }));

    let externalJSONs = await Promise.all(externalJSONPromises);

    let ret = {}

    //collect all schema objects into `ret` and return it.
    externalJSONs
        .map(entry => entry.content.components.schemas)
        //note: this means that if we have duplicates, the last file will win. not a problem for now.
        .forEach(schemaParent => Object.keys(schemaParent)
            .forEach(k => ret[k] = schemaParent[k]))

    return ret;
}

/**
 * Given a filename, read, parse and return the JSON content of the file.
 * @param {String} filename The filename to read the JSON from
 * @returns The parsed JS object.
 */
async function fileContentAsJSON(filename) {
    let json = await fs.readJson(filename)
    return json
}

/**
 * Given the set of all schemas in an RPC spec document, retrieve those that reference external
 * files.
 * @param {Map<string,string>} allSchemas Mapping of schemas from keys to schema definitions
 * @returns The external schema references, keyed by their original keys.
 */
async function externalRefsFrom(allSchemas) {

    const isExternalRef = ref => ref && ref.length > 0 && ref.charAt(0) != "#";

    let externalKeys = Object.keys(allSchemas)
        .filter(k =>
            allSchemas[k]["$ref"] !== undefined && isExternalRef(allSchemas[k]["$ref"]))
    return externalKeys.map(k => { return { key: k, value: allSchemas[k]["$ref"] }; });
}

/**
 * Extract the filename from an external reference
 * @param {String} ref The external reference
 * @returns The file name the reference refers to.
 */
const filenameFromExternalRef = ref => ref.split("#")[0];

//TODO: this assumes the script is run in a specific directory relative to the files.
/**
 * Given a relative path, retrieve the full path to the relative API.
 * Note this assumes the references in the file are relative to the current working directory.
 * @param {String} relative The relative path
 * @returns The full filesystem path
 */
const fullPathForRefFile = relative => `${process.cwd()}/${relative}` //should canonize this

let args = process.argv.slice(2);

if (args.length > 0) {
    runValidation(args[0])
}
else
    console.error("Missing filename");