Merge pull request #34 from open-rpc/feat/generate-method-id

feat(ids): upgrade the content descriptor id generators

package.json

@@ -25,7 +25,7 @@
   },
   "homepage": "https://github.com/open-rpc/schema-utils-js#readme",
   "dependencies": {
-    "@open-rpc/meta-schema": "^1.0.6",
+    "@open-rpc/meta-schema": "^1.2.0",
     "@types/ajv": "^1.0.0",
     "ajv": "^6.10.0",
     "fs-extra": "^7.0.1",

src/generate-method-id.test.ts

@@ -0,0 +1,61 @@
+import { generateMethodParamId, generateMethodResultId } from "./generate-method-id";
+import { types } from "@open-rpc/meta-schema";
+
+describe("methodParamId", () => {
+  it("returns an id for params", () => {
+    const method = {
+      name: "foo",
+      params: [{ name: "bar" }],
+      result: { name: "baz" },
+    };
+    const result = generateMethodParamId(method, method.params[0]);
+    expect(result).toBe("foo/0");
+  });
+
+  it("index by name when the method paramStructure is by-name", () => {
+    const method = {
+      name: "foo",
+      paramStructure: "by-name",
+      params: [{ name: "bar" }],
+      result: { name: "baz" },
+    } as types.MethodObject;
+
+    expect(generateMethodParamId(method, { name: "bar" })).toBe("foo/bar");
+  });
+
+  describe("throws when the content descriptor is not found in the params", () => {
+    it("by-position", () => {
+      const method = {
+        name: "foo",
+        params: [{ name: "u will never get dis" }],
+        result: { name: "baz" },
+      } as types.MethodObject;
+
+      expect(() => generateMethodParamId(method, { name: "123" }))
+        .toThrow("Content Descriptor not found in method.");
+    });
+
+    it("by-name", () => {
+      const method = {
+        name: "foo",
+        paramStructure: "by-name",
+        params: [{ name: "bar" }],
+        result: { name: "baz" },
+      } as types.MethodObject;
+
+      expect(() => generateMethodParamId(method, { name: "123" })).toThrow();
+    });
+  });
+});
+
+describe("methodResultId", () => {
+  it("returns an id for result", () => {
+    const method = {
+      name: "foo",
+      params: [{ name: "bar" }],
+      result: { name: "baz" },
+    };
+    const result = generateMethodResultId(method, method.result);
+    expect(result).toBe("foo/result");
+  });
+});

src/make-id-for-method-param.ts → src/generate-method-id.ts

@@ -1,4 +1,5 @@
 import { types } from "@open-rpc/meta-schema";
+import { some } from "lodash";
 
 const makeNotFoundError = (method: types.MethodObject, contentDescriptor: types.ContentDescriptorObject) => {
   const errorMessage = [
@@ -10,24 +11,23 @@ const makeNotFoundError = (method: types.MethodObject, contentDescriptor: types.
   return new Error(errorMessage);
 };
 
-export const makeIdForMethodParam = (
+export const generateMethodParamId = (
   method: types.MethodObject,
   contentDescriptor: types.ContentDescriptorObject,
 ) => {
-  if (method.params === undefined) { throw makeNotFoundError(method, contentDescriptor); }
-
-  let paramId;
-  if (method.paramStructure === "by-name") {
-    paramId = contentDescriptor.name;
-  } else {
-    const indexOfContentDescriptor = method.params.indexOf(contentDescriptor);
-
-    if (indexOfContentDescriptor !== -1) {
-      paramId = indexOfContentDescriptor;
-    } else {
-      throw makeNotFoundError(method, contentDescriptor);
-    }
+  if (!some(method.params, { name: contentDescriptor.name })) {
+    throw makeNotFoundError(method, contentDescriptor);
   }
 
+  const isByName = method.paramStructure === "by-name";
+  const paramId = isByName ? contentDescriptor.name : method.params.indexOf(contentDescriptor);
+
   return `${method.name}/${paramId}`;
 };
+
+export const generateMethodResultId = (
+  method: types.MethodObject,
+  contentDescriptor: types.ContentDescriptorObject,
+) => {
+  return `${method.name}/result`;
+};

src/index.ts

@@ -1,4 +1,4 @@
 export { parse } from "./parse";
-export { makeIdForMethodParam } from "./make-id-for-method-param";
+export { generateMethodParamId, generateMethodResultId } from "./generate-method-id";
 export { getValidationErrors } from "./get-validation-errors";
 export { MethodCallValidator, ParameterValidationError } from "./method-call-validator";

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

@@ -1,6 +1,6 @@
 import Ajv, { ErrorObject } from "ajv";
 import * as _ from "lodash";
-import { makeIdForMethodParam } from "../make-id-for-method-param";
+import { generateMethodParamId } from "../generate-method-id";
 import { types } from "@open-rpc/meta-schema";
 import { ParameterValidationError } from "./parameter-validation-error";
 
@@ -17,7 +17,7 @@ export class MethodCallValidator {
       params.forEach((param: types.ContentDescriptorObject, i: number) => {
         if (param.schema === undefined) { return; }
 
-        this.ajvValidator.addSchema(param.schema, makeIdForMethodParam(method, param));
+        this.ajvValidator.addSchema(param.schema, generateMethodParamId(method, param));
       });
     });
   }
@@ -33,7 +33,7 @@ export class MethodCallValidator {
       .map((param: types.ContentDescriptorObject, index: number): ParameterValidationError | undefined => {
         if (param.schema === undefined) { return; }
 
-        const idForMethod = makeIdForMethodParam(method, param);
+        const idForMethod = generateMethodParamId(method, param);
         const isValid = this.ajvValidator.validate(idForMethod, params[index]);
         const errors = this.ajvValidator.errors as ErrorObject[];