fix: constrain typing more

src/get-open-rpc-document.ts

@@ -7,15 +7,15 @@ type TGetOpenRPCDocument = (schema: string) => Promise<types.OpenRPC>;
 const fetchUrlSchemaFile: TGetOpenRPCDocument = async (schema) => {
   try {
     const response = await fetch(schema);
-    return await response.json();
+    return await response.json() as types.OpenRPC;
   } catch (e) {
     throw new Error(`Unable to download openrpc.json file located at the url: ${schema}`);
   }
 };
 
-const readSchemaFromFile = async (schema: string) => {
+const readSchemaFromFile: TGetOpenRPCDocument = async (schema) => {
   try {
-    return await readJson(schema);
+    return await readJson(schema) as types.OpenRPC;
   } catch (e) {
     if (e.message.includes("SyntaxError")) {
       throw new Error(`Failed to parse json in file ${schema}`);

src/method-call-validator/method-call-validator.ts

@@ -1,16 +1,16 @@
-import Ajv, { ErrorObject } from "ajv";
+import Ajv, { ErrorObject, Ajv as IAjv } from "ajv";
 import * as _ from "lodash";
 import { generateMethodParamId } from "../generate-method-id";
 import { types } from "@open-rpc/meta-schema";
-import ParameterValidationError from "./parameter-validation-error";
+import MethodCallParameterValidationError from "./parameter-validation-error";
 
 /**
  * A class to assist in validating method calls to an OpenRPC-based service. Generated Clients,
  * Servers, and many others may want to expose the interface provided by an OpenRPC document.
  * In doing so, use this class to easily create a re-useable validator for a particular method.
  */
 export default class MethodCallValidator {
-  private ajvValidator: Ajv.Ajv;
+  private ajvValidator: IAjv;
 
   /**
    * @param document The OpenRPC document containing the methods whose calls we want validated.
@@ -57,23 +57,23 @@ export default class MethodCallValidator {
    * ```
    *
    */
-  public validate(methodName: string, params: any[]): ParameterValidationError[] {
+  public validate(methodName: string, params: any[]): MethodCallParameterValidationError[] {
     const method = _.find(this.document.methods, { name: methodName }) as types.MethodObject;
 
     if (method.params === undefined) {
       return [];
     }
 
     return _.chain(method.params as types.ContentDescriptorObject[])
-      .map((param: types.ContentDescriptorObject, index: number): ParameterValidationError | undefined => {
+      .map((param: types.ContentDescriptorObject, index: number): MethodCallParameterValidationError | undefined => {
         if (param.schema === undefined) { return; }
 
         const idForMethod = generateMethodParamId(method, param);
         const isValid = this.ajvValidator.validate(idForMethod, params[index]);
         const errors = this.ajvValidator.errors as ErrorObject[];
 
         if (!isValid) {
-          return new ParameterValidationError(index, param.schema, params[index], errors);
+          return new MethodCallParameterValidationError(index, param.schema, params[index], errors);
         }
       })
       .compact()

src/validate-open-rpc-document.ts

@@ -1,6 +1,6 @@
 import metaSchema, { types } from "@open-rpc/meta-schema";
 import JsonSchemaDraft07 from "../lib/json-schema-draft-07.json";
-import Ajv from "ajv";
+import Ajv, { ErrorObject } from "ajv";
 
 /**
  * @ignore
@@ -16,7 +16,7 @@ export class OpenRPCDocumentValidationError extends Error {
   /**
    * @param errors The errors received by ajv.errors.
    */
-  constructor(private errors: Ajv.ErrorObject[]) {
+  constructor(private errors: ErrorObject[]) {
     super([
       "Error validating OpenRPC Document against @open-rpc/meta-schema.",
       "The errors found are as follows:",