Improve params validation and minor tweaks

Author: timonson

examples/server.ts

@@ -1,6 +1,7 @@
 import { ensureSymlinkedDataDirectorySync } from "./deps.ts";
-import { numberArrayValidator, respond } from "../server/mod.ts";
+import { respond } from "../server/mod.ts";
 import { add, animalsMakeNoise, makeName } from "./methods.ts";
+import { numberArrayValidator } from "../helpers/server/validation.ts";
 
 export const methods = {
   add: {

server/util_deps.ts renamed to helpers/server/deps.ts

@@ -1,5 +1,9 @@
-import { v } from "./util_deps.ts";
-import { type JsonArray, type JsonObject, type JsonValue } from "../types.ts";
+import { v } from "./deps.ts";
+import {
+  type JsonArray,
+  type JsonObject,
+  type JsonValue,
+} from "../../types.ts";
 
 export type StringOrNull = string | null;
 export type NumberOrNull = number | null;

server/util.ts renamed to helpers/server/validation.ts

@@ -1,4 +1,4 @@
-import { isArray, isFunction, isString } from "./deps.ts";
+import { isArray, isDefined, isFunction, isString } from "./deps.ts";
 import { callMethodInWorker, isMethodObjectWithWorkerUrl } from "./worker.ts";
 import { internalErrorData, validationErrorData } from "./error_data.ts";
 import { CustomError } from "./custom_error.ts";
@@ -8,7 +8,7 @@ import {
   type RpcBatchResponse,
   type RpcResponse,
 } from "../types.ts";
-import { type ValidationObject } from "./validation.ts";
+import { validateInput, type ValidationObject } from "./validation.ts";
 import { type Options } from "./response.ts";
 import { type Methods } from "./method.ts";
 
@@ -40,12 +40,11 @@ export async function executeMethods(
       ? { method: methodOrObject, validation: null }
       : methodOrObject;
     if (validation) {
-      try {
-        validation.parse(params);
-      } catch (error) {
+      const { error } = validateInput(validation)(params);
+      if (error) {
         return {
           id: validationObject.id,
-          data: error.data,
+          data: error,
           isError: true,
           ...validationErrorData,
         };
@@ -71,7 +70,11 @@ export async function executeMethods(
         code: error.code,
         message: error.message,
         id: validationObject.id,
-        data: error.data,
+        data: isDefined(error.data)
+          ? error.data
+          : options.publicErrorStack
+          ? error.stack
+          : undefined,
         isError: true,
       };
     }

server/creation.ts

@@ -7,11 +7,13 @@ export {
 } from "https://dev.zaubrik.com/[email protected]/functions/mod.ts";
 export {
   isArray,
+  isDefined,
   isFunction,
   isNotNull,
   isObject,
   isPresent,
   isString,
   isUrl,
 } from "https://dev.zaubrik.com/[email protected]/type.js";
+export { tryToParse } from "https://dev.zaubrik.com/[email protected]/encoding/json.js";
 export { type Type } from "https://deno.land/x/[email protected]/mod.ts";

server/deps.ts

@@ -16,10 +16,10 @@ export const invalidRequestErrorData = {
 /**
  * -32000 to -32099 Reserved for implementation-defined server-errors.
  */
-export const authErrorData = { code: -32020, message: "Authorization error" };
+export const authErrorData = { code: -32020, message: "Failed authorization" };
 export const validationErrorData = {
   code: -32030,
-  message: "Validation error",
+  message: "Failed params validation",
 };
 export const formDataErrorData = {
   code: -32040,

server/error_data.ts

@@ -1,3 +1,2 @@
 export * from "./response.ts";
 export * from "./method.ts";
-export * from "./util.ts";

server/mod.ts

@@ -2,7 +2,7 @@ import { assertEquals, create } from "../test_deps.ts";
 import { type JsonObject } from "../types.ts";
 import { type Options, respond } from "./response.ts";
 import { CustomError } from "./custom_error.ts";
-import { numberArrayValidator } from "../server/util.ts";
+import { numberArrayValidator } from "../helpers/server/validation.ts";
 
 function createReq(str: string) {
   return new Request("http://0.0.0.0:8000", { body: str, method: "POST" });
@@ -276,7 +276,7 @@ Deno.test("rpc call with failed validation", async function (): Promise<
   const sentToServer =
     '{"jsonrpc": "2.0", "method": "add", "params": [10, "invalid"], "id": 1}';
   const sentToClient =
-    '{"jsonrpc":"2.0","error":{"code":-32030,"message":"Validation error"},"id":1}';
+    '{"jsonrpc":"2.0","error":{"code":-32030,"message":"Failed params validation","data":{"ok":false,"code":"invalid_type","expected":["number"],"path":[1]}},"id":1}';
 
   assertEquals(
     await (await respond(methods)(createReq(sentToServer))).text(),
@@ -302,7 +302,7 @@ Deno.test("rpc call with jwt", async function (): Promise<void> {
   const sentToServer = '{"jsonrpc": "2.0", "method": "login", "id": 3}';
   const sentToClient = '{"jsonrpc": "2.0", "result": "Bob", "id": 3}';
   const authorizationError =
-    '{"jsonrpc": "2.0", "error": {"code": -32020, "message": "Authorization error"}, "id": 3}';
+    '{"jsonrpc": "2.0", "error": {"code": -32020, "message": "Failed authorization"}, "id": 3}';
   const reqOne = createReq(sentToServer);
   reqOne.headers.append("Authorization", `Bearer ${jwt}`);
   assertEquals(

server/response_test.ts

@@ -1,4 +1,11 @@
-import { isFunction, isNotNull, isObject, isString } from "./deps.ts";
+import {
+  isFunction,
+  isNotNull,
+  isObject,
+  isString,
+  tryToParse,
+  type Type,
+} from "./deps.ts";
 import {
   invalidParamsErrorData,
   invalidRequestErrorData,
@@ -55,28 +62,22 @@ function isRpcId(input: unknown): input is RpcId {
   }
 }
 
-function tryToParse(json: string) {
-  try {
-    return [JSON.parse(json), null];
-  } catch {
-    return [null, {
-      id: null,
-      isError: true,
-      ...parseErrorData,
-    }];
-  }
-}
-
 export function validateRequest(
   body: string,
   methods: Methods,
 ): ValidationObject | ValidationObject[] {
-  const [decodedBody, parsingError] = tryToParse(body);
-  if (parsingError) return parsingError;
-  if (Array.isArray(decodedBody) && decodedBody.length > 0) {
-    return decodedBody.map((rpc) => validateRpcRequestObject(rpc, methods));
+  const { value, error } = tryToParse(body);
+  if (error) {
+    return {
+      id: null,
+      isError: true,
+      ...parseErrorData,
+    };
+  }
+  if (Array.isArray(value) && value.length > 0) {
+    return value.map((rpc) => validateRpcRequestObject(rpc, methods));
   } else {
-    return validateRpcRequestObject(decodedBody, methods);
+    return validateRpcRequestObject(value, methods);
   }
 }
 
@@ -129,3 +130,51 @@ export function validateRpcRequestObject(
     };
   }
 }
+
+export interface IssueTree {
+  ok: boolean;
+  code: string;
+  expected: string[];
+  key?: string;
+  tree?: IssueTree;
+  path?: string[];
+}
+
+export function extractErrorPath(issueTree: IssueTree) {
+  const path = issueTree.path || [];
+  if (issueTree.key !== undefined) {
+    path.push(issueTree.key);
+  }
+  const tree = issueTree.tree;
+  if (isObject(tree)) {
+    return extractErrorPath({ ...tree, path });
+  }
+  return { ...issueTree, path };
+}
+
+// deno-lint-ignore no-explicit-any
+export function validateInput(valitaObject: Type<any>) {
+  return (input: unknown) => {
+    try {
+      const value = valitaObject.parse(input);
+      return {
+        value,
+        kind: "success",
+      };
+    } catch (error) {
+      const treeResult = extractErrorPath(
+        // deno-lint-ignore no-explicit-any
+        (error as any).issueTree as IssueTree,
+      );
+      return {
+        error: treeResult as {
+          ok: Required<IssueTree>["ok"];
+          code: Required<IssueTree>["code"];
+          expected: Required<IssueTree>["expected"];
+          path: Required<IssueTree>["path"];
+        },
+        kind: "failure",
+      };
+    }
+  };
+}

server/validation.ts

@@ -1,10 +1,33 @@
+// deno-lint-ignore-file no-explicit-any
+import { type Type } from "./deps.ts";
 import { assertEquals } from "../test_deps.ts";
-import { validateRequest } from "./validation.ts";
+import {
+  extractErrorPath,
+  type IssueTree,
+  validateInput,
+  validateRequest,
+} from "./validation.ts";
 
 const methods = {
   subtract: (a: number, b: number) => a - b,
 };
 
+// Mock `Type` class for testing
+class TypeMock implements Type<any> {
+  constructor(public parse: (input: any) => any) {}
+  nullable: any = () => this;
+  toTerminals: any = () => [];
+  try: any = (input: unknown) => ({ success: true, value: this.parse(input) });
+  name: any = "TypeMock";
+  func: any = () => this;
+  optional: any = () => this;
+  default: any = () => this;
+  assert: any = () => this;
+  map: any = () => this;
+  chain: any = () => this;
+}
+
+// Test cases for `validateRequest`
 Deno.test("validate request object", function (): void {
   assertEquals(
     validateRequest(
@@ -37,3 +60,86 @@ Deno.test("validate request object", function (): void {
     },
   );
 });
+
+// Test cases for `extractErrorPath`
+Deno.test("extractErrorPath - simple IssueTree", () => {
+  const issueTree: IssueTree = {
+    ok: false,
+    code: "error_code",
+    expected: ["string"],
+  };
+
+  const result = extractErrorPath(issueTree);
+  assertEquals(result.path, []);
+});
+
+Deno.test("extractErrorPath - nested IssueTree", () => {
+  const issueTree: IssueTree = {
+    ok: false,
+    code: "error_code",
+    expected: ["string"],
+    key: "root",
+    tree: {
+      ok: false,
+      code: "nested_error_code",
+      expected: ["number"],
+      key: "nested",
+    },
+  };
+
+  const result = extractErrorPath(issueTree);
+  assertEquals(result.path, ["root", "nested"]);
+});
+
+Deno.test("extractErrorPath - with path", () => {
+  const issueTree: IssueTree = {
+    ok: false,
+    code: "error_code",
+    expected: ["string"],
+    key: "root",
+    path: ["existing_path"],
+    tree: {
+      ok: false,
+      code: "nested_error_code",
+      expected: ["number"],
+      key: "nested",
+    },
+  };
+
+  const result = extractErrorPath(issueTree);
+  assertEquals(result.path, ["existing_path", "root", "nested"]);
+});
+
+// Test cases for `validateInput`
+Deno.test("validateInput - valid input", () => {
+  const validation = new TypeMock((input) => input);
+  const input = "valid_input";
+  const validate = validateInput(validation);
+
+  const result = validate(input);
+  assertEquals(result.kind, "success");
+  assertEquals(result.value, input);
+});
+
+Deno.test("validateInput - invalid input", () => {
+  const validation = new TypeMock(() => {
+    throw {
+      issueTree: {
+        ok: false,
+        code: "error_code",
+        expected: ["string"],
+        key: "input",
+      },
+    };
+  });
+  const input = "invalid_input";
+  const validate = validateInput(validation);
+
+  const result = validate(input);
+  assertEquals(result.kind, "failure");
+  if (result.error) {
+    assertEquals(result.error.path, ["input"]);
+  } else {
+    throw new Error("Expected error to be defined");
+  }
+});