implement a way to validate class prop/methods when set/call

.github/workflows/grid_client_tests.yml

@@ -23,6 +23,7 @@ jobs:
       RMB_PROXY: true
       STORE_SECRET: secret
       MNEMONIC: ${{ secrets.MNEMONIC }}
+      SKIP_PROPS_VALIDATION: true
     steps:
       - name: set network for Schedule
         if: ${{env.NETWORK}} == ""

packages/grid_client/src/helpers/validator.ts

@@ -31,4 +31,106 @@ function validateHexSeed(seed: string, length: number): boolean {
   return true;
 }
 
-export { validateObject, validateInput, validateHexSeed };
+interface ValidationOptions {
+  props?: boolean | string | string[];
+  methods?: boolean | string | string[];
+}
+
+function Validate(options?: ValidationOptions): ClassDecorator {
+  const _options = _normalizeValidationOptions(options);
+  return (target: any): any => {
+    const methods = _getMethods(target, _options);
+    for (const method of methods) {
+      const fn = target.prototype[method];
+      target.prototype[method] = function (...args: any[]): any {
+        const errors = validateSync(this);
+        if (errors.length) {
+          throw errors;
+        }
+        return fn.apply(this, args);
+      };
+    }
+
+    return class extends target {
+      constructor(...args: any[]) {
+        super(...args);
+
+        const props = _getProps(this, _options);
+        for (const prop of props) {
+          let _value = this[prop];
+
+          Object.defineProperty(this, prop, {
+            configurable: false,
+            enumerable: true,
+            get: () => _value,
+            set(value) {
+              const errors = validateSync(this);
+              for (const error of errors) {
+                if (error.property === prop) {
+                  throw error;
+                }
+              }
+              _value = value;
+            },
+          });
+        }
+      }
+    };
+  };
+}
+
+function _normalizeValidationOptions(options?: ValidationOptions): Required<ValidationOptions> {
+  return {
+    props: options?.props ?? true,
+    methods: options?.methods ?? true,
+  };
+}
+
+function _getProps(ctor: any, options: Required<ValidationOptions>): string[] {
+  /* This env variable should be used while testing to prevent throw error while setting values */
+  if (process.env.SKIP_PROPS_VALIDATION) {
+    return [];
+  }
+
+  if (options.props === true) {
+    return Object.getOwnPropertyNames(ctor);
+  }
+
+  if (typeof options.props === "string") {
+    return [options.props];
+  }
+
+  if (Array.isArray(options.props)) {
+    return options.props;
+  }
+
+  return [];
+}
+
+function _getMethods(ctor: any, options: Required<ValidationOptions>): string[] {
+  /* This env variable should be used to prevent throw error while calling methods if needed */
+  if (process.env.SKIP_METHODS_VALIDATION) {
+    return [];
+  }
+
+  if (options.methods === true) {
+    const methods = Object.getOwnPropertyNames(ctor.prototype);
+    const constructorIndex = methods.indexOf("constructor");
+    if (constructorIndex !== -1) {
+      methods.splice(constructorIndex, 1);
+    }
+    return methods;
+  }
+
+  if (typeof options.methods === "string") {
+    return [options.methods];
+  }
+
+  if (Array.isArray(options.methods)) {
+    return options.methods;
+  }
+
+  return [];
+}
+
+export { validateObject, validateInput, validateHexSeed, type ValidationOptions, Validate };

packages/grid_client/src/zos/computecapacity.ts

@@ -1,6 +1,9 @@
 import { Expose } from "class-transformer";
 import { IsInt, Max, Min } from "class-validator";
 
+import { Validate } from "../helpers/validator";
+
+@Validate()
 class ComputeCapacity {
   @Expose() @IsInt() @Min(1) @Max(32) cpu: number;
   @Expose() @IsInt() @Min(256 * 1024 ** 2) @Max(256 * 1024 ** 3) memory: number; // in bytes

packages/grid_client/tests/modules/compute_capacity.test.ts

@@ -6,12 +6,12 @@ beforeEach(() => {
   computeCapacity = new ComputeCapacity();
 });
 describe("Compute Capacity module", () => {
-  test.skip("Compute Capacity instance is of type ComputeCapacity.", () => {
+  test("Compute Capacity instance is of type ComputeCapacity.", () => {
     expect(computeCapacity).toBeInstanceOf(ComputeCapacity);
   });
 
   // The following tests are skipped as there's an issue w input validation. Should be returned once validation is fixed here: https://github.com/threefoldtech/tfgrid-sdk-ts/issues/2821
-  test.skip("Min values for cpu & memory.", () => {
+  test("Min values for cpu & memory.", () => {
     const cpu = 0;
     const mem = 255 * 1024 ** 2;
 
@@ -23,7 +23,7 @@ describe("Compute Capacity module", () => {
     expect(result).toThrow();
   });
 
-  test.skip("Max values for cpu & memory.", () => {
+  test("Max values for cpu & memory.", () => {
     const cpu = 33;
     const mem = 255 * 1024 ** 4;
 
@@ -35,7 +35,7 @@ describe("Compute Capacity module", () => {
     expect(result).toThrow();
   });
 
-  test.skip("cpu & memory doesn't accept decimal values.", () => {
+  test("cpu & memory doesn't accept decimal values.", () => {
     const cpu = 1.5;
     const mem = 1.2;
 
@@ -47,13 +47,13 @@ describe("Compute Capacity module", () => {
     expect(result).toThrow();
   });
 
-  test.skip("cpu & memory empty values.", () => {
+  test("cpu & memory empty values.", () => {
     const result = () => computeCapacity.challenge();
 
     expect(result).toThrow();
   });
 
-  test.skip("An error should be thrown if cpu & memory negative values.", () => {
+  test("An error should be thrown if cpu & memory negative values.", () => {
     const negative_cpu = -1;
     const negative_mem = -1;